// © 2026 TechnoLibre (http://www.technolibre.ca)
// License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)

// Le registre des commandes, éprouvé en entier (§ 2.1, § 8.2, § 8.3, § 8.4,
// § 9, § 5.8, § 17 point 3, § 14.12, § 14.15) : chaque commande de COMMANDES
// passe par la séance, sur le système de fichiers d'épreuve et l'horloge
// pilotée, et l'épreuve relève ce qui s'écrit.
//
// La table EXEMPLES donne, par commande, un exemple accepté, un exemple
// refusé — un refus du domaine — et un exemple sans effet ; une commande qui
// n'a pas l'un d'eux y nomme sa raison. Un exemple porte ses arguments, ou la
// fonction qui les tire de la charge où il s'exécute, et les gestes qui le
// préparent (avant), exécutés d'abord, chacun une entrée. REMEDE_NUL_ADMIS
// nomme les refus dont le remède est nul, avec la raison : la valeur se
// corrige dans le champ même, ou aucun geste ne lève le refus.
//
// Deux événements servent de départ, construits une fois par la façade et la
// séance, puis copiés fichier pour fichier dans un système neuf pour chaque
// épreuve : un événement vide, créé, et la charge témoin — la petite
// démonstration chargée, « Modifier », une désignation, deux propositions
// générées sur l'exécuteur direct, la seconde retenue. Ni l'un ni l'autre
// n'est un fichier d'épreuve : la démonstration porte des noms du réservoir
// du générateur, et une copie dériverait d'elle.
//
// La trace des écritures enveloppe ajouterLigne et ecrireAtomique du système
// d'épreuve : une ligne d'entrée du journal, ou le journal réécrit entier,
// compte pour l'entrée ; une ligne de jalon ne compte pas. Défaire rend la
// charge d'avant, ses compteurs d'identifiants exceptés : la séance les porte
// au plus grand de leur valeur restituée et de leur valeur courante (§ 8.9),
// et l'épreuve compare la charge d'avant sous les compteurs rendus. Les noms
// d'épreuve sont inventés ; la version vient du module engendré.
import assert from 'node:assert/strict';
import { creerFichiersSimules } from '../../test/fichiers_simules.js';
import { describe, test } from '../../test/lanceur.js';
import { apercevoir } from '../csv/apercu.js';
import { CATALOGUE } from '../demo/catalogue.js';
import { LIVREES } from '../demo/livrees.js';
import { normaliser } from '../moteur/configuration.js';
import { rechercher } from '../moteur/recherche.js';
import { verifierInvariants } from '../moteur/verification.js';
import { serialiserCharge } from '../stockage/canonique.js';
import { creer as creerDansLeDepot } from '../stockage/depot.js';
import { analyser, configurationDepuisCharge } from '../stockage/document.js';
import { lireJournal, reconstruire } from '../stockage/journal.js';
import { SUFFIXES } from '../stockage/noms.js';
import { planDepuisFichier } from '../stockage/placements.js';
import { VERSION } from '../version.genere.js';
import { COMMANDES } from './commandes.js';
import { creerFacade } from './evenements.js';
import { creerControleurGeneration, creerExecuteurDirect } from './generation.js';
import { creerHorlogePilotee } from './horloge.js';
import { libelle } from './libelles.js';
import { nomAffiche } from './personnes.js';
import { creerSeance } from './seance.js';

const V = VERSION.affichee;
const DEPART = '2031-03-14T18:00:00-04:00';
const NOM_VIDE = 'Soirée des Hérons';
const TITRE = 'Animation des Hérons';
const AUTRE_TITRE = 'Accueil des Hérons';

const DEMONSTRATIONS = LIVREES.map(({ cle, texte }) => ({
  cle,
  nom: CATALOGUE.find((entree) => entree.cle === cle).nom,
  texte,
}));

// --- Lectures de la charge ---------------------------------------------------

const participantDe = (charge, id) => charge.participants.find((personne) => personne.id === id);
const tableDe = (charge, id) => charge.tables.find((table) => table.id === id);
const derniereTable = (charge) => Math.max(...charge.tables.map(({ id }) => id));
const croissant = (a, b) => a - b;

// Les personnes que le retenu assied au tour à la table d'identifiant
// idTable, sans réservation, par identifiant croissant.
function libresA(charge, tour, idTable) {
  const reservees = new Set(charge.reservations.map(({ participant }) => participant));
  const rang = charge.retenu.tables.indexOf(idTable);
  return charge.retenu.placement[tour - 1].sieges[rang].filter((id) => id !== null && !reservees.has(id)).sort(croissant);
}

// Les violations de verifierInvariants du retenu de la charge, la réserve
// admise (§ 12.6) ; [] sur une configuration qui ne se normalise pas.
function violationsDuRetenu(charge, { reserveAutorisee = true } = {}) {
  let instance;
  try {
    instance = normaliser(configurationDepuisCharge(charge));
  } catch {
    return [];
  }
  return verifierInvariants(instance, planDepuisFichier(charge.retenu), { reserveAutorisee });
}

// Les violations de apres que avant ne porte pas, comparées champ pour champ.
function violationsNouvelles(avant, apres) {
  const connues = new Set(violationsDuRetenu(avant).map((violation) => JSON.stringify(violation)));
  return violationsDuRetenu(apres).filter((violation) => !connues.has(JSON.stringify(violation)));
}

// --- La table des exemples ---------------------------------------------------

// Les refus admis à remède null, et pourquoi.
const REMEDE_NUL_ADMIS = new Map([
  ['MOINS_DE_DEUX', 'la valeur se corrige dans le champ même, dont le texte dit la valeur attendue'],
  ['NON_ENTIER', 'la valeur se corrige dans le champ même, dont le texte dit la valeur attendue'],
  ['MOINS_D_UN_TOUR', 'la valeur se corrige dans le champ même, dont le texte dit la valeur attendue'],
  ['LIBELLE_VIDE', 'la valeur se corrige dans le champ même, dont le texte dit la valeur attendue'],
  ['NOM_REQUIS', 'le nom se saisit dans le champ même'],
  ['PARTICIPANT_INCONNU', "une personne retirée entre-temps : aucun geste ne la rend"],
  ['PROPOSITION_INCONNUE', "une proposition effacée entre-temps : aucun geste ne la rend"],
  ['COMPTEUR_SATURE', "un compteur au bout de sa règle : aucun geste ne le fait reculer"],
  ['PLAN_NON_BLOQUE', 'il ne reste rien à débloquer'],
  ['NOM_NON_ASSOCIE', "un refus du CSV relayé par importerParticipants : il se lève dans le fichier ou l'association des colonnes"],
  ['RESERVATION_ABSENTE', "la réservation visée est absente, aucune commande ne la produit, et l'interface n'offre le retrait que sur une réservation présente"],
  ['TITRE_ABSENT', "le titre visé est absent, aucune commande ne le produit, et l'interface n'offre le retrait que sur un titre présent"],
  ['CONVERSION_IMPOSSIBLE', "les réservations « tour » visées sont absentes, aucune commande ne les produit, et l'interface n'offre la conversion que sur des réservations présentes"],
]);

// Le geste qui pose deux places de plus à la table 2, par son champ.
const QUATRE_PLACES_A_LA_TABLE_2 = ['changerPlacesTable', { id: 2, sieges: '4', origine: 'champ' }];

// La personne libre de la table 2 au tour 1, retirée dans la réserve du tour.
const RETIRER_UN_LIBRE_DE_LA_TABLE = (idTable) => [
  'retirerDuTour',
  (charge) => ({ tour: 1, participant: libresA(charge, 1, idTable)[0] }),
];

/**
 * Par commande : accepte, refuse, sansEffet, chacun { args, avant?, sur? }
 * — args, un objet ou une fonction de la charge où l'exemple s'exécute ;
 * avant, des gestes [nom, args] qui le préparent ; sur, 'vide' pour partir
 * de l'événement vide plutôt que de la charge témoin —, ou une chaîne, la
 * raison de son absence. refuse porte code, le refus attendu, et remede,
 * le remède attendu, quand l'exemple le fixe. personne, une
 * fonction des arguments de l'exemple accepté : l'identifiant de la personne
 * que son libellé nomme.
 */
const EXEMPLES = new Map([
  [
    'ajouterParticipant',
    {
      accepte: { args: { champs: { nom: 'Ombrelle', prenom: 'Iris' } } },
      refuse: { args: { champs: { nom: '   ' } }, code: 'NOM_REQUIS' },
      sansEffet: 'ajouter crée toujours une personne, sous un identifiant neuf',
    },
  ],
  [
    'modifierParticipant',
    {
      accepte: { args: { id: 2, champs: { notes: 'Arrive au deuxième tour' } } },
      personne: () => 2,
      refuse: { args: { id: 2, champs: { nom: '' } }, code: 'NOM_REQUIS' },
      sansEffet: { args: (charge) => ({ id: 2, champs: { nom: participantDe(charge, 2).nom } }) },
    },
  ],
  [
    'exclureParticipant',
    {
      accepte: { args: { id: 2 } },
      personne: () => 2,
      refuse: { args: { id: 999 }, code: 'PARTICIPANT_INCONNU' },
      sansEffet: { avant: [['exclureParticipant', { id: 2 }]], args: { id: 2 } },
    },
  ],
  [
    'reintegrerParticipant',
    {
      accepte: { avant: [['exclureParticipant', { id: 2 }]], args: { id: 2 } },
      personne: () => 2,
      refuse: {
        avant: [
          ['exclureParticipant', { id: 1 }],
          ['reserver', { participant: 3, table: 1, siege: 1, portee: 'tous', tour: null }],
        ],
        args: { id: 1 },
        code: 'PLACE_RESERVEE',
      },
      sansEffet: { args: { id: 2 } },
    },
  ],
  [
    'supprimerParticipant',
    {
      accepte: { args: { id: 2 } },
      personne: () => 2,
      refuse: { args: { id: 999 }, code: 'PARTICIPANT_INCONNU' },
      sansEffet: 'supprimer retire toujours une personne ; une personne absente est PARTICIPANT_INCONNU',
    },
  ],
  [
    'importerParticipants',
    {
      accepte: {
        args: (charge) => ({
          apercu: apercevoir('nom;prenom\nPervenche;Théo\n', { participants: charge.participants }),
          mode: 'ajouter',
        }),
      },
      refuse: {
        args: (charge) => ({
          apercu: apercevoir('prenom;courriel\nIris;iris@exemple.test\n', { participants: charge.participants }),
          mode: 'ajouter',
        }),
        code: 'NOM_NON_ASSOCIE',
      },
      sansEffet: {
        args: (charge) => {
          const { nom, prenom } = participantDe(charge, 2);
          const texte = `nom;prenom\n${nom};${prenom ?? ''}\n`;
          return { apercu: apercevoir(texte, { participants: charge.participants, mode: 'mettreAJour' }), mode: 'mettreAJour' };
        },
      },
    },
  ],
  [
    'changerEtat',
    {
      accepte: { args: { etat: 'propose' } },
      refuse: { sur: 'vide', args: { etat: 'propose' }, code: 'AUCUNE_PROPOSITION' },
      sansEffet: { args: { etat: 'retenu' } },
    },
  ],
  [
    'debloquer',
    {
      accepte: 'debloquer passe par seance.debloquer() sur un plan bloqué, éprouvé à part',
      refuse: { args: {}, code: 'PLAN_NON_BLOQUE' },
      sansEffet: "débloquer un plan qui n'est pas bloqué est son refus, PLAN_NON_BLOQUE",
    },
  ],
  [
    'enregistrerGeneration',
    {
      accepte: {
        args: (charge) => {
          const configuration = configurationDepuisCharge(charge);
          const { historique } = charge.reglages.generation;
          const propositions = rechercher(configuration, { graine: 7, nombre: 1, arret: 200, historique });
          return { propositions, configuration, produitVersion: V };
        },
      },
      refuse:
        "ses refus d'avant lancement appartiennent au contrôleur de génération ; la commande ne refuse que " +
        "COMPTEUR_SATURE, un compteur au bout de sa règle, qu'aucune charge témoin n'atteint",
      sansEffet: { args: (charge) => ({ propositions: [], configuration: configurationDepuisCharge(charge), produitVersion: V }) },
    },
  ],
  [
    'retenirProposition',
    {
      accepte: { args: { id: 1 } },
      refuse: { args: { id: 99 }, code: 'PROPOSITION_INCONNUE' },
      sansEffet: { args: { id: 2 } },
    },
  ],
  [
    'effacerPropositions',
    {
      accepte: { args: {} },
      refuse: "effacer ne refuse rien du domaine : une liste réduite à la proposition du retenu est sans effet",
      sansEffet: { avant: [['effacerPropositions', {}]], args: {} },
    },
  ],
  [
    'creerTable',
    {
      accepte: { args: { forme: 'carree' } },
      refuse: "créer une table ne refuse que COMPTEUR_SATURE, un compteur au bout de sa règle, qu'aucune charge témoin n'atteint",
      sansEffet: 'créer ajoute toujours une table, sous un identifiant neuf',
    },
  ],
  [
    'supprimerTable',
    {
      accepte: { args: { id: 4 } },
      refuse: "supprimer une table ne refuse rien du domaine ; une table inconnue est une faute de l'appelant (TypeError)",
      sansEffet: 'supprimer retire toujours une table',
    },
  ],
  [
    'deplacerTable',
    {
      accepte: { args: { id: 2, position: { x: 420, y: -60 } } },
      refuse: 'une table se pose partout : déplacer ne refuse rien du domaine',
      sansEffet: { args: (charge) => ({ id: 2, position: { ...tableDe(charge, 2).position } }) },
    },
  ],
  [
    'changerPlacesTable',
    {
      accepte: { args: QUATRE_PLACES_A_LA_TABLE_2[1] },
      refuse: { args: { id: 2, sieges: '2', origine: 'poignee' }, code: 'SOUS_OCCUPES' },
      sansEffet: { avant: [QUATRE_PLACES_A_LA_TABLE_2], args: QUATRE_PLACES_A_LA_TABLE_2[1] },
    },
  ],
  [
    'realignerTable',
    {
      accepte: { avant: [QUATRE_PLACES_A_LA_TABLE_2], args: { id: 2 } },
      refuse: {
        avant: [QUATRE_PLACES_A_LA_TABLE_2, ['poserTitre', { table: 2, siege: 4, libelle: AUTRE_TITRE }]],
        args: { id: 2 },
        code: 'SIEGES_RETIRES',
      },
      sansEffet: { args: { id: 2 } },
    },
  ],
  [
    'changerDefaut',
    {
      accepte: { args: { sieges: '4', realigner: false } },
      refuse: {
        avant: [['poserTitre', { table: 2, siege: 3, libelle: AUTRE_TITRE }]],
        args: { sieges: '2', realigner: false },
        code: 'SIEGES_RETIRES',
      },
      sansEffet: { args: { sieges: '3', realigner: false } },
    },
  ],
  [
    'changerTours',
    {
      accepte: { args: { tours: '3' } },
      refuse: { args: { tours: '0' }, code: 'MOINS_D_UN_TOUR' },
      sansEffet: { args: { tours: '4' } },
    },
  ],
  [
    'modifierReglage',
    {
      accepte: { args: { cle: 'nouveauxVoisins', valeur: false } },
      refuse: "une clé ou une valeur hors de leur domaine est une faute du code (TypeError) : l'interface n'offre que les réglages admis",
      sansEffet: { args: { cle: 'attribuerSieges', valeur: false } },
    },
  ],
  [
    'reserver',
    {
      accepte: { args: { participant: 5, table: 2, siege: null, portee: 'tour', tour: 2 } },
      personne: () => 5,
      refuse: { args: { participant: 3, table: 1, siege: 1, portee: 'tous', tour: null }, code: 'PLACE_RESERVEE' },
      sansEffet: { args: { participant: 1, table: 1, siege: 1, portee: 'tous', tour: null } },
    },
  ],
  [
    'retirerReservation',
    {
      accepte: { args: { participant: 1, table: 1, portee: 'tous', tour: null } },
      personne: () => 1,
      refuse: { args: { participant: 2, table: 1, portee: 'tous', tour: null }, code: 'RESERVATION_ABSENTE' },
      sansEffet: 'une réservation absente est RESERVATION_ABSENTE ; retirer en retire toujours une',
    },
  ],
  [
    'deplacerReservation',
    {
      accepte: { args: { participant: 1, de: { table: 1, portee: 'tous', tour: null }, vers: { table: 1, siege: 2 } } },
      personne: () => 1,
      refuse: {
        avant: [['reserver', { participant: 5, table: 2, siege: 2, portee: 'tous', tour: null }]],
        args: { participant: 1, de: { table: 1, portee: 'tous', tour: null }, vers: { table: 2, siege: 2 } },
        code: 'PLACE_RESERVEE',
      },
      sansEffet: { args: { participant: 1, de: { table: 1, portee: 'tous', tour: null }, vers: { table: 1, siege: 1 } } },
    },
  ],
  [
    'poserTitre',
    {
      accepte: { args: { table: 2, siege: null, libelle: AUTRE_TITRE } },
      refuse: { args: { table: 1, siege: 1, libelle: AUTRE_TITRE }, code: 'PLACE_TITREE' },
      sansEffet: 'une place déjà titrée refuse PLACE_TITREE : poser ajoute toujours un titre',
    },
  ],
  [
    'retirerTitre',
    {
      accepte: { args: { table: 1, siege: 1 } },
      refuse: { args: { table: 2, siege: 1 }, code: 'TITRE_ABSENT' },
      sansEffet: 'un titre absent est TITRE_ABSENT ; retirer en retire toujours un',
    },
  ],
  [
    'designer',
    {
      accepte: { args: { participant: 5, table: 2, siege: null, libelle: AUTRE_TITRE } },
      personne: () => 5,
      refuse: { args: { participant: 5, table: 1, siege: 1, libelle: AUTRE_TITRE }, code: 'PLACE_RESERVEE' },
      sansEffet: { args: { participant: 1, table: 1, siege: 1, libelle: TITRE } },
    },
  ],
  [
    'convertirEnTous',
    {
      accepte: {
        avant: [1, 2, 3, 4].map((tour) => ['reserver', { participant: 5, table: 2, siege: null, portee: 'tour', tour }]),
        args: { participant: 5, table: 2 },
      },
      personne: () => 5,
      refuse: { args: { participant: 5, table: 2 }, code: 'CONVERSION_IMPOSSIBLE' },
      sansEffet: 'hors des conversions possibles, CONVERSION_IMPOSSIBLE ; convertir remplace toujours les réservations « tour » par une',
    },
  ],
  [
    'deplacerDansRetenu',
    {
      accepte: {
        avant: [['creerTable', { forme: 'ronde' }]],
        args: (charge) => ({ tour: 1, participant: libresA(charge, 1, 2)[0], table: derniereTable(charge), siege: null }),
      },
      personne: (args) => args.participant,
      refuse: { args: (charge) => ({ tour: 1, participant: libresA(charge, 1, 2)[0], table: 3, siege: null }), code: 'TABLE_PLEINE' },
      sansEffet: { args: (charge) => ({ tour: 1, participant: libresA(charge, 1, 2)[0], table: 2, siege: null }) },
    },
  ],
  [
    'echangerDansRetenu',
    {
      accepte: { args: (charge) => ({ tour: 1, a: libresA(charge, 1, 2)[0], b: libresA(charge, 1, 3)[0] }) },
      personne: (args) => args.a,
      refuse: { args: (charge) => ({ tour: 1, a: 1, b: libresA(charge, 1, 2)[0] }), code: 'RESERVEE_AILLEURS' },
      sansEffet: {
        avant: [RETIRER_UN_LIBRE_DE_LA_TABLE(2), RETIRER_UN_LIBRE_DE_LA_TABLE(3)],
        args: (charge) => {
          const [a, b] = charge.retenu.placement[0].reserve;
          return { tour: 1, a, b };
        },
      },
    },
  ],
  [
    'retirerDuTour',
    {
      accepte: { args: (charge) => ({ tour: 1, participant: libresA(charge, 1, 2)[0] }) },
      personne: (args) => args.participant,
      refuse: {
        args: { tour: 1, participant: 1 },
        code: 'INVARIANT_VIOLE',
        remede: { commande: 'retirerReservation', arguments: { participant: 1, table: 1, portee: 'tous', tour: null } },
      },
      sansEffet: {
        avant: [RETIRER_UN_LIBRE_DE_LA_TABLE(2)],
        args: (charge) => ({ tour: 1, participant: charge.retenu.placement[0].reserve[0] }),
      },
    },
  ],
]);

// Les retouches du retenu, que le vérificateur d'invariants juge (§ 14.12).
const RETOUCHES = ['deplacerDansRetenu', 'echangerDansRetenu', 'retirerDuTour'];

// Les arguments d'un exemple sur la charge où il s'exécute.
const argumentsDe = (args, charge) => (typeof args === 'function' ? args(charge) : structuredClone(args));

// --- Le montage --------------------------------------------------------------

function creerIdentifiants(prefixe) {
  let n = 0;
  return () => {
    n += 1;
    return `${prefixe}-${n}`;
  };
}

// La façade sur un système neuf, branchée sur une séance comme App la
// branche : changerRacine crée la séance sur la racine reçue.
function monterFacade() {
  const fs = creerFichiersSimules();
  const horloge = creerHorlogePilotee({ depart: DEPART });
  const identifiant = creerIdentifiants('montage');
  const monte = { fs, horloge, seance: null, racine: null };
  monte.facade = creerFacade({
    fs,
    horloge,
    identifiant,
    produitVersion: V,
    demonstrations: DEMONSTRATIONS,
    ouvert: () => monte.seance?.ouvert?.base ?? null,
    ouvrir: (base) => monte.seance.ouvrir(base),
    fermer: () => monte.seance.fermer(),
    creer: (champs) => monte.seance.creer(champs),
    racine: () => monte.racine,
    changerRacine: async (nouvelle) => {
      monte.racine = nouvelle;
      monte.seance = creerSeance({
        fs,
        racine: nouvelle,
        horloge,
        identifiant,
        produitVersion: V,
        planifier: horloge.planifier,
        annuler: horloge.annuler,
      });
    },
  });
  return monte;
}

// Les fichiers de l'événement base sur le disque : [chemin, texte].
function fichiersDe(fs, racine, base) {
  return [SUFFIXES.etat, SUFFIXES.precedent, SUFFIXES.journal]
    .map((suffixe) => [base + suffixe, fs.contenu(racine.id, base + suffixe)])
    .filter(([, texte]) => texte !== null);
}

let departs = null;

// Les deux événements de départ, construits au premier appel puis partagés :
// { vide, temoin }, chacun { racine, base, fichiers }.
function departsPrets() {
  departs ??= (async () => {
    const monte = monterFacade();
    const { facade, fs, horloge } = monte;
    await facade.demarrer();
    const { base: baseVide } = await facade.creer({ nom: NOM_VIDE });
    const vide = { racine: monte.racine, base: baseVide, fichiers: fichiersDe(fs, monte.racine, baseVide) };

    const { base } = await facade.chargerDemonstration('petite');
    const { seance } = monte;
    await seance.passerEnEcriture();
    await seance.executer('designer', { participant: 1, table: 1, siege: null, libelle: TITRE });
    const controleur = creerControleurGeneration({ seance, executeur: creerExecuteurDirect(), horloge, produitVersion: V });
    const { historique } = seance.charge.reglages.generation;
    await controleur.generer({ graine: 1, nombre: 2, arret: 2000, historique }, { confirmee: true });
    await seance.executer('retenirProposition', { id: 2 });
    await seance.passerEnLecture();

    const { charge } = seance;
    assert.deepEqual(
      charge.propositions.map(({ id }) => id),
      [1, 2],
    );
    assert.equal(charge.retenu.proposition, 2);
    assert.equal(charge.evenement.etat, 'retenu');
    assert.ok(charge.prochainsIds.proposition > Math.max(...charge.propositions.map(({ id }) => id), charge.retenu.proposition));
    assert.deepEqual(violationsDuRetenu(charge), []);
    const temoin = { racine: monte.racine, base, fichiers: fichiersDe(fs, monte.racine, base) };
    return { vide, temoin };
  })();
  return departs;
}

// Une séance neuve, sur un système neuf qui porte une copie des fichiers du
// départ, l'événement ouvert en lecture ; en écriture sur demande.
async function ouvrirCopie(depart, { ecriture = false } = {}) {
  const fs = creerFichiersSimules();
  for (const [chemin, texte] of depart.fichiers) fs.deposer(depart.racine.id, chemin, texte);
  const horloge = creerHorlogePilotee({ depart: DEPART });
  const seance = creerSeance({
    fs,
    racine: depart.racine,
    horloge,
    identifiant: creerIdentifiants('copie'),
    produitVersion: V,
    planifier: horloge.planifier,
    annuler: horloge.annuler,
  });
  await seance.ouvrir(depart.base);
  if (ecriture) await seance.passerEnEcriture();
  return { fs, seance, racine: depart.racine, base: depart.base };
}

// Le même dossier rouvert par une autre séance, en lecture : l'avertissement
// d'ouverture se calcule sur le fichier écrit, sans l'état de la première.
async function rouvrir({ fs, racine, base }, prefixe) {
  const horloge = creerHorlogePilotee({ depart: DEPART });
  const seance = creerSeance({
    fs,
    racine,
    horloge,
    identifiant: creerIdentifiants(prefixe),
    produitVersion: V,
    planifier: horloge.planifier,
    annuler: horloge.annuler,
  });
  await seance.ouvrir(base);
  return seance;
}

// La même copie, son plan bloqué par changerEtat : la séance revient en
// lecture.
async function ouvrirBloque(depart) {
  const ouvert = await ouvrirCopie(depart, { ecriture: true });
  await ouvert.seance.executer('changerEtat', { etat: 'bloque' });
  assert.equal(ouvert.seance.mode, 'lecture');
  assert.equal(ouvert.seance.charge.evenement.etat, 'bloque');
  return ouvert;
}

// La trace des écritures de l'état et du journal : [primitive, chemin,
// sorte de ligne] ; la sorte, pour une ligne ajoutée au journal.
function tracer(fs) {
  const trace = [];
  const ajouterLigne = fs.ajouterLigne;
  fs.ajouterLigne = (racine, chemin, ligne, ...reste) => {
    trace.push(['ajouterLigne', chemin, JSON.parse(ligne).type]);
    return ajouterLigne(racine, chemin, ligne, ...reste);
  };
  const ecrireAtomique = fs.ecrireAtomique;
  fs.ecrireAtomique = (racine, chemin, ...reste) => {
    trace.push(['ecrireAtomique', chemin, null]);
    return ecrireAtomique(racine, chemin, ...reste);
  };
  return trace;
}

// La trace réduite à ce qui porte l'entrée, le .precedent et l'état, dans
// l'ordre : 'entree' pour une ligne d'entrée ou le journal réécrit entier.
function ordreDesEcritures(trace, base) {
  const sortes = [];
  for (const [primitive, chemin, sorte] of trace) {
    if (chemin === base + SUFFIXES.journal && (primitive === 'ecrireAtomique' || sorte === 'entree')) sortes.push('entree');
    if (chemin === base + SUFFIXES.precedent) sortes.push('precedent');
    if (chemin === base + SUFFIXES.etat) sortes.push('etat');
  }
  return sortes;
}

const journalDe = ({ fs, racine, base }) => lireJournal(fs.contenu(racine.id, base + SUFFIXES.journal));
const chargeEcrite = ({ fs, racine, base }) => analyser(fs.contenu(racine.id, base + SUFFIXES.etat)).charge;

// Le refus que rejette la promesse, null quand elle aboutit.
async function refusDe(promesse) {
  try {
    await promesse;
    return null;
  } catch (erreur) {
    return erreur;
  }
}

// Exécute les gestes qui préparent un exemple, chacun sur la charge courante.
async function preparer(seance, avant = []) {
  for (const [nom, args] of avant) await seance.executer(nom, argumentsDe(args, seance.charge));
}

const invariantsAvertis = (seance) => seance.etat().avertissements.filter(({ code }) => code === 'INVARIANT_VIOLE');

// --- La table ----------------------------------------------------------------

describe('registre : la table des exemples couvre chaque commande', () => {
  test('le registre porte des commandes, et chacune a son entrée, un exemple ou la raison de son absence', () => {
    const noms = [...COMMANDES.keys()];
    assert.ok(noms.length > 0, 'le registre COMMANDES est vide');
    assert.deepEqual(
      noms.filter((nom) => !EXEMPLES.has(nom)),
      [],
      'commandes du registre sans entrée dans la table',
    );
    assert.deepEqual(
      [...EXEMPLES.keys()].filter((nom) => !COMMANDES.has(nom)),
      [],
      'entrées de la table hors du registre',
    );
    const incompletes = [];
    for (const [nom, exemple] of EXEMPLES) {
      for (const cle of ['accepte', 'refuse', 'sansEffet']) {
        const valeur = exemple[cle];
        const donne = typeof valeur === 'string' ? valeur.trim() !== '' : valeur?.args !== undefined;
        if (!donne) incompletes.push(`${nom}.${cle}`);
      }
      if (typeof exemple.refuse === 'object' && typeof exemple.refuse.code !== 'string') incompletes.push(`${nom}.refuse.code`);
    }
    assert.deepEqual(incompletes, []);
  });
});

// --- En lecture, et sur un plan bloqué ------------------------------------------

// Pour chaque commande hors debloquer, le refus que la séance lève et le
// compte des écritures : [nom, problème] pour chaque écart.
async function balayerLesRefus(ouvert, attendu) {
  const ecarts = [];
  const temoin = chargeEcrite(await ouvrirCopie((await departsPrets()).temoin));
  const noms = [...COMMANDES.keys()].filter((nom) => nom !== 'debloquer');
  assert.ok(noms.length > 0);
  for (const nom of noms) {
    const exemple = EXEMPLES.get(nom);
    const source = typeof exemple?.accepte === 'object' ? exemple.accepte : exemple?.refuse;
    let args = {};
    try {
      args = argumentsDe(source?.args ?? {}, temoin);
    } catch {
      args = {};
    }
    const ecritures = ouvert.fs.compteurs.ecritures;
    const erreur = await refusDe(ouvert.seance.executer(nom, args));
    const ecart = attendu(erreur);
    if (ecart !== null) ecarts.push([nom, ecart]);
    if (ouvert.fs.compteurs.ecritures !== ecritures) ecarts.push([nom, `${ouvert.fs.compteurs.ecritures - ecritures} écriture(s)`]);
  }
  return ecarts;
}

const attenduModeLecture = (erreur) => {
  if (erreur === null) return 'accepté en lecture';
  if (erreur.code !== 'MODE_LECTURE') return `refusé ${erreur.code} au lieu de MODE_LECTURE`;
  return JSON.stringify(erreur.details.remede) === JSON.stringify({ geste: 'modifier' }) ? null : 'remède autre que modifier';
};

const attenduBloque = (erreur) => {
  if (erreur === null) return 'accepté sur un plan bloqué';
  if (erreur.code !== 'LECTURE_SEULE' || erreur.details.raison !== 'BLOQUE') {
    return `refusé ${erreur.code} ${JSON.stringify(erreur.details.raison ?? null)} au lieu de LECTURE_SEULE BLOQUE`;
  }
  return JSON.stringify(erreur.details.remede) === JSON.stringify({ geste: 'debloquer' }) ? null : 'remède autre que debloquer';
};

describe('registre : en lecture et sur un plan bloqué, aucune commande n’écrit (§ 2.1, § 8.4, § 9)', () => {
  test('en lecture, sur un événement vide, chaque commande est refusée MODE_LECTURE sans écriture', async () => {
    const ouvert = await ouvrirCopie((await departsPrets()).vide);
    assert.deepEqual(await balayerLesRefus(ouvert, attenduModeLecture), []);
  });

  test('en lecture, sur la charge témoin retenue, chaque commande est refusée MODE_LECTURE sans écriture', async () => {
    const ouvert = await ouvrirCopie((await departsPrets()).temoin);
    assert.deepEqual(await balayerLesRefus(ouvert, attenduModeLecture), []);
  });

  test('sur un plan bloqué vide, toujours en lecture, chaque commande est refusée LECTURE_SEULE BLOQUE sans écriture', async () => {
    const ouvert = await ouvrirBloque((await departsPrets()).vide);
    assert.deepEqual(await balayerLesRefus(ouvert, attenduBloque), []);
  });

  test('sur la charge témoin bloquée, toujours en lecture, chaque commande est refusée LECTURE_SEULE BLOQUE sans écriture', async () => {
    const ouvert = await ouvrirBloque((await departsPrets()).temoin);
    assert.deepEqual(await balayerLesRefus(ouvert, attenduBloque), []);
  });
});

describe('registre : debloquer (§ 8.5, § 9)', () => {
  test('seance.debloquer() sur un plan bloqué prend le verrou, écrit une entrée et un jalon, et laisse la séance en écriture', async () => {
    const ouvert = await ouvrirBloque((await departsPrets()).temoin);
    const { fs, seance, racine, base } = ouvert;
    assert.equal(fs.contenu(racine.id, base + SUFFIXES.verrou), null);
    const journal = journalDe(ouvert);
    const trace = tracer(fs);
    await seance.debloquer();
    const verrou = fs.contenu(racine.id, base + SUFFIXES.verrou);
    assert.notEqual(verrou, null, 'aucun verrou pris');
    assert.equal(JSON.parse(verrou).seance, seance.id);
    const apres = journalDe(ouvert);
    assert.equal(apres.entrees.length, journal.entrees.length + 1);
    assert.equal(apres.jalons.length, journal.jalons.length + 1);
    assert.deepEqual(ordreDesEcritures(trace, base), ['entree', 'precedent', 'etat']);
    assert.equal(seance.mode, 'ecriture');
    assert.equal(chargeEcrite(ouvert).evenement.etat, 'retenu');
  });
});

// --- En écriture : l'exemple accepté -------------------------------------------

describe('registre : en écriture, un exemple accepté écrit une entrée, et défaire la rend (§ 8.2, § 8.3)', () => {
  const acceptes = [...EXEMPLES].filter(([, exemple]) => typeof exemple.accepte === 'object');
  assert.ok(acceptes.length > 0);
  for (const [nom, exemple] of acceptes) {
    test(`${nom} : une entrée, le journal d'abord, l'état reconstruit, puis défaire`, async () => {
      const departsCourants = await departsPrets();
      const ouvert = await ouvrirCopie(exemple.accepte.sur === 'vide' ? departsCourants.vide : departsCourants.temoin, {
        ecriture: true,
      });
      const { fs, seance, base } = ouvert;
      await preparer(seance, exemple.accepte.avant);
      const avant = structuredClone(seance.charge);
      const journalAvant = journalDe(ouvert);
      const args = argumentsDe(exemple.accepte.args, avant);
      const trace = tracer(fs);

      const rendu = await seance.executer(nom, args);
      assert.equal(typeof rendu.libelle, 'string');
      const journal = journalDe(ouvert);
      assert.equal(journal.entrees.length, journalAvant.entrees.length + 1, 'une entrée exactement');
      assert.deepEqual(ordreDesEcritures(trace, base), ['entree', 'precedent', 'etat']);
      const derniere = journal.entrees.at(-1);
      const ecrite = chargeEcrite(ouvert);
      assert.equal(serialiserCharge(reconstruire(journal, derniere.revision)), serialiserCharge(ecrite));
      assert.equal(seance.mode, 'ecriture');

      // Aucune commande ne répartit : les réservations ajoutées tiennent à
      // une seule place (§ 5.8, § 17 point 3).
      const connues = new Set(avant.reservations.map((r) => JSON.stringify(r)));
      const ajoutees = ecrite.reservations.filter((r) => !connues.has(JSON.stringify(r)));
      assert.ok(new Set(ajoutees.map(({ table, siege }) => `${table}:${siege}`)).size <= 1, JSON.stringify(ajoutees));

      // Une retouche n'ajoute aucune violation au retenu reçu (§ 14.12).
      if (RETOUCHES.includes(nom)) assert.deepEqual(violationsNouvelles(avant, ecrite), []);

      await seance.defaire();
      const defait = journalDe(ouvert);
      assert.equal(defait.entrees.length, journal.entrees.length + 1, 'une entrée de retour');
      assert.deepEqual(defait.entrees.slice(0, journal.entrees.length), journal.entrees, 'le journal ne perd aucune entrée');
      assert.equal(defait.entrees.at(-1).sens, 'defaire');
      const rendue = seance.charge;
      for (const cle of ['participant', 'table', 'proposition']) {
        assert.equal(rendue.prochainsIds[cle], Math.max(avant.prochainsIds[cle], ecrite.prochainsIds[cle]), cle);
      }
      assert.equal(serialiserCharge(rendue), serialiserCharge({ ...avant, prochainsIds: rendue.prochainsIds }));

      // Le libellé figé ne suit pas un renommage (§ 8.2).
      if (exemple.personne !== undefined) {
        const id = exemple.personne(args);
        const personne = participantDe(rendue, id);
        assert.ok(derniere.libelle.includes(nomAffiche(personne)), `${derniere.libelle} ne nomme pas ${nomAffiche(personne)}`);
        await seance.executer('modifierParticipant', { id, champs: { nom: 'Grisaille', prenom: 'Ondine' } });
        const renomme = journalDe(ouvert).entrees.find(({ revision }) => revision === derniere.revision);
        assert.equal(renomme.libelle, derniere.libelle);
      }
    });
  }
});

// --- En écriture : l'exemple refusé et l'exemple sans effet ------------------------------

describe('registre : un exemple refusé n’écrit rien et nomme son remède (§ 2.1, garantie 3)', () => {
  const refuses = [...EXEMPLES].filter(([, exemple]) => typeof exemple.refuse === 'object');
  assert.ok(refuses.length > 0);
  for (const [nom, exemple] of refuses) {
    test(`${nom} : refusé ${exemple.refuse.code}, sans écriture`, async () => {
      const departsCourants = await departsPrets();
      const ouvert = await ouvrirCopie(exemple.refuse.sur === 'vide' ? departsCourants.vide : departsCourants.temoin, {
        ecriture: true,
      });
      const { fs, seance } = ouvert;
      await preparer(seance, exemple.refuse.avant);
      const args = argumentsDe(exemple.refuse.args, seance.charge);
      const ecritures = fs.compteurs.ecritures;
      const entrees = journalDe(ouvert).entrees.length;
      const erreur = await refusDe(seance.executer(nom, args));
      assert.notEqual(erreur, null, 'accepté');
      assert.equal(erreur.code, exemple.refuse.code, erreur.message);
      if (erreur.code === 'INVARIANT_VIOLE') {
        // La forme du refus de génération : le retenu nommé, et les seules
        // violations que la retouche ajouterait.
        assert.equal(erreur.details.proposition, seance.charge.retenu.proposition);
        assert.ok(erreur.details.violations.length > 0);
        const connues = new Set(violationsDuRetenu(seance.charge).map((violation) => JSON.stringify(violation)));
        assert.deepEqual(
          erreur.details.violations.filter((violation) => connues.has(JSON.stringify(violation))),
          [],
        );
      }
      if (Object.hasOwn(exemple.refuse, 'remede')) assert.deepEqual(erreur.details.remede, exemple.refuse.remede);
      assert.equal(fs.compteurs.ecritures, ecritures, 'écriture');
      assert.equal(journalDe(ouvert).entrees.length, entrees);
    });
  }

  test('chaque refus du domaine nomme son remède, hors des refus admis à remède null', async () => {
    const ecarts = [];
    for (const [nom, exemple] of refuses) {
      const departsCourants = await departsPrets();
      const { seance } = await ouvrirCopie(exemple.refuse.sur === 'vide' ? departsCourants.vide : departsCourants.temoin, {
        ecriture: true,
      });
      await preparer(seance, exemple.refuse.avant);
      const erreur = await refusDe(seance.executer(nom, argumentsDe(exemple.refuse.args, seance.charge)));
      if (erreur === null) {
        ecarts.push(`${nom} : accepté`);
      } else if (!Object.hasOwn(erreur.details ?? {}, 'remede')) {
        ecarts.push(`${nom} : ${erreur.code} sans details.remede`);
      } else if (erreur.details.remede === null && !REMEDE_NUL_ADMIS.has(erreur.code)) {
        ecarts.push(`${nom} : ${erreur.code} au remède null`);
      }
    }
    assert.deepEqual(ecarts, []);
  });
});

describe('registre : un exemple sans effet est refusé SANS_EFFET {commande}, sans entrée ni état (§ 8.2)', () => {
  const sansEffet = [...EXEMPLES].filter(([, exemple]) => typeof exemple.sansEffet === 'object');
  assert.ok(sansEffet.length > 0);
  for (const [nom, exemple] of sansEffet) {
    test(`${nom} : SANS_EFFET, remède null, rien n'écrit`, async () => {
      const ouvert = await ouvrirCopie((await departsPrets()).temoin, { ecriture: true });
      const { fs, seance, racine, base } = ouvert;
      await preparer(seance, exemple.sansEffet.avant);
      const args = argumentsDe(exemple.sansEffet.args, seance.charge);
      const ecritures = fs.compteurs.ecritures;
      const etat = fs.contenu(racine.id, base + SUFFIXES.etat);
      const journal = fs.contenu(racine.id, base + SUFFIXES.journal);
      const erreur = await refusDe(seance.executer(nom, args));
      assert.notEqual(erreur, null, 'accepté');
      assert.equal(erreur.code, 'SANS_EFFET', erreur.message);
      assert.deepEqual(erreur.details, { commande: nom, remede: null });
      assert.equal(fs.compteurs.ecritures, ecritures);
      assert.equal(fs.contenu(racine.id, base + SUFFIXES.etat), etat);
      assert.equal(fs.contenu(racine.id, base + SUFFIXES.journal), journal);
    });
  }
});

// --- Le vérificateur d'invariants -------------------------------------------------

describe('registre : le vérificateur d’invariants juge les retouches et l’ouverture (§ 14.12, § 14.15)', () => {
  test("une retouche qui assiérait à un tour plus de personnes qu'une table n'a de places est refusée, sans écriture", async () => {
    const ouvert = await ouvrirCopie((await departsPrets()).temoin, { ecriture: true });
    const { fs, seance } = ouvert;
    const { charge } = seance;
    const personne = libresA(charge, 1, 2)[0];
    const rang = charge.retenu.tables.indexOf(3);
    assert.equal(charge.retenu.placement[0].sieges[rang].length, tableDe(charge, 3).sieges ?? charge.evenement.siegesParDefaut);
    const ecritures = fs.compteurs.ecritures;
    const erreur = await refusDe(seance.executer('deplacerDansRetenu', { tour: 1, participant: personne, table: 3, siege: null }));
    assert.notEqual(erreur, null, 'accepté');
    // Un refus du contrôle de pose de la retouche, ou du vérificateur ; une
    // faute du code ou du stockage n'en est pas un.
    assert.ok(['TABLE_PLEINE', 'INVARIANT_VIOLE'].includes(erreur.code), erreur.message);
    assert.ok(Object.hasOwn(erreur.details, 'remede'), erreur.message);
    if (erreur.code === 'INVARIANT_VIOLE') {
      assert.equal(erreur.details.proposition, charge.retenu.proposition);
      assert.ok(erreur.details.violations.length > 0);
    }
    assert.equal(fs.compteurs.ecritures, ecritures);
  });

  test("retirerDuTour d'une personne non réservée est accepté : une entrée, la personne dans la réserve du tour, aucun INVARIANT_VIOLE", async () => {
    const ouvert = await ouvrirCopie((await departsPrets()).temoin, { ecriture: true });
    const { seance } = ouvert;
    const personne = libresA(seance.charge, 1, 2)[0];
    const entrees = journalDe(ouvert).entrees.length;
    await seance.executer('retirerDuTour', { tour: 1, participant: personne });
    assert.equal(journalDe(ouvert).entrees.length, entrees + 1);
    assert.ok(chargeEcrite(ouvert).retenu.placement[0].reserve.includes(personne));
    assert.deepEqual(invariantsAvertis(seance), []);
  });

  test('une violation déjà présente, celle d’une dérive, ne bloque pas les retouches, et INVARIANT_VIOLE la tait à l’ouverture comme après défaire, refaire et revenir', async () => {
    const ouvert = await ouvrirCopie((await departsPrets()).temoin, { ecriture: true });
    const { seance } = ouvert;
    await seance.executer('exclureParticipant', { id: libresA(seance.charge, 1, 4)[0] });
    assert.ok(violationsDuRetenu(seance.charge).length > 0, 'la dérive ne laisse aucune violation');
    assert.deepEqual(invariantsAvertis(seance), [], 'après la dérive');
    const revisionDerive = seance.etat().evenement.revision;
    const entrees = journalDe(ouvert).entrees.length;
    const { charge } = seance;
    await seance.executer('echangerDansRetenu', { tour: 1, a: libresA(charge, 1, 2)[0], b: libresA(charge, 1, 3)[0] });
    assert.equal(journalDe(ouvert).entrees.length, entrees + 1);
    assert.deepEqual(invariantsAvertis(seance), [], 'après la retouche');
    await seance.passerEnLecture();

    const autre = await rouvrir(ouvert, 'derive');
    assert.ok(violationsDuRetenu(autre.charge).length > 0, 'la dérive ne survit pas à la réouverture');
    assert.deepEqual(invariantsAvertis(autre), [], "à l'ouverture");
    await autre.passerEnEcriture();
    await autre.defaire();
    assert.ok(violationsDuRetenu(autre.charge).length > 0, 'défaire efface la dérive');
    assert.deepEqual(invariantsAvertis(autre), [], 'après défaire');
    await autre.refaire();
    assert.deepEqual(invariantsAvertis(autre), [], 'après refaire');
    await autre.revenir(revisionDerive);
    assert.ok(violationsDuRetenu(autre.charge).length > 0, 'revenir efface la dérive');
    assert.deepEqual(invariantsAvertis(autre), [], 'après revenir');
  });

  test("un retenu qui laisse une réservation d'un tour non honorée s'ouvre en lecture avec INVARIANT_VIOLE, sans écriture, et le garde après défaire, refaire et revenir", async () => {
    const { temoin } = await departsPrets();
    const source = await ouvrirCopie(temoin);
    const charge = structuredClone(source.seance.charge);
    const personne = libresA(charge, 1, 2)[0];
    const reservation = { participant: personne, table: 3, siege: null, portee: 'tour', tour: 1 };
    charge.reservations.push(reservation);

    const fs = creerFichiersSimules();
    fs.deposerDossier(temoin.racine.id);
    const ecrit = await creerDansLeDepot(fs, temoin.racine, charge, {
      libelle: libelle('ENTREE_CREATION', { nom: charge.evenement.nom }),
      nomJalon: libelle('JALON_CREATION'),
      horodatage: '2031-03-14T17:00:00-04:00',
      produitVersion: V,
    });
    const horloge = creerHorlogePilotee({ depart: DEPART });
    const seance = creerSeance({
      fs,
      racine: temoin.racine,
      horloge,
      identifiant: creerIdentifiants('invariant'),
      produitVersion: V,
      planifier: horloge.planifier,
      annuler: horloge.annuler,
    });
    const ecritures = fs.compteurs.ecritures;
    await seance.ouvrir(ecrit.base);
    assert.equal(fs.compteurs.ecritures, ecritures, 'ouvrir écrit');
    assert.equal(seance.mode, 'lecture');
    const attendu = [
      {
        code: 'INVARIANT_VIOLE',
        details: { proposition: charge.retenu.proposition, violations: [{ code: 'RESERVATION', participant: personne, table: 3, tour: 1 }] },
      },
    ];
    assert.deepEqual(invariantsAvertis(seance), attendu, "à l'ouverture");

    await seance.passerEnEcriture();
    await seance.executer('retirerReservation', { participant: personne, table: 3, portee: 'tour', tour: 1 });
    assert.deepEqual(invariantsAvertis(seance), [], 'la réservation retirée');
    await seance.defaire();
    assert.deepEqual(invariantsAvertis(seance), attendu, 'après défaire');
    await seance.refaire();
    assert.deepEqual(invariantsAvertis(seance), [], 'après refaire');
    await seance.revenir(1);
    assert.deepEqual(invariantsAvertis(seance), attendu, 'après revenir');
  });

  test('un retenu dont changerPlacesTable a versé des surnuméraires en réserve s’ouvre sans INVARIANT_VIOLE, et le reste après défaire et refaire', async () => {
    const ouvert = await ouvrirCopie((await departsPrets()).temoin, { ecriture: true });
    const { seance } = ouvert;
    assert.deepEqual(invariantsAvertis(seance), [], "à l'ouverture de la charge témoin");
    await seance.executer('creerTable', { forme: 'ronde' });
    await seance.executer('changerPlacesTable', { id: 2, sieges: '2', origine: 'champ' });
    const reduite = chargeEcrite(ouvert);
    const reserves = reduite.retenu.placement.map(({ reserve }) => reserve.length);
    assert.ok(reserves.every((n) => n > 0), `réserves ${JSON.stringify(reserves)}`);
    assert.ok(
      violationsDuRetenu(reduite, { reserveAutorisee: false }).some(({ code }) => code === 'NON_ASSIS'),
      'la réserve ne porte personne que la règle sans réserve refuserait',
    );
    await seance.passerEnLecture();

    const autre = await rouvrir(ouvert, 'reouverture');
    assert.deepEqual(invariantsAvertis(autre), [], "à l'ouverture");
    await autre.passerEnEcriture();
    await autre.defaire();
    assert.deepEqual(invariantsAvertis(autre), [], 'après défaire');
    await autre.refaire();
    assert.deepEqual(invariantsAvertis(autre), [], 'après refaire');
  });
});

// --- Créer et charger par la façade ------------------------------------------------

describe('registre : créer un événement et charger une démonstration écrivent sans passer par « Modifier » (§ 2.1, étape 1)', () => {
  test('créer, par la façade, écrit l’état et son entrée, la séance restant en lecture, sans verrou', async () => {
    const monte = monterFacade();
    await monte.facade.demarrer();
    assert.equal(monte.seance.mode, 'lecture');
    const { base } = await monte.facade.creer({ nom: NOM_VIDE });
    const { fs, racine, seance } = monte;
    assert.equal(seance.mode, 'lecture');
    assert.notEqual(fs.contenu(racine.id, base + SUFFIXES.etat), null);
    assert.equal(lireJournal(fs.contenu(racine.id, base + SUFFIXES.journal)).entrees.length, 1);
    assert.equal(fs.contenu(racine.id, base + SUFFIXES.verrou), null);
  });

  test('charger une démonstration, par la façade, écrit l’état et son entrée, la séance restant en lecture, sans verrou', async () => {
    const monte = monterFacade();
    await monte.facade.demarrer();
    const { base } = await monte.facade.chargerDemonstration('petite');
    const { fs, racine, seance } = monte;
    assert.equal(seance.mode, 'lecture');
    assert.equal(seance.ouvert.base, base);
    assert.notEqual(fs.contenu(racine.id, base + SUFFIXES.etat), null);
    assert.equal(lireJournal(fs.contenu(racine.id, base + SUFFIXES.journal)).entrees.length, 1);
    assert.equal(fs.contenu(racine.id, base + SUFFIXES.verrou), null);
  });
});