#!/usr/bin/env python3
"""Interface web locale pour gerer un inventaire Set-OPS."""

from __future__ import annotations

from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import argparse
import json
import os
import re
import secrets
import socket
import subprocess
import tempfile
import time
import threading
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from urllib.parse import urlparse

import yaml

import devis_reseau

from inventory_rules import instance_courante  # noqa: E402
from inventory_rules import (
    ecriture_atomique,
    GROUPE_HOTES_ACTIFS,
    GROUPE_HOTES_PLANIFIES,
    GROUPES_ETAT_HOTE,
    chaine_connexion,
    charger_applications,
    charger_bases_donnees,
    charger_dependances,
    charger_domaines,
    charger_nomenclature,
    charger_serveurs,
    est_groupe_operationnel,
    groupes_operationnels_connus,
    integrations_universelles,
    reconcilier_serveur,
    valider_applications,
    catalogue_liens,
    valider_bases,
    valider_domaines,
    valider_serveurs,
)

RACINE = Path(__file__).resolve().parents[1]
INSTANCE = instance_courante()


def _inventaire(instance: Path, *noms: str) -> Path:
    """Inventaire de l'instance, détection rétro-compatible (premier existant)."""
    for nom in noms:
        p = instance / "inventories" / nom / "hosts.yml"
        if p.exists():
            return p
    # Aucun hosts.yml encore généré : viser le répertoire d'inventaire déjà présent
    # (ses group_vars y sont), sinon le premier nom par défaut.
    for nom in noms:
        if (instance / "inventories" / nom).is_dir():
            return instance / "inventories" / nom / "hosts.yml"
    return instance / "inventories" / noms[0] / "hosts.yml"


# Un seul inventaire par instance (modèle « séparation par instance ») ; on accepte
# l'ancien découpage lab/production en rétro-compatibilité. SETOPS_INVENTAIRE force.
_force = os.environ.get("SETOPS_INVENTAIRE")
INVENTAIRE_DEFAUT = Path(_force) if _force else _inventaire(INSTANCE, "principal", "production")
INVENTAIRE_PRODUCTION = INVENTAIRE_DEFAUT.resolve()
# Inventaire qui porte la config Proxmox / le clonage (modèle) : lab > principal > production.
INVENTAIRE_MODELE = _inventaire(INSTANCE, "lab", "principal", "production")
DOSSIER_PLAYBOOKS_GROUPES = RACINE / "playbooks/groupes"
FICHIER_DEPENDANCES = RACINE / "docs/dependances-groupes.yml"
FICHIER_NOMENCLATURE = INSTANCE / "plan/nomenclature.yml"
FICHIER_BASES = INSTANCE / "plan/bases-donnees.yml"
FICHIER_APPLICATIONS = INSTANCE / "plan/applications.yml"
FICHIER_DOMAINES = INSTANCE / "plan/domaines.yml"
FICHIER_SERVEURS = INSTANCE / "plan/serveurs.yml"

# Intrants de base (panneau GUI). Cibles d'ecriture possedees par le GUI.
# Identite : group_vars/all/10-intrants.yml de l'inventaire. Selon l'instance c'est
# un fichier reel (modele « par instance ») ou un symlink vers une source partagee
# (ecrire suit le symlink). Proxmox : group_vars de l'inventaire modele. Les SECRETS
# n'y entrent jamais.
INTRANTS_IDENTITE = INVENTAIRE_DEFAUT.parent / "group_vars/all/10-intrants.yml"
INTRANTS_PROXMOX = INVENTAIRE_MODELE.parent / "group_vars/proxmox.yml"
# Le seed reseau (`index`) vit dans la nomenclature (le plan reseau) — d'ou tout
# l'adressage se derive. Le panneau Intrants le lit/ecrit la, chirurgicalement, sans
# reformater le fichier (cf. _ecrire_index_nomenclature).
# Frontiere nord/sud (OPNsense) : parametres NON sensibles du pare-feu de bordure.
# La cle/secret d'API n'y entrent JAMAIS — voute uniquement (cf. INTRANTS_CLES_INTERDITES).
# Fabric physique : `underlay.yml`, monte par symlink a la racine du moteur depuis le
# depot de l'HEBERGEUR (ses switches, ses cables). Distinct de l'instance : il ne suit
# pas `make instance-utiliser`. Imbrique sous `underlay:` et riche en commentaires :
# on l'ecrit chirurgicalement, jamais par un safe_dump qui les effacerait.
FICHIER_UNDERLAY = Path(os.environ.get("SETOPS_UNDERLAY") or (RACINE / "underlay.yml"))


def _depot_hebergeur() -> Path | None:
    """Depot de l'HEBERGEUR, derive du symlink `underlay.yml` qui le designe deja.

    Un hebergeur sert PLUSIEURS tenants et n'a qu'une frontiere : ses intrants ne
    peuvent pas vivre chez le tenant actif, sinon basculer sur un invite les ferait
    disparaitre du panneau. None si aucun underlay n'est monte.
    """
    if not FICHIER_UNDERLAY.exists():
        return None
    return FICHIER_UNDERLAY.resolve().parent


# --- CE QUE CETTE CONSOLE PEUT, DERIVE DE CE QUE SA MACHINE PORTE --------------------
#
# LE DEFAUT QUI A RENDU CECI NECESSAIRE (2026-09-16). Servie par le runner d'un SITE,
# cette console affichait ZERO serveur, ZERO application, ZERO base — sans une erreur.
# `serveur_ops` RETIRE le lien `instance` sur un runner d'hebergeur (a juste titre : un
# lien perime vers un tenant serait pire), `charger_yaml` rend `{"all": {"children": {}}}`
# sur un fichier absent, et la page dessinait ce vide comme un plan vide.
#
# C'est la forme exacte que P79 garde partout ailleurs : une derivation qui ne trouve rien
# ne se distingue pas d'une derivation qui n'a rien a trouver. Ici elle avait le pire
# visage possible — celui d'un ecosysteme qu'on croit sans machines.
#
# ON DERIVE, ON NE DECLARE PAS. Un `serveur_ops_gui_mode: site|tenant` au plan serait une
# SECONDE liste, et une liste qui suit une autre prend du retard : il suffirait de
# reconfigurer un runner sans y penser. Les deux symlinks, eux, SONT le pouvoir :
#
#   instance/      -> je configure CET ecosysteme (j'ai sa voute)
#   underlay.yml   -> je materialise sur CETTE fabric (j'ai celle du site)
#
# C'est la meme coupure que `roles/serveur_ops` exige deja dans son assertion, et que
# `docs/responsabilites-locataire-hebergeur.md` nomme : calculer, configurer, materialiser.

def contexte() -> dict:
    """La portee de cette console — DELEGUEE a la classe qui la sert.

    Ce que cette fonction faisait a la main vit desormais dans `Console` et ses deux
    branches. Elle reste parce que le harnais et les preuves l'appellent par ce nom, et
    parce qu'un appelant n'a pas a savoir laquelle des deux consoles lui repond.
    """
    return console().contexte()


def inventaire_du_site() -> dict:
    """Les machines du SITE, mises dans la forme d'un `hosts.yml`.

    L'inventaire d'un site est un SCRIPT (`site_inventaire.py`) : on l'EXECUTE — en
    l'important, sans sous-processus a chaque page — et l'on traduit son resultat dans la
    forme que le reste de ce fichier sait lire. Juger sa source reviendrait a relire le
    raisonnement au lieu du resultat.
    """
    import site_inventaire
    brut = site_inventaire.inventaire() or {}
    hostvars = ((brut.get("_meta") or {}).get("hostvars") or {})
    enfants_site: dict = {}
    for groupe, valeur in brut.items():
        if groupe == "_meta" or not isinstance(valeur, dict):
            continue
        hotes = valeur.get("hosts") or []
        if not hotes:
            continue
        enfants_site[groupe] = {"hosts": {h: dict(hostvars.get(h) or {}) for h in hotes}}
    return {"all": {"children": enfants_site}}


def sonder_donnees(data: dict) -> dict:
    """Meme sonde que `sonder_hotes`, sur un inventaire DEJA charge (le site)."""
    cibles = [(h.get("nom"), h.get("adresse_ip")) for h in liste_hotes(data)]
    with ThreadPoolExecutor(max_workers=16) as executeur:
        resultats = executeur.map(lambda c: (c[0], _joignable(c[1])), cibles)
    return {nom: ok for nom, ok in resultats if nom}


# CE QUE CHAQUE POINT D'ECRITURE EXIGE. Toute route POST y figure — P81 refuse qu'une
# route nouvelle echappe a la garde en silence, parce qu'une garde qui suit une liste
# prend du retard sur elle.
POUVOIR_REQUIS = {
    "/api/inventaire": "editer_le_plan",
    "/api/bases": "editer_le_plan",
    "/api/applications": "editer_le_plan",
    "/api/serveurs": "editer_le_plan",
    "/api/nomenclature": "editer_le_plan",
    "/api/domaines": "editer_le_plan",
    "/api/intrants": "editer_le_plan",
    "/api/instancier": "editer_le_plan",
    "/api/instance-creer": "editer_le_plan",
    "/api/instance-utiliser": "editer_le_plan",
    "/api/verifier": "configurer",
    "/api/deployer": "configurer",
    "/api/pousser": "configurer",
    "/api/creer": "materialiser",
    # LA GARDE DE CETTE ROUTE EST PLUS FINE QUE LES AUTRES, ET C'EST VOULU. Un runbook de
    # site et un runbook de locataire n'exigent pas le meme pouvoir : un seul mot ici
    # serait soit trop laxiste (un site lancerait un geste de locataire), soit trop
    # severe (un locataire ne pourrait plus rien). La portee est DECLAREE au registre,
    # et c'est elle qu'on resout — jamais celle que le navigateur annonce.
    "/api/runbook-etape": "selon-le-runbook",
}


# CE QU'UNE PORTEE DE RUNBOOK EXIGE DE LA CONSOLE. Les deux pouvoirs de `contexte()`, et
# rien d'autre : `poste` porte les deux liens, il doit donc les deux.
POUVOIR_PAR_PORTEE = {
    "tenant": ("configurer",),
    "site": ("materialiser",),
    "poste": ("configurer", "materialiser"),
    "toute": (),
}

# Ce qu'une valeur d'etape a le droit d'etre. Les commandes partent en LISTE (jamais par
# un shell), donc l'injection n'est pas le risque ; ce qui l'est, c'est qu'une valeur se
# fasse lire par `make` comme une option. On refuse donc ce qui commence par un tiret.
MOTIF_VALEUR = re.compile(r"^[^-\s][\w .@:/+=,-]{0,199}$", re.UNICODE)


def _fichier_frontiere() -> Path:
    """Les intrants de la frontiere — a la RACINE du depot de site depuis le 2026-08-22.

    La frontiere est un objet du MONDE PHYSIQUE : ses reglages vivent avec `underlay.yml`
    et `proxmox-hebergeur.yml`, pas dans les group_vars d'un tenant. Range chez un
    locataire, ce fichier a garde une adresse d'API perimee sans que personne la voie —
    et l'applicateur restait suspendu dessus, sans message.

    Les anciens emplacements restent lus, pour un site pas encore migre.
    """
    base = _depot_hebergeur()
    if base:
        racine = base / "opnsense.yml"
        if racine.is_file():
            return racine
        for nom in ("principal", "production", "lab"):
            p = base / "inventories" / nom / "group_vars" / "opnsense.yml"
            if p.is_file():
                return p
        return racine          # a creer la, pas ailleurs
    return INVENTAIRE_DEFAUT.parent / "group_vars/opnsense.yml"


def _fichier_proxmox_hebergeur() -> Path:
    """proxmox-hebergeur.yml de l'HEBERGEUR ; repli sur le proxmox.yml du tenant.

    Meme raisonnement que la frontiere et l'underlay (D-14) : un cluster appartient a
    l'hebergeur, pas au tenant qui y loge. Recopie chez chaque tenant, l'inventaire du
    cluster avait deja diverge — deux listes de stockages contradictoires pour le meme
    materiel. Le repli garde un depot sans underlay monte parfaitement utilisable.
    """
    base = _depot_hebergeur()
    if base:
        return base / "proxmox-hebergeur.yml"
    return INTRANTS_PROXMOX


INTRANTS_FRONTIERE = _fichier_frontiere()
INTRANTS_PROXMOX_HEBERGEUR = _fichier_proxmox_hebergeur()
FICHIERS_INTRANTS = {"identite": INTRANTS_IDENTITE, "proxmox": INTRANTS_PROXMOX,
                     "proxmox_hebergeur": INTRANTS_PROXMOX_HEBERGEUR,
                     "reseau": FICHIER_NOMENCLATURE, "frontiere": INTRANTS_FRONTIERE,
                     "fabric": FICHIER_UNDERLAY}

# Intrants de fabric -> chemin dans underlay.yml. Seules les valeurs PLATES sont ici :
# `reseaux` et `hotes` sont des listes de tables, hors de portee du panneau (cf. la vue
# dediee, a venir). Un intrant absent d'ici s'edite encore dans le YAML.
CHEMINS_UNDERLAY = {
    "underlay_routeur": ("routeur",),
    "underlay_dialecte": ("dialecte",),
    "underlay_stp_mode": ("stp", "mode"),
    "underlay_stp_topologie": ("stp", "topologie"),
}

# (variable, fichier, classe, section, libelle, type, proprietaire)
#
# `proprietaire` repond a une question que le panneau posait sans y repondre : en
# ouvrant l'ecran on trouvait, cote a cote et sans distinction, des valeurs du TENANT
# (son domaine, son realm, son modele) et des valeurs de l'HEBERGEUR (son cluster, sa
# frontiere, sa fabric). Ce sont deux proprietaires, deux depots, deux cycles de vie.
INTRANTS_SCHEMA = [
    ("index", "reseau", "constante", "Réseau", "Index d'instance dans la fédération (seed : dérive supernet 10.<index>, VLAN 1000+index×10+zone, VMID)", "int", "tenant"),
    ("domaine_interne", "identite", "constante", "Identité", "Domaine DNS interne", "str", "tenant"),
    ("fuseau_horaire", "identite", "defaut", "Identité", "Fuseau horaire", "str", "tenant"),
    ("organisation", "identite", "defaut", "Identité", "Organisation (annuaire LDAP, certificats)", "str", "tenant"),
    ("identite_realm", "identite", "defaut", "Identité", "Realm SSO (Keycloak)", "str", "tenant"),
    ("nftables_admin_ssh", "identite", "catalogue", "Sécurité", "Sources SSH d'administration toujours autorisées (garde anti-lockout du pare-feu)", "liste", "tenant"),
    ("proxmox_api_host", "proxmox_hebergeur", "constante", "Cluster", "Hôte API Proxmox", "str", "hebergeur"),
    ("proxmox_api_user", "proxmox_hebergeur", "constante", "Cluster", "Utilisateur API", "str", "hebergeur"),
    ("proxmox_api_port", "proxmox_hebergeur", "constante", "Cluster", "Port API", "str", "hebergeur"),
    ("proxmox_validate_certs", "proxmox_hebergeur", "constante", "Cluster", "Valider les certificats TLS", "bool", "hebergeur"),
    ("proxmox_clone_source_nom", "proxmox", "constante", "Proxmox", "Nom du golden template", "str", "tenant"),
    ("proxmox_clone_vmid_modele", "proxmox", "constante", "Proxmox", "VMID du golden template", "int", "tenant"),
    ("proxmox_clone_noeud", "proxmox", "defaut", "Proxmox", "Nœud Proxmox (défaut)", "str", "tenant"),
    ("proxmox_clone_stockage", "proxmox", "defaut", "Proxmox", "Stockage (défaut)", "str", "tenant"),
    # REPLI, pas un reglage de la flotte. Chaque VM du plan recoit le VNet DERIVE de sa
    # zone (`instancier` pose `proxmox_pont` par hote) ; cette valeur n'est consultee que
    # si l'hote n'en porte pas — c'est-a-dire jamais dans le flux normal. L'intitule le
    # dit, sans quoi on la corrige, on redeploie, et rien ne change : `vmbr3` y est reste
    # faux dix jours sans que rien ne bronche (2026-08-13).
    ("proxmox_clone_pont", "proxmox", "defaut", "Proxmox",
     "Pont réseau — clones manuels seulement (les VM du plan reçoivent le VNet de leur zone)",
     "str", "tenant"),
    ("proxmox_noeuds", "proxmox_hebergeur", "catalogue", "Cluster", "Nœuds disponibles (liste)", "liste", "hebergeur"),
    ("proxmox_stockages", "proxmox_hebergeur", "catalogue", "Cluster", "Stockages disponibles (liste)", "liste", "hebergeur"),
    ("proxmox_ponts", "proxmox_hebergeur", "catalogue", "Cluster", "Ponts réseau disponibles (liste)", "liste", "hebergeur"),
    ("opnsense_api_url", "frontiere", "constante", "Frontière", "URL de gestion de la frontière OPNsense (API REST)", "str", "hebergeur"),
    ("opnsense_api_verifier_certs", "frontiere", "defaut", "Frontière", "Valider le certificat TLS de la frontière", "bool", "hebergeur"),
    ("opnsense_wan_ip", "frontiere", "constante", "Frontière", "Adresse publique du WAN de la frontière (face Internet de l'écosystème)", "str", "hebergeur"),
    ("opnsense_if_wan", "frontiere", "defaut", "Frontière", "Interface WAN — IDENTIFIANT OPNsense (wan), pas le libellé ni le périphérique", "str", "hebergeur"),
    ("opnsense_if_transit", "frontiere", "defaut", "Frontière", "Interface de transit — IDENTIFIANT OPNsense (opt1, opt2…), pas « igb1 » ni le libellé affiché", "str", "hebergeur"),
    ("opnsense_if_gestion", "frontiere", "defaut", "Frontière", "Interface où arrivent les plans d'administration attachés à la frontière — IDENTIFIANT OPNsense (lan). Une règle SSH posée ailleurs ne peut jamais correspondre", "str", "hebergeur"),
    ("underlay_routeur", "fabric", "constante", "Fabric", "Switch qui porte le routage (SVI, ACL, routes) — les autres restent en L2 pur", "str", "hebergeur"),
    ("underlay_dialecte", "fabric", "constante", "Fabric", "Dialecte de CLI du commutateur (cisco | binardat)", "str", "hebergeur"),
    ("underlay_stp_mode", "fabric", "defaut", "Fabric", "Mode de spanning-tree (rstp | mstp | pvst)", "str", "hebergeur"),
    ("underlay_stp_topologie", "fabric", "defaut", "Fabric", "Topologie de câblage (etoile | anneau | maille)", "str", "hebergeur"),
    # `opnsense_prochain_saut` n'est PLUS un intrant : il derive du reseau de transit de
    # l'underlay (`passerelle` du reseau portant `passerelle_sortie`). Le saisir ici en
    # doublon ouvrirait la porte a deux valeurs contradictoires pour un seul lien.
]
# Cles secretes : interdites a l'ecriture par le GUI (garde-fou).
INTRANTS_CLES_INTERDITES = {
    "proxmox_api_token_id", "proxmox_api_token_secret", "ansible_become_pass", "ansible_password",
    # Frontiere : les identifiants d'API ne transitent jamais par le panneau.
    "opnsense_api_key", "opnsense_api_secret",
}
# Rappel en lecture seule (jamais de valeur) : secrets a fournir via Ansible Vault.
def secrets_attendus() -> list[str]:
    """Noms des secrets a fournir par la voute — DERIVES, jamais tenus a la main.

    `voute.secrets_exiges()` les recense depuis le plan, les roles des groupes actifs et
    les group_vars de l'instance ; `voute.SECRETS_HORS_MOTIF` ajoute ceux qui ne portent
    pas le prefixe `vault_` (les jetons Proxmox). C'est la MEME source que la preuve P18.

    Une liste ecrite a la main vivait ici et avait diverge : elle annoncait
    `vault_ldap_sssd`, qu'aucun role ne consomme. Un operateur qui suivait le panneau
    creait donc un secret inutile. Le recensement par motif textuel a lui aussi sa
    limite : il a un temps reclame `vault_step_ca_fingerprint` a cause d'un defaut mort
    dans `client_pki`, qui derive en realite l'empreinte a chaud depuis l'AC.

    Depot public nu (aucune instance) : liste vide plutot qu'une erreur d'affichage.
    """
    try:
        import voute
        return sorted(set(voute.secrets_exiges()) | voute.SECRETS_HORS_MOTIF)
    except Exception:
        return []

# Garde-fous des executions (verifier / deployer) depuis l'interface.
JETON = secrets.token_urlsafe(18)
VERROU = threading.Lock()
VERIF_OK: dict[str, bool] = {}
MOTIF_HOTE = re.compile(r"^[A-Za-z0-9._-]{1,63}$")


# Champs de provisioning persistes comme variables d'hote dans l'inventaire.
# (cle_gui, variable_inventaire, type)
CHAMPS_PROVISION = [
    ("adresse_ip", "ansible_host", "str"),
    ("utilisateur_ansible", "ansible_user", "str"),
    ("cidr", "proxmox_cidr", "int"),
    ("passerelle", "proxmox_passerelle", "str"),
    ("vlan", "proxmox_vlan", "int"),
    ("pont", "proxmox_pont", "str"),
    ("dns", "proxmox_dns", "str"),
    ("vmid", "proxmox_vmid", "int"),
    ("noeud", "proxmox_noeud", "str"),
    ("stockage", "proxmox_stockage", "str"),
    ("disque_taille", "proxmox_disque_taille", "str"),
    ("memoire", "proxmox_memoire", "int"),
    ("coeurs", "proxmox_coeurs", "int"),
]


def charger_yaml(path: Path) -> dict:
    if not path.exists():
        return {"all": {"children": {}}}
    with path.open("r", encoding="utf-8") as fichier:
        data = yaml.safe_load(fichier) or {}
    if not isinstance(data, dict):
        raise ValueError(f"{path} ne contient pas une table YAML.")
    data.setdefault("all", {})
    data["all"].setdefault("children", {})
    return data


def ecrire_yaml(path: Path, data: dict) -> None:
    with ecriture_atomique(path) as fichier:
        yaml.safe_dump(data, fichier, default_flow_style=False, sort_keys=False, allow_unicode=True)


def enfants(data: dict) -> dict:
    return data.setdefault("all", {}).setdefault("children", {})


def groupes_disponibles(data: dict) -> list[str]:
    return groupes_operationnels_connus(enfants(data), DOSSIER_PLAYBOOKS_GROUPES)


def roles_des_groupes() -> dict:
    """Pour chaque playbook de groupe, extrait les roles appliques (chaine groupe -> roles)."""
    resultat: dict = {}
    for chemin in sorted(DOSSIER_PLAYBOOKS_GROUPES.glob("*.yml")):
        roles: list[str] = []
        try:
            with chemin.open("r", encoding="utf-8") as fichier:
                docs = yaml.safe_load(fichier) or []
            plays = docs if isinstance(docs, list) else [docs]
            for play in plays:
                if not isinstance(play, dict):
                    continue
                for role in play.get("roles", []) or []:
                    if isinstance(role, str):
                        roles.append(role)
                    elif isinstance(role, dict):
                        nom = role.get("role") or role.get("name")
                        if nom:
                            roles.append(str(nom))
        except (OSError, yaml.YAMLError):
            pass
        resultat[chemin.stem] = {"roles": roles, "stub": not roles}
    return resultat


def hotes_actifs_fichier(path: Path) -> set[str]:
    data = charger_yaml(path)
    return set(enfants(data).get(GROUPE_HOTES_ACTIFS, {}).get("hosts", {}) or {})


def variables_hote(data: dict, hote: str) -> dict:
    resultat: dict = {}
    for groupe_data in enfants(data).values():
        hosts = groupe_data.get("hosts", {})
        valeurs = hosts.get(hote)
        if isinstance(valeurs, dict):
            resultat.update(valeurs)
    return resultat


def liste_hotes(data: dict) -> list[dict]:
    noms = set()
    for groupe_data in enfants(data).values():
        noms.update(groupe_data.get("hosts", {}))

    hotes = []
    for nom in sorted(noms):
        groupes = []
        etat = "planifie"
        visible = False
        for groupe, groupe_data in enfants(data).items():
            if nom not in groupe_data.get("hosts", {}):
                continue
            if groupe == GROUPE_HOTES_ACTIFS:
                etat = "actif"
                visible = True
            elif groupe in GROUPES_ETAT_HOTE:
                visible = True
                continue
            elif est_groupe_operationnel(groupe):
                groupes.append(groupe)
                visible = True
        if not visible:
            continue
        variables = variables_hote(data, nom)
        hote = {"nom": nom, "etat": etat, "groupes": sorted(groupes)}
        for cle, var, _type in CHAMPS_PROVISION:
            valeur = variables.get(var, "")
            hote[cle] = "" if valeur is None else valeur
        if not str(hote.get("utilisateur_ansible", "")).strip():
            hote["utilisateur_ansible"] = "ansible"
        hotes.append(hote)
    return hotes


def _joignable(ip: str, port: int = 22, timeout: float = 1.5) -> bool:
    if not ip:
        return False
    try:
        with socket.create_connection((ip, port), timeout=timeout):
            return True
    except OSError:
        return False


def sonder_hotes(path: Path) -> dict:
    """Etat REEL (vs plan declaratif) : la VM de chaque hote repond-elle sur SSH ?"""
    cibles = [(h.get("nom"), h.get("adresse_ip")) for h in liste_hotes(charger_yaml(path))]
    with ThreadPoolExecutor(max_workers=16) as executeur:
        resultats = executeur.map(lambda c: (c[0], _joignable(c[1])), cibles)
    return {nom: ok for nom, ok in resultats if nom}


def marquer_serveur_actif(hote: str) -> None:
    """Auto-actif : un hote materialise (clone/deploye) passe 'actif' dans le plan."""
    registre = charger_serveurs(FICHIER_SERVEURS)
    serveurs = registre.get("serveurs") or {}
    if hote in serveurs and serveurs[hote].get("etat") != "actif":
        serveurs[hote]["etat"] = "actif"
        ecrire_serveurs(FICHIER_SERVEURS, registre)


def serveurs_reconcilies(data: dict) -> list:
    """Serveurs du plan + valeurs derivees + statut de reconciliation (lecture)."""
    registre = charger_serveurs(FICHIER_SERVEURS)
    nomenclature = charger_nomenclature(FICHIER_NOMENCLATURE)
    hotes = {h["nom"]: h for h in liste_hotes(data) if h.get("nom")}
    resultat = []
    for nom, srv in (registre.get("serveurs") or {}).items():
        rec = reconcilier_serveur(nom, srv, hotes.get(nom), nomenclature)
        d = rec["derive"]
        statut = "absent" if rec["absent_inventaire"] else ("divergence" if rec["divergences"] else "reconcilie")
        resultat.append({
            "nom": nom, "fonction": srv.get("fonction", ""), "etat": srv.get("etat", ""),
            "noeud": srv.get("noeud", ""), "stockage": srv.get("stockage", ""),
            "disque": srv.get("disque", ""), "memoire": srv.get("memoire", ""), "coeurs": srv.get("coeurs", ""),
            "integrations": srv.get("integrations", []),
            "vmid": d.get("vmid", ""), "adresse_ip": d.get("adresse_ip", ""), "vlan": d.get("vlan", ""),
            "statut": statut, "divergences": rec["divergences"],
        })
    return resultat


def flux_api() -> list:
    """Matrice des flux réseau (meta/flux.yml de tous les rôles) — lecture seule."""
    try:
        import resoudre_flux
        flux = resoudre_flux.charger_flux()
    except Exception:
        return []
    lignes = []
    for role in sorted(flux):
        for fl in flux[role]:
            pair = fl.get("pair")
            pair = ", ".join(str(p) for p in pair) if isinstance(pair, list) else str(pair)
            port = fl.get("port")
            port = ", ".join(str(p) for p in port) if isinstance(port, list) else str(port)
            lignes.append({
                "role": role, "sens": fl.get("sens", ""), "port": port,
                "protocole": fl.get("protocole", ""), "pair": pair,
                "chiffrement": fl.get("chiffrement", ""), "raison": fl.get("raison", ""),
            })
    return lignes


def couches_api() -> list:
    """Ordre de déploiement en couches (couches-deploiement.yml + graphe) — lecture seule."""
    try:
        import orchestrer
        return [{"nom": nom, "groupes": list(groupes)} for nom, groupes in orchestrer.ordre_deploiement()]
    except Exception:
        return []


# ═══ LES DEUX CONSOLES, ET LE TRONC QU'ELLES PARTAGENT ═══════════════════════════════
#
# POURQUOI DEUX CLASSES, ET PAS DEUX FONCTIONS (2026-09-20).
#
# Il y avait deux fonctions : `inventaire_api` pour un locataire, `inventaire_api_du_site`
# pour un site. Elles assemblaient LA MEME charge, chacune de son cote — et elles ont
# derive, deux fois le meme jour :
#
#   en FORME    `serveurs` valait `[]` d'un cote et `{}` de l'autre. Les deux « vides »,
#               et la page ne les lit pas pareil : `charger()` LEVAIT, et la console d'un
#               site mourait avant sa premiere vue.
#   en CONTENU  cinq registres etaient servis vides « pour ne pas fabriquer un faux plan
#               de tenant » — alors que le site a SON plan, au meme format, que les
#               lecteurs du moteur lisent sans broncher : 9 serveurs, 21 applications.
#
# Deux fonctions qui doivent rendre la meme forme finissent toujours par ne plus la
# rendre. Un tronc qui assemble, et des branches qui ne decident que de CE QUI LEUR
# APPARTIENT, rendent cette derive impossible : il n'y a plus qu'un seul endroit ou la
# charge se compose.
#
# CE QUE CHAQUE BRANCHE EST, au sens de `docs/responsabilites-locataire-hebergeur.md` :
#
#   ConsoleLocataire   configure SES services — voute du tenant, plan derive d'un seed
#   ConsoleSite        materialise le terrain — voute du site, plan DECLARE (ip, vmid)
#   ConsoleOrpheline   ne pilote rien, et c'est ce qu'elle doit dire
#
# Aucune n'est omnipotente, et la classe le porte au lieu d'un `if portee == ...` seme
# dans le code.


class Console:
    """Le tronc : ce qu'une console EST, quelle que soit la machine qui la sert."""

    # LE ROLE est une propriete de la CLASSE — ce pour quoi cette console existe.
    # LA PORTEE se CALCULE — ce qu'elle peut vraiment, ici et maintenant. Les deux ne se
    # confondent pas : un poste prive de la voute du site reste l'atelier du mainteneur,
    # et n'engendre pourtant rien. Figer la portee sur la classe aurait rendu a ce
    # poste-la un pouvoir que la mesure lui refuse.
    role = "aucun"

    @property
    def portee(self) -> str:
        p = self.pouvoirs()
        return ("poste" if p["configurer"] and p["materialiser"] else
                "tenant" if p["configurer"] else
                "site" if p["materialiser"] else "orphelin")

    @property
    def titre(self) -> str:
        return {
            "poste": f"Poste du mainteneur — {self.ecosysteme()} sur {self.fabric()}",
            "tenant": f"Console du locataire — {self.ecosysteme()}",
            "site": f"Console du SITE — {self.fabric()}",
        }.get(self.portee, "Console sans pouvoir — elle ne pilote rien")

    # LES REGISTRES DU PLAN, declares UNE fois : leur nom a l'ecran, leur fichier, leur
    # lecteur. Une branche qui n'a pas de plan les rend vides — de la BONNE forme, parce
    # que c'est le tronc qui decide de la forme, pas la branche.
    REGISTRES = (
        ("nomenclature", "nomenclature.yml", charger_nomenclature),
        ("bases", "bases-donnees.yml", charger_bases_donnees),
        ("applications", "applications.yml", charger_applications),
        ("domaines", "domaines.yml", charger_domaines),
    )

    # --- CE QUE CHAQUE BRANCHE DECIDE POUR ELLE ---------------------------------------

    def racine_du_plan(self) -> Path | None:
        """Le dossier `plan/` que cette console lit. None = elle n'en a pas."""
        return None

    def inventaire_brut(self) -> dict:
        """L'inventaire, dans la forme d'un `hosts.yml`. Vide par defaut."""
        return {"all": {"children": {}}}

    def nom_inventaire(self) -> str:
        return ""

    def est_production(self) -> bool:
        return False

    def serveurs(self, data: dict) -> list:
        """Les serveurs, TOUJOURS en liste. D'ou ils viennent regarde la branche."""
        return []

    def intrants(self):
        return None

    def pouvoirs(self) -> dict:
        return {"editer_le_plan": False, "configurer": False,
                "materialiser": False, "fabric": False}

    def raisons(self) -> dict:
        return {
            "configurer": "Cette console ne porte la voute d'aucun ecosysteme.",
            "editer_le_plan": "Aucun plan n'est monte ici.",
            "materialiser": "Cette console ne sait sur quelle fabric poser une VM.",
            "fabric": "Aucune fabric n'est montee ici.",
        }

    def ecosysteme(self) -> str | None:
        return None

    def fabric(self) -> str | None:
        return None

    # --- LE TRONC : UN SEUL ENDROIT OU LA CHARGE SE COMPOSE ---------------------------

    def contexte(self) -> dict:
        return {
            "portee": self.portee,
            "role": self.role,
            "titre": self.titre,
            "ecosysteme": self.ecosysteme(),
            "fabric": self.fabric(),
            "peut": self.pouvoirs(),
            "raison": self.raisons(),
            # QUELLE SOURCE D'INVENTAIRE : un site n'a pas de `hosts.yml`, son inventaire
            # est un SCRIPT. Une console qui a quelque chose a piloter le NOMME.
            "inventaire": self.nom_inventaire() or None,
        }

    def peut_conduire(self, portee_etape: str) -> tuple[bool, str]:
        """Cette console peut-elle conduire une etape de CETTE portee — et sinon, pourquoi ?

        LE JUGEMENT VIT ICI, PAS DANS LES ROUTES. Il etait ecrit deux fois : dans la route
        qui LISTE les assistants et dans celle qui EXECUTE une etape. Deux copies d'une
        meme regle finissent par ne plus dire la meme chose — et celle qui se trompe est
        toujours celle qui execute, parce que c'est la moins relue.
        """
        peut = self.pouvoirs()
        manquants = [p for p in POUVOIR_PAR_PORTEE.get(portee_etape, ())
                     if not peut.get(p)]
        if not manquants:
            return True, ""
        return False, self.raisons().get(manquants[0],
                                         "Geste hors de la portee de cette console.")

    def charge(self) -> dict:
        """LA charge servie a la page — la seule, pour les deux consoles.

        Les clefs et leurs FORMES sont fixees ici. Une branche choisit ce qu'elle met
        dedans, jamais la forme de ce qu'elle met : c'est exactement ce qui a manque.
        """
        data = self.inventaire_brut()
        plan = self.racine_du_plan()
        registres = {}
        for clef, fichier, lecteur in self.REGISTRES:
            chemin = (plan / fichier) if plan else None
            registres[clef] = lecteur(chemin) if (chemin and chemin.is_file()) else {}
        return {
            "flux": flux_api(),
            "couches": couches_api(),
            "inventaire": self.nom_inventaire(),
            "production": self.est_production(),
            "groupes": groupes_disponibles(data),
            "dependances": charger_dependances(FICHIER_DEPENDANCES),
            "chaine": roles_des_groupes(),
            **registres,
            "serveurs": self.serveurs(data),
            "hotes": liste_hotes(data),
            "intrants": self.intrants(),
            "integrations_disponibles": integrations_disponibles(),
            "integrations_universelles": integrations_universelles(RACINE),
            "liens_acceptes": catalogue_liens(RACINE),
            # LE SCHEMA VOYAGE AVEC LES DONNEES. Le navigateur genere ses formulaires
            # depuis lui plutot que de les porter en dur. Genere par `make schema`, P61.
            "schema": schema_du_plan(),
            "contexte": self.contexte(),
        }


class ConsoleLocataire(Console):
    """Elle CONFIGURE : des roles sur ses machines, avec la voute du tenant.

    Son plan DERIVE tout d'un seed `index` — VMID, adresse, VLAN. Elle edite donc le
    plan, et l'inventaire qu'elle lit est un artefact genere depuis lui.
    """

    role = "locataire"

    def __init__(self, instance: Path, inventaire: Path, a_voute: bool):
        self._instance = instance
        self._inventaire = inventaire
        self._a_voute = a_voute

    def ecosysteme(self):
        return self._instance.resolve().name

    def racine_du_plan(self):
        return self._instance / "plan"

    def inventaire_brut(self):
        return charger_yaml(self._inventaire)

    def nom_inventaire(self):
        return os.path.relpath(self._inventaire, RACINE)

    def est_production(self):
        return instance_est_production(self._inventaire)

    def serveurs(self, data):
        return serveurs_reconcilies(data)

    def intrants(self):
        return intrants_api()

    def pouvoirs(self):
        return {"editer_le_plan": True, "configurer": self._a_voute,
                "materialiser": False, "fabric": False}

    def raisons(self):
        r = super().raisons()
        r["materialiser"] = ("Cette console configure un ecosysteme ; elle ne sait pas "
                             "sur quelle fabric poser une VM, et c'est voulu : exploiter "
                             "n'est pas engendrer.")
        r["configurer"] = ("Un ecosysteme est monte, mais sa voute n'est pas sur cette "
                           "machine : calculer un inventaire ne demande aucun secret, "
                           "configurer un service si.")
        r["fabric"] = ("La fabric appartient a l'hebergeur. Cette console n'en monte "
                       "aucune carte.")
        return r


class ConsoleSite(Console):
    """Elle MATERIALISE : cree et detruit des VM, pose le reseau, avec la voute du site.

    SES ZONES DERIVENT, SES MACHINES SONT ENCORE ECRITES. Un site a son propre index
    depuis le 2026-09-12 — le 37 pour celui-ci — et ses zones en descendent comme celles
    d'un locataire descendent du sien (P20 le garde). Ce qui reste ecrit dans son plan,
    ce sont les `ip`, `vmid` et `noeud` de ses MACHINES : une dette nommee, pas une
    doctrine. La docstring disait le contraire : elle recopiait un commentaire perime de
    huit jours au lieu de mesurer. Son inventaire, lui, n'est pas un fichier mais un SCRIPT.

    ELLE A UN PLAN, ET ON LE LUI SERT. La charge du site servait cinq registres vides
    « pour ne pas fabriquer un faux plan de tenant ». Le site n'a pas de faux plan : il a
    LE SIEN, au meme format, que les lecteurs du moteur lisent sans broncher — mesure du
    2026-09-20 : 9 serveurs, 21 applications, 2 bases, 1 domaine, tous invisibles.
    """

    role = "site"

    def __init__(self, depot: Path, a_voute: bool):
        self._depot = depot
        self._a_voute = a_voute

    def fabric(self):
        return self._depot.name

    def racine_du_plan(self):
        return self._depot / "plan"

    def inventaire_brut(self):
        return inventaire_du_site()

    def nom_inventaire(self):
        return f"{self.fabric()} (inventaire dynamique)"

    def est_production(self):
        return True

    def serveurs(self, data):
        """Les serveurs DECLARES du site, dans la forme que la page sait lire.

        On ne les reconcilie pas contre une nomenclature : un site n'en a pas, ses
        valeurs sont ecrites. Le statut se lit donc contre l'inventaire REEL — declare
        ici, present la-bas, ou pas.
        """
        chemin = self.racine_du_plan() / "serveurs.yml"
        if not chemin.is_file():
            return []
        registre = (charger_serveurs(chemin) or {}).get("serveurs") or {}
        vivants = {h.get("nom") for h in liste_hotes(data)}
        sortie = []
        for nom, srv in registre.items():
            gabarit = srv.get("gabarit") or {}
            sortie.append({
                "nom": nom,
                # Un site ne derive d'aucune fonction : il nomme le RESEAU qui le porte.
                "fonction": srv.get("reseau", ""),
                "etat": srv.get("etat", ""),
                "noeud": srv.get("noeud", ""),
                "stockage": srv.get("stockage", ""),
                "disque": gabarit.get("disque", ""),
                "memoire": gabarit.get("memoire", ""),
                "coeurs": gabarit.get("vcpu", ""),
                "integrations": srv.get("integrations", []),
                "vmid": srv.get("vmid", ""),
                "adresse_ip": srv.get("ip", ""),
                "vlan": "",
                "statut": "reconcilie" if nom in vivants else "absent",
                "divergences": [],
            })
        return sortie

    def pouvoirs(self):
        # EDITER : pas encore. Les formulaires sont generes depuis le schema du plan d'un
        # LOCATAIRE, ou l'adressage se derive ; le plan d'un site l'ECRIT. Offrir un
        # formulaire qui ecrirait de travers serait pire que ne rien offrir. On LIT.
        return {"editer_le_plan": False, "configurer": False,
                "materialiser": self._a_voute, "fabric": True}

    def raisons(self):
        r = super().raisons()
        r["configurer"] = ("Cette console materialise le terrain ; elle n'a la voute "
                           "d'aucun locataire, donc elle ne configure aucun de leurs "
                           "services.")
        r["editer_le_plan"] = ("Le plan de ce site se LIT ici. Ses adresses sont ECRITES, "
                               "pas derivees d'un seed, et les formulaires sont generes "
                               "depuis le schema d'un plan de locataire : ils ecriraient "
                               "de travers.")
        r["materialiser"] = ("Cette console LIT la carte d'une fabric dont elle n'a pas "
                             "la voute. Creer ou detruire une machine demande le secret "
                             "du site, et il n'est pas ici.")
        r["fabric"] = ("La fabric appartient a l'hebergeur. Ce qui s'affiche ici vient "
                       "d'une copie locale, et une copie avait deja diverge.")
        return r


class ConsolePoste(ConsoleLocataire):
    """L'atelier du mainteneur : les deux voutes, donc les deux pouvoirs.

    Elle EST une console de locataire — meme plan, meme inventaire — qui sait en plus sur
    quelle fabric poser une VM. L'heritage dit exactement ca, et evite une troisieme
    copie de la meme charge.
    """

    role = "poste"

    def __init__(self, instance, inventaire, depot, a_voute_tenant, a_voute_site):
        super().__init__(instance, inventaire, a_voute_tenant)
        self._depot = depot
        self._a_voute_site = a_voute_site

    def fabric(self):
        return self._depot.name

    def pouvoirs(self):
        p = super().pouvoirs()
        p["materialiser"] = self._a_voute_site
        p["fabric"] = True
        return p

    def raisons(self):
        # CE POSTE SAIT SUR QUELLE FABRIC POSER — il en monte la carte. Ce qui lui manque,
        # le cas echeant, c'est la VOUTE. Heriter du refus d'un locataire (« elle ne sait
        # pas sur quelle fabric ») enverrait chercher une carte qui est pourtant la, et
        # ferait perdre le temps qu'un message juste economise.
        r = super().raisons()
        r["materialiser"] = ("Cette console LIT la carte d'une fabric dont elle n'a pas "
                             "la voute. Creer ou detruire une machine demande le secret "
                             "du site, et il n'est pas ici.")
        r["fabric"] = ("La fabric appartient a l'hebergeur. Ce qui s'affiche ici vient "
                       "d'une copie locale, et une copie avait deja diverge.")
        return r


def console(inventaire: Path | None = None) -> Console:
    """QUELLE console sert cette machine — derive de ce qu'elle peut OUVRIR.

    `docs/responsabilites-locataire-hebergeur.md` attache chaque pouvoir a une voute :
    calculer n'en demande aucune, configurer celle du tenant, materialiser celle du site.
    On ne prouve pas qu'une voute s'ouvre — le mot de passe se tape a l'execution — mais
    son ABSENCE est decisive et se mesure sans rien ouvrir.
    """
    a_instance = INSTANCE.exists()
    depot = _depot_hebergeur()
    inv = inventaire or INVENTAIRE_DEFAUT

    voute_tenant = (INSTANCE / "inventories" / "principal" / "group_vars" / "all" /
                    "vault.yml") if a_instance else None
    a_voute_tenant = bool(voute_tenant and voute_tenant.is_file())
    a_voute_site = bool(depot and (depot / "underlay.vault.yml").is_file())

    # LA BRANCHE SUIT LES LIENS — ce que cette machine est faite pour faire. La PORTEE,
    # elle, suivra les voutes : une console de locataire sans sa voute reste une console
    # de locataire (elle calcule son inventaire), et se dira « orpheline » parce qu'elle
    # ne peut rien configurer. Le role et le pouvoir sont deux questions distinctes.
    if a_instance and depot:
        return ConsolePoste(INSTANCE, inv, depot, a_voute_tenant, a_voute_site)
    if a_instance:
        return ConsoleLocataire(INSTANCE, inv, a_voute_tenant)
    if depot:
        return ConsoleSite(depot, a_voute_site)
    return Console()


def inventaire_api(path: Path) -> dict:
    """La charge d'une console de LOCATAIRE — deleguee au tronc.

    Elle reste parce que le harnais et les tests l'appellent par ce nom. Elle n'assemble
    plus rien : assembler deux fois est exactement ce qui a fait deriver la charge du
    site de celle du locataire.
    """
    return ConsoleLocataire(INSTANCE, path, True).charge()


def schema_du_plan() -> dict:
    """Le JSON Schema des registres, tel que `make schema` l'a ecrit.

    Lu depuis le fichier plutot que recalcule : c'est l'artefact VERSIONNE qui fait foi,
    et P61 refuse qu'il soit perime. Recalculer ici laisserait l'ecran afficher une forme
    que personne n'a relue.
    """
    f = RACINE / "docs" / "audit" / "schema-plan.json"
    if not f.is_file():
        return {}
    try:
        return json.loads(f.read_text(encoding="utf-8")).get("registres", {})
    except (OSError, json.JSONDecodeError):
        return {}


def _lire_yaml_dict(path: Path) -> dict:
    if not path.exists():
        return {}
    with path.open("r", encoding="utf-8") as fichier:
        data = yaml.safe_load(fichier) or {}
    return data if isinstance(data, dict) else {}


def instance_est_production(path: Path) -> bool:
    """Cette instance est-elle la PRODUCTION ? (garde-fou de prudence, pas un blocage)

    Le déploiement est permis sur toute instance (lab compris, vers son infra) ;
    ce drapeau ne sert qu'à exiger une confirmation renforcée côté GUI quand c'est
    la prod. Repère explicite : `setops_production` dans `<inventaire>/group_vars/all/`.
    Rétro-compatibilité : à défaut, ancien repère (inventaire nommé « production »).
    """
    base = path.parent / "group_vars" / "all"
    fichiers = sorted(base.glob("*.yml")) if base.is_dir() else []
    plat = path.parent / "group_vars" / "all.yml"
    if plat.exists():
        fichiers.append(plat)
    for f in fichiers:
        d = _lire_yaml_dict(f)
        if isinstance(d, dict) and "setops_production" in d:
            return bool(d["setops_production"])
    return path.resolve() == INVENTAIRE_PRODUCTION


def _lire_fabric_a_plat() -> dict:
    """Les intrants PLATS de underlay.yml, aplatis dans l'espace de noms du panneau."""
    data = _lire_yaml_dict(FICHIER_UNDERLAY).get("underlay") or {}
    plat = {}
    for variable, chemin in CHEMINS_UNDERLAY.items():
        noeud = data
        for clef in chemin:
            noeud = (noeud or {}).get(clef) if isinstance(noeud, dict) else None
        plat[variable] = noeud
    return plat


def intrants_courants() -> dict:
    cache: dict = {}
    valeurs: dict = {}
    for variable, fcle, _classe, _section, _libelle, typ, _prop in INTRANTS_SCHEMA:
        if fcle not in cache:
            cache[fcle] = (_lire_fabric_a_plat() if fcle == "fabric"
                           else _lire_yaml_dict(FICHIERS_INTRANTS[fcle]))
        v = cache[fcle].get(variable)
        if typ == "liste":
            items = v if isinstance(v, list) else []
            valeurs[variable] = [str(x).strip() for x in items if str(x).strip()]
        else:
            valeurs[variable] = "" if v is None else v
    return valeurs


# --- Couverture du schema du plan par le GUI -------------------------------------
#
# Ce que les fonctions de sauvegarde JS ecrivent REELLEMENT, registre par registre.
# Source unique verifiee par `scripts/couverture_gui.py` : tout champ present dans
# un plan reel (instance ou modele) mais absent d'ici signale un trou de l'interface
# — l'operateur devrait editer le YAML a la main, ce que la doctrine refuse.
#
# A TENIR A JOUR avec sauvegarderServeurs / sauvegarderApplications /
# sauvegarderBases / sauvegarderDomaines. Le verificateur controle aussi que chaque
# champ declare ici apparait bien dans le source du GUI (garde anti-derive).
# CE QUE LE GUI SAIT ECRIRE — ET D'OU IL LE TIENT (2026-09-08).
#
# Cette table etait tenue A LA MAIN : quelqu'un devait penser a l'allonger quand un champ
# arrivait au plan, et P19 confrontait la liste au reel. Une copie gardee reste une copie.
#
# LA TABLE EST VIDE, ET C'EST LE BUT. Les SIX registres ont leur formulaire GENERE depuis
# `docs/audit/schema-plan.json` (`make schema`) : la liste se DEDUIT du schema au lieu
# d'etre recopiee ici. `bases_donnees` est sortie la premiere, la nomenclature ensuite,
# puis `serveurs_bd`, `domaines_publics`, et enfin `serveurs` et `applications`.
#
# On la garde plutot que de la supprimer : le mecanisme doit pouvoir accueillir un champ
# qu'un formulaire ecrirait sans que le schema le decrive — et le jour ou ca arrive, il
# faudra l'ECRIRE ICI, visiblement, plutot que de le laisser vivre en silence.
#
# P19 lit `champs_ecrits_par_gui()` et non cette constante : elle garde un mecanisme, pas
# une liste.
CHAMPS_ECRITS_A_LA_MAIN: dict[str, set[str]] = {}

# Les registres dont le formulaire est GENERE : leurs champs viennent du schema.
REGISTRES_GENERES = {"bases_donnees", "nomenclature", "serveurs_bd",
                     "domaines_publics", "serveurs", "applications"}


def champs_ecrits_par_gui() -> dict:
    """Ce que le GUI sait ecrire : declare a la main, plus derive du schema.

    Une seule fonction repond a la question, pour que P19 n'ait pas a savoir lequel des
    deux mecanismes couvre quel registre.
    """
    def _noms(props: dict) -> set:
        """Les champs decrits, TABLES ET BLOCS IMBRIQUES COMPRIS.

        Les plans portent `categorie` et `service` a plat, sous la table `fonctions`.
        Ne rendre que les proprietes de premier niveau ferait dire au GUI qu'il ne sait
        pas les ecrire, alors que le formulaire genere les edite.
        """
        vus = set()
        for nom, spec in (props or {}).items():
            vus.add(nom)
            for conteneur in (spec, spec.get("additionalProperties"), spec.get("items")):
                if isinstance(conteneur, dict) and isinstance(conteneur.get("properties"), dict):
                    vus |= _noms(conteneur["properties"])
        return vus

    resultat = {nom: set(champs) for nom, champs in CHAMPS_ECRITS_A_LA_MAIN.items()}
    for nom, reg in (schema_du_plan() or {}).items():
        if nom in REGISTRES_GENERES:
            resultat[nom] = _noms((reg.get("entite") or {}).get("properties") or {})
    return resultat


def integrations_disponibles() -> list:
    """Roles client_* SELECTIONNABLES : ceux qui restent un choix.

    Les universelles en sont exclues : on ne coche pas ce qui s'applique a tout le
    monde. Le GUI les affiche quand meme, en lecture seule (voir /api/etat) — sinon
    l'operateur lirait « aucune supervision » sur une flotte entierement supervisee.
    """
    base = RACINE / "roles"
    universelles = set(integrations_universelles(RACINE))
    return sorted(p.name for p in base.glob("client_*")
                  if p.is_dir() and p.name not in universelles)


def intrants_api() -> dict:
    schema = [{"variable": v, "fichier": f, "classe": c, "section": s,
               "libelle": l, "type": t, "proprietaire": p} for (v, f, c, s, l, t, p) in INTRANTS_SCHEMA]
    return {
        "schema": schema,
        "valeurs": intrants_courants(),
        "secrets_attendus": secrets_attendus(),
        "fichiers": {k: os.path.relpath(v, RACINE) for k, v in FICHIERS_INTRANTS.items()},
    }


def _coercer_intrant(typ: str, brut: object) -> object:
    if typ == "liste":
        items = brut if isinstance(brut, list) else str(brut).replace("\n", ",").split(",")
        # dedoublonne en preservant l'ordre
        vus, sortie = set(), []
        for x in items:
            s = str(x).strip()
            if s and s not in vus:
                vus.add(s); sortie.append(s)
        return sortie
    s = str(brut).strip()
    if typ == "bool":
        return s.lower() in ("true", "1", "oui", "yes", "on")
    if typ == "int":
        return int(s) if s.lstrip("-").isdigit() else s
    return s


_REFERENCE_VOUTE = re.compile(r"^\{\{\s*vault_[A-Za-z0-9_]+\s*\}\}$")


def _est_reference_voute(valeur: object) -> bool:
    """Vrai si la valeur est une simple REFERENCE de voute (`{{ vault_xxx }}`).

    Un fichier d'intrants peut porter, a cote de ses parametres anodins, des renvois
    par NOM vers la voute (cas de group_vars/opnsense.yml). Ce n'est pas un secret :
    c'est un pointeur. La fusion « preserve les cles non gerees » les relit donc du
    disque, et le garde-fou ne doit pas les confondre avec une valeur saisie.
    """
    return bool(_REFERENCE_VOUTE.match(str(valeur).strip()))


_CLE_RACINE = re.compile(r"^([A-Za-z_][A-Za-z0-9_]*):")


def _rendre_cle(cle: str, valeur: object) -> list[str]:
    """Les lignes que PyYAML ecrirait pour cette seule clef (listes en bloc incluses)."""
    texte = yaml.safe_dump({cle: valeur}, default_flow_style=False,
                           allow_unicode=True, sort_keys=False)
    return texte.rstrip("\n").split("\n")


_ENTREE_TABLE = re.compile(r"^(\s+)([^\s#:][^:]*):(\s*)(.*)$")


def _fusion_table(bloc: list[str], entrees: dict) -> list[str]:
    """Met a jour une table clef->mapping LIGNE A LIGNE, sans la reecrire.

    POURQUOI PAS `_fusion_chirurgicale` SEULE (mesure du 2026-09-08). Elle remplace le
    BLOC entier des qu'une valeur change. Sur `fonctions:` de la nomenclature, ajouter
    une seule entree a produit deux degats mesures :

      - les quinze entrees compactes `{ categorie: 6, service: 2 }` sont devenues
        quarante-deux lignes — le fichier cesse d'etre une table lisible d'un coup d'oeil ;
      - le commentaire « LE POSTE D'EXPLOITATION », qui coiffait `ops:`, s'est retrouve
        en TETE du bloc. Un commentaire deplace ne se contente pas d'etre laid : il
        explique desormais la mauvaise ligne. Il affirmait que `collab` etait le poste
        d'exploitation.

    Ici on ne touche qu'aux LIGNES concernees. Une entree inchangee n'est pas relue, un
    commentaire garde son voisin, et le style compact survit parce qu'on ne le refait pas.
    """
    tete, corps = bloc[0], bloc[1:]
    sortie, vues = [tete], set()
    flow, colonne = 0, 0
    i = 0
    while i < len(corps):
        ligne = corps[i]
        m = _ENTREE_TABLE.match(ligne)
        if not m:
            sortie.append(ligne)
            i += 1
            continue
        indent, cle, ecart, reste = m.group(1), m.group(2).strip(), m.group(3), m.group(4)
        # L'entree s'etend sur les lignes PLUS indentees qui suivent immediatement.
        fin = i
        j = i + 1
        while j < len(corps):
            suite = corps[j]
            if not suite.strip() or suite.strip().startswith("#"):
                break
            creux = len(suite) - len(suite.lstrip())
            if creux <= len(indent):
                break
            fin = j
            j += 1
        vues.add(cle)
        if reste.startswith("{"):
            flow += 1
            colonne = max(colonne, len(indent) + len(cle) + 1 + len(ecart))
        try:
            ancien = (yaml.safe_load("\n".join(l[len(indent):] for l in corps[i:fin + 1])) or {}).get(cle)
        except yaml.YAMLError:
            ancien = object()   # illisible : on la considere changee
        if cle not in entrees:
            i = fin + 1         # entree retiree : ses lignes disparaissent, pas ses voisines
            continue
        if ancien == entrees[cle]:
            sortie.extend(corps[i:fin + 1])
        elif reste.startswith("{"):
            sortie.append(f"{indent}{cle}:{ecart}{_rendre_flow(entrees[cle])}")
        else:
            # L'entree tenait sur plusieurs lignes : on la refait en bloc, indentee
            # comme ses voisines.
            sortie.extend(indent + l for l in _rendre_cle(cle, entrees[cle]))
        i = fin + 1
    # Les entrees NEUVES vont a la fin du bloc, dans le style dominant.
    neuves = [c for c in entrees if c not in vues]
    if neuves:
        indent = "  "
        for ligne in corps:
            m = _ENTREE_TABLE.match(ligne)
            if m:
                indent = m.group(1)
                break
        while sortie and not sortie[-1].strip():
            sortie.pop()
        for cle in neuves:
            if flow:
                ecart = " " * max(1, colonne - len(indent) - len(str(cle)) - 1)
                sortie.append(f"{indent}{cle}:{ecart}{_rendre_flow(entrees[cle])}")
            else:
                sortie.extend(indent + l for l in _rendre_cle(cle, entrees[cle]))
    return sortie


def _rendre_flow(valeur: object) -> str:
    """La forme compacte `{ a: 1, b: 2 }` — celle que le fichier employait deja."""
    rendu = yaml.safe_dump(valeur, default_flow_style=True, allow_unicode=True,
                           sort_keys=False, width=10 ** 6).strip()
    if rendu.startswith("{") and rendu.endswith("}"):
        rendu = "{ " + rendu[1:-1].strip() + " }"
    return rendu


def _fusion_chirurgicale(texte: str, valeurs: dict, tables: set | None = None) -> str:
    """Pose les valeurs dans le texte existant SANS reformater ce qui n'a pas change.

    POURQUOI (mesure du 2026-08-18). Ces fichiers portent la memoire ECRITE des
    decisions : pourquoi `dns_amorcage` pointe sur un resolveur public, pourquoi le
    plan de gestion est reste en 10.0.0.0/24, pourquoi la frontiere ecoute sur `lan`.
    Chaque enregistrement du panneau les repassait au `safe_dump` : clefs retriees,
    et TOUS les commentaires effaces. Un enregistrement de 13:48 a ainsi emporte
    94 lignes de commentaire dans quatre fichiers (129 -> 35, le reste etant l'entete
    que le panneau reecrit) — dont celle qui disait pourquoi la valeur qu'on venait
    de changer avait ete choisie.

    Le depot connaissait deja le geste juste : `_ecrire_intrants_fabric` et
    `_ecrire_index_nomenclature` remplacent la ligne sans toucher au reste. Ce qui
    manquait ici, c'est de savoir remplacer une valeur de LISTE, qui tient sur
    plusieurs lignes.

    Trois regles :
    - une clef dont la valeur ne change pas n'est PAS reecrite (zero bruit au diff) ;
    - les commentaires INTERNES a un bloc remplace sont conserves, jamais juges : une
      explication devenue fausse se corrige a la main, elle ne se supprime pas toute
      seule ;
    - une clef absente du fichier est ajoutee a la fin, jamais inseree au hasard.
    """
    actuel = yaml.safe_load(texte)
    actuel = actuel if isinstance(actuel, dict) else {}
    lignes = texte.split("\n")
    sortie: list[str] = []
    vues: set[str] = set()
    i = 0
    while i < len(lignes):
        m = _CLE_RACINE.match(lignes[i])
        cle = m.group(1) if m else None
        if cle is None or cle not in valeurs:
            sortie.append(lignes[i])
            i += 1
            continue
        # Le bloc de valeur : la ligne de clef, puis tout ce qui est indente ou item de
        # liste. Les commentaires et lignes vides qui SUIVENT la derniere ligne de valeur
        # appartiennent a la clef suivante — on les laisse ou ils sont.
        fin = i
        j = i + 1
        while j < len(lignes):
            l = lignes[j]
            if l.startswith((" ", "\t", "- ")) or l == "-":
                fin = j
            elif l.strip().startswith("#") or not l.strip():
                pass          # peut etre interne au bloc : on tranche avec `fin`
            else:
                break
            j += 1
        vues.add(cle)
        if cle in actuel and actuel[cle] == valeurs[cle]:
            sortie.extend(lignes[i:fin + 1])          # inchangee : pas un octet touche
        elif cle in (tables or set()) and isinstance(valeurs[cle], dict):
            # Table clef->mapping : on edite les lignes concernees, pas le bloc.
            sortie.extend(_fusion_table(lignes[i:fin + 1], valeurs[cle]))
        else:
            internes = [l for l in lignes[i + 1:fin + 1] if l.strip().startswith("#")]
            rendu = _rendre_cle(cle, valeurs[cle])
            sortie.extend([rendu[0]] + internes + rendu[1:])
        i = fin + 1
    ajouts = [c for c in valeurs if c not in vues]
    if ajouts:
        while sortie and not sortie[-1].strip():
            sortie.pop()
        for cle in ajouts:
            sortie.extend(_rendre_cle(cle, valeurs[cle]))
        sortie.append("")
    return "\n".join(sortie)


def _ecrire_intrants_fichier(path: Path, valeurs: dict, entete: str) -> None:
    # Une cle sensible n'est toleree que sous forme de reference de voute preservee.
    # Toute VALEUR reelle sur une de ces cles fait echouer l'ecriture.
    interdits = sorted(cle for cle in set(valeurs) & INTRANTS_CLES_INTERDITES
                       if not _est_reference_voute(valeurs[cle]))
    if interdits:
        raise ValueError(f"Refus d'ecrire des cles sensibles via le GUI: {', '.join(interdits)}")
    path.parent.mkdir(parents=True, exist_ok=True)
    if path.exists():
        # Fichier existant : on pose les valeurs DANS son texte (commentaires preserves).
        path.write_text(_fusion_chirurgicale(path.read_text(encoding="utf-8"), valeurs),
                        encoding="utf-8")
        return
    with ecriture_atomique(path) as fichier:
        fichier.write(entete)
        yaml.safe_dump(valeurs, fichier, default_flow_style=False, sort_keys=True, allow_unicode=True)


def ecrire_intrants(payload: dict) -> None:
    valeurs = payload.get("valeurs", {}) or {}
    # Garde-fou en entree : le panneau n'affiche jamais ces cles, mais une requete
    # forgee pourrait les soumettre. On refuse bruyamment plutot que d'ignorer.
    soumis = sorted(set(valeurs) & INTRANTS_CLES_INTERDITES)
    if soumis:
        raise ValueError(f"Cles sensibles soumises au panneau (voute uniquement): {', '.join(soumis)}")
    if not str(valeurs.get("domaine_interne", "")).strip():
        raise ValueError("domaine_interne ne peut pas etre vide (cle de voute de l'ecosysteme).")
    types = {v: t for (v, f, c, s, l, t, p) in INTRANTS_SCHEMA}
    fichier_de = {v: f for (v, f, c, s, l, t, p) in INTRANTS_SCHEMA}
    par_fichier: dict = {}
    for variable, valeur in valeurs.items():
        if variable not in fichier_de:
            continue
        par_fichier.setdefault(fichier_de[variable], {})[variable] = _coercer_intrant(types[variable], valeur)

    if "identite" in par_fichier:
        # Fusion, comme les trois autres fichiers. C'etait la SEULE branche a ecrire
        # par-dessus le disque, et elle perdait donc en silence tout intrant absent du
        # schema du panneau. Mesure du 2026-08-10, au pre-vol de l'epreuve de
        # portabilite : un enregistrement du panneau a supprime `dns_amorcage` et
        # `amorcage_acces_courriel` de Technolibre. Le premier laisse une VM naitre sans
        # resolution — `apt` ne peut alors rien installer ; le second arrete le
        # deploiement sur la garde de `amorcage_acces` (D-72).
        #
        # Le meme geste sur Chezlepro aurait mange les memes cles. Un panneau qui ne
        # connait pas une valeur ne doit pas avoir le droit de la detruire.
        fusion = _lire_yaml_dict(INTRANTS_IDENTITE)   # preserve les cles non gerees
        fusion.update(par_fichier["identite"])
        _ecrire_intrants_fichier(
            INTRANTS_IDENTITE, fusion,
            "# Intrants d'IDENTITE de l'instance — SOURCE UNIQUE, partagee par tous les envs.\n"
            "# Edite par le panneau « Intrants de base » du GUI (make inventaire-ui).\n"
            "# Reference via symlink depuis inventories/<env>/group_vars/all/10-intrants.yml.\n---\n")
    if "proxmox" in par_fichier:
        fusion = _lire_yaml_dict(INTRANTS_PROXMOX)   # preserve les cles non gerees
        fusion.update(par_fichier["proxmox"])
        _ecrire_intrants_fichier(
            INTRANTS_PROXMOX, fusion,
            "# Parametres Proxmox non sensibles. Les secrets (jetons d'API) vont dans la\n"
            "# voute UNIQUE de l'instance : group_vars/all/vault.yml.\n"
            "# Cles d'intrants editees par le panneau « Intrants de base » du GUI.\n---\n")
    if "proxmox_hebergeur" in par_fichier:
        fusion = _lire_yaml_dict(INTRANTS_PROXMOX_HEBERGEUR)
        fusion.update(par_fichier["proxmox_hebergeur"])
        _ecrire_intrants_fichier(
            INTRANTS_PROXMOX_HEBERGEUR, fusion,
            "# Le CLUSTER, vu par l'HEBERGEUR — pas par un tenant.\n"
            "#\n"
            "# API du cluster, noeuds, stockages, ponts : du materiel possede par\n"
            "# l'hebergeur. Recopiees dans le group_vars de chaque tenant, ces valeurs\n"
            "# avaient deja diverge — deux inventaires contradictoires du meme cluster.\n"
            "#\n"
            "# Ce fichier vit dans le depot de l'HEBERGEUR, a cote d'underlay.yml (D-14),\n"
            "# et se trouve par derivation du symlink qui designe deja l'hebergeur (D-17).\n"
            "#\n"
            "# Chez le TENANT restent son golden template et ses defauts de placement :\n"
            "# des CHOIX faits a l'interieur de ce que l'hebergeur offre ici.\n"
            "#\n"
            "# Les secrets (jeton d'API) n'entrent jamais ici : voute de l'instance.\n---\n")
    if "frontiere" in par_fichier:
        # Fusion (comme Proxmox) : preserve les cles non gerees par le panneau,
        # en particulier les references de voute `{{ vault_opnsense_api_* }}`.
        fusion = _lire_yaml_dict(INTRANTS_FRONTIERE)
        fusion.update(par_fichier["frontiere"])
        _ecrire_intrants_fichier(
            INTRANTS_FRONTIERE, fusion,
            "# Frontiere nord/sud (OPNsense) — parametres NON sensibles.\n"
            "# Cles d'intrants editees par le panneau « Intrants de base » du GUI.\n"
            "#\n"
            "# Les identifiants d'API ne figurent ici que par REFERENCE de nom : leurs\n"
            "# valeurs vivent dans la voute unique de l'instance (ansible-vault edit\n"
            "# group_vars/all/vault.yml), sous vault_opnsense_api_key / _api_secret.\n"
            "# Les obtenir dans OPNsense : System > Access > Users > <utilisateur> >\n"
            "# API keys > « + ». Le secret n'est affiche qu'a la creation.\n"
            "#\n"
            "# Le boitier est HORS FLOTTE Ansible : on ne fait que piloter son API REST\n"
            "# depuis le controleur. Cf. docs/frontiere-opnsense.md.\n"
            "#\n"
            "# Les interfaces se nomment par leur IDENTIFIANT OPNsense (wan, opt1...), celui\n"
            "# que parle l'API REST — ni le peripherique FreeBSD (igb1), ni le libelle affiche.\n"
            "# `opnsense_prochain_saut` n'est pas ici : il DERIVE du reseau de transit de\n"
            "# l'underlay (underlay.yml, cle `passerelle_sortie`). Source unique.\n---\n")
    if "fabric" in par_fichier:
        _ecrire_intrants_fabric(par_fichier["fabric"])
    if "reseau" in par_fichier and "index" in par_fichier["reseau"]:
        _ecrire_index_nomenclature(int(par_fichier["reseau"]["index"]))


def _ecrire_intrants_fabric(valeurs: dict) -> None:
    """Met a jour les cles PLATES de underlay.yml SANS reformater le fichier.

    Meme motif que `_ecrire_index_nomenclature` : ce fichier porte des commentaires qui
    expliquent des decisions d'architecture (pourquoi un seul routeur, pourquoi le
    transit vit dans l'underlay...). Un `safe_dump` les effacerait toutes. On remplace
    donc la ligne existante, en respectant son indentation, et on n'invente rien : une
    clef absente du fichier n'est PAS creee — elle n'a pas de place evidente ou aller.
    """
    if not FICHIER_UNDERLAY.exists():
        return
    texte = FICHIER_UNDERLAY.read_text(encoding="utf-8")
    for variable, chemin in CHEMINS_UNDERLAY.items():
        if variable not in valeurs:
            continue
        val = str(valeurs[variable]).strip()
        if not val:
            continue
        feuille = chemin[-1]
        # Indentation attendue : 2 espaces a la racine du bloc `underlay`, 4 si imbrique.
        indent = "  " * len(chemin)
        motif = re.compile(rf"(?m)^{indent}{re.escape(feuille)}:[ \t]*\S.*$")
        remplacement = f"{indent}{feuille}: {val}"
        texte, n = motif.subn(remplacement, texte, count=1)
        if not n:
            raise ValueError(f"underlay.yml : clef '{feuille}' introuvable — "
                             f"l'ajouter au fichier avant de la regler ici.")
    FICHIER_UNDERLAY.write_text(texte, encoding="utf-8")


def valider_nomenclature(donnees: dict, serveurs: dict) -> None:
    """Refuse une nomenclature qui casserait la derivation, AVANT d'ecrire.

    La nomenclature n'est pas un registre comme les autres : elle ne decrit pas des
    objets, elle decrit la REGLE dont VMID, VLAN, adresse et passerelle se derivent.
    Une fonction retiree ne laisse pas un trou local — elle prive de tout adressage
    chaque VM qui la porte, et `deriver_nomenclature` rend `None` SANS RIEN DIRE.

    Trois refus, dans l'ordre du degat :
      - une fonction encore portee par une VM ne se retire pas ;
      - une fonction ne peut designer qu'une zone declaree ;
      - `index` ne s'ecrit pas ici (il est ALLOUE par le site, cf. l'entete du fichier).
    """
    categories = donnees.get("categories") or {}
    fonctions = donnees.get("fonctions") or {}
    if not isinstance(categories, dict) or not isinstance(fonctions, dict):
        raise ValueError("`categories` et `fonctions` doivent etre des tables.")

    connues = {str(c) for c in categories}
    for nom, f in fonctions.items():
        if not isinstance(f, dict):
            raise ValueError(f"Fonction '{nom}': entree invalide.")
        cat = f.get("categorie")
        if cat in (None, ""):
            raise ValueError(f"Fonction '{nom}': 'categorie' requise.")
        if str(cat) not in connues:
            raise ValueError(f"Fonction '{nom}': zone {cat} non declaree dans `categories` "
                             f"— la VM n'aurait ni VLAN ni adresse.")
        if f.get("service") in (None, ""):
            raise ValueError(f"Fonction '{nom}': 'service' requis.")

    portees = {}
    for nom_vm, srv in (serveurs or {}).items():
        if isinstance(srv, dict) and srv.get("fonction"):
            portees.setdefault(str(srv["fonction"]), []).append(nom_vm)
    for fonction, vms in sorted(portees.items()):
        if fonction not in fonctions:
            raise ValueError(f"Fonction '{fonction}' retiree, mais encore portee par "
                             f"{len(vms)} VM ({', '.join(sorted(vms)[:4])}) — "
                             f"deplacer ces VM d'abord.")

    zones_utilisees = {str(f.get("categorie")) for f in fonctions.values() if isinstance(f, dict)}
    for zone in sorted(zones_utilisees - connues):
        raise ValueError(f"Zone {zone} utilisee mais non declaree.")


def ecrire_nomenclature(path: Path, donnees: dict) -> None:
    """Ecrit la nomenclature SANS effacer ses commentaires.

    POURQUOI PAS `safe_dump`. Ce fichier porte dix-neuf lignes qui disent pourquoi
    `index` EST RECU ET PAS DECIDE, et pourquoi le modele des zones est commun a toute
    la flotte. Un `safe_dump` les emporterait toutes — c'est exactement l'incident du
    2026-08-18 (94 lignes de commentaire perdues en un enregistrement). On repasse donc
    par `_fusion_chirurgicale`, qui pose les valeurs dans le texte existant.

    `index` n'est jamais du lot : il s'ecrit par `_ecrire_index_nomenclature`, depuis le
    panneau Intrants, parce qu'il vient du site et non de cette vue.
    """
    texte = path.read_text(encoding="utf-8") if path.exists() else "---\n"
    valeurs = {cle: donnees[cle] for cle in ("cidr_hote", "reservations", "categories", "fonctions")
               if cle in donnees}
    with ecriture_atomique(path) as fichier:
        fichier.write(_fusion_chirurgicale(texte, valeurs,
                                           tables={"categories", "fonctions"}))


def _ecrire_index_nomenclature(index: int) -> None:
    """Met a jour `index:` dans plan/nomenclature.yml SANS reformater le reste.

    Le fichier garde ses commentaires et son formatage compact (l'adressage se derive
    de ce seul seed). Remplacement de la ligne existante, ou insertion en tete a defaut.
    """
    path = FICHIER_NOMENCLATURE
    texte = path.read_text(encoding="utf-8") if path.exists() else "---\n"
    nouveau, remplace = re.subn(r"(?m)^index:.*$", f"index: {index}", texte)
    if not remplace:
        nouveau = re.sub(r"(?m)^(---\n)", rf"\g<1>index: {index}\n", texte, count=1) or texte
    # Atomique comme les autres : cette ecriture-ci avait ete oubliee au passage du
    # 2026-09-06, et une coupure ici laisserait le seed a moitie ecrit — c'est-a-dire
    # tout l'adressage de l'ecosysteme.
    with ecriture_atomique(path) as fichier:
        fichier.write(nouveau)


def _ecrire_registre(path: Path, entete: str, contenu: dict) -> None:
    """Ecrit un registre du plan SANS effacer les commentaires qu'il porte.

    MESURE DU 2026-09-08, sur les fichiers reels de cet ecosysteme :

        domaines.yml        6 lignes de commentaire ->  3   (PERD 3)
        applications.yml   27                       ->  5   (PERD 22)
        serveurs.yml       18                       ->  3   (PERD 15)
        bases-donnees.yml   4                       ->  4   (intact, il n'en a pas)

    Quarante lignes, detruites par n'importe quel « Sauvegarder » depuis les vues
    Serveurs, Applications ou Domaines. Parmi elles, celle qui explique pourquoi
    `backup-01` a ete RETIRE : « une supervision creuse est pire qu'aucune — elle est
    verte ». Et celle qui dit dans quel ORDRE les deux roles du runner s'appliquent.

    C'est l'incident du 2026-08-18 (94 lignes perdues dans les fichiers d'intrants),
    jamais corrige pour les registres du plan : `_fusion_chirurgicale` avait ete ecrite
    pour les intrants seuls, et les quatre `ecrire_*` sont restes au `safe_dump`.

    Les registres du plan ont tous la meme forme — une clef racine, une table d'entites —
    donc chaque clef racine est declaree comme TABLE : `_fusion_table` edite alors les
    lignes concernees, une entite retiree disparait, et le reste n'est pas touche.

    Un fichier qui n'existe pas encore recoit son entete et un `safe_dump` : il n'y a
    rien a preserver.
    """
    if path.exists():
        texte = path.read_text(encoding="utf-8")
        if texte.strip():
            with ecriture_atomique(path) as fichier:
                fichier.write(_fusion_chirurgicale(texte, contenu, tables=set(contenu)))
            return
    with ecriture_atomique(path) as fichier:
        fichier.write(entete)
        yaml.safe_dump(contenu, fichier, default_flow_style=False,
                       sort_keys=False, allow_unicode=True)


def ecrire_bases(path: Path, registre: dict) -> None:
    entete = (
        "# Registre des bases de donnees Set-OPS (serveurs_bd + bases_donnees).\n"
        "# Edite par make inventaire-ui ou scripts/bases_donnees.py.\n"
        "# 'portee' (application|groupe|hote) interprete 'consommateur' ; defaut groupe.\n"
        "# 'secret' nomme une variable Ansible Vault (jamais le mot de passe).\n"
        "---\n"
    )
    _ecrire_registre(path, entete, {
        "serveurs_bd": registre.get("serveurs_bd", {}) or {},
        "bases_donnees": registre.get("bases_donnees", {}) or {},
    })


def ecrire_applications(path: Path, registre: dict) -> None:
    entete = (
        "# Registre des applications Set-OPS (application = entite pivot).\n"
        "# Edite par make inventaire-ui ou scripts/applications.py.\n"
        "# Une VM peut porter plusieurs applications ; une base se lie a une application.\n"
        "# 'liens' = bindings declaratifs [{vers, role}] resolus par scripts/instancier.py ;\n"
        "# les roles acceptes sont ceux de roles/<groupe>/meta/liens.yml.\n"
        "---\n"
    )
    _ecrire_registre(path, entete, {"applications": registre.get("applications", {}) or {}})


def ecrire_serveurs(path: Path, registre: dict) -> None:
    entete = (
        "# Registre des serveurs (VM) du plan Set-OPS.\n"
        "# Edite par make inventaire-ui ou scripts/serveurs.py.\n"
        "# VMID/IP/VLAN/passerelle sont DERIVES de la fonction via instance/plan/nomenclature.yml.\n"
        "---\n"
    )
    _ecrire_registre(path, entete, {"serveurs": registre.get("serveurs", {}) or {}})


def ecrire_domaines(path: Path, registre: dict) -> None:
    entete = (
        "# Registre des domaines publics (zones DNS de l'instance).\n"
        "# Edite par make inventaire-ui ou scripts/domaines.py.\n"
        "# autorite : primaire-cache | auto-heberge | delegue (label descriptif).\n"
        "---\n"
    )
    _ecrire_registre(path, entete, {"domaines_publics": registre.get("domaines_publics", {}) or {}})


def _extraire_echec(ligne: str, tache: str) -> dict | None:
    """D'une ligne Ansible fatal/unreachable, tire un échec en LANGAGE CLAIR
    (tâche · hôte · type · message) — pour communiquer entre humains."""
    m = re.search(r'(?:fatal|failed):\s*\[([^\]]+)\]:\s*(FAILED!|UNREACHABLE!)?\s*=>\s*(\{.*\})', ligne)
    if not m:
        return None
    hote = m.group(1)
    typ = "injoignable (SSH)" if m.group(2) == "UNREACHABLE!" else "échec"
    detail: dict = {}
    try:
        detail = json.loads(m.group(3))
    except Exception:
        pass
    if detail.get("censored"):
        message = "sortie masquée (no_log) — souvent une tâche qui manipule un secret"
    else:
        msg = str(detail.get("msg", "")).strip()
        # Pour un échec de commande, msg est générique ; la vraie cause est dans stderr.
        stderr = ""
        for cle in ("stderr", "module_stderr", "stdout"):
            valeur = str(detail.get(cle, "")).strip()
            if valeur:
                lignes = [x for x in valeur.splitlines() if x.strip()]
                stderr = lignes[0] if lignes else valeur  # l'erreur mène, l'indice suit
                break
        if msg and msg.lower() not in ("non-zero return code", "module failure", ""):
            message = msg
        elif stderr:
            message = stderr
        else:
            message = msg or "échec sans message explicite (voir le journal complet)"
    message = " ".join(str(message).split())  # une ligne propre
    return {"tache": (tache or "?").strip(), "hote": hote, "type": typ, "message": message[:400]}


def donnees_hote(hote: dict) -> dict:
    variables: dict = {}
    for cle, var, typ in CHAMPS_PROVISION:
        brut = str(hote.get(cle, "")).strip()
        if not brut:
            continue
        if typ == "int" and brut.lstrip("-").isdigit():
            variables[var] = int(brut)
        else:
            variables[var] = brut
    return variables


def construire_inventaire(payload: dict, groupes_connus: list[str]) -> dict:
    enfants_data: dict = {
        "modeles_vm": {"hosts": {}},
        GROUPE_HOTES_ACTIFS: {"hosts": {}},
        GROUPE_HOTES_PLANIFIES: {"hosts": {}},
    }
    for groupe in groupes_connus:
        enfants_data.setdefault(groupe, {"hosts": {}})
    enfants_data.setdefault("hotes_proxmox", {"hosts": {}})

    for hote in payload.get("hotes", []):
        nom = str(hote.get("nom", "")).strip()
        if not nom:
            continue
        variables = donnees_hote(hote)
        groupe_etat = GROUPE_HOTES_ACTIFS if hote.get("etat") == "actif" else GROUPE_HOTES_PLANIFIES
        enfants_data[groupe_etat]["hosts"][nom] = variables
        for groupe in hote.get("groupes", []):
            if groupe not in groupes_connus:
                continue
            enfants_data[groupe]["hosts"][nom] = {}

    return {"all": {"children": enfants_data}}


def valider_dependances_payload(payload: dict, dependencies: dict) -> None:
    hotes = payload.get("hotes", [])
    active_groups: set[str] = set()

    for hote in hotes:
        if hote.get("etat") != "actif":
            continue
        active_groups.update(hote.get("groupes", []))

    missing: list[str] = []
    for hote in hotes:
        if hote.get("etat") != "actif":
            continue
        nom = str(hote.get("nom", "")).strip()
        for groupe in hote.get("groupes", []):
            for required_group in dependencies.get(groupe, {}).get("requiert_groupes_actifs", []):
                if required_group not in active_groups:
                    missing.append(f"{nom}: {groupe} requiert {required_group} actif")

    if missing:
        raise ValueError("Dependances manquantes: " + "; ".join(missing))


def valider_payload(payload: dict, groupes_connus: list[str], dependencies: dict) -> None:
    noms: set[str] = set()
    vmids: dict[str, str] = {}
    for hote in payload.get("hotes", []):
        nom = str(hote.get("nom", "")).strip()
        if not nom:
            raise ValueError("Un hote a un nom vide.")
        if nom in noms:
            raise ValueError(f"Hote en double: {nom}")
        noms.add(nom)
        if hote.get("etat") == "actif" and not str(hote.get("adresse_ip", "")).strip():
            raise ValueError(f"Hote actif sans adresse IP: {nom}")
        groupes = hote.get("groupes", [])
        if not groupes:
            raise ValueError(f"Aucun groupe operationnel pour: {nom}")
        inconnus = sorted(set(groupes) - set(groupes_connus))
        if inconnus:
            raise ValueError(f"Groupes inconnus pour {nom}: {', '.join(inconnus)}")

        vlan = str(hote.get("vlan", "")).strip()
        if vlan and (not vlan.isdigit() or not 1 <= int(vlan) <= 4094):
            raise ValueError(f"VLAN invalide pour {nom}: {vlan} (attendu 1-4094)")
        cidr = str(hote.get("cidr", "")).strip()
        if cidr and (not cidr.isdigit() or not 0 <= int(cidr) <= 32):
            raise ValueError(f"CIDR invalide pour {nom}: {cidr} (attendu 0-32)")
        for cle, libelle in (("memoire", "Memoire"), ("coeurs", "Coeurs")):
            valeur = str(hote.get(cle, "")).strip()
            if valeur and (not valeur.isdigit() or int(valeur) <= 0):
                raise ValueError(f"{libelle} invalide pour {nom}: {valeur} (entier positif attendu)")

        vmid = str(hote.get("vmid", "")).strip()
        if not vmid:
            continue
        if vmid in vmids:
            raise ValueError(f"VMID en double: {vmid} pour {vmids[vmid]} et {nom}")
        vmids[vmid] = nom

    valider_dependances_payload(payload, dependencies)


HTML = r"""<!doctype html>
<html lang="fr">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Set-OPS · Votre artisan numérique</title>
  <style>
    :root {
      color-scheme: dark;
      --fond:#0c1119;
      --fond-degrade:radial-gradient(1100px 540px at 100% -8%, #142033 0, transparent 55%), var(--fond);
      --surface:#151d2b;
      --surface-2:#1a2333;
      --surface-3:#212d41;
      --texte:#e8edf6;
      --muted:#93a1bb;
      --faint:#67738c;
      --ligne:#27324a;
      --ligne-forte:#36445f;
      --primaire:#3b82f6;
      --primaire-fort:#2f6fe0;
      --teal:#2dd4bf;
      --vert:#34d399; --vert-fond:rgba(52,211,153,.13);
      --bleu:#60a5fa; --bleu-fond:rgba(96,165,250,.13);
      --rouge:#f87171; --rouge-fond:rgba(248,113,113,.13);
      --ambre:#fbbf24; --ambre-fond:rgba(251,191,36,.13);
      --ombre:0 1px 2px rgba(0,0,0,.35), 0 10px 30px -14px rgba(0,0,0,.7);
      --ombre-forte:0 18px 50px -18px rgba(0,0,0,.8);
      --rayon:11px; --rayon-sm:8px;
    }
    * { box-sizing: border-box; }
    body {
      margin: 0; background: var(--fond-degrade); color: var(--texte); min-height: 100vh;
      font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
      font-size: 14px; line-height: 1.5; -webkit-font-smoothing: antialiased;
    }
    ::selection { background: color-mix(in srgb, var(--teal) 35%, transparent); }
    * { scrollbar-width: thin; scrollbar-color: var(--ligne-forte) transparent; }
    header {
      position: sticky; top: 0; z-index: 20;
      display: flex; align-items: center; gap: 16px; flex-wrap: wrap;
      padding: 12px 22px; border-bottom: 1px solid var(--ligne);
      background: color-mix(in srgb, var(--surface) 82%, transparent);
      backdrop-filter: saturate(150%) blur(12px);
    }
    .marque { display: flex; align-items: center; gap: 9px; min-width: 0; }
    .marque .pastille { width: 9px; height: 9px; border-radius: 50%; background: var(--teal); box-shadow: 0 0 0 4px color-mix(in srgb, var(--teal) 18%, transparent); flex: none; }
    .marque .titre { display: flex; flex-direction: column; line-height: 1.15; min-width: 0; }
    h1 { margin: 0; font-size: 15px; font-weight: 800; letter-spacing: -.01em; white-space: nowrap; }
    .slogan { font-size: 10.5px; color: var(--muted); font-weight: 600; letter-spacing: .02em; white-space: nowrap; }
    .chemin { color: var(--muted); font-size: 12px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
    .grandit { flex: 1 1 auto; min-width: 0; }
    .resume { display: flex; gap: 6px; flex-wrap: wrap; }
    .chip { display: inline-flex; align-items: center; gap: 6px; border: 1px solid var(--ligne); border-radius: 999px; padding: 3px 10px; background: var(--surface-2); color: var(--muted); font-size: 11.5px; font-weight: 650; }
    .chip b { color: var(--texte); font-weight: 800; }
    .pt { width: 7px; height: 7px; border-radius: 50%; flex: none; }
    .pt.actif { background: var(--vert); } .pt.plan { background: var(--bleu); } .pt.bloq { background: var(--rouge); }
    .barre { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
    .recherche { position: relative; }
    .recherche input { padding-left: 30px; min-width: 180px; }
    .recherche::before { content: "⌕"; position: absolute; left: 10px; top: 50%; transform: translateY(-50%); color: var(--faint); font-size: 16px; }
    button {
      border: 1px solid var(--ligne-forte); background: var(--surface-2); color: var(--texte);
      padding: 8px 13px; border-radius: var(--rayon-sm); cursor: pointer; font: inherit; font-weight: 700;
      transition: background .15s, border-color .15s, transform .05s, box-shadow .15s, opacity .15s, color .15s;
    }
    button:hover:not(:disabled) { border-color: var(--teal); }
    button:active:not(:disabled) { transform: translateY(1px); }
    button:disabled { opacity: .4; cursor: not-allowed; }
    button.primaire { background: var(--primaire); color: #fff; border-color: var(--primaire); box-shadow: var(--ombre); }
    button.primaire:hover:not(:disabled) { background: var(--primaire-fort); border-color: var(--primaire-fort); }
    button.fantome { background: transparent; }
    button.attention { border-color: var(--ambre); color: var(--ambre); }
    button.danger { color: var(--rouge); border-color: transparent; background: transparent; }
    button.danger:hover:not(:disabled) { background: var(--rouge-fond); }
    input, select {
      width: 100%; border: 1px solid var(--ligne-forte); border-radius: var(--rayon-sm);
      padding: 8px 10px; background: var(--surface); color: var(--texte); font: inherit;
      transition: border-color .15s, box-shadow .15s;
    }
    input::placeholder { color: var(--faint); }
    input:focus, select:focus { outline: none; border-color: var(--teal); box-shadow: 0 0 0 3px color-mix(in srgb, var(--teal) 22%, transparent); }

    main { padding: 16px 22px 44px; display: grid; grid-template-columns: minmax(0, 1.6fr) minmax(420px, 1fr); gap: 20px; align-items: start; max-width: 1760px; margin: 0 auto; }
    .toasts { position: fixed; top: 14px; right: 14px; z-index: 60; display: flex; flex-direction: column; gap: 8px; max-width: min(380px, 92vw); pointer-events: none; }
    .toast { pointer-events: auto; background: var(--surface-2); border: 1px solid var(--ligne-forte); border-left: 3px solid var(--bleu); border-radius: var(--rayon-sm); box-shadow: var(--ombre-forte); padding: 9px 12px; font-size: 13px; font-weight: 600; color: var(--texte); display: flex; gap: 9px; align-items: flex-start; animation: toast-in .18s ease-out; }
    .toast.ok { border-left-color: var(--vert); } .toast.erreur { border-left-color: var(--rouge); }
    .toast.sortant { opacity: 0; transform: translateX(12px); transition: opacity .25s, transform .25s; }
    .toast .x { margin-left: auto; cursor: pointer; opacity: .5; font-weight: 800; background: none; border: 0; color: inherit; padding: 0 2px; font-size: 15px; line-height: 1; }
    .toast .x:hover { opacity: 1; }
    @keyframes toast-in { from { opacity: 0; transform: translateX(12px); } }
    input.invalide, select.invalide { border-color: var(--rouge) !important; box-shadow: 0 0 0 1px var(--rouge); }


    .section-grille { margin-bottom: 22px; }
    .section-tete { display: flex; align-items: center; gap: 10px; margin: 0 0 11px; color: var(--faint); font-size: 11px; font-weight: 800; letter-spacing: .09em; text-transform: uppercase; }
    .section-tete .compte { color: var(--muted); }
    .section-tete::after { content: ""; height: 1px; background: var(--ligne); flex: 1; }
    .grille-cartes { display: grid; grid-template-columns: repeat(auto-fill, minmax(190px, 1fr)); gap: 12px; }
    .carte {
      position: relative; text-align: left; display: flex; flex-direction: column; gap: 8px;
      background: var(--surface); border: 1px solid var(--ligne); border-radius: var(--rayon);
      padding: 12px 13px; cursor: pointer; font: inherit; color: var(--texte);
      transition: border-color .14s, box-shadow .14s, transform .05s, background .14s;
    }
    .carte::before { content: ""; position: absolute; left: 0; top: 11px; bottom: 11px; width: 3px; border-radius: 0 3px 3px 0; background: var(--bleu); }
    .carte.actif::before { background: var(--vert); }
    .carte.bloque::before { background: var(--rouge); }
    .carte:hover { border-color: var(--ligne-forte); box-shadow: var(--ombre); }
    .carte.selectionnee { border-color: var(--teal); box-shadow: 0 0 0 1px var(--teal), var(--ombre); background: var(--surface-2); }
    .carte-haut { display: flex; align-items: center; justify-content: space-between; gap: 8px; }
    .carte-vmid { color: var(--faint); font-size: 11px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
    .carte-nom { font-weight: 800; font-size: 14px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
    .carte-nom.sans { color: var(--faint); font-style: italic; font-weight: 600; }
    .carte-ip { color: var(--muted); font-size: 12px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
    .carte-grps { display: flex; gap: 5px; flex-wrap: wrap; margin-top: 1px; }
    .tag { font-size: 10.5px; font-weight: 700; padding: 2px 7px; border-radius: 999px; background: var(--surface-3); color: var(--muted); white-space: nowrap; }
    .tag.plus { background: transparent; color: var(--faint); }
    .badge-statut { display: inline-flex; align-items: center; gap: 5px; border-radius: 999px; padding: 3px 9px; font-size: 10.5px; font-weight: 800; }
    .badge-statut.ok { color: var(--vert); background: var(--vert-fond); }
    .badge-statut.attente { color: var(--bleu); background: var(--bleu-fond); }
    .badge-statut.bloque { color: var(--rouge); background: var(--rouge-fond); }

    aside { position: sticky; top: 70px; max-height: calc(100vh - 90px); overflow: auto; }
    .detail { background: var(--surface); border: 1px solid var(--ligne); border-radius: var(--rayon); box-shadow: var(--ombre); overflow: hidden; }
    .detail.bloque { border-color: color-mix(in srgb, var(--rouge) 50%, var(--ligne)); }
    .detail-tete { display: flex; align-items: center; gap: 10px; padding: 14px 16px 12px; border-bottom: 1px solid var(--ligne); flex-wrap: wrap; }
    .detail-nom { flex: 1 1 150px; min-width: 0; }
    .zone-hint { display: inline-block; margin: 4px 0 0 8px; font-size: 11px; font-weight: 700; color: var(--teal); }
    .stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(64px, 1fr)); gap: 8px; padding: 14px 16px; }
    .stat { background: var(--surface-2); border: 1px solid var(--ligne); border-radius: var(--rayon-sm); padding: 9px 10px; min-width: 0; }
    .stat .v { font-size: 18px; font-weight: 800; line-height: 1.1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
    .stat .v.vide { color: var(--faint); }
    .stat .l { font-size: 9.5px; text-transform: uppercase; letter-spacing: .06em; color: var(--faint); font-weight: 800; margin-top: 3px; }
    .grille { display: grid; grid-template-columns: repeat(auto-fit, minmax(135px, 1fr)); gap: 11px 12px; }
    .champ { display: flex; flex-direction: column; gap: 4px; min-width: 0; }
    .champ > span { color: var(--muted); font-size: 11px; font-weight: 700; }
    .champ .unite { color: var(--faint); font-weight: 600; }
    .champ > span.a-aide { cursor: help; border-bottom: 1px dotted var(--ligne-forte); width: fit-content; }
    .aide-modele { margin: 0 2px 14px; background: var(--surface); border: 1px solid var(--ligne); border-left: 3px solid var(--bleu); border-radius: var(--rayon-sm); }
    .aide-modele > summary { cursor: pointer; padding: 10px 13px; font-size: 12.5px; font-weight: 750; color: var(--bleu); list-style: none; }
    .aide-modele > summary::-webkit-details-marker { display: none; }
    .aide-modele > summary::before { content: "ⓘ "; }
    .aide-corps { padding: 2px 15px 12px; color: var(--muted); font-size: 12.5px; line-height: 1.55; }
    .aide-corps p { margin: 6px 0; } .aide-corps ul { margin: 6px 0; padding-left: 18px; } .aide-corps li { margin: 3px 0; }
    .aide-corps b { color: var(--texte); }
    .aide-ro { border-top: 1px solid var(--ligne); padding-top: 8px; }
    .detail-nom-txt { font-weight: 800; font-size: 17px; padding: 4px 7px; display: inline-block; overflow-wrap: anywhere; }
    #infobulle {
      position: fixed; z-index: 200; max-width: 260px; pointer-events: none;
      background: var(--surface-3); color: var(--texte);
      border: 1px solid var(--ligne-forte); border-radius: var(--rayon-sm);
      padding: 7px 10px; font-size: 12px; font-weight: 600; line-height: 1.4;
      box-shadow: var(--ombre); opacity: 0; transform: translateY(2px);
      transition: opacity .12s ease, transform .12s ease;
    }
    #infobulle.on { opacity: 1; transform: none; }
    .pied { padding: 12px 16px; border-top: 1px solid var(--ligne); display: flex; gap: 8px; align-items: center; }
    .pied .grandit { flex: 1; }
    .pied .hint-dep { color: var(--faint); font-size: 12px; font-style: italic; }
    .dep-bloc { margin-top: 4px; }
    .dep-bloc > summary { list-style: none; cursor: pointer; padding: 10px 13px; display: flex; align-items: center; justify-content: space-between; gap: 8px; font-weight: 800; font-size: 12.5px; background: var(--surface); border: 1px solid var(--ligne); border-radius: var(--rayon-sm); }
    .dep-bloc > summary::-webkit-details-marker { display: none; }
    .dep-bloc > summary::after { content: "▾"; color: var(--faint); }
    .dep-bloc[open] > summary { border-radius: var(--rayon-sm) var(--rayon-sm) 0 0; }
    .dep-corps { border: 1px solid var(--ligne); border-top: none; border-radius: 0 0 var(--rayon-sm) var(--rayon-sm); padding: 11px; display: grid; grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); gap: 8px; }
    .carte-dep { border: 1px solid var(--ligne); border-radius: var(--rayon-sm); padding: 9px 10px; background: var(--surface-2); }
    .carte-dep.ok { border-color: color-mix(in srgb, var(--vert) 45%, var(--ligne)); }
    .carte-dep.attente { border-color: color-mix(in srgb, var(--ambre) 45%, var(--ligne)); }
    .carte-dep.bloque { border-color: color-mix(in srgb, var(--rouge) 50%, var(--ligne)); }
    .carte-dep .haut { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 4px; }
    .carte-dep .nom { font-weight: 800; font-size: 12px; overflow-wrap: anywhere; }
    .carte-dep .txt { color: var(--muted); font-size: 11px; line-height: 1.4; }
    .vide { color: var(--muted); padding: 40px 24px; text-align: center; }
    .vide b { color: var(--texte); display: block; margin-bottom: 4px; font-size: 15px; }

    .vue-bascule { display: inline-flex; border: 1px solid var(--ligne-forte); border-radius: 999px; padding: 2px; background: var(--surface-3); gap: 2px; }
    .vue-bascule button { border: none; background: transparent; border-radius: 999px; padding: 6px 13px; font-size: 12.5px; font-weight: 750; color: var(--muted); box-shadow: none; }
    .vue-bascule button:hover { color: var(--texte); background: transparent; }
    .vue-bascule button.on { background: var(--surface); color: var(--teal); box-shadow: var(--ombre); }
    .mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; color: var(--teal); font-size: 12px; }
    .ch-stub { color: var(--ambre); font-size: 11.5px; font-style: italic; margin-top: 5px; }
    .ch-bases { display: grid; gap: 4px; margin: 6px 0 0 23px; }
    .ch-base { font-size: 11.5px; color: var(--muted); overflow-wrap: anywhere; }
    .badge-bd { display: inline-block; font-size: 10px; font-weight: 800; padding: 1px 6px; border-radius: 999px; background: color-mix(in srgb, var(--bleu) 18%, transparent); color: var(--bleu); }

    .modale { position: fixed; inset: 0; z-index: 50; display: flex; align-items: center; justify-content: center; background: rgba(0,0,0,.55); }
    .modale[hidden] { display: none; }
    .modale-boite { background: var(--surface); border: 1px solid var(--ligne-forte); border-radius: var(--rayon); box-shadow: var(--ombre-forte); padding: 18px 20px; width: min(440px, 92vw); display: grid; gap: 12px; }
    .modale-titre { font-weight: 800; font-size: 15px; }
    .modale-texte { color: var(--muted); font-size: 13px; line-height: 1.5; }
    .modale-actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 4px; }
    .modale-boite.large { width: min(760px, 94vw); max-height: 88vh; overflow: auto; }
    .intrants-corps { display: grid; gap: 16px; }
    .intr-section { display: grid; gap: 9px; }
    .intr-tete { font-weight: 800; font-size: 13px; color: var(--bleu); border-bottom: 1px solid var(--ligne); padding-bottom: 5px; }
    .intr-grille { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 11px; }
    .badge-classe { display: inline-block; font-size: 9.5px; font-weight: 800; letter-spacing: .04em; text-transform: uppercase; padding: 1px 6px; border-radius: 999px; margin-left: 6px; vertical-align: middle; }
    .badge-classe.const { background: color-mix(in srgb, var(--ambre) 20%, transparent); color: var(--ambre); }
    .badge-classe.def { background: color-mix(in srgb, var(--bleu) 18%, transparent); color: var(--bleu); }
    .badge-classe.cat { background: color-mix(in srgb, var(--teal) 20%, transparent); color: var(--teal); }
    .badge-prod { display: inline-flex; align-items: center; font-size: 11px; font-weight: 800; letter-spacing: .06em; padding: 3px 9px; border-radius: 999px; background: var(--rouge); color: #fff; }
    .badge-lab { display: inline-flex; align-items: center; font-size: 11px; font-weight: 800; letter-spacing: .04em; padding: 3px 9px; border-radius: 999px; background: color-mix(in srgb, var(--teal) 22%, transparent); color: var(--teal); }
    .integ-cases { display: flex; flex-wrap: wrap; gap: 6px 12px; padding: 4px 2px; }
    .integ-case { display: inline-flex; align-items: center; gap: 5px; font-size: 12px; font-weight: 600; color: var(--texte); cursor: pointer; }
    .integ-univ { color: var(--vert); font-weight: 700; cursor: help; }
    .integ-exempt { color: var(--faint); text-decoration: line-through; cursor: help; }
    .integ-case input { width: 14px; height: 14px; flex: none; accent-color: var(--teal); }
    /* Matrice serveurs x integrations */
    .mx-cadre { overflow: auto; max-height: calc(100vh - 210px); }
    .mx { border-collapse: separate; border-spacing: 0; font-size: 12px; width: max-content; min-width: 100%; }
    .mx th, .mx td { border-bottom: 1px solid var(--ligne); padding: 5px 8px; }
    .mx thead th, .mx tfoot td, .mx tfoot th { position: sticky; background: var(--surface-2); z-index: 2; }
    .mx thead th { top: 0; font-size: 11px; font-weight: 700; letter-spacing: .04em; color: var(--muted); text-align: center; white-space: nowrap; }
    .mx thead th.mx-t-univ { color: var(--vert); }
    .mx tfoot td, .mx tfoot th { bottom: 0; font-variant-numeric: tabular-nums; text-align: center; color: var(--muted); font-weight: 700; }
    .mx .mx-plein { color: var(--vert); }
    .mx .mx-h { position: sticky; left: 0; background: var(--surface); text-align: left; font-weight: 700; color: var(--texte); white-space: nowrap; cursor: pointer; z-index: 1; }
    .mx thead .mx-coin, .mx tfoot .mx-coin { left: 0; z-index: 3; }
    .mx .mx-h:hover { color: var(--teal); }
    .mx .mx-fn { display: block; font-size: 10px; font-weight: 500; color: var(--faint); }
    .mx tr.mx-sel .mx-h { box-shadow: inset 3px 0 0 var(--teal); }
    .mx .mx-c { text-align: center; }
    .mx .mx-c input { width: 14px; height: 14px; accent-color: var(--teal); cursor: pointer; }
    .mx .mx-univ { color: var(--vert); font-weight: 800; cursor: help; }
    .mx .mx-exempt { color: var(--faint); cursor: help; }
    .mx-leg { margin-top: 10px; }
    .mx-leg code { font-size: 12px; }
    .lien-objet { background: none; border: 0; padding: 0; color: var(--bleu); font: inherit; font-weight: 700; cursor: pointer; text-decoration: underline dotted; }
    .lien-objet:hover { color: var(--teal); }
    .intr-proprio { margin-left: 8px; font-size: 10px; font-weight: 800; letter-spacing: .06em;
      text-transform: uppercase; padding: 2px 8px; border-radius: 999px; cursor: help; }
    .intr-proprio.heb { background: color-mix(in srgb, var(--ambre) 20%, transparent); color: var(--ambre); }
    .intr-proprio.ten { background: color-mix(in srgb, var(--bleu) 18%, transparent); color: var(--bleu); }
    .intr-ro { color: var(--muted); font-size: 12px; line-height: 1.55; }
    .intr-ro b { color: var(--texte); font-weight: 700; }
    .intr-secrets { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 6px; }
    .intr-secrets code { font-size: 11px; background: var(--surface-2); border: 1px solid var(--ligne); border-radius: var(--rayon-sm); padding: 1px 6px; color: var(--muted); }
    .console { position: fixed; left: 0; right: 0; bottom: 0; height: 44vh; background: var(--surface); border-top: 1px solid var(--ligne-forte); box-shadow: 0 -16px 50px -18px rgba(0,0,0,.8); z-index: 40; display: flex; flex-direction: column; }
    .console[hidden] { display: none; }
    .console-tete { display: flex; align-items: center; gap: 12px; padding: 9px 16px; border-bottom: 1px solid var(--ligne); background: var(--surface-2); }
    .console-titre { font-weight: 800; font-size: 13px; }
    .console-etat { font-size: 12px; font-weight: 800; }
    .console-etat.actif { color: var(--bleu); animation: pulse 1.2s ease-in-out infinite; }
    .console-etat.ok { color: var(--vert); } .console-etat.echec { color: var(--rouge); }
    @keyframes pulse { 50% { opacity: .4; } }
    .console pre { margin: 0; padding: 12px 16px; overflow: auto; flex: 1; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; line-height: 1.45; white-space: pre-wrap; word-break: break-word; color: #cdd6e6; }
    @media (max-width: 1000px) {
      main { grid-template-columns: 1fr; }
      aside { position: static; max-height: none; order: -1; }
    }
    /* Vues lecture seule : Flux + Couches */
    .tbl-lecture { width: 100%; border-collapse: collapse; font-size: 12.5px; }
    .tbl-lecture th { text-align: left; padding: 7px 10px; color: var(--muted); font-weight: 750; border-bottom: 1px solid var(--ligne-forte); position: sticky; top: 0; background: var(--surface); }
    .tbl-lecture td { padding: 6px 10px; border-bottom: 1px solid var(--ligne); vertical-align: top; }
    .tbl-lecture tr:hover td { background: var(--surface-2); }
    .flux-raison { color: var(--muted); max-width: 44ch; }
    .sens { font-size: 11px; font-weight: 750; padding: 1px 7px; border-radius: 999px; }
    .sens-ingress { background: color-mix(in srgb, var(--bleu) 16%, transparent); color: var(--bleu); }
    .sens-egress { background: color-mix(in srgb, var(--ambre) 18%, transparent); color: var(--ambre); }
    .chip.chi-tls-requis { background: color-mix(in srgb, var(--teal) 22%, transparent); color: var(--teal); }
    .chip.chi-tls { background: color-mix(in srgb, var(--teal) 13%, transparent); color: var(--teal); }
    .chip.chi-starttls { background: color-mix(in srgb, var(--ambre) 18%, transparent); color: var(--ambre); }
    .chip.chi-ssh { background: color-mix(in srgb, var(--bleu) 18%, transparent); color: var(--bleu); }
    .chip.chi-tls-cible { background: color-mix(in srgb, var(--ambre) 12%, transparent); color: var(--muted); }
    .chip.chi-clair { background: var(--surface-3); color: var(--muted); }
    .couches-pile { display: flex; flex-direction: column; gap: 0; padding: 6px; }
    .couche { border: 1px solid var(--ligne-forte); border-radius: 10px; padding: 9px 12px; background: var(--surface-2); }
    .couche-tete { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; }
    .couche-idx { display: inline-flex; width: 20px; height: 20px; align-items: center; justify-content: center; border-radius: 999px; background: var(--teal); color: var(--surface); font-size: 11px; font-weight: 800; }
    .couche-groupes { display: flex; flex-wrap: wrap; gap: 5px; }
    .couche-fleche { text-align: center; color: var(--muted); font-size: 14px; line-height: 1.5; }
    .legende { display: flex; flex-direction: column; gap: 6px; font-size: 12px; color: var(--muted); }
    .legende .chip { margin-right: 4px; }
    /* Résumé d'erreur en langage clair (console) */
    #console-resume { padding: 12px 16px; background: color-mix(in srgb, var(--rouge) 10%, var(--surface)); border-bottom: 1px solid var(--ligne); }
    .re-tete { display: flex; align-items: center; gap: 10px; font-weight: 800; color: var(--rouge); font-size: 13px; margin-bottom: 6px; }
    .re-tete button { margin-left: auto; }
    .re-liste { margin: 0; padding-left: 18px; display: flex; flex-direction: column; gap: 7px; }
    .re-liste li { font-size: 12.5px; }
    .re-hote { color: var(--teal); font-weight: 700; }
    .re-type { color: var(--muted); font-size: 11px; }
    .re-msg { background: var(--surface-3); border-radius: 6px; padding: 4px 8px; margin-top: 3px; font-family: ui-monospace, monospace; font-size: 11.5px; white-space: pre-wrap; word-break: break-word; }
    /* Devis réseau (config switch) */
    .devis-reseau { margin: 8px 0 0; padding: 12px 14px; background: var(--surface-3); border-radius: 8px; font-family: ui-monospace, monospace; font-size: 11.5px; line-height: 1.5; white-space: pre; overflow: auto; max-height: calc(100vh - 210px); }
  
/* --- LES ASSISTANTS (runbooks) ------------------------------------------------ */
.rb-liste{display:flex;flex-wrap:wrap;gap:8px;margin:2px 0 14px}
.rb-puce{border:1px solid var(--bord,#2a3340);background:#131a22;color:inherit;border-radius:999px;
  padding:6px 13px;font-size:12.5px;font-weight:700;cursor:pointer;display:flex;align-items:center;gap:7px}
.rb-puce.on{background:#1d2a38;border-color:#3d6ea8}
.rb-puce.hors{opacity:.55}
.rb-etape{border:1px solid var(--bord,#2a3340);border-radius:10px;padding:11px 13px;margin-bottom:9px;
  display:grid;grid-template-columns:30px 1fr auto;gap:11px;align-items:start;background:#10161d}
.rb-etape.faite{border-color:#2f6b45}
.rb-etape.ratee{border-color:#8a3b3b}
.rb-etape.bloquee{opacity:.5}
.rb-num{font-weight:800;opacity:.55;text-align:right;padding-top:2px}
.rb-cible{font-family:ui-monospace,Menlo,monospace;font-size:12.5px;font-weight:700}
.rb-libelle{font-size:12.5px;opacity:.9;margin-top:2px}
.rb-pourquoi{font-size:12px;opacity:.72;margin-top:5px;line-height:1.45}
.rb-nature{font-size:10.5px;font-weight:800;letter-spacing:.03em;padding:2px 7px;border-radius:999px;margin-left:7px}
.rb-nature.mesure{background:#1b2c3a;color:#8fc4f0}
.rb-nature.ecriture{background:#2e2716;color:#e6bf6a}
.rb-nature.destructif{background:#3a1c1c;color:#f08a8a}
.rb-meta{font-size:11.5px;opacity:.6;margin-top:4px}
.rb-but{font-size:12.5px;line-height:1.5;opacity:.88}
</style>
</head>
<body>
  <div class="toasts" id="toasts" aria-live="polite"></div>
  <header>
    <div class="marque"><span class="pastille"></span><div class="titre"><h1>Set-OPS</h1><span class="slogan">Votre artisan numérique</span></div></div>
    <span class="chemin" id="chemin"></span>
    <span id="portee" style="font-size:11.5px;font-weight:800;letter-spacing:.02em;padding:3px 9px;border-radius:999px;white-space:nowrap"
          title="Ce que cette console peut faire — dérivé de ce que sa machine porte, pas d'un réglage"></span>
    <div class="grandit"></div>
    <div class="resume" id="resume"></div>
    <div class="barre" title="Raccourcis clavier — 1-3 : changer de vue · j/k : naviguer les serveurs · v : vérifier · d : déployer · / : filtrer · Ctrl+S : sauvegarder la vue">
      <div class="vue-bascule">
        <button type="button" id="btn-vue-serveurs" class="on" onclick="setVue('serveurs')">Serveurs</button>
        <button type="button" id="btn-vue-applications" onclick="setVue('applications')">Applications</button>
        <button type="button" id="btn-vue-bases" onclick="setVue('bases')">Bases</button>
        <button type="button" id="btn-vue-domaines" onclick="setVue('domaines')">Domaines</button>
        <button type="button" id="btn-vue-nomenclature" onclick="setVue('nomenclature')">Nomenclature</button>
        <button type="button" id="btn-vue-integrations" onclick="setVue('integrations')">Intégrations</button>
        <button type="button" id="btn-vue-flux" onclick="setVue('flux')">Flux</button>
        <button type="button" id="btn-vue-couches" onclick="setVue('couches')">Couches</button>
        <button type="button" id="btn-vue-reseau" onclick="setVue('reseau')">Réseau</button>
        <button type="button" id="btn-vue-assistants" onclick="setVue('assistants')" title="Les runbooks de construction : l'ordre des gestes, et pourquoi celui-là">Assistants</button>
      </div>
      <span class="recherche"><input id="filtre" type="search" placeholder="Filtrer…" oninput="filtrer(this.value)"></span>
      <button type="button" class="fantome" onclick="ouvrirIntrants()">⚙ Intrants</button>
      <button type="button" class="fantome" onclick="charger()">Recharger</button>
      <button type="button" class="primaire" id="btn-sauver" onclick="sauvegarderVue()">Sauvegarder</button>
    </div>
  </header>
  <main>
    <section>
      <div id="grilles"></div>
      <details class="dep-bloc" id="panneau-dep">
        <summary>Dépendances causales <span id="dep-resume" class="chip"></span></summary>
        <div class="dep-corps" id="dependances"></div>
      </details>
    </section>
    <aside><div id="detail"></div></aside>
  </main>
  <div class="modale" id="modale" hidden>
    <div class="modale-boite">
      <div class="modale-titre" id="modale-titre"></div>
      <div class="modale-texte" id="modale-texte"></div>
      <label class="champ"><span>Mot de passe du vault Ansible (laisser vide si non requis)</span>
        <input type="password" id="modale-vault" autocomplete="off" placeholder="••••••••" onkeydown="if(event.key==='Enter')confirmerModale()"></label>
      <div class="modale-actions">
        <button type="button" onclick="annulerModale()">Annuler</button>
        <button type="button" class="primaire" onclick="confirmerModale()">Confirmer</button>
      </div>
    </div>
  </div>
  <div class="modale" id="intrants" hidden>
    <div class="modale-boite large">
      <div class="modale-titre">⚙ Intrants de base de l'écosystème</div>
      <div class="modale-texte">Saisis ici les valeurs communes à tout l'écosystème, depuis un endroit unique.
        Les <b>constantes</b> sont une valeur unique non surchargeable&nbsp;; les <b>défauts</b> resurgissent
        comme valeurs proposées là où ils réapparaissent dans les instances déclarées.
        Les secrets ne sont jamais saisis ici&nbsp;: ils restent dans le Vault Ansible (CLI).</div>
      <div class="intrants-corps" id="intrants-corps"></div>
      <div class="modale-actions">
        <button type="button" onclick="fermerIntrants()">Fermer</button>
        <button type="button" class="primaire" onclick="enregistrerIntrants()">Enregistrer</button>
      </div>
    </div>
  </div>
  <div class="modale" id="etape" hidden>
    <div class="modale-boite">
      <div class="modale-titre" id="etape-titre"></div>
      <div class="modale-texte" id="etape-texte"></div>
      <div id="etape-champs"></div>
      <label class="champ"><span>Mot de passe du vault Ansible (laisser vide si non requis)</span>
        <input type="password" id="etape-vault" autocomplete="off" placeholder="••••••••"></label>
      <div class="modale-actions">
        <button type="button" onclick="annulerEtape()">Annuler</button>
        <button type="button" class="primaire" id="etape-ok" onclick="confirmerEtape()">Lancer</button>
      </div>
    </div>
  </div>
  <div class="console" id="console" hidden>
    <div class="console-tete">
      <span class="console-titre" id="console-titre"></span>
      <span class="console-etat" id="console-etat"></span>
      <span class="grandit"></span>
      <button type="button" id="btn-fermer-console" onclick="fermerConsole()">Fermer</button>
    </div>
    <div id="console-resume" hidden></div>
    <pre id="console-sortie"></pre>
  </div>
  <script>
    const JETON = "__JETON__";
    let groupes = [];
    let dependances = {};
    let nomenclature = {};
    // LE SCHEMA DES REGISTRES, a portee globale. Les formulaires generes le lisaient dans
    // `data.schema` — or il n'existe AUCUN `data` global ici : c'est une const locale de
    // `charger()`. Le rendu levait donc `ReferenceError` dans un navigateur, et
    // `sauvegarderBases` pire encore (zone morte : `const data` y est declare plus bas,
    // dans la meme fonction). Eprouver le rendu sous node en LUI FOURNISSANT `data` ne
    // pouvait pas le voir : le banc reproduisait la fonction, pas sa portee.
    let schemaPlan = {};
    let chaine = {};
    let hotes = [];
    let estProduction = false;
    let filtre = '';
    let vuePrincipale = 'serveurs';
    let fluxRegistre = [];      // matrice des flux réseau (lecture seule)
    let couchesRegistre = [];   // ordre de déploiement en couches (lecture seule)
    let bdServeurs = [];
    let bdApplis = [];
    let basesModifie = false;
    let selApp = null;     // index de l'application sélectionnée (vue Applications)
    let selServeur = null; // index du serveur sélectionné (vue Serveurs, maître-détail fusionné)
    let selBase = null;    // clé de l'item sélectionné (vue Bases) : "srv:<i>" ou "bd:<i>"
    let hoteOpCourant = ''; // nom de l'hôte dont les boutons Vérifier/Déployer sont affichés
    let applications = [];
    let applicationsModifie = false;
    let nomEdit = {};         // nomenclature en cours d'édition (copie de travail)
    let selNom = null;        // 'cat:<clef>' ou 'fon:<clef>' — l'entrée sélectionnée
    let nomModifie = false;
    let domaines = [];        // registre des domaines (éditable)
    let selDomaine = null;    // index du domaine sélectionné
    let domainesModifie = false;
    const AUTORITES_DNS = ['primaire-cache', 'auto-heberge', 'delegue'];
    let serveurs = [];
// La selection de la vue « machines du site » — distincte de `selServeur`, qui indexe un
// registre de plan que cette console n'a pas.
let selMachine = null;
    let serveursModifie = false;
    let ongletActif = 'reseau';
    let occupe = false;
    let verifie = {};
    let motVault = '';
    let modaleResolveur = null;
    let intrants = null;
    let integrationsDispo = [];
    let integrationsUniv = {};
    let liensAcceptes = {};
    let sondes = {};   // état RÉEL par hôte : joignable (SSH) ou non — distinct du plan
    let chronoConsole = null;
    let consoleDebut = 0;

    let toastSeq = 0;
    function message(texte, type='', opts={}) {
      const conteneur = document.getElementById('toasts');
      if (!conteneur) return null;
      const t = document.createElement('div');
      t.className = 'toast' + (type ? ' ' + type : '');
      t.id = 'toast-' + (++toastSeq);
      const corps = document.createElement('span');
      corps.textContent = texte;
      t.appendChild(corps);
      const x = document.createElement('button');
      x.type = 'button'; x.className = 'x'; x.textContent = '×';
      x.onclick = () => retirerToast(t);
      t.appendChild(x);
      conteneur.appendChild(t);
      while (conteneur.children.length > 6) conteneur.removeChild(conteneur.firstChild);
      const duree = opts.persistant ? 0 : (opts.duree != null ? opts.duree : (type === 'erreur' ? 7000 : 3500));
      if (duree > 0) setTimeout(() => retirerToast(t), duree);
      return t;   // renvoie le nœud pour permettre de le mettre à jour (opérations longues)
    }
    function majToast(t, texte, type, dureeFin) {
      if (!t) return;
      if (type !== undefined) t.className = 'toast' + (type ? ' ' + type : '');
      const corps = t.querySelector('span'); if (corps) corps.textContent = texte;
      if (dureeFin) setTimeout(() => retirerToast(t), dureeFin);
    }
    function retirerToast(t) {
      if (!t || !t.parentNode) return;
      t.classList.add('sortant');
      setTimeout(() => { if (t.parentNode) t.parentNode.removeChild(t); }, 260);
    }

    let contexte = null;

    // LE MEME PARTAGE QUE `POUVOIR_REQUIS` COTE SERVEUR, ecrit une fois ici pour la page.
    // Ce n'est pas la garde — la garde refuse au serveur — c'est ce qui evite d'aller au
    // refus pour l'apprendre. P81 verifie que les quatre modes y figurent encore.
    const POUVOIR_PAR_MODE = {creer: 'materialiser', verifier: 'configurer',
                              deployer: 'configurer', pousser: 'configurer'};
    // SANS CONTEXTE CONNU, ON NE RETIRE RIEN. Une console qui griserait ses boutons parce
    // qu'elle n'a pas su lire sa portée serait pire que le défaut qu'on corrige : elle
    // empêcherait un geste légitime sans rien expliquer. Le serveur, lui, refuse quand
    // même — c'est lui la garde.
    function peut(pouvoir) { return !contexte || !contexte.peut || !!contexte.peut[pouvoir]; }
    function pourquoiPas(pouvoir) {
      return (contexte && contexte.raison && contexte.raison[pouvoir]) || '';
    }

    // LA CONSOLE DIT CE QU'ELLE EST. Trois consoles identiques à trois URL différentes
    // sont un piège pour qui en ouvre deux : celle d'un site et celle d'un locataire ne
    // peuvent pas les mêmes gestes, et rien ne le disait.
    function appliquerContexte(ctx) {
      // ON VERIFIE LA FORME AVANT DE L'ADOPTER (mesuré le 2026-09-16, par le banc de
      // rendu). Ma première version prenait tout ce qu'on lui donnait : une réponse qui
      // n'était pas un contexte — celle d'une autre route — passait, puis `peut()` lisait
      // `contexte.peut[...]` sur `undefined` et la page mourait d'un TypeError à
      // l'ouverture. `node --check` n'y voyait rien : la syntaxe était juste.
      if (!ctx || typeof ctx.peut !== 'object' || typeof ctx.portee !== 'string') return;
      contexte = ctx;
      const badge = document.getElementById('portee');
      if (!badge) return;
      // LES COULEURS DU THEME, PAS LES MIENNES (corrige le 2026-09-16). Ma premiere
      // version posait un texte sombre sur un fond clair — illisible sur une console qui
      // est en thème sombre. Vu sur une capture, pas dans le code : une couleur ne se
      // relit pas, elle se regarde.
      const couleurs = {
        site:     ['#e0a83a', 'rgba(185, 134, 11, .18)'],
        tenant:   ['var(--teal)', 'var(--surface-3)'],
        poste:    ['var(--muted)', 'var(--surface-3)'],
        orphelin: ['var(--rouge)', 'var(--surface-3)'],
      };
      const [fg, bg] = couleurs[ctx.portee] || couleurs.poste;
      badge.textContent = ctx.titre;
      badge.style.color = fg;
      badge.style.background = bg;
      document.body.dataset.portee = ctx.portee;
      // Ce que la portée interdit ne se propose pas. Le serveur refuse de toute façon
      // (POUVOIR_REQUIS) ; ceci évite d'aller au refus pour l'apprendre.
      const verrou = (el, permis, pourquoi) => {
        if (!el) return;
        el.disabled = !permis;
        el.title = permis ? (el.title || '') : pourquoi;
        el.style.opacity = permis ? '' : '.45';
      };
      verrou(document.getElementById('btn-sauver'), ctx.peut.editer_le_plan,
             ctx.raison.editer_le_plan);
      document.querySelectorAll('button[onclick^="ouvrirIntrants"]').forEach(
        b => verrou(b, ctx.peut.editer_le_plan, ctx.raison.editer_le_plan));
    }

    async function charger() {
      try {
        const ctxRep = await fetch('/api/contexte');
        if (ctxRep.ok) appliquerContexte(await ctxRep.json());
      } catch (e) { /* une console sans contexte reste utilisable, en aveugle */ }
      const reponse = await fetch('/api/inventaire');
      const data = await reponse.json();
      if (data.contexte) appliquerContexte(data.contexte);
      groupes = data.groupes;
      dependances = data.dependances || {};
      nomenclature = data.nomenclature || {};
      schemaPlan = data.schema || {};
      chaine = data.chaine || {};
      fluxRegistre = data.flux || [];
      couchesRegistre = data.couches || [];
      intrants = data.intrants || null;
      integrationsDispo = data.integrations_disponibles || [];
      integrationsUniv = data.integrations_universelles || {};
      liensAcceptes = data.liens_acceptes || {};
      chargerBases(data);
      chargerApplications(data);
      chargerDomaines(data);
      chargerNomEdit(data);
      chargerServeurs(data);
      hotes = data.hotes;
      estProduction = !!data.production;
      verifie = {};
      document.getElementById('chemin').textContent = data.inventaire;
      if (selServeur == null || selServeur >= serveurs.length) selServeur = serveurs.length ? 0 : null;
      dessiner();
      message('Inventaire chargé.', 'ok');
      sonder();   // état réel (joignabilité) en arrière-plan, non bloquant
    }

    async function sonder() {
      try {
        const r = await fetch('/api/sondes');
        if (r.ok) { sondes = await r.json(); dessiner(); }
      } catch (e) { /* silencieux */ }
    }

    function setOnglet(o) { ongletActif = o; dessinerDetail(); }
    function filtrer(valeur) { filtre = (valeur || '').trim().toLowerCase(); dessinerGrilles(); }

    function groupesActifs() { const a = new Set(); hotes.forEach(h => { if (h.etat === 'actif') (h.groupes || []).forEach(g => a.add(g)); }); return a; }
    function groupesPlanifies() { const p = new Set(); hotes.forEach(h => (h.groupes || []).forEach(g => p.add(g))); return p; }
    function statutDependance(groupe) {
      const requis = ((dependances[groupe] || {}).requiert_groupes_actifs || []);
      if (!requis.length) return 'neutre';
      const actifs = groupesActifs(), planifies = groupesPlanifies();
      const manquants = requis.filter(i => !actifs.has(i));
      if (!manquants.length) return 'ok';
      if (manquants.every(i => planifies.has(i))) return 'attente';
      return 'bloque';
    }
    function manquantsPourGroupe(groupe) { const a = groupesActifs(); return ((dependances[groupe] || {}).requiert_groupes_actifs || []).filter(i => !a.has(i)); }
    function hoteBloque(h) { if (!h || h.etat !== 'actif') return false; return (h.groupes || []).some(g => manquantsPourGroupe(g).length); }
    function libelleStatut(s) { return {ok:'actif', attente:'planifié', bloque:'bloqué', neutre:'libre'}[s] || s; }

    function dessiner() { dessinerResume(); dessinerGrilles(); dessinerDependances(); dessinerDetail(); majIndicateurSauvegarde(); }

    function majIndicateurSauvegarde() {
      const b = document.getElementById('btn-sauver');
      if (!b) return;
      const editable = vuePrincipale === 'serveurs' || vuePrincipale === 'integrations' || vuePrincipale === 'applications' || vuePrincipale === 'bases' || vuePrincipale === 'domaines' || vuePrincipale === 'nomenclature';
      const sale = ((vuePrincipale === 'serveurs' || vuePrincipale === 'integrations') && serveursModifie)
                || (vuePrincipale === 'applications' && applicationsModifie)
                || (vuePrincipale === 'bases' && basesModifie)
                || (vuePrincipale === 'domaines' && domainesModifie)
                || (vuePrincipale === 'nomenclature' && nomModifie);
      b.classList.toggle('attention', sale);
      b.textContent = sale ? 'Sauvegarder •' : 'Sauvegarder';
      b.disabled = !editable;
      b.title = editable ? 'Sauvegarder cette vue (Ctrl+S)' : 'Lecture seule — édite dans Serveurs / Applications / Bases';
    }

    function dessinerResume() {
      const actifs = hotes.filter(h => h.etat === 'actif').length;
      const bloques = hotes.filter(h => hoteBloque(h)).length;
      const vivantes = hotes.filter(h => sondes[h.nom] === true).length;
      const sonde = Object.keys(sondes).length > 0;
      document.getElementById('resume').innerHTML = `
        ${estProduction ? '<span class="badge-prod" title="Instance de PRODUCTION : déploiement sous confirmation renforcée">PROD</span>' : '<span class="badge-lab" title="Instance bac à sable (setops_production: false)">bac à sable</span>'}
        <span class="chip"><b>${hotes.length}</b> hôtes</span>
        <span class="chip"><span class="pt actif"></span><b>${actifs}</b> actifs</span>
        <span class="chip"><span class="pt plan"></span><b>${hotes.length - actifs}</b> planifiés</span>
        ${bloques ? `<span class="chip"><span class="pt bloq"></span><b>${bloques}</b> bloqués</span>` : ''}
        ${sonde ? `<span class="chip" title="État RÉEL : VM joignables (sonde SSH), indépendamment du plan"><span class="pt actif"></span><b>${vivantes}</b> vivantes</span>` : ''}`;
    }

    function correspondServeur(s) {
      if (!filtre) return true;
      return [s.nom, s.fonction, s.adresse_ip, s.vmid, s.etat].join(' ').toLowerCase().includes(filtre);
    }

    function setVue(v) {
      vuePrincipale = v;
      if (v === 'serveurs' && selServeur == null && serveurs.length) selServeur = 0;
      if (v === 'applications' && selApp == null && applications.length) selApp = 0;
      if (v === 'bases' && selBase == null) selBase = bdServeurs.length ? 'srv:0' : (bdApplis.length ? 'bd:0' : null);
      document.getElementById('btn-vue-serveurs').classList.toggle('on', v === 'serveurs');
      document.getElementById('btn-vue-applications').classList.toggle('on', v === 'applications');
      document.getElementById('btn-vue-bases').classList.toggle('on', v === 'bases');
      document.getElementById('btn-vue-domaines').classList.toggle('on', v === 'domaines');
      document.getElementById('btn-vue-integrations').classList.toggle('on', v === 'integrations');
      document.getElementById('btn-vue-flux').classList.toggle('on', v === 'flux');
      document.getElementById('btn-vue-couches').classList.toggle('on', v === 'couches');
      document.getElementById('btn-vue-reseau').classList.toggle('on', v === 'reseau');
      document.getElementById('btn-vue-assistants').classList.toggle('on', v === 'assistants');
      dessinerGrilles();
      dessinerDetail();   // le panneau droit reflète la sélection de la vue courante
      majIndicateurSauvegarde();
    }

    const BANNIERE_MODELE = `<details class="aide-modele">
        <summary>Comment lire ce parc — serveur · hôte · groupe · application · base</summary>
        <div class="aide-corps">
          <p><b>Serveur</b> (ce que tu écris ici) → <b>« Appliquer le plan »</b> → <b>Hôte</b> (la VM générée). C'est le même objet, à deux étapes.</p>
          <ul>
            <li><b>Serveur / Hôte</b> — une VM ; elle <b>appartient à des groupes</b>.</li>
            <li><b>Groupe</b> — un rôle appliqué à l'hôte (ex. <span class="mono">serveur_nginx</span>, <span class="mono">client_dns</span>).</li>
            <li><b>Application</b> — un service qui <b>tourne sur</b> un hôte, <b>via</b> un groupe, et <b>expose</b> un FQDN.</li>
            <li><b>Base</b> — une donnée <b>hébergée sur</b> un hôte et <b>consommée par</b> une application.</li>
          </ul>
          <p class="aide-ro">Saisis à <b>gauche</b> (tuiles), édite à <b>droite</b> ; les dérivés (VMID/IP/VLAN/groupes) se calculent à « Appliquer le plan ».</p>
        </div></details>`;

    function dessinerGrilles() {
      if (vuePrincipale === 'applications') { dessinerApplications(); return; }
      if (vuePrincipale === 'bases') { dessinerBases(); return; }
      if (vuePrincipale === 'domaines') { dessinerDomaines(); return; }
      if (vuePrincipale === 'nomenclature') { dessinerNomenclature(); return; }
      if (vuePrincipale === 'integrations') { dessinerIntegrations(); return; }
      if (vuePrincipale === 'flux') { dessinerFlux(); return; }
      if (vuePrincipale === 'couches') { dessinerCouches(); return; }
      if (vuePrincipale === 'reseau') { dessinerReseau(); return; }
      if (vuePrincipale === 'assistants') { dessinerAssistants(); return; }
      dessinerServeurs();
    }

    function legendeLecture() {
      const d = document.getElementById('detail');
      if (vuePrincipale === 'flux') {
        d.innerHTML = `<div class="detail"><div class="section-tete">Chiffrement</div>
          <div class="legende">
            <div><span class="chip chi-tls-requis">tls-requis</span> chiffré + pair vérifié</div>
            <div><span class="chip chi-tls">tls</span> chiffré</div>
            <div><span class="chip chi-starttls">starttls</span> mise à niveau opportuniste</div>
            <div><span class="chip chi-ssh">ssh</span> transport SSH</div>
            <div><span class="chip chi-tls-cible">tls-cible</span> TLS visé (roadmap)</div>
            <div><span class="chip chi-clair">clair</span> non chiffré (local / edge)</div></div>
          <div class="hint-dep" style="margin-top:10px">Lecture seule. Éditer les <code>meta/flux.yml</code> des rôles, puis <code>make flux</code>.</div></div>`;
      } else if (vuePrincipale === 'reseau') {
        d.innerHTML = `<div class="detail"><div class="section-tete">Réseau &amp; fédération</div>
          <div class="hint-dep">Chaque instance fédérée dérive son adressage de son seed <code>index</code> (VLAN/VNI = 1000 + index×10 + zone, unique dans la fédération). La vue liste la flotte, signale toute collision d'index, et génère les devis d'infrastructure : commutateurs (<code>make devis-reseau</code>), frontière nord/sud (<code>make devis-opnsense</code>), SDN EVPN (<code>make devis-sdn</code>) et pare-feu est-ouest Proxmox (<code>make devis-proxmox-fw</code>).</div>
          <div class="hint-dep" style="margin-top:10px">Lecture seule, régénérés du plan — <code>make devis-reseau</code> / <code>make devis-opnsense</code>. Le <strong>dialecte de CLI</strong> et le <strong>mode de routage</strong> (commutateur ou SDN EVPN) se règlent dans la section <em>Fabric</em> du panneau « Intrants de base ». En mode SDN, les commutateurs ne portent ni VLAN tenant, ni SVI, ni ACL : le routage et le filtrage inter-zone vivent sur les hyperviseurs.</div>
          <div class="hint-dep" style="margin-top:10px">Ce qui reste à nommer à la main : les <strong>ports physiques</strong> (<code>&lt;PORT-VERS-…&gt;</code>) et, en SDN, le <strong>nœud de sortie EVPN</strong>. Rien d'autre — adresses, VLAN et routes se dérivent.</div></div>`;
      } else {
        d.innerHTML = `<div class="detail"><div class="section-tete">Reconstruction</div>
          <div class="hint-dep">L'ordre part du socle et remonte : chaque couche suppose la précédente debout. Le tri intra-couche vient du graphe des dépendances.</div>
          <div class="hint-dep" style="margin-top:10px">Lecture seule. Éditer <code>docs/couches-deploiement.yml</code> ; généré dans <code>playbooks/site.yml</code> par <code>make site</code>.</div>
          <div class="hint-dep" style="margin-top:10px"><strong>Vérifier ce qui a été remonté.</strong> Un déploiement vert ne dit pas que le service rend son service. Les <strong>devis de service</strong> lisent le système en marche et le comparent à ce que le plan dérive — ils n'écrivent rien et sortent en erreur s'il y a un écart :
            <code>make identite-plan</code>, <code>make certificats-plan</code>, <code>make expositions-plan</code>, <code>make postgresql-plan</code>, <code>make courriel-plan</code>.
            Détail dans <code>docs/devis-services.md</code>.</div></div>`;
      }
    }

    function dessinerFlux() {
      const cible = document.getElementById('grilles');
      if (!fluxRegistre.length) { cible.innerHTML = '<div class="vide" style="padding:14px">Aucun flux (meta/flux.yml).</div>'; return; }
      const lignes = fluxRegistre.map(f => `<tr>
        <td class="mono">${echapper(f.role)}</td>
        <td><span class="sens sens-${echapper(f.sens)}">${echapper(f.sens)}</span></td>
        <td class="mono">${echapper(f.port)}/${echapper(f.protocole)}</td>
        <td class="mono">${echapper(f.pair)}</td>
        <td><span class="chip chi-${echapper(f.chiffrement)}">${echapper(f.chiffrement)}</span></td>
        <td class="flux-raison">${echapper(f.raison)}</td></tr>`).join('');
      cible.innerHTML = `<div class="section-grille">
        <div class="section-tete">Flux réseau — matrice d'audit <span class="compte">${fluxRegistre.length}</span>
          <span class="hint-dep" style="margin-left:auto">ingress = le rôle écoute · egress = il se connecte · source de nftables + audit</span></div>
        <table class="tbl-lecture"><thead><tr><th>Rôle</th><th>Sens</th><th>Port</th><th>Pair</th><th>Chiffrement</th><th>Raison</th></tr></thead>
        <tbody>${lignes}</tbody></table></div>`;
    }

    let devisReseauTexte = '';
    let devisFrontiereTexte = '';
    function tableauFlotte(inst, coll, fmodeles, findexPris) {
      if (!inst.length) return '<div class="vide" style="padding:14px">Aucune instance découverte (dépôts frères avec plan/nomenclature.yml).</div>';
      const banniere = Object.keys(coll || {}).length
        ? `<div class="hint-dep" style="color:var(--danger);border:1px solid var(--danger);border-radius:8px;padding:8px 10px;margin-bottom:8px">⚠ COLLISION d'index entre instances fédérées : ${Object.entries(coll).map(([i, n]) => 'index ' + i + ' → ' + n.map(echapper).join(', ')).join(' ; ')} — mêmes VLAN/VMID sur le trunk.</div>`
        : '';
      const lignes = inst.map(i => {
        const vlan = i.vlans ? (i.vlans[0] + '-' + i.vlans[1]) : '—';
        const fed = i.federe ? '<span class="chip">fédérée</span>' : '<span class="chip" style="opacity:.6">local</span>';
        const prod = i.production ? '<span class="chip chi-tls-requis">prod</span>' : '';
        const action = i.actif
          ? '<span class="chip chi-tls-requis">active</span>'
          : `<button type="button" class="fantome"${peut('editer_le_plan') ? ''
              : ` disabled title="${echapper(pourquoiPas('editer_le_plan'))}" style="opacity:.45"`} onclick="basculerInstance('${echapper(i.nom)}', ${i.production ? 'true' : 'false'})">Activer</button>`;
        return `<tr>
          <td class="mono">${i.actif ? '★ ' : ''}${echapper(i.nom)}</td>
          <td class="mono">${i.index}</td>
          <td class="mono">${vlan}</td>
          <td>${fed} ${prod}</td>
          <td>${action}</td></tr>`;
      }).join('');
      const optModeles = (fmodeles || []).map(m => `<option value="${echapper(m)}">${echapper(m)}</option>`).join('');
      const creer = (fmodeles || []).length ? `
        <div class="section-tete" style="margin-top:14px">Créer une instance depuis un modèle</div>
        <div style="display:flex;flex-wrap:wrap;gap:8px;align-items:flex-end">
          <label class="champ" style="max-width:14rem"><span>Modèle</span><select id="ci-modele">${optModeles}</select></label>
          <label class="champ" style="max-width:12rem"><span>Nom (dépôt frère)</span><input id="ci-nom" placeholder="OPS-ClientX"></label>
          <label class="champ" style="max-width:9rem"><span>Index</span><input id="ci-index" type="number" placeholder="libre" title="Index unique ; ${(findexPris||[]).length ? 'déjà pris : ' + (findexPris||[]).join(', ') : 'aucun pris'}"></label>
          <button type="button" class="primaire"${peut('editer_le_plan') ? ''
            : ` disabled title="${echapper(pourquoiPas('editer_le_plan'))}" style="opacity:.45"`} onclick="creerInstance()">Créer</button>
        </div>
        <div class="hint-dep" style="margin-top:4px">Copie le modèle vers <code>../&lt;nom&gt;</code> et fixe l'index. Ne bascule pas : reste à renseigner intrants + voûte, puis « Activer ».${(findexPris||[]).length ? ' Index déjà pris : ' + (findexPris||[]).join(', ') + '.' : ''}</div>` : '';
      return `${banniere}<table class="tbl-lecture"><thead><tr><th>Instance</th><th>Index</th><th>VLAN</th><th>Statut</th><th>Active</th></tr></thead><tbody>${lignes}</tbody></table>
        <div class="hint-dep" style="margin-top:6px">★ = active (symlink <code>instance</code>). « Activer » bascule toutes les vues et les déploiements vers cette instance.</div>
        ${creer}`;
    }
    async function creerInstance() {
      const modele = (document.getElementById('ci-modele') || {}).value || '';
      const nom = ((document.getElementById('ci-nom') || {}).value || '').trim();
      const index = ((document.getElementById('ci-index') || {}).value || '').trim();
      if (!nom) { message('Donne un nom de dépôt (ex. OPS-ClientX).', 'erreur'); return; }
      if (!confirm(`Créer l'instance « ${nom} » depuis le modèle « ${modele} »${index ? ' (index ' + index + ')' : ''} ?\\n\\nCopie le modèle vers ../${nom}. L'instance active n'est PAS changée.`)) return;
      try {
        const rep = await fetch('/api/instance-creer', {
          method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON},
          body: JSON.stringify({nom, modele, index})});
        const data = await rep.json();
        if (!rep.ok) { message(data.erreur || 'Création refusée.', 'erreur'); return; }
        message('Instance « ' + nom + ' » créée. Renseigne intrants + voûte, puis « Activer ».', 'ok');
        dessinerReseau();
      } catch (e) { message('Erreur : ' + e.message, 'erreur'); }
    }
    async function basculerInstance(nom, estProd) {
      const avert = estProd
        ? `\\n\\n⚠ « ${nom} » est une instance de PRODUCTION. Déployer y touchera l'infra réelle.`
        : '';
      if (!confirm(`Basculer l'instance active vers « ${nom} » ?\\n\\nToutes les vues et les déploiements viseront alors « ${nom} ».${avert}`)) return;
      try {
        const rep = await fetch('/api/instance-utiliser', {
          method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON},
          body: JSON.stringify({nom})});
        const data = await rep.json();
        if (!rep.ok) { message(data.erreur || 'Bascule refusée.', 'erreur'); return; }
        message('Instance active : ' + nom + ' — rechargement…', 'ok');
        setTimeout(() => location.reload(), 500);
      } catch (e) { message('Erreur : ' + e.message, 'erreur'); }
    }
    async function dessinerReseau() {
      const cible = document.getElementById('grilles');
      cible.innerHTML = '<div class="vide" style="padding:14px">Lecture de la fédération…</div>';
      try {
        const [ri, rd, rf] = await Promise.all([
          fetch('/api/instances', {headers: {'X-Jeton': JETON}}),
          fetch('/api/devis-reseau', {headers: {'X-Jeton': JETON}}),
          fetch('/api/devis-opnsense', {headers: {'X-Jeton': JETON}}),
        ]);
        const di = await ri.json(), data = await rd.json(), dfr = await rf.json();
        if (!rd.ok) { cible.innerHTML = '<div class="vide" style="padding:14px">' + echapper(data.erreur || 'Indisponible.') + '</div>'; return; }
        devisReseauTexte = data.config || '';
        const flotte = `<div class="section-grille"><div class="section-tete">Flotte d'instances <span class="compte">${(di.instances || []).length}</span></div>${tableauFlotte(di.instances || [], di.collisions || {}, di.modeles || [], di.index_pris || [])}</div>`;
        const devis = devisReseauTexte
          ? `<div class="section-grille" style="margin-top:12px"><div class="section-tete">Devis config réseau — switches (instances fédérées)
              <button type="button" class="fantome" style="margin-left:auto" onclick="copierDevis()">Copier</button></div>
              <pre class="devis-reseau">${echapper(devisReseauTexte)}</pre></div>`
          : '<div class="hint-dep" style="margin-top:12px">Aucune instance fédérée : pas de devis convergé à générer.</div>';
        devisFrontiereTexte = dfr.config || '';
        const frontiere = devisFrontiereTexte
          ? `<div class="section-grille" style="margin-top:12px"><div class="section-tete">Devis config réseau — frontière nord/sud (OPNsense)
              <button type="button" class="fantome" style="margin-left:auto" onclick="copierDevisFrontiere()">Copier</button></div>
              <pre class="devis-reseau">${echapper(devisFrontiereTexte)}</pre></div>`
          : `<div class="hint-dep" style="margin-top:12px">Devis frontière indisponible${dfr.erreur ? ' : ' + echapper(dfr.erreur) : ''}.</div>`;
        // LA FABRIC APPARTIENT A L'HEBERGEUR, ET LE DIRE CHANGE CE QU'ON LIT. Chez un
        // locataire, ces devis sont calcules depuis une COPIE locale de la carte du
        // cluster — et une copie avait deja diverge : deux listes de stockages
        // contradictoires pour le meme materiel. Le panneau reste visible (l'omettre
        // ferait croire que la fabric n'existe pas) ; il cesse d'etre lu comme une source.
        const avisFabric = peut('fabric') ? '' :
          `<div class="note-fabric" style="margin-bottom:12px;padding:10px 12px;border-left:3px solid #b9860b;background:color-mix(in srgb,#b9860b 12%,var(--surface));font-size:12.5px">
             <b>Lecture seule — la fabric appartient à l'hébergeur.</b> ${echapper(pourquoiPas('fabric'))}
             Cette console configure un écosystème ; elle ne pose ni VLAN, ni route, ni règle de frontière.</div>`;
        cible.innerHTML = avisFabric + flotte + devis + frontiere;
      } catch (e) {
        cible.innerHTML = '<div class="vide" style="padding:14px">Erreur : ' + echapper(e.message) + '</div>';
      }
    }
    function copierDevis() {
      if (navigator.clipboard) navigator.clipboard.writeText(devisReseauTexte)
        .then(() => message('Devis réseau copié — prêt à coller sur le switch.', 'ok'), () => {});
    }
    function copierDevisFrontiere() {
      if (navigator.clipboard) navigator.clipboard.writeText(devisFrontiereTexte)
        .then(() => message('Devis frontière copié.', 'ok'), () => {});
    }

    function dessinerCouches() {
      const cible = document.getElementById('grilles');
      if (!couchesRegistre.length) { cible.innerHTML = '<div class="vide" style="padding:14px">Ordre de déploiement indisponible.</div>'; return; }
      const blocs = couchesRegistre.map((c, i) => `<div class="couche">
        <div class="couche-tete"><span class="couche-idx">${i}</span><b>${echapper(c.nom)}</b><span class="compte">${c.groupes.length}</span></div>
        <div class="couche-groupes">${c.groupes.map(g => `<span class="chip mono">${echapper(g)}</span>`).join('')}</div></div>`
        ).join('<div class="couche-fleche">↓</div>');
      cible.innerHTML = `<div class="section-grille">
        <div class="section-tete">Ordre de déploiement — couches <span class="compte">${couchesRegistre.length}</span>
          <span class="hint-dep" style="margin-left:auto">make deployer-tout / myDay déroule dans cet ordre · tri topo intra-couche</span></div>
        <div class="couches-pile">${blocs}</div></div>`;
    }

    // --- Matrice serveurs x integrations -------------------------------------
    // Pourquoi cette vue : la fiche de detail montre les integrations d'UN serveur.
    // Savoir qui n'a pas de sauvegarde demandait donc d'ouvrir chaque fiche — et un
    // trou (deux serveurs sans supervision) est reste invisible jusqu'a ce qu'un
    // devis de pare-feu l'enumere. Ici il se lit dans une colonne.
    function servicesRendus(nom) {
      return new Set(applications.filter(a => a.hote === nom).map(a => a.groupe));
    }
    function estExempt(role, rendus) {
      const p = integrationsUniv[role];
      return !!(p && p.sauf_role && rendus.has(p.sauf_role));
    }
    function basculerIntegrationDe(i, role, actif) {
      const s = serveurs[i]; if (!s) return;
      const set = new Set(listeDepuisTexte(s.integrations));
      if (actif) set.add(role); else set.delete(role);
      s.integrations = Array.from(set).join(', ');
      marquerServeursModifie(); dessinerIntegrations();
    }

    function dessinerIntegrations() {
      const cible = document.getElementById('grilles');
      const univ = Object.keys(integrationsUniv).sort();
      // Colonnes facultatives : celles proposees + toute valeur deja presente dans le
      // plan (un role retire de roles/ ne doit pas faire disparaitre sa colonne).
      const dansPlan = new Set();
      serveurs.forEach(s => listeDepuisTexte(s.integrations).forEach(r => dansPlan.add(r)));
      const opt = [...new Set([...integrationsDispo, ...dansPlan])].filter(r => !integrationsUniv[r]).sort();
      const colonnes = [...univ, ...opt];
      const lignes = serveurs.map((s, i) => [s, i]).filter(([s]) => correspondServeur(s));
      if (!colonnes.length) { cible.innerHTML = '<div class="vide" style="padding:14px">Aucun rôle client_* dans roles/.</div>'; return; }
      if (!lignes.length) { cible.innerHTML = '<div class="vide" style="padding:14px">Aucun serveur ne correspond au filtre.</div>'; return; }

      const couvert = {}; colonnes.forEach(r => couvert[r] = 0);
      const corps = lignes.map(([s, i]) => {
        const rendus = servicesRendus(s.nom);
        const set = new Set(listeDepuisTexte(s.integrations));
        const cellules = colonnes.map(role => {
          if (integrationsUniv[role]) {
            if (estExempt(role, rendus)) {
              return `<td class="mx-c mx-exempt" title="Exempté : cet hôte rend ${echapper(integrationsUniv[role].sauf_role)} — il ne s'intègre pas à lui-même">—</td>`;
            }
            couvert[role]++;
            return `<td class="mx-c mx-univ" title="${echapper(integrationsUniv[role].raison || '')}">✓</td>`;
          }
          if (set.has(role)) couvert[role]++;
          return `<td class="mx-c"><input type="checkbox" ${set.has(role) ? 'checked' : ''}`
               + ` onchange="basculerIntegrationDe(${i}, '${echapper(role)}', this.checked)"`
               + ` title="${echapper(role)} sur ${echapper(s.nom)}"></td>`;
        }).join('');
        const sel = i === selServeur ? ' class="mx-sel"' : '';
        return `<tr${sel}><th class="mx-h" onclick="setVue('serveurs'); choisirServeur(${i})" title="Ouvrir la fiche de ${echapper(s.nom)}">`
             + `${echapper(s.nom || '(sans nom)')}<span class="mx-fn">${echapper(s.fonction || '')}</span></th>${cellules}</tr>`;
      }).join('');

      const n = lignes.length;
      const tetes = colonnes.map(role => {
        const u = !!integrationsUniv[role];
        return `<th class="mx-t${u ? ' mx-t-univ' : ''}" title="${u ? 'Politique du rôle — s\'applique à tout hôte' : 'Facultative — un choix, serveur par serveur'}">`
             + `<span>${echapper(role.replace(/^client_/, ''))}</span></th>`;
      }).join('');
      const pieds = colonnes.map(role => {
        const c = couvert[role];
        const cls = integrationsUniv[role] ? 'mx-p mx-univ' : (c === n ? 'mx-p mx-plein' : 'mx-p');
        return `<td class="${cls}">${c}/${n}</td>`;
      }).join('');

      cible.innerHTML = `<div class="section-grille">
        <div class="section-tete">Intégrations — matrice <span class="compte">${n} × ${colonnes.length}</span>
          <span class="hint-dep" style="margin-left:auto">Les colonnes ✓ sont la politique des rôles ; les cases sont les choix, éditables ici</span></div>
        <div class="mx-cadre"><table class="mx">
          <thead><tr><th class="mx-t mx-coin">serveur</th>${tetes}</tr></thead>
          <tbody>${corps}</tbody>
          <tfoot><tr><th class="mx-h mx-coin">couverture</th>${pieds}</tr></tfoot>
        </table></div></div>`;
    }

    function legendeIntegrations() {
      const univ = Object.entries(integrationsUniv).sort();
      const lignes = univ.map(([role, p]) => `<div class="mx-leg"><span class="mx-univ">✓</span> <code>${echapper(role)}</code>
        <div class="hint-dep">${echapper(p.raison || '')}${p.sauf_role ? ` <b>Exemption</b> : l'hôte qui rend <code>${echapper(p.sauf_role)}</code>.` : ''}</div></div>`).join('');
      document.getElementById('detail').innerHTML = `<div class="detail">
        <div class="section-tete">Deux genres d'intégration</div>
        <div class="hint-dep"><b>Universelle</b> — aucun choix de cible : un seul Prometheus, un seul Loki, une seule AC.
          Déclarée <b>une fois par le rôle</b> (<code>roles/&lt;rôle&gt;/meta/integration.yml</code>), elle s'applique à tout hôte
          et ne se décoche pas. Le plan <b>refuse</b> de la redire : deux sources finiraient par diverger.</div>
        ${lignes}
        <div class="hint-dep" style="margin-top:12px"><b>Facultative</b> — un vrai choix, serveur par serveur, écrit dans
          <code>plan/serveurs.yml</code>. Coche dans la matrice, puis <b>Sauvegarder</b>.</div>
        <div class="hint-dep" style="margin-top:12px">La ligne <b>couverture</b> ne juge pas : une colonne à <code>7/14</code>
          peut être exactement juste. Elle rend le motif <em>visible</em> — c'est au lecteur de savoir si les sept manquants
          sont des décisions ou des oublis.</div></div>`;
    }

    function basesDeApp(app, hoteNom) {
      return bdApplis.filter(a => {
        const p = a.portee || 'groupe';
        return (p === 'application' && a.consommateur === app.id)
            || (p === 'groupe' && a.consommateur === app.groupe)
            || (p === 'hote' && a.consommateur === hoteNom);
      });
    }

    function chargerBases(data) {
      const b = data.bases || {serveurs_bd: {}, bases_donnees: {}};
      bdServeurs = Object.entries(b.serveurs_bd || {}).map(([nom, s]) => ({
        nom, type: s.type || 'postgres', hote: s.hote || '', port: s.port || 5432, groupe: s.groupe || ''}));
      bdApplis = Object.entries(b.bases_donnees || {}).map(([cle, x]) => ({
        cle, serveur: x.serveur || '', base: x.base || '', proprietaire: x.proprietaire || '', secret: x.secret || '',
        consommateur: x.consommateur || '', portee: x.portee || 'groupe', usage: x.usage || 'principale'}));
      basesModifie = false;
    }

    function chargerDomaines(data) {
      // Les valeurs restent DE LEUR TYPE (les listes restent des listes) : le formulaire
      // est genere depuis le schema, qui sait deja qu'une liste se saisit par virgules.
      // L'ancien chargement les aplatissait en texte, et la sauvegarde devait deviner
      // comment les reconstruire.
      const dp = ((data.domaines || {}).domaines_publics) || {};
      domaines = Object.entries(dp).map(([nom, x]) => Object.assign({nom}, x));
      domainesModifie = false;
    }
    function marquerDomainesModifie() { domainesModifie = true; majIndicateurSauvegarde(); }
    function choisirDomaine(i) { selDomaine = i; dessiner(); }
    function definirDomaine(champ, v) {
      const d = domaines[selDomaine]; if (!d) return;
      poserChemin(d, champ, v); marquerDomainesModifie();
      if (champ === 'nom') { const t = document.querySelector('#tuile-dom-' + selDomaine + ' .carte-nom'); if (t) { t.textContent = v || '(sans nom)'; t.className = 'carte-nom' + (v ? '' : ' sans'); } }
      else dessinerDetail();
    }
    function ajouterDomaine() {
      const edgeDefaut = groupes.includes('serveur_nginx') ? 'serveur_nginx' : (groupes[0] || '');
      domaines.unshift({nom: '', autorite: 'auto-heberge', edge: edgeDefaut, dnssec: false, secondaires: []});
      selDomaine = 0; marquerDomainesModifie(); dessiner();
      const c = document.querySelector('#detail .grille input'); if (c) c.focus();
    }
    function retirerDomaine() {
      const d = domaines[selDomaine]; if (!d) return;
      if (d.nom && !confirm('Retirer le domaine « ' + d.nom + ' » ?')) return;
      domaines.splice(selDomaine, 1);
      selDomaine = domaines.length ? Math.min(selDomaine, domaines.length - 1) : null;
      marquerDomainesModifie(); dessiner();
    }
    function carteDomaine(d, i) {
      return `<button type="button" class="carte ${i === selDomaine ? 'selectionnee' : ''}" id="tuile-dom-${i}" onclick="choisirDomaine(${i})">
        <div class="carte-haut"><span class="badge-bd">zone</span>${d.dnssec ? '<span class="carte-vmid">dnssec</span>' : ''}</div>
        <div class="carte-nom ${d.nom ? '' : 'sans'}">${echapper(d.nom || '(sans nom)')}</div>
        <div class="carte-ip">${echapper(d.autorite || '—')}</div>
      </button>`;
    }
    // ---- VUE NOMENCLATURE ---------------------------------------------------------
    //
    // Le dernier registre que le GUI ne savait pas ecrire du tout (2026-09-08). Il n'est
    // pas un registre comme les autres : il ne decrit pas des objets, il decrit la REGLE
    // dont VMID, VLAN, adresse et passerelle se derivent. D'ou deux partis pris :
    //
    //   - `index` est montre mais PAS editable ici. Le fichier le dit lui-meme : il est
    //     RECU du site, pas decide par le tenant, et `make underlay` refuse tout ecart.
    //     Il s'ecrit par le panneau Intrants, qui est le chemin de l'intrant recu.
    //   - chaque fonction affiche CE QU'ELLE DERIVE (zone, VLAN, 3e octet) et combien de
    //     VM la portent : sans ca, changer un chiffre ici est un geste a l'aveugle.

    function chargerNomEdit(data) {
      // Copie de travail : editer `nomenclature` en place ferait suivre les indices
      // derives de la vue Serveurs a des valeurs non encore enregistrees.
      nomEdit = JSON.parse(JSON.stringify(data.nomenclature || {}));
      nomModifie = false;
    }
    function marquerNomModifie() { nomModifie = true; majIndicateurSauvegarde(); }
    function selNomInfo() { if (!selNom) return null; const i = selNom.indexOf(':'); return {kind: selNom.slice(0, i), cle: selNom.slice(i + 1)}; }
    function choisirNom(k) { selNom = k; dessiner(); }

    function definirNom(chemin, v) {
      // UN SEUL setter pour toute la profondeur : le generateur transmet une clef
      // POINTEE (`reservations.passerelle`, `fonctions.idm.service`).
      const parts = String(chemin).split('.');
      let o = nomEdit;
      for (let i = 0; i < parts.length - 1; i++) {
        if (o[parts[i]] == null || typeof o[parts[i]] !== 'object') o[parts[i]] = {};
        o = o[parts[i]];
      }
      const feuille = parts[parts.length - 1];
      // Les entiers restent des ENTIERS : le plan est relu par le moteur, pas par un
      // navigateur, et `categorie: "6"` ne derive pas la meme chose que `categorie: 6`.
      o[feuille] = (v !== '' && v != null && String(v).match(/^-?\d+$/)) ? parseInt(v, 10) : v;
      marquerNomModifie();
      if (chemin.startsWith('fonctions.') || chemin.startsWith('categories.')) dessiner();
    }

    function renommerNom(table, ancienne, nouvelle) {
      nouvelle = String(nouvelle || '').trim();
      if (!nouvelle || nouvelle === ancienne) return;
      const t = nomEdit[table] || {};
      if (Object.prototype.hasOwnProperty.call(t, nouvelle)) { message('« ' + nouvelle + ' » existe déjà.', 'erreur'); return; }
      // On preserve l'ORDRE : le fichier est lu par des humains, et un renommage ne doit
      // pas remonter la clef en tete.
      const refait = {};
      Object.keys(t).forEach(k => { refait[k === ancienne ? nouvelle : k] = t[k]; });
      nomEdit[table] = refait;
      selNom = (table === 'categories' ? 'cat:' : 'fon:') + nouvelle;
      marquerNomModifie(); dessiner();
    }

    function ajouterZone() {
      const cats = nomEdit.categories || (nomEdit.categories = {});
      // La prochaine zone LIBRE, pas « la derniere + 1 » : un trou se rebouche.
      let n = 1; while (cats[n] || cats[String(n)]) n++;
      cats[n] = {libelle: ''};
      selNom = 'cat:' + n; marquerNomModifie(); dessiner();
    }
    function ajouterFonction() {
      const f = nomEdit.fonctions || (nomEdit.fonctions = {});
      let nom = 'nouvelle', i = 2; while (f[nom]) nom = 'nouvelle-' + (i++);
      const premiereZone = Object.keys(nomEdit.categories || {})[0];
      f[nom] = {categorie: premiereZone != null ? parseInt(premiereZone, 10) : 1, service: 1};
      selNom = 'fon:' + nom; marquerNomModifie(); dessiner();
    }
    function retirerNom() {
      const info = selNomInfo(); if (!info) return;
      const table = info.kind === 'cat' ? 'categories' : 'fonctions';
      if (info.kind === 'fon' && vmsPortant(info.cle).length) {
        message('« ' + info.cle + ' » est encore portée par ' + vmsPortant(info.cle).length + ' VM.', 'erreur');
        return;
      }
      if (info.kind === 'cat' && fonctionsDansZone(info.cle).length) {
        message('Zone ' + info.cle + ' encore utilisée par ' + fonctionsDansZone(info.cle).length + ' fonction(s).', 'erreur');
        return;
      }
      delete (nomEdit[table] || {})[info.cle];
      selNom = null; marquerNomModifie(); dessiner();
    }

    function vmsPortant(fonction) { return hotes.filter(h => fonctionDe(h.nom).fonction === fonction); }
    function fonctionsDansZone(zone) {
      return Object.entries(nomEdit.fonctions || {}).filter(([, f]) => String(f.categorie) === String(zone)).map(([n]) => n);
    }
    function deriveDe(fonction) {
      // Miroir de `inventory_rules.deriver_nomenclature`, cote ecran. Il ne DECIDE rien :
      // il montre ce que le moteur derivera, pour que le chiffre saisi ait un sens visible.
      const f = (nomEdit.fonctions || {})[fonction];
      if (!f) return null;
      const c = (nomEdit.categories || {})[f.categorie] || (nomEdit.categories || {})[String(f.categorie)];
      const idx = (nomEdit.index != null) ? nomEdit.index : 9;
      const cat = Number(f.categorie);
      if (!c || isNaN(cat)) return null;
      return {libelle: c.libelle || '?', vlan: 1000 + idx * 10 + cat,
              base3: '10.' + idx + '.' + (15 + cat), bloc: (Number(f.service) * 10)};
    }

    function carteZone(cle) {
      const c = (nomEdit.categories || {})[cle] || {};
      const sel = selNom === 'cat:' + cle ? ' on' : '';
      const n = fonctionsDansZone(cle).length;
      return `<button type="button" class="carte${sel}" onclick="choisirNom('cat:${echapper(cle)}')">
        <div class="carte-nom">${echapper(c.libelle || '(sans libellé)')}</div>
        <div class="carte-ip">zone ${echapper(cle)} · ${n} fonction(s)</div></button>`;
    }
    function carteFonction(nom) {
      const sel = selNom === 'fon:' + nom ? ' on' : '';
      const d = deriveDe(nom);
      const nb = vmsPortant(nom).length;
      return `<button type="button" class="carte${sel}" onclick="choisirNom('fon:${echapper(nom)}')">
        <div class="carte-nom">${echapper(nom)}</div>
        <div class="carte-ip">${d ? echapper(d.libelle) + ' · VLAN ' + d.vlan : '<zone inconnue>'} · ${nb} VM</div></button>`;
    }

    function dessinerNomenclature() {
      const cible = document.getElementById('grilles');
      const reg = schemaPlan.nomenclature;
      if (!reg) { cible.innerHTML = '<div class="vide" style="padding:14px">Aucun schéma — lancer <code>make schema</code>.</div>'; return; }
      const props = (reg.entite || {}).properties || {};

      // Le seed, montre et NON editable ici (il vient du site).
      const idx = nomEdit.index == null ? '—' : nomEdit.index;
      const seed = `<label class="champ" title="${echapper((props.index || {}).description || '')}">
          <span>${echapper((props.index || {}).title || 'Index')}</span>
          <input value="${echapper(idx)}" disabled></label>
        <div class="ch-stub" style="grid-column:1/-1">L'index est <b>alloué par le site</b>, pas décidé ici
          (<code>make underlay</code> refuse tout écart). Il s'édite dans le panneau <b>Intrants</b>.</div>`;
      const cidr = props.cidr_hote ? champDepuisSchema('cidr_hote', props.cidr_hote, nomEdit.cidr_hote, nomEdit, 'definirNom') : '';
      const resv = props.reservations ? champDepuisSchema('reservations', props.reservations, nomEdit.reservations, nomEdit, 'definirNom') : '';

      const zones = Object.keys(nomEdit.categories || {});
      const fons = Object.keys(nomEdit.fonctions || {});
      cible.innerHTML = `
        <div class="section-grille">
          <div class="section-tete">Modèle d'adressage</div>
          <div class="grille">${seed}${cidr}${resv}</div>
        </div>
        <div class="section-grille">
          <div class="section-tete">Zones de sécurité <span class="compte">${zones.length}</span>
            <button type="button" class="fantome" style="margin-left:auto" onclick="ajouterZone()">+ Zone</button></div>
          ${zones.length ? `<div class="grille-cartes">${zones.map(carteZone).join('')}</div>`
                         : '<div class="vide" style="padding:14px">Aucune zone. Sans zone déclarée, aucune fonction ne dérive d\'adresse.</div>'}
        </div>
        <div class="section-grille">
          <div class="section-tete">Fonctions <span class="compte">${fons.length}</span>
            <button type="button" class="fantome" style="margin-left:auto" onclick="ajouterFonction()">+ Fonction</button></div>
          ${fons.length ? `<div class="grille-cartes">${fons.map(carteFonction).join('')}</div>`
                        : '<div class="vide" style="padding:14px">Aucune fonction déclarée.</div>'}
        </div>`;
    }

    function inspecteurNomenclature() {
      const cible = document.getElementById('detail');
      const info = selNomInfo();
      const reg = schemaPlan.nomenclature || {};
      const props = (reg.entite || {}).properties || {};
      if (!info) {
        cible.innerHTML = '<div class="detail"><div class="vide"><b>Nomenclature</b>'
          + 'Le modèle dont tout l\'adressage dérive. Choisis une zone ou une fonction.</div></div>';
        return;
      }
      const table = info.kind === 'cat' ? 'categories' : 'fonctions';
      const entree = (nomEdit[table] || {})[info.cle];
      if (!entree) { selNom = null; cible.innerHTML = ''; return; }
      const specEntree = (props[table] || {}).additionalProperties || {};
      const corps = sousFormulaireDepuisSchema(specEntree, entree, table + '.' + info.cle, 'definirNom');

      let consequence = '';
      if (info.kind === 'fon') {
        const d = deriveDe(info.cle);
        const vms = vmsPortant(info.cle);
        consequence = `<div class="section-tete" style="margin:12px 2px 4px">Ce que cette fonction dérive</div>`
          + (d ? `<div class="intr-ro">Zone <b>${echapper(d.libelle)}</b> · VLAN <b>${d.vlan}</b>
                  · sous-réseau <b>${echapper(d.base3)}.0/${echapper(nomEdit.cidr_hote || 24)}</b>
                  · bloc d'hôtes <b>.${d.bloc}x</b></div>`
               : '<div class="intr-ro">Zone inconnue — aucune adresse ne se dérive.</div>')
          + `<div class="section-tete" style="margin:12px 2px 4px">VM portant cette fonction <span class="compte">${vms.length}</span></div>`
          + (vms.length ? `<div class="ch-bases">${vms.map(h => `<div class="ch-base"><span class="mono">${echapper(h.nom)}</span></div>`).join('')}</div>`
                        : '<div class="ch-stub">aucune — cette fonction peut être retirée</div>');
      } else {
        const fs = fonctionsDansZone(info.cle);
        consequence = `<div class="section-tete" style="margin:12px 2px 4px">Fonctions dans cette zone <span class="compte">${fs.length}</span></div>`
          + (fs.length ? `<div class="ch-bases">${fs.map(f => `<div class="ch-base"><span class="mono">${echapper(f)}</span></div>`).join('')}</div>`
                       : '<div class="ch-stub">aucune — cette zone peut être retirée</div>');
      }
      const libelleCle = info.kind === 'cat' ? 'Numéro de zone' : 'Nom de la fonction';
      cible.innerHTML = `<article class="detail">
        <div class="detail-tete"><div class="detail-nom"><span class="detail-nom-txt">${echapper(info.cle)}</span></div>
          <span class="grandit"></span>
          <button type="button" class="danger" title="Retirer" onclick="retirerNom()">✕</button></div>
        <div class="grille">
          <label class="champ" style="grid-column:1/-1"><span>${libelleCle}</span>
            <input value="${echapper(info.cle)}" onchange="renommerNom('${table}', '${echapper(info.cle)}', this.value)"></label>
        </div>
        ${corps}
        ${consequence}
      </article>`;
    }

    async function sauvegarderNomenclature() {
      const rep = await fetch('/api/nomenclature', {method: 'POST',
        headers: {'Content-Type': 'application/json', 'X-Jeton': JETON},
        body: JSON.stringify(nomEdit)});
      const data2 = await rep.json();
      if (!rep.ok) { message(data2.erreur || 'Sauvegarde refusée.', 'erreur'); return; }
      schemaPlan = data2.schema || schemaPlan;
      nomenclature = data2.nomenclature || nomenclature;
      chargerNomEdit(data2); dessiner();
      message('Nomenclature sauvegardée.', 'ok');
    }

    function dessinerDomaines() {
      const cible = document.getElementById('grilles');
      const tuiles = domaines.length
        ? `<div class="grille-cartes">${domaines.map((d, i) => carteDomaine(d, i)).join('')}</div>`
        : '<div class="vide" style="padding:14px">Aucun domaine. Une zone DNS = parent des expositions (FQDN) derrière l\'edge.</div>';
      cible.innerHTML = `<div class="section-grille">
        <div class="section-tete">Domaines <span class="compte">${domaines.length}</span><button type="button" class="fantome" style="margin-left:auto" onclick="ajouterDomaine()">+ Domaine</button></div>
        ${tuiles}</div>`;
    }
    function expositionsSous(zone) {
      if (!zone) return [];
      return applications.flatMap(a => listeDepuisTexte(a.expose)).filter(f => f === zone || f.endsWith('.' + zone));
    }
    function inspecteurDomaine() {
      const cible = document.getElementById('detail');
      if (selDomaine == null || !domaines[selDomaine]) {
        cible.innerHTML = '<div class="detail"><div class="vide"><b>Aucun domaine sélectionné</b>Choisis une tuile, ou ajoute un domaine.</div></div>';
        return;
      }
      const d = domaines[selDomaine];
      const fqdns = expositionsSous(d.nom);
      const liens = fqdns.length
        ? `<div class="ch-bases">${fqdns.map(f => `<div class="ch-base"><span class="mono">${echapper(f)}</span></div>`).join('')}</div>`
        : '<div class="ch-stub">aucune exposition sous cette zone</div>';
      cible.innerHTML = `<article class="detail">
        <div class="detail-tete"><div class="detail-nom"><span class="detail-nom-txt">${echapper(d.nom || '(sans nom)')}</span></div>
          <span class="grandit"></span>
          <button type="button" class="danger" title="Retirer ce domaine" onclick="retirerDomaine()">✕</button></div>
        ${formulaireDepuisSchema('domaines_publics', d, 'definirDomaine', d.nom, "definirDomaine.bind(null,'nom')")}
        <div class="section-tete" style="margin:12px 2px 4px">Expositions sous cette zone</div>
        ${liens}
      </article>`;
    }
    async function sauvegarderDomaines() {
      // SAUVEGARDE DERIVEE DU SCHEMA : les champs ecrits sont ceux qu'il declare. Un
      // champ ajoute au registre apparait au formulaire ET arrive au fichier — sans quoi
      // il serait saisissable et perdu en silence, le pire des deux mondes.
      const dp = {};
      const propsD = ((schemaPlan.domaines_publics || {}).entite || {}).properties || {};
      domaines.forEach(d => {
        if (!String(d.nom).trim()) return;
        const o = {};
        Object.keys(propsD).forEach(cle => {
          const v = d[cle];
          if (v === undefined || v === null || v === '') {
            if (propsD[cle].default !== undefined) o[cle] = propsD[cle].default;
            return;
          }
          o[cle] = (propsD[cle].type === 'boolean') ? !!v : v;
        });
        dp[d.nom] = o;
      });
      const rep = await fetch('/api/domaines', {
        method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON}, body: JSON.stringify({domaines_publics: dp})
      });
      const data = await rep.json();
      if (!rep.ok) { message(data.erreur || 'Sauvegarde refusée.', 'erreur'); return; }
      chargerDomaines(data); dessinerDomaines();
      message('Domaines sauvegardés.', 'ok');
    }

    function chargerApplications(data) {
      const a = (data.applications || {}).applications || {};
      // Les valeurs gardent LEUR TYPE : le formulaire est genere depuis le schema, qui
      // sait qu'une liste se saisit par virgules. Les aplatir ici obligeait la sauvegarde
      // a deviner comment les reconstruire.
      applications = Object.entries(a).map(([id, x]) => Object.assign({id}, x, {
        liens: (x.liens || []).map(l => ({vers: l.vers || '', role: l.role || ''}))}));
      applicationsModifie = false;
    }

    // ---- FORMULAIRES GENERES DEPUIS LE SCHEMA -------------------------------------
    //
    // Le schema (docs/audit/schema-plan.json, `make schema`) decrit la FORME des
    // registres ; ces trois fonctions la rendent. Un champ ajoute au plan apparait donc
    // a l'ecran sans qu'on touche a ce fichier — c'est tout l'objet.
    //
    // Ce qu'elles ne font PAS : valider. La coherence reste aux `valider_*` du serveur,
    // qui refusent la sauvegarde. Un formulaire genere ne saurait pas dire qu'un
    // consommateur designe une application inexistante.

    function sourceDeValeurs(nom) {
      // Les listes fermees, resolues a l'execution. C'est ce qui rend l'hote fantome
      // IMPOSSIBLE A SAISIR, au lieu d'etre refuse apres coup.
      if (nom === 'serveurs') return hotes.map(h => h.nom).filter(Boolean);
      if (nom === 'applications') return applications.map(x => x.id).filter(Boolean);
      if (nom === 'groupes_operationnels') return groupes;
      if (nom === 'serveurs_bd') return bdServeurs.map(x => x.nom).filter(Boolean);
      // `nomenclature`, PAS `data.nomenclature` : il n'existe aucun `data` global. Cette
      // ligne dormait — la vue Serveurs, seule a employer cette source, avait un
      // formulaire ecrit a la main. Elle a leve a la seconde ou le generateur l'a prise.
      if (nom === 'nomenclature.fonctions') return Object.keys((nomEdit.fonctions || nomenclature.fonctions) || {});
      // La zone se choisit dans les zones DECLAREES — et on la lit dans la copie en
      // cours d'edition, pour qu'une zone ajoutee a l'instant soit offerte tout de suite.
      // `{v, t}` : la valeur ecrite au plan reste le numero, l'ecran montre le libelle.
      // `edge` designe un GROUPE Ansible : `instancier` compare cette valeur aux
      // groupes d'un hote pour lui deriver ses SAN. Offrir des HOTES ici produirait un
      // certificat correct sur un nom que personne ne peut appeler.
      if (nom === 'groupes_edge') return groupes.filter(g => g.startsWith('serveur_nginx'));
      // Les listes que le SITE a declarees dans les intrants (noeuds, stockages).
      if (nom.startsWith('intrants.')) {
        const v = ((intrants || {}).valeurs || {})[nom.slice(9)];
        return Array.isArray(v) ? v : [];
      }
      if (nom === 'nomenclature.categories') {
        const cats = (nomEdit.categories || {});
        return Object.keys(cats).map(k => ({v: k, t: k + ' — ' + ((cats[k] || {}).libelle || '?')}));
      }
      return [];
    }

    function champDepuisSchema(cle, spec, valeur, entite, surChangement) {
      // UN CHAMP PEUT AVOIR SON PROPRE EDITEUR (`x-editeur`), plus riche que ce que le
      // schema sait dire : la matrice des integrations montre aussi les universelles et
      // leurs exemptions ; l'editeur de liens contraint le role a ce que le groupe
      // porteur accepte. Le generateur s'efface — la vue les rend elle-meme.
      if (spec['x-editeur']) return '';
      const titre = echapper(spec.title || cle);
      const aide = spec.description ? ` title="${echapper(spec.description)}"` : '';
      // Marqueur discret : le schema SAIT ce qui est requis, le formulaire ecrit a la
      // main ne le montrait pas. Une asterisque plutot que le mot « requis », qui se
      // collait au libelle et se lisait « Base requis ».
      const req = (spec['x-requis'] ? '<abbr class="dsn" title="Champ requis" style="text-decoration:none"> *</abbr>' : '');
      const appel = (expr) => `${surChangement}('${cle}', ${expr})`;
      // `data-champ` remplace l'ancien `data-v`, pose a la main sur trois champs de la
      // vue Serveurs. La validation client (`serveurValeurValide`) le lit ; sans lui,
      // elle aurait cherche des elements qui n'existent plus et serait passee au vert
      // sur ZERO champ. Un controle qui ne trouve rien ne dit pas « tout va bien ».
      const marque = ` data-champ="${echapper(cle)}"`;

      // Liste fermee : soit fixe (enum), soit alimentee a l'execution, soit dependante
      // d'un autre champ de la meme entite.
      let options = null;
      if (spec.enum) options = spec.enum;
      else if (spec['x-source-valeurs']) options = sourceDeValeurs(spec['x-source-valeurs']);
      else if (spec['x-source-selon']) {
        const s = spec['x-source-selon'];
        const pivot = (entite || {})[s.champ];
        options = sourceDeValeurs((s.cas || {})[pivot] || s.defaut);
      }

      if (options) {
        // L'option VIDE n'est pas « rien » : c'est « le defaut ». Quand le schema nomme
        // l'intrant qui le porte (`x-defaut-intrant`), on l'affiche, plutot que de
        // laisser l'operateur deviner ce qu'un champ vide produira.
        const nomDef = spec['x-defaut-intrant'];
        const valDef = nomDef ? ((intrants || {}).valeurs || {})[nomDef] : null;
        const libVide = valDef ? `(défaut : ${valDef})` : '—';
        const opts = [`<option value="">${echapper(libVide)}</option>`].concat(options.map(o => {
          const v = (o && typeof o === 'object') ? o.v : o;
          const txt = (o && typeof o === 'object') ? o.t : o;
          return `<option value="${echapper(v)}"${String(v) === String(valeur == null ? '' : valeur) ? ' selected' : ''}>${echapper(txt)}</option>`;
        })).join('');
        return `<label class="champ"${aide}><span>${titre}${req}</span><select${marque} onchange="${appel('this.value')}">${opts}</select></label>`;
      }
      if (spec.type === 'object' && spec.properties) {
        // BLOC FIXE (`sous_champs` au schema) : ses cases une fois, sans « ajouter ».
        // La clef transmise au setter est POINTEE (`reservations.passerelle`) — c'est ce
        // qui permet a un seul setter de servir toute la profondeur.
        const sousReq = new Set(spec.required || []);
        const cases = Object.keys(spec.properties).map(sc => champDepuisSchema(
          cle + '.' + sc,
          Object.assign({}, spec.properties[sc], {'x-requis': sousReq.has(sc)}),
          (valeur || {})[sc], valeur, surChangement)).join('');
        return `<div style="grid-column:1/-1"${aide}><div class="section-tete">${titre}</div>`
             + `<div class="grille">${cases}</div></div>`;
      }
      if (spec.type === 'boolean') {
        return `<label class="champ"${aide}><span>${titre}${req}</span><input type="checkbox"${marque}${valeur ? ' checked' : ''} onchange="${appel('this.checked')}"></label>`;
      }
      // Repere de saisie : la valeur REELLEMENT derivee pour cette entite, lue dans
      // l'inventaire genere. Le formulaire ecrit a la main annoncait « 2048 » et « 2 » —
      // des constantes inventees, alors que `deriver_ressources` calcule depuis les roles
      // portes. Un repere faux fait croire qu'on connait la valeur.
      const derive = spec['x-defaut-derive'];
      let repere = '';
      if (derive && entite && entite.nom) {
        const h = hotes.find(x => x.nom === entite.nom);
        if (h && h[derive] != null && h[derive] !== '') repere = ` placeholder="dérivé : ${echapper(h[derive])}"`;
      }
      if (spec.type === 'integer') {
        return `<label class="champ"${aide}><span>${titre}${req}</span><input type="number"${marque}${repere} value="${echapper(valeur == null ? '' : valeur)}" oninput="${appel('this.value')}"></label>`;
      }
      if (spec.type === 'array' && (spec.items || {}).properties) {
        return listeDepuisSchema(cle, spec, valeur, surChangement);
      }
      if (spec.type === 'array') {
        // Une liste de textes se saisit separee par des virgules : le YAML reste une
        // liste, la saisie reste lisible.
        const v = Array.isArray(valeur) ? valeur.join(', ') : '';
        return `<label class="champ"${aide}><span>${titre}${req}</span><input${marque} value="${echapper(v)}" placeholder="a, b" oninput="${appel('this.value.split(\',\').map(x=>x.trim()).filter(Boolean)')}"></label>`;
      }
      return `<label class="champ"${aide}><span>${titre}${req}</span><input${marque}${repere} value="${echapper(valeur == null ? '' : valeur)}" oninput="${appel('this.value')}"></label>`;
    }

    function formulaireDepuisSchema(nomRegistre, entite, surChangement, cleCourante, surChangementCle, nomClef) {
      const reg = schemaPlan[nomRegistre] || null;
      if (!reg) return '<div class="vide">Aucun schéma pour ce registre — lancer <code>make schema</code>.</div>';
      const props = (reg.entite || {}).properties || {};
      const requis = new Set((reg.entite || {}).required || []);
      const morceaux = [];
      if (reg['x-clef'] && surChangementCle) {
        const k = reg['x-clef'];
        morceaux.push(`<label class="champ" title="${echapper(k.description || '')}"><span>${echapper(k.title)}</span>` +
          `<input data-champ="${echapper(nomClef || 'cle')}" value="${echapper(cleCourante == null ? '' : cleCourante)}" oninput="(${surChangementCle})(this.value)"></label>`);
      }
      Object.keys(props).forEach(cle => {
        const spec = Object.assign({}, props[cle], {'x-requis': requis.has(cle)});
        morceaux.push(champDepuisSchema(cle, spec, (entite || {})[cle], entite, surChangement));
      });
      return `<div class="grille">${morceaux.join('')}</div>`;
    }

    function poserChemin(objet, chemin, valeur) {
      // `reservations.passerelle`, `exposition.0.cible` : un seul mecanisme pour toute
      // la profondeur, tableaux compris. Les setters de chaque vue s'appuient dessus.
      const parts = String(chemin).split('.');
      let o = objet;
      for (let i = 0; i < parts.length - 1; i++) {
        const suivant = parts[i + 1];
        if (o[parts[i]] == null || typeof o[parts[i]] !== 'object') {
          o[parts[i]] = String(suivant).match(/^\d+$/) ? [] : {};
        }
        o = o[parts[i]];
      }
      o[parts[parts.length - 1]] = valeur;
    }

    function listeDepuisSchema(cle, spec, valeur, surChangement) {
      // UNE LISTE D'OBJETS de forme connue (`entrees` au schema) : une sous-fiche par
      // element, plus un bouton d'ajout. L'ajout et le retrait passent par le MEME
      // setter que les champs — on lui remet le tableau entier, serialise dans
      // l'attribut. Pas de fonction globale a resoudre au clic : ce qui marche sous le
      // banc marche dans le navigateur.
      const items = spec.items || {};
      const arr = Array.isArray(valeur) ? valeur : [];
      const defauts = {};
      Object.keys(items.properties || {}).forEach(c => {
        if (items.properties[c].default !== undefined) defauts[c] = items.properties[c].default;
      });
      const ajout = echapper(JSON.stringify(arr.concat([defauts])));
      const lignes = arr.map((e, i) => {
        const retrait = echapper(JSON.stringify(arr.filter((_, j) => j !== i)));
        return `<div class="ch-base" style="display:block">
          <div style="display:flex;align-items:center;gap:6px">
            <span class="dsn">#${i + 1}</span><span class="grandit"></span>
            <button type="button" class="danger" title="Retirer"
              onclick="${surChangement}('${cle}', ${retrait})">✕</button></div>
          ${sousFormulaireDepuisSchema(items, e, cle + '.' + i, surChangement)}</div>`;
      }).join('');
      return `<div style="grid-column:1/-1">
        <div class="section-tete">${echapper(spec.title || cle)} <span class="compte">${arr.length}</span>
          <button type="button" class="fantome" style="margin-left:auto"
            onclick="${surChangement}('${cle}', ${ajout})">+ Ajouter</button></div>
        ${arr.length ? lignes : '<div class="ch-stub">aucune entrée</div>'}</div>`;
    }

    function sousFormulaireDepuisSchema(specEntree, entree, prefixe, surChangement) {
      // Une ligne de table (`entree` au schema) : les memes cases qu'une entite, mais
      // sous une clef pointee, pour que le setter sache ou poser la valeur.
      const props = (specEntree || {}).properties || {};
      const requis = new Set((specEntree || {}).required || []);
      const cases = Object.keys(props).map(c => champDepuisSchema(
        prefixe + '.' + c, Object.assign({}, props[c], {'x-requis': requis.has(c)}),
        (entree || {})[c], entree, surChangement)).join('');
      return `<div class="grille">${cases}</div>`;
    }

    function dsnBase(a) {
      const s = bdServeurs.find(x => x.nom === a.serveur);
      if (!s) return '(serveur inconnu : ' + echapper(a.serveur || '—') + ')';
      return `${s.type}://${a.proprietaire || '?'}:****@${s.hote || '?'}:${s.port || '?'}/${a.base || '?'}`;
    }

    function marquerBasesModifie() { basesModifie = true; majIndicateurSauvegarde(); }
    function selBaseInfo() { if (!selBase) return null; const p = selBase.split(':'); return {kind: p[0], i: +p[1]}; }
    function choisirBase(key) { selBase = key; dessiner(); }
    function definirServeurBd(champ, v) {
      const info = selBaseInfo(); if (!info || info.kind !== 'srv') return;
      const s = bdServeurs[info.i]; if (!s) return;
      s[champ] = v; marquerBasesModifie();
      if (champ === 'nom') { const t = document.querySelector('#tuile-base-srv-' + info.i + ' .carte-nom'); if (t) t.textContent = v || '(sans nom)'; }
    }
    function definirBaseBd(champ, v) {
      const info = selBaseInfo(); if (!info || info.kind !== 'bd') return;
      const a = bdApplis[info.i]; if (!a) return;
      a[champ] = v; marquerBasesModifie();
      if (champ === 'cle') { const t = document.querySelector('#tuile-base-bd-' + info.i + ' .carte-nom'); if (t) t.textContent = v || '(sans id)'; }
      else if (champ === 'serveur' || champ === 'portee') dessinerDetail();
    }
    function ajouterServeurBd() { bdServeurs.unshift({nom: '', type: 'postgres', hote: '', port: 5432, groupe: ''}); selBase = 'srv:0'; marquerBasesModifie(); dessiner(); }
    function retirerServeurBd() { const info = selBaseInfo(); if (!info || info.kind !== 'srv') return; bdServeurs.splice(info.i, 1); selBase = null; marquerBasesModifie(); dessiner(); }
    function ajouterBaseBd() { bdApplis.unshift({cle: '', serveur: (bdServeurs[0] || {}).nom || '', base: '', proprietaire: '', secret: '', consommateur: '', portee: 'groupe', usage: 'principale'}); selBase = 'bd:0'; marquerBasesModifie(); dessiner(); }
    function retirerBaseBd() { const info = selBaseInfo(); if (!info || info.kind !== 'bd') return; bdApplis.splice(info.i, 1); selBase = null; marquerBasesModifie(); dessiner(); }

    function carteBaseServeur(s, i) {
      const key = 'srv:' + i;
      return `<button type="button" class="carte ${selBase === key ? 'selectionnee' : ''}" id="tuile-base-srv-${i}" onclick="choisirBase('${key}')">
        <div class="carte-haut"><span class="badge-bd">${echapper(s.type || 'bd')}</span>${s.port ? `<span class="carte-vmid">:${echapper(s.port)}</span>` : ''}</div>
        <div class="carte-nom ${s.nom ? '' : 'sans'}">${echapper(s.nom || '(sans nom)')}</div>
        <div class="carte-ip">${echapper(s.hote || '— hôte ?')}</div>
      </button>`;
    }
    function carteBaseDonnee(a, i) {
      const key = 'bd:' + i;
      return `<button type="button" class="carte ${selBase === key ? 'selectionnee' : ''}" id="tuile-base-bd-${i}" onclick="choisirBase('${key}')">
        <div class="carte-haut"><span class="badge-bd">${echapper(a.portee || 'groupe')}</span></div>
        <div class="carte-nom ${a.cle ? '' : 'sans'}">${echapper(a.cle || '(sans id)')}</div>
        <div class="carte-ip">${echapper(a.base || '—')} @ ${echapper(a.serveur || '?')}</div>
      </button>`;
    }
    function dessinerBases() {
      const cible = document.getElementById('grilles');
      const srv = bdServeurs.length ? `<div class="grille-cartes">${bdServeurs.map((s, i) => carteBaseServeur(s, i)).join('')}</div>` : '<div class="vide" style="padding:12px">Aucun serveur de BD.</div>';
      const bd = bdApplis.length ? `<div class="grille-cartes">${bdApplis.map((a, i) => carteBaseDonnee(a, i)).join('')}</div>` : '<div class="vide" style="padding:12px">Aucune base.</div>';
      cible.innerHTML = `<div class="section-grille"><div class="section-tete">Serveurs de bases <span class="compte">${bdServeurs.length}</span><button type="button" class="fantome" style="margin-left:auto" onclick="ajouterServeurBd()">+ Serveur BD</button></div>${srv}</div>
        <div class="section-grille"><div class="section-tete">Bases applicatives <span class="compte">${bdApplis.length}</span><button type="button" class="fantome" style="margin-left:auto" onclick="ajouterBaseBd()">+ Base</button></div>${bd}</div>`;
    }
    function inspecteurBase() {
      const cible = document.getElementById('detail');
      const info = selBaseInfo();
      if (!info) { cible.innerHTML = '<div class="detail"><div class="vide"><b>Aucun élément sélectionné</b>Choisis un serveur de base ou une base à gauche.</div></div>'; return; }
      if (info.kind === 'srv') {
        const s = bdServeurs[info.i];
        if (!s) { cible.innerHTML = '<div class="detail"><div class="vide">Introuvable.</div></div>'; return; }
        const ici = bdApplis.filter(a => a.serveur === s.nom);
        const iciHtml = ici.length ? `<div class="ch-bases">${ici.map(a => `<div class="ch-base"><span class="badge-bd">${echapper(a.portee || 'groupe')}</span> <span class="mono">${echapper(a.base || '?')}</span> (${echapper(a.cle)})</div>`).join('')}</div>` : '<div class="ch-stub">aucune base sur ce serveur</div>';
        cible.innerHTML = `<article class="detail">
          <div class="detail-tete"><div class="detail-nom"><span class="detail-nom-txt">${echapper(s.nom || '(sans nom)')}</span></div><span class="grandit"></span><span class="badge-bd">${echapper(s.type || 'bd')}</span><button type="button" class="danger" title="Retirer" onclick="retirerServeurBd()">✕</button></div>
          ${formulaireDepuisSchema('serveurs_bd', s, 'definirServeurBd', s.nom, "definirServeurBd.bind(null,'nom')")}
          <div class="section-tete" style="margin:12px 2px 2px">Bases hébergées ici</div>${iciHtml}
          ${(() => {
            const hS = hotes.find(h => h.nom === s.hote);
            if (hS && hS.etat === 'actif') { const hiS = hotes.indexOf(hS);
              return `<div class="pied"><span class="hint-dep">Déployer applique les rôles sur l'hôte « ${echapper(s.hote)} ».</span><span class="grandit"></span>${estProduction ? '<span class="badge-prod">PROD</span>' : ''}<button type="button" class="${estProduction ? 'danger' : 'primaire'}" onclick="lancer('pousser', ${hiS})" title="Déployer l'hôte du serveur de BD">Déployer</button></div>`; }
            return `<div class="pied"><span class="hint-dep">${s.hote ? `Active + pousse d'abord l'hôte « ${echapper(s.hote)} ».` : 'Aucun hôte assigné.'}</span></div>`;
          })()}
        </article>`;
      } else {
        const a = bdApplis[info.i];
        if (!a) { cible.innerHTML = '<div class="detail"><div class="vide">Introuvable.</div></div>'; return; }
        // FORMULAIRE GENERE DEPUIS LE SCHEMA (2026-09-08) — plus aucun champ en dur.
        // Les huit `<label>` qui vivaient ici sont derives de docs/audit/schema-plan.json :
        // libelles, types, listes fermees, et la source CONDITIONNELLE du consommateur
        // (elle depend de la portee) que le schema declare desormais au lieu de la laisser
        // vivre dans ce fichier. Un champ ajoute au registre apparait sans toucher au JS,
        // et P61 refuse qu'un champ du plan manque au schema.
        cible.innerHTML = `<article class="detail">
          <div class="detail-tete"><div class="detail-nom"><span class="detail-nom-txt">${echapper(a.cle || '(sans id)')}</span></div><span class="grandit"></span><button type="button" class="danger" title="Retirer" onclick="retirerBaseBd()">✕</button></div>
          ${formulaireDepuisSchema('bases_donnees', a, 'definirBaseBd', a.cle, "definirBaseBd.bind(null,'cle')")}
          <div class="dsn mono" style="margin-top:8px">${echapper(dsnBase(a))}</div>
          ${(() => {
            const srv = bdServeurs.find(x => x.nom === a.serveur);
            const hB = srv ? hotes.find(h => h.nom === srv.hote) : null;
            if (hB && hB.etat === 'actif') { const hiB = hotes.indexOf(hB);
              return `<div class="pied"><span class="hint-dep">Déployer applique les rôles sur « ${echapper(srv.hote)} » (le serveur de BD qui héberge cette base).</span><span class="grandit"></span>${estProduction ? '<span class="badge-prod">PROD</span>' : ''}<button type="button" class="${estProduction ? 'danger' : 'primaire'}" onclick="lancer('pousser', ${hiB})" title="Déployer le serveur de BD (crée cette base)">Déployer</button></div>`; }
            return `<div class="pied"><span class="hint-dep">${(srv && srv.hote) ? `Active + pousse d'abord l'hôte « ${echapper(srv.hote)} ».` : 'Serveur de BD sans hôte assigné.'}</span></div>`;
          })()}
        </article>`;
      }
    }

    async function sauvegarderBases() {
      const sd = {};
      const propsSrv = ((schemaPlan.serveurs_bd || {}).entite || {}).properties || {};
      bdServeurs.forEach(s => {
        if (!String(s.nom).trim()) return;
        const o = {};
        Object.keys(propsSrv).forEach(cle => {
          const v = s[cle];
          if (v === undefined || v === null || v === '') return;
          o[cle] = (propsSrv[cle].type === 'integer') ? (parseInt(v, 10) || v) : v;
        });
        sd[s.nom] = o;
      });
      const bd = {};
      // SAUVEGARDE DERIVEE DU SCHEMA (2026-09-08). Les sept champs etaient enumeres ici
      // en dur : un champ ajoute au registre serait apparu au formulaire genere et
      // aurait disparu SILENCIEUSEMENT a l'enregistrement — le pire des deux mondes.
      // Les valeurs par defaut viennent du schema (`default`), plus du JS.
      const propsBd = ((schemaPlan.bases_donnees || {}).entite || {}).properties || {};
      bdApplis.forEach(a => {
        if (!String(a.cle).trim()) return;
        const e = {};
        Object.keys(propsBd).forEach(cle => {
          const v = a[cle];
          e[cle] = (v === undefined || v === '' || v === null) ? (propsBd[cle].default ?? v) : v;
        });
        bd[a.cle] = e;
      });
      const rep = await fetch('/api/bases', {
        method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON}, body: JSON.stringify({serveurs_bd: sd, bases_donnees: bd})
      });
      const data = await rep.json();
      if (!rep.ok) { message(data.erreur || 'Sauvegarde refusée.', 'erreur'); return; }
      chargerBases(data);
      dessinerBases();
      message('Bases de données sauvegardées.', 'ok');
    }

    function marquerApplicationsModifie() { applicationsModifie = true; majIndicateurSauvegarde(); }
    function choisirApp(i) { selApp = i; dessiner(); }
    function definirApplication(champ, v) {
      const a = applications[selApp]; if (!a) return;
      poserChemin(a, champ, v); marquerApplicationsModifie();
      if (champ === 'id') { const t = document.querySelector('#tuile-app-' + selApp + ' .carte-nom'); if (t) { t.textContent = v || '(sans id)'; t.className = 'carte-nom' + (v ? '' : ' sans'); } }
      else if (champ === 'groupe') {
        const ok = Object.keys(liensAcceptes[a.groupe] || {});
        (a.liens || []).forEach(l => { if (l.role && !ok.includes(l.role)) l.role = ''; });
        dessinerDetail();
      }
      else if (champ === 'hote' || champ === 'port') dessinerDetail();
    }
    function ajouterApplication() {
      applications.unshift({id: '', groupe: (groupes[0] || ''), hote: '', port: '', requiert: '', expose: '', websocket: false, liens: []});
      selApp = 0; marquerApplicationsModifie(); dessiner();
      const c = document.querySelector('#detail .grille input'); if (c) c.focus();
    }
    function retirerApplication() {
      const a = applications[selApp]; if (!a) return;
      if (a.id && !confirm('Retirer l\'application « ' + a.id + ' » ?')) return;
      applications.splice(selApp, 1);
      selApp = applications.length ? Math.min(selApp, applications.length - 1) : null;
      marquerApplicationsModifie(); dessiner();
    }

    function ajouterLien() {
      const a = applications[selApp]; if (!a) return;
      if (!a.liens) a.liens = [];
      const roles = Object.keys(liensAcceptes[a.groupe] || {});
      a.liens.push({vers: '', role: roles.length === 1 ? roles[0] : ''});
      marquerApplicationsModifie(); dessinerDetail();
    }
    function retirerLien(i) {
      const a = applications[selApp]; if (!a || !a.liens) return;
      a.liens.splice(i, 1); marquerApplicationsModifie(); dessinerDetail();
    }
    function definirLien(i, champ, v) {
      const a = applications[selApp]; if (!a || !a.liens || !a.liens[i]) return;
      a.liens[i][champ] = v; marquerApplicationsModifie();
      if (champ === 'role') dessinerDetail();
    }
    function blocLiens(a) {
      const accepte = liensAcceptes[a.groupe] || {};
      const roles = Object.keys(accepte);
      if (!roles.length) {
        return `<div class="ch-stub">Le rôle « ${echapper(a.groupe || '—')} » n'accepte aucun lien
          (aucun <span class="mono">roles/${echapper(a.groupe || '?')}/meta/liens.yml</span>).</div>`;
      }
      const cibles = applications.map(x => x.id).filter(x => x && x !== a.id);
      const lignes = (a.liens || []).map((l, i) => {
        const spec = accepte[l.role] || {};
        const vars = Object.keys(spec.variables || {});
        const optV = '<option value="">— cible —</option>' + cibles.map(c =>
          `<option value="${echapper(c)}" ${c === l.vers ? 'selected' : ''}>${echapper(c)}</option>`).join('');
        const optR = '<option value="">— rôle —</option>' + roles.map(r =>
          `<option value="${echapper(r)}" ${r === l.role ? 'selected' : ''}>${echapper(r)}</option>`).join('');
        const inconnue = l.vers && !cibles.includes(l.vers);
        return `<div class="ch-base" style="gap:8px;align-items:center">
          <select style="max-width:12rem" onchange="definirLien(${i}, 'role', this.value)">${optR}</select>
          <span class="mono">→</span>
          <select style="max-width:12rem" onchange="definirLien(${i}, 'vers', this.value)">${optV}</select>
          ${inconnue ? `<span class="tag" style="color:#b45309">cible « ${echapper(l.vers)} » inconnue</span>` : ''}
          ${vars.length ? `<span class="tag" title="Variables injectées sur cette application">${echapper(vars.join(', '))}</span>` : ''}
          <span class="grandit"></span>
          <button type="button" class="danger" title="Retirer ce lien" onclick="retirerLien(${i})">✕</button>
        </div>`;
      }).join('');
      return `${lignes || '<div class="ch-stub">aucun lien déclaré</div>'}
        <div style="margin-top:6px"><button type="button" class="fantome" onclick="ajouterLien()">+ Lien</button></div>`;
    }

    function carteApp(a, i) {
      const exp = listeDepuisTexte(a.expose);
      return `<button type="button" class="carte ${i === selApp ? 'selectionnee' : ''}" id="tuile-app-${i}" onclick="choisirApp(${i})">
        <div class="carte-haut"><span class="badge-bd">app</span>${a.port ? `<span class="carte-vmid">:${echapper(a.port)}</span>` : ''}</div>
        <div class="carte-nom ${a.id ? '' : 'sans'}">${echapper(a.id || '(sans id)')}</div>
        <div class="carte-ip">${echapper(a.hote || '— hôte ?')}</div>
        ${exp.length ? `<div class="carte-grps"><span class="tag">${echapper(exp[0])}</span>${exp.length > 1 ? `<span class="tag plus">+${exp.length - 1}</span>` : ''}</div>` : ''}
      </button>`;
    }
    function dessinerApplications() {
      const cible = document.getElementById('grilles');
      const tuiles = applications.length
        ? `<div class="grille-cartes">${applications.map((a, i) => carteApp(a, i)).join('')}</div>`
        : '<div class="vide" style="padding:14px">Aucune application. Une VM peut en porter plusieurs.</div>';
      cible.innerHTML = `<div class="section-grille">
        <div class="section-tete">Applications <span class="compte">${applications.length}</span><button type="button" class="fantome" style="margin-left:auto" onclick="ajouterApplication()">+ Application</button></div>
        ${tuiles}</div>`;
    }
    function inspecteurApplication() {
      const cible = document.getElementById('detail');
      if (selApp == null || !applications[selApp]) {
        cible.innerHTML = '<div class="detail"><div class="vide"><b>Aucune application sélectionnée</b>Choisis une tuile à gauche, ou ajoute une application.</div></div>';
        return;
      }
      const a = applications[selApp];
      const dsns = basesDeApp(a, a.hote);
      const liens = dsns.length
        ? `<div class="ch-bases">${dsns.map(b => `<div class="ch-base"><span class="badge-bd">${echapper(b.portee || 'groupe')}</span> <span class="mono">${echapper(dsnBase(b))}</span></div>`).join('')}</div>`
        : '<div class="ch-stub">aucune base liée</div>';
      cible.innerHTML = `<article class="detail">
        <div class="detail-tete"><div class="detail-nom"><span class="detail-nom-txt">${echapper(a.id || '(sans id)')}</span></div>
          <span class="grandit"></span>
          <button type="button" class="danger" title="Retirer cette application" onclick="retirerApplication()">✕</button></div>
        ${formulaireDepuisSchema('applications', a, 'definirApplication', a.id, "definirApplication.bind(null,'id')", 'id')}
        <div class="section-tete" style="margin:12px 2px 4px">Liens (bindings)
          <span class="compte">${(a.liens || []).length}</span></div>
        ${blocLiens(a)}
        <div class="section-tete" style="margin:12px 2px 4px">Bases consommées</div>
        ${liens}
        ${(() => {
          const hA = hotes.find(x => x.nom === a.hote);
          if (hA && hA.etat === 'actif') {
            const hiA = hotes.indexOf(hA);
            return `<div class="pied"><span class="hint-dep">Déployer applique les rôles sur l'hôte porteur « ${echapper(a.hote)} ».</span><span class="grandit"></span>${estProduction ? '<span class="badge-prod">PROD</span>' : ''}<button type="button" class="${estProduction ? 'danger' : 'primaire'}" onclick="lancer('pousser', ${hiA})" title="Déployer l'hôte porteur (rend l'application vivante)">Déployer</button></div>`;
          }
          return `<div class="pied"><span class="hint-dep">${a.hote ? `Active + pousse d'abord l'hôte « ${echapper(a.hote)} ».` : 'Aucun hôte assigné.'}</span></div>`;
        })()}
      </article>`;
    }

    function listeDepuisTexte(v) {
      // Elle accepte desormais une VRAIE liste autant qu'un texte separe par des virgules.
      // Les chargeurs aplatissaient `expose`, `requiert` et `integrations` en chaine ;
      // le formulaire genere, lui, attend le type que le schema declare. Plutot que de
      // toucher aux douze sites d'appel, la conversion vit ici, en un seul endroit.
      if (Array.isArray(v)) return v.map(x => String(x).trim()).filter(Boolean);
      return String(v || '').split(',').map(s => s.trim()).filter(Boolean);
    }

    async function sauvegarderApplications() {
      const apps = {};
      const propsA = ((schemaPlan.applications || {}).entite || {}).properties || {};
      applications.forEach(a => {
        if (!String(a.id).trim()) return;
        const o = {};
        Object.keys(propsA).forEach(cle => {
          const spec = propsA[cle];
          if (cle === 'liens') {
            // Un lien incomplet n'est pas un lien : il ferait echouer le validateur du
            // moteur a la sauvegarde suivante, sur une entree que personne n'a voulue.
            const lns = (a.liens || []).filter(l => String(l.vers || '').trim() && String(l.role || '').trim())
                                       .map(l => ({vers: l.vers, role: l.role}));
            if (lns.length) o.liens = lns;
            return;
          }
          if (spec.type === 'array') { const l = listeDepuisTexte(a[cle]); if (l.length) o[cle] = l; return; }
          if (spec.type === 'boolean') { if (a[cle]) o[cle] = true; return; }
          const v = a[cle];
          if (v === undefined || v === null || String(v).trim() === '') return;
          o[cle] = (spec.type === 'integer') ? (parseInt(v, 10) || v) : v;
        });
        // `groupe` et `hote` sont REQUIS : on les ecrit meme vides, pour que le
        // validateur du moteur refuse clairement plutot que de recevoir un objet muet.
        if (o.groupe === undefined) o.groupe = a.groupe || '';
        if (o.hote === undefined) o.hote = a.hote || '';
        apps[a.id] = o;
      });
      const rep = await fetch('/api/applications', {
        method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON}, body: JSON.stringify({applications: apps})
      });
      const data = await rep.json();
      if (!rep.ok) { message(data.erreur || 'Sauvegarde refusée.', 'erreur'); return; }
      chargerApplications(data);
      dessinerApplications();
      message('Applications sauvegardées.', 'ok');
    }

    function chargerServeurs(data) {
      serveurs = (data.serveurs || []).map(s => ({...s, integrations: s.integrations || []}));
      serveursModifie = false;
    }


    function marquerServeursModifie() { serveursModifie = true; majIndicateurSauvegarde(); }
    function choisirServeur(i) { selServeur = i; dessiner(); }
    function definirServeur(champ, v) {
      const s = serveurs[selServeur]; if (!s) return;
      poserChemin(s, champ, v); marquerServeursModifie();
      if (champ === 'nom') { const t = document.querySelector('#tuile-srv-' + selServeur + ' .carte-nom'); if (t) { t.textContent = v || '(sans nom)'; t.className = 'carte-nom' + (v ? '' : ' sans'); } }
      else if (champ === 'fonction' || champ === 'etat') dessiner();
    }
    function basculerIntegration(role, actif) {
      const s = serveurs[selServeur]; if (!s) return;
      const set = new Set(listeDepuisTexte(s.integrations));
      if (actif) set.add(role); else set.delete(role);
      s.integrations = Array.from(set); marquerServeursModifie();
    }
    function ajouterServeur() {
      serveurs.unshift({nom: '', fonction: (Object.keys(nomenclature.fonctions || {})[0] || ''), etat: 'planifie', noeud: '', stockage: '', disque: '', memoire: '', coeurs: '', integrations: '', statut: 'absent', vmid: '', adresse_ip: '', vlan: ''});
      selServeur = 0; marquerServeursModifie(); dessiner();
      const c = document.querySelector('#detail .grille input'); if (c) c.focus();
    }
    function retirerServeur() {
      const s = serveurs[selServeur]; if (!s) return;
      if (s.nom && !confirm('Retirer le serveur « ' + s.nom + ' » du plan ?')) return;
      serveurs.splice(selServeur, 1);
      selServeur = serveurs.length ? Math.min(selServeur, serveurs.length - 1) : null;
      marquerServeursModifie(); dessiner();
    }
    function ouvrirApp(id) { const i = applications.findIndex(a => a.id === id); selApp = i >= 0 ? i : null; setVue('applications'); }
    function ouvrirBaseServeur(nom) { const i = bdServeurs.findIndex(x => x.nom === nom); selBase = i >= 0 ? 'srv:' + i : null; setVue('bases'); }

    function pointVie(nom) {
      const v = sondes[nom];
      return v === true ? '<span class="pt actif" title="VM joignable (SSH)"></span> '
           : v === false ? '<span class="pt bloq" title="Injoignable"></span> ' : '';
    }
    function carteServeur(s, i) {
      const actif = s.etat === 'actif';
      const recon = s.statut === 'divergence' ? '<span class="tag plus" title="Le plan diverge de l\'inventaire généré">⚠ divergent</span>'
                  : s.statut === 'absent' ? '<span class="tag" title="Déclaré, pas encore instancié">○ non instancié</span>' : '';
      return `<button type="button" class="carte ${actif ? 'actif' : 'attente'} ${i === selServeur ? 'selectionnee' : ''}" id="tuile-srv-${i}" onclick="choisirServeur(${i})">
        <div class="carte-haut"><span class="badge-statut ${actif ? 'ok' : 'attente'}">${actif ? 'actif' : 'planifié'}</span>${s.vmid ? `<span class="carte-vmid">#${echapper(s.vmid)}</span>` : ''}</div>
        <div class="carte-nom ${s.nom ? '' : 'sans'}">${echapper(s.nom || '(sans nom)')}</div>
        <div class="carte-ip">${pointVie(s.nom)}${echapper(s.adresse_ip || '—')}</div>
        ${recon ? `<div class="carte-grps">${recon}</div>` : ''}
      </button>`;
    }
    // LA CONSOLE D'UN SITE DESSINE SES MACHINES (2026-09-20).
    //
    // `inventaire_api_du_site` sert volontairement `serveurs: {}` — « on ne fabrique pas
    // un faux plan de tenant pour remplir l'ecran ». C'est juste : un site declare ses
    // machines dans SON plan, avec `ip`, `vmid` et `noeud` ECRITS, la ou un locataire les
    // derive de son seed. Mais la page tirait de ce registre vide le message d'un
    // locataire sans serveurs — « + Serveur », `make serveurs-bootstrap » — et les douze
    // machines du site, servies dans `hotes`, n'etaient dessinees nulle part.
    //
    // Un site a douze machines et sa console n'en montrait aucune : c'est le defaut du
    // 2026-09-16 qui revient par une autre porte. La premiere fois, l'inventaire etait
    // vide ; cette fois il est plein et c'est la VUE qui regarde au mauvais endroit.
    function dessinerMachinesDuSite() {
      const cible = document.getElementById('grilles');
      const nom = (contexte && contexte.fabric) || 'ce site';
      const entete = `<div class="section-grille"><div class="section-tete">Machines de ${echapper(nom)}
        <span class="compte">${hotes.length}</span></div>
        <div class="hint-dep">Ces machines sont déclarées dans le plan du site — <code>ip</code>,
        <code>vmid</code> et <code>noeud</code> y sont <b>écrits</b>, pas dérivés d'un seed&nbsp;:
        un site est le terrain, il n'a rien dont les faire descendre. Cette console ne les édite
        donc pas&nbsp;; elle les <b>matérialise</b> et leur applique des rôles — voir la vue
        <b>Assistants</b>.</div></div>`;
      if (!hotes.length) {
        cible.innerHTML = entete + '<div class="vide" style="padding:14px">Cet inventaire dynamique ne rend aucune machine. Ce n\'est pas un plan vide : c\'est une mesure vide, et elle mérite un regard — <span class="mono">make site-inventaire</span>.</div>';
        return;
      }
      const vus = hotes.map((h, i) => [h, i]).filter(([h]) =>
        !filtre || (h.nom || '').toLowerCase().includes(filtre));
      const sections = [['Actives', vus.filter(([h]) => h.etat === 'actif')],
                        ['Planifiées', vus.filter(([h]) => h.etat !== 'actif')]];
      cible.innerHTML = entete + sections.filter(([, l]) => l.length).map(([t, l]) =>
        `<div class="section-grille"><div class="section-tete">${t} <span class="compte">${l.length}</span></div>
         <div class="grille-cartes">${l.map(([h, i]) => carteMachineDuSite(h, i)).join('')}</div></div>`).join('');
    }

    // LE MEME GABARIT QUE LES SERVEURS, et pas un second qui lui ressemblerait : deux
    // cartes qui se ressemblent finissent par ne plus se ressembler.
    function carteMachineDuSite(h, i) {
      const actif = h.etat === 'actif';
      const roles = (h.groupes || []).length;
      return `<button type="button" class="carte ${actif ? 'actif' : 'attente'} ${i === selMachine ? 'selectionnee' : ''}" id="tuile-mach-${i}" onclick="choisirMachine(${i})">
        <div class="carte-haut"><span class="badge-statut ${actif ? 'ok' : 'attente'}">${actif ? 'actif' : 'planifié'}</span>${h.vmid ? `<span class="carte-vmid">#${echapper(h.vmid)}</span>` : ''}</div>
        <div class="carte-nom">${echapper(h.nom)}</div>
        <div class="carte-ip">${pointVie(h.nom)}${echapper(h.adresse_ip || '—')}</div>
        ${roles ? `<div class="carte-grps"><span class="tag">${roles} rôle${roles > 1 ? 's' : ''}</span></div>` : ''}
      </button>`;
    }

    function choisirMachine(i) { selMachine = i; dessinerMachinesDuSite(); dessinerDetail(); }

    function inspecteurMachineDuSite() {
      const cible = document.getElementById('detail');
      const h = hotes[selMachine];
      if (!h) {
        cible.innerHTML = `<div class="detail"><div class="section-tete">Console du SITE</div>
          <div class="hint-dep">Choisis une machine à gauche. Cette console <b>matérialise</b> le
          terrain — créer et détruire des VM, poser le réseau et la frontière — et n'entre
          chez aucun locataire : elle n'a la voûte d'aucun d'eux.</div>
          <div class="hint-dep" style="margin-top:10px">Les séquences qui lui reviennent sont
          dans la vue <b>Assistants</b>.</div></div>`;
        return;
      }
      const ligne = (c, v) => v ? `<div><span class="aide-ro">${c}</span> <span class="mono">${echapper(String(v))}</span></div>` : '';
      cible.innerHTML = `<div class="detail"><div class="section-tete">${echapper(h.nom)}</div>
        ${ligne('état', h.etat)}${ligne('adresse', h.adresse_ip)}${ligne('VMID', h.vmid)}
        ${ligne('VLAN', h.vlan)}${ligne('nœud', h.noeud)}
        <div class="section-tete" style="margin-top:12px">Rôles</div>
        <div>${(h.groupes || []).map(g => `<span class="chip">${echapper(g)}</span>`).join(' ') || '<span class="aide-ro">aucun</span>'}</div>
        <div class="hint-dep" style="margin-top:12px">Lecture seule. Le plan de ce site vit dans
        son dépôt&nbsp;; cette console ne l'édite pas. Pour lui appliquer un rôle&nbsp;:
        <code>make site-appliquer GROUPE=…</code>, ou la vue <b>Assistants</b>.</div></div>`;
    }

    function dessinerServeurs() {
      // Une console qui n'edite aucun plan n'a pas de registre `serveurs` — et elle a
      // pourtant des machines. On dessine CE QU'ELLE A.
      if (!peut('editer_le_plan')) return dessinerMachinesDuSite();
      const cible = document.getElementById('grilles');
      const entete = BANNIERE_MODELE + `<div class="section-grille"><div class="section-tete">Serveurs <span class="compte">${serveurs.length}</span>
        <button type="button" class="fantome" style="margin-left:auto" onclick="ajouterServeur()">+ Serveur</button>
        <button type="button" class="fantome" onclick="appliquerPlan()">⚙ Appliquer le plan</button></div></div>`;
      if (!serveurs.length) { cible.innerHTML = entete + '<div class="vide" style="padding:14px">Aucun serveur. « + Serveur » ou <span class="mono">make serveurs-bootstrap</span>.</div>'; return; }
      const idx = serveurs.map((s, i) => [s, i]).filter(([s]) => correspondServeur(s));
      const sections = [['Actifs', idx.filter(([s]) => s.etat === 'actif')], ['Planifiés', idx.filter(([s]) => s.etat !== 'actif')]];
      cible.innerHTML = entete + sections.filter(([, l]) => l.length).map(([t, l]) =>
        `<div class="section-grille"><div class="section-tete">${t} <span class="compte">${l.length}</span></div><div class="grille-cartes">${l.map(([s, i]) => carteServeur(s, i)).join('')}</div></div>`).join('');
    }
    function inspecteurServeur() {
      if (!peut('editer_le_plan')) return inspecteurMachineDuSite();
      const cible = document.getElementById('detail');
      if (selServeur == null || !serveurs[selServeur]) {
        hoteOpCourant = '';
        cible.innerHTML = '<div class="detail"><div class="vide"><b>Aucun serveur sélectionné</b>Choisis une tuile à gauche, ou ajoute un serveur.</div></div>';
        return;
      }
      const s = serveurs[selServeur];
      const vi = (intrants && intrants.valeurs) || {};
      const libDef = (d) => '(défaut' + (d ? ' : ' + d : '') + ')';
      const optFonction = Object.keys(nomenclature.fonctions || {}).map(f => `<option value="${echapper(f)}" ${f === s.fonction ? 'selected' : ''}>${echapper(f)}</option>`).join('');
      const optEtat = ['planifie', 'actif'].map(e => `<option value="${e}" ${e === s.etat ? 'selected' : ''}>${e}</option>`).join('');
      const optDeListe = (liste, sel, lib) => `<option value="" ${sel ? '' : 'selected'}>${echapper(lib)}</option>`
        + [...new Set([...(liste || []), ...(sel ? [sel] : [])])].map(v => `<option value="${echapper(v)}" ${v === sel ? 'selected' : ''}>${echapper(v)}</option>`).join('');
      const set = new Set(listeDepuisTexte(s.integrations));
      const tousRoles = [...new Set([...integrationsDispo, ...set])];
      const cases = tousRoles.length
        ? tousRoles.map(role => `<label class="integ-case" title="${echapper(role)}"><input type="checkbox" ${set.has(role) ? 'checked' : ''} onchange="basculerIntegration('${echapper(role)}', this.checked)"><span>${echapper(role.replace(/^client_/, ''))}</span></label>`).join('')
        : '<span class="dsn">aucun rôle client_* disponible</span>';
      // Integrations universelles : montrees, jamais cochables. Sans cet affichage,
      // un plan silencieux se lirait « cet hote n'est pas supervise » — l'inverse
      // exact de la politique. L'exemption `sauf_role` s'evalue ici comme au moteur.
      const rendus = new Set(applications.filter(a => a.hote === s.nom).map(a => a.groupe));
      const univ = Object.entries(integrationsUniv)
        .filter(([role, p]) => !(p.sauf_role && rendus.has(p.sauf_role)))
        .map(([role, p]) => `<span class="integ-case integ-univ" title="${echapper(p.raison || '')}">✓ ${echapper(role.replace(/^client_/, ''))}</span>`).join('');
      const exempts = Object.entries(integrationsUniv)
        .filter(([role, p]) => p.sauf_role && rendus.has(p.sauf_role))
        .map(([role, p]) => `<span class="integ-case integ-exempt" title="Exempté : cet hôte rend le service ${echapper(p.sauf_role)}">— ${echapper(role.replace(/^client_/, ''))}</span>`).join('');
      const info = infoFonction(s.fonction);
      const zoneHint = info ? `<span class="zone-hint" title="Dérivé de la nomenclature">${echapper(info.libelle)} · VLAN ${info.vlan}</span>` : '';
      const h = hotes.find(x => x.nom === s.nom);
      const apps = applications.filter(a => a.hote === s.nom);
      const appsHtml = apps.length
        ? `<div class="ch-bases">${apps.map(a => `<div class="ch-base"><span class="badge-bd">app</span> <button type="button" class="lien-objet" onclick="ouvrirApp('${echapper(a.id)}')">${echapper(a.id || '(sans id)')}</button>${a.expose ? ` <span class="mono">→ ${echapper(listeDepuisTexte(a.expose).join(', '))}</span>` : ''}</div>`).join('')}</div>`
        : '<div class="ch-stub">aucune application sur cet hôte</div>';
      const bds = bdServeurs.filter(x => x.hote === s.nom);
      const bdHtml = bds.length
        ? `<div class="ch-bases">${bds.map(x => `<div class="ch-base"><span class="badge-bd">${echapper(x.type)}</span> <button type="button" class="lien-objet" onclick="ouvrirBaseServeur('${echapper(x.nom)}')">${echapper(x.nom)}</button> <span class="mono">:${echapper(x.port)}</span></div>`).join('')}</div>`
        : '<div class="ch-stub">aucun serveur de base ici</div>';
      hoteOpCourant = s.nom;
      const hi = h ? hotes.indexOf(h) : -1;
      let boutons = '';
      // CE QUE LA PORTEE INTERDIT NE SE PROPOSE PAS COMME LE RESTE. Le bouton demeure —
      // le retirer ferait croire que le geste n'existe pas — mais il est inerte et porte
      // sa raison en infobulle. Meme geste que les integrations universelles, affichees
      // en lecture seule plutot qu'omises.
      const inerte = (pouvoir) => peut(pouvoir) ? ''
        : ` disabled title="${echapper(pourquoiPas(pouvoir))}" style="opacity:.45"`;
      if (h) boutons += `<button type="button"${peut('materialiser')
          ? ' title="Cloner la VM depuis le golden template (Proxmox)"' : inerte('materialiser')} onclick="lancer('creer', ${hi})">🖥 Créer la VM</button>`;
      if (h && h.etat === 'actif' && !hoteBloque(h)) {
        const clsDep = estProduction ? 'danger' : 'primaire';
        boutons += `<button type="button" id="btn-verifier"${inerte('configurer')} onclick="lancer('verifier', ${hi})">Vérifier</button>`
                 + `<button type="button" id="btn-deployer" class="${clsDep}"${inerte('configurer')} onclick="lancer('deployer', ${hi})">Déployer</button>`;
      }
      let pied;
      if (boutons) {
        const bloque = h && h.etat === 'actif' && hoteBloque(h);
        const hint = bloque ? `<span class="hint-dep">Prérequis manquant : ${[...new Set((h.groupes || []).flatMap(g => manquantsPourGroupe(g)))].join(', ')}</span>` : '';
        pied = `<div class="pied">${estProduction ? '<span class="badge-prod">PROD</span>' : ''}${hint}<span class="grandit"></span>${boutons}</div>`;
      } else {
        pied = `<div class="pied"><span class="hint-dep">Applique le plan pour instancier cet hôte (⚙ Appliquer le plan)</span></div>`;
      }
      const statBadge = s.statut === 'divergence' ? '<span class="badge-statut bloque">divergent</span>'
        : s.statut === 'absent' ? '<span class="badge-statut attente">non instancié</span>'
        : '<span class="badge-statut ok">réconcilié</span>';
      cible.innerHTML = `<article class="detail">
        <div class="detail-tete"><div class="detail-nom"><span class="detail-nom-txt">${echapper(s.nom || '(sans nom)')}</span>${zoneHint}</div>
          <span class="grandit"></span>${statBadge}
          <button type="button" class="danger" title="Retirer ce serveur" onclick="retirerServeur()">✕</button></div>
        <div class="stats">${tuile(s.vmid, 'VMID')}${tuile(s.adresse_ip, 'IP')}${tuile(s.vlan, 'VLAN')}</div>
        <div class="dsn" style="padding:5px 2px"><b>Plan</b> : ${echapper(s.etat)} &nbsp;·&nbsp; <b>Réel</b> : ${sondes[s.nom] === true ? '<span class="pt actif"></span> vivante' + (s.adresse_ip ? ' (' + echapper(s.adresse_ip) + ')' : '') : sondes[s.nom] === false ? '<span class="pt bloq"></span> injoignable' : '<span class="pt plan"></span> non sondé'}</div>
        <div class="section-tete" style="margin:4px 2px 2px">Identité — saisie du plan (surcharge les défauts)</div>
        ${formulaireDepuisSchema('serveurs', s, 'definirServeur', s.nom, "definirServeur.bind(null,'nom')", 'nom')}
        <div class="grille">
          <label class="champ" style="grid-column:1/-1"><span>Intégrations (rôles client)</span><div class="integ-cases">${univ}${exempts}${cases}</div><span class="dsn" style="font-size:11px">Les ✓ sont la politique des rôles : elles s'appliquent à tout hôte et ne se décochent pas.</span></label>
        </div>
        <div class="section-tete" style="margin:12px 2px 2px">Applications ici</div>${appsHtml}
        <div class="section-tete" style="margin:12px 2px 2px">Bases ici</div>${bdHtml}
        <div class="dsn" style="padding:6px 2px;color:#94a3b8">VMID / IP / VLAN sont <b>dérivés</b>. Sauvegarde (Ctrl+S) puis « Appliquer le plan » pour régénérer l'inventaire.</div>
        ${pied}
      </article>`;
      majBoutonsDeploiement();
    }

    function serveurValeurValide(cle, v) {
      const s = String(v == null ? '' : v).trim();
      if (s === '') return true;   // vide = dérivé / défaut, autorisé
      if (cle === 'nom') return /^[a-z0-9]+(-[a-z0-9]+)*-\d+$/.test(s);
      if (cle === 'memoire') return /^\d+$/.test(s) && +s >= 64 && +s <= 1048576;
      if (cle === 'coeurs') return /^\d+$/.test(s) && +s >= 1 && +s <= 256;
      if (cle === 'disque') return /^\d+\s*[GMgm]?$/.test(s);
      return true;
    }
    function validerChampServeur(el) {
      const ok = serveurValeurValide(el.getAttribute('data-champ'), el.value);
      el.classList.toggle('invalide', !ok);
      return ok;
    }

    async function sauvegarderServeurs() {
      const champs = Array.from(document.querySelectorAll('#detail [data-champ]'));
      const invalides = champs.filter(el => !validerChampServeur(el));
      // Un controle qui n'inspecte AUCUN champ n'est pas un controle : si le formulaire
      // cesse un jour de marquer ses contröles, on le dit plutot que de laisser passer.
      if (!champs.length) { message('Formulaire non marqué : sauvegarde refusée.', 'erreur'); return; }
      if (invalides.length) {
        message('Corrige les ' + invalides.length + ' champ(s) en rouge avant de sauvegarder.', 'erreur');
        invalides[0].focus();
        return;
      }
      const srv = {};
      const propsS = ((schemaPlan.serveurs || {}).entite || {}).properties || {};
      serveurs.forEach(s => {
        if (!String(s.nom).trim()) return;
        const o = {};
        Object.keys(propsS).forEach(cle => {
          const spec = propsS[cle];
          if (spec.type === 'array') {
            const l = listeDepuisTexte(s[cle]); if (l.length) o[cle] = l; return;
          }
          const v = s[cle];
          if (v === undefined || v === null || String(v).trim() === '') return;
          o[cle] = (spec.type === 'integer') ? (parseInt(v, 10) || v) : v;
        });
        // `etat` a un defaut METIER, pas un defaut de schema : un serveur sans etat est
        // planifie, jamais actif. Le declarer ici plutot qu'au schema evite de le poser
        // par ecrit dans chaque plan.
        if (!o.etat) o.etat = 'planifie';
        srv[s.nom] = o;
      });
      const rep = await fetch('/api/serveurs', {
        method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON}, body: JSON.stringify({serveurs: srv})
      });
      const data = await rep.json();
      if (!rep.ok) { message(data.erreur || 'Sauvegarde refusée.', 'erreur'); return; }
      chargerServeurs(data); dessinerServeurs();
      message('Serveurs (plan) sauvegardés. Pense à « Appliquer le plan ».', 'ok');
    }

    async function appliquerPlan() {
      const t = message('Application du plan…', '', {persistant: true});
      try {
        const rep = await fetch('/api/instancier', {method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON}, body: '{}'});
        const data = await rep.json();
        const derniere = (data.sortie || '').split('\n').pop();
        majToast(t, (data.ok ? 'Plan appliqué : ' : 'Échec : ') + derniere, data.ok ? 'ok' : 'erreur', data.ok ? 4000 : 8000);
        if (data.ok) charger();
      } catch (e) {
        majToast(t, 'Erreur réseau : ' + e, 'erreur', 8000);
      }
    }

    function dessinerDependances() {
      const cible = document.getElementById('dependances');
      const noms = Object.keys(dependances).sort();
      const bloques = noms.filter(g => statutDependance(g) === 'bloque').length;
      const resume = document.getElementById('dep-resume');
      resume.textContent = bloques ? bloques + ' bloqués' : noms.length + ' suivis';
      if (!noms.length) { cible.innerHTML = '<div class="vide" style="padding:14px">Aucune dépendance.</div>'; return; }
      cible.innerHTML = noms.map(groupe => {
        const config = dependances[groupe] || {};
        const requis = config.requiert_groupes_actifs || [];
        const statut = statutDependance(groupe);
        const manquants = manquantsPourGroupe(groupe);
        const detail = requis.length ? `requiert ${requis.join(', ')}` : 'aucun prérequis';
        const manque = requis.length && manquants.length ? `manquant : ${manquants.join(', ')}` : '';
        return `
          <div class="carte-dep ${statut}" title="${echapper(config.raison || '')}">
            <div class="haut"><span class="nom">${echapper(groupe)}</span><span class="chip"><span class="pt ${statut === 'ok' ? 'actif' : statut === 'bloque' ? 'bloq' : 'plan'}"></span>${libelleStatut(statut)}</span></div>
            <div class="txt">${echapper(detail)}</div>
            ${manque ? `<div class="txt">${echapper(manque)}</div>` : ''}
          </div>`;
      }).join('');
    }

    function tuile(valeur, libelle) {
      const v = (valeur === '' || valeur == null) ? '—' : String(valeur);
      return `<div class="stat"><div class="v ${v === '—' ? 'vide' : ''}">${echapper(v)}</div><div class="l">${echapper(libelle)}</div></div>`;
    }

    function dessinerDetail() {
      // Le panneau de droite reflète la sélection de la VUE COURANTE.
      if (vuePrincipale === 'flux' || vuePrincipale === 'couches' || vuePrincipale === 'reseau') return legendeLecture();
      if (vuePrincipale === 'assistants') return inspecteurRunbook();
      if (vuePrincipale === 'integrations') return legendeIntegrations();
      if (vuePrincipale === 'applications') return inspecteurApplication();
      if (vuePrincipale === 'bases') return inspecteurBase();
      if (vuePrincipale === 'domaines') return inspecteurDomaine();
      if (vuePrincipale === 'nomenclature') return inspecteurNomenclature();
      return inspecteurServeur();
    }

    function majBoutonsDeploiement() {
      const bv = document.getElementById('btn-verifier');
      const bd = document.getElementById('btn-deployer');
      const hote = hoteOpCourant || '';
      if (bv) { bv.disabled = occupe; bv.title = occupe ? 'Exécution en cours' : 'Dry-run (--check --diff), aucune modification'; }
      if (bd) { bd.disabled = occupe || !verifie[hote]; bd.title = !verifie[hote] ? 'Vérifiez (dry-run) d\'abord' : 'Applique les playbooks sur la VM réelle'; }
    }

    function fonctionDe(nom) {
      const m = (nom || '').match(/^(.+)-(\d+)$/);
      return m ? {fonction: m[1], seq: parseInt(m[2], 10)} : {fonction: nom || '', seq: null};
    }
    function infoFonction(fonction) {
      const d = (nomenclature.fonctions || {})[fonction];
      if (!d) return null;
      const c = (nomenclature.categories || {})[d.categorie];
      if (!c) return null;
      // VLAN derive du seed index (miroir de inventory_rules.vlan_de) : 1000 + index*10 + zone.
      const idx = (nomenclature.index != null) ? nomenclature.index : 9;
      const vlan = 1000 + idx * 10 + Number(d.categorie);
      return {categorie: d.categorie, service: d.service, libelle: c.libelle, vlan};
    }
    function echapper(valeur) {
      return String(valeur).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
    }

    function ouvrirConsole(titre, hote) {
      document.getElementById('console-titre').textContent = titre + ' · ' + hote;
      document.getElementById('console-sortie').textContent = '';
      const res = document.getElementById('console-resume'); res.hidden = true; res.innerHTML = '';
      const etat = document.getElementById('console-etat');
      etat.className = 'console-etat actif'; etat.textContent = '● en cours';
      document.getElementById('btn-fermer-console').disabled = true;
      document.getElementById('console').hidden = false;
      consoleDebut = Date.now();
      clearInterval(chronoConsole);
      chronoConsole = setInterval(() => {
        const s = Math.round((Date.now() - consoleDebut) / 1000);
        etat.textContent = '● en cours · ' + s + 's';
      }, 1000);
    }
    function ecrireConsole(t) { const p = document.getElementById('console-sortie'); p.textContent += t; p.scrollTop = p.scrollHeight; }
    let dernierResumeTexte = '';
    function afficherResumeErreur(resume) {
      const el = document.getElementById('console-resume');
      const echecs = (resume && resume.echecs) || [];
      if (!echecs.length) { el.hidden = true; return; }
      const lignes = echecs.map(e =>
        `<li><b>${echapper(e.tache)}</b> — <span class="re-hote">${echapper(e.hote)}</span> <span class="re-type">${echapper(e.type)}</span>
         <div class="re-msg">${echapper(e.message)}</div></li>`).join('');
      dernierResumeTexte = echecs.map(e => `• [${e.type}] ${e.tache} @ ${e.hote} : ${e.message}`).join('\n');
      el.innerHTML = `<div class="re-tete">❌ Échec — ${echecs.length} tâche(s) en erreur
        <button type="button" class="fantome" onclick="copierResume()" title="Copier un résumé clair à transmettre">Copier</button></div>
        <ul class="re-liste">${lignes}</ul>`;
      el.hidden = false;
    }
    function copierResume() {
      if (navigator.clipboard) navigator.clipboard.writeText(dernierResumeTexte)
        .then(() => message('Résumé copié — à transmettre au mainteneur.', 'ok'), () => {});
    }
    function finirConsole(rc) {
      clearInterval(chronoConsole); chronoConsole = null;
      const s = Math.round((Date.now() - consoleDebut) / 1000);
      const etat = document.getElementById('console-etat');
      etat.className = 'console-etat ' + (rc === 0 ? 'ok' : 'echec');
      etat.textContent = (rc === 0 ? '✓ succès' : '✗ échec (rc=' + rc + ')') + ' · ' + s + 's';
      document.getElementById('btn-fermer-console').disabled = false;
    }
    function fermerConsole() { if (!occupe) document.getElementById('console').hidden = true; }

    function ouvrirModale(titre, texte) {
      document.getElementById('modale-titre').textContent = titre;
      document.getElementById('modale-texte').textContent = texte;
      const champ = document.getElementById('modale-vault');
      champ.value = motVault || '';
      document.getElementById('modale').hidden = false;
      setTimeout(() => champ.focus(), 0);
      return new Promise(res => { modaleResolveur = res; });
    }
    function confirmerModale() {
      const v = document.getElementById('modale-vault').value;
      document.getElementById('modale').hidden = true;
      const r = modaleResolveur; modaleResolveur = null;
      if (r) r(v);
    }
    function annulerModale() {
      document.getElementById('modale').hidden = true;
      const r = modaleResolveur; modaleResolveur = null;
      if (r) r(null);
    }

    function ouvrirIntrants() {
      if (!intrants) { message('Intrants indisponibles (rechargez).', 'erreur'); return; }
      rendreIntrants();
      document.getElementById('intrants').hidden = false;
    }
    function fermerIntrants() { document.getElementById('intrants').hidden = true; }

    function rendreIntrants() {
      const corps = document.getElementById('intrants-corps');
      const schema = intrants.schema || [];
      const valeurs = intrants.valeurs || {};
      const sections = [];
      const parSection = {};
      const proprioDe = {};
      schema.forEach(ch => {
        if (!parSection[ch.section]) { parSection[ch.section] = []; sections.push(ch.section); }
        parSection[ch.section].push(ch);
        proprioDe[ch.section] = ch.proprietaire || 'tenant';
      });
      let html = '';
      sections.forEach(sec => {
        // Le panneau melangeait deux proprietaires sans le dire. Un tenant et son
        // hebergeur n'ont ni le meme depot, ni le meme cycle de vie : editer une
        // section « hébergeur » touche TOUS les tenants du cluster.
        const heb = proprioDe[sec] === 'hebergeur';
        const chip = heb
          ? '<span class="intr-proprio heb" title="Propriété de l\'HÉBERGEUR — écrit hors du dépôt du tenant ; la modification vaut pour tous ses tenants">hébergeur</span>'
          : '<span class="intr-proprio ten" title="Propriété du TENANT — écrit dans son dépôt ; n\'affecte que lui">tenant</span>';
        html += '<div class="intr-section"><div class="intr-tete">' + echapper(sec) + chip + '</div><div class="intr-grille">';
        parSection[sec].forEach(ch => {
          const v = valeurs[ch.variable];
          let badge;
          if (ch.classe === 'constante') badge = '<span class="badge-classe const" title="Valeur unique, non surchargeable">Constante</span>';
          else if (ch.classe === 'catalogue') badge = '<span class="badge-classe cat" title="Liste de valeurs autorisées, proposée dans les menus déroulants">Catalogue</span>';
          else badge = '<span class="badge-classe def" title="Valeur par défaut, surchargeable dans les instances">Défaut</span>';
          const lib = echapper(ch.libelle) + badge;
          if (ch.type === 'bool') {
            const coche = (v === true || v === 'true' || v === 'True') ? ' checked' : '';
            html += '<label class="champ"><span>' + lib + '</span>'
                  + '<input type="checkbox" data-intrant="' + echapper(ch.variable) + '" data-type="bool"' + coche + '></label>';
          } else if (ch.type === 'liste') {
            const txt = Array.isArray(v) ? v.join(', ') : (v == null ? '' : v);
            html += '<label class="champ" style="grid-column:1/-1"><span>' + lib + ' <span class="unite">· séparés par des virgules</span></span>'
                  + '<input type="text" data-intrant="' + echapper(ch.variable) + '" data-type="liste"'
                  + ' placeholder="ex. asgard, pve-02, pve-03" value="' + echapper(txt) + '"></label>';
          } else {
            const t = ch.type === 'int' ? 'number' : 'text';
            html += '<label class="champ"><span>' + lib + '</span>'
                  + '<input type="' + t + '" data-intrant="' + echapper(ch.variable) + '" data-type="' + echapper(ch.type) + '"'
                  + ' value="' + echapper(v == null ? '' : v) + '"></label>';
          }
        });
        html += '</div></div>';
      });
      // Nomenclature en lecture seule (lue ailleurs : vue Nomenclature)
      const n = nomenclature || {};
      if (Object.keys(n).length) {
        html += '<div class="intr-section"><div class="intr-tete">Nomenclature (lecture seule)</div>'
              + '<div class="intr-ro">';
        if (n.supernet) html += 'Supernet&nbsp;: <b>' + echapper(n.supernet) + '</b><br>';
        if (n.domaine || n.domaine_interne) html += 'Domaine&nbsp;: <b>' + echapper(n.domaine || n.domaine_interne) + '</b><br>';
        const nbCat = n.categories ? Object.keys(n.categories).length : 0;
        const nbFon = n.fonctions ? Object.keys(n.fonctions).length : 0;
        html += nbCat + ' catégorie(s), ' + nbFon + ' fonction(s) déclarée(s).';
        html += '<br><span style="font-style:italic">Modifiable dans le plan (nomenclature.yml), pas ici.</span>';
        html += '</div></div>';
      }
      // Secrets attendus : informatif, jamais saisis ici
      const secrets = intrants.secrets_attendus || [];
      if (secrets.length) {
        html += '<div class="intr-section"><div class="intr-tete">Secrets attendus (Vault — CLI)</div>'
              + '<div class="intr-ro">Ces clés ne sont jamais saisies ni stockées ici. Édite-les via <b>ansible-vault</b>.'
              + '<div class="intr-secrets">'
              + secrets.map(s => '<code>' + echapper(s) + '</code>').join('')
              + '</div></div></div>';
      }
      const f = intrants.fichiers || {};
      const chemins = Object.values(f).map(x => echapper(x)).join(', ');
      if (chemins) html += '<div class="intr-ro" style="margin-top:2px">Écrit dans&nbsp;: <b>' + chemins + '</b></div>';
      corps.innerHTML = html;
    }

    async function enregistrerIntrants() {
      const valeurs = {};
      document.querySelectorAll('#intrants-corps [data-intrant]').forEach(el => {
        const k = el.getAttribute('data-intrant');
        valeurs[k] = el.type === 'checkbox' ? el.checked : el.value;
      });
      const ancienDomaine = (intrants.valeurs || {}).domaine_interne;
      const nouveauDomaine = valeurs.domaine_interne;
      if (nouveauDomaine !== undefined && nouveauDomaine !== ancienDomaine) {
        if (!confirm('Changer le domaine interne (« ' + (ancienDomaine || '∅') + ' » → « ' + (nouveauDomaine || '∅')
            + ' ») impacte tout l\'écosystème (DNS, certificats, noms d\'hôtes). Continuer ?')) return;
      }
      try {
        const reponse = await fetch('/api/intrants', {
          method: 'POST',
          headers: {'Content-Type': 'application/json', 'X-Jeton': JETON},
          body: JSON.stringify({valeurs}),
        });
        if (!reponse.ok) {
          let detail = '';
          try { detail = (await reponse.json()).erreur || ''; } catch (e) { detail = await reponse.text(); }
          message('Échec de l\'enregistrement des intrants : ' + detail, 'erreur');
          return;
        }
        const data = await reponse.json();
        intrants = data.intrants || intrants;
        nomenclature = data.nomenclature || nomenclature;
        fermerIntrants();
        message('Intrants de base enregistrés.', 'ok');
      } catch (e) {
        message('Erreur réseau : ' + e, 'erreur');
      }
    }

    async function lancer(mode, index) {
      const hote = hotes[index] ? hotes[index].nom : '';
      if (!hote) { message('Hôte introuvable.', 'erreur'); return; }
      if (occupe) return;
      // Un seul entonnoir pour les quatre gestes : la coupure se dit ici, et elle nomme
      // sa raison. « Interdit » sans raison envoie chercher une panne qui n'existe pas.
      const pouvoirMode = POUVOIR_PAR_MODE[mode];
      if (pouvoirMode && !peut(pouvoirMode)) {
        message(pourquoiPas(pouvoirMode), 'erreur', {duree: 9000});
        return;
      }
      let vault = '';
      if ((mode === 'deployer' || mode === 'pousser') && !verifie[hote]) { message('Vérifiez (dry-run) d\'abord.', 'erreur'); return; }
      if (mode === 'creer' || mode === 'deployer' || mode === 'pousser' || mode === 'verifier') {
        if (estProduction && (mode === 'deployer' || mode === 'pousser')) {
          const saisi = prompt('⚠️ PRODUCTION — action réelle sur « ' + hote + ' ».\n'
            + 'Tape le nom exact de l\'hôte pour confirmer :');
          if (saisi === null) return;
          if (saisi.trim() !== hote) { message('Confirmation annulée : le nom ne concorde pas.', 'erreur'); return; }
        }
        const av = estProduction ? '⚠️ PRODUCTION. ' : '';
        const txt = mode === 'creer'
          ? 'Clone la VM « ' + hote + ' » depuis le golden template sur Proxmox (création réelle).'
          : mode === 'pousser'
          ? av + 'Déploie l\'hôte « ' + hote + ' » (applique ses playbooks, en root). Non transactionnel.'
          : mode === 'verifier'
          ? 'Dry-run (--check), AUCUNE modification. Mot de passe vault pour déchiffrer les secrets — laisse VIDE si cet hôte n\'a pas de secrets.'
          : av + 'Applique les playbooks de groupes sur la VM réelle, en root (sudo). Non transactionnel.';
        const titre = (mode === 'creer' ? 'Créer la VM — ' : mode === 'pousser' ? 'Déployer — ' : mode === 'verifier' ? 'Vérifier — ' : 'Déployer — ') + hote;
        vault = await ouvrirModale(titre, txt);
        if (vault === null) return;
        motVault = vault;
      }
      occupe = true; majBoutonsDeploiement();
      const titreConsole = {verifier: 'Vérification (dry-run)', deployer: 'Déploiement', creer: 'Création VM (clone)', pousser: 'Déploiement'}[mode] || mode;
      ouvrirConsole(titreConsole, hote);
      try {
        const rep = await fetch('/api/' + mode, {
          method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON},
          body: JSON.stringify(vault ? {hote, vault} : {hote})
        });
        if (!rep.ok || !rep.body) {
          const d = await rep.json().catch(() => ({}));
          ecrireConsole((d.erreur || 'Refusé.') + '\n'); finirConsole(1);
          occupe = false; majBoutonsDeploiement(); return;
        }
        const lecteur = rep.body.getReader();
        const dec = new TextDecoder();
        let rc = null; let brut = '';
        while (true) {
          const {value, done} = await lecteur.read();
          if (done) break;
          let texte = dec.decode(value, {stream: true});
          brut += texte;
          const m = texte.match(/__FIN__ rc=(-?\d+)/);
          if (m) { rc = parseInt(m[1], 10); }
          texte = texte.replace(/\n?__RESUME__ .*\n?/, '').replace(/\n?__FIN__ rc=-?\d+\n?/, '');
          if (texte) ecrireConsole(texte);
        }
        if (rc === null) rc = 1;
        const mr = brut.match(/__RESUME__ (.+)/);
        if (rc !== 0 && mr) { try { afficherResumeErreur(JSON.parse(mr[1])); } catch (e) {} }
        finirConsole(rc);
        if (mode === 'verifier' && rc === 0) { verifie[hote] = true; message('Vérification réussie — déploiement débloqué pour ' + hote + '.', 'ok'); }
        else if (mode === 'creer') { message(rc === 0 ? 'VM « ' + hote + ' » créée — hôte marqué actif.' : 'Échec de la création.', rc === 0 ? 'ok' : 'erreur'); if (rc === 0) appliquerPlan(); else sonder(); }
        else if (mode === 'deployer' || mode === 'pousser') { verifie[hote] = false; message(rc === 0 ? 'Déploiement terminé — hôte marqué actif.' : 'Déploiement en échec.', rc === 0 ? 'ok' : 'erreur'); if (rc === 0) appliquerPlan(); else sonder(); }
      } catch (e) {
        ecrireConsole('Erreur client : ' + e.message + '\n'); finirConsole(1);
      }
      occupe = false; majBoutonsDeploiement();
    }


    // ═══ LES ASSISTANTS — un runbook, son ordre, et pourquoi cet ordre-la ═══════════
    //
    // CE QUE CETTE VUE AJOUTE. Les autres vues editent le PLAN ; celle-ci conduit des
    // GESTES. Le Makefile porte 132 cibles qui disent chacune ce qu'elle fait, et aucune
    // ne dit dans quel ordre. Cette connaissance vivait en prose dans les documents :
    // l'exploitant devait la lire ailleurs, puis revenir cliquer ici.
    //
    // RIEN N'EST ECRIT EN DUR ICI. La liste, les libelles, les natures et les variables
    // viennent de `/api/runbooks`, qui joint `docs/runbooks-construction.yml` au Makefile
    // au moment de servir. Une cible renommee se voit donc ici, elle ne s'invente pas.
    let runbooks = [], rbSel = null, rbEcarts = [], rbEtats = {};
    let etapeResolveur = null;

    async function chargerRunbooks() {
      try {
        const r = await fetch('/api/runbooks', {headers: {'X-Jeton': JETON}});
        const d = await r.json();
        runbooks = d.runbooks || [];
        rbEcarts = d.ecarts || [];
        if (d.erreur) message('Registre des runbooks : ' + d.erreur, 'erreur', {duree: 9000});
        if (!rbSel && runbooks.length) rbSel = (runbooks.find(x => x.conduisible) || runbooks[0]).id;
      } catch (e) { message('Assistants indisponibles : ' + e.message, 'erreur'); }
    }

    function rbCourant() { return runbooks.find(x => x.id === rbSel) || null; }
    function rbEtat(id, i) { return (rbEtats[id] || {})[i] || null; }

    // LA SEQUENCE EST UN GARDE-FOU, PAS UNE DECORATION. Une etape qui ECRIT suppose que la
    // precedente a reussi — sinon on batit sur un terrain qu'on n'a pas verifie. Une
    // etape qui MESURE reste toujours offerte : mesurer apres un echec est exactement ce
    // qu'on fait pour comprendre. Les etapes facultatives ne bloquent personne.
    function etapeBloquee(rb, i) {
      // Hors de portee de CETTE console : l'etape se lit, elle ne se lance pas.
      if (rb.etapes[i].conduisible === false) return true;
      if (rb.etapes[i].nature === 'mesure') return false;
      for (let j = i - 1; j >= 0; j--) {
        if (rb.etapes[j].facultative) continue;
        return rbEtat(rb.id, j) !== 'ok';
      }
      return false;
    }

    function dessinerAssistants() {
      const g = document.getElementById('grilles');
      if (!runbooks.length) {
        g.innerHTML = '<div class="hint-dep">Chargement des assistants…</div>';
        chargerRunbooks().then(() => {
          if (vuePrincipale === 'assistants') { dessinerAssistants(); dessinerDetail(); }
        });
        return;
      }
      const puces = runbooks.map(rb => {
        const n = rb.etapes.length;
        return '<button type="button" class="rb-puce' + (rb.id === rbSel ? ' on' : '')
          + (rb.conduisible ? '' : ' hors') + '" onclick="choisirRunbook(\'' + rb.id + '\')"'
          + ' title="' + echapper(rb.conduisible ? rb.but : rb.raison) + '">'
          + echapper(rb.titre) + '<span class="chip">' + n + '</span></button>';
      }).join('');
      const rb = rbCourant();
      let corps = '';
      if (rb) {
        corps = rb.etapes.map((e, i) => {
          const etat = rbEtat(rb.id, i);
          const bloquee = etapeBloquee(rb, i);
          const cls = etat === 'ok' ? ' faite' : etat === 'echec' ? ' ratee' : bloquee ? ' bloquee' : '';
          const vars = (e.variables || []).map(v => v.nom + '=…').join(' ');
          const fixes = Object.entries(e.fixes || {}).map(([k, v]) => k + '=' + v).join(' ');
          const meta = [e.duree ? 'durée observée ' + e.duree : '',
                        e.facultative ? 'facultative' : ''].filter(Boolean).join(' · ');
          return '<div class="rb-etape' + cls + '">'
            + '<div class="rb-num">' + (i + 1) + '</div>'
            + '<div><div><span class="rb-cible">make ' + echapper(e.cible)
            + (vars ? ' ' + echapper(vars) : '') + (fixes ? ' ' + echapper(fixes) : '')
            + '</span><span class="rb-nature ' + e.nature + '">' + e.nature + '</span></div>'
            + '<div class="rb-libelle">' + echapper(e.libelle || '(aucun libellé au Makefile)') + '</div>'
            + '<div class="rb-pourquoi">' + echapper(e.pourquoi) + '</div>'
            + (meta ? '<div class="rb-meta">' + echapper(meta) + '</div>' : '')
            + (etat === 'ok' ? '<div class="rb-meta">✔ réussie dans cette session</div>' : '')
            + (etat === 'echec' ? '<div class="rb-meta">✘ échouée — la suite reste bloquée</div>' : '')
            + (e.conduisible === false ? '<div class="rb-meta">⊘ hors de portée de cette console — '
                + echapper(e.raison || '') + '</div>' : '')
            + '</div>'
            + '<div><button type="button" class="' + (e.nature === 'destructif' ? '' : 'primaire')
            + '" ' + (bloquee ? 'disabled' : '') + ' onclick="lancerEtape(' + i + ')">'
            + (e.nature === 'mesure' ? 'Mesurer' : e.nature === 'destructif' ? 'Détruire…' : 'Lancer')
            + '</button></div></div>';
        }).join('');
      }
      const alerte = rbEcarts.length
        ? '<div class="hint-dep" style="border-color:#8a3b3b">Le registre des runbooks porte '
          + rbEcarts.length + ' écart(s) avec le Makefile : <code>python3 scripts/runbooks.py verifier</code></div>'
        : '';
      g.innerHTML = alerte + '<div class="rb-liste">' + puces + '</div>' + corps;
    }

    function choisirRunbook(id) { rbSel = id; dessinerAssistants(); dessinerDetail(); }

    function inspecteurRunbook() {
      const d = document.getElementById('detail');
      const rb = rbCourant();
      if (!rb) { d.innerHTML = '<div class="detail"><div class="hint-dep">Aucun assistant.</div></div>'; return; }
      const compte = rb.etapes.filter((e, i) => rbEtat(rb.id, i) === 'ok').length;
      d.innerHTML = '<div class="detail"><div class="section-tete">' + echapper(rb.titre) + '</div>'
        + '<div class="rb-but">' + echapper(rb.but) + '</div>'
        + '<div class="hint-dep" style="margin-top:10px">Portée&nbsp;: <code>' + echapper(rb.portee)
        + '</code> · ' + compte + '/' + rb.etapes.length + ' étape(s) réussie(s) dans cette session.</div>'
        + (function () {
            const fermees = rb.etapes.filter(e => e.conduisible === false);
            if (!fermees.length) return '';
            return '<div class="hint-dep" style="margin-top:10px;border-color:#8a3b3b">'
              + fermees.length + ' étape(s) sur ' + rb.etapes.length + ' hors de portée ici&nbsp;: '
              + echapper(fermees.map(e => e.cible).join(', ')) + '. ' + echapper(fermees[0].raison || '')
              + '</div>';
          })()
        + (rb.doc ? '<div class="hint-dep" style="margin-top:10px">Le récit complet&nbsp;: <code>'
            + echapper(rb.doc) + '</code></div>' : '')
        + '<div class="hint-dep" style="margin-top:10px">Les libellés viennent du <code>Makefile</code>, '
        + 'lus à chaque affichage&nbsp;; l\'ordre et le « pourquoi » viennent de '
        + '<code>docs/runbooks-construction.yml</code>. Une étape d\'écriture attend que la '
        + 'précédente ait réussi&nbsp;; une mesure reste toujours offerte.</div></div>';
    }

    // La modale d'etape : les champs que le REGISTRE declare, et rien d'autre.
    function ouvrirModaleEtape(rb, e, i) {
      document.getElementById('etape-titre').textContent = (i + 1) + '. make ' + e.cible;
      const avert = e.nature === 'destructif'
        ? '⚠️ GESTE DESTRUCTIF. ' : e.nature === 'ecriture' ? 'Ce geste écrit. ' : 'Aucune écriture. ';
      document.getElementById('etape-texte').textContent = avert + e.pourquoi;
      const champs = document.getElementById('etape-champs');
      let html = (e.variables || []).map(v => {
        if (v.valeurs) {
          return '<label class="champ"><span>' + echapper(v.invite || v.nom)
            + (v.facultatif ? ' (facultatif)' : '') + '</span><select id="var-' + v.nom + '">'
            + (v.facultatif ? '<option value=""></option>' : '')
            + v.valeurs.map(x => '<option>' + echapper(x) + '</option>').join('') + '</select></label>';
        }
        return '<label class="champ"><span>' + echapper(v.invite || v.nom)
          + (v.facultatif ? ' (facultatif)' : '') + '</span><input id="var-' + v.nom
          + '" autocomplete="off" placeholder="' + echapper(v.exemple || '') + '"></label>';
      }).join('');
      // LA CONFIRMATION ECRITE EST LE SEUL GARDE-FOU QUI RESISTE A UN CLIC DISTRAIT.
      if (e.nature === 'destructif') {
        html += '<label class="champ"><span>Pour confirmer, écris <b>DETRUIRE</b></span>'
          + '<input id="var-__confirmation" autocomplete="off"></label>';
      }
      champs.innerHTML = html;
      document.getElementById('etape-vault').value = motVault || '';
      document.getElementById('etape').hidden = false;
      return new Promise(res => { etapeResolveur = res; });
    }
    function confirmerEtape() {
      const rb = rbCourant(); if (!rb) return;
      const r = etapeResolveur;
      const boite = document.getElementById('etape-champs');
      const valeurs = {};
      let confirmation = null;
      boite.querySelectorAll('input,select').forEach(el => {
        const nom = el.id.replace(/^var-/, '');
        if (nom === '__confirmation') confirmation = el.value.trim();
        else valeurs[nom] = el.value.trim();
      });
      document.getElementById('etape').hidden = true;
      etapeResolveur = null;
      if (r) r({valeurs, vault: document.getElementById('etape-vault').value, confirmation});
    }
    function annulerEtape() {
      document.getElementById('etape').hidden = true;
      const r = etapeResolveur; etapeResolveur = null;
      if (r) r(null);
    }

    async function lancerEtape(i) {
      const rb = rbCourant(); if (!rb || occupe) return;
      const e = rb.etapes[i];
      if (e.conduisible === false) { message(e.raison || rb.raison, 'erreur', {duree: 9000}); return; }
      if (etapeBloquee(rb, i)) { message('L\'étape précédente n\'a pas réussi.', 'erreur'); return; }
      const rep0 = await ouvrirModaleEtape(rb, e, i);
      if (rep0 === null) return;
      if (e.nature === 'destructif' && rep0.confirmation !== 'DETRUIRE') {
        message('Confirmation annulée : le mot ne concorde pas.', 'erreur'); return;
      }
      motVault = rep0.vault;
      occupe = true; majBoutonsDeploiement();
      ouvrirConsole(rb.titre + ' — étape ' + (i + 1), e.cible);
      try {
        const rep = await fetch('/api/runbook-etape', {
          method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON},
          body: JSON.stringify({runbook: rb.id, cible: e.cible, index: i,
                                valeurs: rep0.valeurs, vault: rep0.vault})
        });
        if (!rep.ok || !rep.body) {
          const d = await rep.json().catch(() => ({}));
          ecrireConsole((d.erreur || 'Refusé.') + '\n'); finirConsole(1);
          occupe = false; majBoutonsDeploiement(); return;
        }
        const lecteur = rep.body.getReader();
        const dec = new TextDecoder();
        let rc = null, brut = '';
        while (true) {
          const {value, done} = await lecteur.read();
          if (done) break;
          let texte = dec.decode(value, {stream: true});
          brut += texte;
          const m = texte.match(/__FIN__ rc=(-?\d+)/);
          if (m) rc = parseInt(m[1], 10);
          texte = texte.replace(/\n?__RESUME__ .*\n?/, '').replace(/\n?__FIN__ rc=-?\d+\n?/, '');
          if (texte) ecrireConsole(texte);
        }
        if (rc === null) rc = 1;
        const mr = brut.match(/__RESUME__ (.+)/);
        if (rc !== 0 && mr) { try { afficherResumeErreur(JSON.parse(mr[1])); } catch (err) {} }
        finirConsole(rc);
        rbEtats[rb.id] = rbEtats[rb.id] || {};
        rbEtats[rb.id][i] = rc === 0 ? 'ok' : 'echec';
        message(rc === 0 ? 'Étape ' + (i + 1) + ' réussie.' : 'Étape ' + (i + 1) + ' en échec.',
                rc === 0 ? 'ok' : 'erreur');
      } catch (err) {
        ecrireConsole('Erreur client : ' + err.message + '\n'); finirConsole(1);
        rbEtats[rb.id] = rbEtats[rb.id] || {}; rbEtats[rb.id][i] = 'echec';
      }
      occupe = false; majBoutonsDeploiement();
      if (vuePrincipale === 'assistants') { dessinerAssistants(); dessinerDetail(); }
    }

    function sauvegarderVue() {
      if (occupe) return;
      if (vuePrincipale === 'serveurs' || vuePrincipale === 'integrations') sauvegarderServeurs();
      else if (vuePrincipale === 'applications') sauvegarderApplications();
      else if (vuePrincipale === 'bases') sauvegarderBases();
      else if (vuePrincipale === 'domaines') sauvegarderDomaines();
      else if (vuePrincipale === 'nomenclature') sauvegarderNomenclature();
      else message('Vue en lecture seule (Flux / Couches) — édite dans Serveurs / Applications / Bases / Domaines.');
    }

    function ordreServeursVisibles() {
      const vis = serveurs.map((s, i) => [s, i]).filter(([s]) => correspondServeur(s));
      return [...vis.filter(([s]) => s.etat === 'actif'), ...vis.filter(([s]) => s.etat !== 'actif')].map(([, i]) => i);
    }
    function naviguerServeurs(delta) {
      const ordre = ordreServeursVisibles();
      if (!ordre.length) return;
      let pos = ordre.indexOf(selServeur);
      pos = pos < 0 ? (delta > 0 ? 0 : ordre.length - 1)
                    : Math.min(ordre.length - 1, Math.max(0, pos + delta));
      choisirServeur(ordre[pos]);
      const c = document.getElementById('tuile-srv-' + ordre[pos]);
      if (c) c.scrollIntoView({block: 'nearest', behavior: 'smooth'});
    }

    document.addEventListener('keydown', e => {
      if (e.key === 'Escape' && modaleResolveur) { annulerModale(); return; }
      if ((e.ctrlKey || e.metaKey) && (e.key === 's' || e.key === 'S')) { e.preventDefault(); sauvegarderVue(); return; }
      const dansSaisie = /^(INPUT|SELECT|TEXTAREA)$/.test((document.activeElement || {}).tagName || '');
      if (dansSaisie || e.ctrlKey || e.metaKey || e.altKey) return;
      const vues = {'1': 'serveurs', '2': 'applications', '3': 'bases'};
      if (vues[e.key]) { setVue(vues[e.key]); return; }
      if (e.key === '/') { e.preventDefault(); const f = document.getElementById('filtre'); if (f) f.focus(); return; }
      if (vuePrincipale !== 'serveurs') return;
      if (e.key === 'j') { naviguerServeurs(1); return; }
      if (e.key === 'k') { naviguerServeurs(-1); return; }
      if (e.key === 'v') { const b = document.getElementById('btn-verifier'); if (b && !b.disabled) b.click(); return; }
      if (e.key === 'd') { const b = document.getElementById('btn-deployer'); if (b && !b.disabled) b.click(); return; }
    });

    // Validation inline des champs du plan (vue Serveurs) — liseré rouge avant l'envoi.
    document.addEventListener('input', e => {
      if (e.target && e.target.matches && e.target.matches('[data-v]')) validerChampServeur(e.target);
    });

    // Garde-fou : prévenir la perte d'éditions de plan non sauvegardées.
    window.addEventListener('beforeunload', e => {
      if (serveursModifie || applicationsModifie || basesModifie || domainesModifie) { e.preventDefault(); e.returnValue = ''; }
    });

    // ------ Info-bulles d'aide au survol de la description d'un champ ------
    (function () {
      const AIDES = {
        'Adresse IP': "Adresse IPv4 de la VM sur son VLAN. Ex. 10.10.12.11. Souvent dérivée — clic « Proposer ».",
        'CIDR': "Masque réseau en bits. 24 = /24 (255.255.255.0).",
        'Passerelle': "Routeur de sortie du VLAN. En général le .1 du sous-réseau.",
        'VLAN': "Identifiant 802.1Q (1–4094). Dérivé de la fonction via la nomenclature.",
        'Pont': "Pont réseau Proxmox. Ex. vmbr0.",
        'DNS': "Résolveur DNS de la VM. En général le DNS interne de l'écosystème.",
        'Utilisateur Ansible': "Compte technique utilisé par Ansible. Par défaut : ansible.",
        'VMID': "Identifiant unique Proxmox. Dérivé (catégorie + service + rang).",
        'Nœud': "Hôte Proxmox cible. Ex. pve-01.",
        'Stockage': "Pool de stockage Proxmox du disque. Ex. local-zfs.",
        'Disque': "Taille du disque système. Ex. 32G. Dérivée des logiciels hébergés + socle.",
        'Mémoire': "RAM en Mo. Dérivée des logiciels hébergés + socle (avec marge).",
        'Cœurs': "vCPU alloués. Dérivés des logiciels hébergés (maximum, pas additif).",
        'Nom': "Identifiant unique du serveur de base, sans espace.",
        'Type': "Moteur de la base. Ex. postgres, redis.",
        'Hôte': "VM qui héberge ce service (nom du serveur).",
        'Hôte (VM)': "VM cible où l'application est déployée.",
        'Port': "Port d'écoute du service.",
        'Groupe Ansible': "Groupe/rôle Set-OPS appliqué. Ex. serveur_postgresql.",
        'Groupe (rôle)': "Rôle Set-OPS appliqué à l'application.",
        'Identifiant': "Clé courte et unique, sans espace.",
        'Portée': "À qui la base est offerte : groupe, hôte ou application.",
        'Consommateur': "L'entité (groupe / hôte / application) qui utilise la base.",
        'Usage': "Étiquette libre. Ex. principale.",
        'Serveur': "Serveur de base de données qui héberge cette base.",
        'Base': "Nom de la base de données.",
        'Propriétaire': "Rôle SQL propriétaire de la base.",
        'Secret (Vault)': "Nom de la variable Ansible Vault contenant le mot de passe.",
        'Requiert (applis)': "Applications prérequises, séparées par des virgules.",
        'Expose (FQDN)': "Nom(s) public(s) exposé(s). Ex. forge.exemple.ca.",
        'Serveur (fonction-NN)': "Nom = fonction + rang. Ex. web-frontal-03.",
      };
      const bulle = document.createElement('div');
      bulle.id = 'infobulle';
      bulle.setAttribute('role', 'tooltip');
      document.body.appendChild(bulle);

      function libelleDe(el) {
        const n = el.firstChild;
        return ((n && n.nodeType === 3 ? n.textContent : el.textContent) || '').trim();
      }
      function aideDe(el) {
        if (!el || !el.matches || !el.matches('.champ > span')) return null;
        return AIDES[libelleDe(el)] || null;
      }
      function placer(el) {
        const r = el.getBoundingClientRect();
        bulle.style.left = Math.max(8, Math.min(r.left, innerWidth - bulle.offsetWidth - 8)) + 'px';
        let haut = r.top - bulle.offsetHeight - 8;
        if (haut < 8) haut = r.bottom + 8;           // bascule sous le champ si pas la place
        bulle.style.top = haut + 'px';
      }
      document.addEventListener('mouseover', e => {
        const aide = aideDe(e.target);
        if (!aide) return;
        bulle.textContent = aide;
        bulle.classList.add('on');
        placer(e.target);
      });
      document.addEventListener('mouseout', e => {
        if (e.target && e.target.matches && e.target.matches('.champ > span')) bulle.classList.remove('on');
      });

      // Affordance : souligné pointillé sur les descriptions qui ont une aide.
      function marquer(racine) {
        if (!racine.querySelectorAll) return;
        racine.querySelectorAll('.champ > span').forEach(s => {
          if (AIDES[libelleDe(s)]) s.classList.add('a-aide');
        });
      }
      new MutationObserver(muts => muts.forEach(m =>
        m.addedNodes.forEach(n => { if (n.nodeType === 1) marquer(n); })
      )).observe(document.body, { childList: true, subtree: true });
      marquer(document);
    })();

    charger().catch(err => message(err.message, 'erreur'));
  </script>
</body>
</html>
"""


def basculer_instance(nom: str) -> str:
    """Repointe le symlink `instance/` vers un depot frere. Renvoie la nouvelle cible.

    Memes garde-fous que `make instance-utiliser`, plus une validation STRICTE : `nom`
    doit etre une instance DECOUVERTE (dossier frere avec plan/nomenclature.yml), ce
    qui interdit toute traversee de chemin (pas de '/', '..', cible arbitraire).
    """
    import instances as _inst
    connues = {i["nom"] for i in _inst.decouvrir()}
    if nom not in connues:
        raise ValueError(f"Instance inconnue : {nom!r} (attendu : {', '.join(sorted(connues)) or 'aucune'}).")
    cible = RACINE.parent / nom
    if not cible.is_dir():
        raise ValueError(f"Dossier introuvable : ../{nom}")
    lien = RACINE / "instance"
    if lien.exists() and not lien.is_symlink():
        raise ValueError("'instance' existe et n'est pas un symlink — refus.")
    if lien.is_symlink() or lien.exists():
        lien.unlink()
    lien.symlink_to(f"../{nom}")
    return os.readlink(lien)


class Gestionnaire(BaseHTTPRequestHandler):
    # Inventaire de l'instance ACTIVE, resolu DYNAMIQUEMENT depuis le symlink
    # `instance/` a chaque acces : ainsi la bascule d'instance (POST
    # /api/instance-utiliser) prend effet sans redemarrer le serveur. Les chemins
    # de plan (FICHIER_*) sont deja relatifs au symlink et suivent de meme.
    # SETOPS_INVENTAIRE force un inventaire fixe (CI / usage explicite).
    @property
    def inventaire(self) -> Path:
        force = os.environ.get("SETOPS_INVENTAIRE")
        return Path(force) if force else _inventaire(INSTANCE, "principal", "production")

    def log_message(self, *args) -> None:  # silence par defaut
        pass

    def repondre(self, status: int, contenu: bytes, content_type: str) -> None:
        try:
            self.send_response(status)
            self.send_header("Content-Type", content_type)
            self.send_header("Content-Length", str(len(contenu)))
            self.end_headers()
            self.wfile.write(contenu)
        except (BrokenPipeError, ConnectionResetError):
            pass  # le client a ferme la connexion : rien a faire

    def repondre_json(self, status: int, data: dict) -> None:
        self.repondre(status, json.dumps(data, ensure_ascii=False).encode("utf-8"), "application/json; charset=utf-8")

    def _ecrire_flux(self, texte: str) -> bool:
        try:
            self.wfile.write(texte.encode("utf-8", "replace"))
            self.wfile.flush()
            return True
        except (BrokenPipeError, ConnectionResetError):
            return False

    def executer_flux(self, hote: str, mode: str, vault: str | None = None) -> None:
        if not MOTIF_HOTE.match(hote or ""):
            self.repondre_json(400, {"erreur": "Nom d'hote invalide."})
            return
        tous_hotes = {h.get("nom") for h in liste_hotes(charger_yaml(self.inventaire))}
        if hote not in tous_hotes:
            self.repondre_json(409, {"erreur": f"{hote} est inconnu de l'inventaire (applique le plan d'abord)."})
            return
        # 'creer' (clone) est permis meme sur un hote planifie ; les autres exigent actif.
        if mode in ("verifier", "deployer", "pousser") and hote not in hotes_actifs_fichier(self.inventaire):
            self.repondre_json(409, {"erreur": f"{hote} n'est pas un hote actif sauvegarde."})
            return
        if mode == "deployer" and not VERIF_OK.get(hote):
            self.repondre_json(409, {"erreur": "Verification (dry-run) requise avant de deployer."})
            return
        if not VERROU.acquire(blocking=False):
            self.repondre_json(409, {"erreur": "Une execution est deja en cours."})
            return
        fichier_vault = None
        journal = None
        try:
            cible = {"deployer": "deployer", "pousser": "deployer",
                     "creer": "creer-vm"}.get(mode, "verifier-deploiement")
            env = dict(os.environ, PYTHONUNBUFFERED="1", ANSIBLE_FORCE_COLOR="0")
            if vault:
                # LE MOT DE PASSE SAISI S'AJOUTE AUX CLES, IL NE LES REMPLACE PAS.
                #
                # Verifie empiriquement le 2026-09-08, contre deux voutes jetables a mots
                # de passe distincts : `ANSIBLE_VAULT_PASSWORD_FILE` et
                # `ANSIBLE_VAULT_IDENTITY_LIST` se CUMULENT — Ansible essaie tous les
                # secrets, et un PASSWORD_FILE errone n'empeche rien.
                #
                # Ca compte depuis « une voute, une cle » (2026-08-28) : creer une VM
                # ouvre DEUX voutes dans la meme execution — celle du tenant et
                # `underlay.vault.yml`. Un seul mot de passe ne pourrait pas les ouvrir
                # toutes les deux. Ce qui sauve ce chemin, c'est que `make` calcule
                # `ANSIBLE_VAULT_IDENTITY_LIST` par-dessus (Makefile, `?=`), et que les
                # deux coexistent dans l'environnement de la recette.
                #
                # NE PAS « SIMPLIFIER » EN RETIRANT L'UN DES DEUX. Le PASSWORD_FILE sert
                # le cas ou la cle n'est pas sur la machine (un runner qui n'a que la
                # sienne) ; l'IDENTITY_LIST sert le poste de l'exploitant, qui les a
                # toutes. Chacun couvre ce que l'autre ne couvre pas.
                fd, fichier_vault = tempfile.mkstemp(prefix="setops-vault-")  # 0600 par defaut
                os.write(fd, str(vault).encode("utf-8"))
                os.close(fd)
                env["ANSIBLE_VAULT_PASSWORD_FILE"] = fichier_vault
            self.send_response(200)
            self.send_header("Content-Type", "text/plain; charset=utf-8")
            self.send_header("Cache-Control", "no-cache")
            self.end_headers()
            # Persistance : un journal horodaté par exécution, en plus du streaming live.
            dossier_logs = self.inventaire.parents[2] / "logs"
            dossier_logs.mkdir(parents=True, exist_ok=True)
            chemin_log = dossier_logs / f"{hote}-{cible}-{time.strftime('%Y%m%dT%H%M%S')}.log"
            journal = open(chemin_log, "w", encoding="utf-8")
            entete = f"$ make {cible} HOTE={hote}\n\n"
            journal.write(entete)
            self._ecrire_flux(entete)
            tache_courante = ""
            echecs: list[dict] = []
            proc = subprocess.Popen(
                ["make", cible, f"HOTE={hote}"],
                cwd=str(RACINE), env=env,
                stdin=subprocess.DEVNULL,
                stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1,
            )
            try:
                for ligne in proc.stdout:
                    journal.write(ligne)
                    if ligne.startswith("TASK ["):
                        deb, fin = ligne.find("["), ligne.find("]")
                        if -1 < deb < fin:
                            tache_courante = ligne[deb + 1:fin]
                    elif ("FAILED!" in ligne or "UNREACHABLE!" in ligne) and \
                            ("fatal:" in ligne or ligne.lstrip().startswith("failed:")):
                        echec = _extraire_echec(ligne, tache_courante)
                        if echec:
                            echecs.append(echec)
                    if not self._ecrire_flux(ligne):
                        # Navigateur déconnecté : on continue à journaliser jusqu'au bout.
                        for reste in proc.stdout:
                            journal.write(reste)
                        break
            finally:
                rc = proc.wait()
            if mode == "verifier" and rc == 0:
                VERIF_OK[hote] = True
            elif mode in ("deployer", "pousser"):
                VERIF_OK.pop(hote, None)
            # Auto-actif : un hote qu'on vient de materialiser (clone reussi) ou de
            # deployer passe 'actif' dans le plan. Reflet fidele : materialise = actif.
            if rc == 0 and mode in ("creer", "deployer", "pousser"):
                try:
                    marquer_serveur_actif(hote)
                except Exception:
                    pass
            if rc != 0 and echecs:
                self._ecrire_flux("__RESUME__ " + json.dumps({"echecs": echecs[:6]}, ensure_ascii=False) + "\n")
            journal.write(f"\n__FIN__ rc={rc}\n")
            self._ecrire_flux(f"\n[journal : {os.path.relpath(chemin_log, RACINE)}]\n__FIN__ rc={rc}\n")
        finally:
            if journal:
                try:
                    journal.close()
                except OSError:
                    pass
            if fichier_vault:
                try:
                    os.remove(fichier_vault)
                except OSError:
                    pass
            VERROU.release()

    def executer_runbook(self, runbook: str, cible: str, valeurs: dict,
                         vault: str | None = None, index: int | None = None) -> None:
        """Une etape DECLAREE d'un runbook — et rien d'autre.

        LE NAVIGATEUR NE NOMME PAS UNE COMMANDE, IL NOMME UNE PLACE. On ne lance pas
        « la cible que la page demande » : on lance ce que le registre declare a cette
        place-la, avec les seules variables qu'il declare. Une page compromise, ou
        simplement perimee, ne peut donc pas reclamer `raser` depuis un runbook de mesure.

        C'est la meme discipline que `POUVOIR_REQUIS` : ce qui protege n'est pas un bouton
        grise, c'est un serveur qui refuse — et qui DIT pourquoi.
        """
        try:
            import runbooks as _rb
            etape = _rb.etape_declaree(runbook, cible, RACINE, index)
        except Exception as exc:                                        # noqa: BLE001
            self.repondre_json(500, {"erreur": f"Registre des runbooks illisible : {exc}"})
            return
        if etape is None:
            self.repondre_json(409, {"erreur": f"« {cible} » n'est pas une etape declaree "
                                     f"du runbook « {runbook} ». Rien n'a ete lance."})
            return

        # Les variables : celles du registre, dans l'ordre du registre.
        args: list[str] = []
        for v in etape["variables"]:
            brut = str(valeurs.get(v["nom"], "")).strip()
            if not brut:
                if v.get("facultatif"):
                    continue
                self.repondre_json(400, {"erreur": f"{v['nom']} est requis pour cette etape."})
                return
            if not MOTIF_VALEUR.match(brut):
                self.repondre_json(400, {"erreur": f"{v['nom']} : valeur refusee (caracteres "
                                         f"interdits, ou commence par un tiret)."})
                return
            if v.get("valeurs") and brut not in v["valeurs"]:
                self.repondre_json(400, {"erreur": f"{v['nom']} : « {brut} » n'est pas une "
                                         f"valeur admise ({', '.join(v['valeurs'])})."})
                return
            args.append(f"{v['nom']}={brut}")
        # Les valeurs IMPOSEES par l'etape (CONFIRMER=true et compagnie) ne viennent
        # jamais du navigateur : une confirmation qu'on peut envoyer soi-meme n'en est pas
        # une. Le garde-fou reel est la confirmation ECRITE exigee cote page, plus la
        # garde propre a la cible.
        for clef, val in (etape["fixes"] or {}).items():
            args.append(f"{clef}={val}")

        if not VERROU.acquire(blocking=False):
            self.repondre_json(409, {"erreur": "Une execution est deja en cours."})
            return
        fichier_vault = None
        journal = None
        try:
            env = dict(os.environ, PYTHONUNBUFFERED="1", ANSIBLE_FORCE_COLOR="0")
            if vault:
                fd, fichier_vault = tempfile.mkstemp(prefix="setops-vault-")
                os.write(fd, str(vault).encode("utf-8"))
                os.close(fd)
                env["ANSIBLE_VAULT_PASSWORD_FILE"] = fichier_vault
            self.send_response(200)
            self.send_header("Content-Type", "text/plain; charset=utf-8")
            self.send_header("Cache-Control", "no-cache")
            self.end_headers()
            # Un journal par execution. Chez un locataire il vit dans l'instance ; sur un
            # runner de site il n'y a pas d'instance, et `tmp/` est deja hors depot.
            dossier_logs = (INSTANCE / "logs") if INSTANCE.exists() else (RACINE / "tmp" / "logs")
            dossier_logs.mkdir(parents=True, exist_ok=True)
            chemin_log = dossier_logs / f"{runbook}-{cible}-{time.strftime('%Y%m%dT%H%M%S')}.log"
            journal = open(chemin_log, "w", encoding="utf-8")
            entete = f"$ make {cible} {' '.join(args)}\n\n"
            journal.write(entete)
            self._ecrire_flux(entete)
            tache_courante = ""
            echecs: list[dict] = []
            proc = subprocess.Popen(
                ["make", cible, *args],
                cwd=str(RACINE), env=env,
                stdin=subprocess.DEVNULL,
                stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1,
            )
            try:
                for ligne in proc.stdout:
                    journal.write(ligne)
                    if ligne.startswith("TASK ["):
                        deb, fin = ligne.find("["), ligne.find("]")
                        if -1 < deb < fin:
                            tache_courante = ligne[deb + 1:fin]
                    elif ("FAILED!" in ligne or "UNREACHABLE!" in ligne) and \
                            ("fatal:" in ligne or ligne.lstrip().startswith("failed:")):
                        echec = _extraire_echec(ligne, tache_courante)
                        if echec:
                            echecs.append(echec)
                    if not self._ecrire_flux(ligne):
                        for reste in proc.stdout:
                            journal.write(reste)
                        break
            finally:
                rc = proc.wait()
            if rc != 0 and echecs:
                self._ecrire_flux("__RESUME__ " + json.dumps({"echecs": echecs[:6]},
                                                             ensure_ascii=False) + "\n")
            journal.write(f"\n__FIN__ rc={rc}\n")
            self._ecrire_flux(f"\n[journal : {os.path.relpath(chemin_log, RACINE)}]\n__FIN__ rc={rc}\n")
        finally:
            if journal:
                try:
                    journal.close()
                except OSError:
                    pass
            if fichier_vault:
                try:
                    os.remove(fichier_vault)
                except OSError:
                    pass
            VERROU.release()

    def do_GET(self) -> None:
        chemin = urlparse(self.path).path
        try:
            if chemin == "/":
                page = HTML.replace("__JETON__", JETON)
                self.repondre(200, page.encode("utf-8"), "text/html; charset=utf-8")
            elif chemin == "/favicon.ico":
                self.repondre(204, b"", "image/x-icon")
            elif chemin == "/api/contexte":
                self.repondre_json(200, contexte())
            elif chemin == "/api/inventaire":
                # LE GESTIONNAIRE NE SAIT PLUS LAQUELLE LUI REPOND, et c'est le but : il
                # demandait « est-ce un site ? » pour choisir entre deux assembleurs, et
                # les deux ont derive. Il demande maintenant sa charge a sa console.
                self.repondre_json(200, console(self.inventaire).charge())
            elif chemin == "/api/sondes":
                self.repondre_json(200,
                                   sonder_donnees(console(self.inventaire).inventaire_brut()))
            elif chemin == "/api/devis-reseau":
                tenants = devis_reseau.decouvrir()
                self.repondre_json(200, {
                    "config": devis_reseau.generer(tenants) if tenants else "",
                    "tenants": [{"nom": nom, "index": n["index"]} for nom, _, n in tenants],
                })
            elif chemin == "/api/devis-opnsense":
                # Import paresseux : ce module lit l'underlay et les inventaires de tous
                # les tenants ; une erreur ici ne doit pas empecher le reste du panneau.
                try:
                    import devis_opnsense as _dop
                    tenants = _dop.decouvrir()
                    self.repondre_json(200, {
                        "config": _dop.rendre(_dop.construire(tenants)) if tenants else "",
                    })
                except Exception as exc:
                    self.repondre_json(200, {"config": "", "erreur": str(exc)})
            elif chemin == "/api/runbooks":
                # Import paresseux, comme les devis : un registre casse ne doit pas
                # emporter le reste de la console avec lui.
                try:
                    import runbooks as _rb
                    ctx = contexte()
                    _c = console(self.inventaire)
                    _juger = _c.peut_conduire
                    liste = []
                    for rb in _rb.assembler(RACINE):
                        # CHAQUE ETAPE SE PESE SEULE (2026-09-20, mesure sur TechnoLibre).
                        # Juge au seul runbook, une unique etape qui materialise fermait
                        # toute la sequence a un locataire — qui perdait le droit de
                        # deployer SA flotte. Il la conduit donc, et bute precisement la
                        # ou il faut : sur la machine a engendrer.
                        etapes = []
                        for etape in rb["etapes"]:
                            ok, pourquoi = _juger(etape["portee"])
                            etapes.append({**etape, "conduisible": ok, "raison": pourquoi})
                        ok_rb, pourquoi_rb = _juger(rb["portee"])
                        liste.append({
                            **rb,
                            "etapes": etapes,
                            # ON NE CACHE PAS CE QU'ON NE PEUT PAS FAIRE. Un runbook hors
                            # de portee reste VISIBLE et se lit : savoir que le geste
                            # existe, et chez qui il se fait, fait partie du metier.
                            "conduisible": any(e["conduisible"] for e in etapes),
                            "raison": pourquoi_rb if not ok_rb else "",
                        })
                    self.repondre_json(200, {"runbooks": liste, "contexte": ctx,
                                             "ecarts": _rb.verifier(RACINE)})
                except Exception as exc:                                # noqa: BLE001
                    self.repondre_json(200, {"runbooks": [], "erreur": str(exc)})
            elif chemin == "/api/instances":
                import instances as _inst
                import instance_creer as _ic
                liste = _inst.decouvrir()
                self.repondre_json(200, {
                    "instances": liste,
                    "collisions": {str(k): v for k, v in _inst.collisions(liste).items()},
                    "modeles": sorted(_ic.modeles_disponibles()),
                    "index_pris": sorted(_ic.index_federes_utilises()),
                })
            else:
                self.repondre_json(404, {"erreur": "Introuvable"})
        except Exception as exc:
            self.repondre_json(500, {"erreur": str(exc)})

    def do_POST(self) -> None:
        chemin = urlparse(self.path).path
        if self.headers.get("X-Jeton") != JETON:
            self.repondre_json(403, {"erreur": "Jeton manquant ou invalide."})
            return
        longueur = int(self.headers.get("Content-Length", "0") or 0)
        corps = self.rfile.read(longueur).decode("utf-8") if longueur else ""
        try:
            donnees = json.loads(corps) if corps else {}
        except json.JSONDecodeError:
            self.repondre_json(400, {"erreur": "Corps JSON invalide."})
            return
        # LA GARDE EST ICI, PAS DANS LE NAVIGATEUR. Un bouton grise est une politesse ;
        # ce qui protege, c'est un serveur qui refuse. Et il DIT pourquoi : « interdit »
        # sans raison envoie chercher une panne la ou il n'y en a pas.
        ctx = contexte()
        besoin = POUVOIR_REQUIS.get(chemin)
        if besoin == "selon-le-runbook":
            # LA PORTEE VIENT DU REGISTRE, PAS DU CORPS DE LA REQUETE. Le navigateur nomme
            # un runbook ; c'est le fichier declare qui dit ce que ce runbook exige.
            besoin = None
            try:
                import runbooks as _rb
                vise = str(donnees.get("runbook", ""))
                _i = donnees.get("index")
                _etape = _rb.etape_declaree(vise, str(donnees.get("cible", "")), RACINE,
                                            _i if isinstance(_i, int) else None)
                # La portee de L'ETAPE. Celle du runbook n'est que son defaut, et juger
                # sur elle fermerait a un locataire une sequence qui est la sienne.
                portee_etape = _etape["portee"] if _etape else None
                connu = any(r["id"] == vise for r in _rb.assembler(RACINE))
            except Exception:                                           # noqa: BLE001
                portee_etape, connu = None, False
            if not connu:
                self.repondre_json(409, {"erreur": f"Runbook inconnu : « {donnees.get('runbook', '')} »."})
                return
            # Etape introuvable a cette place : `executer_runbook` le dira mieux que nous,
            # avec le nom et la place. On le laisse refuser, sans rien lancer.
            if portee_etape is not None:
                ok_etape, pourquoi = console(self.inventaire).peut_conduire(portee_etape)
                if not ok_etape:
                    self.repondre_json(409, {"erreur": pourquoi, "portee": ctx["portee"]})
                    return
        if besoin and not ctx["peut"].get(besoin):
            self.repondre_json(409, {"erreur": ctx["raison"].get(besoin, "Geste hors de "
                                                                "la portee de cette console."),
                                     "portee": ctx["portee"], "pouvoir": besoin})
            return
        try:
            if chemin == "/api/inventaire":
                self.repondre_json(409, {"erreur": "hosts.yml est genere depuis le plan. "
                                         "Edite instance/plan/serveurs.yml et instance/plan/applications.yml "
                                         "(vues Serveurs / Applications), puis « Appliquer le plan »."})
            elif chemin == "/api/bases":
                valider_bases(donnees, charger_applications(FICHIER_APPLICATIONS))
                ecrire_bases(FICHIER_BASES, donnees)
                self.repondre_json(200, inventaire_api(self.inventaire))
            elif chemin == "/api/applications":
                valider_applications(donnees, charger_domaines(FICHIER_DOMAINES),
                                     charger_serveurs(FICHIER_SERVEURS))
                ecrire_applications(FICHIER_APPLICATIONS, donnees)
                self.repondre_json(200, inventaire_api(self.inventaire))
            elif chemin == "/api/serveurs":
                valider_serveurs(donnees, charger_nomenclature(FICHIER_NOMENCLATURE))
                ecrire_serveurs(FICHIER_SERVEURS, donnees)
                self.repondre_json(200, inventaire_api(self.inventaire))
            elif chemin == "/api/nomenclature":
                valider_nomenclature(donnees, charger_serveurs(FICHIER_SERVEURS))
                ecrire_nomenclature(FICHIER_NOMENCLATURE, donnees)
                self.repondre_json(200, inventaire_api(self.inventaire))
            elif chemin == "/api/domaines":
                valider_domaines(donnees)
                ecrire_domaines(FICHIER_DOMAINES, donnees)
                self.repondre_json(200, inventaire_api(self.inventaire))
            elif chemin == "/api/intrants":
                ecrire_intrants(donnees)
                self.repondre_json(200, inventaire_api(self.inventaire))
            elif chemin == "/api/instance-utiliser":
                cible = basculer_instance(str(donnees.get("nom", "")).strip())
                self.repondre_json(200, {"ok": True, "cible": cible})
            elif chemin == "/api/instance-creer":
                import instance_creer as _ic
                brut_idx = str(donnees.get("index", "")).strip()
                _ic.creer(str(donnees.get("nom", "")).strip(),
                          str(donnees.get("modele", "")).strip(),
                          int(brut_idx) if brut_idx else None)
                self.repondre_json(200, {"ok": True, "nom": str(donnees.get("nom", "")).strip()})
            elif chemin == "/api/instancier":
                # Cliquer « Appliquer le plan » EST l'intention explicite : on force
                # (le diff-refus est un garde-fou CLI ; ici le clic le confirme). git = filet.
                resultat = subprocess.run(
                    ["python3", str(RACINE / "scripts/instancier.py"), "appliquer", "--force"],
                    capture_output=True, text=True, cwd=str(RACINE))
                self.repondre_json(200, {"ok": resultat.returncode == 0,
                                         "sortie": (resultat.stdout + resultat.stderr).strip()})
            elif chemin == "/api/verifier":
                self.executer_flux(str(donnees.get("hote", "")), "verifier", donnees.get("vault"))
            elif chemin == "/api/deployer":
                self.executer_flux(str(donnees.get("hote", "")), "deployer", donnees.get("vault"))
            elif chemin == "/api/creer":
                self.executer_flux(str(donnees.get("hote", "")), "creer", donnees.get("vault"))
            elif chemin == "/api/runbook-etape":
                _idx = donnees.get("index")
                self.executer_runbook(str(donnees.get("runbook", "")),
                                      str(donnees.get("cible", "")),
                                      donnees.get("valeurs") or {},
                                      donnees.get("vault"),
                                      int(_idx) if isinstance(_idx, int) else None)
            elif chemin == "/api/pousser":
                self.executer_flux(str(donnees.get("hote", "")), "pousser", donnees.get("vault"))
            else:
                self.repondre_json(404, {"erreur": "Introuvable"})
        except Exception as exc:
            self.repondre_json(400, {"erreur": str(exc)})


def main() -> int:
    parser = argparse.ArgumentParser(description="Interface web locale pour gerer un inventaire Set-OPS.")
    parser.add_argument("--inventaire", type=Path, default=INVENTAIRE_DEFAUT)
    parser.add_argument("--hote", default="127.0.0.1")
    parser.add_argument("--port", type=int, default=8765)
    args = parser.parse_args()

    serveur = ThreadingHTTPServer((args.hote, args.port), Gestionnaire)
    print(f"Interface inventaire: http://{args.hote}:{args.port}/")
    print(f"Inventaire: {Gestionnaire.inventaire}")
    serveur.serve_forever()
    return 0


if __name__ == "__main__":
    raise SystemExit(main())