Air Desktop — Index des documents de conception

Document de référence — Version 1.4 (2026-07-10, passe post-M5 : ADRs jusqu’à 087, sceaux couche-0-v1.12 / couche-1-v1.9, jalon std-sur-Air atteint)

Ce document recense l’ensemble des documents de conception du projet Air Desktop, élaborés pendant les sessions préparatoires. Il sert de :

• Index navigationnel pour retrouver rapidement un document.
• Checklist de complétude pour vérifier que tout est en place.
• Carte des travaux à reprendre pour les sessions futures.

Identité du projet

• Nom du projet : Air
• Identité publique : Air Desktop
• Domaine : air-desktop.org
• Organisation GitHub : air-desktop-project
• Repo principal : github.com/air-desktop-project/air
• Préfixe technique des crates : air-
• Licence : Mozilla Public License 2.0

Convention de nommage des fichiers

• ADRs (Architecture Decision Records) : ADR-NNN-titre-court-LL.md (préfixe ADR-, numéro à 3 chiffres, titre en kebab-case, suffixe de langue -fr ou -en).
• Documents fondateurs (vision, charte, principes d’ingénierie) : nom thématique + suffixe de langue (vision-fr.md, charter-en.md, etc.).
• Specs et documents internes : nom thématique en kebab-case, langue implicite par contenu et contexte.

Structure de la documentation

air/
├── README.md                                # Vue d'ensemble publique du projet
├── README-fr.md                             # Vue d'ensemble publique du projet (FR)
├── LICENSE                                  # MPL 2.0 (à copier)
├── CHANGELOG.md                             # À démarrer
├── CONTRIBUTING.md                          # À rédiger (TODO)
├── CODE_OF_CONDUCT.md                       # Contributor Covenant 2.1 (TODO)
├── SECURITY.md                              # À rédiger (TODO)
├── Cargo.toml                               # Workspace Rust privé (couche 0)
├── Cargo.lock                               # Lockfile committé
├── rust-toolchain.toml                      # Toolchain pinée
├── crates/
│   ├── air-sys-types/                       # Types fondamentaux de la couche 0
│   └── air-sys-syscall/                     # Wrappers Rust des syscalls Linux
└── docs/
    ├── INDEX.md                             # Ce document
    ├── EXCEPTIONS.md                        # Exceptions explicites au principe dépendances (ADR-024)
    ├── COVERAGE-EXCEPTIONS.md               # Branches/lignes couche 0 non couvertes (raison légitime)
    ├── UNSUPPORTED.md                       # Syscalls/opcodes legacy non wrappés + remplaçants (io_uring 3b)
    │
    ├── vision/
    │   ├── vision-fr.md                     # Vision du projet (FR)
    │   └── vision-en.md                     # Project Vision (EN)
    │
    ├── charte/
    │   ├── charte-fr.md                     # Charte (5 principes, FR)
    │   └── charter-en.md                    # Charter (EN)
    │
    ├── principes-ingenierie/
    │   ├── principes-ingenierie-fr.md       # 9 principes (FR)
    │   └── engineering-principles-en.md     # Engineering Principles (EN)
    │
    ├── adrs/
    │   ├── registre-adrs-fr.md              # Registre / index des ADRs (v3.36)
    │   ├── ADR-001-aircom-fr.md            # 17 ADRs fondateurs + ADR-018 imagerie
    │   ├── ADR-002-modele-objet-fr.md
    │   ├── ADR-003-compositeur-wayland-fr.md
    │   ├── ADR-004-linux-tier-1-fr.md
    │   ├── ADR-005-systemd-fr.md
    │   ├── ADR-006-profils-fr.md
    │   ├── ADR-007-air-console-fr.md
    │   ├── ADR-008-air-tui-fr.md
    │   ├── ADR-009-framework-vues-fr.md
    │   ├── ADR-010-airapp-fr.md
    │   ├── ADR-011-phasage-fr.md
    │   ├── ADR-012-versionnement-fr.md
    │   ├── ADR-012-bis-telemetrie-fr.md
    │   ├── ADR-013-distribution-fr.md
    │   ├── ADR-014-catalogue-materiel-fr.md
    │   ├── ADR-015-licence-gouvernance-fr.md
    │   ├── ADR-016-i18n-fr.md
    │   ├── ADR-017-accessibilite-fr.md
    │   ├── ADR-018-modele-imagerie-fr.md
    │   ├── ADR-019-modele-erreurs-fr.md     # ADRs phase 0 (renumérotés +1)
    │   ├── ADR-020-strategie-signaux-fr.md
    │   ├── ADR-021-conventions-couche-0-fr.md
    │   ├── ADR-022-architecture-io-uring-fr.md
    │   ├── ADR-023-runtime-air-fr.md
    │   ├── ADR-024-workflow-dependances-fr.md
    │   ├── ADR-025-builds-reproductibles-fr.md  # OK (clôt la série de design phase 0)
    │   ├── ADR-026-contrat-air-tui-fr.md        # OK (contrat 1.0 `air-tui`)
    │   └── ADR-027-doc-polyglotte-fr.md         # OK (doc polyglotte ABI C — diff. couche 2)
    │
    ├── architecture/
    │   └── macro-architecture-fr.md         # Macro-architecture des 6 couches
    │
    ├── notes/                               # Pistes / cadrages exploratoires (NON engageants)
    │   ├── libc-compat-exploration-fr.md
    │   ├── android-vendor-interface-exploration-fr.md
    │   ├── api-reseau-strategie-fr.md       # cadrage `air-network` (couche 2)
    │   ├── audit-dlmalloc-fr.md             # distillation dlmalloc → allocateur global Air (couche 1)
    │   └── audit-s2n-tls-fr.md              # relevé chiffré s2n-tls → contingence air-tls maison (couche 2)
    │
    ├── specs/
    │   ├── layer-0/
    │   │   ├── introduction-fr.md           # Intro développeur couche 0 (encart dev C/C++)
    │   │   ├── air-sys-types.md             # Partiel, avec TODO
    │   │   ├── family-process.md
    │   │   ├── family-fs.md
    │   │   ├── family-mem.md
    │   │   ├── family-signal.md
    │   │   ├── family-time.md
    │   │   ├── family-net.md
    │   │   ├── family-ipc.md
    │   │   ├── family-security.md
    │   │   ├── family-system.md
    │   │   ├── family-device.md             # uevent/evdev (sysfs → fs)
    │   │   ├── family-ebpf.md               # bpf() exhaustif + perf_event_open
    │   │   ├── family-fs-inotify.md         # extension inotify (prérequis AirFileSystemWatcher)
    │   │   ├── family-mem-mmap-region.md    # MmapRegion partageable refcounté (implémenté #31)
    │   │   ├── family-process-privsep.md    # setgroups/setres*id (prérequis drop_privileges)
    │   │   ├── io-uring-overview.md         # Synthèse, avec TODO
    │   │   ├── io-uring-1-core.md           # TODO
    │   │   ├── io-uring-2a-filesystem.md    # TODO
    │   │   ├── io-uring-2b-network.md       # TODO
    │   │   ├── io-uring-2c-async.md         # TODO
    │   │   ├── io-uring-3a-registration.md  # TODO
    │   │   ├── io-uring-3b-linked.md        # TODO
    │   │   ├── io-uring-3c-multishot.md     # TODO
    │   │   ├── io-uring-3d-shared.md        # TODO
    │   │   └── io-uring-4-raw.md            # TODO
    │   ├── layer-1/
    │   │   ├── air-base-lib-core.md         # erreurs, chaînes/chemins, temps
    │   │   ├── air-base-lib-services.md     # logging, identifiants, config
    │   │   ├── air-filesystem.md            # AirFileSystem + watcher
    │   │   ├── air-memory.md                # allocateurs arena/pool/slab + comptabilité
    │   │   ├── air-process.md               # processus, pidfd, drop_privileges
    │   │   ├── air-thread.md                # threads, mutex/rwlock/sémaphore, MPSC
    │   │   ├── air-socket.md                # sockets + résolution de noms enfichable
    │   │   ├── air-crypto.md                # primitives cryptographiques (RustCrypto)
    │   │   ├── air-device.md                # énumération/surveillance natives (sysfs+uevent)
    │   │   ├── air-config.md                # compilateur config + artefact Cap'n Proto (crate dédiée)
    │   │   ├── air-config-source-format.md  # grammaire du format de source air-config (design)
    │   │   └── air-config-schemas-v1.md     # schémas .capnp v1 + BNF gelée du format de source
    │   ├── layer-2/
    │   │   ├── air-object.md                # modèle d'objet C-ABI (clé de voûte couche 2)
    │   │   ├── air-com.md                    # IPC natif AirCom (sans-IO, capability=fd, pub-sub anneau shm)
    │   │   └── air-event.md                 # façade C-ABI de l'event loop async (sur air-runtime)
    │   └── layer-4/
    │       ├── air-tui-core.md              # Noyau 1.0 `Capabilities`/focus/commandes
    │       └── air-tui-runtime-api.md       # Surface d'API conceptuelle runtime
    │
    ├── setup/
    │   ├── phase-A-decisions.md
    │   ├── phase-B1-structure.md
    │   ├── phase-B2-operations.md
    │   ├── phase-C-infrastructure.md
    │   └── phase-D-community.md
    │
    ├── guides/                              # TODO
    │   ├── first-contribution.md
    │   └── getting-started/
    │
    └── maintainers/                         # TODO
        ├── release-process.md
        ├── moderation.md
        ├── onboarding-maintainers.md
        └── cve-handling.md

Inventaire des documents produits

Documents fondateurs

ADRs fondateurs (17) et ADR-018 (modèle d’imagerie)

Voir le registre des ADRs pour la liste consolidée. Tous les fichiers sont sous docs/adrs/.

ADRs phase 0

ADRs post-phase 0

Spécifications techniques de la couche 0

🔒 COUCHE 0 — SCELLÉE le 2026-06-14 (tag couche-0-v1), re-scellée couche-0-v1.1 (errno additif, PR #77), couche-0-v1.2 (extension exec/redirection execve/execveat/dup3/fchdir/chdir/exit_group, PR #100), couche-0-v1.3 (execve_prepared — exec sans alloc pour air-process, PR #104), puis couche-0-v1.4 le 2026-06-25 (faccessat honore réellement ses flags via faccessat2 SYS 439 — , couche-0-v1.5 (famille poll/ppoll — attente synchrone bornée interruptible, ADR-044, PR #129), puis couche-0-v1.6 le 2026-06-28 : la couche 0 devient std-free (#![cfg_attr(not(test), no_std)], prouvé par le compilateur, Principe 4) via types FD natifs d’Air (OwnedFd/BorrowedFd/RawFd + close(2) interne, PR #148), famille futex(2) (PR #147), std-free (ffi→alloc/core, OsString→octets, FutexMutex, PR #149) et clone3 spawn de thread (clone_thread + trampoline asm 2-arches, join CHILD_CLEARTID, PR #150) — ADR-048 + Amendement 1 ; jalons antérieurs conservés) ; puis couche-0-v1.7 (famille arch — arch_prctl set_fs/get_fs TLS x86_64, ADR-051/052) ; puis couche-0-v1.8 le 2026-07-02 (famille terminal — termios/tty complète : attributs tcgetattr/tcsetattr, contrôle-ligne tcdrain/tcflush/tcflow/tcsendbreak, winsize (TIOCGWINSZ/S), PTY (/dev/ptmx+TIOCGPTN/TIOCSPTLCK/TIOCGPTPEER), session/job-control (tc[gs]etpgrp/TIOCSCTTY/TIOCNOTTY/TIOCGSID) ; fonctions dédiées typées ADR-021 conv. 3, Option<Pid>, EINTR remonté, RAII FD ; tests sur PTY réel /dev/ptmx + cycle session en enfant setsid ; ADR-060, PRs #200–#204 ; 1 exception CHILD-EXIT) ; puis couche-0-v1.9 (signaux async, ADR-066), couche-0-v1.10 (sockaddr/sockopt libc, ADR-070/071), couche-0-v1.11 le 2026-07-09 (additifs cumulés libc/std — chroot/killpg/sigaltstack+AltStack/sendfile/fchmod/fchown/futimens/munmap_raw, ADR-085), puis couche-0-v1.12 le 2026-07-10 (raw_syscall** — escape hatch syscall générique, EXCEPTION assumée temporaire à retirer avec l’équipe Rust, ADR-087, jalon M5).** CODE complet (11 familles + io_uring 12 Temps + extensions MmapRegion/privsep/fs::inotify/ affinité CPU/exec/faccessat2), barrière complète verte sur 2 arches (x86_64 speedy, aarch64 raspi-srv-2), 100 % de couverture hors exceptions documentées (couvrable VIDE au sens strict, ADR-035 ; lignes 97,74 % / branches 82,73 % brutes), // SAFETY: sur chaque bloc unsafe, doc développeur FR + EN. Le socle syscall n’évolue plus que par RFC (ADR-015) ; les constantes Errno peuvent être complétées additivement par les besoins des contrats couche 1 landés (re-sceau vX.Y, jalons antérieurs conservés). Couche 1 — 8/8 CRATES CŒUR IMPLÉMENTÉ : air-base-lib cœur (PR #73) + air-crypto (PR #80) + air-socket (PR #86) + air-filesystem (PR #87) + air-memory (PR #88) + air-device (PR #94) + air-thread (PR #97) + air-process (PR #105). Reste pour clore la couche 1 : air-base-lib services (logging/identifiants ; air-config → crate dédiée, Cap’n Proto, ADR-040/041) et l’ABI C (libair-base.so, différée).

🔒 COUCHE 1 — SCELLÉE couche-1-v1.0 (2026-07-03, ADR-062) ; re-scellée v1.1 (ADR-065), v1.2 (ADR-066), couche-1-v1.3 (2026-07-05, ADR-067 — crate air-account) ; v1.4/v1.5 (credentials + drop_to_user, ADR-068), couche-1-v1.6 (air-handle + moteur socket, ADR-069), couche-1-v1.7 le 2026-07-09 (Managers de domaine ADR-077 + AirSignalManager, chantier B), couche-1-v1.8 le 2026-07-09 (air-process::spawn_process, socle posix_spawn, chantier B), couche-1-v1.9 le 2026-07-10 (introspection thread cible — air-runtime::process_context [auxv+bornes de pile] + AirProcessManager::resource_limit, socle de getauxval/pthread_getattr_np de la libc, ADR-086, jalon M5 ; earmark ADR-078 crypto → couche-1-v1.10). API Rust publique figée sur 17 crates (air-base-core/air-base-lib, air-crypto, air-socket, air-filesystem, air-memory, air-alloc, air-device, air-env, air-stdio, air-terminal, air-poll, air-signal, air-thread, air-process, air-runtime async inclus, air-config*, air-libm). Précédée des audits pré-sceau (#212/#213), des 4 P0 (AirFile #214, air-poll #215, termios/PTY #216, air-signal #217) et du remodel os_str env/args (#218). HORS sceau : C-ABI (air-base-capi + libc, régime air-stable) · PAL std::sys · toolchain C/C++. Évolution ensuite par descellement additif v1.x (RFC, modèle ADR-051). Toit libc — jalon M0 (fondations) posé : split code / artefact (ADR-029) — crates/air-libc-capi (rlib pur, le code : buildable pour *-linux-air) + crates/air-libc-c (cdylib host-only, l’artefact libair_c.so). M1-b — split « logique / shims C-ABI » (couverture) : la LOGIQUE mesurable vit dans des crates sœurs SANS symbole libc #[no_mangle] — crates/air-libc-fmt (moteur de format printf, couvert à 100 %, surface format-string N°1) et crates/air-libc-alloc (logique malloc/free/…, couvert à 100 %) ; les primitives mem*/str* (#![no_builtins]) dans crates/air-libc-strmem. Seul air-libc-capi porte les shims #[no_mangle] extern "C" (qui délèguent), exclu du gate de couverture (comme air-libc-strmem) car ces symboles surchargent le runtime de couverture LLVM. Régime air-stable — errno C-ABI (__errno_location + E*) + crt (__libc_start_main/air_main) câblé sur air_runtime::start::bootstrap ; registre libc-conformance.md ; harnais on-target rt/crates/airlibc-return42 (return 42). 1er additif v1.x révélé : AirRuntime::errno_location() -> *mut i32 (RFC de descellement à ratifier). Caveats de sceau résorbés post-sceau (PR #66, merge 380d389) : gates qualité gravés en cargo xtask (barrier/couvrable-vide/check-syscalls/ audit-exceptions/repro, cf. outillage-xtask.md). La reproductibilité ADR-025 est outillée (repro, 4 rlibs bit-pour-bit) ; le re-sync des fichier:ligne du registre est outillé (audit-exceptions), qui a corrigé une dérive du décompte → registre à 69 entrées production (STRUCTURAL 38, FEATURE-KERNEL 13, PRIVILEGE 10, CHILD-EXIT 8, DEFERRED-TOOLING 0). check-syscalls certifie 161 numéros conformes (2 arches, 0 écart).

Spécifications techniques de la couche 1

Spécifications techniques de la couche 2

Spécifications techniques de la couche 4

Spécifications techniques de la couche 5 (services système réseau)

Documents de setup phase 0

Point d’attention — Statut de la macro-architecture

La macro-architecture a fait l’objet d’une passe 1 de nettoyage (2026-05-20) qui a :

• Aligné la section 2 (couche 0) sur les ADRs phase 0 (ADR-019 modèle d’erreurs, ADR-020 stratégie signaux, ADR-021 conventions transverses, ADR-022 architecture io_uring) et sur le découpage acté en deux crates air-sys-types + air-sys-syscall.
• Neutralisé toutes les références prospectives ADR-018 à ADR-026 en marqueurs neutres (« ADR à produire — service [X] »). Les ADRs services système couche 5 recevront leur numéro définitif au moment de leur instruction (numéros ≥ ADR-028 ; ADR-027 est pris par la stratégie de documentation polyglotte).

Une passe 2 de complétion reste à mener plus tard, en parallèle de l’implémentation : enrichir les sections couches 1 à 5 avec les détails issus des ADRs et specs récents (notamment les conventions transverses dans le code couche 1, l’articulation détaillée AirCom/io_uring/runtime async, etc.).

Travaux à reprendre

Travaux prioritaires (à reprendre en premier)

1. CONTRIBUTING.md détaillé
   • Localisation : CONTRIBUTING.md à la racine du repo.
   • Périmètre : guide complet de contribution avec workflow Git, conventions, DCO, processus RFC.

Spec détaillée du module io_uring (9 documents)

À produire au niveau de détail des autres specs de familles :

5. docs/specs/layer-0/io-uring-1-core.md (Temps 1 : cœur API)
6. docs/specs/layer-0/io-uring-2a-filesystem.md (Temps 2a : 21 opérations FS)
7. docs/specs/layer-0/io-uring-2b-network.md (Temps 2b : 8 opérations réseau)
8. docs/specs/layer-0/io-uring-2c-async.md (Temps 2c : 9 opérations async)
9. docs/specs/layer-0/io-uring-3a-registration.md (Temps 3a : registration)
10. docs/specs/layer-0/io-uring-3b-linked.md (Temps 3b : linked)
11. docs/specs/layer-0/io-uring-3c-multishot.md (Temps 3c : multishot)
12. docs/specs/layer-0/io-uring-3d-shared.md (Temps 3d : shared)
13. docs/specs/layer-0/io-uring-4-raw.md (Temps 4 : raw)

Référence : ADR-022 + io-uring-overview.md.

Documents de conventions formels (mise en forme depuis Phases B et C)

14. STYLE_GUIDE.md à la racine (depuis Phase B1).
15. TESTING_GUIDE.md à la racine (depuis Phase B2 section 1).
16. ERROR_HANDLING.md à la racine (depuis Phase B2 section 2 + ADR-019).
17. COMMIT_CONVENTIONS.md à la racine (depuis Phase B2 section 3).
18. PR_REVIEW_GUIDE.md à la racine (depuis Phase B2 section 3).
19. RELEASE_PROCESS.md à la racine (depuis Phase C section 3).
20. INFRASTRUCTURE.md à la racine (depuis Phase C section 2).

Spec exhaustive de air-sys-types

21. Compléter docs/specs/layer-0/air-sys-types.md avec spec type par type (méthodes, invariants, tests). Probablement à produire en parallèle de l’implémentation effective de la crate.

Documents de la communauté

22. docs/guides/first-contribution.md : guide pas-à-pas du premier patch.
23. docs/guides/getting-started/ : guides de démarrage pour différents profils.
24. SECURITY.md à la racine : politique de divulgation des vulnérabilités.
25. CODE_OF_CONDUCT.md à la racine : Contributor Covenant 2.1 (texte officiel).
26. CHANGELOG.md à la racine : démarrage avec section [Unreleased].

Documents internes mainteneurs

27. docs/maintainers/release-process.md : procédure de release détaillée.
28. docs/maintainers/moderation.md : procédure de modération.
29. docs/maintainers/onboarding-maintainers.md : onboarding nouveau mainteneur.
30. docs/maintainers/cve-handling.md : gestion des CVEs.

Statistiques globales

Statistiques techniques (estimées)

Pour les conversations futures

Quand tu démarres une nouvelle session sur Air, pointe Claude vers ce document docs/INDEX.md comme premier point de référence. Claude pourra ainsi rapidement :

1. Comprendre ce qui existe déjà.
2. Comprendre ce qui reste à produire.
3. S’orienter dans la hiérarchie de documentation.

Suggestion de prompt initial :

« Bonjour, on continue le travail sur Air. Lis docs/INDEX.md pour comprendre l’état actuel du projet, puis on va travailler sur [sujet à préciser]. »

Ordre de priorité suggéré pour les travaux futurs

Court terme :

1. README final + CONTRIBUTING — pour que le repo soit présentable.

Moyen terme (avant ouverture publique) :

4. SECURITY.md, CODE_OF_CONDUCT.md, CHANGELOG.md.
5. Documents de conventions formels (mise en forme).
6. Configuration GitHub Actions de base.

Plus tard (en parallèle de l’implémentation) :

7. Spec détaillée io_uring (9 documents).
8. Spec exhaustive air-sys-types.
9. Documents internes mainteneurs.

Licence du document : MPL 2.0 Statut : Document de référence et checklist. Version 1.4 — passe post-M5 (2026-07-10) : inventaire ADRs porté à 087, sceaux couche-0-v1.12 / couche-1-v1.9, jalon std-sur-Air atteint.

Suivi — état d’avancement & tâches à venir

Document unique de suivi vivant. C’est le point d’entrée « où en est-on / quelle est la prochaine tâche / par où on est passé / qu’a-t-on fait ». Il est tenu à jour au fil des merges (chaque jalon met à jour l’état + coche/ajoute une tâche). Référencé par CLAUDE.md et AGENTS.md.

Rôle des autres documents (pour ne pas les confondre) :

• INDEX.md — carte structurelle : ce qui existe, où le trouver.
• JOURNAL.md — archive chronologique append-only (le détail session par session, PR par PR). On y écrit l’historique ; on ne le « maintient » pas comme tableau de bord.
• roadmap-couche1-libc-pal-fr.md — plan détaillé §-numéroté de la clôture couche 1 (les specs/audits y renvoient via « §5.3 P0.x »). Le statut vivant de ce plan est tenu ici.

Dernière mise à jour : 2026-07-13 (🎉 std COMPLET sur le PAL safe + MERGÉ + RE-SCELLÉ — target_os="air", sans libc C, unsafe confiné couche 0. Portage std mergé (#326) + différés soft mergés (#327 : os::fd/pipe, options socket [+ descellement couche-0-v1.13], DNS). Tous sous-systèmes prouvés on-target 2 arches (x86_64/carbon + aarch64/raspi vrai matériel) : alloc/errno/futex+sync/stdio/env/exit/thread/mpsc/fd+fs(+current_exe)/process/net(TCP+UDP + timeouts/multicast)/random/os::fd/pipe/DNS. 1 seul fork externe (bitflags), RustCrypto/icu4x/air-base-lib hors fermeture (ADR-090). RE-SCEAUX POSÉS (signés) : couche-0-v1.13 (options socket à structure) + couche-1-v2.0 (jalon majeur : la couche 1 rend possible std sur Air). COUCHE 2 EN COURS : ✅ ADR-091 (motif réseau sans-IO normatif) ; ✅ métadonnée de couche + gate check-layers (#328) ; ✅ air-async inc 0→3 — runtime async couche 2 complet et sound : découpage air-uring(L1)/air-async(L2) [ADR-092], sûreté d’annulation io_uring (valgrind definitely-lost=0), exécuteur spawn/block_on, éveil inter-thread (handshake SeqCst, loom vert), roue de timers, back-pressure, thread-per-core (ReactorPool/msg_ring), multishot + provided buffers (soundness étendue), I/O fichier/réseau, embarquement hôte — mergés #329-332, zéro unsafe couche 1, zéro descellement couche 0. ✅ IPC AirCom — FONDATION posée (#333) : air-com/air-com-proto (sans-IO sur air-async, ADR-091), capability = fd (SCM_RIGHTS, ADR-010), wire Cap’n Proto (ADR-040) ; 4 lacunes couche 1 comblées — air-shm (memfd+seals, zero-copy), SCM_RIGHTS async (air-uring/air-async), SEQPACKET + pont OwnedFd (air-socket additif → re-sceau couche-1-v2.1) ; preuve : fd-capability portant un shm scellé traverse le socket, pair mmap zero-copy. ✅ Spec AirCom posée (#334) (couche 2, wire format + transport + pub-sub anneau + bootstrap air-registry). ✅ AirCom inc.1 — Codec Cap’n Proto réel : nouveau crate air-com-schema (schéma v1 figé Envelope/CapRef/ShmRef/MessageKind, code généré committé, no_std+alloc), Codec réel remplaçant le placeholder Ping/Pong (Envelope schema-first, décodage borné anti-hostile, zéro unsafe/panic), pilote+exemple Call→Return (exit 0), fuzz fuzz_air_com_codec (871k runs, 0 crash) ; verdict no_std : capnp no_std+alloc OK (prouvé en graphe isolé alloc-only) — chemin nominal, aucune nouvelle exception. Cœur 98 % lignes / pilote 98 %. ✅ AirCom inc.2 — StateMachine multi-états + Multiplexer + Handshaker : StateMachine à deux niveaux (cycle de connexion Opening→Established→Draining→Closed/Faulted + une machine par canal Idle→AwaitingReturn→{Returned|Errored|Cancelled}, transitions illégales rejetées sans panic), Multiplexer (ChannelTable : channelId par canal, parité de rôle client-pairs/serveur-impairs, borné maxChannels, isolation inter-canaux prouvée), Handshaker (négo de version Hello capnp ajouté au schéma v1, intersection déterministe min-version/bornes + extensions communes triées, échec → Faulted sans I/O) ; pilote + exemple ping_pong : handshake + 2 requêtes concurrentes multiplexées sur 1 connexion (exit 0) ; model-based tests de la StateMachine (proptest : modèle de référence, puits terminaux, pas de deadlock) + fuzz fuzz_air_com_handshake (Hello hostile, 506k runs, 0 crash). Cœur 98,9 % lignes (state/channel 100 %) / pilote 99 %. ✅ AirCom inc.3 — transport SEQPACKET bout-en-bout + 2 surfaces + exemple 2-exe : le bootstrap std::os::unix::net d’inc.0 a disparu — le control plane passe sur AirUnixSeqpacket réel (socketpair et adresse abstraite nommée, bridge into_owned_fd→air-async) ; deux surfaces de première classe partageant le même cœur (async sur air-async/io_uring : Connection::connect_async/Listener::{bind_async,accept}/call/serve ; sync sur air-socket bloquant : connect_sync/{bind_sync,accept_blocking}/call_blocking/serve_blocking) ; test croisé client sync ↔ serveur async et l’inverse (preuve du partage du cœur, spec §11) ; livrable développeurs = 2 vrais binaires aircom_server/aircom_client (méthode « greet », 2 requêtes multiplexées sur channelId 0/2, adresse abstraite, README tutoriel) — exécutés en 2 process, exit 0 des deux côtés. Cœur PUR inchangé (aucune fn unsafe exposée), pilote >90 %. ✅ AirCom inc.3b — accept SEQPACKET pleinement io_uring : le STOP-and-report d’inc.3 est clos — l’accept(2) bloquant du listener nommé a disparu. Additif couche 1 (air-socket, autorisé BDFL — pur, zéro changement sémantique des API existantes, miroir de AirUnixSeqpacket) : AirUnixSeqpacketListener::into_owned_fd(self) -> OwnedFd (transfère l’ownership hors du registre air-handle, testé bind→into_owned_fd→ré-adoption→accept réel sans double-close, 100 % lignes+branches sur le neuf). Pilote async air-com : Listener::bind_async bride désormais le fd d’écoute vers air-async (TcpListener::from_owned) et Listener::accept fait un IORING_OP_ACCEPT (plus d’accept(2) bloquant) ; surface sync inchangée (accept_blocking natif). Exemple 2-process relancé (exit 0 des deux côtés) + test pilote named_async_roundtrip (accept io_uring round-trip). Pilote air-com (surface.rs) 100 % lignes. Additif L1 en attente du re-sceau couche-1-v2.2, DIFFÉRÉ au jalon de finalisation d’AirCom (posé par le superviseur — aucun tag posé ici). ✅ AirCom inc.4 — data plane zero-copy intégré + Flow Controller : composant 5/9 Flow Controller réalisé (cœur PUR air-com-proto/flow.rs, remplace le marqueur unité) — crédits par canal, fenêtre bornée (modèle reactive-streams), grant_credit/consume_credit/available_credit intégrés à la table de canaux du Session Context ; jamais de file non bornée, crédit jamais négatif (checked ops), property-tests proptest (invariant somme, borne respectée, épuisement→blocage, recharge→déblocage). Message MessageKind::credit orthogonal à la StateMachine de requête (routé hors du cycle de vie de canal — ni on_send ni on_receive). Data plane intégré au flux de messages (pilote air-com/dataplane.rs) : Connection::call_with_payload/serve_with_payload — une invocation porte une charge volumineuse via ShmRef (schéma capnp v1 étendu par ajout compatible Envelope.shmRefs @5, discipline ADR-012, ShmRef déjà présent activé) ; le memfd scellé voyage par SCM_RIGHTS avec le message de contrôle, le pair mmap zero-copy (la charge ne traverse jamais le socket — seul le fd). Conventions §5 appliquées : sealing obligatoire (segment non scellé refusé côté production ET réception → Faulted ; défense en profondeur : sceaux réels du memfd vérifiés, un sealed=true menti est rejeté), partage read-only (F_SEAL_WRITE + mmap PROT_READ), length logique ≤ taille validé en amont (Principe 4). Le cœur ne voit que la référence (invariant §1.1 — aucun fd ; le pilote apparie slot↔fd). Flow control appliqué au data plane (fenêtre initiale semée à l’ouverture, crédit consommé avant émission, rendu par le consommateur après lecture). Exemple 2-process aircom_dataplane_{server,client} : le client publie 1 Mio scellé, le serveur mmap zero-copy et confirme (len+checksum) — exécutés sur carbon, exit 0 des deux côtés, checksums coïncidents. fuzz fuzz_air_com_codec étendu (champs shmRefs). Cœur 98,9 % lignes (flow/state 100 %, channel 99,6 %) / pilote 97,6 % lignes (dataplane 95,4 %). Cœur PUR inchangé (aucune fn unsafe exposée, no_std). ✅ AirCom inc.5 — pub-sub par anneau de mémoire partagée (§7, diffusion 1→N) : 9ᵉ patron autonome distinct du RPC (canal dédié, hors StateMachine requête/réponse). Cœur PUR air-com-proto/ring.rs — anneau SPMC (1 producteur / N consommateurs) : disposition figée v1 ({capacity, slotPayloadCap, writeSeq, notify} + slots {stamp, len, payload}, arithmétique checked_*/saturante, zéro as nu), RingProducer::ring_publish (overwrite best-effort, ne bloque JAMAIS) / RingConsumer::ring_poll (détection de perte par saut de writeSeq au-delà de capacity, compteur lost persisté), protocole seqlock (estampille writing-impair/committed-pair, barrières Release/Acquire) rejetant toute lecture déchirée (comptée perdue, jamais rendue) — zéro fn unsafe, zéro panic, no_std ; accès mémoire délégués au pilote via traits RingReader/RingWriter (le cœur ne touche aucun octet partagé, invariant §1.1). Pilote air-com/pubsub.rs : Publisher (memfd scellé FUTURE_WRITE|GROW|SHRINK — producteur garde l’écriture, abonnés read-only), Subscriber (mmap RO, poll / next_blocking avec réveil futex réel portée Shared inter-process sur le mot notify), AsyncSubscriber (air-async — sonde temporisée : le réveil futex-via-io_uring/eventfd exige 2 pièces couche 1 absentes, hors additif atomique unique → différé honnêtement, best-effort §7). Additif couche 1 air-shm (accesseurs atomic_u32/atomic_u64 bornés+alignés sur vues mmap — l’unsafe reste couche 1, jamais dans le pilote). Model-based + property tests (roundtrip sans perte, abonné lent détecte l’overwrite, perte en bord de fenêtre reportée, lecture déchirée détectée/comptée/retentée, 2 abonnés reçoivent chacun tout, len mensongère bornée) + fuzz fuzz_air_com_ring (anneau hostile : writeSeq/stamp/len mensongers, charge tronquée — 2 000 000 runs, 0 crash, jamais de charge > slotPayloadCap). Cœur ring.rs 95,7 % lignes (100 % fn ; régions restantes = gardes SizeOverflow/conversions injoignables sur 64 bits, Principe 2) / pilote pubsub.rs 97,4 % lignes. DÉCISION BDFL : ship du mécanisme prouvé in-process ; bootstrap control-plane (§7 « Établissement » : publier le fd d’anneau via ShmRef+MessageKind::event) + exemple 2-exécutables pub-sub DIFFÉRÉS (→ inc.6/additif). Additif L1 air-shm en attente du re-sceau couche-1-v2.2 groupé au jalon de finalisation AirCom (avec l’additif inc.3b). ✅ AirCom inc.6 — contrat air-registry matérialisé (mock couche 2, §9) : la découverte nommée par fd (l’impl réelle est couche 5, hors périmètre). Cœur PUR air-com-proto/registry.rs (no_std+alloc, zéro unsafe/panic, sans fd §1.1) — wire maison length-prefixé borné et anti-hostile (ServiceName newtype validé « parse, don’t validate » : non vide / UTF-8 (from_utf8 Result) / borné MAX_SERVICE_NAME_LEN=255 ; RegistryRequest{Register,Lookup} + RegistryResponse{Ok,NotFound,Denied}, décodage slice::get/checked_*, tag inconnu / longueur mensongère / octets excédentaires rejetés), table de services nom→handle opaque u64 (register/duplicate/lookup, le cœur ne voit jamais de fd — le pilote apparie handle↔fd), et application du verdict d’entitlement (resolve_lookup/resolve_register : reçoivent un booléen, Denied l’emporte sur NotFound, spec §9). Pilote air-com/registry.rs : rendez-vous par socketpair, fd-only — register(name) cède reg_side au registry par SCM_RIGHTS (le service garde svc_side = canal d’acceptation) ; lookup(name) → le registry crée une paire fraîche, pousse service_end au service par le canal stocké et rend client_end au client, chacun enveloppant son fd en Connection (handshake Requester/Responder). Additif de surface couche 2 Connection::from_connected_async(fd,role,id) (aucun additif/descellement couche 1). Preuve end-to-end : service register(«greet») → client lookup(«greet») obtient un fd → call → le service serve répond Hello, Ada — aucune adresse échangée (matchmaking par fd, capability infalsifiable ADR-010) ; cas NotFound (inconnu) et Denied (entitlement refusé masquant un service présent) prouvés. fuzz fuzz_air_com_registry (décodeur de requêtes/réponses hostile + round-trip + table/verdict, 1 000 000 runs, 0 crash). Cœur registry.rs 100 % lignes (99,5 % régions ; 1 garde u16 injoignable par construction, Principe 2) / pilote registry.rs 98 % lignes (95 % fn ; seule fn non couverte = closure d’échec socketpair(2) injoignable). PAS d’exemple 2-process pour cet incrément (décision BDFL : contrat prouvé in-process ; l’exemple viendra avec le bootstrap pub-sub différé). Prochain (AirCom) : AirCom inc.7 — intégration modèle d’objet (ADR-002) : call sur AirObject + 1er service réel air-notifyd → air-sshd. ✅ Chantier air-object (ADR-002) OUVERT — découpage validé BDFL : AO.1 (air-value) → AO.2 (air-object cœur : AirObject/AirClass, refcount AtomicU32, AirHandle) → AO.3 (propriétés observables + send_message + politiques de thread) → AO.4 (proc-macro #[air_class]) → AO.5 (introspection + conformité ABI complète), puis câblage AirCom inc.7 (MessageKind::call sur AirObject + air-notifyd). ✅ AO.1 — air-value RÉALISÉ : nouveau crate crates/air-value/ (couche 2, cdylib+rlib → libair-value.so, calqué sur air-base-capi) livrant l’AirValue — union taguée #[repr(C)] à LAYOUT FIGÉ (ABI 10 ans, ADR-012) : AirValueKind(u32) + AirValuePayload(union 16 o : i:i64/f:f64/b:bool/buffer:AirBuffer{ptr,len}/obj:*mut c_void) ⇒ AirValue = 24 o, align 8 (kind@0, pad 4..8, payload@8), gelé et vérifié par sizeof/offsetof C + tests Rust. AirStatus in-band ({code:AirStatusCode(u32), message}, ADR-045, miroir AirErrorKind + codes frontière NULL_ARGUMENT=100/WRONG_TYPE=102). Surface air_value_* : constructeurs (null/int/float/bool/string/bytes/object), getters typés (as_int…as_object, WRONG_TYPE sur mauvais type), retain/release/clone, set_object_ops. Règle de propriété « +1 retours / +0 arguments » implémentée fidèlement : côté C manuelle, côté Rust automatisée par AirValueOwned (Drop=release, Clone=retain). Buffers AIR_STRING/AIR_BYTES = comptés par référence (en-tête AtomicU32 caché avant ptr — l’ABI ne voit que (ptr,len) ; AIR_STRING valide l’UTF-8). AIR_OBJECT découplé d’air-object (qui n’existe pas encore) via un hook de vtable global (AtomicPtr, air_value_set_object_ops) : retain/release délèguent au hook si installé (AO.2 l’installera), sinon no-op sûr — zéro unsafe non justifié, zéro panic, zéro UB. Header committé include/air_value.h (cbindgen, diffé en CI, xtask CAPI_CRATES étendu). Tests : unit + property (proptest) + conformité ABI C (tests/abi/conformance.c : layout gelé + règle +1/+0 avec ops objet installées par le C) + header_committed + allocateur compteur (tests/alloc_balance.rs : zéro fuite, libération à refcount 0) + multi-thread (retain/release concurrents) + fuzz fuzz_air_value_string (1 000 000 runs, 0 crash, ASAN : ni fuite ni double-free). Barrière verte (fmt/clippy -D warnings/machete/check-layers 2→1) ; couverture 98,5 % lignes / 100 % fonctions (7 lignes restantes = gardes OOM/non_exhaustive injoignables, documentées STRUCTURAL, Principe 2). Dép unique air-base-lib (comme air-base-capi : source #![no_std], l’artefact cdylib hérite de l’allocateur/panic-handler du std du graphe). ✅ AO.2 — air-object cœur RÉALISÉ : nouveau crate crates/air-object/ (couche 2, cdylib+rlib → libair-object.so, calqué sur air-value) livrant le cycle de vie & l’identité d’objet. AirObject — en-tête #[repr(C)] à LAYOUT FIGÉ (ABI 10 ans, ADR-012) : { isa:*const AirClass, refcount:AtomicU32, flags:u32, reserved:u64 } = 24 o, align 8 (isa@0, refcount@8, flags@12, reserved@16 ; reserved = espace figé pour l’extension d’en-tête AO.3+), suivi d’un payload variable zéro-initialisé ; vérifié par sizeof/offsetof C + Rust. Champ isa (idiome ObjC, évite le mot-clé C++ class). Refcount = AtomicU32 côté Rust (interior mutability correcte — le premier prototype u32+from_ptr était UB derrière un &, corrigé), rendu uint32_t côté ABI (post-traitement cbindgen dans xtask). AirClass — méta-classe (une classe est un AirObject) : name/parent(nullable)/instance_size/finalize(nullable) ; layout non gelé (vtable/propriétés → AO.3/AO.5), opaque côté C (forward-déclarée). Bootstrap métaclasse : static ROOT auto-référente (isa → elle-même), immortelle via fanion AIR_OBJECT_FLAG_STATIC (retain/release = no-op, jamais libérée, sûr en .rodata) ; classes déclarables via AirClassCell (const, Sync). API C-ABI : air_object_alloc (refcount 1 + payload zéro), air_object_retain/release (Arc, release saturant ; à 0 → finalize puis dealloc), air_object_class, air_object_is_kind_of (remonte isa→parent), air_object_root_class, air_object_runtime_init. AirHandle<T> (RAII Rust : Drop=release/Clone=retain). Branchement du hook AO.1 prouvé bout-en-bout : air_object_runtime_init installe les ops objet dans air-value (air_value_set_object_ops) ⇒ un AirValue AIR_OBJECT retient/relâche réellement l’AirObject (test C et Rust : refcount varie, finalisé au bon moment). Durcissement conformité ABI (demande superviseur) : env AIR_ABI_CONFORMANCE_REQUIRED=1 (posée en CI, job test-coverage/air-x86_64) ⇒ l’absence de cc n’est plus un skip silencieux mais un ÉCHEC ; si gcc ET clang présents, le consommateur C est compilé+exécuté avec les deux ; rétro-appliqué à air-value. libair-object.so agrège air-value (rlib) et ré-exporte air_value_* (un consommateur du modèle d’objet lie une seule .so ⇒ hook unique). Header committé include/air_object.h (xtask CAPI_CRATES étendu). Tests : unit + property (proptest) + conformité ABI C (layout gelé, métaclasse, cycle de vie, is_kind_of, intégration AO.1) + header_committed + allocateur compteur (alloc_balance.rs) + multi-thread (retain/release concurrents, finalize 1×) + intégration hook (integration_hook.rs). Pas de nouveau fuzz (justifié : aucune frontière d’octets externe — pointeurs+entiers ; la frontière octets vit dans air-value, déjà fuzzée). Barrière verte (fmt/clippy -D warnings/machete/check-layers/gen-capi-header/mdbook) ; couverture 97,7 % lignes / 100 % fonctions (4 lignes restantes = gardes OOM/overflow/saturation injoignables, documentées STRUCTURAL, Principe 2). ✅ AO.3 — propriétés observables + send_message + politiques de thread RÉALISÉ : air-object étendu (spec §5/§2/§6). AirClass étendue (toujours opaque côté C) : politique de thread obligatoire AirThreadPolicy (Immutable/MainThreadOnly/ThreadSafe — AirClassCell::new/with_members l’exigent, pas de défaut silencieux) + table de propriétés (AirPropertyDescriptor = AirPropertyInfo{nom,AirValueKind} + accesseurs typés get(+1)/set(+0), jamais d’offset brut) + table de méthodes (AirMethodDescriptor = sélecteur → imp(args +0 → +1)). Nouvelles structs C figées committées au header : AirPropertyInfo, AirPropertyDescriptor, AirMethodDescriptor, AirThreadPolicy (repr(u32), variantes préfixées AIR_THREAD_POLICY_*) ; AirObservation/AirNotificationToken opaques (forward-déclarées). Propriétés : air_object_get_property(+1, AIR_NULL si inconnu) / air_object_set_property(AirStatus : NOT_FOUND inconnu, UNSUPPORTED Immutable/lecture-seule, WRONG_TYPE via le setter) ; résolution héritée (chaîne parent). Observation (data binding) : air_object_observe/unobserve, set notifie ancienne/nouvelle valeur (+0) sur un instantané par valeur — ré-entrance sûre (un observateur peut set/observe/unobserve), retrait pendant notif sans UB, ordre déterministe. Registre par objet : tête de liste doublement chaînée logée dans les 8 o reserved de l’en-tête figé (usage documenté ; jamais touché par le C), sérialisée par un verrou tournant core pur (no_std, sections courtes) ; purge automatique à la finalisation (zéro fuite, prouvé par l’allocateur compteur). Wrappers Rust : AirObservable<T> (cellule réactive mono-thread) + AirNotificationCenter (pub-sub par nom, closures) — plus un centre C-ABI global air_notification_subscribe/unsubscribe/post ; portée intra-processus clairement documentée (≠ AirCom). Messages : air_object_send_message(+1, dispatch via classe + chaîne parent, AIR_NULL si sélecteur inconnu / args NULL avec n>0). Politiques de thread (§6, sécurité par construction) : MainThreadOnly debug-only (décision ratifiée : debug_assert en debug, zéro coût en release — Main Thread Checker UIKit) via air_object_set_main_thread (TID principal, air-thread::current_tid couche 1, arête 2→1) ; enforcement sur get/set/send_message/release ; prédicat air_object_thread_violation (doc(hidden), testable — le panic=abort du profil de test interdit d’intercepter un vrai debug_assert) ; Immutable refuse set. Layout AirObject (24 o) inchangé/figé. Dép ajoutée : air-thread (couche 1, no_std, zéro dép externe) pour current_tid. Header committé régénéré (air_object.h tire désormais air_value.h). Tests : 54 unit+property (get/set round-trips, inconnu/mauvais type/lecture-seule/écriture-seule, héritage props+méthodes, observation ancienne/nouvelle/ré-entrance/unobserve-pendant-notif/multi-observateurs/purge-à-la-finalisation, send_message dispatch/héritage/inconnu/args, AirObservable, AirNotificationCenter Rust+C-ABI global, Immutable refuse set, noms bornés hostiles, observation concurrente ThreadSafe), + intégration thread_policy (2 arches de la logique MainThreadOnly), conformité ABI C durcie (conformance.c : classe avec props+méthodes définie depuis C, get/set, observateur C notifié, send_message — gcc ET clang), header_committed, alloc_balance (nœuds d’observation zéro fuite). Barrière verte (fmt/clippy -D warnings/machete/check-layers 2→1/gen-capi-header/mdbook) ; couverture 98,2 % lignes / 98,4 % fonctions (restant = gardes OOM/overflow d’alloc AO.2, garde isa NULL, SpinLock::new const-évalué — injoignables, documentés STRUCTURAL, Principe 2). ✅ AO.4 — proc-macro #[air_class] RÉALISÉ : premier crate proc-macro d’Air crates/air-object-macros/ (couche 2, [lib] proc-macro = true, build-time only — compile pour l’hôte, jamais liée dans un artefact cible). Attribut #[air_class(thread = …)] générant (à partir d’une struct) exactement les descripteurs const écrits à la main en AO.3 : un static AirClassCell (via with_members, const), un AirPropertyDescriptor par champ #[observable] (accesseurs get(+1)/set(+0) typés via offset_of! dans le payload #[repr(C)] après l’en-tête figé 24 o ; la notification des observateurs est héritée du chemin générique air_object_set_property d’AO.3 — la macro n’y ajoute rien), la politique de thread issue de thread = …, et un accesseur Self::air_class() -> *const AirClass. « Zéro glue par classe » : aucune fonction C par classe — la classe passe par les air_object_* génériques ; interop AirHandle<Self> gratuite (générique sur le payload). Contrainte forte respectée : thread = … OBLIGATOIRE (absent ⇒ erreur de compilation claire, jamais de défaut silencieux) ; type de champ #[observable] non géré ⇒ erreur de compilation ; jamais de panique de macro non contrôlée (toute mauvaise utilisation = compile_error! à span correct). Périmètre v1 (documenté/justifié) : champs gérés = bool/i64/f64 (scalaires AirValue, Copy, valides zéro-initialisés, sans stockage possédé → aucun finaliseur) ; différés = champs à valeur possédée (AIR_STRING/AIR_BYTES/AIR_OBJECT : exigent stockage refcompté + finaliseur généré + discipline retain/release — incrément à part) et méthodes riches (table de méthodes vide ; le dispatch reste exercé : send_message rend AIR_NULL sur sélecteur inconnu depuis une classe générée). Structure testable : toute la logique vit dans expand.rs (sur proc_macro2::TokenStream, unit-testée — couverte par llvm-cov) ; seul le fin adaptateur #[proc_macro_attribute] (proc_macro↔proc_macro2) est non instrumentable (exécuté par rustc, couvert par trybuild). Macro ré-exportée par air-object (pub use air_object_macros::air_class — dépendance normale, proc-macro compile pour l’hôte donc zéro fork ADR-090 ; header committé air_object.h inchangé : parse_deps=false + une proc-macro n’expose aucun type #[repr(C)]). Exception 80 % proc-macro ACTÉE (syn/quote/proc-macro2, versions pinnées =2.0.117/=1.0.45/=1.0.106, syn default-features=false) dans docs/EXCEPTIONS.md — fixe la politique proc-macro d’Air (vaut pour toute future crate *-macros : build-time only, non livrée, pur Rust zéro-C) — + crates/air-object-macros/DEPENDENCIES.md. Traitement couche/gate : le crate vit sous crates/air-* (contrairement à xtask, hors crates/, donc non scanné) ⇒ il déclare [package.metadata.air] layer = 2 (métadonnée INERTE ; zéro dép air-* → aucune arête à vérifier ; air-object→air-object-macros = arête 2→2 conforme). Tests : trybuild compile-fail (8 cas, .stderr committés : thread manquant/()/inconnu, clé inattendue, args superflus, type de champ non géré, cible non-struct, tuple, générique) + 16 tests unitaires sur expand (tous les bras diagnostiques + génération, validation lexicale de la sortie) + e2e air-object/tests/macro_class.rs (4 tests : une classe #[air_class] ThreadSafe/Immutable traverse alloc/get/set [+ mauvais type→WRONG_TYPE, inconnu→NOT_FOUND]/observation [ancienne/nouvelle]/send_message/is_kind_of/release + AirHandle Clone/Drop — compile ET tourne, plus fort qu’un compile-pass). Pas de fuzz (justifié : la macro consomme du code source de confiance, pas des octets hostiles runtime). Barrière verte (fmt/clippy -D warnings/machete/check-layers 59 couches conformes/gen-capi-header air_object.h identique/deny licences ok/mdbook). Prochain (air-object) : AO.5 — introspection + conformité ABI complète. ✅ AO.5 — introspection (list_all/properties/parent/name/describe) + conformité ABI MERGÉ (#347) — chantier air-object COMPLET : air-object étendu (spec §7). Registre global de classes — enregistrement paresseux automatique à la première air_object_alloc d’une classe (« zéro glue » : le développeur ne déclare rien), liste intrusive (fanion registered: AtomicBool + maillon next_registered: AtomicPtr ajoutés à AirClass — layout non gelé, opaque côté C, donc header inchangé ; les statiques vivent en .data car AirClass contient des atomiques ⇒ mutation définie), zéro allocation heap pour le registre, mutations sérialisées par un verrou tournant REGISTRY_LOCK (core pur). Invariant de durée de vie documenté : une classe allouée-depuis doit être immortelle (#[air_class]/AirClassCell static/air_class_new) ou libérée par air_class_free (qui la désenregistre — pas de pointeur pendouillant) ; air_class_free gère l’unlink tête et multi-pas. Surface C-ABI nouvelle : air_class_list_all(*mut usize) -> *const *const AirClass (instantané possédé pris sous verrou, libéré par air_object_free_class_list(list, n)), air_class_properties(cls, *mut usize) -> *const AirPropertyDescriptor (zéro-copie : table AO.3 de la classe, propriétés propres ; inheritées via remontée parent — décision documentée : renvoie le descripteur, dont .info=AirPropertyInfo{nom,kind}, plutôt que copier un tableau AirPropertyInfo), air_class_parent, air_class_name, air_class_registered_count, et air_object_describe(obj) -> char* — chaîne de debug possédée (nom de classe + propriétés nom=valeur, héritées comprises), bornée et sans octet NUL (scalaires imprimés, agrégats String/Bytes/Object en jetons <…> ⇒ ne re-sérialise aucun octet externe), libérée par air_object_free_string (convention documentée : allocateur d’Air via CString, pas free(3)). AirClass reste opaque côté C (header air_object.h régénéré : 6 fonctions ajoutées, zéro type nouveau). Preuve « zéro glue » (Pattern A générique) — livrable de conformité : conformance.c étendu d’une suite d’introspection qui, sans aucun code par classe, construit une hiérarchie Shape←Square depuis C (air_class_new), énumère toutes les classes (list_all), liste leurs propriétés (properties), lit/écrit par nom découvert dynamiquement (round-trip val+1), décrit un objet (describe → contient nom + propriété propre + héritée), vérifie parenté (parent/is_kind_of) — gcc ET clang, REQUIRED ; + preuve qu’une classe #[air_class] (Widget) traverse la même surface d’introspection générique (macro_class.rs). Tests : 67 unit+property (registre : présence/absence-si-jamais-allouée, énumération, première alloc concurrente 16 threads → inscription unique [barrière], désenregistrement tête/multi-pas/no-op, properties/parent/name + bras NULL, describe scalaires/héritées/write-only/toutes variantes de kind/table NULL/nom NULL) + conformité ABI C durcie (dual-compilateur) + alloc_balance étendu (describe→free_string et list_all→free_class_list zéro fuite, allocateur compteur) + header_committed. Pas de nouveau fuzz (justifié : l’introspection produit, ne parse aucun flux externe ; noms bornés cstr_bytes, déjà couverts). Correctif induit : le test AO.2 air_class_cell_new_at_runtime (cellule sur la pile) fuit désormais intentionnellement sa cellule (Box::leak → 'static) pour respecter le nouvel invariant de registre. Stabilité ABI : la suite de conformité fonctionnelle est livrée ; l’outillage lourd (symboles versionnés GNU/.map, air-symver/air-abi-check/air-deprecation-tracker) reste HORS périmètre AO.5 (chantier transverse séparé, Principe 8) — non construit, noté comme suite. Barrière verte (fmt/clippy -D warnings/machete/check-layers 2→1/gen-capi-header air_object.h identique/deny/mdbook) ; couverture 97,8 % lignes / 98,5 % fonctions (restant = gardes défensives injoignables : saturation/OOM/overflow AO.2, isa NULL, SpinLock::new const-évalué, double-check de course register/unregister, registre vide, CString NUL ; + monomorphisations génériques AirHandle<T>/AirObservable<T> reportées vides par CGU mais exercées — documentées STRUCTURAL, Principe 2). Merge #347 durci en revue (2 findings mineurs, ABI-neutre) : air_class_properties ramène *n_out = 0 sur une classe malformée (table NULL avec compte déclaré > 0 — plus d’itération C props[0..n] sur base NULL ; aligné sur air_object_describe, test dédié verrouillant les deux bras du garde), et le doc-comment de air_class_list_all documente la durée de vie des AirClass* empruntés (une classe heap air_class_new libérée pendant qu’on tient l’instantané ⇒ pointeur pendouillant ; les statiques usuelles restent immortelles). Barrière + test-coverage rejoués verts après correctif. 🎉 Chantier air-object (ADR-002) COMPLET (AO.1→AO.5 : air-value, cœur, propriétés/observation/messages/thread, #[air_class], introspection). ✅ AirCom inc.7 — intégration modèle d’objet (MessageKind::call sur AirObject) + 1er service réel air-notifyd — MERGÉ #349 (main f8ac34b) : schéma corps d’invocation dédié (air-com-schema/invoke.capnp : Call{objectId,selector:Text,args}/Return{value}/Error{code,message} — ajout compatible coexistant ADR-012, aircom.capnp inchangé byte-pour-byte ; methodId = sélecteur textuel cohérent avec air_object_send_message, alternative table-d’ids UInt64 rejetée+documentée) ; cœur PUR air-com-proto/invoke.rs (no_std, zéro unsafe/panic, objectId/selector opaques — sans fd ni objet §1.1) — codec Call/Return/InvokeError borné anti-hostile (unit + property round-trip + fuzz fuzz_air_com_invoke 1,1 M runs, 0 crash ; ~98 % lignes) ; pilote air-com/object.rs — registre d’export objectId → *mut AirObject (retain/release équilibrés, prouvé par finaliseur-compteur), marshalling AirValue ↔ capnp (scalaires v1, AIR_OBJECT différé), dispatch call → send_message → returnMsg/error (objet inconnu / sélecteur inconnu AIR_NULL / violation de politique de thread), Connection::call_object/serve_objects sur les deux surfaces async+sync (+ test croisé sync↔async dans les deux sens) ; nouvelle arête 2→2 air-com → air-object/air-value (check-layers vert) ; air-notifyd (nouveau crate couche 2, 1er service ADR-001) — classe AirNotifyd (méthode notify(title,body)→status + propriété observable count) + 2 exécutables aircom_notifyd_{server,client} exécutés on-target (carbon), exit 0 des deux côtés. NB : #[air_class] diffère encore la génération de méthodes (AO.4) ⇒ la classe notify est câblée à la main via AirClassCell::with_members (forme exacte que la macro émettra). Durci en revue avant merge (superviseur, revue adverse par agent → verdict SAIN ; ABI-neutre) : #![forbid(unsafe_code)] posé sur le cœur air-com-proto (l’invariant §11 « le cœur n’expose aucune fn unsafe » passe de garanti-par-revue à vérifié par le compilateur) + un doc-comment corrigé. 🎉 AirCom : les 7 incréments (inc.1→7) sont MERGÉS — l’IPC natif d’Air a son 1er service réel (air-notifyd). Restent, différés/soft : args AIR_OBJECT + génération de méthodes par #[air_class] ; bootstrap control-plane pub-sub + exemple 2-exe pub-sub (différés inc.5) ; re-sceau couche-1-v2.2 groupé (additifs L1 air-socket::into_owned_fd inc.3b + air-shm inc.5). Prochain : couche 2 — framework réseau → air-sshd (ADR-074, la vraie cible produit). ✅ CHAPITRE RÉSEAU OUVERT (2026-07-13) — stratégie ratifiée BDFL : air-sshd en direct (sur air-async+air-socket+air-crypto en sans-IO ; SSH ≠ TLS → framework générique air-network/air-tls différé, hors chemin critique). ADR-093 rédigé + refondu (directive BDFL v1/v2) (phase 1 = couche transport SSH-2, sous-ADR d’ADR-074, draft pour ratification) : topologie de crates figée — cœur sans-IO air-ssh-proto (invariant, réutilisé verbatim en v2) + air-sshd scindé (pilote d’octets swappable SshByteStream : v1 air-async / v2 stack « ssh » d’air-network enveloppant le même cœur ; couche service invariante) + facilité partagée air-service (trait ServiceHost : v1 systemd socket-activation+sd_notify a minima / v2 air-launchd). air-sshd publie ses événements de session sur AirCom (pub-sub §7 + objet-service interrogeable list_sessions) → air-com dépendance v1. Algos modernes only (curve25519-sha256/ssh-ed25519/chacha20-poly1305@openssh.com/aes256-gcm@openssh.com), aléa injecté, conf binaire air-config (existe ; conf par-utilisateur HomeDirectory en P2), cible wire-compat OpenSSH ; 4 incréments T.1→T.4 (3 crates+seams+schéma events+identification+Framer → KEXINIT+négo+event → KEX+dérivation → chiffré+NEWKEYS+preuve ssh réel). 2 ADR compagnons v2 (air-launchd ; stack « ssh » air-network). Socle entièrement prêt (air-crypto profil SSH implémenté, air-async, air-socket, air-config ~16k l., AirCom, air-process/privsep, PTY, signalfd, air-account). Après ratification : impl en incréments délégués carbon (re-vérif+merge comme AirCom)).

0. Actualité — CIBLE DE PRODUCTION (2026-07-10)

🎯 OBJECTIF PREMIER (pivot 2026-07-10, ADR-088) : une toolchain Rust dont la std repose uniquement sur Air, par un PAL custom safe bindant la couche 1, SANS libc C. Sans cet outil fondamental, on ne peut pas produire sereinement le reste. Le jalon M5 est ATTEINT mais par le chemin de l’option A (ADR-076) : std liait la libc C libair_c — or la frontière C réintroduit de l’unsafe, incohérent avec la doctrine (« unsafe en couche 0 seulement »). ADR-088 amende ADR-076 : PAL custom std::sys::pal::air bindant les Managers couche 1 Rust safe (premier backend std safe de bout en bout), cible target_os="air", libair_c survit mais découplée de std, AirTaskManager remplace AirProcessManager, résorbe raw_syscall. M5 = marchepied de faisabilité. Étude : etude-std-pal-air-safe-fr.md.

Cible produit ensuite : air-sshd — le serveur SSH d’Air, full Rust, async io_uring, wire-compat OpenSSH (ADR-074) — la toolchain safe est son prérequis. (Il n’y a pas de jalon « compiler OpenSSH réel » : OpenSSH n’était qu’une fonction de forçage, rôle rempli.)

Acquis récents (couche 1 scellée → toits) :

• 🎉 M5 ATTEINT (2026-07-10) — std tourne sur Air, ZÉRO glibc, 2 arches. Le lien de hello-std contre libair passe de 12 → 0 symboles indéfinis (5 PR : __xpg_strerror_r #308, open/fcntl #309, introspection thread couche 1 [ADR-086] #310, getauxval/ pthread_self/détection-pile #311, TLS keys #[thread_local] #312, syscall générique [ADR-087] #313). Run on-target : hello from std on air + exit 0 sur x86_64-air (carbon) ET aarch64-air (raspi). Un programme Rust std static-PIE lié intégralement sans glibc. Pari ADR-076 tenu de bout en bout. Re-sceaux couche-0-v1.12 (ADR-087 raw_syscall, escape hatch temporaire à retirer avec l’équipe Rust) + couche-1-v1.9 (ADR-086 introspection thread).
• Campagne réseau ADR-069 close : registre de handles air-handle, moteur socket air-socket, surface socket libc complète (30 symboles, libair_c.so) + sendmsg/ recvmsg/SCM_RIGHTS. Re-sceaux couche-0-v1.10 (ADR-070 sockaddr + ADR-071 sockopt) et couche-1-v1.6 (ADR-069). CI basculée x86 (ADR-072).
• Doctrines gravées : config binaire (ADR-073), vision air-sshd (ADR-074) — la vraie cible (OpenSSH n’était qu’une fonction de forçage), fourniture du PAL (ADR-075).
• Chantier A du PAL COMPLET : 6 briques additives couche 1 (AirCondvar, AirOnce, os_str, mutation d’env, yield_now/set_thread_name, destructeurs thread_local).
• Bug de fondation aarch64 CORRIGÉ (gdb) : le TCB (64 o) recouvrait la zone TLS (tpidr_el0 base commune TCB+TLS à +16) → tout 2ᵉ #[thread_local] cassait. Fix validé 2 arches (selftest rt x86-air = 42 ET aarch64-air = 42).
• Chantier B lancé, option A prouvée : build-std=std compile entièrement pour Air (env=musl, zéro patch libc/std) ; reste le lien (-lc = libair, -lunwind = stub).

⚠️ 2026-07-08 — RÈGLE + ARCHITECTURE (ADR-077) : la libc bind EXCLUSIVEMENT la couche 1 (jamais la couche 0), via des Managers de domaine objet (AirFileManager/AirTaskManager/AirNetworkManager/AirSystemManager/AirSignalManager/AirEnvironmentManager/AirMemoryManager). Remédiation livrée (re-sceau couche-1-v1.7, ADR-077) : les Managers sont la surface médiatrice objet consommée par les toits (libc et PAL), jamais la couche 0 en direct. Les symboles air-libc-* bindent les Managers / briques couche 1.

Prochaines tâches (pivot ADR-088 — chantier PAL safe). Le jalon M5 (option A : std sur la libc C libair_c) est atteint et conservé comme marchepied de faisabilité, mais il réintroduit de l’unsafe par la frontière C — incohérent avec la doctrine. ADR-088 pivote : std reposera sur un PAL custom safe (std::sys::pal::air + sys/<domaine>/air.rs) bindant les Managers couche 1 Rust safe, zéro FFI, cible target_os="air" (Air n’est plus déguisé en unix), libair_c découplée de std, escape hatch raw_syscall résorbé. Stratégie de sceau : desceller la couche 1 une fois pour tout le chantier, resceller une fois au jalon (comme couche-1-v1.0).

• ✅ Étapes 1–2 faites : note d’étude (etude-std-pal-air-safe-fr.md)
  • ADR-088 acté (tranche §6.a–e). ADR-089 réserve le SecurityManager (#324).
• ✅ Lot 1 mergé (#322/#323) — seul changement cassant : renommage AirProcessManager → AirTaskManager (médie air-process/air-thread/air-runtime + resource_limit) + surface futex/gettid ; propagation doc (macro-archi, ADR-077/085/086, INDEX, registre, libc-conformance).
• ✅ Étape 3 faite (incrément 0+1, branche feat/pal-safe-air-target, en revue) — reprofilage cible : cible canonique *-linux-air reprofilée target_os="air" (retrait env=musl/ target-family), option-A renommée marchepied *-linux-air-musl (M5 préservé, baseline rejouée : hello from std on air/exit 0/zéro glibc). Fork rust-src localisé réversible (rt/rust-src-air/ : patch + apply-air-pal.sh + copie vendor/ gitignorée, override __CARGO_TESTS_ONLY_SRC_ROOT). std COMPILE pour *-linux-air, 2 arches (x86_64 + aarch64), lien d’un binaire std minimal sans symbole libc indéfini (patch minimal : 5 fichiers std::sys, murs A1–A4). os=air inconnue ⇒ restricted_std (voie standard des ports custom).
• ✅ Incrément 2 — PROTOTYPE rustc-dep-of-std sur air-alloc : PROUVÉ + dé-risqué (commit 5f12621, branche). std compile 2 arches avec le vrai air-alloc (arène mmap/futex couche 0) comme allocateur global — sonde air-alloc-probe : ELF static-pie, zéro glibc, zéro symbole indéfini, 5 Kio (arène réelle liée, plus le placeholder). Mesure décisive : la couche 0/1 ne change QU’EN build-config (3 Cargo.toml, +38 l., feature rustc-dep-of-std + façades rustc-std-workspace-*) — ZÉRO .rs source, zéro sémantique, zéro gate/scellé touché. Vérifié superviseur : tests hôte des 3 crates scellées verts (23+807+199, 0 échec). ⇒ Le descellement formel de la couche 0 N’EST PAS nécessaire (crates Air déjà no_std-propres).
• ✅ Incrément 3 — AUDIT deps externes (commit cfe216d, branche) : fardeau brut de binding naïf = ~71 forks (33 icu4x via air-base-lib + 37 RustCrypto via air-crypto + 1 bitflags), intenable — MAIS presque entièrement évitable par DÉCOUPLAGE, pas par fork. Aucune externe n’a rustc-dep-of-std amont (toutes no_std) ; les 11 proc-macros compilent pour l’hôte → zéro fork. Trouvaille : les 2 grappes 🔴 n’entrent dans std que par couplage accidentel — (1) AirError/AirResult/AirPath sont définis dans air-base-core (icu-free) ; air-base-lib ne fait que les ré-exporter + ajouter icu ⇒ rediriger les imports Managers fs/net/process/runtime vers air-base-core sort icu4x du graphe std (chemin d’import, zéro sémantique) ; (2) AirRandom::fill n’appelle que air-sys-syscall::getrandom (couche 0) ⇒ isoler le random sort RustCrypto du graphe. Vérifié source : air-base-core définit bien les types, Vague 0 dépend de air-base-core (pas -lib).
• ✅ ADR-090 ratifié (2026-07-11, sur main) — grave la discipline : binding par rustc-dep-of-std (build-config, pas de descellement) ; imports air-base-core jamais air-base-lib ; exceptions 80 % (icu4x/RustCrypto) hors fermeture std ; AirRandom hors crypto ; frontière no_std = relation à std ; industrialisation par vagues.
• ✅ Vague 0 — binding réel du noyau (commit a9769c4, branche) : std compile ET lie pour x86_64 ET aarch64 sur 5 vrais Managers — io/error→air-base-core, pal/air::futex+sync/* (Mutex/Condvar/RwLock/Once/Parker réels)→air-thread::raw_futex, stdio→air-stdio, env→air-env (+ alloc→air-alloc). Fermeture vérifiée : uniquement bitflags (ni icu4x, ni RustCrypto, ni air-base-lib) — fork count = 1. Zéro .rs couche 0/1 touché, hôte scellé vert. Lien : static-pie zéro glibc ; x86_64 = __tls_get_addr seul indéfini (hook TLS runtime), aarch64 = zéro indéfini. Placeholders restants : random, thread_local.
• ✅ Vague 1a — découplage air-base-lib→air-base-core (commits b9b4edc/89ba1d4/9d80380, branche) : seuls air-filesystem + air-socket dépendaient directement d’air-base-lib (les 3 autres déjà sur air-base-core). Redirection ABI-neutre, aucun cas d’i18n réel (le seul from_utf8_lossy = wrapper stdlib zéro-icu). Vérifié : air-filesystem/air-socket/air-process ont icu4x=0, air-base-lib=0 dans leur fermeture (fork=1). exit réel bindé sur air-process::exit_process (prouvé au désassemblage : __NR_exit_group, pas abort()). Hôte scellé vert (aucune régression).
• 🎯 Vague 1b — JALON ATTEINT (commits 396944c/636eda7/168dd4b, branche) : hello-std s’exécute sur le PAL safe. Résidus Vague 0 levés : (1) __tls_get_addr supprimé via "tls-model": "local-exec" dans les specs cibles (TLS statique, accès %fs:OFFSET direct) ; (2) _start abouté au bootstrap d’air-runtime (crt0 Air : self-reloc/TLS/TCB/canari/argv → __air_start→bootstrap→main→println!→exit_process), _start hors de std (côté binaire, ne casse pas les #![no_main]). air-runtime+air-memory en rustc-dep-of-std (build-config, zéro source couche 1 touchée), fermeture sans icu4x/crypto, fork=1. VÉRIFIÉ SUPERVISEUR sur 2 arches : hello from std on air+exit 0 sur x86_64/carbon ET aarch64/raspi-srv-2 (sha256 identique, static-pie, 0 glibc, 0 UND). Hôte scellé vert (127 tests feature OFF), zéro FFI hors _start asm/extern "C" (SAFETY documenté), aucun descellement.
• ✅ Bug spawn aarch64 : NON REPRODUCTIBLE (2026-07-11, raspi) — air_runtime::thread::spawn (clone3+CLONE_SETTLS Variant I) prouvé sound (~16 000 spawns : canonique .tbss + instrumenté .tdata + isolation ; selftest rt=42, 5/5 re-vérif superviseur). Les 2 bugs historiques sont corrigés (TCB/TLS overlap 2026-07-07 ; asm x19→x21 #150). Le TODO « fix bug spawn aarch64 » était stale ⇒ sys/thread (PAL) est débloqué côté runtime.
• ✅ Vague 1c — sys/thread réel (commits 2e953ef/2ccb15e, branche) : std::thread::spawn+join s’exécutent sur le PAL safe, 2 arches VÉRIFIÉES superviseur (x86_64/carbon + aarch64/raspi : worker sum=5050, join, exit 0 ; stress 800 threads OK). Binding Thread::new→air_runtime::thread::spawn (trampoline extern "C" fn(usize), Box<ThreadInit> pointeur fin, expose_provenance), join→futex CHILD_CLEARTID, set_name/yield_now→air-thread, sleep→air-base-core, id→current_tid ; available_parallelism/garde de pile = stubs documentés. Zéro source couche 0/1 touchée, fermeture toujours 1 fork, air-runtime déjà bindé (rien à ajouter).
• ✅ air-alloc alignement fort — MERGÉ sur main (#325, 384c80b, 2026-07-11) : implémenté l’alignement fort (align > 16, memalign dlmalloc) dans l’arène, lève ADR-056 D5 (amendé). Découvert via std::sync::mpsc (align 64 → l’ancien refus align>16→null faisait abort SIGILL). 30 tests (matrice 32/64/128/256/page + realloc/dedicated/alloc_zeroed/OOM) + property + fuzz (44 600 exécutions). CI verte (test-coverage root ✓, supply-chain ✓, cross-aarch64 ✓). ⇒ mpsc/ crossbeam/types sur-alignés débloqués (la branche PAL rebasera sur ce main pour en bénéficier).
• ✅ std::sync::mpsc VALIDÉ sur le PAL, 2 arches (branche, merge 927e624 + sonde d85405e) : après intégration du fix air-alloc (merge main, conflit nul), la sonde hello-mpsc (8 producteurs × 1000, somme 32004000) s’exécute — x86_64/carbon (120 runs 0 échec) ET aarch64/raspi (vrai ARM), exit 0, static-pie 0 glibc. Le cas SIGILL (V1c-6) est clos, fix align-fort prouvé en contexte. air-alloc = dépendance path de std (rustc-dep-of-std) ⇒ patch rust-src inchangé.
• ✅ sys/fd + minimal sys/fs réels (commits d32fb79/f05907c, branche) : FileDesc(OwnedFd) → AirFileManager (read/write/read_at/write_at/seek/fsync/ftruncate/set_nonblocking) + duplicate→ air-handle ; File::open/create/read/write/seek minimal. Aller-retour fichier std prouvé 2 arches (sonde hello-fs : 16 Ko écrits+relus identiques + seek, exit 0 ; x86_64/carbon 10/10 + aarch64/raspi). Zéro additif couche 1, zéro unsafe dans le bras, zéro source couche 0/1, fermeture 1 fork. Frontière assumée (Vfd-3) : std::os::fd non exposé (éviterait un portage net/pipe/stdio-fd complet) — unification air-handle (ADR-069) = chantier distinct.
• ✅ sys/fs COMPLÉTÉ (commits c2879d5/9aa5290, branche) : métadonnées (statx→FileAttr/ FileType/FilePermissions, temps), ReadDir/DirEntry (getdents64), unlink/rename/mkdir/ rmdir/DirBuilder/remove_dir_all, liens (symlink/link/readlink/canonicalize/copy), set_permissions/set_times, exists ; current_exe (readlinkat /proc/self/exe, bras sys/paths/air.rs). Zéro additif couche 1, fermeture propre (fork=1, icu/crypto/regex=0). Prouvé 2 arches (sonde hello-fs2 : read_dir trié + métadonnées + liens + rename + suppression + current_exe, exit 0 ; x86_64/carbon + aarch64/raspi — 1ʳᵉ panique aarch64 = artefact de renommage du binaire par le superviseur, re-run au bon nom = OK). std::fs largement fonctionnel.
• ✅ sys/process réel (commits 76a8dc1/f372a9c, branche) : std::process::Command spawn/exec/wait/status/kill — bâti sur AirProcess (pidfd : clone3+CLONE_PIDFD/execve/ waitid/pidfd_send_signal, wait+kill en couche 1, pas spawn_process nu qui exigerait un waitid couche 0). Stdio Inherit/Null/Fd ; Piped/output différés (avec std::os::fd/ pipe). Prouvé 2 arches (hello-proc : /bin/true→0, /bin/false→1, introuvable→127, exit 0 ; x86_64/carbon 20/20 + aarch64/raspi). Zéro additif couche 1, zéro FFI, zéro unsafe, fermeture 1 fork (air-account→air-base-core, découplage tenu).
• ✅ sys/net réel (commits 54a53f6/ce6e8d7, branche) : std::net TCP + UDP — bâti sur air_socket::engine::AirSocket (couche 1 &self, pas les façades &mut self). TcpStream connect/read/write/peek/shutdown/nodelay/keepalive/nonblocking/addrs ; TcpListener bind/accept (SO_REUSEADDR, backlog 128) ; UdpSocket send_to/recv_from/peek_from + connect/send/recv ; adresses numériques (DNS différé). Prouvé 2 arches (hello-net : TCP + UDP loopback roundtrip, exit 0 ; x86_64/carbon 10/10 + aarch64/raspi). Zéro additif fonctionnel couche 1, fermeture 1 fork.
• ✅ std FONCTIONNELLEMENT COMPLET pour fichiers / threads / mpsc / process / réseau — le réseau était le dernier gros sous-système. Reste pour « std bouclé » : sys/random (dernier mur dur), + différés soft.
• 🎉 sys/random réel — std FONCTIONNELLEMENT BOUCLÉ (commits 82517f1/12b676e/6e336c0, branche) : isolation par micro-crate air-random (couche 1, no_std, sur getrandom couche 0) — air-crypto la ré-exporte (surface fill/generate_key inchangée, régression hôte 0 : air-crypto 42/42, air-random 3/3). Gate ADR-090 vérifié superviseur : fermeture air-random = {air-sys-syscall, air-sys-types, bitflags}, RustCrypto = 0 (build-std 33 crates : RustCrypto/icu4x/air-base-lib = 0, fork = 1). sys/random/air.rs (zéro unsafe) → HashMap/RandomState amorcés sur CSPRNG kernel. Prouvé 2 arches (hello-random : entropie réelle distincte + HashMap 1000 entrées, exit 0 ; x86_64/carbon 5/5 + aarch64/raspi). ⇒ tous les murs durs de std franchis.
• ✅ Portage std MERGÉ sur main (#326, ce46a0b, 2026-07-11) : squash, CI verte (test-coverage root + supply-chain + build + loom + cross-aarch64), Verified GitHub. Couche 1 évoluée (découplage air-filesystem/air-socket→air-base-core, micro-crate air-random, features rustc-dep-of-std) mais NON re-scellée — le re-sceau viendra après les différés soft (décision BDFL : ne desceller qu’une fois). Fork rust-src localisé (rt/rust-src-air, vendor/ gitignoré).
• ⏭️ Séquence en cours (BDFL, branche feat/std-osfd-pipe, 1 PR à la fin) : différés soft PUIS re-sceau. (a) ✅ std::os::fd + sys/pipe (commit 3689ebb) — AsRawFd/OwnedFd, io::pipe, Stdio::Piped/ Command::output débloqués ; zéro additif couche 1 (via sys/pipe+AirStdio::Fd), fermeture 1 fork ; prouvé 2 arches (hello-pipe : io::pipe + capture "hello-air\n" + os::fd, exit 0). (b) ✅ options socket (commit 4105188) — additif couche 1 air-socket (méthodes typées &self, +5 tests, zéro unsafe) : ttl/linger/nodelay+keepalive getters/broadcast/multicast loop+ttl/only_v6/connect_timeout (ppoll+SO_ERROR)/duplicate ; prouvé 2 arches (hello-sockopt set==get, exit 0), fermeture 1 fork, régression hôte 0. Options à STRUCTURE — additif COUCHE 0 v1.13 FAIT (commits 27195dd/1f89c98) : air-sys-types (ip_mreq/ipv6_mreq #[repr(C)], const assert! ABI) + air-sys-syscall (6 wrappers dédiés typés) + couche 1 air-socket + PAL ⇒ read_timeout/write_timeout (+ read vide expiré) + multicast join/leave v4/v6, prouvés 2 arches. Plus aucun unsupported sur les options socket. ⚠️ Barrière : plancher lignes rouge (93.29%<94) = artefact llvm-cov d’hôte (net.rs 64.53% au baseline = impossible pour couche 0 scellée ; branches +12/0-manque) → arbitre = CI test-coverage root ; tag couche-0-v1.13 contingent à CI verte. (c) ✅ DNS FAIT (commits 0ec7032/e18117c) — câblage lookup_host sur AirNameResolver existant (best_effort [hosts, DNS RFC 1035, localhost], IPv6-first) + additif air-socket (AirLocalhostSource, ponts core::net, zéro unsafe) ; prouvé 2 arches (hello-dns : localhost + numérique + connect-par-nom, exit 0), fermeture 1 fork (résolveur maison, getaddrinfo 0). ⇒ TOUS les différés soft traités. hostname() laissé unsupported (tirerait air-system — chantier distinct). Reste : PR unique + CI (arbitre couverture couche 0) + re-sceaux (couche-0-v1.13 + couche-1).
• 📌 DIRECTIVE BDFL (2026-07-11, après consolidation) : rendre normatif le motif réseau sans-IO (docs/notes/reseau-architecture-crates-fr.md) via un ADR — toute impl réseau doit s’y conformer (seul motif testant la pile indépendamment). Précurseur : AirDnsSource. À faire avant air-async/ couche 2. Voir mémoire projet.
• 🗺️ PHASE SUIVANTE = couche 2 (séquence BDFL) : runloop air-async (réacteur io_uring↔Waker/ exécuteur/timers) → IPC Air → framework réseau Air → air-sshd (démonstration couche 2). En parallèle, à traiter : hygiène pré-merge branche PAL (Cargo.lock stubs façades → deny/audit/ machete + repro), merge de la branche PAL, re-sceau couche 1 (ADR-088 « resceller une fois »). Différés soft std (non bloquants pour un programme courant) : std::os::fd (AsRawFd/FromRawFd) + sys/pipe (io::pipe, chantier libc-fd, débloque Stdio::Piped/Command::output) ; options socket fines (timeouts/ttl/linger/broadcast/multicast) ; DNS (brancher AirNameResolver sur lookup_host) ; available_parallelism/park-unpark/TLS dynamique. RFC amont (etude-rfc-trait-backend-std-fr.md).
• 🗺️ Roadmap au-delà du portage std (séquence BDFL 2026-07-11) : (1) boucler std (fs/process/net) ; (2) couche 2 — la runloop (= air-async, réacteur io_uring↔Waker/exécuteur/timers, pièce maîtresse identifiée dans architecture-prerequis-air-sshd-fr.md), puis l’IPC Air, puis le framework réseau Air ; (3) air-sshd (ADR-074) — composant réseau primordial et démonstration du fonctionnement de la couche 2. Puis hygiène pré-merge (Cargo.lock stubs façades → deny/audit/machete + repro ADR-025), merge de la branche, re-sceau couche 1 (ADR-088 « desceller une fois, resceller une fois »). RFC amont Tier-3 + backend std::sys safe (etude-rfc-trait-backend-std-fr.md) : la preuve downstream est acquise.
• ⏭️ Étape 4 (conditionnée à la décision) — implémentation par sous-système (facile→dur, chacun bindant son Manager) : exit/random/time/os_str/args/env → fd/stdio → futex+sync (les 3 wrappers débloquent Mutex/Condvar/RwLock/Once/Parker) → fs → thread+thread_local → process → net. Manques couche 1 (§5 étude : current_exe, DirEntry typé, park/unpark, options socket) comblés en additifs v1.x au fil de l’eau.
• 🎯 Jalon de succès : hello-std re-tourne sur le PAL safe, 2 arches, sans libair_c liée — preuve d’un userland Rust safe de bout en bout (unsafe confiné couche 0). Puis re-sceau couche 1 unique + RFC amont (Tier-3 *-linux-air, backend std::sys safe).

Dettes/leçons associées : raw_syscall/GlobalAlloc-safe traités dans ce chantier (§5) ; lane CI nightly hello-std/rt à monter ; leçon gravée jamais différer les runs raspi (un cross-build aarch64 vert ne prouve rien au runtime). Cible produit après la toolchain safe : air-sshd (ADR-074).

1. Où en est-on (vue d’ensemble)

Couche 1 scellée le 2026-07-03 (tag couche-1-v1.0, ADR-062). Voir §4 pour les jalons.

2. Sceau couche-1 : FAIT — et file des tâches à venir

Décision de gouvernance BDFL : combler les P0 des audits, remodeler ce qui l’exigeait, PUIS sceller. Tout est fait :

Prochaine étape (voir §0 Actualité en tête) : air-sshd — le serveur SSH d’Air full Rust (ADR-074). Le chantier B du PAL est clos : std lie et tourne sur la libc d’Air (M5 atteint, hello-std 2 arches). Toits libc C-ABI et PAL prouvés ; la toolchain Rust full-Air est acquise et sert désormais de socle à la production air-sshd.

Additifs v1.x (descellement additif, non bloquants) : spawn ergonomique §2.B.2, Condvar/Once, set_var/mutation d’env, destructeurs TLS, getsockopt/setsockopt, mman fichier-adossé, stat/fstat public, mkstemp, barrière de poison + fault_state() (ADR-064 §7), gap aarch64 crypto (#14), instrumentation IO debug (ADR-063), regex (§4-I), AirRuntime::errno_location() -> *mut i32 (socle de __errno_location() de la libc — premier additif révélé par le toit libc M0, roadmap §6 ; RFC de descellement additif requis), M3 Phase A — signaux+pthread (ADR-066) : install de handler async réel pour les signaux non-faute (air-signal::install_handler/restore_disposition, unsafe localisé) + pending(), et primitives futex(2) typées sur mémoire externe (air-thread::raw_futex) pour bâtir pthread_mutex_t/cond_t de la libc et std::sys du PAL ; fondation posée en couches 0 (couche-0-v1.9) et 1 (couche-1-v1.2), rien en couche 2. (La face sigaction-de-faute n’est PAS un additif — les 4 fautes restent inertes, ADR-064 §2 ; seul l’install de handler non-faute est descellé, ADR-066.) Cette liste se complète au fil des points identifiés.

3. Méthode de production (rappel pour agents)

• Doctrine de couche : seule la couche 1 consomme la couche 0 ; les tiers couche 1 sont fidèles (un appel = un syscall), EINTR remonté (jamais de retry auto), zéro unsafe exposé, erreurs AirError/AirResult, arithmétique défensive (jamais as lossy), nommage ADR-029 (zéro abréviation).
• Qualité, avant tout merge : cargo fmt/clippy -D/test, cargo xtask barrier (WARN = vert ; 5 advisory unsafe pré-existants security.rs/inotify.rs ignorés), couverture 100 % lignes (exceptions STRUCTURAL = marqueur in-code // COVERAGE (STRUCTURAL, ADR-035), comme air-process/air-poll), fuzz sur toute surface de parsing d’octets externes (sinon « Note fuzz » justifiée dans la spec).
• Git : trunk-based, tout par PR sauf doc pure → commit direct sur main (pas de CI pour de la doc). DCO -s + signature GPG (clé BDFL), jamais de trailer Co-Authored-By. Production déléguée à claude -p headless (carbon/speedy) ; le superviseur pilote validation + push + PR + merge (squash) + re-vérif main/trailer.
• Nouvelle crate ⇒ committer Cargo.lock (reproductibilité ADR-025).

4. Jalons réalisés (résumé — détail dans JOURNAL.md)

• Couche 0 — scellée couche-0-v1 (2026-06-14) puis re-scellée jusqu’à couche-0-v1.8 (2026-07-02, famille terminal/termios-tty, ADR-060), puis les descellements additifs de la campagne libc/std : v1.9 (signaux async, ADR-066), v1.10 (sockaddr/sockopt libc, ADR-070/071), v1.11 (additifs cumulés libc/std — chroot/killpg/sigaltstack/sendfile/fchmod/fchown/futimens/munmap_raw, ADR-085) et v1.12 le 2026-07-10 (raw_syscall, escape hatch syscall générique, exception temporaire à retirer, ADR-087, jalon M5). Code complet, plus d’évolution hors RFC (descellement additif).
• Couche 1 — cœur livré : air-base-lib (cœur + services), air-crypto, air-socket, air-filesystem, air-memory, air-device, air-thread, air-process, air-config, air-stdio, air-runtime, temps, i18n no_std (icu4x, ADR-059), futex maison, loom (ADR-058).
• Couche 1 — SCELLÉE couche-1-v1.0 (2026-07-03, ADR-062) : campagne close. Audits pré-sceau face-libc (#212) / face-PAL (#213) ; les 4 P0 — AirFile (#214), air-poll (#215), termios/PTY (#216), air-signal (#217) ; remodel os_str env/args pré-sceau (#218) ; doctrines gravées ADR-063 (instrumentation IO) + ADR-064 (signaux, dont §7 barrière de poison). Re-scellée additivement jusqu’à couche-1-v1.9 (v1.1 errno_location ADR-065 ; v1.2 signaux/futex ADR-066 ; v1.3 air-account ADR-067 ; v1.4/v1.5 credentials + drop_to_user ADR-068 ; v1.6 air-handle + moteur socket ADR-069 ; v1.7 Managers de domaine ADR-077 ; v1.8 spawn_process socle posix_spawn ; v1.9 introspection thread cible ADR-086, jalon M5). Earmark ADR-078 crypto air-tls → v1.10.
• 🎉 Jalon M5 — std tourne sur Air, zéro glibc (2026-07-10). Un programme Rust std (hello-std, static-PIE) lié intégralement contre libair (la libc d’Air, sans glibc) s’exécute on-target sur les 2 arches (hello from std on air + exit 0 sur x86_64-air/carbon ET aarch64-air/raspi). Le lien passe de 12 → 0 symboles indéfinis (5 PR #308–#314 : __xpg_strerror_r, open/fcntl, introspection thread [ADR-086], getauxval/pthread_self/détection-pile, TLS keys, syscall générique [ADR-087]). Le pari ADR-076 (std sur la libc d’Air) est tenu de bout en bout : toolchain Rust full-Air prouvée. Re-sceaux couche-0-v1.12 + couche-1-v1.9.

5. Dettes connues (à planifier, non bloquantes pour le sceau)

• 🔧 Escape hatch syscall/raw_syscall (ADR-087) — à RETIRER avec l’équipe Rust. Le pal std de *-linux-air appelle quelques syscalls (gettid, futex…) via la fonction C générique syscall, ce qui a imposé un raw_syscall en couche 0 (entorse assumée à ADR-021 conv. 3 + à la règle « libc bind couche 1 »). Dette explicite : travailler avec l’équipe Rust pour que le pal std sur Air se passe du syscall générique (chaque op via son wrapper typé), puis retirer raw_syscall de la couche 0.
• 🔧 GlobalAlloc safe (air-alloc) — à RENDRE safe avec l’équipe libs Rust. Doctrine fondatrice : le unsafe doit vivre en couche 0 uniquement (barrière kernel) ; l’impl de GlobalAlloc par air-alloc (couche 1) reste unsafe par le trait. But = supprimer ce unsafe dans le cas d’Air (action item amont teams libs Rust), même registre que raw_syscall. Voir la doctrine unsafe (macro-architecture, Section 1/2/8).
• Lane CI nightly hello-std/rt à monter : le harnais M5 (rt/, hors-arbre) n’est pas encore construit/exécuté en CI. Leçon gravée : jamais différer les runs raspi.
• Gates de couverture couche 1 : cargo xtask couvrable-vide/audit-exceptions ne réconcilient mécaniquement que crates/air-sys-* (couche 0). Les crates couche 1 documentent leurs exceptions STRUCTURAL in-code. Étendre les gates à la couche 1 bute sur une collision de basename (time.rs couche 0 ET couche 1) → décision de design de gate (RFC/tâche séparée).
• mdBook non pinné — à figer pour la reproductibilité (ADR-025).
• air-doc-publish.sh vit hors dépôt (speedy) — à éventuellement versionner sous tools/.
• Instrumentation IO (ADR-063) : décidée, à implémenter en additif v1.x.
• Flake préexistant air-libc-stdio (révélé sous cargo test --workspace en forte charge, taux faible) : des tests inspectant errno après échec (fputs_null_and_write_on_readonly, close_reports_backend_error) échouent par intermittence — course probable sur l’état global (registre FILE) entre tests parallèles, bien qu’errno soit thread_local. Hors périmètre M3 (crate non modifiée). À corriger séparément (sérialiser ces tests).

Ce document se met à jour à la main au fil des merges. Pour l’historique fin (session par session, PR par PR), voir JOURNAL.md.

Roadmap — clôture de la couche 1 pour la libc C et le PAL Rust

✅ PLAN ACCOMPLI (2026-07-10) — ce document est désormais HISTORIQUE. La couche 1 a été scellée couche-1-v1.0 le 2026-07-03 (ADR-062) puis re-scellée additivement jusqu’à couche-1-v1.9 (v1.1→v1.9 : errno_location, signaux/futex, air-account, credentials/drop_to_user, air-handle+moteur socket, Managers de domaine, spawn_process, introspection thread cible). Ses deux toits sont prouvés : la libc C-ABI (~256 symboles) et le PAL Rust — std lie et tourne sur la libc d’Air, zéro glibc, 2 arches (jalon M5 atteint). Ce document décrit le plan d’origine ; le statut vivant est dans etat-avancement.md, et la prochaine phase = air-sshd (ADR-074). Le tableau de bord §8 ci-dessous reflète l’état au moment du plan, pas l’état courant.

Plan détaillé §-numéroté (les specs/audits y renvoient via « §5.3 P0.x »). Le statut vivant (ce qui est fait/en cours/à venir) est tenu dans le document de suivi etat-avancement.md, pas ici — ce document décrit le plan, le tableau de bord §8 en donne l’ossature.

But. Faire une passe de production complète de la couche 1 avant de la sceller (couche-1-v1.0), plutôt que sceller/desceller au fil de l’eau comme on l’a subi sur la couche 0. On n’éliminera pas tout descellement futur — on transforme les descellements structurels (« il manque une brique entière ») en descellements additifs mineurs (« il manque une fonction dans une brique existante »).

Principe directeur. La couche 1 a deux toits qui s’y assoient — la libc C-ABI (ADR-046/047/053) et le PAL Rust (la std cible *-linux-air, ADR-049/052). Seule la couche 1 consomme la couche 0 (ADR-052) : les deux toits sont au-dessus, clients, jamais dedans. Chaque brique de cette roadmap doit répondre à « quelle fonction libc et/ou quelle primitive PAL la réclame ? » — sinon elle attend. La complétude est pilotée par la demande des deux consommateurs, pas par une exhaustivité abstraite.

Sources. Inventaire couche 1 (crates + specs docs/specs/layer-1/), docs/notes/audits/RAPPORT-CONSOLIDE-libc-fr.md (41 familles musl), ADR-046/047/053 (libc), docs/notes/audit-icu4x-rust-pur-fr.md (i18n), ADR-049/052/055/056 (PAL/runtime). Statut de départ : main = 2689d69.

Légende

• ☐ à faire · ◐ partiel/en cours · ☑ fait
• Criticité : 🔴 bi-consommateur (libc ET PAL — rigueur maximale, dette figée si erreur) · 🟠 mono-libc · 🟡 mono-PAL · ⚪ interne/packaging
• Colonnes Libc / Pal : ● consommateur direct · ○ indirect · — non concerné

1. Ce qui est DÉJÀ en place (socle acquis)

Ne pas refaire ; à auditer face-libc/face-PAL avant le sceau (§5).

¹ air-crypto/air-base-lib tirent encore des deps qui bloquent le no_std strict → visés par §2.

Bi-consommateurs déjà acquis (🔴 mais faits) : air-alloc, air-env, air-crypto::AirRandom, air-process, air-socket, air-runtime (TCB/TLS). Ils restent sacrés : toute évolution passe par RFC une fois scellés.

2. Chantiers RESTANTS — bi-consommateurs 🔴 (rigueur maximale, chemin critique)

Ce sont les briques qui portent le plus de risque : une erreur d’API casse les deux toits, et la garantie ABI libc (10 ans, Principe 8) fige la dette.

2.A — i18n : Air utilise icu4x (Option V, ADR-059) 🔴 · L● P●

Sert la libc (ctype, locale, collation, strcoll, normalisation, segmentation, calendriers) et le PAL/str (to_uppercase, normalisation, comparaison Unicode). Brique sensible — mais plus le long pole.

DÉCISION BDFL (ADR-059, data-backée). Vérification empirique faite : la fermeture icu4x compile pour *-linux-air (--release + default-features = false ; LSTM inclus, libm OK) — la réécriture du socle n’est pas nécessaire. Air utilise icu4x (extension exception ADR-016), possède l’API air-string dual-face + le pipeline de données (à terme). ⇒ le §2.A se réduit à un chantier no_std, pas une réimplémentation.

• ☑ 2.A.1 air-base-lib → #![no_std] — dernière crate cœur non-no_std. #![cfg_attr(not(test), no_std)] + extern crate alloc (posé #152, ADR-048 ; confirmé ici, fermeture icu prouvée on-target). Débloque la fermeture couche 1 complète (i18n comprise) pour la cible.
• ☑ 2.A.2 deps icu_* d’air-base-lib → default-features = false (coupe transitivement la feature std ; 6 lignes du [workspace.dependencies] racine). Fermeture (air-base-lib + icu + socle) prouvée compilable on-target x86_64/aarch64-unknown-linux-air en release (build-std=core,alloc) — le repli logging debug d’icu_provider est inactif en release.
• ☐ 2.A.3 air-string dual-face : ajouter la face C-ABI (libc) au-dessus de l’AirString existant (le moteur existe déjà via icu4x).
• ☐ 2.A.4 Re-sonder la fermeture couche 1 complète pour *-linux-air (post-no_std air-base-lib) — preuve on-target.
• ☐ 2.A.5 (optionnel/différé) pipeline datagen Air (host, réutilise le datagen icu4x sur sources CLDR/UCD) si Air veut maîtriser ses propres tables — compiled_data suffit pour démarrer.
• Abandonné (ADR-059) : vendoring des 6 utils, port du socle, port de calendrical_calculations — inutiles, icu4x compile tel quel. air-libm (☑) reste surface math Air publique mais n’est pas requis par icu (icu tire libm via core_maths).
• Segmentation LSTM incluse (décision BDFL) : fournie par icu_segmenter feature auto — compile déjà pour la cible (prouvé).

2.B — air-thread en no_std + futex maison 🔴 · L● P●

Sert pthread_mutex/rwlock/cond (libc) et std::sync + std::thread (PAL). C’est aussi la zone non-déterministe discutée pour l’instrumentation (loom).

• ☑ 2.B.1 Migrer AirMutex/AirRwLock/AirSemaphore du backend std::sync → futex maison DÉJÀ FAIT : la migration a eu lieu de facto au passage #![no_std] d’air-thread (#182, ADR-055) — sync.rs montre les 3 primitives sur air_sys_syscall::futex + AtomicU32, « aucune dépendance à std::sync ». (L’inventaire INDEX/etat-avancement était périmé sur ce point.)
• ☐ 2.B.2 Spawn Air-natif : closure boxée via air-alloc (☑) — retirer le std::thread conditionnel (cfg(not(target_env="air"))).
• ☐ 2.B.3 Couvrir les branches de contention de façon déterministe — voir §3 (loom) : à cadrer avant le sceau, car sceller fige la surface.

2.C — Temps (monotone + horloge murale) 🔴 · L● P●

clock_gettime/time/nanosleep/gmtime (libc) ↔ Instant/SystemTime (PAL).

• ◐ 2.C.1 Confirmer que AirInstant/AirSystemTime (base-lib core) couvrent monotone + mur + nanosleep, no_std-propres, et exposables aux deux faces. (Le calendaire au-dessus dépend de 2.A.3.)

2.D — air-stdio : brique stdio/console bas-niveau 🔴 · L● P●

FILE* (libc) ↔ std::io::{Stdin,Stdout,Stderr} (PAL). Le niveau brut (handles fd 0/1/2 + isatty + verrou) est partagé ; le moteur FILE* bufferisé et printf/scanf restent libc (§4). Aujourd’hui non spécifié côté PAL (rapport PAL : « stdio bas-niveau MANQUE »).

• ☐ 2.D.1 Créer air-stdio (brique dédiée, décision BDFL) : handles standard partagés (lecture/écriture brutes, isatty, verrou par flux, sécurité atfork), no_std, consommée par les deux toits.
• ☐ 2.D.2 air-filesystem prend une dépendance sur air-stdio (décision BDFL) — les E/S de plus haut niveau s’appuient sur les handles standard.

2.E — Finitions des briques acquises 🔴/🟠

• ☐ 2.E.1 air-memory : backing mmap (différé) — piles/TLS des threads spawn.
• ◐ 2.E.2 air-crypto : rendre no_std-strict (auditer les deps qui bloquent). FAIT : default-features = false sur sha2/sha3/aes-gcm/chacha20poly1305/ argon2/ed25519-dalek (coupe la fuite std transitive ; features réactivées = strict nécessaire, aléa toujours via AirRandom couche 0). Preuve on-target x86_64-unknown-linux-air (release, build-std=core,alloc) : fermeture crypto entière no_std, zéro libc/std. Reste (chantier dédié) : sur aarch64, cpufeatures (dép non-optionnelle, détection ARMv8) lie libc (getauxval) qui n’a pas de profil env=air → chemin libc-free air_auxval(AT_HWCAP) à fournir. Détail : crates/air-crypto/DEPENDENCIES.md.

3. Étude PRÉ-SCEAU — instrumentation déterministe (à trancher avant §5)

Non une brique livrée : un outillage test-only à cadrer avant le sceau (le sceau fige la surface, autant avoir les seams dans la bonne forme). Détail en mémoire projet ; motivé par la variance de couverture (plancher 96→94, #189) et par la testabilité de contrats libc.

• ☑ 3.1 loom — déterminisme de concurrence. FAIT (ADR-058) : gouvernance gravée + harnais (alias d’atomique core/loom + shim futex yield/no-op). Tous les verrous futex de couche 1 modélisés : air-thread AirMutex/AirRwLock/AirSemaphore (5 modèles) + le Mutex d’air-alloc + le StreamLock (verrou par flux) d’air-stdio — 7 modèles verts, exécutés en CI par un job loom dédié (--cfg loom, --locked). Plancher couverture lignes remonté 94→96 sur mesure empirique (5 passes : 96.65–96.66 %, variance 0.01 % ⇒ #189 annulé, filet resserré). Cargo.lock complété (arêtes loom, repro ADR-025). Garde-fou : loom = sûreté ; vivacité validée on-target.
• ☐ 3.2 air-fault (nom proposé ; pas air-debug, réservé au LIB_AIR_DEBUG runtime) — injection de fautes syscall (EINTR, EFAULT, mmap/malloc échoue au N-ième). Rend testables des contrats aujourd’hui quasi-intestables : ADR-021 « EINTR remonté à l’appelant », vision « malloc échoue plutôt que hang ». Seam cfg-gated à la frontière L1→L0, zéro coût prod.
• Garde-fou non négociable : le selftest on-target (rt/, 2 arches) reste juge de la réalité. L’instrumentation monte le % de couverture ; elle ne remplace jamais la preuve on-target (piège du mock — fatal pour un projet « fait ce qu’il dit »).

4. Chantiers RESTANTS — mono-toit (importants, moins « sacrés »)

Rigueur normale couche 1 (100 % couverture), mais un seul consommateur → une erreur ne casse qu’un toit.

4-K (détail) — air-runtime async io_uring, dans la passe

Spec docs/specs/layer-1/air-runtime.md (v1.0 validée BDFL), non implémentée. Objet couche 1 : consomme air-sys-syscall (io_uring) directement (il EST couche 1).

• ☐ 4-K.1 air-runtime-core : exécuteur mono-thread, Task/spawn/block_on, réacteur.
• ☐ 4-K.2 air-runtime-io : futures sur complétions, AirIoBuf (modèle buffers possédés, décision centrale de la spec), enregistrement fd.
• ☐ 4-K.3 air-runtime-time : sleep/timeout/intervalle.
• ☐ 4-K.4 air-runtime-signal : signaux async via signalfd (ADR-020).
• ☐ 4-K.5 air-runtime-sync : AirAsyncMutex, AirNotify, channel async.
• ☐ 4-K.6 Mode multi-cœur : thread-per-core via msg_ring (peut suivre en v1.x additif si besoin).

Note de cohérence. L’async ne sert pas d’assise à la libc/PAL, mais le BDFL a tranché de le produire et le sceller dans la même passe que le reste — le sceau couche-1-v1.0 couvre toute la couche 1, pas seulement le sous-ensemble face-libc/face-PAL.

5. Porte de SCEAU — couche-1-v1.0

Après §2 (et le mono-toit §4 requis par le périmètre v1), avant de construire la libc et le PAL au-dessus :

• ☐ 5.1 Audit face-libc : rejouer les 41 familles musl contre l’inventaire couche 1 — chaque fonction du périmètre v1 (ADR-046 : ~25-30 familles, cible OpenSSH) a-t-elle sa brique ? (completeness critic)
• ✅ 5.2 Audit face-PAL (fait, docs/notes/audit-face-pal-cloture-fr.md) : ZÉRO gap fondateur ; les manques (Condvar/Once/dtors TLS/env-mutation/os_str) livrés en chantier A du PAL. Toit std en cours (chantier B, option A, ADR-076) : std compile sur la libc d’Air.
• ☐ 5.3 Combler les manques additifs remontés par 5.1/5.2. (L’async §4-K est inclus dans la surface scellée mais n’a pas d’audit « face-toit » — ses consommateurs sont couche 2+.)
• ☐ 5.4 Sceller : figer l’API Rust couche 1 en couche-1-v1.0 (RFC). ⚠️ Sceau couche 1 = API Rust ; la C-ABI vit au-dessus (crate libc/air-base-capi) avec son propre régime de stabilité (zones air-stable). Sceau couche 1 ≠ figer les signatures C.
• Modèle de re-sceau (précédent couche 0, ADR-051) : les manques futurs se traitent en descellement additif v1.x (jalons antérieurs conservés), pas en refonte. On accepte qu’il y en aura — moins souvent que sur la couche 0.

6. Hors périmètre de ce sceau (à ne pas confondre)

• libc C-ABI (ADR-046/047) et PAL std::sys (ADR-049 phase 3) : ce sont les toits, construits sur la couche 1 scellée — hors de cette roadmap (qui prépare leur assise).
• (NB : l’air-runtime async, un temps envisagé hors passe, est finalement inclus dans le sceau — cf. §4-K, décision BDFL.)
• Familles libc différées post-v1 (ADR-046 D7) : aio, ipc SysV, mq, ldso/dlopen, wordexp/glob (rejetés — RCE/injection).

7. Ordre d’exécution proposé (topologique)

1. §3.1 loom (parallèle, faible risque) — stabilise la couverture avant tout figeage.
2. §2.B air-thread no_std + futex — brique de synchro fondatrice ; débloque le spawn Air-natif (adosse air-alloc ☑).
3. §2.C temps + §2.D air-stdio + §2.E finitions — petits, parallélisables.
4. §2.A i18n Rust-pur — le long pole : 2.A.1 → 2.A.2 → 2.A.3/2.A.4 → 2.A.5 → 2.A.6 (LSTM). Peut avancer en parallèle des petits chantiers.
5. §4-K air-runtime async — track parallèle indépendant (ne dépend ni de la libc ni du PAL) ; peut démarrer tôt et avancer en fond.
6. §4 mono-toit (F/G/H) — une fois le cœur stable ; parallélisables. 4-I regex différé post-sceau (crate additive).
7. §5 audits face-libc/face-PAL (completeness critic) → sceau couche-1-v1.0 (couvre toute la couche 1, async inclus).
8. Au-dessus du sceau : §4-J (ABI C), puis libc C-ABI et PAL std::sys ; puis §4-I regex (additif).

8. Tableau de bord (à cocher au fil des PR)

Roadmap — libc C-ABI scopée OpenSSH (sur la couche 1 scellée)

✅ STATUT 2026-07-10 — M0–M4 livrés ; JALON M5 (toolchain std-sur-Air) ATTEINT. La libc C-ABI compte ~256 symboles (Rust pur) ; std lie et tourne contre libair (zéro glibc), hello-std s’exécute on-target 2 arches (hello from std on air

• exit 0) — la toolchain Rust full-Air est prouvée (ADR-076).

⚠️ Recadrage BDFL (2026-07-10) — le jalon « compiler OpenSSH réel » est RETIRÉ. Cette roadmap a rempli son rôle : compiler OpenSSH n’était qu’une fonction de forçage (le consommateur C le plus exigeant, pour piloter la libc et révéler les additifs couche 1). Elle a donné une libc C-ABI de ~256 symboles et une toolchain std prouvée. On ne vise pas à faire tourner le C d’OpenSSH upstream sur Air. La vraie cible = air-sshd, notre serveur SSH full Rust (async io_uring, wire-compat OpenSSH, conf binaire — ADR-074). Le §6 « M5 — OpenSSH » ci-dessous est conservé comme historique ; la production courante passe à air-sshd. Statut vivant : etat-avancement.md.

But. Produire la libc C-ABI d’Air, bornée à ce dont OpenSSH a besoin (ADR-046/047), comme toit sur la couche 1 scellée (couche-1-v1.0, re-scellée additivement jusqu’à couche-1-v1.9). Jalon final = sshd + ssh configurent, linkent et tournent sur Air. La libc sert de spec-de-certitude pour le PAL (std::sys) et de driver pour révéler les additifs v1.x de la couche 1.

Ordre stratégique (décision BDFL) : libc d’abord (consommateur le plus exigeant, sur-ensemble des besoins du PAL) → PAL ensuite (sous-ensemble + delta Rust) → ABI C air_* (riche/sécure/hors-normes) en couronnement.

Priorité de production, dans cet ordre : SÉCURITÉ > QUALITÉ > PERFORMANCE (Principe 5 : sur-sécuriser puis mesurer, jamais l’inverse).

1. Périmètre & non-buts

• Cible unique : OpenSSH (sshd + ssh + ssh-keygen/agent). Rien de plus.
• Familles dans le scope (ADR-046, ~25-30) : crt/startup, errno, stdio (FILE*), string/mem, stdlib (malloc/exit/getenv/qsort…), unistd/fcntl, stat/dirent, signal, pthread, network (socket/getaddrinfo), time, termios/pty, pwd/grp/shadow, setjmp/longjmp, misc (getopt/realpath/getpass/openpty/syslog/basename).
• Non-buts (hors scope, différés) : locale complète (minimum vital seulement), printf/scanf exotiques (positions %n$, locale numérique), aio, IPC SysV, mq, dlopen/ldso, wordexp/glob (rejetés RCE, ADR-046 D7), NSS/pam, iconv large. Ajoutés additivement si un besoin OpenSSH réel émerge.
• Kernel = bible, pas POSIX : conformité fonctionnelle (SHOULD→MUST), pas conformité de certification. Voir §3.

2. Architecture

• Rust-first, shim mince. Chaque symbole libc = un #[no_mangle] pub extern "C" fin au-dessus d’une brique couche 1 scellée (dual-face : la brique Rust est conçue 1 fois, consommée par la libc et le PAL). L’unsafe/FFI est assumé côté frontière C (C n’a pas de sûreté) ; l’implémentation derrière reste des appels couche 1 sûrs.
• Structure de crates (à figer en M0, sur le modèle air-base-capi) : des crates *-capi par famille (ex. air-stdio-capi, air-posix-io-capi…) agrégées en l’artefact final libc (.so + .a) + objets crt1.o/crti.o/crtn.o.
• Architecture « logique mesurée / shims C-ABI exclus » (gravée dès M1-b, étendue M1-c) — le POURQUOI : nos symboles #[no_mangle] extern "C" (malloc, memcpy, fwrite…) surchargent les symboles du runtime de couverture LLVM et de l’allocateur du harnais ⇒ l’écriture du profil llvm-cov échoue (crate à 0 %). Règle absolue : une crate dont on veut MESURER la couverture ne lie AUCUNE crate exportant un symbole libc #[no_mangle] (ni sien, ni transitif). On scinde donc : la LOGIQUE pure (politique d’allocation, moteur format, FILE* bufferisé, atexit/getenv…) vit dans des crates sans #[no_mangle], donc mesurées à ~100 % (air-libc-fmt, air-libc-alloc, air-libc-stdio, air-libc-stdlib, …) ; les shims #[no_mangle] extern "C" minces qui délèguent vivent dans air-libc-capi (exclus du gate de couverture, --ignore-filename- regex). Les shims divergents (exit/abort/_Exit -> !) y vivent aussi (insondables par un test du gate, comme air-process/src/exit.rs).
• crt / startup : _start→__libc_start_main→main, câblé sur air_runtime::start::bootstrap (déjà prouvé on-target, selftest exit 42) : TLS, environ/argv/envp, atexit, errno #[thread_local].
• errno : per-thread via air-runtime (déjà en place). Zéro globale libc (vision Air) ; errno in-band, pas d’état caché.
• FILE* : struct C de la couche libc (au-dessus de la couche 1), bufferisée (_IOFBF/_IOLBF/_IONBF), enveloppant un AirFile/air-stdio (fd) + tampon + orientation + flags error/eof + verrou (flockfile). La couche 1 reste sans tampon ; toute la bufferisation vit ici.
• sigaction : au-dessus d’air-signal. Sur les fautes synchrones : fourni mais INERTE (compile, réussit, handler jamais appelé, coredump toujours — ADR-064 §2). Signaux asynchrones : émulés via signalfd + drainage (ou sigaction réel non- faute, décision M3).

3. Doctrine de conformité (rigueur exigée)

Chaque symbole porte, dans sa doc (§4), une étiquette de conformité :

• Registre central : docs/libc-conformance.md — table symbole → étiquette → (déviation/justification/ADR). Vérifié en CI (chaque symbole exporté a une étiquette).
• Cas phares à tracer : sigaction/signal inertes sur fautes (NON-POSIX-DÉLIBÉRÉ, ADR-064) ; free/air_free (POSIX void vs AIR-EXT int) ; toute fonction qui refuse une troncature muette (POSIX-PARTIEL, ADR-032).

4. Documentation — 3 sorties depuis UNE source

Source de vérité unique : les blocs de doc sur les extern "C" Rust (///), incluant l’étiquette de conformité (§3) et le POURQUOI (transparence Air : dire ce qu’on fait, les pièges, les alternatives — pas que la signature).

1. Rust : rustdoc natif sur les fonctions FFI.
2. Doxygen : le header C committé (.h, déjà discipliné en CI — gate « header ABI C ≟ committé ») porte les commentaires doxygen /** */, miroir de la doc Rust (mêmes étiquettes). Doxygen → HTML + XML.
3. man (3ᵉ format) : dérivé de doxygen — GENERATE_MAN = YES produit les pages man(3) depuis la même source doxygen. → Oui, le 3ᵉ format est produisible depuis les deux premiers (précisément : depuis la source doxygen).

• Cohérence outillée : un gate CI vérifie Rust-doc ↔ header ↔ étiquettes (extension du gate header ABI C committé existant). Aucune dérive silencieuse.
• Pinning (ADR-025) : version de doxygen figée (reproductibilité).

5. Règles de production (intégralement respectées, dans l’ordre)

① SÉCURITÉ. Zéro UB ; toute donnée externe parsée (format de printf/scanf, getaddrinfo, strtol…) est bornée + fuzzée (cargo-fuzz). Pas de troncature muette (ADR-032). Les tables d’état couche 1 (handles/allocs) alimentent la traçabilité (vision instrumentable, ADR-063 en debug). Frontière C = unsafe assumé et localisé ; implémentation derrière = couche 1 sûre. ② QUALITÉ. cargo xtask barrier vert ; couverture (100 % lignes sur la logique Rust ; les shims triviaux couverts par les tests de conformité fonctionnels + harnais C réels) ; tests de conformité ABI (ADR-012 : air-abi-check/air-symver sur les symboles exportés) ; corpus de vecteurs (ex. printf contre une référence). Zéro Co-Authored-By ; DCO + signature. ③ PERFORMANCE. Après sécurité + qualité (Principe 5) : mesurer (chemins chauds = memcpy/stdio/malloc), justifier par écrit toute optimisation qui allège une défense, garantir l’invariant par construction. Cible matériel modeste (Pi 4).

6. Jalons (topologiques — chacun testable, additif, PR par PR)

• M0 — Fondations. ☑ fait. Structure de crates *-capi + conventions ABI-C figées ; pipeline doc (rustdoc + doxygen + man) câblé + gate cohérence ; crt (crt1/i/n sur air-runtime::bootstrap) + errno ; libc-conformance.md initialisé. Test : int main(){return 42;} C linke sur la libc Air et sort 42 on-target.
• M1 — stdio + string/mem + stdlib cœur. FILE* bufferisé sur air-stdio/AirFile (fopen/fclose/fread/fwrite/fflush/setvbuf/fgets/fputs), moteur vfprintf fuzzé, malloc/free/calloc/realloc (sur air-alloc), str*/mem*, exit/ atexit/abort, getenv/setenv (sur air-env). **Test : printf hello-world C
  • une poignée de programmes C réels.** Découpé en tranches PR : M1-a string/mem ☑, M1-b malloc + moteur de format fuzzé ☑, M1-c FILE*+exit/atexit/getenv ☑, M1-d frontière variadique printf (option A : shim C va_arg + glue Rust mesurée air-libc-printf + hello-world C) ☑.
  • Frontière variadique printf — décision BDFL : option (A). Rust-stable ne peut définir une fonction C variadique (c_variadic = nightly), or la libc doit rester sur stable (ADR-025, barrier, couverture). Retenu : parseur + moteur de format 100 % Rust fuzzé (surface d’attaque N°1 en Rust) + un shim C mince faisant le seul va_arg mécanique (piloté par le plan d’args du parseur, puis re-délègue au moteur Rust). C’est la 1ʳᵉ exception nommée à « zéro C » — minimale, sans logique ni surface d’attaque, justifiée par l’impossibilité c_variadic sur stable. À consigner dans docs/EXCEPTIONS.md + le registre de conformité à l’impl (M1-d).
• M2 — I/O fichier & métadonnées. ☑ fait (validé). open/ openat/creat/read/write/close/lseek/pread/pwrite/dup/dup2/dup3/fcntl/pipe/pipe2 (sur couche 0, FD brut, EINTR remonté, O_CLOEXEC POSIX rétabli), stat/fstat/ lstat/fstatat/access/faccessat (struct stat ABI Air), opendir/fdopendir/ readdir/closedir/rewinddir (DIR opaque + struct dirent, parseur getdents64 fuzzé), mkstemp/mkdtemp (entropie kernel), realpath (sur canonicalize), getcwd/chdir/fchdir. Architecture : logique mesurée air-libc-fileio + shims air-libc-capi::fileio + shim C variadique fileio_shim.c (open/openat/ fcntl, option A — même exception « zéro C » que printf). Déviations gravées D-M2.1..D-M2.5 (cf. libc-conformance.md). Test : I/O fichier + parcours de répertoire (round-trips réels + fuzz fuzz_libc_dirent).
• M3 — signaux & threads. ☑ fait. sigaction/signal (inertes sur fautes, ADR-064), sigprocmask/kill/raise/sigsuspend (sur air-signal) ; pthread_* (create/ join/mutex/cond/rwlock/once/key+dtor, sur air-thread+TLS). Test : threading + signaux non-faute drainés ; faute → coredump, handler ignoré.
• M4 — réseau, temps, tty, comptes, setjmp, misc. ☑ fait. socket/bind/connect/listen/ accept/send/recv/getaddrinfo/getnameinfo/inet_pton (sur air-socket) ; time/ clock_gettime/nanosleep/gmtime/strftime ; tcgetattr/tcsetattr/cfmakeraw/openpty (sur air-terminal) ; getpwnam/getpwuid/getgrnam (backends /etc air-config) ; setjmp/longjmp (îlot asm, ADR-047 §4-H) ; getopt/getpass/syslog/basename.
• M5 — OpenSSH. RETIRÉ (recadrage BDFL 2026-07-10) — conservé comme historique. L’intention d’origine : fournir les headers manquants, compiler OpenSSH upstream contre la libc Air, combler les manques révélés. Cette étape est abandonnée en tant que jalon : compiler OpenSSH n’était qu’une fonction de forçage (elle a rempli son rôle — libc ~256 symboles + toolchain std). Remplacée par air-sshd : notre serveur SSH full Rust (async io_uring, wire-compat OpenSSH, conf binaire — ADR-074). Le jalon « toolchain std-sur-Air » (M5 au sens du suivi) est, lui, ATTEINT (cf. bandeau). Les manques libc éventuels révélés par air-sshd restent traités par descellement additif v1.x documenté.

(Chaque jalon = une ou plusieurs PR ; barrier vert + conformité + doc + coverage avant merge. Chaque additif couche 1 révélé est traité par RFC additif.)

7. Points de cohabitation avec le PAL (à capturer au fil de l’eau)

Dans un process mixte Rust(PAL)+C(libc), à documenter dès qu’un jalon les touche : allocateur partagé (air-alloc sous les deux) · errno cohérent (per-thread air-runtime) · TLS (un seul modèle) · fd 0/1/2 (bufferisation FILE* vs stdio du PAL) · délivrance des signaux (un seul régime). Ces notes deviennent la spec de certitude du PAL.

8. Rapport de fin de production (livrable exigé)

En fin de production (et à chaque jalon majeur mergé), un rapport détaillé :

• Choix faits + POURQUOI, famille par famille (dont structure de crates, modèle FILE*, errno, gestion signaux).
• Table de conformité consolidée (POSIX / POSIX-PARTIEL / NON-POSIX-DÉLIBÉRÉ / AIR-EXT) + journal des déviations (chacune justifiée + ADR).
• Additifs couche 1 v1.x déclenchés par la libc (descellements additifs).
• Notes de cohabitation PAL (§7).
• Mesures de performance (chemins chauds) + toute défense allégée justifiée.

9. Exécution autonome

Même boucle que la campagne de sceau : production déléguée claude -p headless (carbon/speedy), superviseur pilote git (branche/valide/barrier/PR/squash-merge/ re-vérif main+trailer) ; doc pure = commit direct main signé (worktree isolé) ; zéro Co-Authored-By. Pilotage autonome jalon par jalon ; rapport détaillé en fin de production (§8). Un seul acte réservé à autorisation BDFL explicite : si un choix structurant non prévu émerge (ex. un NON-POSIX-DÉLIBÉRÉ nouveau, ou un compromis sécurité), je le remonte avant de graver.

Registre de conformité — libc C-ABI d’Air

Registre central de la doctrine de conformité (roadmap roadmap-libc-openssh-fr.md §3). Chaque symbole exporté par la libc C-ABI d’Air y figure avec son étiquette de conformité, sa déviation éventuelle (listée + justifiée) et l’ADR de référence.

Source de vérité = le /// sur chaque extern "C" (roadmap §4). Ce fichier agrège ces étiquettes. Cohérence outillée : le test air-libc-capi/tests/conformance_labels.rs échoue si un symbole extern "C" défini dans air-libc-capi/src/ (errno, crt, shims malloc) n’a pas d’étiquette dans son /// ou n’apparaît pas ici. Les mem*/str* sont définis dans air-libc-strmem (ré-exportés par air_libc_capi::string) et y portent leurs étiquettes ; ils figurent au registre ci-dessous.

Mise à jour M2 (2026-07-04) : familles I/O fichier fd brut (fcntl.h/ unistd.h), métadonnées (sys/stat.h, struct stat ABI Air) et répertoires (dirent.h, DIR opaque) — logique mesurée air-libc-fileio, shims air-libc-capi::fileio, frontière variadique open/openat/fcntl via fileio_shim.c (option A, comme printf). Cf. section « M2 » et déviations D-M2.1..D-M2.5. Précédent :

Dernière mise à jour : 2026-07-04 (jalon M1-d — frontière variadique printf (option A) : famille printf/fprintf/sprintf/snprintf + v* via un mince shim C va_arg et la glue Rust mesurée air-libc-printf, au-dessus du moteur fuzzé air-libc-fmt ; sur M1-a/M1-b/M1-c). Architecture « logique / shims » étendue : logique stdio dans air-libc-stdio, exit/atexit/getenv dans air-libc-stdlib, glue printf dans air-libc-printf (crates mesurées) ; shims extern "C" minces dans air-libc-capi::{stdio,stdlib} (exclus du gate) ; 1ʳᵉ exception « zéro C » = le shim C va_arg (air-libc-c/csrc/printf_shim.c, cf. EXCEPTIONS.md). Six crates de logique libc mesurées : air-libc-fmt, air-libc-alloc, air-libc-stdio, air-libc-stdlib, air-libc-printf.

Taxonomie (roadmap §3)

M0 — Fondations (air-libc-capi) : errno + crt

Fonctions

Types

Constantes E* (numéros errno Linux)

Étiquette : POSIX (toutes). Valeurs conformes à asm-generic/errno{,-base}.h (identiques x86_64 / aarch64). Source de vérité unique = couche 0 (air_sys_types::Errno) : les #define du header sont des littéraux croisés-vérifiés contre la couche 0 (test errno_constants_match_layer0), jamais inventés. Périmètre M0 = les errno déjà ancrés en couche 0 ; d’autres seront ajoutés par famille (jalons M1+), au fil des besoins réels d’OpenSSH.

EPERM(1) · ENOENT(2) · ESRCH(3) · EINTR(4) · E2BIG(7) · ENOEXEC(8) · EBADF(9) · ECHILD(10) · EAGAIN(11) · EWOULDBLOCK(11, alias EAGAIN) · ENOMEM(12) · EACCES(13) · EFAULT(14) · EBUSY(16) · EEXIST(17) · EXDEV(18) · ENODEV(19) · ENOTDIR(20) · EINVAL(22) · ENFILE(23) · EMFILE(24) · ENOTTY(25) · ENOSPC(28) · ESPIPE(29) · EPIPE(32) · ERANGE(34) · ENOSYS(38) · ELOOP(40) · ETIME(62) · EPROTO(71) · EBADMSG(74) · EMSGSIZE(90) · EOPNOTSUPP(95) · ECONNRESET(104) · ENOBUFS(105) · ETIMEDOUT(110) · EALREADY(114) · ECANCELED(125).

Code vs artefact (air-libc-capi / air-libc-c, ADR-029)

Les symboles ci-dessus sont définis dans la crate de code air-libc-capi (rlib pur — leur source de vérité /// + header committé y vivent). L’artefact partagé libair_c.so est produit par la crate sœur air-libc-c (cdylib, host-only), qui ne définit aucun symbole propre : elle se contente de ré-exporter (pub use) et d’ancrer (#[used]) ceux d’air-libc-capi pour forcer leur export dans la .so. Aucune entrée de registre supplémentaire n’est donc requise pour air-libc-c (surface ABI identique, zéro symbole ajouté).

M1 — tranche string/mem (air-libc-strmem ; ré-export air-libc-capi::string)

Primitives mem*/str* sans allocation : #[no_mangle] extern "C" définis dans la crate air-libc-strmem (isolée pour porter #![no_builtins], cf. le split) et ré-exportés par le module air_libc_capi::string (chemin stable + visibilité cbindgen via parse.include/extra_bindings). Shims minces sur une logique sûre (tranches bornées / marches de pointeurs bornées par n, zéro indexation paniquante, zéro UB — roadmap §5.①). Toutes POSIX : mêmes valeurs de retour, mêmes pointeurs, comparaisons en unsigned char conformes à la norme. Aucune déviation de comportement ; la seule garantie plus forte (sûreté, non observable côté C) est le court-circuit n == 0 (pointeurs nuls tolérés là où from_raw_parts/copy de Rust exigent du non-nul) — pas une déviation POSIX. strdup (allocation) est différé à la tranche stdlib.

M1-b — famille malloc (logique air-libc-alloc ; shims air-libc-capi::malloc)

Famille allocation de stdlib.h. Split « logique / shims C-ABI » : la LOGIQUE (malloc_impl/free_impl/…) vit dans la crate air-libc-alloc (Rust pur, mesurée à 100 %, aucun symbole #[no_mangle]), au-dessus de l’arène globale scellée d’air-alloc (verrou futex, fusion O(1), échec ⇒ null déterministe, ADR-056) ; les shims extern "C" minces qui délèguent vivent dans air_libc_capi::malloc (exclus du gate de couverture, car leurs #[no_mangle] surchargent le runtime de couverture LLVM). La logique porte le modèle d’en-tête borné (placé devant chaque bloc) qui rend free/realloc possibles sans que le C repasse taille/alignement. Sécurité #1 (roadmap §5.①) : overflow calloc checked (checked_mul), zéro as lossy (try_from / checked_* partout), zéro double-free/UAF introduit (chaque bloc libéré une fois via son en-tête ; realloc recopie puis libère l’ancien après succès du neuf). strdup/strndup allouent ⇒ ici, pas dans string.

Moteur de format (crate air-libc-fmt — aucun symbole extern "C")

Le cœur du rendu printf ([air_libc_fmt], extrait dans sa propre crate pour être mesuré à 100 % par llvm-cov) est du Rust pur, sans unsafe, sans allocation, agnostique de la source des arguments (FormatArgs). Il n’exporte aucun symbole C (donc aucune entrée de registre requise, et rien à parser pour cbindgen) : le câblage variadique printf/snprintf/vfprintf (option A, extern "C", dans air-libc-capi) est le jalon M1-d. C’est LA surface d’attaque « format-string », isolée et fuzzée (cible fuzz_libc_format, cf. fuzz/). Invariants garantis par construction + prouvés au fuzz : zéro panic, zéro débordement du puits borné (snprintf-exact : écrit min(longueur théorique, capacité)), zéro boucle infinie/DoS (remplissages bornés par la capacité, compteur saturating_add), et %n REJETÉ — rendu littéral, aucun argument consommé, jamais une écriture mémoire (vecteur d’exploitation format-string classique neutralisé). Cf. déviation D-M1b.5 ci-dessous.

M1-c — stdio.h (FILE* bufferisé) : air-libc-stdio (logique) ; shims air-libc-capi::stdio

Famille stdio.h. Split « logique / shims C-ABI » : la LOGIQUE (FILE bufferisé, registre des flux, flush-at-exit) vit dans air-libc-stdio (Rust pur, mesurée, aucun symbole #[no_mangle]), au-dessus d’AirFile/air-stdio (couche 1) ; les shims extern "C" minces vivent dans air_libc_capi::stdio (exclus du gate). Bufferisation bloc/ligne/sans (_IOFBF/_IOLBF/_IONBF), verrou par-FILE (thread-safety POSIX, façon flockfile), boucle sur écriture courte + retry EINTR dans le toit (ADR-021 conv.2). Sécurité #1 : bornage strict des tampons (get/copy_from_slice, jamais d’indexation), zéro as lossy, overflow size*nmemb checked (fread/fwrite). Parseur de mode fopen fuzzé (fuzz_libc_stdio_mode) ; bufferisation fuzzée (fuzz_libc_stdio_buffer, backend mémoire).

Données (FILE *)

Constantes <stdio.h>

Étiquette POSIX (toutes, littéraux ABI standard) : EOF(-1) · SEEK_SET(0) · SEEK_CUR(1) · SEEK_END(2) · _IOFBF(0) · _IOLBF(1) · _IONBF(2) · BUFSIZ(8192).

M1-c — stdlib.h : exit/atexit/abort + getenv (air-libc-stdlib ; shims air-libc-capi::stdlib)

Split « logique / shims » : le registre atexit (borné), la séquence de nettoyage (perform_exit_cleanup) et le cache getenv vivent dans air-libc-stdlib (mesurée) ; les shims — dont exit/_Exit/_exit/abort qui divergent (-> !, insondables par le gate, comme air-process/src/exit.rs) — vivent dans air_libc_capi::stdlib. Séquence exit : handlers atexit (ordre inverse) → flush tous les FILE → air_process::exit_process.

M1-d — frontière variadique printf (shim C va_arg + glue air-libc-printf)

Famille printf (stdio.h). Décision BDFL — option (A) (roadmap §6) : Rust-stable ne peut pas définir de fonction C variadique (c_variadic = nightly). Retenu : parseur + moteur de rendu 100 % Rust fuzzé (air-libc-fmt, la surface d’attaque « format-string » N°1) + un mince shim C (air-libc-c/csrc/ printf_shim.c) faisant le seul va_arg mécanique. C’est la 1ʳᵉ exception nommée à « zéro C » (cf. docs/EXCEPTIONS.md).

Architecture. Le shim ne parse rien (zéro logique de format en C) : il (a) demande le plan des types d’args à la glue Rust mesurée air-libc-printf (air_fmt_arg_kinds), (b) fait le va_arg(ap, <type promu>) dicté par le plan, (c) re-délègue au moteur Rust (air_fmt_render_buf/_stream). Le plan et le rendu passent par le même parseur (air_libc_fmt::format) ⇒ zéro divergence. Sécurité #1 : %n rejeté (rendu littéral, aucun argument tiré, jamais d’écriture-arrière — cf. déviation D-M1b.6) ; puits snprintf borné (jamais de débordement) ; promotions C par défaut respectées. Fuzzé : moteur (fuzz_libc_format) et glue (fuzz_libc_printf). Preuve d’exécution : harnais hello-world C (air-libc-c/tests/hello_world.rs, « Hello, Air 42 »).

Symboles fournis par le shim C (déclarés dans air_c.h, exportés dans libair_c.so — nm -D) :

Conversions supportées (moteur M1-b) : d i u x X o c s p % ; drapeaux - + espace 0 # ; largeur/précision (dont */.*) ; longueurs hh h l ll z t j. Différés (hors scope) : flottants e f g a (rendus littéralement tant qu’air-libm n’est pas câblé — aucun argument tiré) ; positions %n$ ; locale numérique. %n : rejeté (NON-POSIX-DÉLIBÉRÉ, sécurité — cf. D-M1b.6).

Points d’entrée de support de la glue Rust (air-libc-printf, #[no_mangle], exportés dans libair_c.so mais hors ABI libc standard — consommés uniquement par le shim ; non scannés par conformance_labels, hors air-libc-capi/src) :

M2 — I/O fichier fd brut + métadonnées + répertoires (air-libc-fileio ; shims air-libc-capi::fileio)

Familles fcntl.h/unistd.h (fd brut), sys/stat.h (métadonnées) et dirent.h (répertoires). Split « logique / shims C-ABI » : la LOGIQUE (open_impl/read_impl/stat_impl/opendir_impl/readdir_impl/mkstemp_impl/…, le remplissage de la struct stat ABI Air, la bufferisation getdents64 derrière DIR) vit dans air-libc-fileio (Rust pur, mesurée, aucun symbole libc #[no_mangle] standard), au-dessus de la couche 0 (openat2/read/write/ pread/pwrite/close/lseek/statx/faccessat/getdents64/dup_fd/dup3/ pipe2/getrandom/getcwd/chdir) et de la couche 1 (canonicalize → realpath) ; les shims extern "C" minces vivent dans air_libc_capi::fileio (exclus du gate). Sécurité #1 : chemins via C-strings bornées (octets, zéro présomption UTF-8) ; buffers getdents64/readdir bornés (get, jamais d’indexation) ; zéro as lossy sur les champs stat (try_from/wrapping_shl) ; fd empruntés sans double-close.

Sémantique fd brut : le C gère la vie du fd (open rend un int désolidarisé, close reconstruit l’OwnedFd et le ferme une fois ; les autres empruntent). EINTR remonté (jamais de retry auto — ADR-021 conv.2). O_CLOEXEC : couche 0 le force toujours ; open/dup/dup2 effacent FD_CLOEXEC si l’appelant ne l’a pas demandé, rétablissant la sémantique POSIX (fd héritable par exec) — D-M2.1.

struct stat/dirent/DIR = ABI Air (largeur fixe, arch-indépendant, distinct de la glibc — comme FILE) : les programmes compilés contre air_c.h voient notre layout (D-M2.2). Le parseur getdents64 → dirent (données kernel externes) est fuzzé (fuzz_libc_dirent).

Fonctions non variadiques (shims air-libc-capi::fileio)