/**
 * Planification — Extension navigateur EasyVista (Canton de Vaud / DGNSI)
 *
 * Vue claire et rapide du planning des techniciens : interventions,
 * réservations, absences, statut pompier, etc. Regroupé par tech avec
 * timelines visuelles et popups détaillés.
 *
 * Copyright (c) 2026 Quentin Rouiller
 * Licensed under the MIT License — see LICENSE file in the project root.
 *
 * @author Quentin Rouiller
 * @repository https://gitea.netaplaid.ch/FroSteel/Planification
 *
 * Développé par Quentin Rouiller (QRO) — DGNSI, Canton de Vaud. Licence MIT.
 */

// ============================================================================
// viewer.js — vue claire du planning techniciens
// ============================================================================
// v2026.5.46 — bug « navigation rapide entre dates » : rendus périmés
// refusés (verrous storeSyncFolder + pipeline 3bis + filet renderFromData).
// v2026.5.46 — bug « tech retiré encore affiché » : la projection filtre
// l'annuaire du jour par l'équipe configurée actuelle (TEAM).
// v2026.5.46 — vue horizontale « échelle exacte » : lignes d'heures et
// ligne « maintenant » bornées avant le bloc des absents journée entière ;
// isTechAbsent évalue la plage configurée (DAY_START/DAY_END).
// v2026.5.46 — bug « navigation rapide » (suite) : jeton d'annulation pris
// dès l'entrée de loadForDate + gardes après les await pré-pipeline.
// v2026.5.46 — même famille : garde du chemin de boot sans session
// (refreshSessionAndLoad) contre une navigation pendant la lecture du store.
// v2026.5.46 — retours de revue : propriété du pipeline (_loadPipelineToken,
// « Arrêter » ciblé, 3bis avorté sans effet), re-rendu des réglages permis,
// double plage pour « absent toute la journée », _dayRange() unique,
// segments calculés une fois, filtre TEAM en hasOwnProperty.
// v2026.5.46 — retours de revue (2e passe) : cycle de vie du bouton
// « Arrêter » lié à la propriété du pipeline (plus de bouton fantôme, clic
// sans pipeline sans effet), zones absentes adjacentes fusionnées (plus de
// tronçons dans les interstices), dayLen dans _dayRange().
// v2026.5.46 — bug « réservations multiples le même jour » : le créneau
// (heures) entre dans ivKey/_ivAbsenceSig des réservations/absences — deux
// créneaux d'un même tech/jour ne fusionnent plus (un seul s'affichait quand
// EV partageait le request_id). + modal Modifier réservation : le N°
// d'intervention auto-remplit ville/rue/catégorie (helper _wireResNumberLookup
// partagé avec la création).
// v2026.5.46 — passe /simplify : _fusionnerPlages() remplace 4 copies de
// la fusion d'intervalles, _jourAffiche() nomme le prédicat « jour affiché »
// (3 sites), tolérance des interstices dérivée du gap CSS réel, dayE
// destructuré partout où dayStart+dayLen le re-dérivait.
// v2026.5.46 — bug « boucle de conflit du cache dossier » : le CAS de
// storeSyncFolder utilisait le savedAt renvoyé par « stat » (que l'hôte sert
// depuis _index.json, parfois périmé) comme référence d'écriture, alors que
// l'hôte compare le CAS au savedAt RELU dans le fichier. Index en retard =
// conflit permanent, écriture jamais aboutie, index jamais rafraîchi (deadlock).
// On prend désormais la référence CAS dans le fichier réellement lu et fusionné
// (folder.savedAt), pas dans stat : l'écriture aboutit et guérit l'index.
// v2026.5.46 — deux correctifs d'affichage (vue horizontale) :
//  1. fond des cartes d'absence : en échelle exacte la carte est haute et le
//     dégradé « couleur → neutre à 40 % » laissait le bas vide → en vue
//     horizontale la couleur douce remplit toute la carte (CSS).
//  2. plus de DOUBLON absence récurrente + vraie absence : si le tech a une
//     vraie absence EV ce jour (congé/maladie), l'absence récurrente configurée
//     ne s'affiche plus (fond/badge/note suivent la vraie absence).
// v2026.5.47 — passage au numéro de version 2026.5.47 (la 2026.5.46 est publiée ;
// le travail non poussé se fait désormais sous 2026.5.47). Pas de pull.
// v2026.5.47 — vue horizontale : la barre de progression « Actualisation
// X/Y » ne recouvre plus le haut de la sidebar (badge/titre/zone de reconnexion) ;
// elle se cale au-dessus de la zone de CONTENU, à droite de la sidebar
// (--sidebar-w mesuré en JS, robuste aux breakpoints/zoom).
// v2026.5.47b — la barre passe SOUS la banderole de session/reconnexion
// quand il y en a une (top = --stack-top, qui intègre la hauteur des banderoles),
// au lieu de la recouvrir ; top:0 quand il n'y a pas de banderole.
// v2026.5.47 — onglet Synchro : bouton « Tester la communication » qui fait
// l'aller-retour extension → hôte (version) → dossier (stat réel) et affiche un
// diagnostic lisible. Va de pair avec l'hôte natif v2026.1.8 (verrou dédié sur
// _index.json contre les « lost update » multi-postes ; icône tray ré-affichée
// au redémarrage d'explorer via TaskbarCreated).
// v2026.5.46 — refonte complète de la couche données : store unifié par
// jour (planv2_*), fusion unique vie/mort, verdict unique par intervention,
// projection rendu centralisée, sync dossier v2. Cf. section « COUCHE
// DONNÉES v2 » plus bas pour le modèle complet.
//
// v2026.5.46 — vue horizontale « échelle de temps exacte » (option
// Apparence, exclusive avec « Afficher les pauses ») : cartes posées en
// position réelle sur une bande continue, cf. _buildExactRow.
//
// v2026.5.46 — fiabilisation de la détection de session EasyVista
// (faux « déconnecté ») : cookie overwrite ignoré + vérification serveur
// avant bannière, expiration sur preuve uniquement, cookie sans onglet EV,
// contre-vérification des statuts HTTP côté background.
//
// v2026.5.46 — mode exact : poignée de déplacement à gauche des cartes
// (remplace le bloc d'heures), règle des heures alignée par MESURE runtime
// (_alignExactRuler), vraie césure midi (style timeline-noon).
//
// v2026.5.46 — mode exact : cartes étroites jamais vides (ville + fin
// d'adresse compactes), tolérance d'empilement 10 min (les enchaînements
// pile ne s'empilent plus), ligne « maintenant » UNIQUE et continue.
//
// v2026.5.46 — mode exact : sous-lignes en FLUX réel (.iv-exact-lane),
// bande à hauteur auto — un empilement n'est plus jamais rogné.
//
// v2026.5.46 — mode exact : position/ancres/hauteur des cartes
// verrouillées (!important) — la règle « position: relative » des cartes
// closed/resolved (mode flux, plus spécifique) cassait posé + taille.
//
// v2026.5.46 — la méta réservation (n° DS/ville/rue/catégorie, locale au
// poste, EV ne la stocke pas) remonte enfin au dossier partagé et aux autres
// postes : ivMerge la complète depuis l'autre copie (n'était jamais recopiée
// → écrasée par l'iv EV re-fetchée) + l'édition « infos seules » déclenche
// bien storeSave/push (avant : mutation mémoire sans persistance).
//
// v2026.5.46 — (1) ouverture de fiche des interventions faites/clôturées
// réparée (formLink retiré au dossier → régénération via la réf) ; (2) mode
// exact : cartes à fond neutre, seul le bord gauche est coloré et sert de
// poignée (clic = modifier, glisser = déplacer).
//
// v2026.5.46 — mode exact : bord gauche à points colorés sur TOUTES les
// cartes (drag bloqué pour faites/clôturées/réservations/absences), bulles
// moins hautes (sous-ligne 60→48 px) ; croix native du champ recherche masquée.
//
// v2026.5.46 — mode exact : lignes d'heures verticales CONTINUES qui
// traversent tout le tableau (calque global, _layoutExactGrid) ; règle des
// heures réellement fixe en haut au scroll (top:0, la topbar est masquée).
//
// v2026.5.46 — mode exact : fines lignes aux demi-heures (h30) ; les
// traits passent DERRIÈRE les bulles d'intervention (z-index sous les cartes).
//
// v2026.5.46 — mode exact : vide sous les bulles supprimé (bande centrée,
// hauteur ↑), heures pleines vs demi-heures (pointillé) différenciées, aucune
// ligne sur les techs absents, adresse abrégée tenue plus longtemps.
//
// v2026.5.46 — mode exact : bulles un chouïa plus hautes (texte qui
// respire) et espace haut/bas resserré ; léger contour conservé.
//
// v2026.5.46 — mode exact : bulles encore agrandies (remplissent leur
// zone) et ensemble resserré (marges de bande et entre sous-lignes réduites).
//
// v2026.5.46 — mode exact : bulles encore un peu plus grandes + n°
// d'intervention détaché du bloc ville+adresse (qui restent groupés).
//
// v2026.5.46 — mode exact : bulles encore agrandies + plus d'espace sous
// le n° ; bandelette pompier refixée en haut (le centrage la décentrait).
//
// v2026.5.46 — mode exact : bulles encore agrandies ; pompier — bandelette
// figée en haut (taille inchangée) + bulles centrées dans l'espace restant.
//
// v2026.5.46 — contact : deux numéros de téléphone séparés par un espace
// n'étaient plus collés à l'affichage (re-découpe du bloc capturé).
//
// v2026.5.46 — alerte doublons de réservation RETIRÉE à la
// demande : le marquage ROUGE des conflits (detectOverlaps, pré-existant)
// reste seul en place, comme avant.
//
// v2026.5.46 — vue par heure : les réservations affichent le lieu (meta)
// sinon le créateur ; catégorie « Autre » en fuchsia sur toutes les vues.
//
// v2026.5.46 — « Réservation » en tête de bulle comme le n° d'intervention
// (gabarit + espace dessous) ; « Autre » passe du fuchsia au vert lime.
//
// v2026.5.46 — « Autre » : lime pas retenu → rose framboise.
//
// v2026.5.46 — vue par heure : les journées totalement VIDES ont enfin
// leurs trous (survol « Libre », clic droit, drop précis) — la bande est
// construite même sans aucune intervention.
//
// v2026.5.46 — « Autre » en violet foncé ; la ligne du temps saute les
// techs absents (helper _exactAbsentSegments partagé avec les lignes d'heures).
//
// v2026.5.46 — la ligne du temps n'a plus ni point ni trait sur la règle
// des heures : elle démarre au haut des cartes.
//
// v2026.5.46 — la ligne du temps est REPOSÉE immédiatement après chaque
// rendu/resize/bascule (avant : détruite par le rendu, elle ne revenait qu'au
// tick d'horloge de 30 s → souvent absente).
//
// Idée de base : on récupère tout depuis le XML EasyVista (calendar_block) en
// 1 seule requête. attr1/attr2/attr3 + textContent contiennent déjà ref,
// contact, lieu, catégorie, formLink, deadline. Plus besoin de faire 74
// requêtes xhr2 au chargement comme la v3. Le texte complet de l'action
// (Problème / À faire / Matériel) est lazy-load au hover, seulement si
// l'user survole la ligne.
//
// Fetch des fiches : séquentiel (1 par 1) au lieu d'en paralléliser. Le
// serveur EasyVista sérialise de toute façon, et ça rend l'abort instantané
// si l'user change de date en cours.
// Le cache est écrit toutes les 5 fiches (incrémental), pas juste à la fin.
// Comme ça si l'user change de date au milieu, ce qu'on a déjà fetché est
// pas perdu.
// ============================================================================

// ============================================================================
// v2026.5.38 : Observabilité — logger unifié + handlers globaux
// ============================================================================
// Toutes les erreurs runtime (uncaught + unhandled rejection) sont attrapées
// par les listeners ci-dessous et loggées avec un préfix clair, un timestamp,
// et la stack trace si dispo. L'idée : qd l'user lance F12 et copie la console,
// on a tout pour reproduire et corriger.
//
// Format des logs : [PREFIX][LEVEL] message {context}
//   - LEVEL : INFO / WARN / ERROR
//   - PREFIX : module qui logue (load, currentUser, session, viewMode, ...)
//   - message : un truc lisible humain
//   - context : objet sérialisable avec les vars utiles au debug
// ============================================================================

// Clef localStorage pour le mode debug — exposé dans le panel admin.
// Quand activé : LOG.info() devient visible. Sinon : muet.
// LOG.warn et LOG.error sont TOUJOURS visibles, peu importe le flag.
const DEBUG_LOGS_KEY = "debug_logs";

const LOG = (() => {
  // On capture la version du manifest une fois, pour la mettre dans les logs
  // d'erreur (utile qd l'user nous envoie un screenshot console).
  let _version = "?";
  try {
    if (chrome && chrome.runtime && chrome.runtime.getManifest) {
      _version = chrome.runtime.getManifest().version || "?";
    }
  } catch (e) {
    // chrome.runtime peut ne pas être dispo dans certains contextes
  }

  // État debug — relu depuis localStorage. Peut être toggle à la volée
  // depuis le panel admin sans reload.
  let _debug = false;
  try {
    _debug = localStorage.getItem(DEBUG_LOGS_KEY) === "1";
  } catch (e) {
    // localStorage peut être bloqué (mode privé) — on reste en mode normal
  }

  const _stamp = () => new Date().toISOString().substring(11, 23); // HH:MM:SS.mmm

  const _format = (level, prefix, msg, ctx) => {
    const head = `[${_stamp()}][v${_version}][${prefix}][${level}]`;
    if (ctx !== undefined) return [head, msg, ctx];
    return [head, msg];
  };

  return {
    // info() : visible UNIQUEMENT si debug activé. Pour les étapes verbose.
    info: (prefix, msg, ctx) => {
      if (!_debug) return;
      console.log(..._format("INFO", prefix, msg, ctx));
    },
    // warn / error : toujours visibles
    warn: (prefix, msg, ctx)  => console.warn (..._format("WARN",  prefix, msg, ctx)),
    error:(prefix, msg, ctx)  => console.error(..._format("ERROR", prefix, msg, ctx)),
    // Erreur "interne" — affiche stack + serialize l'objet erreur
    exception: (prefix, msg, err, extra) => {
      const ctx = {
        name:    err && err.name,
        message: err && err.message,
        stack:   err && err.stack,
        extra:   extra
      };
      console.error(..._format("ERROR", prefix, msg, ctx));
    },
    // Toggle à la volée depuis le panel admin
    setDebug: (on) => {
      _debug = !!on;
      try { localStorage.setItem(DEBUG_LOGS_KEY, _debug ? "1" : "0"); } catch (e) {}
      // Synchroniser avec le service worker (qui a son propre flag)
      try {
        chrome.runtime.sendMessage({ type: "setDebugLogs", on: _debug }, () => {
          // on ignore lastError volontairement : le SW peut être en sommeil
          if (chrome.runtime.lastError) { /* ok */ }
        });
      } catch (e) {}
      console.log(..._format("INFO", "logger", `mode debug = ${_debug ? "ON" : "OFF"}`));
    },
    isDebug: () => _debug,
    version: () => _version
  };
})();

// Global error handler : attrape les exceptions qui passent à travers tous les
// try/catch. L'user voit un toast, on logue tout en console.
window.addEventListener("error", (event) => {
  // Bruit bénin de Chrome lors d'un redimensionnement rapide de fenêtre :
  // un callback de ResizeObserver déclenche un layout qui programme un nouveau
  // resize au tick suivant. Le navigateur gère la situation tout seul (les
  // notifications restantes seront livrées au tick suivant) — il n'y a rien
  // à corriger côté JS, mais Chrome signale quand même l'event en boucle.
  // On filtre pour éviter de spammer les logs et le toast utilisateur.
  const msg = (event.message || "") + "";
  if (msg.includes("ResizeObserver loop")) return;

  LOG.exception("global", "uncaught error",
    event.error || new Error(event.message || "unknown"),
    { filename: event.filename, lineno: event.lineno, colno: event.colno });
  try {
    if (typeof showToast === "function") {
      showToast("Erreur inattendue", "Voir la console (F12) pour le détail");
    }
  } catch (e) { /* showToast peut ne pas être init au tout début */ }
});

// Promesses rejetées sans .catch() — typiquement des async/await sans try
window.addEventListener("unhandledrejection", (event) => {
  const reason = event.reason;
  LOG.exception("global", "unhandled promise rejection",
    reason instanceof Error ? reason : new Error(String(reason)),
    { promise: "unhandled" });
  try {
    if (typeof showToast === "function") {
      showToast("Erreur asynchrone", "Voir la console (F12) pour le détail");
    }
  } catch (e) { /* idem */ }
});

LOG.info("boot", "viewer.js chargé", { version: LOG.version() });

LOG.warn("planification",
  `Planification v${LOG.version()} — Mode ${LOG.isDebug() ? "DEBUG" : "PROD"}.`);

// ============================================================================
// Configuration
// ============================================================================

// v2026.5.41 : plus aucune équipe / absence récurrente codée en dur.
// L'utilisateur configure tout depuis Paramètres → Équipe :
//   - cfg.team           = { id: name }   — techniciens à afficher
//   - cfg.recurringAbsences = { id: [days] } — jours d'absence récurrente
// (chrome.storage.local["admin_config"], persiste entre les mises à jour)
//
// TEAM et RECURRING_ABSENCES sont rechargées au boot depuis admin_config par
// _initTeamFromConfig() (appelée tôt dans init()). Tant qu'elles ne sont pas
// chargées, elles restent vides → aucun fetch tenté.
let TEAM = {};
// v2026.5.46 — vue horizontale « échelle de temps exacte » (option
// Apparence). Miroir de cfg.horizontalExactMode, lu au boot et au toggle.
let HORIZONTAL_EXACT_MODE = false;
let RECURRING_ABSENCES = {};

// idx commun dérivé des bornes "startMin-endMin", posé sur le
// .gap-placeholder (rect carte-body / mini-cards) ET sur le
// .timeline-hole correspondant. Pas de matching fragile — si les bornes
// sont identiques, les 2 partagent le même attribut. highlightGap
// toggle .gap-hover-active sur tous les [data-gap-idx="N"] dans la
// card, exactement comme highlightIntervention pour [data-iv-idx="N"].
function highlightGap(cardEl, gapIdx, on) {
  if (!cardEl || gapIdx == null) return;
  cardEl.querySelectorAll(`[data-gap-idx="${gapIdx}"]`).forEach(el => {
    el.classList.toggle("gap-hover-active", on);
  });
}

function _bindGapPlaceholder(phEl, cardEl) {
  if (!cardEl || !phEl) return;
  const startMin = Number(phEl.dataset.startMin);
  const endMin = Number(phEl.dataset.endMin);
  if (!Number.isFinite(startMin) || !Number.isFinite(endMin)) return;
  const idx = startMin + "-" + endMin;
  phEl.dataset.gapIdx = idx;
  phEl.addEventListener("mouseenter", () => highlightGap(cardEl, idx, true));
  phEl.addEventListener("mouseleave", () => highlightGap(cardEl, idx, false));
}

// Détection post-rendu d'une mini-card iv tronquée → masque les
// gap-placeholder-mini de la MÊME ligne pour libérer la place. Le
// flex CSS ne suffit pas car le navigateur ne sait pas que le
// contenu de l'iv déborde son flex-basis (overflow:hidden masque le
// débordement). On le détecte explicitement via scrollWidth > clientWidth.
function _trimMiniGapsForFit() {
  document.querySelectorAll(".iv-mini-block-cards").forEach(blockCards => {
    // Reset : remettre tous les gaps non-full visibles d'abord
    blockCards.querySelectorAll(".gap-placeholder-mini:not(.gap-placeholder-full)").forEach(g => {
      g.style.removeProperty("display");
    });
    // Détection : au moins une iv tronque-t-elle son contenu ?
    let needsTrim = false;
    blockCards.querySelectorAll(".iv-mini-card").forEach(iv => {
      const txt = iv.querySelector(".iv-mini-card-text");
      if (txt && txt.scrollWidth > txt.clientWidth + 1) needsTrim = true;
      const tCol = iv.querySelector(".iv-mini-time-vertical");
      if (tCol && tCol.scrollWidth > tCol.clientWidth + 1) needsTrim = true;
    });
    if (needsTrim) {
      blockCards.querySelectorAll(".gap-placeholder-mini:not(.gap-placeholder-full)").forEach(g => {
        g.style.display = "none";
      });
    }
  });
}

// Re-check au resize de la fenêtre (la largeur dispo change → certaines
// iv passent ou non en troncature).
let _trimRO = null;
function _attachMiniGapsResizeWatcher() {
  if (typeof ResizeObserver === "undefined") return;
  if (_trimRO) return;
  let scheduled = false;
  _trimRO = new ResizeObserver(() => {
    if (scheduled) return;
    scheduled = true;
    requestAnimationFrame(() => {
      scheduled = false;
      _trimMiniGapsForFit();
      // v2026.5.46 — recale la règle des heures du mode exact (resize,
      // bandeaux qui apparaissent/disparaissent, zoom, sidebar).
      if (typeof _alignExactRuler === "function") _alignExactRuler();
      if (typeof _layoutExactGrid === "function") _layoutExactGrid();
      if (typeof updateNowLine === "function") updateNowLine();
    });
  });
  _trimRO.observe(document.body);
}

async function _initTeamFromConfig() {
  try {
    const cfg = await loadAdminConfig();
    TEAM = cfg.team || {};
    RECURRING_ABSENCES = cfg.recurringAbsences || {};
    // v2026.5.46 — mode « échelle de temps exacte » (vue horizontale).
    HORIZONTAL_EXACT_MODE = !!cfg.horizontalExactMode;
    document.documentElement.classList.toggle("horizontal-exact", HORIZONTAL_EXACT_MODE);
    // applique l'option "Afficher les pauses" au boot.
    // v2026.5.46 — exclusive avec le mode exact : si les deux traînent
    // dans la config, le mode exact gagne à l'affichage.
    document.documentElement.classList.toggle("show-iv-gaps", !!cfg.showInterventionGaps && !HORIZONTAL_EXACT_MODE);
    // recharger les statuts personnalisables depuis la config.
    if (Array.isArray(cfg.closedStatus) && cfg.closedStatus.length > 0) {
      CLOSED_STATUS = cfg.closedStatus.slice();
    }
    if (Array.isArray(cfg.resolvedStatus) && cfg.resolvedStatus.length > 0) {
      RESOLVED_STATUS = cfg.resolvedStatus.slice();
    }
    if (Array.isArray(cfg.cancelledStatus) && cfg.cancelledStatus.length > 0) {
      CANCELLED_STATUS = cfg.cancelledStatus.slice();
    }
    KEEP_DIAG_GHOSTS = !!cfg.keepDisappearedGhosts;
    COORDINATOR_MODE = !!cfg.coordinatorMode;
    _impersonate = cfg.impersonate || null;
  } catch (e) {
    LOG.warn("boot", "_initTeamFromConfig err", e);
  }
}

// statuts EasyVista éditables depuis admin_config (Paramètres → EV).
// Les valeurs par défaut servent de filet de sécurité au 1er install et
// pour les versions où la config n'aurait pas encore ces clés.
// Clôturé et Terminé par défaut (les 2 statuts qui signifient
// "finalisé officiellement" dans EV). N'affecte QUE les nouveaux installs
// (config vide) — si une config existe déjà avec d'autres valeurs,
// loadAdminConfig la garde intacte (cf. fusion `...stored`).
const DEFAULT_CLOSED_STATUS = ["Clôturé", "Terminé"];
const DEFAULT_RESOLVED_STATUS = [];
const DEFAULT_CANCELLED_STATUS = ["Annulé", "Supprimé"];
let CLOSED_STATUS = [...DEFAULT_CLOSED_STATUS];
let RESOLVED_STATUS = [...DEFAULT_RESOLVED_STATUS];
let CANCELLED_STATUS = [...DEFAULT_CANCELLED_STATUS];
// v2026.5.45 — flag diagnostic, lu depuis admin_config au boot et mis à
// jour quand on toggle la case "Garder les disparitions". Quand true : on
// ne retire JAMAIS les ghosts (KEEP forcé), peu importe le verdict.
let KEEP_DIAG_GHOSTS = false;
// v2026.5.46 — mode coordinateur : affiche le badge "Mes actions" dans la
// barre de stats (nb d'interventions où l'utilisateur a une action). Off par défaut.
let COORDINATOR_MODE = false;
// Mode coordinateur — "Mes actions" : fetch + parse de la page EV
// General_MyActionsItem PAR L'EXTENSION (aucune fenêtre EV ouverte).
//   _myActionsCount : nombre (badge "A faire : N"). null = pas encore chargé.
//   _myActionsRows  : lignes parsées [{numero}]. null = pas encore chargé.
let _myActionsCount = null;
let _myActionsRows = null;
let _myActionsLoading = false;
let _myActionsDiag = ""; // diagnostic du dernier fetch (affiché dans l'onglet)

// v2026.5.46 — impersonation (RÉSERVÉE à Quentin Rouiller) : permet de tester
// la vue coordinateur en "se faisant passer pour" une autre personne. Chargé
// depuis admin_config (cfg.impersonate = { enabled, name, initials, memberId }).
let _impersonate = null;
// Vrai uniquement si l'utilisateur connecté EST Quentin Rouiller (garde-fou
// pour n'afficher l'onglet Test qu'à lui).
function _isQuentin() {
  const n = (state && state.currentUser && state.currentUser.name) || "";
  return /rouiller/i.test(n) && /quentin/i.test(n);
}
// Identité effective utilisée pour retrouver "l'action liée à la personne"
// (Partie A « Mes actions »). Si impersonation active ET QRO → identité simulée,
// sinon l'utilisateur réel.
function _effectiveIdentity() {
  const real = {
    name: (state && state.currentUser && state.currentUser.name) || "",
    initials: (state && state.currentUser && state.currentUser.initials) || "",
    memberId: (state && state.currentUser && state.currentUser.memberId) || "",
    impersonated: false
  };
  if (_isQuentin() && _impersonate && _impersonate.enabled &&
      (_impersonate.name || _impersonate.initials || _impersonate.memberId)) {
    return {
      name: _impersonate.name || "",
      initials: _impersonate.initials || "",
      memberId: _impersonate.memberId || "",
      impersonated: true
    };
  }
  return real;
}

// Clés de stockage
// v2026.5.46 — store unifié v2. L'ancien préfixe "planning_cache_" est
// abandonné (format incompatible) : les vieilles clés sont purgées au boot
// (cf. storePurgeLegacy) et l'enrichissement se reconstruit au fil de l'eau.
const STORE_PREFIX = "planv2_";          // + YYYY-MM-DD → entrée jour schéma 2
const LEGACY_CACHE_PREFIX = "planning_cache_"; // ancien format (purgé au boot)

// v2026.5.46 — meta des réservations créées depuis l'extension (n° DS,
// ville, rue, catégorie). EasyVista ne stocke PAS ces infos : on les garde
// localement et on les réapplique à CHAQUE parse, pour qu'elles survivent aux
// refresh EV et au recyclage d'actionId des réservations.
// Structure : { "<isoDate>|<techId>|<HH:MM>": { numero, ville, rue, categorie } }
const RESERVATION_META_KEY = "reservation_meta";
let _resMetaStore = {};
function _resMetaKey(techId, isoDate, hhmm) {
  return `${isoDate}|${techId}|${(hhmm || "").slice(0, 5)}`;
}
async function loadResMetaStore() {
  try {
    const r = await chrome.storage.local.get(RESERVATION_META_KEY);
    _resMetaStore = r[RESERVATION_META_KEY] || {};
  } catch (e) { _resMetaStore = {}; }
}
function _resMetaGet(techId, isoDate, hhmm) {
  return _resMetaStore[_resMetaKey(techId, isoDate, hhmm)] || null;
}
async function _resMetaSet(techIds, isoDate, hhmm, meta) {
  // La clé date doit être au format du XML calendar_block (JJ/MM/AAAA = iv.startDate),
  // pas en ISO, sinon le lookup au parse ne matche jamais.
  const dkey = (typeof isoToDDMMYYYY === "function") ? isoToDDMMYYYY(isoDate) : isoDate;
  for (const techId of (techIds || [])) {
    _resMetaStore[_resMetaKey(String(techId), dkey, hhmm)] = {
      numero: meta.numero || "", ville: meta.ville || "",
      rue: meta.rue || "", categorie: meta.categorie || ""
    };
  }
  try { await chrome.storage.local.set({ [RESERVATION_META_KEY]: _resMetaStore }); }
  catch (e) { LOG.warn("reservation", "écriture meta persistante échouée", { err: e && e.message }); }
}
// v2026.5.46 — set par clé "brute" : la date est déjà au format XML
// (JJ/MM/AAAA = iv.startDate). Utilisé pour éditer une réservation déjà affichée.
async function _resMetaSetRaw(techId, ddmmyyyyDate, hhmm, meta) {
  _resMetaStore[_resMetaKey(String(techId), ddmmyyyyDate, hhmm)] = {
    numero: meta.numero || "", ville: meta.ville || "",
    rue: meta.rue || "", categorie: meta.categorie || ""
  };
  try { await chrome.storage.local.set({ [RESERVATION_META_KEY]: _resMetaStore }); }
  catch (e) { LOG.warn("reservation", "écriture meta (édition) échouée", { err: e && e.message }); }
}

// v2026.5.46 — assignations pompier : liste de périodes
// { techId, name, start, end } (dates ISO YYYY-MM-DD). Le « pompier du mois »
// affiché = l'assignation couvrant la date affichée. Règle : un seul pompier
// par jour → on bloque tout chevauchement avec un AUTRE technicien.
const POMPIER_KEY = "pompier_assignments";
let _pompierAssignments = [];
async function loadPompierAssignments() {
  try {
    const r = await chrome.storage.local.get(POMPIER_KEY);
    _pompierAssignments = Array.isArray(r[POMPIER_KEY]) ? r[POMPIER_KEY] : [];
  } catch (e) { _pompierAssignments = []; }
}
// Assignation couvrant une date ISO (comparaison lexicale OK sur YYYY-MM-DD).
function _pompierForDate(isoDate) {
  if (!isoDate) return null;
  return _pompierAssignments.find(a => a.start <= isoDate && isoDate <= a.end) || null;
}
// Périodes en conflit avec [start,end] portées par un AUTRE technicien.
function _pompierConflicts(start, end, techId) {
  return _pompierAssignments.filter(a =>
    String(a.techId) !== String(techId) && a.start <= end && start <= a.end);
}
async function _pompierAddAssignment(techId, name, start, end) {
  // Remplacement propre : on retire les périodes du MÊME tech qui chevauchent.
  _pompierAssignments = _pompierAssignments.filter(a =>
    !(String(a.techId) === String(techId) && a.start <= end && start <= a.end));
  _pompierAssignments.push({ techId: String(techId), name: name || "", start, end });
  try { await chrome.storage.local.set({ [POMPIER_KEY]: _pompierAssignments }); }
  catch (e) { LOG.warn("pompier", "écriture assignation pompier échouée", { err: e && e.message }); }
}
// v2026.5.46 — retire une assignation exacte (après déplacement de dates).
async function _pompierRemoveExact(techId, start, end) {
  const before = _pompierAssignments.length;
  _pompierAssignments = _pompierAssignments.filter(a =>
    !(String(a.techId) === String(techId) && a.start === start && a.end === end));
  if (_pompierAssignments.length !== before) {
    try { await chrome.storage.local.set({ [POMPIER_KEY]: _pompierAssignments }); } catch (e) {}
  }
}
// v2026.5.46 — collecte les pompiers depuis 2 sources et fusionne :
//  (1) le store local d'assignations (créées via l'extension),
//  (2) le CACHE du planning : toute absence type Pompier réellement présente dans
//      EasyVista, sur les jours déjà chargés. Chaque absence porte sa période
//      début→fin (JJ/MM/AAAA dans le cache → converti en ISO).
// Dédupliqué par tech|début|fin. Renvoie une liste {techId, name, start, end} (ISO).
async function _collectPompiers() {
  const _toIso = (s) => { const m = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(s || ""); return m ? `${m[3]}-${m[2]}-${m[1]}` : (s || ""); };
  const map = new Map();
  // actionId vient du cache (nécessaire pour supprimer l'absence lors d'une
  // modification de dates). Le store local n'en a pas → complété par le cache.
  const add = (techId, name, start, end, actionId) => {
    if (!techId || !start || !end) return;
    const k = `${techId}|${start}|${end}`;
    const ex = map.get(k);
    if (!ex) map.set(k, { techId: String(techId), name: name || "", start, end, actionId: actionId || null });
    else if (!ex.actionId && actionId) ex.actionId = actionId;
  };
  for (const a of _pompierAssignments) add(a.techId, a.name, a.start, a.end, null);
  try {
    // v2026.5.46 — scan des jours du store v2 (liste plate d'ivs)
    const all = await chrome.storage.local.get(null);
    for (const key of Object.keys(all)) {
      if (key.indexOf(STORE_PREFIX) !== 0) continue;
      const entry = all[key];
      if (!entry || !Array.isArray(entry.ivs)) continue;
      for (const iv of entry.ivs) {
        if (!iv || !iv.isPompier || ivIsDead(iv)) continue;
        const tid = iv.techId;
        add(tid, (TEAM && TEAM[tid]) || "Pompier", _toIso(iv.startDate), _toIso(iv.endDate || iv.startDate), iv.actionId);
      }
    }
  } catch (e) { LOG.warn("pompier", "scan store pompiers échoué", { err: e && e.message }); }
  return [...map.values()];
}

// v4.1 : plus de constante de concurrence. Les fiches sont fetchées
// séquentiellement (1 à la fois) car le serveur EasyVista est lent de toute
// façon, et ça garantit un abort instantané + pas de race sur le DOM.

// ============================================================================
// Mapping de catégorie → titre court + couleur
// ============================================================================

const CATEGORY_TO_TITLE = [
  // Arrivées / nouvelles installations → Installation (bleu)
  [/Arriv[ée]e\s+ou\s+mutation/i,                   "Installation", "installation"],
  [/Accessoire\s+pour\s+PC/i,                       "Installation", "installation"],
  [/Nouveau\s+Poste\s+Windows/i,                    "Installation", "installation"],
  [/Nouveau\s+Poste\s+macOS/i,                      "Installation", "installation"],
  // Récupération / départ (vert)
  [/D[ée]part\s+d[\u2018\u2019']un\s+utilisateur/i, "Récupération", "recup"],
  [/Reprise\s+du\s+mat[ée]riel/i,                   "Récupération", "recup"],
  // Remplacement (orange)
  [/Remplacement\s+de\s+mat[ée]riel/i,              "Remplacement", "remplacement"],
];

/**
 * Détecte si le texte de l'action commence par "Roll Out".
 */
function isRollOut(iv) {
  const texts = [
    iv.bulleDescription,
    iv.infobulle && iv.infobulle.aFaire,
    iv.label
  ];
  for (const t of texts) {
    if (!t) continue;
    if (/^\s*[«"']?\s*roll[\s\-]*out/i.test(String(t))) return true;
    if (/(?:^|\bA faire\s*:\s*)roll[\s\-]*out/i.test(String(t))) return true;
  }
  return false;
}

/**
 * Détecte si le texte de l'action mentionne une récupération de matériel.
 * Accepté : "RÉCUPÉRATION DE MATÉRIEL" ou "Récupération" au début de l'action,
 * ou dans "A faire : Récupération ...".
 */
function isRecupAction(iv) {
  const texts = [
    iv.bulleDescription,
    iv.infobulle && iv.infobulle.aFaire,
    iv.label
  ];
  for (const t of texts) {
    if (!t) continue;
    const s = String(t);
    if (/^\s*r[ée]cup[ée]ration/i.test(s)) return true;
    if (/\bA\s+faire\s*:\s*r[ée]cup[ée]ration/i.test(s)) return true;
  }
  return false;
}

/**
 * Dérive un titre court et une clé de couleur à partir d'une intervention.
 * Priorité :
 *   1. Si la ref commence par I260 → "Incident" (violet)
 *   2. Si l'action commence par "Roll Out" → "Roll Out" (brun)
 *   3. Si l'action mentionne récupération → "Récupération" (vert)
 *   4. Sinon, mapping par catégorie (fiche)
 *   5. Sinon, "Autres" (gris)
 */
function deriveShortTitle(iv) {
  if (iv.type === "AL-Reservation") return "Réservation";
  if (iv.ref && /^I\d/.test(iv.ref)) return "Incident";
  if (isRollOut(iv)) return "Roll Out";
  if (isRecupAction(iv)) return "Récupération";
  const cat = iv.categoryLine || "";
  if (!cat) return "Autres";
  for (const [regex, title] of CATEGORY_TO_TITLE) {
    if (regex.test(cat)) return title;
  }
  return "Autres";
}

function deriveColorKey(iv) {
  if (iv.type === "AL-Reservation") return "reservation";
  if (iv.type === "AL-Absence") return "absence";  // v5.0.15 : couleur noire/gris foncé
  if (iv.ref && /^I\d/.test(iv.ref)) return "incident";
  if (isRollOut(iv)) return "rollout";
  if (isRecupAction(iv)) return "recup";
  const cat = iv.categoryLine || "";
  if (!cat) return "autre";
  for (const [regex, , colorKey] of CATEGORY_TO_TITLE) {
    if (regex.test(cat)) return colorKey;
  }
  return "autre";
}

// ============================================================================
// État global
// ============================================================================

let state = {
  session: null,           // { phpsessid, origin, tabId }
  currentDate: null,       // "YYYY-MM-DD" affiché
  currentData: null,       // projection rendue (techs[] — objets iv PARTAGÉS avec le store)
  currentDay: null,        // v2026.5.46 — store du jour affiché (LA vérité, cf. couche données v2)
  loading: false,
  // v5.0.9 : timestamp (ms) auquel la session EV va expirer.
  sessionExpireAt: null,
  // v5.0.9 : true pendant une reconnexion en cours
  reconnecting: false,
  // v5.0.9 : true si la session est expirée (bannière rouge affichée)
  sessionExpired: false,
  // Cookie PHPSESSID présent mais fetchUser retourne null (page login SSO
  // intermédiaire). On garde le polling actif tant que la vraie session
  // (avec user identifié) n'est pas arrivée.
  sessionPending: false,
  // v5.0.9 : true si on a déjà fait le ping de confirmation < 5 min
  sessionPingDone: false,
  // v5.0.10 : dernière origine EV connue comme fonctionnelle (itsma.vd.ch
  // ou itsma.etat-de-vaud.ch selon qu'on est en externe ou interne).
  // Conservée même quand state.session est null, pour savoir où rediriger
  // lors de la reconnexion.
  lastKnownOrigin: null,
  // v5.0.11 : contexte réseau détecté ("internal" ou "external" ou null).
  // Détecté automatiquement au démarrage par un HEAD test sur l'URL interne.
  networkContext: null,
  // v5.0.11 : timer (setTimeout id) pour le timeout de reconnexion 90 sec
  reconnectTimeoutId: null
};

// v5.0.9 : constantes session
const SESSION_DURATION_MS = 30 * 60 * 1000;  // 30 min
// v2026.5.46 — calibrage serveur du compteur de session
const SESSION_SYNC_INTERVAL_MS = 90 * 1000;  // recalage périodique
const SESSION_SYNC_MIN_GAP_MS = 60 * 1000;   // throttle entre deux recalages
const SESSION_WARN_THRESHOLD_MS = 5 * 60 * 1000;  // 5 min → affichage compteur
const SESSION_CRITICAL_THRESHOLD_MS = 2 * 60 * 1000;  // 2 min → rouge + modal

// v5.0.11 : timeout de la reconnexion. Si l'user n'est pas reconnecté
// dans ce délai, on bascule en état "Reconnexion échouée" avec choix du réseau.
const RECONNECT_TIMEOUT_MS = 90 * 1000;  // 90 sec

// Tracking des iv déplacées vers une autre date.
// EasyVista a un cache serveur qui peut continuer à retourner l'iv pour la
// date d'origine pendant quelques secondes après le drag&drop. Pour éviter
// que l'iv ré-apparaisse en boucle sur l'ancien jour pendant ce délai, on
// la marque ici et on la filtre du fresh tant que la fenêtre est active.
// Map<actionId, { fromDate, toDate, ts }>
const _recentlyMovedAway = new Map();
const _RECENT_MOVE_TTL_MS = 60 * 1000;

function _registerRecentMove(actionId, fromDate, toDate) {
  if (!actionId || !fromDate || !toDate || fromDate === toDate) return;
  _recentlyMovedAway.set(String(actionId), { fromDate, toDate, ts: Date.now() });
}

// v2026.5.46 — l'iv vient-elle d'être déplacée HORS de cette date ?
// Utilisé comme garde d'INGESTION (storeApplyFresh n'ingère pas sa fausse
// présence resservie par le cache serveur EV) et comme filtre d'AFFICHAGE
// (storeProject). Purge automatique de la fenêtre TTL au passage ; arriver
// sur la date CIBLE annule la fenêtre (l'iv y est légitime).
function _recentlyMovedAwayCovers(actionId, currentDate) {
  if (!_recentlyMovedAway.size || actionId === undefined || actionId === null) return false;
  const now = Date.now();
  for (const [k, e] of _recentlyMovedAway) {
    if (now - e.ts > _RECENT_MOVE_TTL_MS) _recentlyMovedAway.delete(k);
    else if (e.toDate === currentDate) _recentlyMovedAway.delete(k);
  }
  const e = _recentlyMovedAway.get(String(actionId));
  return !!(e && e.fromDate === currentDate);
}

// ─── Annulation coopérative d'un refresh manuel (v3.1) ──────────────────────
// Chaque refresh reçoit un "jeton" (entier incrémenté). Les workers lisent
// isRefreshAborted() avant chaque fetch : si le jeton a changé ou si
// l'utilisateur a cliqué sur "Arrêter", ils s'arrêtent proprement.
//
// v3.2 : on ajoute une "abortPromise" par refresh. loadForDate race cette
// promesse avec son Promise.all, donc dès qu'on clique Arrêter, loadForDate
// sort immédiatement (masque le bouton, fait un toast), même si les fetches
// en cours continuent silencieusement. Le changement de token les rend
// inoffensifs (ils ne peuvent plus écrire le cache ni updater le DOM).
let currentRefreshToken = 0;
let abortedToken = -1;
let abortResolvers = new Map(); // token → resolve fn of the abort promise

function startNewRefresh() {
  currentRefreshToken++;
  return currentRefreshToken;
}
function abortCurrentRefresh() {
  // v2026.5.46 — « Arrêter » vise le pipeline EN COURS (propriétaire du
  // bouton) et LUI SEUL : sans pipeline actif il n'y a rien à annuler, et une
  // navigation encore pré-pipeline (jeton pris à l'entrée) survit toujours —
  // elle affichera son jour.
  if (_loadPipelineToken !== null) abortedToken = _loadPipelineToken;
  // Réveiller tous les loadForDate en attente (normalement un seul)
  for (const [token, resolve] of abortResolvers) {
    if (token <= currentRefreshToken) {
      resolve("aborted");
      abortResolvers.delete(token);
    }
  }
  // tuer toutes les requêtes EV en vol côté background pour que
  // rien ne continue en arrière-plan. fire-and-forget.
  try {
    sendMessage({ type: "abortAllFetches" }).catch(() => {});
  } catch (e) { /* ignore */ }
  // retirer l'animation "en cours" sur toutes les iv en analyse (le verdict,
  // lui, reste le dernier connu — l'analyse sera retentée au prochain refresh)
  if (state.currentData && state.currentData.techs) {
    for (const tech of state.currentData.techs) {
      for (const iv of tech.interventions || []) {
        if (iv._analyzing) {
          iv._analyzing = false;
          try { updateInterventionRow(iv); } catch (e) { /* ignore */ }
        }
      }
    }
  }
}
// v4.1.9 : isRefreshAborted(myToken) retourne true si :
//  - un nouveau refresh a été lancé (currentRefreshToken > myToken), OU
//  - l'utilisateur a explicitement cliqué "Arrêter" (abortedToken).
// Sans myToken fourni (compat), on ne teste que l'abort explicite.
function isRefreshAborted(myToken) {
  if (typeof myToken !== "number") return abortedToken === currentRefreshToken;
  if (abortedToken === myToken) return true;       // « Arrêter » a visé CE flux
  if (myToken < currentRefreshToken) return true;  // un flux plus récent existe
  return false;
}
function cleanupAbortResolver(myToken) {
  abortResolvers.delete(myToken);
}

// ============================================================================
// Boot
// ============================================================================

document.addEventListener("DOMContentLoaded", init);

async function init() {
  // v2026.5.46 — onglet dédié "Mes actions" : viewer.html?view=myactions
  // affiche la page-liste (rendue par l'extension) au lieu du planning.
  try {
    if (new URLSearchParams(location.search).get("view") === "myactions") {
      await initMyActionsPage();
      return;
    }
  } catch (e) { /* pas de URLSearchParams → boot planning normal */ }
  await initTheme();
  // v2026.5.46 — hygiène du store au boot : purge unique des clés de
  // l'ANCIEN format (planning_cache_*, libère le quota) + purge des jours v2
  // plus vieux que cfg.cacheDays (le réglage est enfin appliqué réellement,
  // plus seulement quand le quota déborde). Non bloquant.
  storePurgeLegacy().then(() => storePurgeOldDays()).catch(() => {});
  // v2026.5.46 — charger la meta persistante des réservations (n°/adresse/type).
  await loadResMetaStore();
  // v2026.5.46 — charger les assignations pompier (affichées dans les stats).
  await loadPompierAssignments();
  // v2026.5.39 : appliquer le zoom texte enregistré dès le boot, avant que
  // le DOM ne soit affiché (sinon "flash" à la taille par défaut).
  _initTextZoomFromConfig();
  // appliquer la couleur + police de la topbar enregistrées.
  _initTopbarStyleFromConfig();
  // exposer la hauteur réelle de la topbar (sticky) en variable CSS.
  _initTopbarHeightVar();
  // surveille les redim. → re-trim les gaps mini si une iv tronque
  _attachMiniGapsResizeWatcher();
  // v2026.5.45 (issue #3) : si on vient de faire une mise à jour depuis
  // une version qui avait le bug structurel d'écrasement des absences
  // récurrentes, prévenir l'utilisateur via toast. Une seule fois.
  _checkInstallEventAndNotify();
  // v2026.5.45 (issue #4) : écouter les changements de cookie EZV
  // broadcastés par background.js (si la permission "cookies" est accordée).
  _attachCookieChangeListener();
  // v2026.5.39 : lire les heures de la journée depuis admin_config (8-18 défaut).
  await _initDayBoundsFromConfig();
  // v2026.5.41 : charger l'équipe et les absences récurrentes depuis admin_config.
  // Avant ce point, TEAM = {} → aucun fetch ne tournera tant que la config
  // n'est pas chargée. Si l'utilisateur n'a rien configuré, le fetch retournera
  // l'erreur "no_team_configured" qui invite à ouvrir les paramètres.
  await _initTeamFromConfig();
  bindTopbar();
  bindTooltipInteractions();
  initModalScrollLock();  // v4.2.9 : bloquer le scroll arrière quand modal
  initAppFooter();        // v4.2.9 : pied de page discret bas-droite
  initAppClock();         // v5.0.0 : horloge HH:MM au milieu topbar
  _applyViewMode();       // v2026.5.32 : appliquer la vue sauvegardée
  initSessionTimer();     // v5.0.9 : compteur de session EV (tick 1s)
  initDateCustomPicker(); // v2026.5.17 : faux input date avec jour
  _ivDockInit();          // dock latéral d'iv mises de côté

  // Initialiser la date = aujourd'hui
  state.currentDate = todayISO();
  document.getElementById("date-picker").value = state.currentDate;
  updateDatePickerDayLabel(state.currentDate);  // v2026.5.16 : label "Mardi"

  // v5.0.11 : détecter le contexte réseau en arrière-plan (non bloquant)
  detectNetworkContextAsync();

  // Charger la sesson puis le planning
  await refreshSessionAndLoad();
}

/**
 * v5.0.11 : détecte si on est en interne (bureau VPN) ou externe (télétravail),
 * de manière asynchrone au démarrage. Résultat utilisé pour choisir le bon
 * domaine lors de la reconnexion.
 */
async function detectNetworkContextAsync(force = false) {
  try {
    const resp = await sendMessage({ type: "detectNetwork", force });
    if (resp && resp.ok) {
      const wasInternal = state.networkContext === "internal";
      state.networkContext = resp.context;
      // Si on n'a pas encore de lastKnownOrigin, on prend celui du contexte détecté
      if (!state.lastKnownOrigin) {
        state.lastKnownOrigin = resp.origin;
      }
      LOG.info("viewer", `réseau détecté : ${resp.context} → ${resp.origin}`);
      // v2026.5.46 — passage (ou confirmation) en INTERNE → on (re)lance la
      // synchro dossier pour la date affichée, ce qui relance le host natif s'il
      // était éteint. En externe, storeSyncFolder ne fait rien.
      if (resp.context === "internal" && !wasInternal && state.currentDate) {
        reconcileCacheForDate(state.currentDate).catch(() => {});
      }
    }
  } catch (e) {
    LOG.warn("viewer", "détection réseau échouée", e);
  }
}

async function refreshSessionAndLoad() {
  const resp = await sendMessage({ type: "getSession" });
  if (!resp.ok || !resp.session) {
    // si un store existe pour le jour demandé, on l'affiche avec une
    // bannière "session expirée" sticky au-dessus. Sinon écran plein.
    const dateAuLancement = state.currentDate;
    const day = await storeLoad(dateAuLancement);
    // v2026.5.46 — l'utilisateur a pu naviguer pendant la lecture du store
    // (boot sans session) : si la date affichée a changé entre-temps, on ne
    // touche ni l'état ni l'écran (sinon les données du jour lu seraient
    // affichées sous l'étiquette du nouveau jour).
    if (state.currentDate !== dateAuLancement) return;
    if (day) {
      state.currentDay = day;
      renderFromData({
        techs: storeProject(day, state.currentDate),
        targetDate: state.currentDate,
        captureTime: day.savedAt || null,
        source: "store"
      });
      showSessionExpiredBanner();
    } else {
      showSessionNeeded();
    }
    return;
  }
  state.session = resp.session;
  // v5.0.10 : mémoriser l'origine courante pour la reconnexion si besoin
  if (resp.session && resp.session.origin) {
    state.lastKnownOrigin = resp.session.origin;
  }
  hideSessionNeeded();
  hideEvUnreachable();
  hideSessionExpiredBanner();
  hideEvUnreachableBanner();
  state.sessionExpired = false;
  state.reconnecting = false;
  fetchAndShowCurrentUser();
  // v5.0.9 : à chaque démarrage/reconnexion, on suppose que la session vient
  // d'être rafraîchie à 30 min. updateSessionIndicator va masquer le compteur.
  markSessionActivity();
  await loadForDate(state.currentDate);
}

/**
 * v5.0.9 : doit être appelée à chaque requête EasyVista réussie. Reset le
 * timer local à 30 min (la session serveur a été renouvelée implicitement).
 */
function markSessionActivity() {
  state.sessionExpireAt = Date.now() + SESSION_DURATION_MS;
  state.sessionPingDone = false;  // reset le flag de ping
  updateSessionIndicator();
}

// v4.2 : fetche l'utilisateur EasyVista connecté (via background.js) et
// l'affiche dans la topbar.
// v2026.5.26 : en cas d'échec, affiche un rond gris "?" + retry 60s (max 10 essais).
// v2026.5.34 : le badge est maintenant TOUJOURS visible (état "?" par défaut
//              dans le HTML). Cette fonction met à jour le contenu (initiales
//              quand succès, "?" quand échec). Logs abondants pour debug.
//
// État initial (HTML) : <button class="user-badge user-badge-unknown">?</button>
// État succès          : initiales calculées + couleur dérivée du nom
// État échec           : "?" + couleur grise (classe user-badge-unknown)
//
// Retry : 10 tentatives espacées de 60s (10 min max), arrêt au 1er succès.
let _currentUserRetryCount = 0;
const _CURRENT_USER_MAX_RETRIES = 10;
const _CURRENT_USER_RETRY_DELAY_MS = 60 * 1000;

/**
 * Récupère le nom de l'utilisateur EasyVista connecté et l'affiche dans le badge.
 *
 * @author Quentin Rouiller
 */
async function fetchAndShowCurrentUser() {
  const attemptId = _currentUserRetryCount + 1;
  LOG.info("currentUser", `tentative ${attemptId}/${_CURRENT_USER_MAX_RETRIES + 1} de fetchCurrentUser`);

  const badge = document.getElementById("user-badge");
  if (!badge) {
    // Fallback défensif : pas de badge dans le DOM ? On log et on abandonne.
    LOG.warn("currentUser", "badge DOM introuvable — abandon");
    return;
  }

  let success = false;
  let errorReason = null;

  try {
    const resp = await sendMessage({ type: "fetchCurrentUser" });
    LOG.info("currentUser", "réponse reçue :", resp ? JSON.stringify(resp).substring(0, 200) : "(null)");

    if (!resp) {
      errorReason = "response_null";
    } else if (!resp.ok) {
      errorReason = resp.error || "ok_false";
    } else if (!resp.user) {
      errorReason = "user_null";
    } else {
      const fullName = resp.user.name || resp.user.login || null;
      if (!fullName) {
        errorReason = "name_empty";
      } else {
        // Succès : mise à jour du badge
        const initials = computeUserInitials(fullName);
        LOG.info("currentUser", `SUCCÈS : "${fullName}" → initiales "${initials}"`);
        badge.textContent = initials;
        badge.title = fullName;
        badge.style.setProperty("--user-badge-color", colorFromName(fullName));
        badge.classList.remove("user-badge-unknown");
        // On retire aussi "hidden" au cas où (compat ancienne version)
        badge.classList.remove("hidden");
        state.currentUser = resp.user;
        const wasPending = state.sessionPending;
        state.sessionPending = false;  // session définitive → polling peut s'arrêter
        success = true;
        _currentUserRetryCount = 0;  // reset compteur au succès
        // Si on était en attente d'auth définitive (page login SSO), le
        // planning n'a pas encore été chargé avec la vraie session — on
        // relance maintenant qu'on a un user valide.
        if (wasPending && typeof loadForDate === "function") {
          loadForDate(state.currentDate, { forceRefetch: true }).catch(() => {});
        }
      }
    }
  } catch (err) {
    errorReason = "exception: " + String(err);
    LOG.warn("currentUser", "exception durant sendMessage :", err);
  }

  if (success) return;

  // Échec : on laisse le badge en état "inconnu" (déjà le cas par défaut)
  // et on schedule un retry.
  LOG.warn("currentUser", `échec (raison: ${errorReason}) — badge reste en état "?"`);

  // user_null = page de login SSO intermédiaire → on a un cookie PHPSESSID
  // mais pas la vraie session définitive. On flag pour que le polling 2s
  // continue à surveiller le PHPSESSID (qui changera quand l'auth termine).
  if (errorReason === "user_null") {
    state.sessionPending = true;
  }

  // Défense : s'assurer que le badge est bien en état inconnu (au cas où
  // une mise à jour partielle a eu lieu puis échoué).
  badge.textContent = "?";
  badge.title = "Utilisateur — cliquer pour accéder aux paramètres";
  badge.style.setProperty("--user-badge-color", "#6b7280");
  badge.classList.add("user-badge-unknown");
  badge.classList.remove("hidden");

  // Schedule retry si pas trop d'essais
  if (_currentUserRetryCount < _CURRENT_USER_MAX_RETRIES) {
    _currentUserRetryCount++;
    LOG.info("currentUser", `retry programmé : ${_currentUserRetryCount}/${_CURRENT_USER_MAX_RETRIES} dans ${_CURRENT_USER_RETRY_DELAY_MS / 1000}s`);
    setTimeout(() => {
      fetchAndShowCurrentUser();
    }, _CURRENT_USER_RETRY_DELAY_MS);
  } else {
    LOG.warn("currentUser", "max retries atteint, arrêt du retry automatique. Le badge reste cliquable (Paramètres accessible).");
  }
}

/**
 * v2026.5.34 : déclenche un fetchAndShowCurrentUser() SI le user n'est pas
 * encore connu (badge en état "?"). Appelée après chaque succès de planning
 * pour profiter d'une session EV valide sans attendre le retry de 60s.
 *
 * Sans effet si :
 *  - state.currentUser est déjà renseigné (pas besoin de re-fetcher)
 *  - un retry est déjà en cours (évite les doublons)
 *
 * @param {string} reason - contexte pour les logs (ex: "after_load_success")
 *
 * @author Quentin Rouiller
 */
function _maybeRetryFetchUser(reason) {
  if (state.currentUser && state.currentUser.name) {
    // User déjà connu, rien à faire
    return;
  }
  const badge = document.getElementById("user-badge");
  if (badge && !badge.classList.contains("user-badge-unknown")) {
    // Badge n'est pas en état inconnu → user probablement connu par un autre chemin
    return;
  }
  LOG.info("currentUser", `relance opportuniste (raison: ${reason}) — user encore inconnu`);
  // Reset le compteur puisqu'on a un nouveau contexte (session fraîche)
  _currentUserRetryCount = 0;
  fetchAndShowCurrentUser();
}

// v4.2.3 : calcule les initiales depuis un nom au format "Nom, Prénom" ou
// "Nom Prénom" ou "Prénom Nom". On prend la 1re lettre majuscule de chaque
// mot/segment significatif, limité à 2 caractères.
function computeUserInitials(fullName) {
  if (!fullName) return "?";
  // Format "Nom, Prénom" → prendre initiale avant virgule et après
  let parts;
  if (fullName.includes(",")) {
    parts = fullName.split(",").map(s => s.trim()).filter(Boolean);
  } else {
    parts = fullName.split(/\s+/).filter(Boolean);
  }
  const letters = parts
    .map(p => p.charAt(0))
    .filter(c => /[A-Za-zÀ-ÿ]/.test(c))
    .slice(0, 2)
    .join("")
    .toUpperCase();
  return letters || (fullName.charAt(0).toUpperCase() || "?");
}

// v4.2.3 : couleur déterministe à partir du nom. Palette neutre et sobre
// (tons tamisés), compatible avec les thèmes clair et sombre de l'extension.
function colorFromName(name) {
  // Hash simple (djb2) pour dériver un index stable
  let h = 5381;
  for (let i = 0; i < name.length; i++) {
    h = ((h << 5) + h + name.charCodeAt(i)) & 0xffffffff;
  }
  const palette = [
    "#5b6372", // gris bleuté
    "#6b7280", // gris neutre
    "#4a5568", // ardoise
    "#3b5a72", // bleu profond tamisé
    "#4f6a5e", // vert sauge sombre
    "#6b5a4f", // brun taupe
    "#5d4a6b", // prune sombre
    "#6a5a3a", // kaki bronze
    "#3a5a5e", // sarcelle sombre
    "#6c5c67"  // mauve grisé
  ];
  return palette[Math.abs(h) % palette.length];
}

// v4.2.3 : affiche/masque la popup nom complet sous la pastille
function toggleUserNamePopup() {
  const badge = document.getElementById("user-badge");
  const popup = document.getElementById("user-name-popup");
  if (!badge || !popup) return;
  if (!popup.classList.contains("hidden")) {
    hideUserNamePopup();
    return;
  }

  // v2026.5.17 : afficher aussi le temps restant de la session (MM:SS) avec
  // une couleur qui dépend du seuil (vert/jaune/rouge).
  // v2026.5.26 : si user inconnu, afficher "Utilisateur inconnu" + retry + réglages
  popup.innerHTML = "";
  const nameEl = document.createElement("div");
  nameEl.className = "user-name-popup-name";
  if (state.currentUser && state.currentUser.name) {
    nameEl.textContent = state.currentUser.name;
  } else {
    nameEl.textContent = "Utilisateur inconnu";
    nameEl.style.fontStyle = "italic";
    nameEl.style.color = "var(--text-muted)";
  }
  popup.appendChild(nameEl);

  const sessEl = document.createElement("div");
  sessEl.className = "user-name-popup-session";
  sessEl.id = "user-name-popup-session";
  _renderUserPopupSessionLine(sessEl);
  popup.appendChild(sessEl);

  // v2026.5.46 — le popup devient le panneau de contrôle de la session :
  // ligne « Connexion » (domaine actif) + bouton Prolonger toujours accessible
  // (avant : uniquement dans le chip d'alerte < 5 min).
  const connEl = document.createElement("div");
  connEl.className = "user-name-popup-conn";
  connEl.id = "user-name-popup-conn";
  _renderUserPopupConnLine(connEl);
  popup.appendChild(connEl);

  const extendPopupBtn = document.createElement("button");
  extendPopupBtn.type = "button";
  extendPopupBtn.className = "user-name-popup-settings";
  const _extendHtml = '<span class="settings-ico">🔄</span> Prolonger la session (30 min)';
  extendPopupBtn.innerHTML = _extendHtml;
  extendPopupBtn.title = "Remet le compteur de session EasyVista à 30 minutes";
  extendPopupBtn.addEventListener("click", () => _sessionExtend(extendPopupBtn, _extendHtml));
  popup.appendChild(extendPopupBtn);

  // v2026.5.25 : bouton Paramètres (remplace les 5 clics sur le titre)
  // v2026.5.32 : bouton "Vue" pour basculer Vue classique ↔ Vue horizontale
  // v2026.5.39 r7 : on affiche la vue de DESTINATION (pas la vue actuelle),
  // et le logo s'adapte pour visualiser comment seront affichées les
  // interventions après clic.
  //   - en classique : on propose Horizontale + logo "rangées" (≡)
  //   - en horizontal : on propose Classique + logo "grille" (⊞)
  const viewBtn = document.createElement("button");
  viewBtn.type = "button";
  viewBtn.className = "user-name-popup-settings";
  const currentView = _getCurrentView();
  if (currentView === "horizontal") {
    viewBtn.innerHTML = '<span class="settings-ico">⊞</span> Passer en vue Classique';
  } else {
    viewBtn.innerHTML = '<span class="settings-ico">≡</span> Passer en vue Horizontale';
  }
  viewBtn.title = "Bascule entre vue classique (cards en grille) et vue horizontale (1 ligne par tech)";
  viewBtn.addEventListener("click", (e) => {
    e.stopPropagation();
    hideUserNamePopup();
    _toggleView();
  });
  popup.appendChild(viewBtn);

  const settingsBtn = document.createElement("button");
  settingsBtn.type = "button";
  settingsBtn.className = "user-name-popup-settings";
  settingsBtn.innerHTML = '<span class="settings-ico">⚙</span> Paramètres';
  settingsBtn.title = "Ouvrir les paramètres d'administration";
  settingsBtn.addEventListener("click", (e) => {
    e.stopPropagation();
    hideUserNamePopup();
    if (typeof showAdminPanel === "function") {
      showAdminPanel();
    }
  });
  popup.appendChild(settingsBtn);

  // v2026.5.38 : signature auteur en bas du popup user-badge
  // Style : même look que le footer "QRO/vX.Y.Z" en bas à droite — petit,
  // gris atténué, séparé par une fine ligne supérieure.
  const authorLine = document.createElement("div");
  authorLine.className = "user-name-popup-author";
  authorLine.textContent = "Développé par Quentin Rouiller";
  authorLine.title = "Auteur de l'extension";
  popup.appendChild(authorLine);

  popup.classList.remove("hidden");
  badge.classList.add("open");
  // Positionne juste en dessous de la pastille
  const r = badge.getBoundingClientRect();
  popup.style.left = Math.max(8, r.left) + "px";
  popup.style.top = (r.bottom + 6) + "px";
}
function hideUserNamePopup() {
  const popup = document.getElementById("user-name-popup");
  const badge = document.getElementById("user-badge");
  if (popup) popup.classList.add("hidden");
  if (badge) badge.classList.remove("open");
}

// v2026.5.17 : remplit la ligne "Session : MM:SS" avec couleur selon seuil.
// Recalcule à chaque appel — appelée aussi par le tick session pour rafraîchir.
function _renderUserPopupSessionLine(el) {
  if (!el) return;
  // v2026.5.46 — état expiré affiché explicitement dans le popup.
  if (state.sessionExpired) {
    el.textContent = "Session : expirée";
    el.className = "user-name-popup-session session-critical";
    return;
  }
  const remainingMs = _getSessionRemainingMs();
  if (remainingMs == null) {
    el.textContent = "Session : —";
    el.className = "user-name-popup-session";
    return;
  }
  const mins = Math.floor(remainingMs / 60000);
  const secs = Math.floor((remainingMs % 60000) / 1000);
  const txt = `Session : ${String(mins).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
  el.textContent = txt;
  el.className = "user-name-popup-session";
  if (remainingMs <= SESSION_CRITICAL_THRESHOLD_MS) {
    el.classList.add("session-critical");
  } else if (remainingMs <= SESSION_WARN_THRESHOLD_MS) {
    el.classList.add("session-warn");
  } else {
    el.classList.add("session-ok");
  }
}

// v2026.5.17 : récupère en ms le temps restant avant expiration de la session.
// Retourne null si on ne connaît pas encore (pas de session ouverte).
function _getSessionRemainingMs() {
  if (!state.sessionExpireAt) return null;
  const remaining = state.sessionExpireAt - Date.now();
  return remaining > 0 ? remaining : 0;
}

// v2026.5.46 — calibrage du compteur local sur le SERVEUR (timeout_ajax
// session_time, le même endpoint qu'EV utilise pour sa propre modal de
// timeout : il ne prolonge pas la session). Throttle interne 60 s sauf force.
let _sessionSyncLast = 0;
let _sessionSyncInFlight = false;
async function _sessionServerSync(opts) {
  const force = !!(opts && opts.force);
  if (_sessionSyncInFlight) return false;
  if (!force && Date.now() - _sessionSyncLast < SESSION_SYNC_MIN_GAP_MS) return false;
  if (state.sessionExpired || state.reconnecting) return false;
  _sessionSyncInFlight = true;
  try {
    const resp = await sendMessage({ type: "getSessionRemaining" });
    _sessionSyncLast = Date.now();
    if (resp && resp.ok && typeof resp.remainingMs === "number") {
      const drift = state.sessionExpireAt ? (state.sessionExpireAt - (Date.now() + resp.remainingMs)) : null;
      state.sessionExpireAt = Date.now() + resp.remainingMs;
      if (drift !== null && Math.abs(drift) > 30000) {
        LOG.info("session", "compteur recalé sur le serveur (dérive " + Math.round(drift / 1000) + "s)");
      }
      updateSessionIndicator();
      return true;
    }
    if (resp && resp.error === "session_expired") handleSessionExpired();
    return false;
  } catch (e) {
    return false;
  } finally {
    _sessionSyncInFlight = false;
  }
}

// v2026.5.46 — le compteur local atteint 0 : VERIFIER au serveur avant de
// declarer la session expiree (un onglet EV ouvert peut la maintenir vivante
// alors que notre hypothese locale 30 min est depassee).
// v2026.5.46 — l'expiration n'est déclarée QUE SUR PREUVE : réponse
// serveur « session_expired » (la sonde a reçu une page de login), temps
// restant nul, ou « no_session » (plus AUCUN PHPSESSID — ni onglet EV ni
// cookie : l'extension ne peut de toute façon plus rien fetcher). Une erreur
// TRANSITOIRE (réseau, HTTP 5xx, réponse invalide, messaging) ne bascule
// PLUS en « session expirée » : nouvel essai au plus tôt dans 30 s, le chip
// reste à 00:00 entre-temps (cf. updateSessionIndicator).
let _sessionExpireVerifying = false;
let _sessionExpireNextTryAt = 0;
async function _sessionExpireVerify() {
  if (_sessionExpireVerifying || state.sessionExpired) return;
  if (Date.now() < _sessionExpireNextTryAt) return;
  _sessionExpireVerifying = true;
  let verdict = "unknown";   // alive | dead | unknown
  let remainingMs = 0;
  try {
    const resp = await sendMessage({ type: "getSessionRemaining" });
    if (resp && resp.ok && typeof resp.remainingMs === "number") {
      if (resp.remainingMs > 1000) { verdict = "alive"; remainingMs = resp.remainingMs; }
      else verdict = "dead";
    } else if (resp && (resp.error === "session_expired" || resp.error === "no_session")) {
      verdict = "dead";
    }
  } catch (e) { /* messaging KO → verdict unknown */ }
  _sessionExpireVerifying = false;
  if (verdict === "alive") {
    state.sessionExpireAt = Date.now() + remainingMs;
    LOG.warn("session", "compteur local a 0 mais session serveur vivante (" +
      Math.round(remainingMs / 1000) + "s) → recalé, pas d'expiration");
    updateSessionIndicator();
    return;
  }
  if (verdict === "unknown") {
    _sessionExpireNextTryAt = Date.now() + 30000;
    LOG.warn("session", "compteur local a 0, vérification serveur impossible (transitoire) → nouvel essai dans 30 s, pas d'expiration");
    return;
  }
  handleSessionExpired();
}

// v2026.5.46 — prolongation de session factorisée (chip topbar + popup
// badge) : désactive le bouton, appelle keep_connection, recale le compteur.
async function _sessionExtend(btn, restoreHtml) {
  if (btn) { btn.disabled = true; btn.textContent = "…"; }
  try {
    const resp = await sendMessage({ type: "extendSession" });
    if (resp && resp.ok && typeof resp.remainingMs === "number") {
      state.sessionExpireAt = Date.now() + resp.remainingMs;
      state.sessionPingDone = false;
      showToast("Session prolongée", "30 minutes de plus");
    } else {
      throw new Error((resp && resp.error) || "erreur inconnue");
    }
  } catch (err) {
    if (err.message === "session_expired" || err.message === "no_session") {
      handleSessionExpired();
      return;
    }
    showToast("Prolongation impossible", err.message || "erreur");
  } finally {
    if (btn) { btn.disabled = false; if (restoreHtml) btn.innerHTML = restoreHtml; }
    updateSessionIndicator();
  }
}

// v2026.5.46 — ligne « Connexion » du popup badge : domaine EV actif.
function _renderUserPopupConnLine(el) {
  if (!el) return;
  const o = state.lastKnownOrigin || "";
  let txt = "Connexion : —";
  if (state.sessionExpired) txt = "Connexion : session à rétablir";
  else if (o.includes("etat-de-vaud")) txt = "Connexion : EasyVista interne (bureau)";
  else if (o.includes("itsma.vd.ch")) txt = "Connexion : EasyVista externe (télétravail)";
  el.textContent = txt;
}


// ============================================================================
// Thème clair/sombre
// ============================================================================

// v2026.5.41 : thème unifié sur admin_config.theme (chrome.storage.local).
// Le toggle topbar écrit dans la même clé que le select Apparence du panel,
// pour que les deux soient toujours en accord.
async function initTheme() {
  let pref = "auto";
  try {
    const cfg = await loadAdminConfig();
    if (cfg.theme === "light" || cfg.theme === "dark" || cfg.theme === "auto") {
      pref = cfg.theme;
    }
  } catch (e) {}
  _applyTheme(pref);
  _watchOsThemeChanges();
}

function detectDefaultTheme() {
  if (window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches) {
    return "dark";
  }
  return "light";
}

async function toggleTheme() {
  // L'effectif courant (light ou dark), même si pref="auto"
  const currentAttr = document.documentElement.getAttribute("data-theme");
  const effective = (currentAttr === "light" || currentAttr === "dark")
    ? currentAttr : detectDefaultTheme();
  const next = effective === "dark" ? "light" : "dark";
  _applyTheme(next);
  try {
    const cfg = await loadAdminConfig();
    cfg.theme = next;
    await saveAdminConfig(cfg);
  } catch (e) {
    LOG.warn("theme", "toggle save err", e);
  }
}

// ============================================================================
// Topbar handlers
// ============================================================================

function bindTopbar() {
  document.getElementById("theme-toggle").addEventListener("click", toggleTheme);
  // v4.1.10 : 2 boutons de rafraichissement.
  //  - refresh-btn (Total) : force le re-fetch de toutes les fiches (même celles
  //    déjà enrichies), utile pour voir les statuts évoluer.
  //  - refresh-partial-btn (Partiel) : re-fetch juste le XML planning pour
  //    détecter nouvelles/disparues interventions, mais ne refetch PAS les
  //    fiches déjà connues → rapide.
  document.getElementById("refresh-btn").addEventListener("click", () => {
    setActiveRefreshButton("total");
    refreshPlanning({ total: true });
  });
  const partialBtn = document.getElementById("refresh-partial-btn");
  if (partialBtn) {
    partialBtn.addEventListener("click", () => {
      setActiveRefreshButton("partial");
      refreshPlanning({ partial: true });
    });
  }
  document.getElementById("abort-btn").addEventListener("click", () => {
    // Feedback visuel instantané : masquer le bouton tout de suite, sans
    // attendre que loadForDate finisse sa race.
    showAbortButton(false);
    abortCurrentRefresh();
    showAbortToast();
  });
  document.getElementById("clear-cache-btn").addEventListener("click", onClearCache);

  // v4.2.6 : boutons Absence et Douchette
  // v2026.5.46 — bouton principal "Ajouter" → menu Réservation/Absence/Pompier.
  const addMenuBtn = document.getElementById("add-menu-btn");
  const addMenu = document.getElementById("add-menu");
  if (addMenuBtn && addMenu) {
    const addMenuWrap = document.getElementById("add-menu-wrap");
    // v2026.5.46 — rétablit le menu dans son conteneur (dé-portalise) + reset.
    const _restoreAddMenu = () => {
      addMenu.classList.remove("add-menu--right");
      addMenu.style.left = ""; addMenu.style.top = "";
      if (addMenuWrap && addMenu.parentNode !== addMenuWrap) addMenuWrap.appendChild(addMenu);
    };
    const closeAddMenu = () => {
      addMenu.classList.add("hidden");
      addMenuBtn.setAttribute("aria-expanded", "false");
      _restoreAddMenu();
    };
    addMenuBtn.addEventListener("click", (e) => {
      e.stopPropagation();
      const willOpen = addMenu.classList.contains("hidden");
      addMenuBtn.setAttribute("aria-expanded", willOpen ? "true" : "false");
      // v2026.5.46 — en vue horizontale (bouton dans la sidebar gauche),
      // on PORTALISE le menu dans <body> et on l'ouvre à DROITE du bouton, sinon
      // il est rogné/derrière les cartes (contexte d'empilement de la sidebar).
      const horiz = document.documentElement.classList.contains("view-horizontal");
      if (willOpen && horiz) {
        if (addMenu.parentNode !== document.body) document.body.appendChild(addMenu);
        const r = addMenuBtn.getBoundingClientRect();
        addMenu.classList.add("add-menu--right");
        addMenu.style.left = Math.round(r.right + 10) + "px";
        addMenu.style.top = Math.round(r.top) + "px";
        addMenu.classList.remove("hidden");
      } else if (willOpen) {
        _restoreAddMenu();
        addMenu.classList.remove("hidden");
      } else {
        closeAddMenu();
      }
    });
    // Clic ailleurs → fermer le menu (exclut le wrap ET le menu lui-même,
    // car portalisé dans <body> en vue horizontale).
    document.addEventListener("click", (e) => {
      if (!addMenu.classList.contains("hidden") && !e.target.closest("#add-menu-wrap") && !e.target.closest("#add-menu")) closeAddMenu();
    });
    const wire = (id, fn) => { const b = document.getElementById(id); if (b) b.addEventListener("click", () => { closeAddMenu(); fn(); }); };
    wire("add-menu-reservation", showReservationModal);
    wire("add-menu-absence", showAbsenceModal);
    wire("add-menu-pompier", showPompierModal);
  }
  const douchetteBtn = document.getElementById("douchette-btn");
  // v2026.5.46 — CORRECTIF : ne PAS passer le handler direct, sinon l'Event
  // arrive comme preselectTechId → hideList truthy → la liste des techniciens
  // était masquée dans la modal douchette.
  if (douchetteBtn) douchetteBtn.addEventListener("click", () => showDouchetteModal());

  document.getElementById("nav-prev").addEventListener("click", () => navigateDate(-1));
  document.getElementById("nav-next").addEventListener("click", () => navigateDate(+1));
  document.getElementById("nav-today").addEventListener("click", () => loadForDate(todayISO()));
  // clic sur le badge rouge "Auj. JJ.MM" → revient à aujourd'hui.
  const todayBadgeEl = document.getElementById("today-badge");
  if (todayBadgeEl) {
    todayBadgeEl.addEventListener("click", () => loadForDate(todayISO()));
  }

  document.getElementById("date-picker").addEventListener("change", (e) => {
    if (e.target.value) loadForDate(e.target.value);
  });

  // v4.2.3 : clic sur la pastille d'initiales → toggle popup nom complet
  const userBadge = document.getElementById("user-badge");
  if (userBadge) {
    userBadge.addEventListener("click", (e) => {
      e.stopPropagation();
      toggleUserNamePopup();
    });
  }
  // Clic ailleurs ou touche Escape ferme la popup user
  document.addEventListener("click", (e) => {
    const popup = document.getElementById("user-name-popup");
    if (popup && !popup.classList.contains("hidden")) {
      // Ne pas fermer si le clic est dans la popup elle-même ou sur le badge
      if (!e.target.closest("#user-name-popup") && !e.target.closest("#user-badge")) {
        hideUserNamePopup();
      }
    }
    // v4.2.4 : clic ailleurs ferme aussi la grande bulle d'interventoin
    // quand elle est ouverte via clic timeline (mode "anchored"). Clic sur
    // la bulle elle-même ou sur une timeline-slot ne ferme pas.
    const tip = tooltipEl();
    if (tip && tip.dataset.mode === "anchored" && tip.classList.contains("visible")) {
      if (!e.target.closest("#tooltip") && !e.target.closest(".timeline-slot")) {
        hideTooltip({ force: true });
      }
    }
  });
  // v2026.5.20 : nouveau comportement de la touche Échap
  //  - Appui court : ferme uniquement le popup SOUS la souris (normal ou
  //    minimisé). Si la souris n'est sur aucun popup, ne fait rien.
  //    Ferme aussi le popup user-badge et la grande bulle anchored.
  //  - Maintenu ≥ 3 secondes : ferme TOUS les popups flottants, mais garde
  //    les pastilles dock (popups "réduits" en bas).
  let _escHoldTimer = null;
  let _escHoldTriggered = false;
  const ESC_HOLD_MS = 3000;

  document.addEventListener("keydown", (e) => {
    if (e.key !== "Escape") return;
    // keydown peut se répéter si la touche est maintenue ; on ignore les répétitions.
    if (e.repeat) return;
    // Armer le timer "maintenu 3s"
    _escHoldTriggered = false;
    if (_escHoldTimer) clearTimeout(_escHoldTimer);
    _escHoldTimer = setTimeout(() => {
      _escHoldTriggered = true;
      _escHoldTimer = null;
      // Fermer TOUS les popups flottants (normaux + minimisés) mais pas les dockés
      document.querySelectorAll(".pinned-popup:not(.pinned-popup-reduced)").forEach(p => {
        try { p.remove(); } catch (err) {}
      });
      // Nettoyer la liste
      for (let i = pinnedPopups.length - 1; i >= 0; i--) {
        if (!document.body.contains(pinnedPopups[i].el)) {
          pinnedPopups.splice(i, 1);
        }
      }
      _ensureDockCloseAllBtn();
    }, ESC_HOLD_MS);
  });

  document.addEventListener("keyup", (e) => {
    if (e.key !== "Escape") return;
    if (_escHoldTimer) {
      clearTimeout(_escHoldTimer);
      _escHoldTimer = null;
    }
    if (_escHoldTriggered) {
      // On a déjà fait l'action "maintenu", ne rien faire de plus
      _escHoldTriggered = false;
      return;
    }
    // Appui court : fermer le popup sous la souris si applicable
    hideUserNamePopup();
    const tip = tooltipEl();
    if (tip && tip.dataset.mode === "anchored" && tip.classList.contains("visible")) {
      hideTooltip({ force: true });
    }
    // Quel popup est sous la souris ? Utiliser :hover pour détecter
    const hovered = document.querySelector(".pinned-popup:hover");
    if (hovered && !hovered.classList.contains("pinned-popup-reduced")) {
      // Retirer aussi de pinnedPopups
      const idx = pinnedPopups.findIndex(p => p.el === hovered);
      if (idx >= 0) pinnedPopups.splice(idx, 1);
      hovered.remove();
      _ensureDockCloseAllBtn();
    }
  });

  // v5.0.10 : clic "Ouvrir EasyVista" sur l'écran plein → déclenche la
  // reconnexion SSO + l'auto-reload du viewer dès que la nouvelle session
  // est détectée (au lieu d'ouvrir juste un onglet).
  document.getElementById("open-ev-btn").addEventListener("click", () => {
    triggerReconnect();
  });

  // v4.2 : écran "EasyVista inaccessible"
  const openEvBtn2 = document.getElementById("open-ev-btn-2");
  if (openEvBtn2) openEvBtn2.addEventListener("click", openEasyVista);
  const retryBtn = document.getElementById("retry-btn");
  if (retryBtn) retryBtn.addEventListener("click", async () => {
    hideEvUnreachable();
    document.getElementById("loading").classList.remove("hidden");
    await refreshSessionAndLoad();
  });

  // v4.1.12 : bindings bannière session expirée
  const reconnectBtn = document.getElementById("session-banner-reconnect");
  if (reconnectBtn) reconnectBtn.addEventListener("click", openEasyVista);
  const closeBtn = document.getElementById("session-banner-close");
  if (closeBtn) closeBtn.addEventListener("click", hideSessionExpiredBanner);

  // v4.2.5 : bindings bannière "EasyVista inaccessible"
  const evRetryBtn = document.getElementById("ev-unreachable-banner-retry");
  if (evRetryBtn) evRetryBtn.addEventListener("click", async () => {
    hideEvUnreachableBanner();
    await refreshSessionAndLoad();
  });
  const evOpenBtn = document.getElementById("ev-unreachable-banner-open");
  if (evOpenBtn) evOpenBtn.addEventListener("click", openEasyVista);
  const evCloseBtn = document.getElementById("ev-unreachable-banner-close");
  if (evCloseBtn) evCloseBtn.addEventListener("click", hideEvUnreachableBanner);
}

async function openEasyVista() {
  // v5.0.10 : ouvrir sur le domaine le plus approprié :
  //   - lastKnownOrigin si on a déjà eu une session fonctionnelle (respecte
  //     interne vs externe selon le réseau)
  //   - session.origin si on a encore la session
  //   - itsma.vd.ch en fallback (domaine externe accessible de partout,
  //     même depuis le réseau VD il redirige vers l'interne transparent)
  const origin = state.lastKnownOrigin
              || (state.session && state.session.origin)
              || "https://itsma.vd.ch";
  await chrome.tabs.create({ url: origin + "/" });
}

// Navigation ±1 jour en sautant les week-ends
function navigateDate(direction) {
  const d = isoToDate(state.currentDate);
  d.setDate(d.getDate() + direction);
  // Sauter les week-ends
  while (d.getDay() === 0 || d.getDay() === 6) {
    d.setDate(d.getDate() + direction);
  }
  loadForDate(dateToISO(d));
}

async function onClearCache() {
  // v4.1.20 : modal central avec 2 choix (jour / tout) + annuler
  showClearCacheModal();
}

// v4.1.20 : modal central de confirmation pour vider le cache. L'arrière-plan
// est flouté, l'utilisateur a deux choix explicites + Annuler.
function showClearCacheModal() {
  // Ne pas ouvrir 2x si déjà affiché
  if (document.getElementById("clear-cache-modal")) return;

  const dateTxt = formatDateDM(state.currentDate);

  const overlay = document.createElement("div");
  overlay.id = "clear-cache-modal";
  overlay.className = "modal-overlay";
  overlay.innerHTML = `
    <div class="modal-card" role="dialog" aria-labelledby="clear-cache-title">
      <h2 id="clear-cache-title" class="modal-title">Vider le cache</h2>
      <p class="modal-message">
        Le cache stocke les données des interventions pour éviter de
        re-télécharger à chaque ouverture. Que voulez-vous supprimer&nbsp;?
      </p>
      <div class="modal-actions">
        <button type="button" class="btn btn-modal-danger" data-action="clear-day">
          Vider le cache du ${dateTxt}
        </button>
        <button type="button" class="btn btn-modal-danger-strong" data-action="clear-all">
          Vider tout le cache
        </button>
        <button type="button" class="btn btn-modal-cancel" data-action="cancel">
          Annuler
        </button>
      </div>
    </div>
  `;
  document.body.appendChild(overlay);

  const close = () => {
    overlay.remove();
  };

  overlay.addEventListener("click", async (e) => {
    const action = e.target.closest("[data-action]")?.dataset.action;
    if (!action) {
      // Clic sur le fond (pas sur la carte) → fermer
      if (e.target === overlay) close();
      return;
    }
    if (action === "cancel") {
      close();
      return;
    }
    if (action === "clear-day") {
      close();
      await chrome.storage.local.remove(STORE_PREFIX + state.currentDate);
      state.currentDay = null;
      await loadForDate(state.currentDate, { forceRefetch: true });
      return;
    }
    if (action === "clear-all") {
      close();
      // Supprimer toutes les clés du store v2 (+ vieux planning_cache_* s'il en reste)
      const all = await chrome.storage.local.get(null);
      const toRemove = Object.keys(all).filter(k => k.startsWith(STORE_PREFIX) || k.startsWith(LEGACY_CACHE_PREFIX));
      if (toRemove.length) {
        await chrome.storage.local.remove(toRemove);
      }
      state.currentDay = null;
      await loadForDate(state.currentDate, { forceRefetch: true });
      return;
    }
  });

  // Échap ferme la modale
  const escHandler = (e) => {
    if (e.key === "Escape") {
      close();
      document.removeEventListener("keydown", escHandler);
    }
  };
  document.addEventListener("keydown", escHandler);
}

// ============================================================================
// v4.2.5 : modal d'alerte générique (session expirée / EV inaccessible /
// erreur d'ouverture). Remplace les alert() natives par une vraie popup
// avec flou autour, titre, message et boutons personnalisables.
// ============================================================================

/**
 * Affiche un modal d'alerte.
 * @param {Object} opts
 * @param {string} opts.title - Titre
 * @param {string} opts.message - Message (HTML autorisé si opts.html=true)
 * @param {boolean} [opts.html=false] - Si true, message interprété comme HTML
 * @param {Array<{label:string, variant:"primary"|"secondary"|"danger", action:(()=>void|Promise<void>)}>} opts.buttons
 *        Boutons (en bas du modal). Le 1er = focus par défaut.
 */
// ============================================================================
// notification dans le titre de l'onglet (tab title flip)
// ============================================================================
// Quand la session EasyVista va expirer, on alterne le titre de l'onglet
// entre "Planification" et "Planification" (toggle 700 ms) — visible
// dans la barre des onglets du navigateur même quand le tab n'est pas
// au premier plan, comme Gmail/Slack qui ajoutent "(3) " devant.
let _expirationTitleInterval = null;
let _expirationTitleTimeout = null;
let _expirationTitleOriginal = null;

function _setExpirationTitleNotice(active, durationMs) {
  if (_expirationTitleInterval) {
    clearInterval(_expirationTitleInterval);
    _expirationTitleInterval = null;
  }
  if (_expirationTitleTimeout) {
    clearTimeout(_expirationTitleTimeout);
    _expirationTitleTimeout = null;
  }
  // Restaure l'original si on en avait sauvegardé un.
  if (!active) {
    if (_expirationTitleOriginal != null) {
      try { document.title = _expirationTitleOriginal; } catch (e) {}
      _expirationTitleOriginal = null;
    }
    return;
  }
  _expirationTitleOriginal = document.title || "Planification";
  let on = true;
  const tick = () => {
    try {
      // remplacement complet du titre par un message d'alerte —
      // le mot change drastiquement entre les deux états, l'œil capte
      // beaucoup mieux le mouvement dans la barre d'onglets.
      document.title = on
        ? "🚨 SESSION EXPIRE 🚨"
        : _expirationTitleOriginal;
    } catch (e) {}
    on = !on;
  };
  tick();
  _expirationTitleInterval = setInterval(tick, 700);

  if (durationMs && durationMs > 0) {
    _expirationTitleTimeout = setTimeout(() => {
      _setExpirationTitleNotice(false);
    }, durationMs);
  }
}

function showAlertModal(opts) {
  // Si un alert modal est déjà affiché, l'enlever d'abord
  const existing = document.getElementById("alert-modal");
  if (existing) existing.remove();

  const overlay = document.createElement("div");
  overlay.id = "alert-modal";
  overlay.className = "modal-overlay";

  const card = document.createElement("div");
  card.className = "modal-card";
  card.setAttribute("role", "dialog");
  card.setAttribute("aria-labelledby", "alert-modal-title");

  const h = document.createElement("h2");
  h.id = "alert-modal-title";
  h.className = "modal-title";
  h.textContent = opts.title || "";
  card.appendChild(h);

  const p = document.createElement("p");
  p.className = "modal-message";
  if (opts.html) {
    p.innerHTML = opts.message || "";
  } else {
    p.textContent = opts.message || "";
  }
  card.appendChild(p);

  const actions = document.createElement("div");
  actions.className = "modal-actions";
  (opts.buttons || []).forEach((btn, i) => {
    const b = document.createElement("button");
    b.type = "button";
    b.className = "btn";
    if (btn.variant === "primary") b.classList.add("btn-modal-primary");
    else if (btn.variant === "danger") b.classList.add("btn-modal-danger-strong");
    else b.classList.add("btn-modal-cancel");
    b.textContent = btn.label;
    b.addEventListener("click", async () => {
      overlay.remove();
      if (typeof btn.action === "function") {
        try { await btn.action(); } catch (e) { LOG.exception("alert-modal", "action de bouton en échec", e); }
      }
    });
    actions.appendChild(b);
    if (i === 0) setTimeout(() => b.focus(), 50);
  });
  card.appendChild(actions);

  // opt-in pour injecter le sous-bandeau "Activer multi-onglets"
  // dans la modal — utilisé par les modals d'erreur fiche EZV pour que
  // l'utilisateur puisse activer la lecture du cookie sans naviguer
  // vers les paramètres.
  if (opts.injectCookiesPrompt && typeof _injectCookiesPromptInBanner === "function") {
    try { _injectCookiesPromptInBanner(card); } catch (e) {}
  }

  overlay.appendChild(card);
  document.body.appendChild(overlay);

  // Clic sur le fond (flou) → fermer
  overlay.addEventListener("click", (e) => {
    if (e.target === overlay) overlay.remove();
  });

  // Échap ferme la modale
  const escHandler = (e) => {
    if (e.key === "Escape") {
      overlay.remove();
      document.removeEventListener("keydown", escHandler);
    }
  };
  document.addEventListener("keydown", escHandler);
}

// ============================================================================
// v4.2.9 : blocage du scroll en arrière-plan quand un modal est ouvert
// ============================================================================
//
// Un MutationObserver surveille l'apparition/disparition de tout élément
// .modal-overlay dans le body. Dès qu'il y en a au moins un, on ajoute la
// classe `modal-open` sur body → CSS bloque le scroll. Quand le dernier
// modal disparaît, la classe est retirée.
//
// Centralisé ici pour que TOUS les modals (existants et futurs) en profitent
// sans modification individuelle.

function initModalScrollLock() {
  const updateLock = () => {
    const hasModal = document.querySelector(".modal-overlay") !== null;
    document.body.classList.toggle("modal-open", hasModal);
  };
  const observer = new MutationObserver(updateLock);
  observer.observe(document.body, { childList: true, subtree: false });
  updateLock();  // au cas où un modal serait déjà là au boot
}

// v4.2.9 : pied de page discret "QRO / vX.X.X" en bas à droite.
// La version est lue depuis le manifest (source unique de vérité).
/**
 * Pied de page discret bas-droite avec QRO et numéro de version.
 *
 * @author Quentin Rouiller
 */
function initAppFooter() {
  if (document.querySelector(".app-footer")) return;
  let version = "";
  try {
    const manifest = chrome && chrome.runtime && chrome.runtime.getManifest
      ? chrome.runtime.getManifest() : null;
    if (manifest && manifest.version) version = "v" + manifest.version;
  } catch (e) {
    LOG.warn("footer", "getManifest indispo (mode dégradé sans version)", { err: e && e.message });
  }
  const el = document.createElement("div");
  el.className = "app-footer";
  el.textContent = `QRO${version ? " / " + version : ""}`;
  document.body.appendChild(el);
}

// v2026.5.32 : bascule entre Vue classique (cards) et Vue horizontale (rows)
// Persisté dans localStorage (clé : "view_mode"). Défaut : "classic".
const VIEW_MODE_KEY = "view_mode";

function _getCurrentView() {
  try {
    const v = localStorage.getItem(VIEW_MODE_KEY);
    return v === "horizontal" ? "horizontal" : "classic";
  } catch (e) {
    return "classic";
  }
}

function _setCurrentView(mode) {
  try {
    localStorage.setItem(VIEW_MODE_KEY, mode === "horizontal" ? "horizontal" : "classic");
  } catch (e) {
    // localStorage peut être bloqué (mode privé Firefox, quota plein)
    LOG.warn("viewMode", "localStorage indispo, vue non persistée", { err: e && e.message });
  }
  _applyViewMode();
}

function _toggleView() {
  const current = _getCurrentView();
  const next = current === "horizontal" ? "classic" : "horizontal";
  _setCurrentView(next);
}

/**
 * v2026.5.36 : applique le mode de vue (classique/horizontal) en déplaçant
 * physiquement les éléments de la topbar vers/depuis une sidebar verticale
 * à gauche de l'écran.
 *
 * En vue horizontale :
 *   - Sidebar gauche verticale contenant (haut → bas) :
 *     · Navigation date (prev / date / next / aujourd'hui)
 *     · Horloge + date (compacte, une par ligne)
 *     · Info de synchro
 *     · Stats globales (interventions/techs/absents)
 *     · Boutons actions (Absence, Douchette, Actualiser, Tout recharger, Vider cache)
 *   - Topbar réduite à : user-badge + titre + theme-toggle
 *
 * En vue classique :
 *   - Tout est remis dans la topbar comme avant (topbar-left / topbar-right)
 *
 * On mémorise les parents d'origine sur chaque élément (data-orig-parent)
 * pour restaurer proprement en vue classique.
 *
 * v2026.5.38 : on ne log plus que les warnings (parent absent etc.) — les
 * logs verbeux étape par étape ont été retirés, ils polluaient la console
 * à chaque toggle.
 *
 * @author Quentin Rouiller
 */
function _applyViewMode() {
  const mode = _getCurrentView();

  // Mettre à jour la classe sur <html> pour les règles CSS
  document.documentElement.classList.remove("view-classic", "view-horizontal");
  document.documentElement.classList.add("view-" + mode);

  // Liste des IDs à déplacer entre topbar (classique) et sidebar (horizontal)
  // Ordre = ordre visuel dans la sidebar en mode horizontal (haut → bas)
  // v2026.5.37 : user-badge, app-title, theme-toggle déplacés aussi → la topbar
  //              devient vide en vue horizontale.
  // on déplace today-block comme un tout (qui contient nav-today +
  // app-clock). Ainsi, en sidebar, le bouton "Aujourd'hui" reste au-dessus
  // de la date+heure du jour, dans le même cadre, comme en vue classique.
  const ELEMENTS_TO_RELOCATE = [
    "user-badge",              // tout en haut de la sidebar
    "app-title",               // juste après user-badge
    "today-block",             // nav-today + app-clock, en bloc
    "date-nav",                // (pas un id mais une classe, traité à part)
    "capture-info",
    "stats",                   // conteneur stats globales (généré dynamiquement)
    "topline-coord",           // v2026.5.46 — bouton « Mes actions » coordinateur
    "add-menu-wrap",           // v2026.5.46 — bouton "Ajouter" + son menu
    "search-zone",             // v2026.5.46 — barre de recherche, entre "Ajouter" et "Actualiser"
    "douchette-btn",
    "refresh-partial-btn",
    "refresh-btn",
    "abort-btn",
    "clear-cache-btn",
    "theme-toggle"             // tout en bas de la sidebar
  ];

  if (mode === "horizontal") {
    _moveElementsToSidebar(ELEMENTS_TO_RELOCATE);
  } else {
    _restoreElementsToTopbar(ELEMENTS_TO_RELOCATE);
    // v2026.5.46 — garantir que la ligne stats+recherche est correctement
    // reconstituée en classique : stats ET search-zone DANS #topline, dans le
    // bon ordre (stats puis search). Le restore générique pouvait inverser
    // l'ordre / les sortir de #topline → la grille « stats à gauche / barre au
    // milieu » ne s'appliquait plus (ils s'empilaient).
    const _tl = document.getElementById("topline");
    const _st = document.getElementById("stats");
    const _sz = document.getElementById("search-zone");
    if (_tl && _st && _sz) {
      _tl.appendChild(_st);   // stats en 1er (col 1)
      _tl.appendChild(_sz);   // puis la recherche (col 2)
      // v2026.5.46 — le bouton coordinateur DOIT être ré-appendé EN DERNIER.
      // Sinon il reste 1er dans le DOM : la grille (auto-flow) place alors l'item
      // de colonne 3 en premier et POUSSE stats+recherche sur une 2e rangée
      // (la barre de recherche « tombait » sous la ligne). Ordre DOM = colonnes.
      const _co = document.getElementById("topline-coord");
      if (_co) _tl.appendChild(_co);   // col 3, à droite
    }
  }
  // recalage de l'empilement collant (topbar / bandeaux / ligne)
  if (typeof _srSyncStickyOffsets === "function") _srSyncStickyOffsets();

  // libellé complet "Aujourd'hui" partout (vue classique + horizontale).
  const navToday = document.getElementById("nav-today");
  if (navToday) {
    navToday.textContent = "Aujourd'hui";
  }

  // v2026.5.46 — en (re)passant en horizontal, la règle des heures du
  // mode exact devient visible : la caler sur la géométrie réelle.
  if (typeof _alignExactRuler === "function") {
    requestAnimationFrame(() => { _alignExactRuler(); if (typeof _layoutExactGrid === "function") _layoutExactGrid(); if (typeof updateNowLine === "function") updateNowLine(); });
  }
}

/**
 * v2026.5.36 : crée ou retrouve la sidebar, et y déplace les éléments listés.
 * Les éléments sont déplacés dans l'ordre du tableau.
 *
 * @author Quentin Rouiller
 */
function _moveElementsToSidebar(ids) {
  // Créer (ou retrouver) le wrapper qui contiendra sidebar + main côte à côte
  let wrapper = document.getElementById("horizontal-wrapper");
  const mainEl = document.getElementById("main");
  if (!wrapper) {
    wrapper = document.createElement("div");
    wrapper.id = "horizontal-wrapper";
    wrapper.className = "horizontal-wrapper";
    // Placer le wrapper à la place de <main>, puis mettre <main> DEDANS
    if (mainEl && mainEl.parentNode) {
      mainEl.parentNode.insertBefore(wrapper, mainEl);
      wrapper.appendChild(mainEl);
    } else {
      LOG.warn("viewMode", "<main> introuvable, wrapper ajouté à <body>");
      document.body.appendChild(wrapper);
    }
  }

  // Créer la sidebar si elle n'existe pas, et la mettre EN PREMIER dans le wrapper
  let sidebar = document.getElementById("horizontal-sidebar");
  if (!sidebar) {
    sidebar = document.createElement("aside");
    sidebar.id = "horizontal-sidebar";
    sidebar.className = "horizontal-sidebar";
    wrapper.insertBefore(sidebar, wrapper.firstChild);
  } else if (sidebar.parentNode !== wrapper) {
    // Sidebar existe ailleurs, on la remet dans le wrapper
    wrapper.insertBefore(sidebar, wrapper.firstChild);
  }

  // Traitement spécial : .date-nav (classe, pas id)
  // v2026.5.37 : en vue horizontale, on décompose .date-nav pour :
  //   - Mettre btn-today en haut
  //   - Intercaler app-clock entre btn-today et date-custom
  //   - Grouper les 2 flèches dans un wrapper #sidebar-arrows pour qu'elles
  //     soient côte à côte et même largeur
  const dateNav = document.querySelector(".date-nav");
  if (dateNav) {
    _memorizeOriginalParent(dateNav);
    sidebar.appendChild(dateNav);

    // Créer le wrapper des flèches si pas déjà fait, et y mettre prev + next
    let arrowsWrap = document.getElementById("sidebar-arrows");
    if (!arrowsWrap) {
      arrowsWrap = document.createElement("div");
      arrowsWrap.id = "sidebar-arrows";
      sidebar.appendChild(arrowsWrap);
    }
    const prevBtn = document.getElementById("nav-prev");
    const nextBtn = document.getElementById("nav-next");
    if (prevBtn && !arrowsWrap.contains(prevBtn)) {
      _memorizeOriginalParent(prevBtn);
      arrowsWrap.appendChild(prevBtn);
    }
    if (nextBtn && !arrowsWrap.contains(nextBtn)) {
      _memorizeOriginalParent(nextBtn);
      arrowsWrap.appendChild(nextBtn);
    }
  }

  // Pour chaque ID listé, trouver et déplacer
  for (const id of ids) {
    if (id === "date-nav") continue; // déjà traité
    const el = document.getElementById(id);
    if (!el) {
      continue;
    }
    _memorizeOriginalParent(el);
    sidebar.appendChild(el);
  }
}

/**
 * v2026.5.36 : restaure chaque élément à son parent d'origine (mémorisé dans
 * data-orig-parent). Utilisé quand on revient en vue classique.
 *
 * @author Quentin Rouiller
 */
function _restoreElementsToTopbar(ids) {
  // v2026.5.37 : d'abord remettre les flèches dans .date-nav (avant de
  // restaurer .date-nav à son parent d'origine), puis supprimer le wrapper
  // #sidebar-arrows.
  const dateNav = document.querySelector(".date-nav");
  const prevBtn = document.getElementById("nav-prev");
  const nextBtn = document.getElementById("nav-next");
  if (dateNav && prevBtn && !dateNav.contains(prevBtn)) {
    // Remettre prev en premier dans date-nav
    dateNav.insertBefore(prevBtn, dateNav.firstChild);
  }
  if (dateNav && nextBtn && !dateNav.contains(nextBtn)) {
    // Remettre next après date-custom-wrapper (position d'origine) :
    // l'ordre d'origine est [prev, date-custom-wrapper, next, today].
    const dateCustomWrap = dateNav.querySelector(".date-custom-wrapper");
    if (dateCustomWrap && dateCustomWrap.nextSibling) {
      dateNav.insertBefore(nextBtn, dateCustomWrap.nextSibling);
    } else {
      dateNav.appendChild(nextBtn);
    }
  }
  // Supprimer le wrapper des flèches (normalement vide maintenant)
  const arrowsWrap = document.getElementById("sidebar-arrows");
  if (arrowsWrap) {
    arrowsWrap.remove();
  }

  // Restaurer .date-nav à son parent d'origine
  if (dateNav) _restoreToOriginalParent(dateNav, ".date-nav");

  for (const id of ids) {
    if (id === "date-nav") continue;
    const el = document.getElementById(id);
    if (!el) continue;
    _restoreToOriginalParent(el, "#" + id);
  }

  // Supprimer la sidebar si elle existe et est vide
  const sidebar = document.getElementById("horizontal-sidebar");
  if (sidebar && sidebar.children.length === 0) {
    sidebar.remove();
  }

  // Sortir <main> du wrapper et supprimer le wrapper
  const wrapper = document.getElementById("horizontal-wrapper");
  if (wrapper) {
    const mainEl = wrapper.querySelector("#main");
    if (mainEl && wrapper.parentNode) {
      wrapper.parentNode.insertBefore(mainEl, wrapper);
    }
    wrapper.remove();
  }
}

function _memorizeOriginalParent(el) {
  if (el.dataset.origParent) return; // déjà mémorisé
  const parent = el.parentNode;
  if (!parent || !parent.id) {
    // Parent sans id : on mémorise par selector (parent tag + classes)
    let selector = parent.tagName.toLowerCase();
    if (parent.className) {
      const cls = parent.className.split(/\s+/)[0];
      if (cls) selector += "." + cls;
    }
    el.dataset.origParent = "SEL:" + selector;
  } else {
    el.dataset.origParent = "ID:" + parent.id;
  }
  // Mémoriser aussi l'index d'origine pour restaurer l'ordre
  const siblings = Array.from(parent.children);
  el.dataset.origIndex = String(siblings.indexOf(el));
}

function _restoreToOriginalParent(el, label) {
  const orig = el.dataset.origParent;
  if (!orig) {
    return;
  }
  let parent = null;
  if (orig.startsWith("ID:")) {
    parent = document.getElementById(orig.substring(3));
  } else if (orig.startsWith("SEL:")) {
    parent = document.querySelector(orig.substring(4));
  }
  if (!parent) {
    LOG.warn("viewMode", `parent d'origine pour ${label} introuvable (orig=${orig})`);
    return;
  }
  // Insérer à l'index d'origine si possible
  const idx = parseInt(el.dataset.origIndex || "0", 10);
  const refChild = parent.children[idx] || null;
  if (refChild && refChild !== el) {
    parent.insertBefore(el, refChild);
  } else {
    parent.appendChild(el);
  }
}

// v5.0.0 : horloge HH:MM au milieu de la topbar. Mise à jour toutes les 30s
// (les secondes ne sont pas affichées donc pas besoin d'un tick plus rapide).
// v2026.5.27 : date courte "Jeudi 23.04.26" sur la même ligne que l'heure,
// séparées par un gros point "•", même taille que l'heure.
/**
 * Horloge HH:MM au milieu de la topbar, mise à jour chaque minute (depuis v5.0.0).
 *
 * @author Quentin Rouiller
 */
function initAppClock() {
  const el = document.getElementById("app-clock");
  if (!el) return;
  const dateEl = document.getElementById("app-clock-date");
  const timeEl = document.getElementById("app-clock-time");

  const JOURS = ["Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"];

  let lastDateStr = "";
  const tick = () => {
    const d = new Date();
    const h = String(d.getHours()).padStart(2, "0");
    const m = String(d.getMinutes()).padStart(2, "0");
    const timeStr = `${h}:${m}`;
    if (timeEl) timeEl.textContent = timeStr;
    else el.textContent = timeStr;  // fallback si ancien markup

    // Date courte : "Jeudi 23.04.26"
    if (dateEl) {
      const jour = JOURS[d.getDay()];
      const dd = String(d.getDate()).padStart(2, "0");
      const mm = String(d.getMonth() + 1).padStart(2, "0");
      const yy = String(d.getFullYear()).slice(-2);
      const dateStr = `${jour} ${dd}.${mm}.${yy}`;
      if (dateStr !== lastDateStr) {
        dateEl.textContent = dateStr;
        lastDateStr = dateStr;
      }
    }
    // v5.0.0 : profite du tick pour mettre à jour la ligne rouge "now"
    updateNowLine();
  };
  tick();
  // Tick toutes les 30s : ça garantit une MAJ rapide au changement de min
  setInterval(tick, 30 * 1000);
}

// v2026.5.17 : met à jour le faux input date custom (ex: "Vendredi 24.04.2026")
// Remplace l'ancien updateDatePickerDayLabel. L'input date natif reste présent
// mais caché, et son onChange continue de déclencher le chargement.
const DAY_NAMES_FULL = ["Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"];
function updateDatePickerDayLabel(isoDate) {
  const el = document.getElementById("date-custom-label");
  const dateCustom = document.getElementById("date-custom");
  if (!el) return;
  if (!isoDate) {
    el.textContent = "";
    if (dateCustom) dateCustom.classList.remove("is-today");
    return;
  }
  try {
    const d = isoToDate(isoDate);
    const day = DAY_NAMES_FULL[d.getDay()];
    const dd = String(d.getDate()).padStart(2, "0");
    const mm = String(d.getMonth() + 1).padStart(2, "0");
    const yyyy = d.getFullYear();
    // libellé "Vendredi 24.04.2026" — couleur fixe désormais (la
    // personnalisation se fait sur toute la topbar via les paramètres).
    el.textContent = `${day} ${dd}.${mm}.${yyyy}`;
    const isToday = (isoDate === todayISO());
    if (dateCustom) dateCustom.classList.toggle("is-today", isToday);
  } catch (e) {
    el.textContent = "";
  }
}

// v2026.5.17 : brancher le faux input date — clic dessus ouvre le vrai input
// caché pour choisir une date.
function initDateCustomPicker() {
  const custom = document.getElementById("date-custom");
  const picker = document.getElementById("date-picker");
  if (!custom || !picker) return;
  const openPicker = () => {
    try {
      if (typeof picker.showPicker === "function") {
        picker.showPicker();
      } else {
        picker.focus();
        picker.click();
      }
    } catch (e) {
      picker.focus();
    }
  };
  custom.addEventListener("click", openPicker);
  custom.addEventListener("keydown", (e) => {
    if (e.key === "Enter" || e.key === " ") {
      e.preventDefault();
      openPicker();
    }
  });
}

// v5.0.0 : ligne verticale rouge "heure actuelle" sur la timeline, visible
// UNIQUEMENT quand on affiche aujourd'hui. Appelée au tick de l'horloge (30 s)
// ET, juste après chaque rendu/resize/bascule de vue (le rendu
// détruit la ligne avec #cards — le commentaire historique « cf renderFromData »
// décrivait un appel qui n'existait plus).
function updateNowLine() {
  const isToday = state.currentDate === todayISO();
  // Retirer toutes les lignes existantes d'abord
  document.querySelectorAll(".timeline-now-line").forEach(el => el.remove());
  if (!isToday) return;
  // Calculer la position en % sur la timeline (DAY_START à DAY_END)
  const now = new Date();
  const nowMin = now.getHours() * 60 + now.getMinutes();
  if (nowMin < DAY_START || nowMin > DAY_END) return; // hors plage affichée
  const pct = ((nowMin - DAY_START) / DAY_LEN) * 100;
  // Ajouter une ligne sur chaque barre timeline visible
  document.querySelectorAll(".timeline-bar").forEach(bar => {
    const line = document.createElement("div");
    line.className = "timeline-now-line";
    line.style.left = pct + "%";
    bar.appendChild(line);
  });
  // v2026.5.46 — mode exact. : UNE seule ligne continue, calée sur
  // la largeur réelle des bandes (alignement garanti). : saute les
  // absents. : plus de tête ni de trait sur la règle des heures — la
  // ligne démarre au haut des cartes.
  document.querySelectorAll(".exact-now-global, .exact-now-head").forEach(el => el.remove());
  const isExactHoriz = (typeof HORIZONTAL_EXACT_MODE !== "undefined") && HORIZONTAL_EXACT_MODE
    && document.documentElement.classList.contains("view-horizontal");
  if (isExactHoriz) {
    const container = document.getElementById("cards");
    const firstRow = container ? container.querySelector(".iv-exact-row") : null;
    if (container && firstRow) {
      const contRect = container.getBoundingClientRect();
      const rowRect = firstRow.getBoundingClientRect();
      if (rowRect.width > 0 && contRect.width > 0) {
        const x = (rowRect.left - contRect.left) + (pct / 100) * rowRect.width;
        const allCards = container.querySelectorAll(".card");
        const lastCard = allCards.length ? allCards[allCards.length - 1] : null;
        const bottomPx = lastCard
          ? (lastCard.offsetTop + lastCard.offsetHeight)
          : container.scrollHeight;
        // v2026.5.46 — la ligne du temps SAUTE les techs absents
        // (mêmes segments que les lignes d'heures).
        // v2026.5.46 — elle démarre AU HAUT DES CARTES : plus de point
        // ni de trait sur la règle des heures.
        const topPx = allCards.length ? allCards[0].offsetTop : 0;
        const segs = (typeof _exactAbsentSegments === "function")
          ? _exactAbsentSegments(container, topPx, Math.max(topPx, bottomPx))
          : [[topPx, Math.max(topPx, bottomPx)]];
        for (const [s, e] of segs) {
          if (e - s <= 0) continue;
          const line = document.createElement("div");
          line.className = "exact-now-global";
          line.style.left = Math.round(x) + "px";
          line.style.top = s + "px";
          line.style.height = (e - s) + "px";
          container.appendChild(line);
        }
        // v2026.5.46 — plus de tête sur la règle (retirée à la demande).
      }
    }
  }
}

// ============================================================================
// Surveillance du timeout de session EasyVista
// ============================================================================

/**
 * Vérifie si une nouvelle session EV est apparue (cookie PHPSESSID différent).
 * Cas couverts :
 *   1. Reconnexion volontaire (clic « Me reconnecter ») : state.reconnecting = true
 *   2. Reconnexion externe (user rouvre EV / SSO refait silencieusement) :
 *      state.sessionExpired = true, mais l'user n'a jamais cliqué sur le bouton
 *
 * Sans le cas 2, l'user devait recharger l'extension pour que le viewer voie
 * qu'il était à nouveau connecté (il restait bloqué sur la bannière « Session
 * expirée » tant qu'il ne cliquait pas).
 */
async function _checkForRestoredSession() {
  if (!state.reconnecting && !state.sessionExpired && !state.sessionPending) return;
  try {
    const resp = await sendMessage({ type: "getSession" });
    if (!resp || !resp.ok || !resp.session || !resp.session.phpsessid) return;
    const newId = resp.session.phpsessid;
    const oldPhpsessid = state.session ? state.session.phpsessid : null;
    if (newId === oldPhpsessid) return;

    // v2026.1.6 — QRO : anti-boucle « session SSO intermédiaire ». Un PHPSESSID
    // existe dans le cookie mais l'auth SSO n'a pas abouti → page de login,
    // planning vide → fetchPlanningForDate remet state.session = null → au tick
    // suivant ce MÊME PHPSESSID est revu comme « nouveau » (oldPhpsessid=null)
    // → relance toutes les 2 s à l'infini. On mémorise donc le PHPSESSID qui a
    // échoué et on ne le re-tente qu'après 30 s (un PHPSESSID DIFFÉRENT, lui,
    // est tenté immédiatement → vraie reconnexion détectée tout de suite).
    if (newId === state._failedRestoreId && (Date.now() - (state._failedRestoreAt || 0)) < 30000) return;

    LOG.info("session", "nouvelle session détectée :", newId);
    if (state.reconnectTimeoutId) {
      clearTimeout(state.reconnectTimeoutId);
      state.reconnectTimeoutId = null;
    }
    state.session = resp.session;
    if (resp.session.origin) state.lastKnownOrigin = resp.session.origin;
    state.reconnecting = false;
    state.sessionExpired = false;
    markSessionActivity();
    _maybeRetryFetchUser("session_reconnected");
    await loadForDate(state.currentDate);

    // Bilan : si après le chargement la session est restée invalide (SSO
    // intermédiaire), on marque ce PHPSESSID pour le throttler ; sinon on
    // confirme la reconnexion (et on retire les bannières) — pas de faux
    // « Reconnecté » à chaque tour.
    if (!state.session) {
      state._failedRestoreId = newId;
      state._failedRestoreAt = Date.now();
    } else {
      state._failedRestoreId = null;
      hideReconnectingBanner();
      hideSessionExpiredBanner();
      hideReconnectFailedBanner();
      showToast("Reconnecté", "Session EasyVista renouvelée");
    }
  } catch (e) {
    // Silencieux : on réessayera au prochain tick / au prochain focus.
  }
}

/**
 * Initialise le tick du compteur de session (toutes les secondes).
 * Pas de requête réseau : décompte purement local depuis state.sessionExpireAt.
 * En parallèle, un polling 2s actif dès qu'on est en reconnexion OU en session
 * expirée, pour détecter automatiquement le retour de session, peu importe
 * comment l'user s'est reconnecté (bouton bandeau, ouverture manuelle EV, ou
 * SSO/IAM silencieux depuis l'extérieur).
 */
function initSessionTimer() {
  setInterval(() => {
    updateSessionIndicator();
  }, 1000);

  setInterval(_checkForRestoredSession, 2000);

  // v2026.5.46 — recalage périodique du compteur sur le serveur (l'onglet
  // visible uniquement ; au retour de visibilité un recalage immédiat suit).
  setInterval(() => {
    if (!document.hidden) _sessionServerSync();
  }, SESSION_SYNC_INTERVAL_MS);
  // calibrage initial : remplace l'hypothèse « 30 min » du boot par la vraie
  // valeur serveur dès que l'interface est posée.
  setTimeout(() => { _sessionServerSync({ force: true }); }, 5000);

  // Au retour de visibilité (l'user revient sur l'onglet du viewer) ou au
  // focus de la fenêtre, check immédiat — sans attendre le tick de 2s. Évite
  // de regarder une bannière « expirée » périmée pendant 2s alors qu'on est
  // déjà reconnecté.
  document.addEventListener("visibilitychange", () => {
    if (!document.hidden) { _checkForRestoredSession(); _sessionServerSync(); }
  });
  window.addEventListener("focus", () => {
    _checkForRestoredSession();
    _sessionServerSync();
  });
}

/**
 * Met à jour l'affichage du compteur session dans la topbar.
 * Règles :
 *   - Session expirée ou reconnexion → compteur caché (bannière gère l'affichage)
 *   - > 5 min restantes → compteur invisible
 *   - 2-5 min → jaune, bouton "Prolonger" visible
 *   - < 2 min → rouge pulse + modal automatique (une seule fois)
 *   - <= 0 → déclenche l'état "expirée"
 */
// v2026.5.46 — vrai si un bandeau de session (expirée / EV inaccessible /
// reconnexion / reconnexion échouée) est actuellement visible.
function _anySessionBannerVisible() {
  try {
    return (typeof _SESSION_BANNER_IDS !== "undefined" ? _SESSION_BANNER_IDS : [])
      .some(id => { const b = document.getElementById(id); return b && !b.classList.contains("hidden"); });
  } catch (e) { return false; }
}

// v2026.5.46 — REFONTE PROPRE : une SEULE notification de session, le chip
// #app-session dans la topbar. Mis à jour chaque seconde (cf. initSessionTimer).
// Règles :
//   - masqué si > 5 min restantes, ou pas de session connue ;
//   - masqué si session expirée / reconnexion en cours / un bandeau de session
//     est déjà affiché (jamais de doublon avec la banderole / page de reco) ;
//   - sinon : compteur LIVE MM:SS (jaune < 5 min, rouge < 2 min) + « Prolonger ».
// Plus d'alertes glissantes ni de modal automatique (qui restaient collées et
// masquaient le décompte).
function updateSessionIndicator() {
  // v2026.5.46 — le popup badge (s'il est ouvert) tique CHAQUE seconde,
  // quel que soit l'état (avant : figé au-dessus de 5 min).
  const _popupSessLine = document.getElementById("user-name-popup-session");
  if (_popupSessLine) _renderUserPopupSessionLine(_popupSessLine);
  const _popupConnLine = document.getElementById("user-name-popup-conn");
  if (_popupConnLine) _renderUserPopupConnLine(_popupConnLine);

  const el = document.getElementById("app-session");
  if (!el) return;

  if (state.sessionExpired || state.reconnecting || _anySessionBannerVisible() || !state.sessionExpireAt) {
    el.classList.add("hidden");
    return;
  }

  const remainingMs = state.sessionExpireAt - Date.now();
  if (remainingMs <= 0) {
    _sessionExpireVerify();
    // v2026.5.46 — pendant la vérification (ou son backoff 30 s après
    // une erreur transitoire) : chip honnête à 00:00 rouge avec « Prolonger »
    // (un keep_connection réussi recale tout le compteur).
    el.classList.remove("hidden", "session-warn");
    el.classList.add("session-critical");
    const tEl = el.querySelector(".session-time");
    if (tEl) {
      tEl.textContent = "00:00";
    } else {
      el.innerHTML = `
    <span class="session-icon">⏱</span>
    <span class="session-time">00:00</span>
    <button type="button" class="session-extend-btn" title="Prolonger la session de 30 min">🔄 Prolonger</button>
  `;
      const bEl = el.querySelector(".session-extend-btn");
      if (bEl) bEl.addEventListener("click", () => _sessionExtend(bEl, "🔄 Prolonger"));
    }
    return;
  }
  if (remainingMs > SESSION_WARN_THRESHOLD_MS) { el.classList.add("hidden"); return; }

  // Zone d'alerte (< 5 min) : un seul ping de confirmation serveur (le compteur
  // local peut être désynchronisé si EV a rafraîchi sans qu'on mette à jour
  // notre horloge). On NE se rappelle PAS récursivement (le tick 1s suffit).
  if (!state.sessionPingDone) {
    state.sessionPingDone = true;
    _sessionServerSync({ force: true });
  }

  const mm = Math.floor(remainingMs / 60000);
  const ss = Math.floor((remainingMs % 60000) / 1000);
  const timeStr = `${String(mm).padStart(2, "0")}:${String(ss).padStart(2, "0")}`;
  el.classList.remove("hidden", "session-warn", "session-critical");
  el.classList.add(remainingMs <= SESSION_CRITICAL_THRESHOLD_MS ? "session-critical" : "session-warn");

  el.innerHTML = `
    <span class="session-icon">⏱</span>
    <span class="session-time">${timeStr}</span>
    <button type="button" class="session-extend-btn" title="Prolonger la session de 30 min">🔄 Prolonger</button>
  `;
  const extendBtn = el.querySelector(".session-extend-btn");
  if (extendBtn) extendBtn.addEventListener("click", () => _sessionExtend(extendBtn, "🔄 Prolonger"));

}


/**
 * Appelée quand le compteur atteint 0 ou quand une requête EV échoue en
 * session expirée. Affiche la bannière "Session expirée" avec bouton "Me
 * reconnecter".
 */
function handleSessionExpired() {
  if (state.sessionExpired) return;
  state.sessionExpired = true;
  state.sessionExpireAt = null;
  LOG.warn("session", "session EV expirée");
  showSessionExpiredBanner();
  const el = document.getElementById("app-session");
  if (el) el.classList.add("hidden");
}


/**
 * Appelé au clic "Me reconnecter" dans la bannière. Ouvre EasyVista dans un
 * nouvel onglet (déclenche Windows SSO Kerberos automatique). Le polling
 * dans initSessionTimer détectera la nouvelle session et rechargera le viewer.
 *
 * v5.0.10 : utilise l'origine dynamique (interne ou externe selon le réseau).
 * v5.0.11 : détecte le contexte réseau avant d'ouvrir (si pas déjà connu) +
 *           timeout 90s : si pas reconnecté après ce délai, propose choix manuel.
 *
 * @param {string} [forcedOrigin] - origine à forcer (pour le choix manuel
 *   dans le fallback après timeout). Si absent : détection auto.
 */
async function triggerReconnect(forcedOrigin) {
  state.reconnecting = true;
  hideSessionExpiredBanner();
  hideReconnectFailedBanner();
  showReconnectingBanner();

  // Annuler tout timeout précédent
  if (state.reconnectTimeoutId) {
    clearTimeout(state.reconnectTimeoutId);
    state.reconnectTimeoutId = null;
  }

  try {
    let origin = forcedOrigin;
    if (!origin) {
      // v5.0.11 : re-détecter le réseau à chaque expiration pour gérer le
      // cas où on a changé de contexte (bureau → TT) pendant la session.
      await detectNetworkContextAsync(true);
      origin = state.lastKnownOrigin
            || (state.session && state.session.origin)
            || "https://itsma.vd.ch";
    }
    LOG.info("session", "triggerReconnect → ouverture de", origin);
    await sendMessage({ type: "openEasyVistaLogin", origin });

    // Démarrer le timeout 90s : si pas reconnecté, basculer en mode "Échec"
    state.reconnectTimeoutId = setTimeout(() => {
      if (state.reconnecting && !state.session) {
        LOG.warn("session", "reconnexion timeout 90s → bannière échec");
        state.reconnecting = false;
        hideReconnectingBanner();
        showReconnectFailedBanner();
      }
    }, RECONNECT_TIMEOUT_MS);
  } catch (err) {
    LOG.warn("session", "openEasyVistaLogin failed:", err);
    state.reconnecting = false;
    hideReconnectingBanner();
    showSessionExpiredBanner();
  }
}

/**
 * v5.0.11 : l'user clique "Annuler" pendant la reconnexion. On arrête le
 * polling/timeout et on revient à l'état "Session expirée" normal.
 */
function cancelReconnect() {
  if (state.reconnectTimeoutId) {
    clearTimeout(state.reconnectTimeoutId);
    state.reconnectTimeoutId = null;
  }
  state.reconnecting = false;
  hideReconnectingBanner();
  hideReconnectFailedBanner();
  showSessionExpiredBanner();
}


// v5.0.0 : stockage des paramètres admin dans chrome.storage.local.
// Clé unique : "admin_config". Contient la config éditable (équipe,
// absences récurrentes, statuts etc.). Au 1er lancement : initialisée
// avec les valeurs hardcodées actuelles.
const ADMIN_CONFIG_KEY = "admin_config";

function getDefaultAdminConfig() {
  return {
    team: { ...TEAM },                          // Clone pour ne pas modifier le hardcode
    recurringAbsences: { ...RECURRING_ABSENCES }, // idem
    groupId: "191",
    evOrigins: ["https://itsma.etat-de-vaud.ch", "https://itsma.vd.ch"],
    closedStatus: [...DEFAULT_CLOSED_STATUS],
    resolvedStatus: [...DEFAULT_RESOLVED_STATUS],
    cancelledStatus: [...DEFAULT_CANCELLED_STATUS],
    dayStart: 8,
    dayEnd: 18,
    cacheDays: 7,
    // v2026.5.45 — diagnostic disparitions : si true, on NE retire JAMAIS
    // les ghosts (verdict CANCELLED/REMOVE → on log seulement). Sert à valider
    // les verdicts cas par cas avant de basculer en prod. Décorrélé de
    // LOG.isDebug() (qui ne contrôle plus que la verbosité console).
    keepDisappearedGhosts: false
  };
}

async function loadAdminConfig() {
  try {
    const stored = await chrome.storage.local.get(ADMIN_CONFIG_KEY);
    if (stored && stored[ADMIN_CONFIG_KEY]) {
      // Fusion avec les defaults (pour rajouter d'éventuelles nouvelles clés)
      return { ...getDefaultAdminConfig(), ...stored[ADMIN_CONFIG_KEY] };
    }
  } catch (e) {
    LOG.warn("admin", "loadAdminConfig err", e);
  }
  return getDefaultAdminConfig();
}

async function saveAdminConfig(cfg) {
  try {
    await chrome.storage.local.set({ [ADMIN_CONFIG_KEY]: cfg });
    return true;
  } catch (e) {
    LOG.error("admin", "saveAdminConfig err", e);
    return false;
  }
}

// v5.0.0 : affiche le panel admin plein écran.
// showAdminPanel accepte un id de section initiale ("appearance",
// "team", "easyvista", "diagnostics", "about"). Défaut : "appearance".
async function showAdminPanel(initialSection) {
  // Ferme un éventuel panel existant
  const existing = document.getElementById("admin-panel");
  if (existing) existing.remove();

  // Charge la config actuelle
  const cfg = await loadAdminConfig();

  // Overlay plein écran
  const overlay = document.createElement("div");
  overlay.id = "admin-panel";
  overlay.className = "modal-overlay admin-overlay";

  const card = document.createElement("div");
  card.className = "admin-panel-card";

  // En-tête
  const header = document.createElement("div");
  header.className = "admin-header";
  const title = document.createElement("h2");
  title.textContent = "⚙ Administration";
  title.className = "admin-title";
  const closeBtn = document.createElement("button");
  closeBtn.type = "button";
  closeBtn.className = "admin-close-btn";
  closeBtn.textContent = "×";
  closeBtn.title = "Fermer (Échap)";
  closeBtn.addEventListener("click", () => overlay.remove());
  header.appendChild(title);
  header.appendChild(closeBtn);
  card.appendChild(header);

  // Navigation latérale (onglets)
  const body = document.createElement("div");
  body.className = "admin-body";

  const sidebar = document.createElement("nav");
  sidebar.className = "admin-sidebar";

  const content = document.createElement("div");
  content.className = "admin-content";

  // v2026.5.39 : Apparence en 1re. À propos en dernière (après Diagnostics).
  const sections = [
    { id: "appearance", label: "Apparence",      render: renderAdminSectionAppearance },
    { id: "team",       label: "Équipe",         render: renderAdminSectionTeam },
    { id: "easyvista",  label: "EasyVista",      render: renderAdminSectionEV },
    { id: "sync",       label: "Synchronisation",render: renderAdminSectionSync },
    { id: "data",       label: "Données",        render: renderAdminSectionData },
    { id: "diagnostics",label: "Diagnostics",    render: renderAdminSectionDiagnostics },
    { id: "about",      label: "À propos",       render: renderAdminSectionAbout }
  ];
  // v2026.5.46 — onglet "Test (QRO)" RÉSERVÉ à Quentin Rouiller : permet de
  // se faire passer pour une autre personne (coordinateur) pour tester « Mes
  // actions » sans être réellement coordinateur. Caché pour tout autre utilisateur.
  if (_isQuentin()) {
    sections.push({ id: "qrotest", label: "🧪 Test (QRO)", render: renderAdminSectionImpersonate });
  }

  // utilise la section demandée si valide, sinon "appearance" par défaut.
  let currentSection = sections.some(s => s.id === initialSection)
    ? initialSection
    : "appearance";

  const navButtons = {};
  for (const section of sections) {
    const btn = document.createElement("button");
    btn.type = "button";
    btn.className = "admin-nav-btn";
    btn.textContent = section.label;
    btn.dataset.section = section.id;
    if (section.id === currentSection) btn.classList.add("active");
    btn.addEventListener("click", () => {
      currentSection = section.id;
      for (const k in navButtons) navButtons[k].classList.remove("active");
      btn.classList.add("active");
      content.innerHTML = "";
      section.render(content, cfg, () => saveAndReload(cfg));
    });
    navButtons[section.id] = btn;
    sidebar.appendChild(btn);
  }

  body.appendChild(sidebar);
  body.appendChild(content);
  card.appendChild(body);
  overlay.appendChild(card);
  document.body.appendChild(overlay);

  // rendu initial = la section demandée (par défaut "appearance").
  const initialSec = sections.find(s => s.id === currentSection) || sections[0];
  initialSec.render(content, cfg, () => saveAndReload(cfg));

  // Échap ferme le panel
  const escHandler = (e) => {
    if (e.key === "Escape") {
      overlay.remove();
      document.removeEventListener("keydown", escHandler);
    }
  };
  document.addEventListener("keydown", escHandler);

  async function saveAndReload(updatedCfg) {
    const ok = await saveAdminConfig(updatedCfg);
    if (ok) {
      // v2026.5.41 : application immédiate sans demander de recharger.
      // 1) repeupler TEAM / RECURRING_ABSENCES en mémoire depuis la nouvelle config.
      // 2) refetcher le planning du jour courant.
      // 3) le toast reste visible au-dessus du panel grâce au z-index 11000.
      await _initTeamFromConfig();
      showToast("Config enregistrée", "Mise à jour du planning…");
      try {
        await loadForDate(state.currentDate);
      } catch (e) {
        LOG.warn("admin", "reload planning err", e);
      }
    } else {
      showAlertModal({
        title: "Erreur",
        message: "Impossible d'enregistrer la configuration.",
        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
      });
    }
  }
}

// v5.0.0 : section "Équipe" du panel admin.
// v5.0.1 : affiche la liste complète du groupe EasyVista (20+ personnes),
// avec case à cocher "inclure dans la planification" pour chacune.
function renderAdminSectionTeam(container, cfg, saveFn) {
  const h = document.createElement("h3");
  h.textContent = "Équipe";
  h.className = "admin-section-title";
  container.appendChild(h);

  const desc = document.createElement("p");
  desc.className = "admin-section-desc";
  desc.textContent = "Sélectionnez les personnes qui doivent apparaître dans la planification. Les IDs viennent d'EasyVista (bouton Détecter) ou peuvent être saisis manuellement.";
  container.appendChild(desc);

  // ---- v2026.5.41 : Sélecteur de groupe EasyVista (SI-CSS / SI-EXT / …) ----
  // Placé en tête de la section Équipe : c'est le groupe qui détermine quels
  // techniciens sont listés. Détection live depuis le <select id="plan_group_id">
  // de la page Planning EV — robuste aux ajouts/renommages.
  const groupRow = _makeAdminRow(
    "Groupe EasyVista",
    "Par défaut SI-CSS. La liste est récupérée automatiquement depuis EasyVista."
  );
  const groupSelect = document.createElement("select");
  groupSelect.className = "admin-select";
  groupSelect.style.minWidth = "240px";

  function paintGroupOptions(groups, selectedId, selectedName) {
    groupSelect.innerHTML = "";
    const list = (groups && groups.length) ? groups.slice() : [];
    if (selectedId && !list.some(g => g.id === selectedId)) {
      list.unshift({ id: selectedId, name: selectedName || ("Groupe " + selectedId) });
    }
    if (list.length === 0) {
      const o = document.createElement("option");
      o.value = "";
      o.textContent = "— Détection en cours… —";
      o.disabled = true;
      o.selected = true;
      groupSelect.appendChild(o);
      updateGroupIdCaption(null);
      return;
    }
    for (const g of list) {
      const o = document.createElement("option");
      o.value = g.id;
      // v2026.5.41 : nom seul, l'ID est affiché en caption séparée sous le select
      o.textContent = g.name;
      if (g.id === selectedId) o.selected = true;
      groupSelect.appendChild(o);
    }
    updateGroupIdCaption(groupSelect.value);
  }

  function updateGroupIdCaption(id) {
    if (!id) { groupIdCaption.textContent = ""; return; }
    groupIdCaption.textContent = "ID groupe : " + id;
  }

  // Caption ID — créée maintenant pour qu'elle soit dispo dans paintGroupOptions
  const groupIdCaption = document.createElement("span");
  groupIdCaption.className = "admin-section-desc";
  groupIdCaption.style.marginLeft = "12px";
  groupIdCaption.style.fontStyle = "italic";

  paintGroupOptions(cfg.detectedGroups || [], cfg.groupId, cfg.groupName);

  groupSelect.addEventListener("change", async () => {
    const id = groupSelect.value;
    const opt = groupSelect.options[groupSelect.selectedIndex];
    cfg.groupId = id;
    const name = opt ? opt.textContent.trim() : "";
    cfg.groupName = name;
    updateGroupIdCaption(id);
    await saveAdminConfig(cfg);
    showToast("Groupe enregistré", name || id);
    // v2026.5.41 : refresh auto de la liste d'équipe avec le nouveau group_id.
    await refreshTeamForGroup(id);
  });

  groupRow.querySelector(".admin-row-control").appendChild(groupSelect);

  // Caption ID groupe à droite du select
  groupRow.querySelector(".admin-row-control").appendChild(groupIdCaption);

  container.appendChild(groupRow);

  const groupStatus = document.createElement("div");
  groupStatus.className = "admin-section-desc";
  groupStatus.style.marginTop = "4px";
  groupStatus.style.marginBottom = "12px";
  container.appendChild(groupStatus);

  async function detectGroups() {
    groupStatus.textContent = "Connexion à EasyVista…";
    try {
      const resp = await sendMessage({ type: "detectGroups" });
      if (resp && resp.ok && resp.groups && resp.groups.length) {
        cfg.detectedGroups = resp.groups;
        if (!cfg.groupId) {
          const def = resp.groups.find(g => /^SI-CSS$/i.test(g.name)) || resp.groups[0];
          cfg.groupId = def.id;
          cfg.groupName = def.name;
        }
        await saveAdminConfig(cfg);
        paintGroupOptions(resp.groups, cfg.groupId, cfg.groupName);
        groupStatus.textContent = `${resp.groups.length} groupe(s) détecté(s).`;
      } else {
        const err = (resp && resp.error) || "aucun groupe trouvé";
        groupStatus.textContent = "Détection impossible : " + err + ".";
      }
    } catch (e) {
      LOG.warn("admin", "detectGroups err", e);
      groupStatus.textContent = "Erreur : " + (e.message || e);
    }
  }

  // Auto-détection à l'ouverture (non-bloquant, sans popup)
  detectGroups();

  // État local : liste {id, name, included, days:[0..6]}
  // Au départ on remplit depuis cfg.team actuel, puis la détection EV
  // enrichit cette liste.
  const rows = [];
  for (const [id, name] of Object.entries(cfg.team || {})) {
    rows.push({
      id,
      name,
      included: true,
      days: (cfg.recurringAbsences[id] || []).slice()
    });
  }

  const tableWrap = document.createElement("div");
  tableWrap.className = "admin-team-wrap";
  container.appendChild(tableWrap);

  function render() {
    tableWrap.innerHTML = "";

    // v2026.5.41 : tri = inclus d'abord, puis exclus, alphabétique dans
    // chaque groupe. Pas de tri à chaque toggle de checkbox (sinon la ligne
    // sauterait sous le curseur), uniquement aux render() (ouverture +
    // après détection auto).
    rows.sort((a, b) => {
      if (a.included !== b.included) return a.included ? -1 : 1;
      return (a.name || "").localeCompare(b.name || "", "fr", { sensitivity: "base" });
    });

    // Stats : nb inclus / total
    const included = rows.filter(r => r.included).length;
    const stats = document.createElement("div");
    stats.className = "admin-section-desc";
    stats.style.marginTop = "0";
    stats.textContent = `${included} personne(s) incluse(s) sur ${rows.length} connue(s).`;
    tableWrap.appendChild(stats);

    // Table
    const table = document.createElement("table");
    table.className = "admin-team-table";
    const thead = document.createElement("thead");
    thead.innerHTML = "<tr><th>Inclure</th><th>ID</th><th>Nom affiché</th><th>Absences récurrentes</th><th></th></tr>";
    table.appendChild(thead);
    const tbody = document.createElement("tbody");
    table.appendChild(tbody);

    const days = ["Dim","Lun","Mar","Mer","Jeu","Ven","Sam"];
    rows.forEach((r, idx) => {
      const tr = document.createElement("tr");
      if (!r.included) tr.classList.add("admin-row-excluded");

      // Checkbox inclure
      const tdInc = document.createElement("td");
      const cb = document.createElement("input");
      cb.type = "checkbox";
      cb.checked = r.included;
      cb.addEventListener("change", () => {
        r.included = cb.checked;
        tr.classList.toggle("admin-row-excluded", !r.included);
        stats.textContent = `${rows.filter(x => x.included).length} personne(s) incluse(s) sur ${rows.length} connue(s).`;
      });
      tdInc.appendChild(cb);
      tr.appendChild(tdInc);

      // ID — v2026.5.40 : non modifiable (lecture seule), affiché en
      // texte simple plutôt qu'un input.
      const tdId = document.createElement("td");
      const idEl = document.createElement("span");
      idEl.className = "admin-team-id-readonly";
      idEl.textContent = r.id;
      tdId.appendChild(idEl);
      tr.appendChild(tdId);

      // Nom — v2026.5.40 : non modifiable (lecture seule), affiché en
      // texte simple. Détecté/configuré via "Détecter depuis EasyVista".
      const tdName = document.createElement("td");
      const nameEl = document.createElement("span");
      nameEl.className = "admin-team-name-readonly";
      nameEl.textContent = r.name;
      tdName.appendChild(nameEl);
      tr.appendChild(tdName);

      // Jours d'absence récurrente — v2026.5.40 : du lundi (1) au
      // vendredi (5), pas de samedi/dimanche (jamais utilisés au DGNSI).
      const tdAbs = document.createElement("td");
      for (let d = 1; d <= 5; d++) {
        const lbl = document.createElement("label");
        lbl.className = "admin-day-cb";
        const cbd = document.createElement("input");
        cbd.type = "checkbox";
        cbd.checked = r.days.includes(d);
        cbd.addEventListener("change", () => {
          if (cbd.checked && !r.days.includes(d)) r.days.push(d);
          if (!cbd.checked) r.days = r.days.filter(x => x !== d);
        });
        lbl.appendChild(cbd);
        lbl.appendChild(document.createTextNode(days[d]));
        tdAbs.appendChild(lbl);
      }
      tr.appendChild(tdAbs);

      // v2026.5.40 : poubelle retirée (jamais utilisée — l'équipe est
      // hardcodée et ajustée via les checkboxes "exclure", pas par suppression).

      tbody.appendChild(tr);
    });

    tableWrap.appendChild(table);

    // v2026.5.26 : bouton "+ Ajouter manuellement" retiré. La liste complète
    // des techniciens du groupe est chargée automatiquement depuis EasyVista
    // à l'ouverture du panel admin (voir auto-détection plus bas).

    // Bouton Enregistrer
    const saveBtn = document.createElement("button");
    saveBtn.type = "button";
    saveBtn.className = "btn btn-primary";
    saveBtn.textContent = "💾 Enregistrer";
    saveBtn.style.marginTop = "20px";
    saveBtn.style.marginLeft = "10px";
    saveBtn.addEventListener("click", () => {
      // v2026.5.45 (issue #3 — cause structurelle) : on MERGE avec l'état
      // existant au lieu de tout remplacer. Sans ça, sauvegarder pendant
      // qu'on est sur un autre groupe que celui où les absences récurrentes
      // ont été configurées WIPE silencieusement les absences des techs qui
      // ne sont pas dans rows (ex: techs d'un autre groupe).
      // Logique : on ne touche QUE les entrées des techs présents dans la
      // vue (rows) — leur état (inclus/exclu, jours) est mis à jour. Les
      // techs absents de la vue gardent leurs entrées intactes.
      const newTeam = { ...(cfg.team || {}) };
      const newRecAbs = { ...(cfg.recurringAbsences || {}) };
      for (const r of rows) {
        if (!r.id) continue;
        if (r.included) {
          newTeam[r.id] = r.name || ("? (" + r.id + ")");
          if (r.days && r.days.length > 0) {
            newRecAbs[r.id] = r.days.slice();
          } else {
            delete newRecAbs[r.id];
          }
        } else {
          // Tech décoché → on retire son entrée de team ET de recurringAbsences
          delete newTeam[r.id];
          delete newRecAbs[r.id];
        }
      }
      cfg.team = newTeam;
      cfg.recurringAbsences = newRecAbs;
      saveFn();
    });
    tableWrap.appendChild(saveBtn);
  }

  render();

  // v2026.5.26 : auto-détection EasyVista à l'ouverture du panel admin.
  // On lance en arrière-plan (non-bloquant), et on merge avec cfg.team actuel
  // quand le résultat arrive. Les techs actuellement en cfg.team restent
  // cochés par défaut ; les nouveaux détectés du groupe apparaissent non-cochés.
  (async () => {
    try {
      const resp = await sendMessage({ type: "detectTeam", groupId: cfg.groupId });
      if (resp && resp.ok && resp.members && resp.members.length) {
        for (const m of resp.members) {
          const existing = rows.find(r => r.id === m.id);
          if (existing) {
            if (m.name && !m.name.startsWith("?") && existing.name.startsWith("?")) {
              existing.name = m.name;
            }
          } else {
            // restaurer les absences récurrentes depuis cfg si elles
            // existent — un changement de groupe ne doit jamais les "oublier"
            // visuellement (la donnée elle-même n'a pas bougé en storage).
            rows.push({
              id: m.id,
              name: m.name || "? (" + m.id + ")",
              included: !!m.alreadyInTeam,
              days: (cfg.recurringAbsences && cfg.recurringAbsences[m.id])
                ? cfg.recurringAbsences[m.id].slice()
                : []
            });
          }
        }
        render();
      }
    } catch (err) {
      LOG.warn("admin", "auto-détection en échec", err);
    }
  })();

  // v2026.5.41 : refresh complet de la liste d'équipe quand on change de groupe.
  // Appelé depuis le handler `change` du sélecteur de groupe.
  // Comportement : on REMPLACE complètement les rows (le nouveau groupe a
  // potentiellement une équipe totalement différente), et on rerend la table.
  // Aucun pré-cochage : l'utilisateur choisit les techs à inclure dans le
  // nouveau groupe, puis clique sur Enregistrer.
  async function refreshTeamForGroup(newGroupId) {
    rows.length = 0;
    render();
    try {
      const resp = await sendMessage({ type: "detectTeam", groupId: newGroupId });
      if (resp && resp.ok && resp.members && resp.members.length) {
        for (const m of resp.members) {
          // restaurer les jours d'absence récurrente depuis cfg.
          // Sans ça, revenir au groupe initial réaffichait des cases vides
          // alors que les absences étaient toujours en storage.
          rows.push({
            id: m.id,
            name: m.name || "? (" + m.id + ")",
            included: !!m.alreadyInTeam,
            days: (cfg.recurringAbsences && cfg.recurringAbsences[m.id])
              ? cfg.recurringAbsences[m.id].slice()
              : []
          });
        }
        render();
      } else {
        LOG.warn("admin", "refreshTeamForGroup : aucune personne", resp);
      }
    } catch (err) {
      LOG.warn("admin", "refreshTeamForGroup err", err);
    }
  }

  // ─── Réinitialisation des absences récurrentes (déplacé depuis Diagnostics) ─
  // v2026.1.5 — QRO
  const recAbsTitle = document.createElement("div");
  recAbsTitle.textContent = "♻ Réinitialiser les absences récurrentes";
  recAbsTitle.style.cssText = "margin:24px 0 8px 0; font-size:14px; font-weight:600; color:var(--text); border-bottom:1px solid var(--border); padding-bottom:4px;";
  container.appendChild(recAbsTitle);

  const recAbsRow = document.createElement("div");
  recAbsRow.style.cssText = "margin-top:8px;";
  const recAbsHint = document.createElement("p");
  recAbsHint.textContent = "Si vos absences récurrentes sont dans un état incohérent (ancien bug), vous pouvez tout remettre à zéro et les reconfigurer ci-dessus.";
  recAbsHint.style.cssText = "font-size:12px; color:var(--text-faint); margin:0 0 10px 0;";
  recAbsRow.appendChild(recAbsHint);
  const resetRecAbsBtn = document.createElement("button");
  resetRecAbsBtn.type = "button";
  resetRecAbsBtn.className = "btn";
  resetRecAbsBtn.textContent = "🗓 Réinitialiser les absences récurrentes";
  resetRecAbsBtn.addEventListener("click", () => {
    const count = Object.keys(cfg.recurringAbsences || {}).length;
    showAlertModal({
      title: "Réinitialiser les absences récurrentes ?",
      message: count > 0
        ? `Cela supprimera les ${count} absence(s) récurrente(s) actuellement configurée(s). L'équipe et les autres paramètres ne sont pas touchés. Continuer ?`
        : "Aucune absence récurrente n'est actuellement configurée. Le bouton videra quand même la clé pour repartir d'un état propre.",
      buttons: [
        { label: "Annuler", variant: "secondary", action: () => {} },
        {
          label: "Réinitialiser",
          variant: "danger",
          action: async () => {
            cfg.recurringAbsences = {};
            await saveAdminConfig(cfg);
            await _initTeamFromConfig();
            showToast("Absences récurrentes", "réinitialisées");
            const overlay = document.getElementById("admin-panel");
            if (overlay) overlay.remove();
            if (typeof showAdminPanel === "function") showAdminPanel("team");
          }
        }
      ]
    });
  });
  recAbsRow.appendChild(resetRecAbsBtn);
  container.appendChild(recAbsRow);
}

// v2026.5.41 : Section EasyVista — édition manuelle des domaines (interne /
// externe). Les valeurs par défaut restent hardcodées (DEFAULT_EV_ORIGINS),
// mais l'utilisateur peut les remplacer ou en ajouter d'autres si EasyVista
// change d'URL. Bouton "Réinitialiser" pour revenir aux défauts.
const DEFAULT_EV_ORIGIN_INTERNAL = "https://itsma.etat-de-vaud.ch";
const DEFAULT_EV_ORIGIN_EXTERNAL = "https://itsma.vd.ch";

function _normalizeOrigin(raw) {
  let s = (raw || "").trim();
  if (!s) return "";
  // Retirer trailing slash
  s = s.replace(/\/+$/, "");
  // Préfixer https:// si l'utilisateur a tapé juste un domaine
  if (!/^https?:\/\//i.test(s)) s = "https://" + s;
  return s;
}

function renderAdminSectionEV(container, cfg, saveFn) {
  const h = document.createElement("h3");
  h.textContent = "EasyVista";
  h.className = "admin-section-title";
  container.appendChild(h);

  const desc = document.createElement("p");
  desc.className = "admin-section-desc";
  desc.textContent = "Domaines EasyVista surveillés pour détecter votre session active. Le domaine interne (réseau DGNSI) et le domaine externe (Internet) sont préremplis. Modifiez-les si EasyVista change d'URL.";
  container.appendChild(desc);

  // État local : on lit cfg.evOrigins, sinon défaut.
  const origins = (cfg.evOrigins && cfg.evOrigins.length >= 2)
    ? cfg.evOrigins.slice()
    : [DEFAULT_EV_ORIGIN_INTERNAL, DEFAULT_EV_ORIGIN_EXTERNAL];

  // ---- Champ "Domaine interne" ----
  const internalRow = _makeAdminRow(
    "Domaine interne (DGNSI)",
    `Réseau interne du Canton. Défaut : ${DEFAULT_EV_ORIGIN_INTERNAL}`
  );
  const internalInput = document.createElement("input");
  internalInput.type = "text";
  internalInput.className = "admin-input";
  internalInput.style.minWidth = "320px";
  internalInput.placeholder = DEFAULT_EV_ORIGIN_INTERNAL;
  internalInput.value = origins[0] || "";
  internalRow.querySelector(".admin-row-control").appendChild(internalInput);
  container.appendChild(internalRow);

  // ---- Champ "Domaine externe" ----
  const externalRow = _makeAdminRow(
    "Domaine externe (Internet)",
    `Accès depuis l'extérieur. Défaut : ${DEFAULT_EV_ORIGIN_EXTERNAL}`
  );
  const externalInput = document.createElement("input");
  externalInput.type = "text";
  externalInput.className = "admin-input";
  externalInput.style.minWidth = "320px";
  externalInput.placeholder = DEFAULT_EV_ORIGIN_EXTERNAL;
  externalInput.value = origins[1] || "";
  externalRow.querySelector(".admin-row-control").appendChild(externalInput);
  container.appendChild(externalRow);

  // ---- Statut / messages ----
  const status = document.createElement("div");
  status.className = "admin-section-desc";
  status.style.marginTop = "4px";
  container.appendChild(status);

  // ---- Boutons ----
  const btnWrap = document.createElement("div");
  btnWrap.style.marginTop = "16px";
  btnWrap.style.display = "flex";
  btnWrap.style.gap = "8px";

  const saveBtn = document.createElement("button");
  saveBtn.type = "button";
  saveBtn.className = "btn btn-primary";
  saveBtn.textContent = "💾 Enregistrer";
  saveBtn.addEventListener("click", async () => {
    const a = _normalizeOrigin(internalInput.value);
    const b = _normalizeOrigin(externalInput.value);
    if (!a || !b) {
      status.textContent = "Les deux domaines doivent être renseignés.";
      return;
    }
    internalInput.value = a;
    externalInput.value = b;

    // v2026.5.41 : si un domaine n'est pas dans le host_permissions par défaut
    // du manifest, demander la permission au navigateur. Sans ça, le service
    // worker ne peut pas fetcher ces nouveaux domaines.
    const hardcodedDefaults = [DEFAULT_EV_ORIGIN_INTERNAL, DEFAULT_EV_ORIGIN_EXTERNAL];
    const customOrigins = [a, b].filter(o => !hardcodedDefaults.includes(o));
    if (customOrigins.length > 0) {
      const origins = customOrigins.map(o => o + "/*");
      try {
        const granted = await chrome.permissions.request({ origins });
        if (!granted) {
          status.textContent = "⚠ Permission refusée pour " + customOrigins.join(", ") + ". Les fetches échoueront sur ces domaines.";
          showAlertModal({
            title: "Permission refusée",
            message: "Vous avez refusé l'accès aux domaines personnalisés. L'extension ne pourra pas y fetcher de données. Vous pouvez réessayer en cliquant à nouveau sur Enregistrer.",
            buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
          });
          return;
        }
      } catch (e) {
        LOG.warn("admin", "permissions.request err", e);
        status.textContent = "Erreur permission : " + (e.message || e);
        return;
      }
    }

    cfg.evOrigins = [a, b];
    const ok = await saveAdminConfig(cfg);
    if (!ok) {
      status.textContent = "Erreur lors de l'enregistrement.";
      return;
    }
    status.textContent = "Domaines enregistrés.";
    showToast("Domaines enregistrés", `${a}  •  ${b}`);
    try {
      await refreshSessionAndLoad();
    } catch (e) {
      LOG.warn("admin", "reload after EV domain change err", e);
    }
  });
  btnWrap.appendChild(saveBtn);

  const resetBtn = document.createElement("button");
  resetBtn.type = "button";
  resetBtn.className = "btn btn-secondary";
  resetBtn.textContent = "↺ Réinitialiser aux valeurs par défaut";
  resetBtn.addEventListener("click", () => {
    internalInput.value = DEFAULT_EV_ORIGIN_INTERNAL;
    externalInput.value = DEFAULT_EV_ORIGIN_EXTERNAL;
    status.textContent = "Valeurs par défaut restaurées (cliquez sur Enregistrer pour appliquer).";
  });
  btnWrap.appendChild(resetBtn);

  container.appendChild(btnWrap);

  // ─── : sous-section "Statuts EasyVista" — UI liste ───────────────
  // Une seule entrée par statut suffit (ex: "Clôturé") : la détection est
  // automatiquement insensible à la casse et aux accents. L'user peut
  // ajouter, modifier ou supprimer des entrées avec les boutons.
  const SUB_TITLE_STYLE = "margin:24px 0 6px 0; font-size:14px; font-weight:600; color:var(--text); border-bottom:1px solid var(--border); padding-bottom:4px;";
  const SUB_HINT_STYLE = "font-size:12px; color:var(--text-faint); margin:0 0 12px 0;";

  const stTitle = document.createElement("div");
  stTitle.textContent = "🏷 Statuts EasyVista";
  stTitle.style.cssText = SUB_TITLE_STYLE;
  container.appendChild(stTitle);

  const stHint = document.createElement("p");
  stHint.textContent = "Libellés EV qui signifient clos / résolu / annulé. La détection est faite en arrière-plan en ignorant la casse et les accents — pas besoin de saisir toutes les variantes.";
  stHint.style.cssText = SUB_HINT_STYLE;
  container.appendChild(stHint);

  const _makeStatusListRow = (labelText, descText, defaultArr, currentArr, onSave) => {
    const row = _makeAdminRow(labelText, descText);
    const ctrl = row.querySelector(".admin-row-control");
    container.appendChild(row);

    // État local (copie défensive)
    let items = (currentArr && currentArr.length) ? currentArr.slice() : defaultArr.slice();

    const wrap = document.createElement("div");
    wrap.style.cssText = "display:flex; flex-direction:column; gap:4px; min-width:320px;";
    ctrl.appendChild(wrap);

    const list = document.createElement("div");
    list.style.cssText = "display:flex; flex-direction:column; gap:4px;";
    wrap.appendChild(list);

    const persist = async () => {
      try {
        onSave(items.slice());
        await saveAdminConfig(cfg);
        LOG.warn("admin", `${labelText} sauvegardés`, { count: items.length, valeurs: items });
        showToast(labelText, `${items.length} entrée(s) — recharge la page pour appliquer`);
      } catch (err) {
        LOG.error("admin", `échec sauvegarde ${labelText}`, { err: err && err.message });
        showToast("Erreur", (err && err.message) || String(err));
      }
    };

    const renderList = () => {
      list.innerHTML = "";
      items.forEach((val, idx) => {
        const itemRow = document.createElement("div");
        itemRow.style.cssText = "display:flex; gap:6px; align-items:center;";

        const inp = document.createElement("input");
        inp.type = "text";
        inp.className = "admin-input";
        inp.value = val;
        inp.style.flex = "1";
        inp.addEventListener("change", async () => {
          const v = inp.value.trim();
          if (!v) {
            // Vide → on supprime l'entrée
            items.splice(idx, 1);
            renderList();
            await persist();
            return;
          }
          if (v !== items[idx]) {
            items[idx] = v;
            await persist();
          }
        });
        itemRow.appendChild(inp);

        const delBtn = document.createElement("button");
        delBtn.type = "button";
        delBtn.className = "btn";
        delBtn.textContent = "🗑";
        delBtn.title = "Supprimer";
        delBtn.style.cssText = "padding:4px 10px;";
        delBtn.addEventListener("click", async () => {
          items.splice(idx, 1);
          renderList();
          await persist();
        });
        itemRow.appendChild(delBtn);

        list.appendChild(itemRow);
      });
    };

    const addBtn = document.createElement("button");
    addBtn.type = "button";
    addBtn.className = "btn";
    addBtn.textContent = "➕ Ajouter une entrée";
    addBtn.style.cssText = "align-self:flex-start; padding:4px 10px;";
    addBtn.addEventListener("click", () => {
      items.push("");
      renderList();
      // focus sur la nouvelle ligne
      const inputs = list.querySelectorAll("input");
      const last = inputs[inputs.length - 1];
      if (last) last.focus();
    });
    wrap.appendChild(addBtn);

    renderList();
  };

  _makeStatusListRow(
    "Clôturé / Résolu (✓✓ vert)",
    "Statuts EV qui signifient « finalisé officiellement » (incluant Clôturé et Résolu).",
    DEFAULT_CLOSED_STATUS,
    cfg.closedStatus,
    (arr) => { cfg.closedStatus = arr; }
  );

  // entrées "Résolu" et "Annulé/Supprimé" retirées de l'UI.
  //   - Résolu : fusionné dans la liste Clôturé/Résolu (un seul statut
  //     "finalisé" couvre les deux côté admin).
  //   - Annulé/Supprimé : la décision est basée sur le comportement du tech
  //     (action présente sans commentaire = annulée), pas sur le statut
  //     global de la fiche. CANCELLED_STATUS reste dans le code pour
  //     back-compat des configs existantes mais n'est plus exposé.

  // v2026.5.46 — Gestion des sessions multi-onglets EZV (déplacé ici depuis
  // Diagnostics) : autorise la lecture du cookie PHPSESSID (HttpOnly) pour
  // rester connecté même avec d'anciens onglets EZV ouverts. Permission
  // "cookies" optionnelle, demandée au runtime. Ce N'EST PAS expérimental.
  const cookieRow = document.createElement("label");
  cookieRow.className = "admin-cookie-row";
  cookieRow.style.cssText = "display:flex; align-items:center; gap:10px; padding:10px; background:var(--bg-muted); border-radius:6px; cursor:pointer; margin-top:18px;";
  const cookieCheckbox = document.createElement("input");
  cookieCheckbox.type = "checkbox";
  cookieCheckbox.disabled = true;
  const cookieText = document.createElement("div");
  cookieText.style.cssText = "flex:1;";
  cookieText.innerHTML = `<strong>Gérer les sessions multi-onglets EZV</strong><div style="font-size:12px; color:var(--text-faint); margin-top:2px;">Permet à l'extension de lire le cookie session pour rester connectée même si plusieurs onglets EZV historiques sont ouverts. Sans ça, après une reconnexion, l'extension peut se baser sur un PHPSESSID périmé.</div>`;
  cookieRow.appendChild(cookieCheckbox);
  cookieRow.appendChild(cookieText);
  (async () => {
    try {
      const has = await new Promise(r => chrome.permissions.contains({ permissions: ["cookies"] }, r));
      cookieCheckbox.checked = !!has;
      cookieCheckbox.disabled = false;
    } catch (e) {
      cookieCheckbox.disabled = true;
      LOG.warn("permissions", "contains err", { err: e && e.message });
    }
  })();
  cookieCheckbox.addEventListener("change", async () => {
    cookieCheckbox.disabled = true;
    try {
      if (cookieCheckbox.checked) {
        LOG.warn("permissions", "demande de permission cookies (toggle EasyVista)");
        const granted = await new Promise(r => chrome.permissions.request({ permissions: ["cookies"] }, r));
        if (granted) {
          LOG.warn("permissions", "permission cookies ACCORDÉE → multi-onglets EZV actif");
          showToast("Multi-onglets activé", "L'extension lit désormais le cookie session.");
          cfg.cookiesPromptDismissed = false;
          await saveAdminConfig(cfg);
          if (typeof _removeAllCookiesPrompts === "function") _removeAllCookiesPrompts();
        } else {
          LOG.warn("permissions", "permission cookies REFUSÉE par l'utilisateur");
          cookieCheckbox.checked = false;
          showToast("Refusé", "L'extension reste sur l'ancien comportement.");
        }
      } else {
        LOG.warn("permissions", "retrait de la permission cookies (toggle EasyVista)");
        const removed = await new Promise(r => chrome.permissions.remove({ permissions: ["cookies"] }, r));
        if (removed) {
          LOG.warn("permissions", "permission cookies retirée → fallback URL");
          showToast("Multi-onglets désactivé", "Retour au comportement standard (URL).");
        } else {
          LOG.warn("permissions", "retrait de la permission a échoué");
          cookieCheckbox.checked = true;
        }
      }
    } catch (err) {
      LOG.warn("permissions", "toggle err", { err: err && err.message });
      showToast("Erreur", "Impossible de modifier la permission");
    } finally {
      cookieCheckbox.disabled = false;
    }
  });
  container.appendChild(cookieRow);
}

// v2026.5.39 : section Apparence — thème, taille du texte, cache.
// Chaque champ s'enregistre direct (pas besoin de bouton "Enregistrer"
// global), pour que le user voit l'effet immédiatement.
function renderAdminSectionAppearance(container, cfg, saveFn) {
  const h = document.createElement("h3");
  h.textContent = "Apparence";
  h.className = "admin-section-title";
  container.appendChild(h);

  // ---- Champ Thème (1er) ----
  const themeRow = _makeAdminRow(
    "Thème",
    "Clair, sombre ou suit l'OS."
  );
  const themeSelect = document.createElement("select");
  themeSelect.className = "admin-select";
  for (const opt of [
    { val: "auto",  label: "Automatique (selon l'OS)" },
    { val: "light", label: "Clair" },
    { val: "dark",  label: "Sombre" }
  ]) {
    const o = document.createElement("option");
    o.value = opt.val;
    o.textContent = opt.label;
    if ((cfg.theme || "auto") === opt.val) o.selected = true;
    themeSelect.appendChild(o);
  }
  themeSelect.addEventListener("change", async () => {
    cfg.theme = themeSelect.value;
    _applyTheme(cfg.theme);
    await saveAdminConfig(cfg);
  });
  themeRow.querySelector(".admin-row-control").appendChild(themeSelect);
  container.appendChild(themeRow);

  // la durée du cache a été déplacée dans Diagnostics → section Cache,
  // à côté des boutons Export/Import (regroupement logique).

  // ---- Champ Taille du texte (3e) — slider horizontal ----
  // 5 crans : -2 (-20%), -1 (-10%), 0 (100% défaut), +1 (+10%), +2 (+20%)
  const zoomRow = _makeAdminRow(
    "Taille du texte",
    "Glisse le curseur pour changer la taille. 100% = défaut. Persisté entre sessions."
  );
  const zoomWrap = document.createElement("div");
  zoomWrap.className = "admin-zoom-slider-wrap";
  // v2026.5.39 r9 : déclaration EN PREMIER pour pouvoir l'utiliser dans la
  // boucle datalist (sinon TDZ ReferenceError → la section ne s'affichait plus)
  const _zoomLabel = (lv) => {
    const pct = { "-2": 70, "-1": 85, "0": 100, "1": 110, "2": 120 }[String(lv)] || 100;
    return pct + "%";
  };
  const zoomSlider = document.createElement("input");
  zoomSlider.type = "range";
  zoomSlider.min = "-2";
  zoomSlider.max = "2";
  zoomSlider.step = "1";
  zoomSlider.className = "admin-zoom-slider";
  zoomSlider.setAttribute("list", "zoom-ticks");
  const currentZoom = (typeof cfg.textZoom === "number") ? cfg.textZoom : 0;
  zoomSlider.value = String(currentZoom);
  // datalist (5 ticks)
  const ticks = document.createElement("datalist");
  ticks.id = "zoom-ticks";
  for (const v of [-2, -1, 0, 1, 2]) {
    const opt = document.createElement("option");
    opt.value = String(v);
    opt.label = _zoomLabel(v);
    ticks.appendChild(opt);
  }
  zoomWrap.appendChild(ticks);
  const zoomVal = document.createElement("span");
  zoomVal.className = "admin-zoom-value";
  zoomVal.textContent = _zoomLabel(currentZoom);
  // v2026.5.39 r11 : on N'APPLIQUE PAS le zoom pendant le drag (event "input"),
  // sinon l'UI fait du yo-yo et la position de la souris vs le curseur dérive.
  // Pendant le drag : on met juste à jour le label % pour que l'user voie où
  // il va atterrir. Au release ("change"), on applique le zoom + on save.
  zoomSlider.addEventListener("input", () => {
    const lv = parseInt(zoomSlider.value, 10) || 0;
    zoomVal.textContent = _zoomLabel(lv);
  });
  zoomSlider.addEventListener("change", async () => {
    const lv = parseInt(zoomSlider.value, 10) || 0;
    _applyTextZoom(lv);
    cfg.textZoom = lv;
    await saveAdminConfig(cfg);
  });
  zoomWrap.appendChild(zoomSlider);
  zoomWrap.appendChild(zoomVal);
  zoomRow.querySelector(".admin-row-control").appendChild(zoomWrap);
  container.appendChild(zoomRow);

  // ---- Heures de la journée (4e) ----
  // v2026.5.41 : bouton "Appliquer" explicite (au lieu de save direct au change),
  // avec toast de confirmation et reload du planning + de la timeline.
  const hoursRow = _makeAdminRow(
    "Heures de la journée",
    "Plage horaire affichée sur la timeline. Défaut : 8h - 18h. Cliquez sur Appliquer pour valider et recharger."
  );
  const hoursWrap = document.createElement("div");
  hoursWrap.style.cssText = "display:flex; align-items:center; gap:6px; flex-wrap:wrap;";
  const hStart = document.createElement("input");
  hStart.type = "number"; hStart.min = "0"; hStart.max = "23"; hStart.step = "1";
  hStart.className = "admin-input admin-input-num";
  hStart.value = String(cfg.dayStart || 8);
  const sep = document.createElement("span");
  sep.textContent = "h  →";
  sep.style.cssText = "color: var(--text-muted); font-size: 13px;";
  const hEnd = document.createElement("input");
  hEnd.type = "number"; hEnd.min = "1"; hEnd.max = "24"; hEnd.step = "1";
  hEnd.className = "admin-input admin-input-num";
  hEnd.value = String(cfg.dayEnd || 18);
  const hSuffix = document.createElement("span");
  hSuffix.textContent = "h";
  hSuffix.style.cssText = "color: var(--text-muted); font-size: 13px;";

  const applyBtn = document.createElement("button");
  applyBtn.type = "button";
  applyBtn.className = "btn btn-primary";
  applyBtn.textContent = "✓ Appliquer";
  applyBtn.style.marginLeft = "10px";
  applyBtn.addEventListener("click", async () => {
    let s = parseInt(hStart.value, 10);
    let e = parseInt(hEnd.value, 10);
    if (isNaN(s) || s < 0) s = 0;
    if (s > 23) s = 23;
    if (isNaN(e) || e <= s) e = s + 1;
    if (e > 24) e = 24;
    hStart.value = String(s);
    hEnd.value = String(e);

    // Pas de changement effectif → on évite le reload inutile
    const unchanged = (cfg.dayStart === s) && (cfg.dayEnd === e);
    cfg.dayStart = s;
    cfg.dayEnd = e;

    applyBtn.disabled = true;
    const oldLabel = applyBtn.textContent;
    applyBtn.textContent = "Application…";
    try {
      const ok = await saveAdminConfig(cfg);
      if (!ok) {
        showAlertModal({
          title: "Erreur",
          message: "Impossible d'enregistrer les heures.",
          buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
        });
        return;
      }
      // Mettre à jour les bornes en mémoire pour la timeline (utilisées
      // par buildTimeline / updateNowLine sans re-fetch).
      DAY_START = s * 60;
      DAY_END = e * 60;
      showToast("Heures appliquées", `${s}h → ${e}h`);
      if (!unchanged) {
        // Refetch le planning pour que les requêtes EV repartent avec
        // les nouvelles bornes (day_start_hour / day_end_hour).
        await loadForDate(state.currentDate);
      }
    } catch (err) {
      LOG.warn("admin", "apply hours err", err);
      showAlertModal({
        title: "Erreur",
        message: "Échec de l'application : " + (err.message || err),
        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
      });
    } finally {
      applyBtn.disabled = false;
      applyBtn.textContent = oldLabel;
    }
  });

  hoursWrap.appendChild(hStart);
  hoursWrap.appendChild(sep);
  hoursWrap.appendChild(hEnd);
  hoursWrap.appendChild(hSuffix);
  hoursWrap.appendChild(applyBtn);
  hoursRow.querySelector(".admin-row-control").appendChild(hoursWrap);
  container.appendChild(hoursRow);

  // couleur de la barre du haut — refonte UI propre, avec presets
  // cliquables + picker fin + champ hex. Le texte de la topbar prend
  // automatiquement une couleur lisible (blanc ou foncé) selon la luminance.
  const colorRow = _makeAdminRow(
    "Couleur de la barre du haut",
    "S'applique uniquement à la topbar. Le texte s'adapte automatiquement (clair/foncé) pour rester lisible."
  );
  const colorWrap = document.createElement("div");
  colorWrap.style.cssText = "display:flex; flex-direction:column; gap:10px;";

  // Presets : 12 couleurs choisies pour bien rendre en topbar.
  const COLOR_PRESETS = [
    { val: "",        label: "Défaut" },
    { val: "#ffffff", label: "Blanc" },
    { val: "#f4f5f7", label: "Gris clair" },
    { val: "#1f2937", label: "Anthracite" },
    { val: "#0f4f8b", label: "Bleu DGNSI" },
    { val: "#1e3a8a", label: "Marine" },
    { val: "#065f46", label: "Vert sapin" },
    { val: "#7c2d12", label: "Brique" },
    { val: "#7c3aed", label: "Violet" },
    { val: "#dc2626", label: "Rouge" },
    { val: "#dbeafe", label: "Bleu pastel" },
    { val: "#dcfce7", label: "Vert pastel" }
  ];
  const presetWrap = document.createElement("div");
  presetWrap.style.cssText = "display:flex; gap:6px; flex-wrap:wrap;";
  const _refreshPresetSelected = (current) => {
    [...presetWrap.children].forEach(c => {
      const isSel = (c.dataset.color || "") === (current || "");
      c.style.boxShadow = isSel
        ? "0 0 0 3px var(--accent), 0 1px 3px rgba(0,0,0,0.15)"
        : "0 1px 3px rgba(0,0,0,0.15)";
    });
  };
  for (const p of COLOR_PRESETS) {
    const sw = document.createElement("button");
    sw.type = "button";
    sw.dataset.color = p.val;
    sw.title = p.label;
    sw.style.cssText = `
      width:30px; height:30px; padding:0; cursor:pointer;
      border:1px solid var(--border-strong); border-radius:50%;
      background:${p.val || "transparent"};
      ${p.val ? "" : "background:repeating-linear-gradient(45deg,#fff 0 4px,#ddd 4px 8px);"}
    `;
    sw.addEventListener("click", async () => {
      _applyTopbarColor(p.val);
      cfg.topbarColor = p.val;
      colorInput.value = p.val || "#ffffff";
      colorHex.value = p.val;
      _refreshPresetSelected(p.val);
      await saveAdminConfig(cfg);
    });
    presetWrap.appendChild(sw);
  }
  colorWrap.appendChild(presetWrap);

  // Picker custom + hex + reset, sur une seconde ligne.
  const customLine = document.createElement("div");
  customLine.style.cssText = "display:flex; align-items:center; gap:8px; flex-wrap:wrap;";
  const colorLabel = document.createElement("span");
  colorLabel.textContent = "Couleur perso :";
  colorLabel.style.cssText = "font-size:12px; color:var(--text-muted);";
  const colorInput = document.createElement("input");
  colorInput.type = "color";
  colorInput.style.cssText = "width:42px; height:32px; padding:0; border:1px solid var(--border-strong); border-radius:6px; cursor:pointer;";
  colorInput.value = cfg.topbarColor || "#ffffff";
  const colorHex = document.createElement("input");
  colorHex.type = "text";
  colorHex.className = "admin-input";
  colorHex.style.cssText = "width:100px; font-family: monospace;";
  colorHex.placeholder = "#rrggbb";
  colorHex.value = cfg.topbarColor || "";
  const colorReset = document.createElement("button");
  colorReset.type = "button";
  colorReset.className = "btn btn-subtle";
  colorReset.textContent = "Réinitialiser";
  colorInput.addEventListener("input", async () => {
    const v = colorInput.value;
    colorHex.value = v;
    _applyTopbarColor(v);
    cfg.topbarColor = v;
    _refreshPresetSelected(v);
    await saveAdminConfig(cfg);
  });
  colorHex.addEventListener("change", async () => {
    const v = colorHex.value.trim();
    if (v && !/^#[0-9a-fA-F]{3,8}$/.test(v)) {
      showToast("Format invalide", "Utilise #rrggbb (ex: #1a73e8)");
      colorHex.value = cfg.topbarColor || "";
      return;
    }
    if (v) colorInput.value = v;
    _applyTopbarColor(v);
    cfg.topbarColor = v;
    _refreshPresetSelected(v);
    await saveAdminConfig(cfg);
  });
  colorReset.addEventListener("click", async () => {
    cfg.topbarColor = "";
    colorHex.value = "";
    colorInput.value = "#ffffff";
    _applyTopbarColor("");
    _refreshPresetSelected("");
    await saveAdminConfig(cfg);
    showToast("Couleur réinitialisée", "Topbar revenue au défaut");
  });
  customLine.appendChild(colorLabel);
  customLine.appendChild(colorInput);
  customLine.appendChild(colorHex);
  customLine.appendChild(colorReset);
  colorWrap.appendChild(customLine);
  colorRow.querySelector(".admin-row-control").appendChild(colorWrap);
  container.appendChild(colorRow);
  _refreshPresetSelected(cfg.topbarColor || "");

  // police de l'application — s'applique à TOUTE la page (topbar +
  // cards + popups + tooltips + panel admin). Liste de polices système.
  const fontRow = _makeAdminRow(
    "Police de l'application",
    "Style de texte pour toute la page (topbar, cartes, popups). Defaults système si non choisi."
  );
  const fontWrap = document.createElement("div");
  fontWrap.style.cssText = "display:flex; align-items:center; gap:8px; flex-wrap:wrap;";
  const fontSelect = document.createElement("select");
  fontSelect.className = "admin-select";
  fontSelect.style.minWidth = "260px";
  for (const opt of APP_FONT_OPTIONS) {
    const o = document.createElement("option");
    o.value = opt.val;
    o.textContent = opt.label;
    if (opt.stack) o.style.fontFamily = opt.stack;
    if ((cfg.appFont || cfg.topbarFont || "") === opt.val) o.selected = true;
    fontSelect.appendChild(o);
  }
  // Aperçu live à droite du select : affiche un petit texte avec la police.
  const fontPreview = document.createElement("span");
  fontPreview.style.cssText = "font-size:14px; color:var(--text-muted); padding:6px 10px; border:1px solid var(--border); border-radius:6px; background:var(--bg-muted);";
  const _refreshFontPreview = (val) => {
    const stack = _appFontStack(val);
    fontPreview.style.fontFamily = stack || "inherit";
    fontPreview.textContent = "Aperçu — Vendredi 24.04.2026";
  };
  _refreshFontPreview(cfg.appFont || cfg.topbarFont || "");
  fontSelect.addEventListener("change", async () => {
    const v = fontSelect.value;
    _applyAppFont(v);
    cfg.appFont = v;
    delete cfg.topbarFont; // nettoyage de l'ancienne clé.
    _refreshFontPreview(v);
    await saveAdminConfig(cfg);
  });
  fontWrap.appendChild(fontSelect);
  fontWrap.appendChild(fontPreview);
  fontRow.querySelector(".admin-row-control").appendChild(fontWrap);
  container.appendChild(fontRow);

  // option "Afficher les pauses" — fait apparaître le rectangle
  // dashed entre 2 iv qui ne s'enchainent pas, sur les 2 vues. Le hover
  // bidirectionnel rectangle ↔ timeline-hole est ensuite synchronisé.
  const gapsRow = _makeAdminRow(
    "Afficher les pauses",
    "Affiche un rectangle entre 2 interventions consécutives qui ne s'enchainent pas. Au survol du rectangle ou de la zone vide dans la timeline, les 2 se mettent en surbrillance ensemble."
  );
  const gapsLabel = document.createElement("label");
  gapsLabel.style.cssText = "display:flex; align-items:center; gap:8px; cursor:pointer;";
  const gapsCb = document.createElement("input");
  gapsCb.type = "checkbox";
  gapsCb.checked = !!cfg.showInterventionGaps;
  const gapsTxt = document.createElement("span");
  gapsTxt.textContent = "Activé";
  gapsLabel.appendChild(gapsCb);
  gapsLabel.appendChild(gapsTxt);
  gapsCb.addEventListener("change", async () => {
    cfg.showInterventionGaps = gapsCb.checked;
    // v2026.5.46 — exclusif avec « échelle de temps exacte » : activer
    // les pauses désactive le mode exact (re-rendu pour revenir aux blocs
    // Matin/Après-midi).
    let exactWasOn = false;
    if (gapsCb.checked && cfg.horizontalExactMode) {
      exactWasOn = true;
      cfg.horizontalExactMode = false;
      HORIZONTAL_EXACT_MODE = false;
      exactCb.checked = false;
      document.documentElement.classList.remove("horizontal-exact");
    }
    document.documentElement.classList.toggle("show-iv-gaps", gapsCb.checked);
    await saveAdminConfig(cfg);
    if (exactWasOn && state.currentData) {
      try { renderFromData(state.currentData); } catch (e) { /* rendu au prochain refresh */ }
    }
  });
  gapsRow.querySelector(".admin-row-control").appendChild(gapsLabel);
  container.appendChild(gapsRow);

  // v2026.5.46 — option « Vue horizontale : échelle de temps exacte » :
  // chaque carte est posée à son heure réelle sur une bande continue, le
  // bandeau timeline disparaît (les cartes portent le temps elles-mêmes).
  // EXCLUSIF avec « Afficher les pauses » (les rectangles de pause n'ont pas
  // de sens quand l'espace vide EST la pause) : cocher l'une décoche l'autre.
  const exactModeRow = _makeAdminRow(
    "Vue horizontale : échelle de temps exacte",
    "En vue horizontale, chaque intervention est placée pile à son heure réelle sur une échelle continue (une intervention à 9h est sous le repère 9h), largeur proportionnelle à la durée, chevauchements décalés en dessous. La barre du temps au-dessus des cartes disparaît. Incompatible avec « Afficher les pauses » : activer l'un désactive l'autre. La vue classique n'est pas affectée."
  );
  const exactLabel = document.createElement("label");
  exactLabel.style.cssText = "display:flex; align-items:center; gap:8px; cursor:pointer;";
  const exactCb = document.createElement("input");
  exactCb.type = "checkbox";
  exactCb.checked = !!cfg.horizontalExactMode;
  const exactTxt = document.createElement("span");
  exactTxt.textContent = "Activé";
  exactLabel.appendChild(exactCb);
  exactLabel.appendChild(exactTxt);
  exactCb.addEventListener("change", async () => {
    cfg.horizontalExactMode = exactCb.checked;
    HORIZONTAL_EXACT_MODE = exactCb.checked;
    if (exactCb.checked && cfg.showInterventionGaps) {
      cfg.showInterventionGaps = false;
      gapsCb.checked = false;
    }
    document.documentElement.classList.toggle("horizontal-exact", exactCb.checked);
    document.documentElement.classList.toggle("show-iv-gaps", !!cfg.showInterventionGaps);
    await saveAdminConfig(cfg);
    // reconstruire les rangées (bande exacte <-> blocs Matin/Après-midi)
    if (state.currentData) {
      try { renderFromData(state.currentData); } catch (e) { /* rendu au prochain refresh */ }
    }
  });
  exactModeRow.querySelector(".admin-row-control").appendChild(exactLabel);
  container.appendChild(exactModeRow);

  // v2026.5.46 — Mode coordinateur : RESTE dans Apparence, marqué « en
  // développement » (fonctionnalité non terminée). Affiche le badge « Mes
  // actions » dans la barre de stats.
  const coordRow = _makeAdminRow(
    "Mode coordinateur 🚧 en développement",
    "Affiche dans la barre de stats le nombre d'interventions où tu as une action (badge « Mes actions »), cliquable pour ouvrir la liste détaillée. Fonctionnalité en développement, pas encore finalisée. Désactivé par défaut."
  );
  const coordLabel = document.createElement("label");
  coordLabel.style.cssText = "display:flex; align-items:center; gap:8px; cursor:pointer;";
  const coordCb = document.createElement("input");
  coordCb.type = "checkbox";
  coordCb.checked = !!cfg.coordinatorMode;
  const coordTxt = document.createElement("span");
  coordTxt.textContent = "Activé";
  coordLabel.appendChild(coordCb);
  coordLabel.appendChild(coordTxt);
  coordCb.addEventListener("change", async () => {
    cfg.coordinatorMode = coordCb.checked;
    COORDINATOR_MODE = coordCb.checked;
    await saveAdminConfig(cfg);
    if (state.currentData) { try { renderFromData(state.currentData); } catch (e) {} } // rafraîchir la barre de stats
  });
  coordRow.querySelector(".admin-row-control").appendChild(coordLabel);
  container.appendChild(coordRow);
}

// Helper pour créer une ligne label/desc + zone contrôle (utilisée par
// plusieurs sections admin).
function _makeAdminRow(labelText, descText) {
  const row = document.createElement("div");
  row.className = "admin-row";
  const lbl = document.createElement("div");
  lbl.className = "admin-row-label";
  const strong = document.createElement("strong");
  strong.textContent = labelText;
  lbl.appendChild(strong);
  if (descText) {
    const d = document.createElement("div");
    d.className = "admin-row-desc";
    d.textContent = descText;
    lbl.appendChild(d);
  }
  const ctrl = document.createElement("div");
  ctrl.className = "admin-row-control";
  row.appendChild(lbl);
  row.appendChild(ctrl);
  return row;
}

// v2026.5.46 — onglet "Test (QRO)" : impersonation pour tester la vue
// coordinateur. N'affecte QUE l'affichage local (jamais EasyVista).
function renderAdminSectionImpersonate(container, cfg, saveFn) {
  cfg.impersonate = cfg.impersonate || { enabled: false, name: "", initials: "", memberId: "" };
  const imp = cfg.impersonate;

  const intro = document.createElement("p");
  intro.style.cssText = "font-size:13px; color:var(--text-muted); margin:0 0 6px;";
  intro.textContent = "Réservé à Quentin Rouiller. Permet de tester la vue « Mes actions » en te faisant passer pour une autre personne (ex. un coordinateur). N'affecte que l'affichage local de l'extension — aucune action côté EasyVista.";
  container.appendChild(intro);

  const who = document.createElement("p");
  who.style.cssText = "font-size:12px; color:var(--text-muted); margin:0 0 12px;";
  who.textContent = "Connecté en tant que : " + ((state.currentUser && state.currentUser.name) || "?");
  container.appendChild(who);

  const enRow = _makeAdminRow("Activer l'impersonation", "Quand c'est activé, « Mes actions » cherche l'action de la personne ci-dessous au lieu de la tienne.");
  const enLabel = document.createElement("label"); enLabel.style.cssText = "display:flex; align-items:center; gap:8px; cursor:pointer;";
  const enCb = document.createElement("input"); enCb.type = "checkbox"; enCb.checked = !!imp.enabled;
  const enTxt = document.createElement("span"); enTxt.textContent = "Activé";
  enLabel.appendChild(enCb); enLabel.appendChild(enTxt);
  enCb.addEventListener("change", async () => {
    imp.enabled = enCb.checked; _impersonate = imp; await saveAdminConfig(cfg);
    LOG.warn("impersonation", `${imp.enabled ? "ACTIVÉE" : "désactivée"} — identité simulée : ${imp.name || imp.initials || imp.memberId || "(vide)"}`);
  });
  enRow.querySelector(".admin-row-control").appendChild(enLabel);
  container.appendChild(enRow);

  const _txt = (labelTxt, desc, key, ph) => {
    const row = _makeAdminRow(labelTxt, desc);
    const inp = document.createElement("input"); inp.type = "text"; inp.className = "modal-form-input"; inp.value = imp[key] || ""; inp.placeholder = ph || "";
    inp.addEventListener("change", async () => {
      imp[key] = inp.value.trim(); _impersonate = imp; await saveAdminConfig(cfg);
      LOG.info("impersonation", `champ '${key}' = '${imp[key]}' (impersonation ${imp.enabled ? "active" : "inactive"})`);
    });
    row.querySelector(".admin-row-control").appendChild(inp);
    container.appendChild(row);
  };
  _txt("Nom de la personne", "Nom tel qu'il apparaît dans EasyVista (ex. « Monbaron, Cédric »).", "name", "Nom, Prénom");
  _txt("Initiales", "Initiales utilisées dans l'historique des fiches (ex. ECM, RPH, AWR).", "initials", "ECM");
  _txt("ID membre (optionnel)", "Identifiant EV de la personne, si tu le connais.", "memberId", "ex. 77160");
  // ─── v2026.5.46 — Conversion de l'ANCIEN cache dossier (v1 → v2) ─────
  const convHr = document.createElement("hr");
  convHr.style.cssText = "border:none; border-top:1px solid var(--border); margin:16px 0 12px;";
  container.appendChild(convHr);

  const convTitle = document.createElement("p");
  convTitle.style.cssText = "font-size:13px; font-weight:700; margin:0 0 4px;";
  convTitle.textContent = "♻️ Récupérer l'ancien cache dossier";
  container.appendChild(convTitle);

  const convIntro = document.createElement("p");
  convIntro.style.cssText = "font-size:12px; color:var(--text-muted); margin:0 0 10px;";
  convIntro.textContent = "Lit les fichiers-jour de l'ancienne version (AAAA\\MM\\AAAA-MM-JJ.json à la racine du partage), les convertit au nouveau format (verdicts, fait/clos, commentaires inclus) et les fusionne au planning local — la synchronisation les propage ensuite au sous-dossier v2. Les anciens fichiers ne sont pas modifiés. Réseau interne requis.";
  container.appendChild(convIntro);

  const convPathRow = _makeAdminRow("Dossier de l'ancien cache",
    "Racine du partage de l'ancienne version (pré-rempli avec le dossier configuré).");
  const convPathInp = document.createElement("input");
  convPathInp.type = "text";
  convPathInp.className = "modal-form-input";
  convPathInp.value = cfg.sharedCachePath || "";
  convPathInp.placeholder = "\\\\SERVEUR\\partage\\…\\Cache";
  convPathRow.querySelector(".admin-row-control").appendChild(convPathInp);
  container.appendChild(convPathRow);

  const convBtnRow = _makeAdminRow("Lancer la conversion",
    "Jour par jour ; le compte-rendu s'affiche ci-dessous. Relançable sans risque (fusion).");
  const convBtn = document.createElement("button");
  convBtn.type = "button";
  convBtn.className = "btn btn-secondary";
  convBtn.textContent = "♻️ Analyser et convertir";
  convBtnRow.querySelector(".admin-row-control").appendChild(convBtn);
  container.appendChild(convBtnRow);

  const convReport = document.createElement("div");
  convReport.style.cssText = "font-family:ui-monospace,monospace; font-size:11.5px; color:var(--text-muted); margin:4px 0 0; min-height:16px; white-space:pre-wrap;";
  container.appendChild(convReport);

  convBtn.addEventListener("click", () => {
    showAlertModal({
      title: "Convertir l'ancien cache dossier ?",
      message: "Tous les jours trouvés dans « " + (convPathInp.value || "?") + " » seront convertis et fusionnés au planning. Les anciens fichiers ne sont pas modifiés. Continuer ?",
      buttons: [
        { label: "Annuler", variant: "secondary", action: () => {} },
        {
          label: "Convertir",
          variant: "primary",
          action: async () => {
            convBtn.disabled = true;
            convBtn.textContent = "Conversion…";
            convReport.textContent = "Lecture de la liste des jours…";
            try {
              const res = await importLegacyFolderCache(convPathInp.value, (done, total, conv, skip) => {
                convReport.textContent = `… ${done}/${total} jour(s) — ${conv} converti(s), ${skip} ignoré(s)`;
              });
              if (res && res.ok) {
                convReport.textContent = `✅ Terminé : ${res.converted}/${res.total} jour(s) converti(s), ${res.skipped} ignoré(s), ${res.ivTotal} intervention(s).`;
                showToast("Ancien cache converti", `${res.converted} jour(s)`);
              } else {
                convReport.textContent = `❌ ${(res && res.error) || "échec inconnu"}`;
                showToast("Conversion impossible", (res && res.error) || "erreur");
              }
            } catch (err) {
              convReport.textContent = "❌ " + ((err && err.message) || String(err));
            } finally {
              convBtn.disabled = false;
              convBtn.textContent = "♻️ Analyser et convertir";
            }
          }
        }
      ]
    });
  });
}


// v2026.5.39 r7 : zoom GLOBAL via body.style.zoom — fait scaler TOUS les
// textes visibles. Couvre tooltip, intervention rows, absences, réservations,
// "En pompier", etc.
// Niveaux : -2 = 75% (-25%), -1 = 90%, 0 = 100%, +1 = 110%, +2 = 120%.
// v2026.5.39 r8 : on expose aussi --zoom-factor (et --zoom-inv) pour que
// le CSS compense les calculs vh sur la sidebar (sinon à 75% la sidebar
// ne couvre que 75vh de la viewport effective).
const TEXT_ZOOM_PCT = { "-2": 70, "-1": 85, "0": 100, "1": 110, "2": 120 };
function _applyTextZoom(level) {
  const lv = Math.max(-2, Math.min(2, parseInt(level, 10) || 0));
  const pct = TEXT_ZOOM_PCT[String(lv)] || 100;
  const factor = pct / 100;
  const html = document.documentElement;
  html.style.setProperty("--text-scale", String(factor));
  html.style.setProperty("--zoom-factor", String(factor));
  html.style.setProperty("--zoom-inv", String(1 / factor));
  if (document.body) {
    document.body.style.zoom = pct + "%";
  }
}

// Lit cfg.textZoom et l'applique dès que la config est chargée. Idempotent.
async function _initTextZoomFromConfig() {
  try {
    const cfg = await loadAdminConfig();
    if (typeof cfg.textZoom === "number") {
      _applyTextZoom(cfg.textZoom);
    }
  } catch (e) {
    LOG.warn("textZoom", "init failed", { err: e && e.message });
  }
}

// grande palette de polices proposées (incluant Arial, Helvetica,
// Tahoma, Verdana, Georgia, Times, Courier, etc. + variantes système).
// "" = défaut (police héritée de l'app, currently system-ui).
// La police choisie s'applique à TOUTE la page (body) et donc aux cards,
// popups, tooltips, panel admin — pas seulement à la topbar.
const APP_FONT_OPTIONS = [
  { val: "",            label: "Défaut (système)" },
  { val: "system",      label: "Système moderne (recommandé)",
    stack: 'system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif' },

  // ── Sans-serif classiques ──────────────────────────────────────────────
  { val: "arial",       label: "Arial",
    stack: 'Arial, Helvetica, sans-serif' },
  { val: "helvetica",   label: "Helvetica",
    stack: '"Helvetica Neue", Helvetica, Arial, sans-serif' },
  { val: "verdana",     label: "Verdana",
    stack: 'Verdana, Geneva, sans-serif' },
  { val: "tahoma",      label: "Tahoma",
    stack: 'Tahoma, Geneva, sans-serif' },
  { val: "trebuchet",   label: "Trebuchet MS",
    stack: '"Trebuchet MS", Tahoma, sans-serif' },
  { val: "calibri",     label: "Calibri",
    stack: 'Calibri, Candara, "Segoe UI", sans-serif' },
  { val: "segoe",       label: "Segoe UI",
    stack: '"Segoe UI", Tahoma, sans-serif' },
  { val: "gillsans",    label: "Gill Sans",
    stack: '"Gill Sans", "Gill Sans MT", Calibri, sans-serif' },
  { val: "futura",      label: "Futura",
    stack: 'Futura, "Trebuchet MS", Arial, sans-serif' },
  { val: "optima",      label: "Optima",
    stack: 'Optima, "Segoe UI", Candara, sans-serif' },

  // ── Serif ──────────────────────────────────────────────────────────────
  { val: "times",       label: "Times New Roman",
    stack: '"Times New Roman", Times, serif' },
  { val: "georgia",     label: "Georgia",
    stack: 'Georgia, "Times New Roman", serif' },
  { val: "cambria",     label: "Cambria",
    stack: 'Cambria, Georgia, serif' },
  { val: "garamond",    label: "Garamond",
    stack: 'Garamond, "EB Garamond", Georgia, serif' },
  { val: "palatino",    label: "Palatino",
    stack: '"Palatino Linotype", "Book Antiqua", Palatino, serif' },
  { val: "bookman",     label: "Bookman",
    stack: '"Bookman Old Style", Bookman, Georgia, serif' },

  // ── Monospace ──────────────────────────────────────────────────────────
  { val: "courier",     label: "Courier New",
    stack: '"Courier New", Courier, monospace' },
  { val: "consolas",    label: "Consolas",
    stack: 'Consolas, "Lucida Console", monospace' },
  { val: "lucida_mono", label: "Lucida Console",
    stack: '"Lucida Console", Consolas, monospace' },
  { val: "jetbrains",   label: "Mono moderne (JetBrains/Fira)",
    stack: '"JetBrains Mono", "Fira Code", Consolas, monospace' },

  // ── Display / fun ──────────────────────────────────────────────────────
  { val: "comic",       label: "Comic Sans MS",
    stack: '"Comic Sans MS", "Comic Neue", cursive' },
  { val: "impact",      label: "Impact",
    stack: 'Impact, "Arial Narrow Bold", sans-serif' },
  { val: "brush",       label: "Brush Script",
    stack: '"Brush Script MT", "Lucida Handwriting", cursive' },
  { val: "copperplate", label: "Copperplate",
    stack: 'Copperplate, "Copperplate Gothic Light", serif' },

  // ── Condensée ──────────────────────────────────────────────────────────
  { val: "condensed",   label: "Condensée (Arial Narrow)",
    stack: '"Arial Narrow", "Helvetica Narrow", "Roboto Condensed", sans-serif' }
];

function _appFontStack(val) {
  const opt = APP_FONT_OPTIONS.find(o => o.val === val);
  return (opt && opt.stack) || "";
}

// luminance d'une couleur hex (#rgb / #rrggbb) → 0..1. Sert à choisir
// automatiquement un texte LISIBLE (blanc ou foncé) sur le fond de topbar.
function _hexToLuminance(hex) {
  if (!hex || typeof hex !== "string") return 1;
  let m = hex.replace(/^#/, "").trim();
  if (m.length === 3) m = m.split("").map(c => c + c).join(""); // #abc → #aabbcc
  if (m.length !== 6) return 1;
  const r = parseInt(m.slice(0, 2), 16);
  const g = parseInt(m.slice(2, 4), 16);
  const b = parseInt(m.slice(4, 6), 16);
  if ([r, g, b].some(isNaN)) return 1;
  // Formule pondérée perception humaine.
  return (0.299 * r + 0.587 * g + 0.114 * b) / 255;
}
function _readableTextOn(hex) {
  return _hexToLuminance(hex) > 0.62 ? "#1a1f2b" : "#ffffff";
}

// applique la couleur de fond de la topbar (variable CSS --topbar-bg)
// + une couleur de texte lisible automatique (--topbar-text). Vide → on
// retire les deux variables, fallback aux defaults thème.
// on pose AUSSI la classe html.has-topbar-color pour que les boutons
// de la topbar adoptent un look translucide cohérent avec le fond choisi
// (sinon ils restent gris/blancs et deviennent illisibles sur fond foncé).
function _applyTopbarColor(color) {
  const html = document.documentElement;
  const v = (color || "").trim();
  if (v) {
    html.style.setProperty("--topbar-bg", v);
    html.style.setProperty("--topbar-text", _readableTextOn(v));
    html.classList.add("has-topbar-color");
  } else {
    html.style.removeProperty("--topbar-bg");
    html.style.removeProperty("--topbar-text");
    html.classList.remove("has-topbar-color");
  }
}

// applique la police à TOUTE la page via --app-font sur :root, héritée
// par body (cf. CSS body { font-family: var(--app-font, inherit); }).
function _applyAppFont(val) {
  const html = document.documentElement;
  const stack = _appFontStack(val);
  if (stack) {
    html.style.setProperty("--app-font", stack);
  } else {
    html.style.removeProperty("--app-font");
  }
}

// v2026.5.45 (issue #3) : lit le marqueur _lastInstallEvent posé par
// background.js dans chrome.runtime.onInstalled. Si la version précédente
// était < 2026.5.45 ET que ce n'est pas une fresh install, affiche un toast
// préventif invitant à vérifier les absences récurrentes (susceptibles
// d'avoir été corrompues par le bug d'écrasement de l'ancienne version).
// Marque ensuite l'event comme `notified: true` pour ne pas re-afficher.
// v2026.5.45 (issue #4) : reçoit les broadcasts cookieChanged émis
// par background.js. Quand le PHPSESSID change ou expire côté navigateur,
// on recale le compteur local de session sans avoir besoin d'attendre un
// fetch raté. Si le cookie est supprimé (removed) → on bascule en état
// "session expirée". Si une expirationDate fraîche arrive → on l'utilise
// pour aligner le compteur à la valeur EXACTE plutôt qu'à une estimation.
function _attachCookieChangeListener() {
  if (!chrome.runtime || !chrome.runtime.onMessage) return;
  if (_attachCookieChangeListener._attached) return;
  _attachCookieChangeListener._attached = true;
  chrome.runtime.onMessage.addListener((msg) => {
    if (!msg || msg.type !== "cookieChanged") return;
    try {
      const phpsessid8 = msg.phpsessid ? msg.phpsessid.slice(0, 8) + "…" : null;
      LOG.info("session", "broadcast cookieChanged reçu",
        { domain: msg.domain, removed: !!msg.removed, cause: msg.cause,
          phpsessid8, expirationDate: msg.expirationDate || null });
      if (msg.removed) {
        // v2026.5.46 — chrome.cookies émet TOUJOURS un événement
        // removed (cause "overwrite") juste AVANT de re-poser un cookie mis
        // à jour : ce n'est PAS une déconnexion, le nouveau cookie suit dans
        // la foulée. Basculer en « session expirée » ici affichait la
        // bannière à tort à chaque rafraîchissement du PHPSESSID.
        if (msg.cause === "overwrite") {
          LOG.info("session", "cookie PHPSESSID réécrit (overwrite) → nouveau cookie attendu, rien à faire");
          return;
        }
        // Vraie suppression (logout explicite, expiration, éviction) : on
        // laisse 3 s au navigateur/SSO pour poser un éventuel nouveau cookie
        // (relog), puis on VÉRIFIE au serveur avant d'alarmer.
        if (state._cookieRemovedTimer) clearTimeout(state._cookieRemovedTimer);
        state._cookieRemovedTimer = setTimeout(async () => {
          state._cookieRemovedTimer = null;
          if (state.sessionExpired) return;
          try {
            const resp = await sendMessage({ type: "getSessionRemaining" });
            if (resp && resp.ok && typeof resp.remainingMs === "number" && resp.remainingMs > 1000) {
              state.sessionExpireAt = Date.now() + resp.remainingMs;
              LOG.warn("session", "cookie supprimé mais session serveur vivante → pas d'expiration, compteur recalé");
              updateSessionIndicator();
              return;
            }
          } catch (e) { /* messaging KO → on retombe sur l'expiration */ }
          LOG.warn("session", `cookie PHPSESSID supprimé (${msg.domain}, cause=${msg.cause}) et session non confirmée → session expirée`);
          if (typeof handleSessionExpired === "function") handleSessionExpired();
        }, 3000);
        return;
      }
      if (msg.phpsessid) {
        // Un nouveau cookie annule une alarme « suppression » en attente.
        if (state._cookieRemovedTimer) {
          clearTimeout(state._cookieRemovedTimer);
          state._cookieRemovedTimer = null;
        }
        if (state.sessionExpired) {
          LOG.warn("session", `nouveau PHPSESSID ${phpsessid8} via cookie → reprise auto (relog détecté)`);
          state.sessionExpired = false;
          if (typeof hideSessionExpiredBanner === "function") hideSessionExpiredBanner();
        } else {
          LOG.info("session", `PHPSESSID rafraîchi en cookie (${phpsessid8})`);
        }
        // v2026.5.46 — l'expiration du COOKIE n'est pas celle de la
        // SESSION serveur (30 min d'inactivité glissantes) : l'ancien
        // recalibrage sur expirationDate faussait le compteur. On recale
        // sur la vérité serveur (session_time).
        _sessionServerSync({ force: true });
      }
    } catch (e) {
      LOG.warn("session", "cookieChanged handler err", { err: e && e.message });
    }
  });
  LOG.info("session", "listener cookieChanged attaché côté viewer");
}

async function _checkInstallEventAndNotify() {
  try {
    const stored = await chrome.storage.local.get("_lastInstallEvent");
    const ev = stored && stored._lastInstallEvent;
    if (!ev || ev.notified) return;
    const isUpdate = ev.reason === "update";
    const prev = ev.previousVersion || "";
    // Toast uniquement pour les mises à jour depuis < 2026.5.45.
    // Le bug d'écrasement existait dans toutes les versions antérieures.
    const isAffected = isUpdate && _versionIsBefore(prev, "2026.5.45");
    if (isAffected) {
      // Délai pour laisser le viewer s'initialiser proprement avant le toast.
      setTimeout(() => {
        showToast(
          `Mise à jour vers v${ev.currentVersion || LOG.version()}`,
          "Vérifiez vos absences récurrentes dans Paramètres → Équipe — un bug de l'ancienne version pouvait les effacer."
        );
      }, 2000);
    }
    // Marquer comme notifié dans tous les cas (pas de re-toast au prochain boot).
    ev.notified = true;
    await chrome.storage.local.set({ _lastInstallEvent: ev });
  } catch (e) {
    LOG.warn("install", "_checkInstallEventAndNotify err", { err: e && e.message });
  }
}

// Comparaison lexicographique des numéros sémantiques `YYYY.M.PATCH`. Retourne
// true si `a < b`. Retourne false si `a` est invalide ou >= b.
function _versionIsBefore(a, b) {
  if (!a) return false;
  const parse = s => String(s).split(".").map(n => parseInt(n, 10)).map(n => isNaN(n) ? 0 : n);
  const A = parse(a);
  const B = parse(b);
  const len = Math.max(A.length, B.length);
  for (let i = 0; i < len; i++) {
    const ai = A[i] || 0;
    const bi = B[i] || 0;
    if (ai < bi) return true;
    if (ai > bi) return false;
  }
  return false; // égales
}

async function _initTopbarStyleFromConfig() {
  try {
    const cfg = await loadAdminConfig();
    _applyTopbarColor(cfg.topbarColor || "");
    // ancien `topbarFont` migré vers `appFont` (couvre toute la page).
    _applyAppFont(cfg.appFont || cfg.topbarFont || "");
  } catch (e) {
    LOG.warn("topbarStyle", "init failed", { err: e && e.message });
  }
}

// la topbar étant sticky, les éléments stickys sous elle (bannière
// session, barre de progression, alerte session) doivent connaître sa
// hauteur RÉELLE pour ne pas se faire couper. Sa hauteur varie selon la
// police, le zoom, la taille de la date, donc on la mesure dynamiquement
// via ResizeObserver et on expose --topbar-height sur :root.
let _topbarRO = null;
function _initTopbarHeightVar() {
  const topbar = document.querySelector("header.topbar");
  if (!topbar) return;
  const updateVar = () => {
    const h = Math.ceil(topbar.getBoundingClientRect().height);
    if (h > 0) {
      document.documentElement.style.setProperty("--topbar-height", h + "px");
    }
    // on en profite pour vérifier dynamiquement si la topbar
    // déborde en mode "row" — si oui, on bascule en compact (column).
    _ensureTopbarFitsOrCompact();
    // v2026.5.46 — recalage de l'empilement collant (--topbar-h / --stack-top)
    // à CHAQUE changement de taille de la topbar/fenêtre. Sans ça, après avoir
    // réduit puis restauré la fenêtre, l'offset du sticky #topline restait figé
    // → décalage/gap de la ligne stats+recherche.
    if (typeof _srSyncStickyOffsets === "function") _srSyncStickyOffsets();
  };
  updateVar();
  try {
    if (_topbarRO) _topbarRO.disconnect();
    _topbarRO = new ResizeObserver(updateVar);
    _topbarRO.observe(topbar);
    _topbarRO.observe(document.body);  // pour réagir au redim. fenêtre
  } catch (e) {
    window.addEventListener("resize", updateVar);
  }
}

// détection dynamique de chevauchement dans la topbar (vue classique).
// pour pouvoir REVENIR en mode row depuis le compact, on doit mesurer
// la largeur des sections en mode row (= classe topbar-compact retirée).
// Sinon en compact .date-nav prend 100 % et leftWidth devient énorme → on
// reste bloqué en compact.
//
// Approche : on retire temporairement la classe avant la mesure (un flag
// évite la boucle infinie via ResizeObserver), on mesure, on réapplique
// si nécessaire. Le flash potentiel d'1 frame est invisible à l'œil.
let _measuringTopbar = false;
function _ensureTopbarFitsOrCompact() {
  if (_measuringTopbar) return;
  if (!document.documentElement.classList.contains("view-classic")) return;
  const tb = document.querySelector("header.topbar");
  if (!tb) return;
  const leftEl = tb.querySelector(".topbar-left");
  const rightEl = tb.querySelector(".topbar-right");
  if (!leftEl || !rightEl) return;

  const wasCompact = document.documentElement.classList.contains("topbar-compact");
  if (wasCompact) {
    _measuringTopbar = true;
    document.documentElement.classList.remove("topbar-compact");
    // Force un reflow synchrone pour que les widths reflètent le mode row.
    void tb.offsetWidth;
  }

  const measure = (el, gap) => {
    let sum = 0; let visibleCount = 0;
    for (const c of el.children) {
      if (!(c instanceof HTMLElement)) continue;
      if (c.classList.contains("hidden")) continue;
      const rect = c.getBoundingClientRect();
      if (rect.width === 0) continue;
      sum += rect.width;
      visibleCount++;
    }
    if (visibleCount > 1) sum += (visibleCount - 1) * gap;
    return sum;
  };

  const leftWidth = measure(leftEl, 14);
  const rightWidth = measure(rightEl, 8);
  const sessEl = document.getElementById("app-session");
  const sessWidth = (sessEl && !sessEl.classList.contains("hidden"))
    ? sessEl.getBoundingClientRect().width + 12 : 0;

  const padding = 40;
  const sectionGap = 12;
  const totalNeeded = leftWidth + rightWidth + sessWidth + padding + sectionGap;
  const available = window.innerWidth;

  const compactNeeded = totalNeeded > available - 4;
  document.documentElement.classList.toggle("topbar-compact", compactNeeded);
  _measuringTopbar = false;
}

// v2026.5.39 : génère un texte décrivant l'emplacement physique du cache
// chrome.storage.local selon le navigateur + l'OS détecté. Sert de tooltip
// (title=) sur le champ "Durée du cache" dans le panel admin.
function _getCacheLocationHint() {
  const ua = (navigator.userAgent || "").toLowerCase();
  const isFirefox = ua.includes("firefox") || ua.includes("gecko/");
  const isMac     = /mac|darwin/.test(ua);
  const isWin     = /windows|win64|win32/.test(ua);
  const isLinux   = /linux/.test(ua) && !isMac && !isWin;

  let extId = "?";
  try { extId = chrome.runtime.id || "?"; } catch (e) {}

  const lines = [];
  lines.push("Emplacement physique du cache :");
  lines.push("");
  if (isFirefox) {
    if (isMac) {
      lines.push("~/Library/Application Support/Firefox/Profiles/<profil>/");
      lines.push("  storage/default/moz-extension+++" + extId + "/idb/");
    } else if (isWin) {
      lines.push("%APPDATA%\\Mozilla\\Firefox\\Profiles\\<profil>\\");
      lines.push("  storage\\default\\moz-extension+++" + extId + "\\idb\\");
    } else if (isLinux) {
      lines.push("~/.mozilla/firefox/<profil>/storage/default/");
      lines.push("  moz-extension+++" + extId + "/idb/");
    } else {
      lines.push("(profil Firefox) / storage / default / moz-extension+++" + extId + " / idb /");
    }
  } else {
    // Chrome / Edge / Brave (Chromium-based)
    if (isMac) {
      lines.push("~/Library/Application Support/Google/Chrome/Default/");
      lines.push("  Local Extension Settings/" + extId + "/");
    } else if (isWin) {
      lines.push("%LOCALAPPDATA%\\Google\\Chrome\\User Data\\Default\\");
      lines.push("  Local Extension Settings\\" + extId + "\\");
    } else if (isLinux) {
      lines.push("~/.config/google-chrome/Default/");
      lines.push("  Local Extension Settings/" + extId + "/");
    } else {
      lines.push("(profil Chrome) / Local Extension Settings / " + extId + " /");
    }
  }
  lines.push("");
  lines.push("Extension ID : " + extId);
  return lines.join("\n");
}

// v2026.5.39 r6 : section "À propos" — version, description courte, auteur.
function renderAdminSectionAbout(container, cfg, saveFn) {
  const h = document.createElement("h3");
  h.textContent = "À propos";
  h.className = "admin-section-title";
  container.appendChild(h);

  const card = document.createElement("div");
  card.className = "admin-about-card";

  const v = LOG.version();
  card.innerHTML = `
    <div class="admin-about-row">
      <div class="admin-about-label">Extension</div>
      <div class="admin-about-value"><strong>Planification</strong></div>
    </div>
    <div class="admin-about-row">
      <div class="admin-about-label">Version</div>
      <div class="admin-about-value">v${escapeHtml(v)}</div>
    </div>
    <div class="admin-about-row">
      <div class="admin-about-label">Auteur</div>
      <div class="admin-about-value"><strong>Quentin Rouiller</strong></div>
    </div>
    <div class="admin-about-row">
      <div class="admin-about-label">Affiliation</div>
      <div class="admin-about-value">Technicien DGNSI — Canton de Vaud</div>
    </div>
    <div class="admin-about-desc">
      Extension Chrome / Firefox qui offre une vue claire et rapide du planning
      des techniciens DGNSI dans EasyVista. Regroupe interventions, réservations
      et absences par technicien avec timeline visuelle, popups détaillés
      épinglables, et 2 modes d'affichage (vue cards classique ou vue horizontale
      compacte).
    </div>
    <div class="admin-about-row">
      <div class="admin-about-label">Licence</div>
      <div class="admin-about-value">MIT</div>
    </div>
    <div class="admin-about-row">
      <div class="admin-about-label">Code source</div>
      <div class="admin-about-value"><a href="https://gitea.netaplaid.ch/FroSteel/Planification" target="_blank" rel="noopener">gitea.netaplaid.ch/FroSteel/Planification</a></div>
    </div>
  `;
  container.appendChild(card);
}

// Helper applique un thème (utilisé par le sélecteur Apparence).
// Si "auto", on retire data-theme pour laisser le CSS detecter prefers-color-scheme.
function _applyTheme(theme) {
  // v2026.5.41 : on résout "auto" en JS plutôt que de retirer data-theme,
  // car le CSS n'a pas de bloc @media (prefers-color-scheme: dark) et
  // retomberait sur le thème clair par défaut. On lit prefers-color-scheme
  // du navigateur et on pose data-theme="dark" ou "light" en conséquence.
  const html = document.documentElement;
  const effective = (theme === "light" || theme === "dark") ? theme : detectDefaultTheme();
  html.setAttribute("data-theme", effective);
  // Sync l'icône topbar avec le thème effectif.
  const icon = document.getElementById("theme-icon");
  if (icon) icon.textContent = effective === "dark" ? "☀️" : "🌙";
}

// v2026.5.41 : écoute les changements de thème OS pour les répercuter
// quand l'utilisateur est en mode "auto" (cfg.theme === "auto" ou absent).
function _watchOsThemeChanges() {
  if (!window.matchMedia) return;
  const mq = window.matchMedia("(prefers-color-scheme: dark)");
  const handler = async () => {
    try {
      const cfg = await loadAdminConfig();
      const pref = cfg.theme || "auto";
      if (pref === "auto") _applyTheme("auto");
    } catch (e) {}
  };
  if (mq.addEventListener) mq.addEventListener("change", handler);
  else if (mq.addListener) mq.addListener(handler);  // fallback Safari ancien
}

// export du cache planning au format JSON (toutes les clés
// planning_cache_*). Logge chaque étape (succès / échec) pour diagnostic.
async function exportPlanningCache() {
  LOG.info("cache-export", "début export du cache planning (store v2)");
  try {
    const all = await chrome.storage.local.get(null);
    const cacheData = {};
    let count = 0;
    let totalBytes = 0;
    for (const [k, v] of Object.entries(all)) {
      if (k.startsWith(STORE_PREFIX)) {
        cacheData[k] = v;
        count++;
      }
    }
    if (count === 0) {
      LOG.warn("cache-export", "aucune clé planv2_* trouvée → rien à exporter");
      showToast("Aucun cache", "Rien à exporter (aucune date en cache)");
      return;
    }
    const json = JSON.stringify(cacheData, null, 2);
    totalBytes = json.length;
    const blob = new Blob([json], { type: "application/json" });
    const url = URL.createObjectURL(blob);
    const a = document.createElement("a");
    a.href = url;
    a.download = `planning-cache-${todayISO()}.json`;
    document.body.appendChild(a);
    a.click();
    a.remove();
    URL.revokeObjectURL(url);
    LOG.warn("cache-export", `export OK → ${a.download}`,
      { fichier: a.download, jours: count, taille_kb: Math.round(totalBytes / 1024) });
    showToast("Cache exporté", `${count} jour(s) — ${Math.round(totalBytes / 1024)} Ko`);
  } catch (err) {
    LOG.error("cache-export", "export échoué", { err: err && err.message, stack: err && err.stack });
    showToast("Erreur export", (err && err.message) || String(err));
  }
}

// import du cache planning. Si pas de cache local → import direct,
// sinon modal "Tout écraser" / "Fusionner" / "Annuler". Logs verbeux.
async function importPlanningCache() {
  LOG.info("cache-import", "ouverture du sélecteur de fichier");
  const input = document.createElement("input");
  input.type = "file";
  input.accept = ".json,application/json";
  input.onchange = async () => {
    const file = input.files && input.files[0];
    if (!file) {
      LOG.info("cache-import", "aucun fichier sélectionné");
      return;
    }
    LOG.info("cache-import", "fichier sélectionné", { nom: file.name, taille_kb: Math.round(file.size / 1024) });
    let data, text;
    try {
      text = await file.text();
      data = JSON.parse(text);
    } catch (e) {
      LOG.error("cache-import", "JSON invalide", { err: e && e.message });
      showToast("JSON invalide", e.message || String(e));
      return;
    }
    let importedKeys = Object.keys(data).filter(k => k.startsWith(STORE_PREFIX));
    // v2026.5.46 — accepte AUSSI un FICHIER-JOUR v2 isolé (format dossier
    // « AAAA-MM-JJ.json » = {schema:2, savedAt, _gz}), pas seulement l'export
    // complet (clés planv2_*). La date vient du NOM du fichier.
    if (importedKeys.length === 0 && data && data.schema === 2) {
      const mDate = (file.name || "").match(/(\d{4}-\d{2}-\d{2})/);
      if (!mDate) {
        showToast("Date introuvable", "Renomme le fichier en AAAA-MM-JJ.json pour l'importer comme un jour.");
        return;
      }
      const day = await _deserializeDayV2(text);
      if (!day || !Array.isArray(day.ivs)) {
        showToast("Fichier-jour illisible", "Contenu inattendu (ni export, ni jour v2 valide).");
        return;
      }
      day.date = mDate[1];
      data = { [STORE_PREFIX + mDate[1]]: day };
      importedKeys = [STORE_PREFIX + mDate[1]];
      LOG.info("cache-import", `fichier-jour v2 détecté → ${mDate[1]} (${day.ivs.length} iv)`);
    }
    if (importedKeys.length === 0) {
      LOG.warn("cache-import", "aucune clé planv2_* ni fichier-jour v2 valide (les exports de l'ancienne version ne sont pas compatibles)");
      showToast("Aucun cache trouvé", "Fichier export v2 (planv2_*) ou jour v2 (AAAA-MM-JJ.json) attendu.");
      return;
    }
    // filet : ne garder que des entrées jour v2 bien formées
    importedKeys = importedKeys.filter(k => {
      const d = data[k];
      return d && d.schema === 2 && Array.isArray(d.ivs);
    });
    LOG.info("cache-import", `${importedKeys.length} clé(s) v2 trouvée(s) dans le fichier`);

    // après import : si le jour AFFICHÉ fait partie des clés importées, la
    // copie mémoire (state.currentDay = la vérité) doit être rechargée depuis
    // le storage, sinon le prochain storeSave écraserait l'import silencieusement.
    const _importRefreshCurrent = async (keys) => {
      try {
        if (state.currentDate && keys.includes(STORE_PREFIX + state.currentDate)) {
          state.currentDay = await storeLoad(state.currentDate);
          storeRenderCurrent("import");
        }
      } catch (e) { /* best-effort */ }
    };

    const allLocal = await chrome.storage.local.get(null);
    const localKeys = Object.keys(allLocal).filter(k => k.startsWith(STORE_PREFIX));

    if (localKeys.length === 0) {
      // Pas de cache local → import direct
      try {
        const toSet = {};
        for (const k of importedKeys) toSet[k] = data[k];
        await chrome.storage.local.set(toSet);
        LOG.warn("cache-import", `import direct OK (cache local vide) — ${importedKeys.length} jour(s)`);
        showToast("Cache importé", `${importedKeys.length} jour(s) ajouté(s)`);
        await _importRefreshCurrent(importedKeys);
      } catch (err) {
        LOG.error("cache-import", "écriture chrome.storage échouée", { err: err && err.message });
        showToast("Erreur import", (err && err.message) || String(err));
      }
      return;
    }

    LOG.info("cache-import", `cache local existant (${localKeys.length} jour(s)) → modal de choix`);
    showAlertModal({
      title: "Cache déjà présent",
      message: `Tu as déjà ${localKeys.length} jour(s) en cache local. Le fichier en contient ${importedKeys.length}. Que faire ?`,
      buttons: [
        { label: "Annuler", variant: "secondary", action: () => {
          LOG.info("cache-import", "annulé par l'user");
        } },
        {
          label: "Tout écraser",
          variant: "danger",
          action: async () => {
            try {
              await chrome.storage.local.remove(localKeys);
              const toSet = {};
              for (const k of importedKeys) toSet[k] = data[k];
              await chrome.storage.local.set(toSet);
              LOG.warn("cache-import",
                `écrasement OK — ${localKeys.length} ancien(s) supprimé(s), ${importedKeys.length} importé(s)`);
              showToast("Cache remplacé", `${importedKeys.length} jour(s) — anciennes données supprimées`);
              await _importRefreshCurrent(importedKeys);
            } catch (err) {
              LOG.error("cache-import", "écrasement échoué", { err: err && err.message });
              showToast("Erreur import", (err && err.message) || String(err));
            }
          }
        },
        {
          label: "Fusionner",
          variant: "primary",
          action: async () => {
            try {
              // v2026.5.46 — vraie fusion par intervention (dayMerge →
              // ivMerge, modèle vie/mort), plus un simple « le savedAt le plus
              // récent écrase l'autre jour entier ».
              const toSet = {};
              let added = 0, merged = 0;
              for (const k of importedKeys) {
                const local = allLocal[k];
                const imported = data[k];
                if (!local) { toSet[k] = imported; added++; }
                else { toSet[k] = dayMerge(local, imported); merged++; }
              }
              if (Object.keys(toSet).length > 0) await chrome.storage.local.set(toSet);
              LOG.warn("cache-import",
                `fusion OK — ${added} jour(s) ajouté(s), ${merged} jour(s) fusionné(s) par intervention`);
              showToast("Fusion OK", `${added} ajouté(s), ${merged} fusionné(s)`);
              await _importRefreshCurrent(importedKeys);
            } catch (err) {
              LOG.error("cache-import", "fusion échouée", { err: err && err.message });
              showToast("Erreur fusion", (err && err.message) || String(err));
            }
          }
        }
      ]
    });
  };
  input.click();
}

// export / import de admin_config (paramètres). Pas de modal —
// import = écrasement direct. Logs verbeux.
async function exportAdminConfig() {
  LOG.info("config-export", "début export des paramètres");
  try {
    const stored = await chrome.storage.local.get(ADMIN_CONFIG_KEY);
    const cfg = (stored && stored[ADMIN_CONFIG_KEY]) || {};
    if (!cfg || Object.keys(cfg).length === 0) {
      LOG.warn("config-export", "aucun admin_config en local — export d'un objet vide");
    }
    const json = JSON.stringify({ [ADMIN_CONFIG_KEY]: cfg }, null, 2);
    const blob = new Blob([json], { type: "application/json" });
    const url = URL.createObjectURL(blob);
    const a = document.createElement("a");
    a.href = url;
    a.download = `planning-config-${todayISO()}.json`;
    document.body.appendChild(a);
    a.click();
    a.remove();
    URL.revokeObjectURL(url);
    LOG.warn("config-export", `export OK → ${a.download}`,
      { fichier: a.download, taille_octets: json.length });
    showToast("Paramètres exportés", a.download);
  } catch (err) {
    LOG.error("config-export", "export échoué", { err: err && err.message, stack: err && err.stack });
    showToast("Erreur export", (err && err.message) || String(err));
  }
}

async function importAdminConfig() {
  LOG.info("config-import", "ouverture du sélecteur de fichier");
  const input = document.createElement("input");
  input.type = "file";
  input.accept = ".json,application/json";
  input.onchange = async () => {
    const file = input.files && input.files[0];
    if (!file) {
      LOG.info("config-import", "aucun fichier sélectionné");
      return;
    }
    LOG.info("config-import", "fichier sélectionné", { nom: file.name, taille_octets: file.size });
    let data;
    try {
      const text = await file.text();
      data = JSON.parse(text);
    } catch (e) {
      LOG.error("config-import", "JSON invalide", { err: e && e.message });
      showToast("JSON invalide", e.message || String(e));
      return;
    }
    // On accepte deux formats : { admin_config: {...} } OU directement {...}
    const cfg = (data && typeof data === "object" && data[ADMIN_CONFIG_KEY])
      ? data[ADMIN_CONFIG_KEY]
      : data;
    if (!cfg || typeof cfg !== "object") {
      LOG.error("config-import", "format invalide — pas d'objet admin_config");
      showToast("Fichier invalide", "Aucune config admin_config trouvée");
      return;
    }
    try {
      await chrome.storage.local.set({ [ADMIN_CONFIG_KEY]: cfg });
      LOG.warn("config-import", `import OK — recharge la page pour appliquer`,
        { keys: Object.keys(cfg) });
      showToast("Paramètres importés", "Recharge la page pour appliquer");
    } catch (err) {
      LOG.error("config-import", "écriture chrome.storage échouée", { err: err && err.message });
      showToast("Erreur import", (err && err.message) || String(err));
    }
  };
  input.click();
}

// v2026.5.46 : onglet dédié à la synchronisation dossier partagé.
let _syncLogTimer = null;

function renderAdminSectionSync(container, cfg, saveFn) {
  if (_syncLogTimer) { clearInterval(_syncLogTimer); _syncLogTimer = null; }

  const SUB_TITLE_STYLE = "margin:24px 0 8px 0; font-size:14px; font-weight:600; color:var(--text); border-bottom:1px solid var(--border); padding-bottom:4px;";
  const SUB_HINT_STYLE = "font-size:12px; color:var(--text-faint); margin:0 0 10px 0;";

  const h = document.createElement("h3");
  h.textContent = "Synchronisation";
  h.className = "admin-section-title";
  container.appendChild(h);

  const intro = document.createElement("p");
  intro.textContent = "Partage le cache du planning entre postes via un dossier réseau (une image par jour, classée par année/mois). Nécessite le petit script d'installation. L'extension fonctionne normalement sans.";
  intro.style.cssText = SUB_HINT_STYLE;
  container.appendChild(intro);

  // v2026.5.47 — panneau réorganisé en SECTIONS logiques (retour Quentin :
  // « c'était pas clair, Re-vérifier n'était pas au bon endroit »). Chaque action
  // vit dans la section qui la concerne :
  //   1. État        → grille + « Re-vérifier l'état » (c'est lui qu'il rafraîchit)
  //   2. Dossier     → le chemin du partage
  //   3. Script poste → installeur + « Tester la communication » + résultat
  //   4. Journal      → « Ouvrir dans un onglet » + mode détaillé + log en direct

  // ── 1. État ──────────────────────────────────────────────────────────────
  const etatTitle = document.createElement("div");
  etatTitle.textContent = "État de la synchronisation";
  etatTitle.style.cssText = SUB_TITLE_STYLE;
  container.appendChild(etatTitle);

  const syncStatus = document.createElement("div");
  syncStatus.className = "admin-diag-grid";
  syncStatus.innerHTML = `<div><strong>État</strong></div><div>⏳ vérification…</div>`;
  container.appendChild(syncStatus);

  const reprobeRow = document.createElement("div");
  reprobeRow.style.cssText = "display:flex; gap:8px; margin-top:8px;";
  const reprobeBtn = document.createElement("button");
  reprobeBtn.type = "button";
  reprobeBtn.className = "btn btn-subtle";
  reprobeBtn.textContent = "🔁 Re-vérifier l'état";
  reprobeBtn.addEventListener("click", () => _refreshSyncStatus());
  reprobeRow.appendChild(reprobeBtn);
  container.appendChild(reprobeRow);

  // ── 2. Dossier partagé ───────────────────────────────────────────────────
  const dossierTitle = document.createElement("div");
  dossierTitle.textContent = "Dossier partagé";
  dossierTitle.style.cssText = SUB_TITLE_STYLE;
  container.appendChild(dossierTitle);

  const pathRow = _makeAdminRow(
    "Chemin (UNC ou lecteur réseau)",
    "Ex. \\\\SERVEUR\\partage\\…\\Cache — laissé vide = synchronisation désactivée."
  );
  const pathInput = document.createElement("input");
  pathInput.type = "text";
  pathInput.className = "admin-input";
  pathInput.style.cssText = "min-width:320px;";
  pathInput.placeholder = "\\\\SERVEUR\\partage\\…\\Cache";
  pathInput.value = cfg.sharedCachePath || "";
  pathInput.addEventListener("change", async () => {
    cfg.sharedCachePath = pathInput.value.trim();
    try {
      await saveAdminConfig(cfg);
      showToast("Dossier partagé", cfg.sharedCachePath ? "Enregistré" : "Synchronisation désactivée");
      _refreshSyncStatus();
    } catch (err) {
      showToast("Erreur", "Impossible d'enregistrer (voir console F12)");
    }
  });
  pathRow.querySelector(".admin-row-control").appendChild(pathInput);
  container.appendChild(pathRow);

  // ── 3. Script de synchronisation (sur le poste) ──────────────────────────
  const scriptTitle = document.createElement("div");
  scriptTitle.textContent = "Script de synchronisation (sur le poste)";
  scriptTitle.style.cssText = SUB_TITLE_STYLE;
  container.appendChild(scriptTitle);

  const scriptHint = document.createElement("p");
  scriptHint.textContent = "Petit script à installer sur le poste Windows : il fait le lien avec le dossier partagé. Installe-le, puis teste la communication de bout en bout.";
  scriptHint.style.cssText = SUB_HINT_STYLE;
  container.appendChild(scriptHint);

  const scriptRow = document.createElement("div");
  scriptRow.style.cssText = "display:flex; gap:8px; flex-wrap:wrap; align-items:center;";
  const dlLink = document.createElement("a");
  // v2026.5.46 — le script hôte (PowerShell) est publié en ASSET de la release
  // de la version courante : téléchargement direct du zip, prêt à dézipper et
  // lancer (Gerer.cmd). URL construite avec la version → chaque version de
  // l extension pointe vers SON installeur.
  dlLink.href = "https://gitea.netaplaid.ch/FroSteel/Planification/releases/download/v" +
    ((typeof LOG !== "undefined" && LOG.version && LOG.version()) || "2026.5.47") +
    "/planification-native-host.zip";
  dlLink.target = "_blank";
  dlLink.rel = "noopener";
  dlLink.className = "btn";
  dlLink.textContent = "⬇ Télécharger l'installeur";
  scriptRow.appendChild(dlLink);
  // v2026.5.47 — test de communication de bout en bout (extension → hôte →
  // dossier). Rangé ici, avec l'installeur : on installe, puis on teste.
  const testBtn = document.createElement("button");
  testBtn.type = "button";
  testBtn.className = "btn";
  testBtn.textContent = "🔌 Tester la communication";
  testBtn.addEventListener("click", () => _testComm());
  scriptRow.appendChild(testBtn);
  container.appendChild(scriptRow);

  const testResult = document.createElement("pre");
  testResult.style.cssText = "margin:8px 0 0 0; padding:10px; background:var(--bg-muted); border:1px solid var(--border); border-radius:6px; font-family:Consolas,monospace; font-size:12px; white-space:pre-wrap; word-break:break-word; display:none;";
  container.appendChild(testResult);

  // (Cache local : déplacé dans l'onglet « Données » — v2026.1.6.)

  const logTitle = document.createElement("div");
  logTitle.textContent = "📜 Journal d'activité (en direct)";
  logTitle.style.cssText = SUB_TITLE_STYLE;
  container.appendChild(logTitle);

  // v2026.5.47 — « Ouvrir dans un onglet » rangé AVEC le journal (c'est le
  // journal qu'il ouvre en grand), plus dans un pêle-mêle de boutons.
  const journalActions = document.createElement("div");
  journalActions.style.cssText = "display:flex; gap:8px; margin:0 0 8px 0;";
  const tabBtn = document.createElement("button");
  tabBtn.type = "button";
  tabBtn.className = "btn btn-subtle";
  tabBtn.textContent = "↗ Ouvrir dans un onglet";
  tabBtn.addEventListener("click", () => nmShowLog());
  journalActions.appendChild(tabBtn);
  container.appendChild(journalActions);

  const verboseWrap = document.createElement("label");
  verboseWrap.style.cssText = "display:flex; align-items:center; gap:8px; font-size:13px; margin:0 0 8px 0; cursor:pointer;";
  const verboseChk = document.createElement("input");
  verboseChk.type = "checkbox";
  verboseChk.checked = !!cfg.syncVerbose;
  verboseWrap.appendChild(verboseChk);
  verboseWrap.appendChild(document.createTextNode("Tout afficher (mode détaillé)"));
  container.appendChild(verboseWrap);

  const logPre = document.createElement("pre");
  logPre.style.cssText = "background:var(--bg-alt,#1b1b1b); color:var(--text,#ddd); border:1px solid var(--border); border-radius:6px; padding:10px; height:280px; overflow:auto; font-family:Consolas,monospace; font-size:12px; white-space:pre-wrap; word-break:break-word; margin:0;";
  logPre.textContent = "⏳ chargement du journal…";
  container.appendChild(logPre);

  verboseChk.addEventListener("change", async () => {
    cfg.syncVerbose = verboseChk.checked;
    try { await saveAdminConfig(cfg); } catch (e) {}
    _loadSyncLog();
  });

  // v2026.5.47 — test de communication de bout en bout, sur demande
  // (bouton). Trois étapes lisibles : hôte joignable + version, dossier
  // configuré, puis aller-retour RÉEL (stat d'une date via l'hôte → prouve que
  // l'hôte atteint le dossier partagé). Best-effort, jamais bloquant.
  async function _testComm() {
    testResult.style.display = "block";
    testResult.textContent = "⏳ test en cours…";
    const lines = [];
    try {
      const ok = await nmProbe(true);
      if (!ok) {
        testResult.textContent = "❌ Le script hôte ne répond pas (non installé ou arrêté).\n" +
          "→ Télécharge et lance l'installeur, puis relance ce test.";
        return;
      }
      lines.push(`✅ Script hôte joignable — v${_nmVersion || "?"} (communication extension ↔ hôte OK)`);
      const path = (cfg.sharedCachePath || "").trim();
      if (!path) {
        lines.push("⚠️ Aucun dossier partagé défini — la synchronisation est désactivée.");
        testResult.textContent = lines.join("\n");
        return;
      }
      lines.push(`• Dossier : ${path}`);
      const testDate = state.currentDate || new Date().toISOString().slice(0, 10);
      const st = await nmStatDay(testDate, path);
      if (st && typeof st.exists === "boolean") {
        const maj = (st.exists && st.savedAt) ? ` (dernière maj ${new Date(st.savedAt).toLocaleString()})` : "";
        lines.push(`✅ Dossier atteint — aller-retour hôte ↔ dossier OK.`);
        lines.push(`   Planning du ${testDate} : ${st.exists ? "présent dans le dossier" + maj : "absent du dossier"}.`);
      } else {
        lines.push("❌ Le dossier n'a pas répondu (chemin injoignable, hors réseau interne, ou droits insuffisants).");
      }
    } catch (e) {
      lines.push("❌ Erreur pendant le test (voir console F12) : " + (e && e.message));
    }
    testResult.textContent = lines.join("\n");
  }

  async function _refreshSyncStatus() {
    syncStatus.innerHTML = `<div><strong>État</strong></div><div>⏳ vérification…</div>`;
    let line;
    try {
      const ok = await nmProbe(true);
      if (!ok) line = "❌ script non installé — télécharge et lance l'installeur";
      // v2026.5.46 — « obsolète » UNIQUEMENT si la version installée est
      // réellement PLUS ANCIENNE que celle requise (comparaison sémantique).
      // Une version égale OU plus récente = à jour (avant, tout ≠ était flaggé).
      else if (_versionIsBefore(_nmVersion, NM_HOST_REQUIRED_VERSION)) line = `⚠️ script v${escapeHtml(_nmVersion || "?")} obsolète (requis v${NM_HOST_REQUIRED_VERSION}) — relance l'installeur`;
      else line = `✅ actif (v${escapeHtml(_nmVersion)})`;
    } catch (e) {
      line = "❌ erreur de vérification (voir console F12)";
    }
    const pathTxt = (cfg.sharedCachePath || "").trim() || "— non défini —";
    syncStatus.innerHTML =
      `<div><strong>État</strong></div><div>${line}</div>` +
      `<div><strong>Dossier</strong></div><div>${escapeHtml(pathTxt)}</div>`;
  }

  async function _loadSyncLog() {
    if (!document.body.contains(logPre)) {
      if (_syncLogTimer) { clearInterval(_syncLogTimer); _syncLogTimer = null; }
      return;
    }
    let txt = "";
    try { txt = await nmGetLog(); } catch (e) {}
    let lines = (txt || "").split("\n");
    if (!cfg.syncVerbose) lines = lines.filter(l => !/\[DEBUG\]/.test(l));
    lines = lines.filter(l => l.length);
    const atBottom = (logPre.scrollTop + logPre.clientHeight >= logPre.scrollHeight - 20);
    if (!lines.length) {
      logPre.innerHTML = `<div style="color:#888">(aucune activité pour le moment)</div>`;
    } else {
      logPre.innerHTML = lines.map(l => {
        let color = "#9cdcfe";                       // INFO
        if (/\[ERREUR\]/.test(l)) color = "#ff6b6b"; // erreur
        else if (/\[DEBUG\]/.test(l)) color = "#9a9a9a"; // détail
        const m = /^(\d{2}\/\d{2}\/\d{4} \d{2}:\d{2}:\d{2})(.*)$/.exec(l);
        if (m) return `<div><span style="color:#777">${escapeHtml(m[1])}</span><span style="color:${color}">${escapeHtml(m[2])}</span></div>`;
        return `<div style="color:${color}">${escapeHtml(l)}</div>`;
      }).join("");
    }
    if (atBottom) logPre.scrollTop = logPre.scrollHeight;
  }

  _refreshSyncStatus();
  _loadSyncLog();
  _syncLogTimer = setInterval(_loadSyncLog, 3000);
}

// v2026.1.6 — QRO : onglet « Données » — cache local + sauvegarde des paramètres
// (regroupe ce qui était éparpillé dans Synchronisation et Diagnostics).
function renderAdminSectionData(container, cfg, saveFn) {
  const SUB_TITLE_STYLE = "margin:24px 0 8px 0; font-size:14px; font-weight:600; color:var(--text); border-bottom:1px solid var(--border); padding-bottom:4px;";
  const SUB_HINT_STYLE = "font-size:12px; color:var(--text-faint); margin:0 0 10px 0;";

  const h = document.createElement("h3");
  h.textContent = "Données";
  h.className = "admin-section-title";
  container.appendChild(h);

  // ─── Cache local du planning ──────────────────────────────────────────
  const cacheTitle = document.createElement("div");
  cacheTitle.textContent = "📦 Cache local du planning";
  cacheTitle.style.cssText = SUB_TITLE_STYLE;
  container.appendChild(cacheTitle);

  const cacheDurRow = _makeAdminRow(
    "Durée du cache (jours)",
    "Au-delà, les anciens caches locaux sont purgés automatiquement. Défaut : 7 jours."
  );
  cacheDurRow.title = _getCacheLocationHint();
  const cacheInput = document.createElement("input");
  cacheInput.type = "number";
  cacheInput.min = "1";
  cacheInput.max = "365";
  cacheInput.step = "1";
  cacheInput.className = "admin-input admin-input-num";
  cacheInput.value = String(cfg.cacheDays || 7);
  cacheInput.addEventListener("change", async () => {
    let v = parseInt(cacheInput.value, 10);
    if (isNaN(v) || v < 1) v = 1;
    if (v > 365) v = 365;
    cacheInput.value = String(v);
    cfg.cacheDays = v;
    try {
      await saveAdminConfig(cfg);
      showToast("Durée du cache", `${v} jour(s)`);
    } catch (err) {
      showToast("Erreur", "Impossible d'enregistrer (voir console F12)");
    }
  });
  cacheDurRow.querySelector(".admin-row-control").appendChild(cacheInput);
  container.appendChild(cacheDurRow);

  const cacheBtnRow = document.createElement("div");
  cacheBtnRow.style.cssText = "display:flex; gap:8px; flex-wrap:wrap; margin-top:8px;";
  const exportCacheBtn = document.createElement("button");
  exportCacheBtn.type = "button";
  exportCacheBtn.className = "btn";
  exportCacheBtn.textContent = "💾 Exporter le cache (.json)";
  exportCacheBtn.addEventListener("click", () => exportPlanningCache());
  cacheBtnRow.appendChild(exportCacheBtn);
  const importCacheBtn = document.createElement("button");
  importCacheBtn.type = "button";
  importCacheBtn.className = "btn";
  importCacheBtn.textContent = "📂 Importer un cache (export ou 1 jour)";
  importCacheBtn.addEventListener("click", () => importPlanningCache());
  cacheBtnRow.appendChild(importCacheBtn);
  container.appendChild(cacheBtnRow);

  // ─── Sauvegarde des paramètres ────────────────────────────────────────
  const cfgTitle = document.createElement("div");
  cfgTitle.textContent = "💾 Sauvegarde des paramètres";
  cfgTitle.style.cssText = SUB_TITLE_STYLE;
  container.appendChild(cfgTitle);

  const cfgHint = document.createElement("p");
  cfgHint.textContent = "L'import remplace directement les paramètres courants — pas de fusion.";
  cfgHint.style.cssText = SUB_HINT_STYLE;
  container.appendChild(cfgHint);

  const cfgBtnRow = document.createElement("div");
  cfgBtnRow.style.cssText = "display:flex; gap:8px; flex-wrap:wrap;";
  const exportCfgBtn = document.createElement("button");
  exportCfgBtn.type = "button";
  exportCfgBtn.className = "btn";
  exportCfgBtn.textContent = "💾 Exporter les paramètres (.json)";
  exportCfgBtn.addEventListener("click", () => exportAdminConfig());
  cfgBtnRow.appendChild(exportCfgBtn);
  const importCfgBtn = document.createElement("button");
  importCfgBtn.type = "button";
  importCfgBtn.className = "btn";
  importCfgBtn.textContent = "📂 Importer les paramètres (.json)";
  importCfgBtn.addEventListener("click", () => importAdminConfig());
  cfgBtnRow.appendChild(importCfgBtn);
  container.appendChild(cfgBtnRow);
}

function renderAdminSectionDiagnostics(container, cfg, saveFn) {
  const h = document.createElement("h3");
  h.textContent = "Diagnostics";
  h.className = "admin-section-title";
  container.appendChild(h);

  // v2026.5.38 : on passe par LOG.version() qui a déjà gardé une copie au boot
  const version = LOG.version();

  const info = document.createElement("div");
  info.className = "admin-diag-grid";
  info.innerHTML = `
    <div><strong>Version</strong></div><div>${escapeHtml(version)}</div>
    <div><strong>Date courante</strong></div><div>${escapeHtml(state.currentDate || "?")}</div>
    <div><strong>Aujourd'hui</strong></div><div>${escapeHtml(todayISO())}</div>
    <div><strong>Session EasyVista</strong></div><div>${state.session ? "✓ connecté (" + (state.session.origin || "?") + ")" : "✗ non détecté"}</div>
    <div><strong>Popups épinglées</strong></div><div>${pinnedPopups.length}</div>
  `;
  container.appendChild(info);

  // on regroupe tout ce qui touche au cache dans une sous-section
  // dédiée (durée + export + import) pour que ce soit logique visuellement.
  const SUB_TITLE_STYLE = "margin:24px 0 8px 0; font-size:14px; font-weight:600; color:var(--text); border-bottom:1px solid var(--border); padding-bottom:4px;";
  const SUB_HINT_STYLE = "font-size:12px; color:var(--text-faint); margin:0 0 10px 0;";

  // (Cache du planning : déplacé dans l'onglet « Synchronisation » — v2026.5.46.)

  // (Sauvegarde des paramètres : déplacée dans l'onglet « Données » — v2026.1.6.)

  // (Réinitialisation des absences récurrentes : déplacée dans l'onglet « Équipe » — v2026.1.5.)

  // ─── Sous-section : Système ──────────────────────────────────────────
  const sysTitle = document.createElement("div");
  sysTitle.textContent = "🛠 Système";
  sysTitle.style.cssText = SUB_TITLE_STYLE;
  container.appendChild(sysTitle);

  // Toggle "Logs verbeux (debug)"
  const debugRow = document.createElement("label");
  debugRow.className = "admin-debug-row";
  debugRow.style.cssText = "display:flex; align-items:center; gap:10px; padding:10px; background:var(--bg-muted); border-radius:6px; cursor:pointer;";
  const debugCheckbox = document.createElement("input");
  debugCheckbox.type = "checkbox";
  debugCheckbox.checked = LOG.isDebug();
  const debugText = document.createElement("div");
  debugText.style.cssText = "flex:1;";
  debugText.innerHTML = `<strong>Logs verbeux (debug)</strong><div style="font-size:12px; color:var(--text-faint); margin-top:2px;">Affiche les étapes détaillées dans la console (F12). À activer pour signaler un bug avec un max de contexte.</div>`;
  debugRow.appendChild(debugCheckbox);
  debugRow.appendChild(debugText);
  debugCheckbox.addEventListener("change", () => {
    LOG.setDebug(debugCheckbox.checked);
    LOG.warn("admin", `debug logs ${debugCheckbox.checked ? "activés" : "désactivés"}`);
    showToast("Debug logs", debugCheckbox.checked ? "ACTIVÉ — voir console F12" : "désactivé");
  });
  container.appendChild(debugRow);

  // v2026.5.45 — Toggle "Garder les disparitions" (mode diagnostic ghosts)
  // Décorrélé de "Logs verbeux". Quand coché : aucun ghost n'est retiré, on
  // log juste les verdicts. Quand décoché (défaut) : verdict REMOVE = retrait
  // effectif de l'iv du planning.
  const keepDiagRow = document.createElement("label");
  keepDiagRow.className = "admin-keep-diag-row";
  keepDiagRow.style.cssText = "display:flex; align-items:center; gap:10px; padding:10px; background:var(--bg-muted); border-radius:6px; cursor:pointer; margin-top:10px;";
  const keepDiagCheckbox = document.createElement("input");
  keepDiagCheckbox.type = "checkbox";
  keepDiagCheckbox.checked = !!KEEP_DIAG_GHOSTS;
  const keepDiagText = document.createElement("div");
  keepDiagText.style.cssText = "flex:1;";
  keepDiagText.innerHTML = `<strong>Garder les disparitions (diagnostic ghosts)</strong><div style="font-size:12px; color:var(--text-faint); margin-top:2px;">Coché : aucune intervention disparue n'est retirée — verdict CANCELLED/REMOVE log seulement, l'iv reste affichée. Décoché (défaut) : verdict appliqué, les iv marquées REMOVE sortent du planning.</div>`;
  keepDiagRow.appendChild(keepDiagCheckbox);
  keepDiagRow.appendChild(keepDiagText);
  keepDiagCheckbox.addEventListener("change", async () => {
    KEEP_DIAG_GHOSTS = keepDiagCheckbox.checked;
    const cfg2 = await loadAdminConfig();
    cfg2.keepDisappearedGhosts = KEEP_DIAG_GHOSTS;
    await saveAdminConfig(cfg2);
    LOG.warn("admin", `keepDisappearedGhosts = ${KEEP_DIAG_GHOSTS}`);
    showToast("Diagnostic ghosts", KEEP_DIAG_GHOSTS ? "ACTIVÉ — aucun retrait, verdicts loggés" : "désactivé — verdict REMOVE appliqué");
  });
  container.appendChild(keepDiagRow);

  // v2026.5.46 — « Gérer les sessions multi-onglets EZV » DÉPLACÉ dans la
  // section EasyVista (ce n'est PAS une fonctionnalité en développement).
  // Le « Mode coordinateur » est remis dans Apparence (marqué en développement).

  // Bouton reset
  const resetBtn = document.createElement("button");
  resetBtn.type = "button";
  resetBtn.className = "btn btn-danger";
  resetBtn.textContent = "⚠ Réinitialiser la configuration (équipe, etc.)";
  resetBtn.style.marginTop = "20px";
  resetBtn.addEventListener("click", () => {
    showAlertModal({
      title: "Confirmer la réinitialisation",
      message: "Remettre TOUTES les configurations aux valeurs par défaut ? (les techniciens ajoutés manuellement seront perdus)",
      buttons: [
        { label: "Annuler", variant: "secondary", action: () => {} },
        {
          label: "Réinitialiser",
          variant: "danger",
          action: async () => {
            await chrome.storage.local.remove(ADMIN_CONFIG_KEY);
            showToast("Réinitialisé", "Rechargez la page pour voir les défauts");
          }
        }
      ]
    });
  });
  container.appendChild(resetBtn);
}

// ============================================================================
// v4.2.6 : Modals Absence et Douchette
// ============================================================================

// Types d'absence EasyVista (extraits du HTML plan_set_holidays_popup.php)
const HOLIDAY_TYPES = [
  { guid: "{EF51F439-441E-4A68-9D1A-A6E0A85F32FE}", label: "Congés" },
  { guid: "{B5B887A7-DE5D-4CAB-B55E-7D01E5D0DF84}", label: "Déménagement" },
  { guid: "{8476B26C-DFE4-4256-B2B5-3CE1C9EC3479}", label: "Ecrans" },
  { guid: "{E7432422-55CB-4DB9-8A26-619D036E2155}", label: "Evènements spéciaux" },
  { guid: "{F9B8FFC6-5D64-4339-AAAF-166D6D3801DA}", label: "MAC" },
  { guid: "{0554F45A-9B31-43D7-A1E2-0407D74F3BB5}", label: "Maladie" },
  { guid: "{E8301A0F-B246-420A-863C-3837F1B581E0}", label: "PC" },
  { guid: "{60D70502-063D-45AD-9415-25C1C556105F}", label: "Pompier" },
  { guid: "{B343C590-1446-45BF-9CE6-790C759BA999}", label: "Réunion" },
  { guid: "{7E63F472-677E-4EFD-B822-1AF4DC163AEC}", label: "Rollout" },
  { guid: "{D45DEF80-9DDA-46BA-957E-B5B6D7F9D46A}", label: "Téléphones" },
  { guid: "{06BCAC52-5A8A-4D6D-9BC6-566AAF18666A}", label: "UTP" }
];

/**
 * Formate une date ISO YYYY-MM-DD en DD/MM/YYYY (format EasyVista).
 */
function isoToEvDate(iso) {
  if (!iso) return "";
  const parts = iso.split("-");
  if (parts.length !== 3) return iso;
  return `${parts[2]}/${parts[1]}/${parts[0]}`;
}

/**
 * Construit un bloc liste de techniciens avec checkboxes.
 * @param {Object} opts
 * @param {boolean} [opts.selectAll] - Afficher la case "Tout sélectionner"
 * @returns {HTMLElement}
 */
function buildTechCheckboxList(opts = {}) {
  const container = document.createElement("div");
  container.className = "modal-tech-list";

  const techIds = Object.keys(TEAM);

  if (opts.selectAll) {
    const allRow = document.createElement("label");
    allRow.className = "modal-tech-item tech-selectall";
    const allBox = document.createElement("input");
    allBox.type = "checkbox";
    allBox.className = "tech-select-all";
    const allLabel = document.createElement("span");
    allLabel.textContent = "Tout sélectionner";
    allRow.appendChild(allBox);
    allRow.appendChild(allLabel);
    container.appendChild(allRow);

    allBox.addEventListener("change", () => {
      container.querySelectorAll(".tech-checkbox").forEach(cb => {
        cb.checked = allBox.checked;
      });
    });
  }

  for (const id of techIds) {
    const row = document.createElement("label");
    row.className = "modal-tech-item";
    const cb = document.createElement("input");
    cb.type = "checkbox";
    cb.className = "tech-checkbox";
    cb.value = id;
    const label = document.createElement("span");
    label.textContent = TEAM[id];
    row.appendChild(cb);
    row.appendChild(label);
    container.appendChild(row);

    // Cocher "Tout" si toutes les cases sont cochées (et décocher sinon)
    cb.addEventListener("change", () => {
      const allBox = container.querySelector(".tech-select-all");
      if (!allBox) return;
      const boxes = [...container.querySelectorAll(".tech-checkbox")];
      allBox.checked = boxes.every(b => b.checked);
      allBox.indeterminate = !allBox.checked && boxes.some(b => b.checked);
    });
  }

  // v2026.5.46 — pré-sélection d'un tech (clic droit sur sa carte) : on
  // coche ce tech et, si hideList, on masque la liste (le tech est déjà choisi
  // → « page sans le choix du tech »). La case reste dans le DOM pour que
  // getCheckedTechIds() la retrouve.
  if (opts.preselectTechId != null) {
    const pid = String(opts.preselectTechId);
    container.querySelectorAll(".tech-checkbox").forEach(cb => { cb.checked = (cb.value === pid); });
    if (opts.hideList) container.style.display = "none";
  }

  return container;
}

/**
 * Récupère la liste des techIds cochés dans une liste de checkboxes.
 */
function getCheckedTechIds(container) {
  return [...container.querySelectorAll(".tech-checkbox:checked")].map(cb => cb.value);
}

/**
 * Ouvre la modal "Créer une absence".
 */
// v2026.5.46 — opts.startTime/opts.endTime : heures pré-remplies (clic
// droit sur la ligne d'un tech → menu Réservation/Absence).
function showAbsenceModal(preselectTechId, opts = {}) {
  const existing = document.getElementById("absence-modal");
  if (existing) existing.remove();

  const overlay = document.createElement("div");
  overlay.id = "absence-modal";
  overlay.className = "modal-overlay";

  const card = document.createElement("div");
  card.className = "modal-card modal-wide";
  card.setAttribute("role", "dialog");

  // v5.0.0 : on mémorise la date affichée au moment de l'ouverture de la
  // modal. Le reload après création se fait sur cette date précise, pas
  // sur state.currentDate (qui aurait pu changer entre-temps).
  const dateAtOpen = state.currentDate || todayISO();

  const title = document.createElement("h2");
  title.className = "modal-title";
  title.textContent = "Créer une absence";
  card.appendChild(title);

  // Liste des techs (sans "Tout sélectionner" : on ne met quasi jamais tout
  // le monde en absence, et c'est trop dangereux par erreur)
  const techGroup = document.createElement("div");
  techGroup.className = "modal-form-group";
  const techLabel = document.createElement("label");
  techLabel.className = "modal-form-label";
  techLabel.textContent = "Technicien(s)";
  techGroup.appendChild(techLabel);
  const techList = buildTechCheckboxList({ selectAll: false, preselectTechId, hideList: !!preselectTechId });
  techGroup.appendChild(techList);
  card.appendChild(techGroup);

  // Dates et heures : aujourd'hui ou le jour affiché, 08:00-18:00
  const today = state.currentDate || todayISO();

  const dateGroup = document.createElement("div");
  dateGroup.className = "modal-form-group";
  const dateLabel = document.createElement("label");
  dateLabel.className = "modal-form-label";
  dateLabel.textContent = "Date et heure de début";
  dateGroup.appendChild(dateLabel);
  const dateRow1 = document.createElement("div");
  dateRow1.className = "modal-form-row";
  const startDate = document.createElement("input");
  startDate.type = "date";
  startDate.className = "modal-form-input";
  startDate.id = "absence-start-date";
  startDate.value = today;
  const startTime = document.createElement("input");
  startTime.type = "time";
  startTime.className = "modal-form-input";
  startTime.id = "absence-start-time";
  startTime.value = (opts && opts.startTime) || "08:00";
  dateRow1.appendChild(startDate);
  dateRow1.appendChild(startTime);
  dateGroup.appendChild(dateRow1);
  card.appendChild(dateGroup);

  const endGroup = document.createElement("div");
  endGroup.className = "modal-form-group";
  const endLabel = document.createElement("label");
  endLabel.className = "modal-form-label";
  endLabel.textContent = "Date et heure de fin";
  endGroup.appendChild(endLabel);
  const endRow = document.createElement("div");
  endRow.className = "modal-form-row";
  const endDate = document.createElement("input");
  endDate.type = "date";
  endDate.className = "modal-form-input";
  endDate.id = "absence-end-date";
  endDate.value = today;
  const endTime = document.createElement("input");
  endTime.type = "time";
  endTime.className = "modal-form-input";
  endTime.id = "absence-end-time";
  endTime.value = (opts && opts.endTime) || "18:00";
  endRow.appendChild(endDate);
  endRow.appendChild(endTime);
  endGroup.appendChild(endRow);
  card.appendChild(endGroup);

  // v5.0.4 : presets rapides pour les horaires (matin / après-midi / journée)
  const presetGroup = document.createElement("div");
  presetGroup.className = "modal-form-group";
  const presetLabel = document.createElement("label");
  presetLabel.className = "modal-form-label";
  presetLabel.textContent = "Presets rapides";
  presetGroup.appendChild(presetLabel);
  const presetRow = document.createElement("div");
  presetRow.className = "modal-form-row modal-preset-row";
  const presets = [
    { label: "Matin",           start: "08:00", end: "12:00" },
    { label: "Après-midi",      start: "13:00", end: "18:00" },
    { label: "Toute la journée", start: "08:00", end: "18:00" }
  ];
  for (const p of presets) {
    const btn = document.createElement("button");
    btn.type = "button";
    btn.className = "btn btn-secondary modal-preset-btn";
    btn.textContent = p.label;
    btn.addEventListener("click", () => {
      startTime.value = p.start;
      endTime.value = p.end;
      // Synchroniser visuellement la mise à jour et déclencher
      // endDateTouched si besoin (la date reste inchangée)
      startTime.dispatchEvent(new Event("input", { bubbles: true }));
      endTime.dispatchEvent(new Event("input", { bubbles: true }));
    });
    presetRow.appendChild(btn);
  }
  presetGroup.appendChild(presetRow);
  card.appendChild(presetGroup);
  // v2026.5.46 — on choisit d'abord le preset (Matin/Après-midi/Journée),
  // PUIS l'heure : le bloc presets est remonté au-dessus des champs date/heure.
  card.insertBefore(presetGroup, dateGroup);

  // v5.0.0 : la date de fin suit la date de début tant que l'user ne l'a
  // pas explicitement modifiée. 95% des absences sont d'un seul jour, donc
  // changer juste le start doit mettre à jour le end aussi.
  let endDateTouched = false;
  endDate.addEventListener("input", () => { endDateTouched = true; });
  startDate.addEventListener("input", () => {
    if (!endDateTouched || endDate.value < startDate.value) {
      endDate.value = startDate.value;
    }
  });

  // Type d'absence
  const typeGroup = document.createElement("div");
  typeGroup.className = "modal-form-group";
  const typeLabel = document.createElement("label");
  typeLabel.className = "modal-form-label";
  typeLabel.textContent = "Type d'absence";
  typeGroup.appendChild(typeLabel);
  const typeSelect = document.createElement("select");
  typeSelect.className = "modal-form-select";
  typeSelect.id = "absence-type-select";
  const emptyOpt = document.createElement("option");
  emptyOpt.value = "";
  emptyOpt.textContent = "— Choisir un type —";
  typeSelect.appendChild(emptyOpt);
  // v2026.5.46 — l'absence ne propose plus que Congés et Maladie. Le Pompier
  // a son propre flux (popup dans la modal Réservation) ; les autres types
  // (Ecrans, MAC, Réunion…) sont des réservations, pas des absences.
  const ABSENCE_TYPES = HOLIDAY_TYPES.filter(t => /^(cong[ée]s|maladie)$/i.test(t.label));
  for (const t of ABSENCE_TYPES) {
    const opt = document.createElement("option");
    opt.value = t.guid;
    opt.textContent = t.label;
    typeSelect.appendChild(opt);
  }
  typeGroup.appendChild(typeSelect);
  card.appendChild(typeGroup);

  // Boutons Appliquer / Annuler
  const actions = document.createElement("div");
  actions.className = "modal-actions horizontal";
  const cancelBtn = document.createElement("button");
  cancelBtn.type = "button";
  cancelBtn.className = "btn btn-modal-cancel";
  cancelBtn.textContent = "Annuler";
  cancelBtn.addEventListener("click", () => overlay.remove());
  const applyBtn = document.createElement("button");
  applyBtn.type = "button";
  applyBtn.className = "btn btn-modal-primary";
  applyBtn.textContent = "Appliquer";
  applyBtn.addEventListener("click", async () => {
    // Validation
    const techIds = getCheckedTechIds(techList);
    if (techIds.length === 0) {
      showAlertModal({
        title: "Sélection manquante",
        message: "Choisissez au moins un technicien.",
        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
      });
      return;
    }
    if (!typeSelect.value) {
      showAlertModal({
        title: "Sélection manquante",
        message: "Choisissez un type d'absence.",
        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
      });
      return;
    }
    const sd = startDate.value, st = startTime.value;
    const ed = endDate.value, et = endTime.value;
    if (!sd || !st || !ed || !et) {
      showAlertModal({
        title: "Dates/heures manquantes",
        message: "Remplissez toutes les dates et heures.",
        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
      });
      return;
    }
    // v5.0.0 : validation fin >= début pour ne pas envoyer des absences
    // inversées à EasyVista (il les accepte mais elles n'apparaissent jamais
    // dans le planning, cf bug constaté).
    if (ed < sd || (ed === sd && et <= st)) {
      showAlertModal({
        title: "Dates incohérentes",
        message: "La date/heure de fin doit être après la date/heure de début.",
        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
      });
      return;
    }
    // Désactiver le bouton pendant l'envoi
    applyBtn.disabled = true;
    applyBtn.textContent = "Envoi…";
    try {
      await submitAbsence({
        techIds: techIds,
        startDate: sd,
        startTime: st,
        endDate: ed,
        endTime: et,
        typeGuid: typeSelect.value
      });
      overlay.remove();
      showToast("Absence créée", techIds.length + " tech" + (techIds.length > 1 ? "s" : ""));
      // v5.0.0 : reload le planning DE LA DATE AFFICHÉE AVANT (dateAtOpen),
      // pas de state.currentDate qui a pu être modifié entre-temps (bug
      // où le planning sautait à la date de début de l'absence).
      if (state.session) {
        await loadForDate(dateAtOpen, { forceRefetch: true });
      }
    } catch (err) {
      applyBtn.disabled = false;
      applyBtn.textContent = "Appliquer";
      showAlertModal({
        title: "Erreur lors de la création",
        message: "Impossible de créer l'absence : " + (err.message || err),
        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
      });
    }
  });
  actions.appendChild(cancelBtn);
  actions.appendChild(applyBtn);
  card.appendChild(actions);

  overlay.appendChild(card);
  document.body.appendChild(overlay);

  overlay.addEventListener("click", (e) => {
    if (e.target === overlay) overlay.remove();
  });
  const escHandler = (e) => {
    if (e.key === "Escape") {
      overlay.remove();
      document.removeEventListener("keydown", escHandler);
    }
  };
  document.addEventListener("keydown", escHandler);
}

/**
 * Envoie la requête de création d'absence à EasyVista.
 * Appelle le background script qui fait le POST avec la bonne session.
 */
async function submitAbsence(opts) {
  const resp = await sendMessage({
    type: "submitAbsence",
    techIds: opts.techIds,
    startDate: isoToEvDate(opts.startDate),
    startTime: opts.startTime + ":00",  // HH:MM:SS
    endDate: isoToEvDate(opts.endDate),
    endTime: opts.endTime + ":00",
    typeGuid: opts.typeGuid,
    currentDate: isoToEvDate(opts.startDate)
  });
  if (!resp || !resp.ok) {
    throw new Error(resp && resp.error ? resp.error : "erreur inconnue");
  }
  return resp;
}

// ============================================================================
// v2026.1.6 — QRO : RÉSERVATION d'un créneau (« Évènements spéciaux »)
// ============================================================================
// Crée une VRAIE réservation dans EasyVista (réutilise submitAbsence avec le
// GUID « Evènements spéciaux ») + attache des infos client (n° d'intervention,
// ville, rue, catégorie) au créneau, propagées par le merge et affichées dans
// la bulle. Les réservations créées directement dans EV restent inchangées.
const RESERVATION_TYPE_GUID = "{E7432422-55CB-4DB9-8A26-619D036E2155}"; // Evènements spéciaux
const RESERVATION_CATEGORIES = ["Installation", "Remplacement", "Récupération", "Incident"];
// v2026.5.46 — GUID du type "Pompier" (utilisé par le popup pompier de la
// modal Réservation). Doit rester aligné avec HOLIDAY_TYPES.
const POMPIER_TYPE_GUID = "{60D70502-063D-45AD-9415-25C1C556105F}";

// v2026.1.6 — QRO : couleur (clé CSS --c-<key>) du TYPE d'intervention prévu
// pour une réservation, d'après sa catégorie.
function _resTypeColorKey(cat) {
  switch ((cat || "").toLowerCase()) {
    case "installation": return "installation";
    case "remplacement": return "remplacement";
    case "récupération":
    case "recuperation": return "recup";
    case "incident": return "incident";
    default: return null;
  }
}

// Cherche une intervention par n°/ref dans le planning courant (cache, sans
// appel EV) et en déduit catégorie + localisation (ville / rue).
// Renvoie {categorie, ville, rue} (champs vides si non déterminés) ou null.
function _lookupInterventionInfo(num) {
  const n = String(num || "").trim();
  if (!n || !state.currentData || !state.currentData.techs) return null;
  for (const t of state.currentData.techs) {
    for (const iv of (t.interventions || [])) {
      if (String(iv.ref || "").trim() === n || String(iv.actionId || "").trim() === n) {
        const cat = (iv.categoryLine || "").toLowerCase();
        let categorie = "";
        if (/install/.test(cat)) categorie = "Installation";
        else if (/remplac/.test(cat)) categorie = "Remplacement";
        else if (/r[ée]cup/.test(cat)) categorie = "Récupération";
        else if (/incident/.test(cat)) categorie = "Incident";
        const loc = (iv.bulleLieu || "").trim();
        let ville = "", rue = "";
        if (loc) {
          const isStreet = s => /(rue|route|chemin|avenue|av\.|ch\.|impasse|all[ée]e|place|bd|boulevard|\d)/i.test(s);
          const parts = loc.split(/\s*[,\/]\s*/).map(s => s.trim()).filter(Boolean);
          if (parts.length >= 2) {
            rue = parts.find(isStreet) || parts[1] || "";
            ville = parts.find(p => !isStreet(p)) || parts[0] || "";
          } else if (isStreet(loc)) { rue = loc; } else { ville = loc; }
        }
        return { categorie, ville, rue };
      }
    }
  }
  return null;
}

// Après création + refresh : attache les infos client aux réservations du
// créneau (repérées par technicien + heure de début). Best-effort.
async function _attachReservationMeta(techIds, isoDate, startHHMM, meta) {
  try {
    const isCurrent = _jourAffiche(isoDate);
    const day = isCurrent ? state.currentDay : await storeLoad(isoDate);
    if (!day || !Array.isArray(day.ivs)) return;
    const ids = (techIds || []).map(String);
    let touched = false;
    for (const iv of day.ivs) {
      if (ivIsDead(iv)) continue;
      if (!ids.includes(String(iv.techId))) continue;
      const isRes = iv.type === "AL-Reservation" ||
        /sp[ée]cia/i.test(iv.label || iv.reservationLabel || "");
      if (isRes && (iv.startTime || "").slice(0, 5) === startHHMM) {
        iv.resNumero = meta.numero || "";
        iv.resVille = meta.ville || "";
        iv.resRue = meta.rue || "";
        iv.resCategorie = meta.categorie || "";
        iv.updatedAt = Date.now();
        touched = true;
      }
    }
    if (touched) {
      await storeSave(isoDate, day);
      if (isCurrent) storeRenderCurrent("store");
    }
  } catch (e) {
    LOG.warn("reservation", "rattachement infos échoué (ignoré)", { err: e && e.message });
  }
}

// v2026.1.6 — QRO : VRAIE récupération EV par n° de DS (même logique qu'une
// intervention planifiée : basicAutoComplete + redirectHeader → formLink →
// fetch fiche). En arrière-plan + logs détaillés.
// v2026.5.46 — QRO : la catégorie est désormais déduite par la MÊME logique
// que les interventions planifiées (deriveShortTitle), à partir du n° et du
// titre de catalogue (TITLE_FR), au lieu d'un scan brut de tout le HTML qui
// trouvait "install"/"remplac"/"incident" un peu partout (UI, commentaires).
async function _fetchReservationInfo(num) {
  const n = String(num || "").trim();
  if (!n) return null;
  LOG.info("reservation", `fetch EV des infos du n° ${n} — début (recherche fiche)`);
  try {
    const formLink = await getFreshFicheFormLinkForRef(n);
    LOG.info("reservation", `n° ${n} : formLink ${formLink ? "trouvé" : "INTROUVABLE"}`);
    if (!formLink) return null;
    const resp = await sendMessage({ type: "fetchFiche", formLink });
    const html = resp && resp.ok ? (resp.html || "") : "";
    LOG.info("reservation", `n° ${n} : fiche récupérée`, { ok: !!(resp && resp.ok), taille: html.length, erreur: resp && resp.error });
    if (!html) return null;
    // Catégorie : on reconstruit un pseudo-iv (ref = n° saisi, categoryLine =
    // titre du catalogue TITLE_FR — l'équivalent fiche de attr3 côté planning)
    // et on réutilise deriveShortTitle, qui gère déjà la priorité ref I→Incident,
    // récupération, et le mapping CATEGORY_TO_TITLE. On ne garde que les titres
    // qui sont une vraie catégorie de réservation (sinon "" → pas d'écrasement).
    let titreFiche = "";
    const titM = html.match(/"dbFieldName"\s*:\s*"TITLE_FR"[^}]*?"value"\s*:\s*"([^"]{2,300})"/);
    if (titM) titreFiche = (decodeJsonString ? decodeJsonString(titM[1]) : titM[1]).trim();
    const titreCourt = deriveShortTitle({ ref: n, categoryLine: titreFiche });
    const categorie = RESERVATION_CATEGORIES.includes(titreCourt) ? titreCourt : "";
    let ville = "", rue = "";
    const locM = html.match(/"dbFieldName"\s*:\s*"[^"]*(?:LOCATION|LOCALISATION|ADDRESS|ADRESSE)[^"]*"[^}]*?"value"\s*:\s*"([^"]{3,160})"/i)
      || html.match(/Localisation[^>]{0,40}>\s*([^<]{3,160})/i);
    if (locM) {
      const loc = decodeJsonString ? decodeJsonString(locM[1]).trim() : locM[1].trim();
      const isStreet = s => /(rue|route|chemin|avenue|av\.|ch\.|impasse|all[ée]e|place|bd|boulevard|\d)/i.test(s);
      const parts = loc.split(/\s*[,\/]\s*/).map(s => s.trim()).filter(Boolean);
      if (parts.length >= 2) { rue = parts.find(isStreet) || parts[1] || ""; ville = parts.find(p => !isStreet(p)) || parts[0] || ""; }
      else if (isStreet(loc)) { rue = loc; } else { ville = loc; }
      LOG.info("reservation", `n° ${n} : localisation brute='${loc}'`);
    } else {
      LOG.info("reservation", `n° ${n} : localisation non trouvée dans la fiche (à caler)`);
    }
    LOG.info("reservation", `n° ${n} : titre catalogue='${titreFiche}' → titre court='${titreCourt}' → catégorie='${categorie}' | ville='${ville}' rue='${rue}'`);
    return { categorie, ville, rue };
  } catch (e) {
    LOG.warn("reservation", `fetch infos n° ${n} échoué`, { err: e && e.message });
    return null;
  }
}

// v2026.5.46 — opts.startTime/opts.endTime : heures pré-remplies (clic
// droit sur la ligne d'un tech → créneau libre le plus proche du curseur).
// v2026.5.46 — auto-remplissage ville/rue/catégorie à partir du N°
// d'intervention (DS), partagé par les modals de création ET de modification
// de réservation. Installe les écouteurs sur numField : à la saisie d'un n°
// (>= 4 car.), remplit les champs cibles NON modifiés à la main — d'abord
// depuis le cache planning (instantané), puis depuis le fetch EV réel. Une
// barre de chargement optionnelle signale le fetch. Les champs déjà touchés
// par le coordinateur ne sont jamais écrasés.
function _wireResNumberLookup(numField, cibles) {
  const { catSelect, villeField, rueField, loadingBar } = cibles;
  let catTouched = false, villeTouched = false, rueTouched = false;
  catSelect.addEventListener("change", () => { catTouched = true; });
  villeField.addEventListener("input", () => { villeTouched = true; });
  rueField.addEventListener("input", () => { rueTouched = true; });
  const apply = (info) => {
    if (!info) return;
    if (!catTouched && info.categorie) catSelect.value = info.categorie;
    if (!villeTouched && info.ville) villeField.value = info.ville;
    if (!rueTouched && info.rue) rueField.value = info.rue;
  };
  let seqRef = 0, debounce = null, lastNum = null;
  const trigger = () => {
    const num = numField.value.trim();
    if (num.length < 4) { if (loadingBar) loadingBar.classList.add("hidden"); return; }  // pas encore "complet"
    // déjà recherché tel quel → on ne relance PAS (le 'change' au blur du champ,
    // ex. clic sur la date, relançait un fetch identique). Seule une
    // MODIFICATION du n° re-déclenche.
    if (num === lastNum) return;
    lastNum = num;
    LOG.info("reservation", `n° saisi : ${num} → recherche infos (planning + EV)`);
    apply(_lookupInterventionInfo(num));        // instantané (cache planning)
    const seq = ++seqRef;                        // fetch EV réel en arrière-plan
    if (loadingBar) loadingBar.classList.remove("hidden");
    _fetchReservationInfo(num).then(info => {
      if (seq === seqRef) { apply(info); if (loadingBar) loadingBar.classList.add("hidden"); }
    });
  };
  numField.addEventListener("change", trigger);
  numField.addEventListener("input", () => { clearTimeout(debounce); debounce = setTimeout(trigger, 700); });
}

function showReservationModal(preselectTechId, opts = {}) {
  const existing = document.getElementById("reservation-modal");
  if (existing) existing.remove();

  const overlay = document.createElement("div");
  overlay.id = "reservation-modal";
  overlay.className = "modal-overlay";
  const card = document.createElement("div");
  card.className = "modal-card modal-wide";
  card.setAttribute("role", "dialog");
  card.style.maxHeight = "88vh";          // filet de sécurité si petit écran
  card.style.overflowY = "auto";
  const dateAtOpen = state.currentDate || todayISO();

  const title = document.createElement("h2");
  title.className = "modal-title";
  title.textContent = "Réserver un créneau";
  card.appendChild(title);

  // Technicien(s)
  const techGroup = document.createElement("div");
  techGroup.className = "modal-form-group";
  const techLabel = document.createElement("label");
  techLabel.className = "modal-form-label";
  techLabel.textContent = "Technicien(s)";
  techGroup.appendChild(techLabel);
  const techList = buildTechCheckboxList({ selectAll: false, preselectTechId, hideList: !!preselectTechId });
  techList.style.maxHeight = "140px";      // liste défilante → pas de scroll global
  techList.style.overflowY = "auto";
  techGroup.appendChild(techList);
  card.appendChild(techGroup);

  // Dates / heures (comme l'absence)
  const today = state.currentDate || todayISO();
  const _mkDT = (labelTxt, dVal, tVal, idp) => {
    const g = document.createElement("div"); g.className = "modal-form-group";
    const l = document.createElement("label"); l.className = "modal-form-label"; l.textContent = labelTxt; g.appendChild(l);
    const row = document.createElement("div"); row.className = "modal-form-row";
    const d = document.createElement("input"); d.type = "date"; d.className = "modal-form-input"; d.id = idp + "-date"; d.value = dVal;
    const t = document.createElement("input"); t.type = "time"; t.className = "modal-form-input"; t.id = idp + "-time"; t.value = tVal;
    row.appendChild(d); row.appendChild(t); g.appendChild(row); card.appendChild(g);
    return { d, t, group: g };
  };
  const start = _mkDT("Date et heure de début", today, (opts && opts.startTime) || "08:00", "res-start");
  const end   = _mkDT("Date et heure de fin",   today, (opts && opts.endTime) || "18:00", "res-end");
  let endDateTouched = false;
  end.d.addEventListener("input", () => { endDateTouched = true; });
  start.d.addEventListener("input", () => { if (!endDateTouched || end.d.value < start.d.value) end.d.value = start.d.value; });

  // Presets rapides
  const presetGroup = document.createElement("div"); presetGroup.className = "modal-form-group";
  const presetRow = document.createElement("div"); presetRow.className = "modal-form-row modal-preset-row";
  [["Matin","08:00","12:00"],["Après-midi","13:00","18:00"],["Journée","08:00","18:00"]].forEach(([lbl,s,e]) => {
    const b = document.createElement("button"); b.type = "button"; b.className = "btn btn-secondary modal-preset-btn"; b.textContent = lbl;
    b.addEventListener("click", () => { start.t.value = s; end.t.value = e; });
    presetRow.appendChild(b);
  });
  presetGroup.appendChild(presetRow); card.appendChild(presetGroup);
  // v2026.5.46 — on choisit d'abord Matin/Après-midi/Journée, PUIS l'heure :
  // le bloc presets est remonté juste au-dessus des champs date/heure de début.
  card.insertBefore(presetGroup, start.group);

  // Champs réservation. v2026.5.46 : le n° est sur sa propre ligne avec une
  // barre de chargement juste dessous (visible pendant le fetch EV), puis la
  // catégorie, puis ville/rue en 2 colonnes.
  const numGroup = document.createElement("div"); numGroup.className = "modal-form-group"; numGroup.style.margin = "6px 0 0";
  const numLabel = document.createElement("label"); numLabel.className = "modal-form-label"; numLabel.textContent = "N° d'intervention"; numGroup.appendChild(numLabel);
  const numField = document.createElement("input"); numField.type = "text"; numField.className = "modal-form-input"; numField.placeholder = "ex. I123456"; numGroup.appendChild(numField);
  // Barre de chargement (cachée par défaut, affichée pendant le fetch EV).
  const resLoadingBar = document.createElement("div"); resLoadingBar.className = "res-loading-bar hidden"; numGroup.appendChild(resLoadingBar);
  card.appendChild(numGroup);

  const catGroup = document.createElement("div"); catGroup.className = "modal-form-group"; catGroup.style.margin = "0 0 6px";
  const catLabel = document.createElement("label"); catLabel.className = "modal-form-label"; catLabel.textContent = "Catégorie"; catGroup.appendChild(catLabel);
  const catSelect = document.createElement("select"); catSelect.className = "modal-form-select";
  const emptyOpt = document.createElement("option"); emptyOpt.value = ""; emptyOpt.textContent = "—"; catSelect.appendChild(emptyOpt);
  RESERVATION_CATEGORIES.forEach(c => { const o = document.createElement("option"); o.value = c; o.textContent = c; catSelect.appendChild(o); });
  catGroup.appendChild(catSelect); card.appendChild(catGroup);

  const fieldGrid = document.createElement("div");
  fieldGrid.style.cssText = "display:grid; grid-template-columns:1fr 1fr; gap:8px 12px; margin-top:0;";
  const _mkField = (labelTxt, ph) => {
    const g = document.createElement("div"); g.className = "modal-form-group"; g.style.margin = "0";
    const l = document.createElement("label"); l.className = "modal-form-label"; l.textContent = labelTxt; g.appendChild(l);
    const i = document.createElement("input"); i.type = "text"; i.className = "modal-form-input"; i.placeholder = ph || ""; g.appendChild(i); fieldGrid.appendChild(g);
    return i;
  };
  const villeField = _mkField("Ville / village", "");
  const rueField = _mkField("Rue / chemin / route", "");
  card.appendChild(fieldGrid);

  // v2026.5.46 — auto-remplissage ville/rue/catégorie depuis le n°
  // d'intervention : logique partagée avec la modal de MODIFICATION.
  _wireResNumberLookup(numField, { catSelect, villeField, rueField, loadingBar: resLoadingBar });

  // Boutons
  const actions = document.createElement("div"); actions.className = "modal-actions";
  const cancelBtn = document.createElement("button"); cancelBtn.type = "button"; cancelBtn.className = "btn btn-secondary"; cancelBtn.textContent = "Annuler";
  cancelBtn.addEventListener("click", () => overlay.remove());
  const applyBtn = document.createElement("button"); applyBtn.type = "button"; applyBtn.className = "btn btn-primary"; applyBtn.textContent = "Réserver";
  applyBtn.addEventListener("click", async () => {
    const techIds = getCheckedTechIds(techList);
    if (techIds.length === 0) {
      showAlertModal({ title: "Sélection manquante", message: "Choisissez au moins un technicien.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    const sd = start.d.value, st = start.t.value, ed = end.d.value, et = end.t.value;
    if (!sd || !st || !ed || !et) {
      showAlertModal({ title: "Dates/heures manquantes", message: "Remplissez les dates et heures.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    if (ed < sd || (ed === sd && et <= st)) {
      showAlertModal({ title: "Dates incohérentes", message: "La fin doit être après le début.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    applyBtn.disabled = true; applyBtn.textContent = "Réservation…";
    // v2026.5.46 — on capture la meta AVANT de fermer la modal (les champs
    // seront détachés du DOM).
    const _meta = { numero: numField.value.trim(), ville: villeField.value.trim(), rue: rueField.value.trim(), categorie: catSelect.value };
    try {
      await submitAbsence({ techIds, startDate: sd, startTime: st, endDate: ed, endTime: et, typeGuid: RESERVATION_TYPE_GUID });
      overlay.remove();
      showToast("Réservation créée", techIds.length + " tech" + (techIds.length > 1 ? "s" : ""));
      // v2026.5.46 — meta persistante (réappliquée à chaque parse → survit
      // aux refresh EV). On l'enregistre AVANT le refresh pour qu'elle soit déjà
      // disponible au re-parse.
      // v2026.5.46 — la meta doit être indexée sur la date RÉELLE de la
      // réservation (sd), pas sur la date affichée à l'ouverture de la modal
      // (dateAtOpen) : sinon une résa créée pour un autre jour ne retrouve
      // jamais ses infos (n°/ville/rue/catégorie) au parse de ce jour-là.
      await _resMetaSet(techIds, sd, st, _meta);
      if (state.session) {
        await loadForDate(dateAtOpen, { forceRefetch: true });
        // Patch immédiat du cache UNIQUEMENT si la résa tombe sur le jour
        // affiché — sinon _attachReservationMeta lit/rend le cache d'un AUTRE
        // jour et écrase l'écran courant.
        if (sd === dateAtOpen) {
          await _attachReservationMeta(techIds, sd, st, _meta);
        }
      }
    } catch (err) {
      applyBtn.disabled = false; applyBtn.textContent = "Réserver";
      showAlertModal({ title: "Erreur", message: "Impossible de réserver : " + (err.message || err), buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
    }
  });
  actions.appendChild(cancelBtn); actions.appendChild(applyBtn);
  card.appendChild(actions);

  overlay.appendChild(card);
  document.body.appendChild(overlay);

  // v2026.5.46 — clic sur le fond + touche Échap ferment la modal.
  overlay.addEventListener("click", (e) => {
    if (e.target === overlay) overlay.remove();
  });
  const escHandler = (e) => {
    if (e.key !== "Escape") return;
    overlay.remove();
    document.removeEventListener("keydown", escHandler);
  };
  document.addEventListener("keydown", escHandler);
}

// v2026.5.46 — modal "Modifier la réservation" : édite les infos client
// (n° DS, catégorie, ville, rue) ET la date/heure. EasyVista n'a pas d'« update »
// → si la date/heure change, on RECRÉE la réservation (la nouvelle D'ABORD, puis
// suppression de l'ancienne : ainsi rien n'est perdu si la création échoue).
function showReservationEditModal(iv) {
  const existing = document.getElementById("reservation-edit-modal");
  if (existing) existing.remove();
  const overlay = document.createElement("div");
  overlay.id = "reservation-edit-modal";
  overlay.className = "modal-overlay";
  const card = document.createElement("div");
  card.className = "modal-card modal-wide";
  card.setAttribute("role", "dialog");

  const title = document.createElement("h2");
  title.className = "modal-title";
  title.textContent = "Modifier la réservation";
  card.appendChild(title);

  // Date/heure d'origine (iv.startDate/endDate au format JJ/MM/AAAA → ISO).
  const _toIso = (s) => { const m = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(s || ""); return m ? `${m[3]}-${m[2]}-${m[1]}` : (s || ""); };
  const origSDiso = _toIso(iv.startDate);
  const origEDiso = _toIso(iv.endDate || iv.startDate);
  const origST = (iv.startTime || "").slice(0, 5);
  const origET = (iv.endTime || "").slice(0, 5);

  // Date et heure (début / fin)
  const _mkDT = (labelTxt, dVal, tVal) => {
    const g = document.createElement("div"); g.className = "modal-form-group";
    const l = document.createElement("label"); l.className = "modal-form-label"; l.textContent = labelTxt; g.appendChild(l);
    const row = document.createElement("div"); row.className = "modal-form-row";
    const d = document.createElement("input"); d.type = "date"; d.className = "modal-form-input"; d.value = dVal;
    const t = document.createElement("input"); t.type = "time"; t.className = "modal-form-input"; t.value = tVal;
    row.appendChild(d); row.appendChild(t); g.appendChild(row); card.appendChild(g);
    return { d, t };
  };
  const start = _mkDT("Date et heure de début", origSDiso, origST);
  const end   = _mkDT("Date et heure de fin",   origEDiso, origET);
  start.d.addEventListener("input", () => { if (end.d.value < start.d.value) end.d.value = start.d.value; });

  // Infos client : n°, catégorie, ville, rue (grille 2 colonnes)
  const grid = document.createElement("div");
  grid.style.cssText = "display:grid; grid-template-columns:1fr 1fr; gap:8px 12px; margin-top:4px;";
  const _mkField = (labelTxt, val, ph) => {
    const g = document.createElement("div"); g.className = "modal-form-group"; g.style.margin = "0";
    const l = document.createElement("label"); l.className = "modal-form-label"; l.textContent = labelTxt; g.appendChild(l);
    const i = document.createElement("input"); i.type = "text"; i.className = "modal-form-input"; i.value = val || ""; i.placeholder = ph || ""; g.appendChild(i); grid.appendChild(g);
    return i;
  };
  const numField = _mkField("N° d'intervention", iv.resNumero, "ex. I123456");
  const catGroup = document.createElement("div"); catGroup.className = "modal-form-group"; catGroup.style.margin = "0";
  const catLabel = document.createElement("label"); catLabel.className = "modal-form-label"; catLabel.textContent = "Catégorie"; catGroup.appendChild(catLabel);
  const catSelect = document.createElement("select"); catSelect.className = "modal-form-select";
  const emptyOpt = document.createElement("option"); emptyOpt.value = ""; emptyOpt.textContent = "—"; catSelect.appendChild(emptyOpt);
  RESERVATION_CATEGORIES.forEach(c => { const o = document.createElement("option"); o.value = c; o.textContent = c; if (c === iv.resCategorie) o.selected = true; catSelect.appendChild(o); });
  catGroup.appendChild(catSelect); grid.appendChild(catGroup);
  const villeField = _mkField("Ville / village", iv.resVille, "");
  const rueField = _mkField("Rue / chemin / route", iv.resRue, "");
  card.appendChild(grid);

  // v2026.5.46 — comme à la création : saisir/ajouter un N° d'intervention
  // (DS) récupère et remplit ville/rue/catégorie automatiquement (helper
  // partagé). Avant, la modal de modification laissait ces champs à la main.
  const editLoadingBar = document.createElement("div");
  editLoadingBar.className = "res-loading-bar hidden";
  editLoadingBar.style.marginTop = "6px";
  card.appendChild(editLoadingBar);
  _wireResNumberLookup(numField, { catSelect, villeField, rueField, loadingBar: editLoadingBar });

  const actions = document.createElement("div"); actions.className = "modal-actions"; actions.style.marginTop = "14px";
  const cancelBtn = document.createElement("button"); cancelBtn.type = "button"; cancelBtn.className = "btn btn-secondary"; cancelBtn.textContent = "Annuler";
  cancelBtn.addEventListener("click", () => overlay.remove());
  const okBtn = document.createElement("button"); okBtn.type = "button"; okBtn.className = "btn btn-primary"; okBtn.textContent = "Enregistrer";
  okBtn.addEventListener("click", async () => {
    const meta = { numero: numField.value.trim(), ville: villeField.value.trim(), rue: rueField.value.trim(), categorie: catSelect.value };
    const nSD = start.d.value, nST = start.t.value, nED = end.d.value, nET = end.t.value;
    if (!nSD || !nST || !nED || !nET) {
      showAlertModal({ title: "Dates/heures manquantes", message: "Remplis les dates et heures.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    if (nED < nSD || (nED === nSD && nET <= nST)) {
      showAlertModal({ title: "Dates incohérentes", message: "La fin doit être après le début.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    const timeChanged = (nSD !== origSDiso || nST !== origST || nED !== origEDiso || nET !== origET);
    okBtn.disabled = true; okBtn.textContent = "Enregistrement…";
    try {
      if (timeChanged) {
        // EasyVista n'a pas d'update → recréer (nouvelle D'ABORD, puis supprimer l'ancienne).
        await submitAbsence({ techIds: [iv.techId], startDate: nSD, startTime: nST, endDate: nED, endTime: nET, typeGuid: RESERVATION_TYPE_GUID });
        await _resMetaSet([iv.techId], nSD, nST, meta);
        let delOk = true;
        try {
          const r = await sendMessage({ type: "deletePlanningItem", actionId: iv.actionId, kind: "reservation" });
          delOk = !!(r && r.ok);
        } catch (e) { delOk = false; }
        overlay.remove(); hideTooltip();
        if (delOk) showToast("Réservation modifiée", meta.numero || "");
        else showAlertModal({ title: "Réservation recréée", message: "La nouvelle réservation a bien été créée, mais l'ancienne n'a pas pu être supprimée. Supprime-la manuellement via son popup.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
        // v2026.5.46 — tombstone de l'ancienne résa supprimée (évite la
        // réinjection fantôme par la sync dossier au retour sur la date).
        if (delOk) await _markDeletedInCache(iv.actionId, state.currentDate);
        if (state.session) await loadForDate(state.currentDate, { forceRefetch: true });
      } else {
        // Seules les infos client changent → pas d'appel EV, mais il FAUT
        // persister au store ET pousser au dossier partagé (v2026.5.46 :
        // avant, la mutation restait en mémoire + reservation_meta local → la
        // méta ne remontait jamais au dossier ni aux autres postes).
        await _resMetaSetRaw(iv.techId, iv.startDate, iv.startTime, meta);
        iv.resNumero = meta.numero; iv.resVille = meta.ville; iv.resRue = meta.rue; iv.resCategorie = meta.categorie;
        overlay.remove(); hideTooltip();
        showToast("Réservation modifiée", meta.numero || (TEAM[iv.techId] || ""));
        // _attachReservationMeta : mute l'iv du STORE au bon créneau, storeSave
        // (→ push dossier) et re-render. L'iv éditée est affichée donc sur le
        // jour courant (state.currentDate, ISO).
        await _attachReservationMeta([iv.techId], state.currentDate, (iv.startTime || "").slice(0, 5), meta);
      }
    } catch (err) {
      okBtn.disabled = false; okBtn.textContent = "Enregistrer";
      showAlertModal({ title: "Erreur", message: "Impossible de modifier la réservation : " + (err.message || err), buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
    }
  });
  actions.appendChild(cancelBtn); actions.appendChild(okBtn);
  card.appendChild(actions);

  overlay.appendChild(card);
  document.body.appendChild(overlay);
  overlay.addEventListener("click", (e) => { if (e.target === overlay) overlay.remove(); });
  const escHandler = (e) => {
    if (e.key !== "Escape") return;
    overlay.remove();
    document.removeEventListener("keydown", escHandler);
  };
  document.addEventListener("keydown", escHandler);
}

// v2026.5.46 — modal "Définir un pompier" (ouverte depuis le menu Ajouter).
// Choisit un technicien + une date : crée une absence type Pompier ce jour-là
// ET enregistre ce tech comme « pompier du mois » (mois de la date choisie).
function showPompierModal(preselectTechId) {
  const existing = document.getElementById("pompier-modal");
  if (existing) existing.remove();
  const overlay = document.createElement("div");
  overlay.id = "pompier-modal";
  overlay.className = "modal-overlay";
  const card = document.createElement("div");
  card.className = "modal-card";
  card.setAttribute("role", "dialog");

  const title = document.createElement("h2");
  title.className = "modal-title";
  title.textContent = "🚒 Pompiers";
  card.appendChild(title);

  // v2026.5.46 — liste des pompiers ACTUELS et À VENIR. Fusionne le store
  // local ET le cache du planning (absences Pompier réelles d'EasyVista). Peuplée
  // en asynchrone (scan du cache). Cliquer une ligne navigue vers la date.
  const _today = todayISO();
  const _fmtDate = (iso) => { const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(iso || ""); return m ? `${m[3]}.${m[2]}.${m[1]}` : iso; };
  // v2026.5.46 — en-tête repliable (RÉDUIT par défaut) ; clic = déplier.
  const listHeader = document.createElement("button");
  listHeader.type = "button"; listHeader.className = "pompier-list-header";
  listHeader.innerHTML = `<span class="pompier-list-caret">▸</span><span>Pompiers actuels et à venir</span>`;
  card.appendChild(listHeader);
  const list = document.createElement("div"); list.className = "pompier-list hidden";
  const loadingEl = document.createElement("div"); loadingEl.className = "pompier-list-empty"; loadingEl.textContent = "Chargement…";
  list.appendChild(loadingEl);
  card.appendChild(list);
  listHeader.addEventListener("click", () => {
    const collapsed = list.classList.toggle("hidden");
    listHeader.querySelector(".pompier-list-caret").textContent = collapsed ? "▸" : "▾";
  });
  _collectPompiers().then(all => {
    const upcoming = all
      .filter(a => a.end >= _today)
      .sort((a, b) => a.start.localeCompare(b.start));
    list.innerHTML = "";
    if (!upcoming.length) {
      const emptyEl = document.createElement("div"); emptyEl.className = "pompier-list-empty";
      emptyEl.textContent = "Aucun pompier trouvé (actuel ou à venir) dans les jours déjà chargés.";
      list.appendChild(emptyEl);
      return;
    }
    for (const a of upcoming) {
      const item = document.createElement("button");
      item.type = "button"; item.className = "pompier-list-item";
      const isCurrent = a.start <= _today && _today <= a.end;
      item.innerHTML = `<span class="pompier-list-name">${escapeHtml(a.name)}${isCurrent ? ' <span class="pompier-list-now">en cours</span>' : ''}</span><span class="pompier-list-dates">${_fmtDate(a.start)} → ${_fmtDate(a.end)}</span>`;
      item.title = "Modifier les dates de ce pompier";
      // Clic = modifier les dates (supprime l'absence + recrée).
      item.addEventListener("click", () => { overlay.remove(); showPompierEditModal(a); });
      list.appendChild(item);
    }
  }).catch(() => { list.innerHTML = ""; });

  const formLabel = document.createElement("div"); formLabel.className = "modal-form-label"; formLabel.style.marginTop = "12px"; formLabel.textContent = "Définir un pompier";
  card.appendChild(formLabel);

  const techGroup = document.createElement("div"); techGroup.className = "modal-form-group";
  const techLabel = document.createElement("label"); techLabel.className = "modal-form-label"; techLabel.textContent = "Technicien pompier"; techGroup.appendChild(techLabel);
  const select = document.createElement("select"); select.className = "modal-form-select";
  const empty = document.createElement("option"); empty.value = ""; empty.textContent = "— Choisir —"; select.appendChild(empty);
  for (const id of Object.keys(TEAM)) { const o = document.createElement("option"); o.value = id; o.textContent = TEAM[id]; select.appendChild(o); }
  techGroup.appendChild(select); card.appendChild(techGroup);

  // v2026.5.46 — si un pompier couvre déjà le jour affiché, on l'indique et
  // on pré-remplit (tech + période) pour voir / ajuster le pompier en cours.
  const _openIso = state.currentDate || todayISO();
  const existingPm = _pompierForDate(_openIso);
  if (existingPm) {
    select.value = String(existingPm.techId);
    const infoEl = document.createElement("div");
    infoEl.style.cssText = "margin:-2px 0 10px; font-size:12.5px; color:var(--c-pompier,#e0533d); font-weight:600;";
    infoEl.textContent = `Pré-rempli : ${existingPm.name} couvre le jour affiché (modifie pour ajuster).`;
    card.appendChild(infoEl);
  }

  // v2026.5.46 — pré-sélection explicite (clic droit sur la carte d'un
  // tech) : prioritaire sur le pré-remplissage « pompier du jour ».
  if (preselectTechId != null && TEAM[String(preselectTechId)]) {
    select.value = String(preselectTechId);
  }

  const startGroup = document.createElement("div"); startGroup.className = "modal-form-group";
  const startLabel = document.createElement("label"); startLabel.className = "modal-form-label"; startLabel.textContent = "Date de début"; startGroup.appendChild(startLabel);
  const startInput = document.createElement("input"); startInput.type = "date"; startInput.className = "modal-form-input"; startInput.value = existingPm ? existingPm.start : _openIso;
  startGroup.appendChild(startInput); card.appendChild(startGroup);

  const endGroup = document.createElement("div"); endGroup.className = "modal-form-group";
  const endLabel = document.createElement("label"); endLabel.className = "modal-form-label"; endLabel.textContent = "Date de fin"; endGroup.appendChild(endLabel);
  const endInput = document.createElement("input"); endInput.type = "date"; endInput.className = "modal-form-input"; endInput.value = existingPm ? existingPm.end : _openIso;
  endGroup.appendChild(endInput); card.appendChild(endGroup);
  startInput.addEventListener("input", () => { if (endInput.value < startInput.value) endInput.value = startInput.value; });

  const actions = document.createElement("div"); actions.className = "modal-actions";
  const cancelBtn = document.createElement("button"); cancelBtn.type = "button"; cancelBtn.className = "btn btn-secondary"; cancelBtn.textContent = "Annuler";
  cancelBtn.addEventListener("click", () => overlay.remove());
  const okBtn = document.createElement("button"); okBtn.type = "button"; okBtn.className = "btn btn-primary"; okBtn.textContent = "Définir";
  okBtn.addEventListener("click", async () => {
    const tid = select.value, sdate = startInput.value, edate = endInput.value;
    if (!tid || !sdate || !edate) {
      showAlertModal({ title: "Sélection manquante", message: "Choisis un technicien, une date de début et une date de fin.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    if (edate < sdate) {
      showAlertModal({ title: "Dates incohérentes", message: "La date de fin doit être après le début.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    // Règle : un seul pompier par jour → bloquer si un AUTRE tech couvre un de ces jours.
    const conflicts = _pompierConflicts(sdate, edate, tid);
    if (conflicts.length) {
      const c = conflicts[0];
      showAlertModal({ title: "Conflit pompier", message: `Impossible : ${c.name} est déjà pompier du ${c.start} au ${c.end}. Il ne peut pas y avoir deux pompiers le même jour.`, buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    okBtn.disabled = true; okBtn.textContent = "…";
    try {
      await submitAbsence({ techIds: [tid], startDate: sdate, startTime: "08:00", endDate: edate, endTime: "18:00", typeGuid: POMPIER_TYPE_GUID });
      await _pompierAddAssignment(tid, TEAM[tid], sdate, edate);
      overlay.remove();
      showToast("Pompier défini", TEAM[tid] + " — du " + sdate + " au " + edate);
      if (state.session) await loadForDate(sdate, { forceRefetch: true });
      else if (state.currentData) renderFromData(state.currentData); // rafraîchir le bandeau pompier
    } catch (err) {
      okBtn.disabled = false; okBtn.textContent = "Définir";
      showAlertModal({ title: "Erreur", message: "Impossible de définir le pompier : " + (err.message || err), buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
    }
  });
  actions.appendChild(cancelBtn); actions.appendChild(okBtn);
  card.appendChild(actions);

  overlay.appendChild(card);
  document.body.appendChild(overlay);
  overlay.addEventListener("click", (e) => { if (e.target === overlay) overlay.remove(); });
  const escHandler = (e) => {
    if (e.key !== "Escape") return;
    overlay.remove();
    document.removeEventListener("keydown", escHandler);
  };
  document.addEventListener("keydown", escHandler);
}

// v2026.5.46 — modal "Modifier le pompier" : change les dates d'un pompier
// existant. EasyVista n'a pas d'update → on RECRÉE l'absence Pompier aux nouvelles
// dates (création d'abord), puis on supprime l'ancienne (via son actionId).
// item = { techId, name, start, end, actionId } (dates ISO).
function showPompierEditModal(item) {
  const existing = document.getElementById("pompier-edit-modal");
  if (existing) existing.remove();
  const overlay = document.createElement("div");
  overlay.id = "pompier-edit-modal";
  overlay.className = "modal-overlay";
  const card = document.createElement("div");
  card.className = "modal-card";
  card.setAttribute("role", "dialog");

  const title = document.createElement("h2");
  title.className = "modal-title";
  title.textContent = "🚒 Modifier le pompier";
  card.appendChild(title);

  const who = document.createElement("div");
  who.style.cssText = "margin:-2px 0 10px; font-weight:600; color:var(--c-pompier,#e0533d);";
  who.textContent = item.name || (TEAM[item.techId] || "");
  card.appendChild(who);

  const _mkDate = (labelTxt, val) => {
    const g = document.createElement("div"); g.className = "modal-form-group";
    const l = document.createElement("label"); l.className = "modal-form-label"; l.textContent = labelTxt; g.appendChild(l);
    const i = document.createElement("input"); i.type = "date"; i.className = "modal-form-input"; i.value = val || ""; g.appendChild(i); card.appendChild(g);
    return i;
  };
  const startInput = _mkDate("Date de début", item.start);
  const endInput = _mkDate("Date de fin", item.end);
  startInput.addEventListener("input", () => { if (endInput.value < startInput.value) endInput.value = startInput.value; });

  // Lien : aller à cette date dans le planning.
  const goLink = document.createElement("button");
  goLink.type = "button"; goLink.className = "btn btn-secondary"; goLink.style.cssText = "width:100%; margin-top:2px;";
  goLink.textContent = "📅 Voir dans le planning";
  goLink.addEventListener("click", () => { overlay.remove(); if (typeof loadForDate === "function") loadForDate(item.start); });
  card.appendChild(goLink);

  const actions = document.createElement("div"); actions.className = "modal-actions"; actions.style.marginTop = "14px";
  const cancelBtn = document.createElement("button"); cancelBtn.type = "button"; cancelBtn.className = "btn btn-secondary"; cancelBtn.textContent = "Annuler";
  cancelBtn.addEventListener("click", () => overlay.remove());
  const okBtn = document.createElement("button"); okBtn.type = "button"; okBtn.className = "btn btn-primary"; okBtn.textContent = "Enregistrer";
  okBtn.addEventListener("click", async () => {
    const nStart = startInput.value, nEnd = endInput.value;
    if (!nStart || !nEnd) {
      showAlertModal({ title: "Dates manquantes", message: "Remplis les deux dates.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    if (nEnd < nStart) {
      showAlertModal({ title: "Dates incohérentes", message: "La date de fin doit être après le début.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    if (nStart === item.start && nEnd === item.end) { overlay.remove(); return; } // rien changé
    // Un seul pompier par jour (hors le tech lui-même).
    const conflicts = _pompierConflicts(nStart, nEnd, item.techId);
    if (conflicts.length) {
      const c = conflicts[0];
      showAlertModal({ title: "Conflit pompier", message: `${c.name} est déjà pompier du ${c.start} au ${c.end}. Impossible de chevaucher.`, buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      return;
    }
    okBtn.disabled = true; okBtn.textContent = "Enregistrement…";
    try {
      // 1) Recréer aux nouvelles dates (avant de supprimer → pas de perte).
      await submitAbsence({ techIds: [item.techId], startDate: nStart, startTime: "08:00", endDate: nEnd, endTime: "18:00", typeGuid: POMPIER_TYPE_GUID });
      // 2) Mettre à jour le store local.
      await _pompierRemoveExact(item.techId, item.start, item.end);
      await _pompierAddAssignment(item.techId, item.name, nStart, nEnd);
      // 3) Supprimer l'ancienne absence (si on a son actionId).
      let delOk = false;
      if (item.actionId) {
        try { const r = await sendMessage({ type: "deletePlanningItem", actionId: item.actionId, kind: "absence" }); delOk = !!(r && r.ok); } catch (e) { delOk = false; }
      }
      overlay.remove();
      if (item.actionId && delOk) showToast("Pompier modifié", (item.name || "") + " — du " + nStart + " au " + nEnd);
      else showAlertModal({ title: "Pompier recréé", message: "Le pompier a été recréé aux nouvelles dates, mais l'ancienne période n'a pas pu être supprimée automatiquement. Ouvre son ancien jour dans le planning et supprime-la via son popup si elle persiste.", buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
      // v2026.5.46 — tombstone de l'ancienne période supprimée (jour
      // d'origine + jour affiché) pour éviter la réinjection par la sync dossier.
      if (item.actionId && delOk) {
        await _markDeletedInCache(item.actionId, item.start);
        if (item.start !== state.currentDate) await _markDeletedInCache(item.actionId, state.currentDate);
      }
      if (state.session) await loadForDate(state.currentDate, { forceRefetch: true });
    } catch (err) {
      okBtn.disabled = false; okBtn.textContent = "Enregistrer";
      showAlertModal({ title: "Erreur", message: "Impossible de modifier le pompier : " + (err.message || err), buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
    }
  });
  actions.appendChild(cancelBtn); actions.appendChild(okBtn);
  card.appendChild(actions);

  overlay.appendChild(card);
  document.body.appendChild(overlay);
  overlay.addEventListener("click", (e) => { if (e.target === overlay) overlay.remove(); });
  const escHandler = (e) => {
    if (e.key !== "Escape") return;
    overlay.remove();
    document.removeEventListener("keydown", escHandler);
  };
  document.addEventListener("keydown", escHandler);
}

/**
 * Ouvre la modal "Envoyer la planification sur la douchette".
 */
function showDouchetteModal(preselectTechId) {
  const existing = document.getElementById("douchette-modal");
  if (existing) existing.remove();

  const overlay = document.createElement("div");
  overlay.id = "douchette-modal";
  overlay.className = "modal-overlay";

  const card = document.createElement("div");
  card.className = "modal-card";
  card.setAttribute("role", "dialog");

  const title = document.createElement("h2");
  title.className = "modal-title";
  title.textContent = "Envoyer la planification sur la douchette";
  card.appendChild(title);

  const msg = document.createElement("p");
  msg.className = "modal-message";
  msg.textContent = "Choisissez le ou les techniciens qui recevront la planification du jour sur leur douchette.";
  card.appendChild(msg);

  const techGroup = document.createElement("div");
  techGroup.className = "modal-form-group";
  const techList = buildTechCheckboxList({ selectAll: true, preselectTechId, hideList: !!preselectTechId });
  techGroup.appendChild(techList);
  card.appendChild(techGroup);

  // Boutons
  const actions = document.createElement("div");
  actions.className = "modal-actions horizontal";
  const cancelBtn = document.createElement("button");
  cancelBtn.type = "button";
  cancelBtn.className = "btn btn-modal-cancel";
  cancelBtn.textContent = "Annuler";
  cancelBtn.addEventListener("click", () => overlay.remove());
  const sendBtn = document.createElement("button");
  sendBtn.type = "button";
  sendBtn.className = "btn btn-modal-primary";
  sendBtn.textContent = "Envoyer";
  sendBtn.addEventListener("click", async () => {
    const techIds = getCheckedTechIds(techList);
    if (techIds.length === 0) {
      showAlertModal({
        title: "Sélection manquante",
        message: "Choisissez au moins un technicien.",
        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
      });
      return;
    }
    sendBtn.disabled = true;
    sendBtn.textContent = "Envoi…";
    try {
      const result = await submitDouchette(techIds);
      overlay.remove();
      if (result && result.okCount > 0) {
        // v2026.5.46 — la confirmation EV (script fermeture popup + refresh
        // planning dans la reponse) distingue un ordre PRIS EN COMPTE d un
        // simple HTTP 200 accepte.
        showToast(
          result.confirmed ? "Envoyé sur douchette — confirmé par EasyVista ✓" : "Envoyé sur douchette",
          result.okCount + "/" + techIds.length + " tech" + (techIds.length > 1 ? "s" : "")
            + (result.confirmed ? "" : " — réponse EV inhabituelle, vérifie le planning")
        );
      }
      if (result && result.errors && result.errors.length > 0) {
        showAlertModal({
          title: "Envoi partiellement échoué",
          message: result.errors.length + " tech(s) n'ont pas pu recevoir : "
            + result.errors.map(e => TEAM[e.techId] || e.techId).join(", "),
          buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
        });
      }
    } catch (err) {
      sendBtn.disabled = false;
      sendBtn.textContent = "Envoyer";
      showAlertModal({
        title: "Erreur lors de l'envoi",
        message: "Impossible d'envoyer sur la douchette : " + (err.message || err),
        buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
      });
    }
  });
  actions.appendChild(cancelBtn);
  actions.appendChild(sendBtn);
  card.appendChild(actions);

  overlay.appendChild(card);
  document.body.appendChild(overlay);

  overlay.addEventListener("click", (e) => {
    if (e.target === overlay) overlay.remove();
  });
  const escHandler = (e) => {
    if (e.key === "Escape") {
      overlay.remove();
      document.removeEventListener("keydown", escHandler);
    }
  };
  document.addEventListener("keydown", escHandler);
}

/**
 * Envoie la planification sur la douchette de plusieurs techniciens.
 * dateIso (optionnel) cible un autre jour que celui affiche.
 * Retourne { okCount, errors: [{techId, error}], confirmed }.
 */
async function submitDouchette(techIds, dateIso) {
  const resp = await sendMessage({
    type: "submitDouchette",
    techIds: techIds,
    currentDate: isoToEvDate(dateIso || state.currentDate || todayISO())
  });
  if (!resp || !resp.ok) {
    throw new Error(resp && resp.error ? resp.error : "erreur inconnue");
  }
  return resp;
}

// ============================================================================
// Date helpers
// ============================================================================

function todayISO() {
  const d = new Date();
  return dateToISO(d);
}

function dateToISO(d) {
  const yyyy = d.getFullYear();
  const mm = String(d.getMonth() + 1).padStart(2, "0");
  const dd = String(d.getDate()).padStart(2, "0");
  return `${yyyy}-${mm}-${dd}`;
}

function isoToDate(iso) {
  const [y, m, d] = iso.split("-").map(n => parseInt(n, 10));
  return new Date(y, m - 1, d);
}

function isoToDDMMYYYY(iso) {
  const [y, m, d] = iso.split("-");
  return `${d}/${m}/${y}`;
}

function formatDateDM(iso) {
  const [, m, d] = iso.split("-");
  return `${d}/${m}`;
}

function isoToUnixDate(iso) {
  // Renvoie le timestamp Unix à midi local du jour (pour que le serveur comprenne bien le jour demandé)
  const d = isoToDate(iso);
  d.setHours(12, 0, 0, 0);
  return Math.floor(d.getTime() / 1000);
}

// ============================================================================
// Messages → background
// ============================================================================

// v2026.5.38 : timeout sur sendMessage. En MV3 le service worker peut être
// endormi/relancé : si un handler async oublie d'appeller sendResponse, le
// port reste ouvert et notre Promise pend pour toujours. On force un timeout
// (defaut 15s) qui rejette proprement avec un message clair.
const _SENDMESSAGE_TIMEOUT_MS = 15000;

function sendMessage(msg) {
  return new Promise((resolve, reject) => {
    let settled = false;
    const t0 = performance.now();

    const timer = setTimeout(() => {
      if (settled) return;
      settled = true;
      const dur = Math.round(performance.now() - t0);
      LOG.error("sendMessage", `timeout après ${dur}ms (background ne répond pas)`, { type: msg && msg.type });
      reject(new Error(`sendMessage timeout (${msg && msg.type || "?"})`));
    }, _SENDMESSAGE_TIMEOUT_MS);

    try {
      chrome.runtime.sendMessage(msg, (response) => {
        if (settled) return;
        settled = true;
        clearTimeout(timer);
        if (chrome.runtime.lastError) {
          const dur = Math.round(performance.now() - t0);
          LOG.warn("sendMessage", "lastError", { type: msg && msg.type, err: chrome.runtime.lastError.message, durMs: dur });
          reject(new Error(chrome.runtime.lastError.message));
          return;
        }
        resolve(response || {});
      });
    } catch (e) {
      // chrome.runtime.sendMessage peut throw direct si extension contexte invalide
      if (settled) return;
      settled = true;
      clearTimeout(timer);
      LOG.exception("sendMessage", "throw synchrone", e, { type: msg && msg.type });
      reject(e);
    }
  });
}

// ============================================================================
// COUCHE DONNÉES v2 — store unifié par jour                  // 2026.5.46
// ============================================================================
//
// PRINCIPE : un store par jour = LA seule vérité. Le rendu, le cache local,
// le dossier partagé et EasyVista n'en sont que des projections / des sources.
//
//   EV (XML + fiches)        actions utilisateur          dossier partagé
//        │ alimente                │ alimente                  │ fusionne
//        ▼                         ▼                           ▼
//   ┌──────────────────────────────────────────────────────────────────┐
//   │  STORE DU JOUR  { schema:2, date, savedAt, techs[], ivs[] }      │
//   │  ivs = liste PLATE, dédoublonnée par identité stable             │
//   └──────────────────────────────────────────────────────────────────┘
//        │ persiste (storeSave = seule porte)   │ projette (storeProject =
//        ▼                                      ▼  seul filtre d'affichage)
//   chrome.storage.local planv2_<date>      rendu (cards / horizontal)
//        └→ push débounce → dossier partagé (sous-dossier v2, CAS natif)
//
// ENREGISTREMENT iv — en plus des champs métier historiques (identité, live,
// enrichi fiche/xhr2, méta réservation), chaque iv porte :
//
//   • EXISTENCE (modèle vie/mort, hérité de mais avec UNE seule fusion) :
//       firstSeenAt   1re apparition connue (immuable, min des fusions)
//       lastSeenAt    dernière présence dans le XML EV (événement de VIE)
//       movedAt       déplacement via l'extension même jour (VIE)
//       deletedAt     suppression manuelle locale (MORT)
//       goneAt        constatée disparue/annulée/déplacée ailleurs (MORT)
//       missingSince  absente du dernier XML, analyse pas encore conclue
//       updatedAt     dernière modification réelle du contenu (fraîcheur de
//                     fusion — n'est PLUS re-stampé en masse à chaque save)
//     Règle : morte si max(deletedAt,goneAt) > 0 ET >= max(lastSeenAt,movedAt).
//     Tombstone conservé TOMBSTONE_TTL_MS pour propager la mort entre postes,
//     purgé ensuite.
//
//   • VERDICT (remplace ghost/_disappearStatus/_disappearRemove/_diagnostic*) :
//       verdict = { status, at, source, reason, techComment?, actionInfo?,
//                   officialClosed? }
//       status ∈ "live"      présente dans le planning EV (défaut)
//               "done"       terminée par le tech (✓ gris), pas encore close
//               "suspended"  terminée mais statut EV Suspendu (✓ jaune)
//               "closed"     clôturée/résolue officiellement (✓✓ vert)
//               "gone"       annulée / retirée / disparue sans trace
//               "moved"      déplacée vers une autre date via l'extension
//               "unknown"    analyse impossible (fiche illisible…) → visible
//       source ∈ "planning" (XML EV) | "fiche" (analyse) | "user" (action UI)
//     done/suspended/unknown sont RÉ-analysés à chaque actualisation (pour
//     détecter une clôture ultérieure) ; closed est final (sauf « Tout
//     recharger ») ; gone/moved posent goneAt (mort propagée).
//
//   • TRANSITOIRES (jamais persistés, recalculés par session) :
//       _analyzing (spinner d'analyse), _isNewIv, _timeChanged, _reloading,
//       xhr2Fetching, _hasOverlap, _absenceConflict, _fromDock.
//
// IDENTITÉ STABLE (ivKey) : requestId > actionId > ref — EV recycle parfois
// l'actionId d'une même intervention ; le requestId, lui, ne change pas.
// Filets supplémentaires à l'ingestion : correspondance par réf, et signature
// composite (tech|type|dates|libellé) pour les résa/absences sans requestId.
//
// Auteur : Quentin Rouiller (QRO).
// ============================================================================

const TOMBSTONE_TTL_MS = 7 * 24 * 3600 * 1000;  // rétention tombstone (convergence postes)

// Champs transitoires : jamais écrits dans le cache local ni le dossier.
const IV_TRANSIENT_FIELDS = [
  "_analyzing", "_isNewIv", "_timeChanged", "_reloading",
  "xhr2Fetching", "_hasOverlap", "_absenceConflict", "_fromDock",
  "_dispStartTime", "_dispEndTime"   // heures d'affichage du jour (multi-jours)
];
// Champs en plus à NE PAS écrire dans le dossier partagé : plomberie de
// session EV (régénérée au clic via la réf, fausse hors session). On garde
// TOUT ce qui s'affiche → l'autre poste reconstruit la carte SANS re-fetch.
const IV_FOLDER_DROP_FIELDS = [
  "formLink", "ficheFreshFullUrl", "ficheFreshFormLink",
  "ficheChecksum", "ficheTarget", "formSenderGuid", "_fetchWarning"
];

/** Identité stable d'une iv : requestId > actionId > ref. @author QRO */
function ivKey(iv) {
  // v2026.5.46 — réservations / absences : le CRÉNEAU fait partie de
  // l'identité. EasyVista peut rattacher le MÊME request_id (ou recycler
  // l'actionId) à plusieurs créneaux du même jour pour un même tech (ex. deux
  // réservations 15h-16h et 16h-17h liées à la même intervention). Sans le
  // créneau, ivKey renvoyait la même clé pour les deux → dayDedupeIvs les
  // fusionnait et une seule s'affichait. Les vraies interventions (draggables,
  // request_id unique) gardent une clé inchangée : slot vide.
  const slot = (iv.type === "AL-Reservation" || iv.type === "AL-Absence")
    ? "@" + (iv.startDate || "") + "T" + (iv.startTime || "")
    : "";
  if (iv.requestId) return "q:" + iv.requestId + slot;
  if (iv.actionId !== undefined && iv.actionId !== null) return "a:" + iv.actionId + slot;
  if (iv.ref) return "r:" + iv.ref + slot;
  return null;
}

/** Statut de verdict (défaut "live" : présente dans le planning EV). */
function ivVStatus(iv) {
  return (iv && iv.verdict && iv.verdict.status) || "live";
}

/** Pose un verdict horodaté (+ updatedAt pour la fraîcheur de fusion). */
function ivSetVerdict(iv, status, source, reason, extra) {
  iv.verdict = Object.assign({ status, at: Date.now(), source, reason: reason || "" }, extra || {});
  iv.updatedAt = Date.now();
  return iv.verdict;
}

// v2026.5.46 — INTERVENTIONS MULTI-JOURS : une iv peut commencer le mardi
// 9h et continuer plusieurs jours (startDate ≠ endDate, EV la renvoie dans le
// XML de chaque jour couvert). Le store garde les heures EV BRUTES ; la
// PROJECTION pose des heures d'AFFICHAGE par jour (_dispStartTime/_dispEndTime,
// transitoires) : 1er jour = début réel → fin de journée, jours intermédiaires
// = journée complète, dernier jour = début de journée → fin réelle. Le rendu
// (cartes, timeline, mini-cards, stats, rideau, conflits) lit _ivShownStart/
// _ivShownEnd ; le drag/reschedule et l'analyse gardent les heures réelles.
function ivIsMultiDay(iv) {
  return !!(iv && iv.startDate && iv.endDate && iv.startDate !== iv.endDate);
}
function _ivShownStart(iv) { return (iv && iv._dispStartTime) || (iv && iv.startTime) || ""; }
function _ivShownEnd(iv)   { return (iv && iv._dispEndTime) || (iv && iv.endTime) || ""; }
function _minToHHMMSafe(min) {
  const h = Math.floor(min / 60), m = min % 60;
  return String(h).padStart(2, "0") + ":" + String(m).padStart(2, "0");
}
// l'élément couvre-t-il TOUTE la plage horaire affichée de la journée ?
function _ivIsFullDayShown(iv) {
  const s = timeToMinutes(_ivShownStart(iv));
  const e = timeToMinutes(_ivShownEnd(iv));
  const { dayS: ds, dayE: de } = _dayRange();
  return s !== null && e !== null && s <= ds && e >= de;
}
// Pose (ou retire) les heures d'affichage d'une iv pour le jour donné.
function _ivStampDisplayTimes(iv, isoDate) {
  delete iv._dispStartTime;
  delete iv._dispEndTime;
  if (!ivIsMultiDay(iv) || !isoDate) return;
  const startIso = _ddmmyyyyToIso(iv.startDate);
  const endIso = _ddmmyyyyToIso(iv.endDate);
  if (!startIso || !endIso) return;
  const { dayS, dayE } = _dayRange();
  const dayStartHHMM = _minToHHMMSafe(dayS);
  const dayEndHHMM = _minToHHMMSafe(dayE);
  if (isoDate === startIso) {            // 1er jour : début réel → fin de journée
    iv._dispStartTime = iv.startTime || dayStartHHMM;
    iv._dispEndTime = dayEndHHMM;
  } else if (isoDate === endIso) {       // dernier jour : début de journée → fin réelle
    iv._dispStartTime = dayStartHHMM;
    iv._dispEndTime = iv.endTime || dayEndHHMM;
  } else if (isoDate > startIso && isoDate < endIso) {   // jour plein
    iv._dispStartTime = dayStartHHMM;
    iv._dispEndTime = dayEndHHMM;
  }
}

// ── v2026.5.46 — LOCALISATION OFFICIELLE de la fiche ───────────────────
// L'onglet Détail de la fiche EV porte un champ « Localisation »
// (AM_LOCATION.LOCATION_FR, format « Ville/Adresse ») dans le JSON du
// formulaire embarqué. Extrait au fetch de la fiche : il DEVIENT l'adresse
// affichée sur la carte, et il est COMPARÉ au lieu écrit dans l'action
// (infobulle.lieu, xhr2). En cas de désaccord → lieu en ROUGE + explication
// au survol. Comparaison tolérante : casse, accents, tirets/ponctuation et
// espaces ignorés.
function _extractFicheLocation(html) {
  if (!html) return null;
  let m = /"label":"Localisation"[^}]{0,600}?"value":"((?:[^"\\]|\\.)*)"/.exec(html);
  if (!m) m = /"fullName":"AM_LOCATION\.LOCATION_FR"[^}]{0,600}?"value":"((?:[^"\\]|\\.)*)"/.exec(html);
  if (!m || !m[1]) return null;
  let v = m[1];
  try { v = JSON.parse('"' + v + '"'); } catch (e) { v = v.replace(/\\\//g, "/"); }
  v = String(v).trim();
  return v || null;
}

// v2026.5.46 — comparaison d'adresses TOLÉRANTE : on compare des MOTS
// significatifs (noms + numéros), sans ordre (adresse inversée OK), avec
// INCLUSION (une adresse plus précise d'un côté — étage, complément — n'est
// pas une erreur), et en ignorant les mots de voirie/liaison (rue, av.,
// route, de, la…) pour absorber les abréviations. L'erreur ne sort que si
// les deux adresses divergent VRAIMENT : pas le bon numéro, ou pas la même
// ville/rue.
const _LOC_STOPWORDS = new Set([
  "de", "du", "des", "la", "le", "les", "l", "d", "et", "au", "aux", "a",
  "rue", "r", "av", "avenue", "rte", "route", "ch", "chemin", "pl", "place",
  "bd", "boulevard", "imp", "impasse", "quai", "all", "allee", "prom",
  "promenade", "sent", "sentier", "esc", "escalier", "etage", "niveau", "bat", "batiment"
]);
function _locTokens(s) {
  return _locNorm(s).split(" ").filter(t => t && !_LOC_STOPWORDS.has(t));
}
function _locMatchLoose(a, b) {
  const ta = _locTokens(a), tb = _locTokens(b);
  if (!ta.length || !tb.length) return true;   // pas assez d'info → pas d'alerte
  const sa = new Set(ta), sb = new Set(tb);
  const aInB = ta.every(t => sb.has(t));
  const bInA = tb.every(t => sa.has(t));
  return aInB || bInA;
}

// normalisation pour comparaison d'adresses : minuscules, sans accents, sans
// tirets/apostrophes/ponctuation légère, séparateurs unifiés, espaces réduits.
function _locNorm(s) {
  return String(s || "")
    .normalize("NFD").replace(/[\u0300-\u036f]/g, "")
    .toLowerCase()
    .replace(/[-–—'’\u0060´.,;:]/g, " ")
    .replace(/[\/|]/g, " ")
    .replace(/\s+/g, " ")
    .trim();
}

// (re)calcule iv.locMismatch = {fiche, action} si les deux adresses connues
// divergent (null sinon, si l'une manque, ou si l'action est de catégorie
// « Roll Out » — isRollOut, la MÊME détection que la catégorie affichée sur
// la carte : l'adresse de l'action désigne alors le site du déploiement,
// différer de la fiche est normal). Persisté → propagé au dossier.
function _updateLocMismatch(iv) {
  const ficheLoc = iv.ficheLocation;
  const actionLoc = iv.infobulle && iv.infobulle.lieu;
  const before = iv.locMismatch ? 1 : 0;
  if (!ficheLoc || !actionLoc || isRollOut(iv)) {
    iv.locMismatch = null;
  } else {
    iv.locMismatch = _locMatchLoose(ficheLoc, actionLoc)
      ? null
      : { fiche: ficheLoc, action: actionLoc };
  }
  if ((iv.locMismatch ? 1 : 0) !== before) iv.updatedAt = Date.now();
}

// Le « fiche partiellement récupérée » est PÉRIMÉ si, malgré tout, on a fini
// par lire la fiche : verdict d'analyse abouti (≠ unknown) OU statut
// clos/résolu. Sert à ne plus afficher un resté collé dans le store.
function _staleFetchWarning(iv) {
  if (!iv) return false;
  const vs = ivVStatus(iv);
  if (vs !== "live" && vs !== "unknown") return true;
  if (isClosedStatus(iv.status) || isResolvedStatus(iv.status)) return true;
  return false;
}

// ── Modèle vie/mort ──────────────────────────────────────────────────────────
function ivDeathAt(iv) { return Math.max(iv.deletedAt || 0, iv.goneAt || 0); }
function ivLifeAt(iv)  { return Math.max(iv.lastSeenAt || 0, iv.movedAt || 0); }
function ivIsDead(iv)  { const d = ivDeathAt(iv); return d > 0 && d >= ivLifeAt(iv); }
function ivIsExpiredTombstone(iv, now) {
  const d = ivDeathAt(iv);
  return d > 0 && ((now || Date.now()) - d) > TOMBSTONE_TTL_MS;
}

// Fraîcheur d'une copie = horodatage le plus récent de tous ses événements.
// Sert uniquement à choisir la copie de BASE pour les métadonnées en fusion —
// l'EXISTENCE, elle, est résolue par le modèle vie/mort, jamais par fraîcheur.
function ivFreshness(iv) {
  return Math.max(iv.updatedAt || 0, (iv.verdict && iv.verdict.at) || 0,
                  iv.lastSeenAt || 0, iv.movedAt || 0,
                  iv.deletedAt || 0, iv.goneAt || 0);
}

/**
 * Fusionne deux copies d'une MÊME iv (même identité stable). LA seule fusion
 * du système — utilisée pour : store↔dossier, dédoublonnage, import.
 *   1. métadonnées : copie la plus fraîche en base, enrichissements complétés ;
 *   2. verdict : le plus récent (verdict.at) ;
 *   3. existence : max des événements des deux côtés, puis règle vie/mort —
 *      une VIE strictement postérieure à la mort lève les tombstones
 *      (ré-apparition EV autoritaire), sinon la mort est conservée/propagée.
 * @author Quentin Rouiller
 */
function ivMerge(a, b) {
  if (!a) return b;
  if (!b) return a;
  const base = (ivFreshness(b) > ivFreshness(a)) ? b : a;
  const other = (base === a) ? b : a;
  const w = { ...base };
  // 1re apparition = la plus ancienne connue
  const first = Math.min(a.firstSeenAt || Infinity, b.firstSeenAt || Infinity);
  if (isFinite(first)) w.firstSeenAt = first;
  // enrichissements : on complète depuis l'autre copie sans rien perdre
  if (!w.ficheFetched && other.ficheFetched) {
    w.ficheFetched = true;
    if (!w.status && other.status) w.status = other.status;
    if (!w.bulleDescription && other.bulleDescription) w.bulleDescription = other.bulleDescription;
    if (!w.ficheActionText && other.ficheActionText) w.ficheActionText = other.ficheActionText;
  }
  if (!w.xhr2Fetched && other.xhr2Fetched) {
    w.xhr2Fetched = true;
    if (!w.bulleDescription && other.bulleDescription) w.bulleDescription = other.bulleDescription;
    if (!w.infobulle && other.infobulle) w.infobulle = other.infobulle;
  }
  // v2026.5.46 — méta RÉSERVATION (n° DS, ville, rue, catégorie) : EV ne
  // la stocke PAS, elle est saisie/locale au poste créateur et ne voyage que
  // par le dossier partagé. C'est un ENRICHISSEMENT au même titre que la
  // description de fiche : on le complète depuis l'autre copie quand la base
  // (typiquement l'iv EV re-fetchée par un autre poste, plus fraîche mais
  // SANS la méta) ne l'a pas. Sans cette recopie, la base gagnait et la méta
  // du dossier était perdue → jamais reçue par les autres postes.
  if (!w.resNumero && other.resNumero) w.resNumero = other.resNumero;
  if (!w.resVille && other.resVille) w.resVille = other.resVille;
  if (!w.resRue && other.resRue) w.resRue = other.resRue;
  if (!w.resCategorie && other.resCategorie) w.resCategorie = other.resCategorie;
  // reservationLabel/Creator viennent normalement d'EV (re-fetchés partout),
  // mais on les complète aussi si la base dégradée les a perdus.
  if (!w.reservationLabel && other.reservationLabel) w.reservationLabel = other.reservationLabel;
  if (!w.reservationCreator && other.reservationCreator) w.reservationCreator = other.reservationCreator;
  // verdict le plus récent
  const va = a.verdict, vb = b.verdict;
  w.verdict = !va ? vb : (!vb ? va : (((vb.at || 0) > (va.at || 0)) ? vb : va));
  // existence : union des événements…
  w.deletedAt   = Math.max(a.deletedAt || 0, b.deletedAt || 0) || undefined;
  w.goneAt      = Math.max(a.goneAt || 0, b.goneAt || 0) || undefined;
  w.lastSeenAt  = Math.max(a.lastSeenAt || 0, b.lastSeenAt || 0) || undefined;
  w.movedAt     = Math.max(a.movedAt || 0, b.movedAt || 0) || undefined;
  // missingSince : on garde l'événement de disparition le PLUS RÉCENT (max) —
  // un min permettrait à une « vie » intermédiaire d'effacer une disparition
  // constatée après elle sur l'autre poste.
  const ms = Math.max(a.missingSince || 0, b.missingSince || 0);
  w.missingSince = ms || undefined;
  // …puis règle vie/mort : une vie STRICTEMENT postérieure lève la mort.
  const death = Math.max(w.deletedAt || 0, w.goneAt || 0);
  const life = Math.max(w.lastSeenAt || 0, w.movedAt || 0);
  if (death > 0 && life > death) { w.deletedAt = undefined; w.goneAt = undefined; }
  // revue vivante après sa disparition → plus « manquante »
  if (w.missingSince && (w.lastSeenAt || 0) > w.missingSince) w.missingSince = undefined;
  return w;
}

/** Copie persistable (sans transitoires) ; forFolder retire aussi la plomberie session. */
function ivStrip(iv, forFolder) {
  const c = { ...iv };
  for (const f of IV_TRANSIENT_FIELDS) delete c[f];
  if (forFolder) for (const f of IV_FOLDER_DROP_FIELDS) delete c[f];
  return c;
}

/** Dédoublonne une liste d'ivs par identité stable (fusion ivMerge) + purge les tombstones expirés. */
function dayDedupeIvs(ivs) {
  const now = Date.now();
  const byKey = new Map();
  const out = [];
  for (const iv of (ivs || [])) {
    if (!iv) continue;                          // entrée corrompue → ignorée
    if (ivIsExpiredTombstone(iv, now)) continue;
    const k = ivKey(iv);
    if (!k) { out.push(iv); continue; }
    if (!byKey.has(k)) { byKey.set(k, out.length); out.push(iv); continue; }
    const idx = byKey.get(k);
    out[idx] = ivMerge(out[idx], iv);
  }
  return out;
}

/** Entrée jour vierge. */
function dayNew(isoDate) {
  return { schema: 2, date: isoDate, savedAt: 0, techs: [], ivs: [] };
}

/**
 * Fusionne deux entrées jour (local ↔ dossier, import…) : annuaire des techs
 * du plus récent complété par l'autre, union des ivs par identité (ivMerge).
 */
function dayMerge(a, b) {
  if (!a || !Array.isArray(a.ivs)) return b || null;
  if (!b || !Array.isArray(b.ivs)) return a || null;
  const newer = ((a.savedAt || 0) >= (b.savedAt || 0)) ? a : b;
  const older = (newer === a) ? b : a;
  const techById = new Map();
  for (const t of (older.techs || [])) techById.set(String(t.id), t);
  for (const t of (newer.techs || [])) techById.set(String(t.id), t);  // le récent écrase
  return {
    schema: 2,
    date: newer.date || older.date,
    savedAt: Math.max(a.savedAt || 0, b.savedAt || 0),
    techs: [...techById.values()],
    ivs: dayDedupeIvs([...(a.ivs || []), ...(b.ivs || [])])
  };
}

// ── Persistance locale (chrome.storage.local) ────────────────────────────────

/** Charge l'entrée jour v2 (null si absente ou schéma inconnu). */
async function storeLoad(isoDate) {
  const key = STORE_PREFIX + isoDate;
  const obj = await chrome.storage.local.get(key);
  const day = obj[key];
  if (!day || day.schema !== 2 || !Array.isArray(day.ivs)) return null;
  return day;
}

/**
 * LA porte d'écriture du store : dédoublonne/purge, horodate savedAt,
 * persiste (avec purge + retry si quota plein), puis programme le push
 * débounce vers le dossier partagé. Le `day` en mémoire garde ses champs
 * transitoires (seule la copie persistée est nettoyée).
 */
async function storeSave(isoDate, day, opts = {}) {
  if (!day) return;
  day.schema = 2;
  day.date = isoDate;
  day.ivs = dayDedupeIvs(day.ivs);
  day.savedAt = Date.now();
  const payload = { ...day, ivs: day.ivs.map(iv => ivStrip(iv, false)) };
  const key = STORE_PREFIX + isoDate;
  try {
    await chrome.storage.local.set({ [key]: payload });
  } catch (e) {
    const msg = (e && e.message) || String(e);
    if (msg.toUpperCase().includes("QUOTA")) {
      LOG.warn("store", "quota dépassé → purge des vieux jours puis retry", { key });
      try {
        await storePurgeOldDays();
        await chrome.storage.local.set({ [key]: payload });
        LOG.info("store", "écriture OK après purge", { key });
      } catch (e2) {
        LOG.exception("store", "écriture échouée même après purge", e2, { key });
        if (typeof showToast === "function") showToast("Cache plein", "Les données ne sont pas mises en cache");
        return;
      }
    } else {
      LOG.exception("store", "écriture échouée", e, { key });
      return;
    }
  }
  if (!opts.noFolderPush) scheduleFolderPush(isoDate);
}

/** Purge les jours plus vieux que cfg.cacheDays (défaut 7 j) — au boot ET sur quota plein. */
async function storePurgeOldDays() {
  const cfg = await loadAdminConfig();
  const days = (typeof cfg.cacheDays === "number" && cfg.cacheDays > 0) ? cfg.cacheDays : 7;
  const all = await chrome.storage.local.get(null);
  const now = Date.now();
  const maxAgeMs = days * 24 * 60 * 60 * 1000;
  const toRemove = [];
  for (const k of Object.keys(all)) {
    if (!k.startsWith(STORE_PREFIX)) continue;
    const v = all[k];
    if (v && typeof v.savedAt === "number" && (now - v.savedAt) > maxAgeMs) toRemove.push(k);
  }
  if (toRemove.length > 0) {
    await chrome.storage.local.remove(toRemove);
    LOG.info("store", `purgé ${toRemove.length} jour(s) > ${days}j`, { keys: toRemove });
  }
}

/** Purge unique des clés de l'ANCIEN format (planning_cache_*) — libère le quota. */
async function storePurgeLegacy() {
  try {
    const all = await chrome.storage.local.get(null);
    const toRemove = Object.keys(all).filter(k => k.startsWith(LEGACY_CACHE_PREFIX));
    if (toRemove.length > 0) {
      await chrome.storage.local.remove(toRemove);
      LOG.warn("store", `ancien cache purgé (${toRemove.length} clé(s) planning_cache_*) — store v2 repart de zéro`);
    }
  } catch (e) {
    LOG.warn("store", "purge ancien cache échouée (ignoré)", { err: e && e.message });
  }
}

// ── Ingestion du planning EV (remplace mergeCacheAndFresh) ───────────────────

// Champs « live » recopiés du XML EV à chaque ingestion (le planning peut
// avoir bougé). L'enrichi (description, statut, fiche) reste au store.
function _ivApplyLiveFields(rec, iv, tech, now) {
  const timeChanged = (rec.startTime !== iv.startTime) || (rec.endTime !== iv.endTime) ||
                      (rec.startDate !== iv.startDate) || (String(rec.techId) !== String(iv.techId));
  rec._timeChanged = timeChanged;
  rec.actionId = iv.actionId || rec.actionId;     // fresh prioritaire (vieux caches sans actionId)
  rec.requestId = iv.requestId || rec.requestId;
  rec.ref = iv.ref || rec.ref;
  rec.techId = iv.techId || rec.techId;
  rec.techName = (tech && tech.name) || rec.techName;
  rec.type = iv.type || rec.type;
  rec.originalType = iv.originalType || rec.originalType;
  rec.label = iv.label || rec.label;
  rec.cssClass = iv.cssClass || rec.cssClass;
  rec.isPompier = iv.isPompier;
  rec.absenceCategory = (iv.absenceCategory !== undefined) ? iv.absenceCategory : rec.absenceCategory;
  rec.reservationLabel = iv.reservationLabel || rec.reservationLabel;
  rec.reservationCreator = iv.reservationCreator || rec.reservationCreator;
  rec.startDate = iv.startDate || rec.startDate;
  rec.endDate = iv.endDate || rec.endDate;
  rec.startTime = iv.startTime || rec.startTime;
  rec.endTime = iv.endTime || rec.endTime;
  rec.currentDate = iv.currentDate || rec.currentDate;
  rec.formLink = iv.formLink || rec.formLink;
  rec.deadline = iv.deadline || rec.deadline;
  rec.categoryLine = iv.categoryLine || rec.categoryLine;
  rec.bulleContact = iv.bulleContact || rec.bulleContact;
  rec.bulleLieu = iv.bulleLieu || rec.bulleLieu;
  // méta réservation : le fresh la tient du store persistant (réappliquée au
  // parse) → prioritaire sur la copie du jour.
  rec.resNumero = iv.resNumero || rec.resNumero;
  rec.resVille = iv.resVille || rec.resVille;
  rec.resRue = iv.resRue || rec.resRue;
  rec.resCategorie = iv.resCategorie || rec.resCategorie;
  if (timeChanged) rec.updatedAt = now;
  return rec;
}

// Signature composite résa/absence (EV recycle leur actionId entre requêtes).
function _ivAbsenceSig(iv, techId) {
  // v2026.5.46 — le créneau (heures de début/fin) entre dans la signature :
  // deux réservations du même tech le même jour ne diffèrent QUE par leur
  // horaire ; sans lui, ce filet de secours (matching quand ni actionId ni réf
  // ne collent) les confondait et fusionnait la seconde sur la première.
  return [techId, iv.type, iv.startDate || "", iv.endDate || "",
    iv.startTime || "", iv.endTime || "",
    iv.isPompier ? "P" : "", (iv.label || "").trim()].join("|");
}

/**
 * Ingestion du XML EV frais dans le store du jour. LE point de vérité sur la
 * présence : une iv présente est VIVANTE (lastSeenAt, tombstones levés,
 * verdict live) ; une iv absente devient « manquante » (missingSince) et part
 * à l'analyse — sauf résa/absences (pas de fiche) qui deviennent gone direct.
 *
 * @returns {{day: object, toAnalyze: object[]}} le store mis à jour + la
 *          liste des enregistrements à passer à l'analyse de disparition.
 * @author Quentin Rouiller
 */
function storeApplyFresh(day, freshTechs, isoDate) {
  const now = Date.now();
  day = day || dayNew(isoDate);

  // 1. annuaire des techs du jour = celui du fresh (autoritaire pour l'affichage)
  day.techs = (freshTechs || []).map(t => {
    const meta = { ...t };
    delete meta.interventions;
    return meta;
  });

  // 2. index du store : clé stable + réf + signature résa/absence (filets
  //    contre le recyclage d'actionId par EV)
  const byKey = new Map(), byRef = new Map(), bySig = new Map();
  for (let i = 0; i < day.ivs.length; i++) {
    const r = day.ivs[i];
    const k = ivKey(r);
    if (k && !byKey.has(k)) byKey.set(k, i);
    if (r.ref && !byRef.has(r.ref)) byRef.set(r.ref, i);
    if (r.type === "AL-Absence" || r.type === "AL-Reservation") {
      const s = _ivAbsenceSig(r, r.techId);
      if (!bySig.has(s)) bySig.set(s, i);
    }
  }

  // 3. ingestion : chaque iv du fresh est vivante MAINTENANT
  const seenIdx = new Set();
  let added = 0, revived = 0;
  for (const tech of (freshTechs || [])) {
    for (const iv of (tech.interventions || [])) {
      // garde-fou déplacement récent : EV peut resservir (cache serveur) une
      // iv qu'on vient de déplacer vers une autre date → on N'INGÈRE PAS sa
      // présence pendant la fenêtre, sinon fausse « vie » qui annulerait le
      // verdict moved.
      if (_recentlyMovedAwayCovers(iv.actionId, isoDate)) {
        LOG.info("store", `ingestion ignorée (déplacée à l'instant) actionId=${iv.actionId}`);
        continue;
      }
      const k = ivKey(iv);
      let idx = (k && byKey.has(k)) ? byKey.get(k) : undefined;
      if (idx === undefined && iv.ref && byRef.has(iv.ref)) idx = byRef.get(iv.ref);
      if (idx === undefined && (iv.type === "AL-Absence" || iv.type === "AL-Reservation")) {
        const s = _ivAbsenceSig(iv, tech.id);
        if (bySig.has(s)) idx = bySig.get(s);
      }
      if (idx !== undefined) {
        const rec = day.ivs[idx];
        seenIdx.add(idx);
        const wasDeadOrGone = ivIsDead(rec) || ivVStatus(rec) !== "live";
        _ivApplyLiveFields(rec, iv, tech, now);
        rec.lastSeenAt = now;            // événement de VIE (autorité EV)
        rec.missingSince = undefined;
        if (rec.deletedAt || rec.goneAt) {  // ré-apparue → tombstones levés
          rec.deletedAt = undefined;
          rec.goneAt = undefined;
        }
        if (ivVStatus(rec) !== "live") {
          // de retour dans le planning → re-planifiée/ré-attribuée : verdict
          // remis à live (sinon « fait » bloquerait le drag&drop, cf. v4).
          ivSetVerdict(rec, "live", "planning", "re-présente dans le planning EV");
          rec.ficheFetched = false;       // re-fetch fiche (statut a pu changer)
        }
        if (wasDeadOrGone) revived++;
      } else {
        // iv totalement nouvelle
        const rec = { ...iv };
        rec.techName = tech.name || "";
        rec.firstSeenAt = now;
        rec.lastSeenAt = now;
        rec.updatedAt = now;
        ivSetVerdict(rec, "live", "planning", "nouvelle dans le planning EV");
        rec._isNewIv = true;
        day.ivs.push(rec);
        added++;
      }
    }
  }

  // 4. ivs du store NON vues dans le fresh → disparues.
  //    GARDE-FOU : un tech absent du fresh (retiré de l'équipe locale, ou
  //    équipe configurée différemment sur un autre poste) ne rend PAS ses ivs
  //    « disparues » — elles ne sont simplement plus affichées ici. Sans ça,
  //    on les analyserait/retirerait à tort et on propagerait ces tombstones
  //    au dossier partagé (régression vs comportement historique).
  const freshTechIds = new Set((freshTechs || []).map(t => String(t.id)));
  let wentMissing = 0, goneDirect = 0;
  for (let i = 0; i < day.ivs.length; i++) {
    if (seenIdx.has(i)) continue;
    const rec = day.ivs[i];
    if (!freshTechIds.has(String(rec.techId))) continue;  // tech hors équipe du jour
    if (ivIsDead(rec)) continue;                       // déjà tombstone
    if (rec.firstSeenAt === now) continue;             // vient d'être ajoutée (autre boucle)
    const vs = ivVStatus(rec);
    if (rec.type === "AL-Reservation" || rec.type === "AL-Absence") {
      // pas de fiche à analyser : disparue du planning = retirée → mort
      // directe propagée (anti-résurrection).
      if (vs !== "gone") {
        ivSetVerdict(rec, "gone", "planning", `${rec.type} disparue du planning EV`);
        rec.goneAt = now;
        goneDirect++;
        LOG.info("disparition", `→ gone (résa/absence) actionId=${rec.actionId} tech='${rec.techName}'`,
          { ref: rec.ref, actionId: rec.actionId, type: rec.type, label: rec.label });
      }
      continue;
    }
    // gone/moved vivants (case diagnostic) : pas de ré-analyse.
    if (vs === "gone" || vs === "moved") continue;
    if (!rec.missingSince) {
      rec.missingSince = now;
      wentMissing++;
      LOG.info("disparition",
        `DISPARUE du planning → ref=${rec.ref || "?"} actionId=${rec.actionId} tech='${rec.techName}' verdict=${vs}`,
        { ref: rec.ref, actionId: rec.actionId, requestId: rec.requestId, type: rec.type,
          startTime: rec.startTime, endTime: rec.endTime, statusEnCache: rec.status });
    }
  }

  // 5. dédoublonnage final (filets actionId recyclé) + purge tombstones
  day.ivs = dayDedupeIvs(day.ivs);

  // 6. file d'analyse — construite APRÈS le dédoublonnage pour référencer les
  //    enregistrements DÉFINITIFS du store (un verdict écrit sur une copie
  //    fusionnée-jetée serait perdu). closed ET done sont FINAUX : pas de
  //    ré-analyse à chaque actualisation (économie réseau — v2026.5.46,
  //    demande utilisateur) ; « Tout recharger » les repasse, géré par
  //    l'appelant. suspended reste ré-analysé (statut EV susceptible d'évoluer).
  const toAnalyze = [];
  for (const rec of day.ivs) {
    if (ivIsDead(rec) || !rec.missingSince) continue;
    if (rec.type !== "AL-Intervention") continue;
    const vs = ivVStatus(rec);
    if (vs === "gone" || vs === "moved" || vs === "closed" || vs === "done") continue;
    toAnalyze.push(rec);
  }

  LOG.info("store", `ingestion EV : +${added} nouvelle(s), ${revived} revenue(s), ${wentMissing} disparue(s) (${toAnalyze.length} à analyser), ${goneDirect} résa/absence(s) retirée(s)`,
    { date: isoDate, totalIvs: day.ivs.length });
  return { day, toAnalyze };
}

// ── Mutations utilisateur ────────────────────────────────────────────────────

/**
 * Suppression locale (« Retirer du planning », sans effet EV) : tombstone
 * deletedAt + verdict gone, propagés au dossier. Matche par actionId.
 */
async function storeMarkDeleted(isoDate, actionId) {
  if (!actionId || !isoDate) return false;
  try {
    const day = (state.currentDate === isoDate && state.currentDay && state.currentDay.date === isoDate)
      ? state.currentDay : await storeLoad(isoDate);
    if (!day) return false;
    let found = false;
    for (const rec of day.ivs) {
      if (String(rec.actionId) === String(actionId)) {
        rec.deletedAt = Date.now();
        ivSetVerdict(rec, "gone", "user", "retirée manuellement du planning");
        found = true;
      }
    }
    if (found) await storeSave(isoDate, day);
    return found;
  } catch (err) {
    LOG.warn("store", "pose du tombstone échouée", { actionId, isoDate, err: err && err.message });
    return false;
  }
}

/**
 * Déplacement APPLIQUÉ par l'extension (reschedule réussi côté EV).
 *  - vers une AUTRE date : verdict moved + goneAt sur le jour source (la mort
 *    se propage, l'iv apparaîtra fraîche sur le jour cible au prochain
 *    chargement de celui-ci) + fenêtre anti cache-serveur EV ;
 *  - même jour (heure/tech) : movedAt (événement de vie : la version déplacée
 *    gagne la fusion face à une copie plus ancienne d'un autre poste).
 */
function storeMarkMoved(day, rec, change) {
  const now = Date.now();
  if (!day || !rec) return;
  if (change && change.newDateIso && change.newDateIso !== day.date) {
    rec.goneAt = now;
    ivSetVerdict(rec, "moved", "user", `déplacée vers le ${change.newDateIso}`);
    _registerRecentMove(rec.actionId, day.date, change.newDateIso);
  } else {
    rec.movedAt = now;
    rec.updatedAt = now;
    if (change) {
      if (change.newStartTime) rec.startTime = change.newStartTime;
      if (change.newEndTime) rec.endTime = change.newEndTime;
      if (change.newTechId) rec.techId = String(change.newTechId);
    }
  }
}

// ── Projection rendu (LE seul filtre d'affichage) ────────────────────────────

/**
 * Projette le store du jour en `techs[]` pour le rendu. Les objets iv sont
 * PARTAGÉS par référence avec le store : l'enrichissement en arrière-plan
 * (fiches, xhr2) mute directement les enregistrements, et updateInterventionRow
 * reste valable. Filtres appliqués ICI et nulle part ailleurs :
 *   - tombstones (modèle vie/mort) ;
 *   - verdicts gone/moved (sauf case diagnostic « Garder les disparitions ») ;
 *   - disparues jamais analysées (anti-flash : verdict encore live + missing) ;
 *   - iv parquées au dock (état client, les données restent intactes) ;
 *   - iv tout juste déplacées vers une autre date (fenêtre cache serveur EV).
 */
function storeProject(day, isoDate) {
  if (!day) return [];
  // v2026.5.46 — l'affichage suit l'ÉQUIPE ACTUELLE (Paramètres → Équipe).
  // L'annuaire du jour (day.techs) peut encore contenir un tech retiré de la
  // config : la fusion dossier (dayMerge) fait l'UNION avec les fichiers du
  // partage, écrits avant le retrait ou par un poste dont l'équipe diffère.
  // On filtre à la PROJECTION seulement : le store et le dossier partagé
  // conservent tout (re-ajouter le tech le fait réapparaître avec son
  // historique, les autres postes ne perdent rien). TEAM vide (config pas
  // encore chargée / première installation) → pas de filtre.
  const hasTeam = !!TEAM && Object.keys(TEAM).length > 0;
  const techs = (day.techs || [])
    .filter(t => !hasTeam || Object.prototype.hasOwnProperty.call(TEAM, String(t.id)))
    .map(t => ({ ...t, interventions: [] }));
  const byTech = new Map(techs.map(t => [String(t.id), t]));
  for (const iv of (day.ivs || [])) {
    if (ivIsDead(iv)) continue;
    const vs = ivVStatus(iv);
    if ((vs === "gone" || vs === "moved") && !KEEP_DIAG_GHOSTS) continue;
    // v2026.5.46 — une disparue PAS ENCORE jugée reste AFFICHÉE (grisée,
    // spinner pendant l'analyse) au lieu de disparaître/réapparaître ; si le
    // verdict tombe « gone », elle s'enlève à ce moment-là.
    if (_ivDock.items.size > 0) {
      // masque l'iv parquée UNIQUEMENT sur son jour d'origine (un actionId
      // recyclé par EV sur un autre jour ne doit pas être masqué à tort).
      const snap = _ivDock.items.get(String(iv.actionId));
      if (snap && (!snap._originalDate || snap._originalDate === (isoDate || day.date))) continue;
    }
    if (_recentlyMovedAwayCovers(iv.actionId, isoDate || day.date)) continue;
    const t = byTech.get(String(iv.techId));
    if (!t) continue;   // tech plus dans l'équipe du jour → non rendu (données conservées)
    _ivStampDisplayTimes(iv, isoDate || day.date);   // heures d'affichage du jour (multi-jours)
    t.interventions.push(iv);
  }
  for (const t of techs) {
    t.interventions.sort((a, b) => (_ivShownStart(a)).localeCompare(_ivShownStart(b)));
  }
  return techs;
}

/** Le jour isoDate est-il celui actuellement affiché (état + entrée mémoire) ? */
function _jourAffiche(isoDate) {
  return state.currentDate === isoDate && !!state.currentDay &&
         state.currentDay.date === isoDate;
}

/** Re-rend le jour courant depuis le store en mémoire (après mutation). */
function storeRenderCurrent(source) {
  if (!state.currentDay || typeof renderFromData !== "function") return;
  renderFromData({
    techs: storeProject(state.currentDay, state.currentDate),
    targetDate: state.currentDate,
    captureTime: Date.now(),
    source: source || "store"
  });
}

// ============================================================================
// Sync store <-> dossier partagé (native messaging, optionnel)  // 2026.5.46
// ============================================================================
// Un hôte natif (PowerShell) écrit/lit une image YYYY-MM-DD.json par jour dans
// un dossier réseau partagé (verrou + écriture atomique + compare-and-swap sur
// savedAt). L'extension fonctionne SANS l'hôte (dégradation gracieuse) : s'il
// est absent, ces fonctions sont des no-ops et le store reste purement local.
//
// v2026.5.46 — les fichiers v2 vivent dans le SOUS-DOSSIER « v2 » du
// partage configuré (l'hôte crée les dossiers manquants) : les postes restés
// en ancienne version continuent d'écrire leurs fichiers à la racine sans
// jamais interférer avec le nouveau format. Le transport natif est inchangé.

// v2026.5.46 — date dont le pipeline de chargement (loadForDate) est en
// cours : la convergence dossier est REPORTÉE tant qu'il tourne, pour ne pas
// remplacer state.currentDay (et ses références partagées avec le rendu et la
// file d'enrichissement) en plein milieu des mutations.
let _loadPipelineDate = null;
// v2026.5.46 — jeton du pipeline PROPRIÉTAIRE de _loadPipelineDate : seul
// lui a le droit de retirer le report de convergence dans son finally (un
// pipeline avorté de la même date ne doit pas retirer le verrou posé par son
// successeur). Sert aussi de cible au bouton « Arrêter ».
let _loadPipelineToken = null;

const NM_HOST = "ch.netaplaid.planification";
const NM_HOST_REQUIRED_VERSION = "2026.1.7";
const NM_FOLDER_SUBDIR = "v2";   // sous-dossier des fichiers-jour schéma 2
let _nmAvailable = null;   // null = pas encore sondé ; true/false ensuite
let _nmVersion = null;
const _nmPushTimers = {};
let _lastSyncErrorToast = 0;

function _fmtDateFR(iso) {
  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(iso || "");
  return m ? `${m[3]}/${m[2]}/${m[1]}` : (iso || "");
}

// Toast bas-droite (débounce 30 s) → clic ouvre le journal de sync.
function _notifySyncError(context, errMsg) {
  const now = Date.now();
  if (now - _lastSyncErrorToast < 30000) return;
  _lastSyncErrorToast = now;
  LOG.warn("sync", "erreur hôte signalée", { context, err: errMsg });
  if (typeof showToast === "function") {
    showToast("⚠️ Erreur de synchronisation", "Cliquez pour voir le journal", () => {
      if (typeof showAdminPanel === "function") showAdminPanel("sync");
    });
  }
}

// Vraie erreur hôte = script présent mais opération échouée (≠ absent/timeout).
function _checkNmError(r, context) {
  // conflict/locked = situations normales gérées par retry → pas une "erreur".
  if (r && r.ok === false && r.error && !r._absent && r.error !== "timeout" && !r.conflict && !r.locked) {
    _notifySyncError(context, r.error);
  }
}

// Renvoie le journal brut (chaîne) ou "".
async function nmGetLog() {
  if (!(await nmProbe())) return "";
  const r = await nmSend({ action: "log" });
  return (r && r.ok && r.log) ? String(r.log) : "";
}

// v2026.5.46 — PERF : port natif PERSISTANT (connectNative) au lieu de
// sendNativeMessage. Avant, chaque message relançait un process PowerShell
// (~300-500 ms) → 1-2 s de latence par changement de date. Ici l'hôte démarre
// UNE fois par session et reste vivant ; les échanges deviennent ~ms.
// Corrélation FIFO : l'hôte répond exactement une fois par message, dans
// l'ordre. Une réponse tardive (après timeout) est ignorée mais consomme bien
// sa place dans la file (l'ordre reste intact). À la déconnexion, on vide la
// file et on rouvrira le port à la demande suivante.
let _nmPort = null;
const _nmQueue = [];

function _nmEnsurePort() {
  if (_nmPort) return _nmPort;
  let port;
  try { port = chrome.runtime.connectNative(NM_HOST); }
  catch (e) { return null; }
  port.onMessage.addListener((resp) => {
    const entry = _nmQueue.shift();
    if (entry) entry.settle(resp || { ok: false, error: "empty_response" });
  });
  port.onDisconnect.addListener(() => {
    const err = (chrome.runtime.lastError && chrome.runtime.lastError.message) || "disconnected";
    _nmPort = null;
    while (_nmQueue.length) { _nmQueue.shift().settle({ ok: false, error: err, _absent: true }); }
  });
  _nmPort = port;
  return port;
}

function nmSend(message, timeoutMs = 8000) {
  return new Promise((resolve) => {
    const port = _nmEnsurePort();
    if (!port) { resolve({ ok: false, error: "no_native_host", _absent: true }); return; }
    let settled = false;
    const entry = { settle: (resp) => { if (settled) return; settled = true; clearTimeout(timer); resolve(resp); } };
    const timer = setTimeout(() => {
      // On ne retire PAS l'entrée de la file (l'ordre FIFO doit rester intact) ;
      // une réponse tardive sera ignorée car settled=true.
      if (!settled) { settled = true; resolve({ ok: false, error: "timeout" }); }
    }, timeoutMs);
    _nmQueue.push(entry);
    try {
      port.postMessage(message);
    } catch (e) {
      _nmPort = null;
      entry.settle({ ok: false, error: String(e), _absent: true });
    }
  });
}

// Sonde l'hôte une fois (mémoïsé). Renvoie true si dispo.
async function nmProbe(force = false) {
  if (_nmAvailable !== null && !force) return _nmAvailable;
  const resp = await nmSend({ action: "version" }, 5000);
  _nmAvailable = !!(resp && resp.ok);
  _nmVersion = (resp && resp.version) || null;
  LOG.info("sync", `sonde hôte natif : ${_nmAvailable ? "OK v" + _nmVersion : "absent"}`);
  return _nmAvailable;
}

// Chemin effectif des fichiers v2 = racine configurée + sous-dossier "v2".
// (Resolve-Share côté hôte crée les dossiers manquants → rien à installer.)
async function nmSharePath() {
  const cfg = await loadAdminConfig();
  const root = (cfg && cfg.sharedCachePath) ? String(cfg.sharedCachePath).replace(/[\\/]+$/, "") : "";
  if (!root) return "";
  return root + "\\" + NM_FOLDER_SUBDIR;
}

async function nmStatDay(date, path) {
  const r = await nmSend({ action: "stat", path, date });
  _checkNmError(r, "vérification");
  if (!r || !r.ok) return null;
  return r.exists ? { exists: true, savedAt: r.savedAt || 0 } : { exists: false };
}

function _b64ToBytes(b64) {
  const bin = atob(b64);
  const bytes = new Uint8Array(bin.length);
  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
  return bytes;
}

// v2026.5.46 — octets → base64 (par tranches pour éviter le dépassement de
// pile sur gros tableaux).
function _bytesToB64(bytes) {
  let bin = "";
  const CH = 0x8000;
  for (let i = 0; i < bytes.length; i += CH) {
    bin += String.fromCharCode.apply(null, bytes.subarray(i, Math.min(i + CH, bytes.length)));
  }
  return btoa(bin);
}
// (dé)compression gzip native du navigateur (CompressionStream, Chrome + Firefox).
async function _gzipBytes(bytes) {
  const cs = new CompressionStream("gzip");
  const ab = await new Response(new Blob([bytes]).stream().pipeThrough(cs)).arrayBuffer();
  return new Uint8Array(ab);
}
async function _gunzipBytes(bytes) {
  const ds = new DecompressionStream("gzip");
  const ab = await new Response(new Blob([bytes]).stream().pipeThrough(ds)).arrayBuffer();
  return new Uint8Array(ab);
}

// Sérialise une entrée jour v2 pour le dossier. Enveloppe JSON fine :
// `schema` et `savedAt` restent EN CLAIR (l'hôte lit savedAt pour son
// compare-and-swap), le gros (techs + ivs, plomberie de session retirée) est
// gzippé en base64. Repli JSON brut si gzip échoue.
async function _serializeDayV2(day) {
  const savedAt = day.savedAt || Date.now();
  const body = {
    date: day.date,
    techs: day.techs || [],
    ivs: (day.ivs || []).map(iv => ivStrip(iv, true))
  };
  try {
    const gz = await _gzipBytes(new TextEncoder().encode(JSON.stringify(body)));
    return JSON.stringify({ schema: 2, savedAt, _gz: _bytesToB64(gz) });
  } catch (e) {
    LOG.warn("sync", "gzip indisponible → JSON brut", { err: e && e.message });
    return JSON.stringify({ schema: 2, savedAt, ...body });
  }
}
// Désérialise un fichier-jour v2 → {schema:2, savedAt, date, techs, ivs}.
// Tout contenu d'un autre schéma est REJETÉ (les anciens fichiers vivent à la
// racine du partage, jamais lus ici — pas de migration, on repart de zéro).
async function _deserializeDayV2(text) {
  if (typeof text !== "string" || !text) return null;
  let obj;
  try { obj = JSON.parse(text); } catch (e) { LOG.warn("sync", "contenu dossier illisible", { err: e && e.message }); return null; }
  if (!obj || obj.schema !== 2) {
    LOG.warn("sync", "fichier dossier ignoré (schéma inconnu)", { schema: obj && obj.schema });
    return null;
  }
  if (obj._gz) {
    try {
      const inner = JSON.parse(new TextDecoder("utf-8").decode(await _gunzipBytes(_b64ToBytes(obj._gz))));
      return { schema: 2, savedAt: obj.savedAt || 0, date: inner.date, techs: inner.techs || [], ivs: inner.ivs || [] };
    } catch (e) { LOG.warn("sync", "décompression dossier échouée", { err: e && e.message }); return null; }
  }
  if (!Array.isArray(obj.ivs)) return null;
  return obj;
}

// ── v2026.5.46 — OUTIL QRO : conversion de l'ANCIEN cache dossier ──────
// Lit les fichiers-jour du format v1 à la racine du partage ({savedAt, techs}
// ou {savedAt, _gz:{techs}}), les convertit au modèle v2 (ivs plat, existence
// vie/mort, verdict unique) puis les FUSIONNE au store local — la convergence
// normale les propage ensuite au sous-dossier v2. Les anciens fichiers ne sont
// JAMAIS modifiés. Accessible uniquement depuis l'onglet « Test (QRO) ».

// lecture chunkée + désérialisation V1 (l'inverse de nmReadDay qui exige v2)
async function _legacyReadDay(date, path) {
  let offset = 0;
  const chunks = [];
  for (;;) {
    const r = await nmSend({ action: "read", path, date, offset });
    if (!r || !r.ok || !r.exists) return null;
    const bytes = r.chunk ? _b64ToBytes(r.chunk) : new Uint8Array(0);
    chunks.push(bytes);
    offset = (r.offset || 0) + bytes.length;
    if (!r.more || offset >= (r.total || 0)) break;
  }
  let len = 0; for (const c of chunks) len += c.length;
  const all = new Uint8Array(len);
  let p = 0; for (const c of chunks) { all.set(c, p); p += c.length; }
  let obj;
  try { obj = JSON.parse(new TextDecoder("utf-8").decode(all)); } catch (e) { return null; }
  if (!obj || obj.schema === 2) return null;          // déjà v2 / illisible
  if (obj._gz) {
    try {
      const inner = JSON.parse(new TextDecoder("utf-8").decode(await _gunzipBytes(_b64ToBytes(obj._gz))));
      return { savedAt: obj.savedAt || 0, techs: inner.techs || [] };
    } catch (e) { return null; }
  }
  return Array.isArray(obj.techs) ? obj : null;
}

// une iv v1 → enregistrement v2 (existence + verdict mappés, champs v1 retirés)
function _legacyIvToV2(iv, tech) {
  const rec = { ...iv };
  rec.techName = (tech && tech.name) || rec.techName || "";
  if (rec.techId === undefined || rec.techId === null) rec.techId = tech && tech.id;
  // existence : appearedAt→firstSeenAt ; syncedAt/revivedAt→lastSeenAt ;
  // disappearedAt→goneAt ; deletedAt/movedAt inchangés.
  rec.firstSeenAt = iv.appearedAt || iv.syncedAt || undefined;
  rec.lastSeenAt = Math.max(iv.syncedAt || 0, iv.revivedAt || 0) || undefined;
  rec.updatedAt = iv.syncedAt || undefined;
  if (iv.disappearedAt) rec.goneAt = iv.disappearedAt;
  // verdict v1 (_disappearStatus + _diagnostic*) → verdict v2 unique
  const ds = iv._disappearStatus;
  let st = "live";
  if (ds === "terminated-clos" || ds === "closed" || ds === "terminated") st = "closed";
  else if (ds === "terminated-pending") st = "done";
  else if (ds === "terminated-suspended") st = "suspended";
  else if (ds && /^cancelled/.test(ds)) st = "gone";
  else if (ds === "error" || ds === "fiche_tronquee") st = "unknown";
  const extra = {};
  if (iv._diagnosticTechComment) extra.techComment = iv._diagnosticTechComment;
  if (iv._diagnosticActionInfo) extra.actionInfo = iv._diagnosticActionInfo;
  if (iv._diagnosticOfficiallyClosed) extra.officialClosed = true;
  rec.verdict = Object.assign({
    status: st, at: iv.syncedAt || Date.now(), source: "import-v1",
    reason: ds ? ("converti depuis l'ancien cache (" + ds + ")") : "converti depuis l'ancien cache"
  }, extra);
  // ghost jamais conclu en v1 → « disparue, à analyser » en v2
  if (iv.ghost === true && st === "live") {
    rec.missingSince = iv._diagnosticDetectedAt || iv.syncedAt || Date.now();
  }
  for (const k of ["appearedAt", "syncedAt", "revivedAt", "disappearedAt", "faitAt", "clotureAt", "ghost",
    "_disappearStatus", "_disappearChecking", "_disappearRemove", "_diagnosticTechComment",
    "_diagnosticActionInfo", "_diagnosticOfficiallyClosed", "_diagnosticVerdict",
    "_diagnosticDecisionNormal", "_diagnosticReasoning", "_diagnosticDetectedAt"]) delete rec[k];
  return rec;
}

function _legacyDayToV2(isoDate, v1) {
  const techs = (v1.techs || []).map(t => { const m = { ...t }; delete m.interventions; return m; });
  const ivs = [];
  for (const t of (v1.techs || [])) {
    for (const iv of (t.interventions || [])) ivs.push(_legacyIvToV2(iv, t));
  }
  return { schema: 2, date: isoDate, savedAt: v1.savedAt || Date.now(), techs, ivs: dayDedupeIvs(ivs) };
}

/**
 * Convertit tout l'ancien dossier (racine v1) vers le store v2 : liste les
 * jours, lit chaque fichier v1, convertit, fusionne au store local (dayMerge)
 * et sauvegarde — le push différé propage ensuite vers le sous-dossier v2.
 * @author Quentin Rouiller
 */
async function importLegacyFolderCache(rootPath, onProgress) {
  if (state.networkContext !== "internal") return { ok: false, error: "réseau externe — dossier partagé injoignable" };
  if (!(await nmProbe(true))) return { ok: false, error: "script de synchronisation non installé" };
  const path = String(rootPath || "").replace(/[\\/]+$/, "");
  if (!path) return { ok: false, error: "chemin vide" };
  const lst = await nmSend({ action: "list", path });
  if (!lst || !lst.ok || !Array.isArray(lst.days) || !lst.days.length) {
    return { ok: false, error: "aucun fichier-jour trouvé dans ce dossier" };
  }
  let done = 0, converted = 0, skipped = 0, ivTotal = 0;
  for (const d of lst.days) {
    const iso = (d && d.date) || d;
    done++;
    try {
      const v1 = iso ? await _legacyReadDay(iso, path) : null;
      if (!v1) { skipped++; }
      else {
        const v2 = _legacyDayToV2(iso, v1);
        ivTotal += v2.ivs.length;
        const local = await storeLoad(iso);
        const merged = local ? dayMerge(local, v2) : v2;
        await storeSave(iso, merged);
        if (state.currentDate === iso) { state.currentDay = merged; storeRenderCurrent("import-v1"); }
        converted++;
      }
    } catch (e) {
      skipped++;
      LOG.warn("import-v1", `jour ${iso} ignoré`, { err: e && e.message });
    }
    if (typeof onProgress === "function") { try { onProgress(done, lst.days.length, converted, skipped); } catch (e) { /* ignore */ } }
  }
  LOG.warn("import-v1", `conversion terminée : ${converted} jour(s) converti(s), ${skipped} ignoré(s), ${ivTotal} iv au total`);
  return { ok: true, converted, skipped, total: lst.days.length, ivTotal };
}

// Lecture chunkée (base64) -> entrée jour v2 {schema, savedAt, techs, ivs} ou null.
async function nmReadDay(date, path, note) {
  let offset = 0;
  const chunks = [];
  for (;;) {
    const r = await nmSend({ action: "read", path, date, offset, note: offset === 0 ? note : undefined });
    _checkNmError(r, "restauration");
    if (!r || !r.ok || !r.exists) return null;
    const bytes = r.chunk ? _b64ToBytes(r.chunk) : new Uint8Array(0);
    chunks.push(bytes);
    offset = (r.offset || 0) + bytes.length;
    if (!r.more || offset >= (r.total || 0)) break;
  }
  let len = 0; for (const c of chunks) len += c.length;
  const all = new Uint8Array(len);
  let p = 0; for (const c of chunks) { all.set(c, p); p += c.length; }
  return await _deserializeDayV2(new TextDecoder("utf-8").decode(all));
}

async function nmSaveDay(date, path, day, note, expectedSavedAt) {
  if (!day) return { ok: false };
  const json = await _serializeDayV2(day);
  const msg = { action: "save", path, date, json, savedAt: day.savedAt || Date.now(), note };
  if (expectedSavedAt !== undefined && expectedSavedAt !== null) msg.expectedSavedAt = expectedSavedAt;
  const r = await nmSend(msg);
  _checkNmError(r, "sauvegarde");
  return r || { ok: false };
}

// Ouvre le journal d'activité de l'hôte dans un nouvel onglet (texte lisible).
async function nmShowLog() {
  if (!(await nmProbe(true))) {
    if (typeof showToast === "function") showToast("Synchronisation", "Script non installé");
    return;
  }
  const r = await nmSend({ action: "log" });
  const txt = (r && r.ok && r.log) ? r.log : "(journal vide ou indisponible)";
  const header =
    "Planification — journal de synchronisation\n" +
    `Hôte v${(r && r.version) || "?"} — ${new Date().toLocaleString()}\n` +
    "=".repeat(60) + "\n\n";
  const blob = new Blob([header + txt], { type: "text/plain;charset=utf-8" });
  const url = URL.createObjectURL(blob);
  window.open(url, "_blank");
  setTimeout(() => URL.revokeObjectURL(url), 30000);
}

// Push débounce du store d'un jour vers le dossier (coalesce les storeSave
// successifs déclenchés pendant une actualisation).
function scheduleFolderPush(isoDate) {
  if (_nmAvailable === false) return;
  clearTimeout(_nmPushTimers[isoDate]);
  _nmPushTimers[isoDate] = setTimeout(() => { storeSyncFolder(isoDate); }, 4000);
}

/**
 * Converge le store local et le dossier partagé vers leur UNION (dayMerge →
 * ivMerge, modèle vie/mort), avec compare-and-swap + retry. Appelée à
 * l'arrivée sur une date ET après chaque écriture (push débounce).
 *
 * Réseau INTERNE uniquement (le partage n'est pas joignable en externe) ; en
 * externe, ou tant que le contexte réseau n'est pas connu, on ne touche PAS au
 * host → il ne se lance pas.
 *
 * v2026.5.46 — le rendu après tirage du dossier passe par storeProject
 * (mêmes filtres que tout rendu : tombstones, dock, déplacées récentes) → fini
 * le flash d'une iv parquée/déplacée qui réapparaissait via la sync.
 * @author Quentin Rouiller
 */
async function storeSyncFolder(isoDate, opts = {}) {
  try {
    if (state.networkContext !== "internal") {
      LOG.info("sync", `synchro dossier ignorée — réseau ${state.networkContext || "inconnu"} (host non sollicité)`);
      return;
    }
    if (!opts.fromPipeline && _loadPipelineDate === isoDate) {
      // pipeline de chargement actif sur cette date → on repousse (re-débounce)
      // plutôt que de fusionner sous ses pieds. (Le pipeline lui-même appelle
      // avec fromPipeline:true à un point sûr — v2026.5.46.)
      scheduleFolderPush(isoDate);
      return;
    }
    if (!(await nmProbe())) return;
    const path = await nmSharePath(); if (!path) return;
    const fr = _fmtDateFR(isoDate);
    for (let attempt = 0; attempt < 3; attempt++) {
      // jour affiché → la copie EN MÉMOIRE est la plus fraîche (mutations
      // d'enrichissement non encore persistées incluses), sinon le disque.
      // Garde-fou : currentDay doit bien être l'entrée de CETTE date (course
      // possible pendant une navigation rapide entre jours).
      const isCurrent = _jourAffiche(isoDate);
      const local = isCurrent ? state.currentDay : await storeLoad(isoDate);
      const st = await nmStatDay(isoDate, path);
      const folderExists = !!(st && st.exists);
      const folderAt = folderExists ? (st.savedAt || 0) : 0;
      const localAt = (local && local.savedAt) || 0;
      if (!local && !folderExists) return;                 // rien des deux côtés
      if (folderExists && local && localAt === folderAt) return;  // déjà identiques
      const folder = folderExists
        ? await nmReadDay(isoDate, path, `Restauration du planning du ${fr} depuis le dossier`)
        : null;
      // v2026.5.46 — référence CAS = savedAt DU FICHIER réellement lu,
      // CAPTURÉ AVANT toute fusion/mutation. dayMerge peut renvoyer folder PAR
      // RÉFÉRENCE quand le store local est vide (jour présent seulement dans le
      // dossier) : le merged.savedAt = Date.now() ci-dessous écraserait alors
      // folder.savedAt et le CAS repartirait sur une valeur fausse. On ne se
      // fie donc PAS à folderAt (issu de « stat »/_index.json, parfois périmé) ;
      // folderAt ne sert que de secours si la lecture du fichier a échoué.
      const folderFileAt = (folder && typeof folder.savedAt === "number") ? folder.savedAt : folderAt;
      const merged = dayMerge(local, folder);
      if (!merged) return;
      // contenu fusionné = NOUVEL état → nouveau savedAt. Sans ça, on
      // écrirait un contenu différent sous le même stamp : le CAS d'un
      // poste tiers passerait à tort, et les postes à localAt === folderAt
      // ne tireraient jamais cette fusion.
      merged.savedAt = Date.now();
      // v2026.5.46 — « le dossier est plus récent » se juge sur le savedAt
      // RÉEL du fichier lu (folderFileAt), pas sur folderAt (stat/index périmé) :
      // sinon un fichier plus récent d'un autre poste ne re-rendait pas.
      const pulledNewer = folderExists && folderFileAt > localAt;
      // 1. aligner le store local sur la fusion (set brut → ne re-déclenche pas le push)
      await chrome.storage.local.set({
        [STORE_PREFIX + isoDate]: { ...merged, ivs: merged.ivs.map(iv => ivStrip(iv, false)) }
      });
      // v2026.5.46 — verrou anti-rendu périmé (navigation rapide).
      // La date affichée a pu changer pendant les await natifs ci-dessus
      // (lectures du partage réseau : plusieurs secondes) : on re-évalue avant
      // de toucher l'état à l'écran, sinon le jour quitté écrase le jour
      // affiché. Un appel de pipeline (fromPipeline) ne garde la main que si
      // SON jeton est encore vivant : le 3bis d'un pipeline avorté ne doit
      // ni remplacer state.currentDay ni re-rendre. Hors pipeline, un
      // pipeline actif sur cette date garde la main sur state.currentDay.
      const pipelineVivant = typeof opts.myToken === "number" && !isRefreshAborted(opts.myToken);
      const stillCurrent = _jourAffiche(isoDate) &&
        (opts.fromPipeline ? pipelineVivant : _loadPipelineDate !== isoDate);
      if (stillCurrent) {
        state.currentDay = merged;
        if (pulledNewer) storeRenderCurrent("dossier-sync");
      }
      // 2. pousser la fusion vers le dossier (compare-and-swap sur folderFileAt,
      // la référence capturée AVANT la fusion — cf. plus haut : ce que l'hôte
      // relira dans le fichier pour comparer).
      const r = await nmSaveDay(isoDate, path, merged, `Synchronisation du planning du ${fr} (fusion)`,
        folderExists ? folderFileAt : null);
      if (r && r.ok) return;
      if (r && (r.conflict || r.locked)) {       // qqn a écrit entre-temps → on refusionne
        await new Promise(res => setTimeout(res, 800 + attempt * 500));
        continue;
      }
      return;  // autre cas (hôte absent, erreur) → best-effort, on abandonne
    }
  } catch (e) {
    LOG.warn("sync", "storeSyncFolder échoué (ignoré)", { isoDate, err: e && e.message });
  }
}

// Réconciliation à l'arrivée sur une date = convergence local ↔ dossier.
async function reconcileCacheForDate(isoDate) {
  return storeSyncFolder(isoDate);
}

// ============================================================================
// Flux principal : charger une date
// ============================================================================

/**
 * Charge le planning pour la date donnée. Pipeline v2 :
 *   1. store local → rendu immédiat (projection) ;
 *   2. fetch XML EasyVista (calendar_block) ;
 *   3. storeApplyFresh = LA fusion (vie/mort, verdicts, disparitions) ;
 *   4. rendu + sauvegarde du squelette ;
 *   5. phase A : prefetch xhr2 PARALLÈLE (contact/lieu/description de base) ;
 *   6. phase B : fiches complètes + analyse des disparues en SÉQUENTIEL ;
 *   7. sauvegarde finale + convergence dossier en arrière-plan.
 *
 * @author Quentin Rouiller
 */
async function loadForDate(isoDate, opts = {}) {
  LOG.info("load", `début pour ${isoDate}`, { opts, hasSession: !!state.session });
  const _t0 = performance.now();

  // v2026.5.18 : au changement de date, on réduit tous les popups épinglés
  // dans la taskbar du bas (l'user peut les re-agrandir au clic).
  const previousDate = state.currentDate;
  if (previousDate && previousDate !== isoDate) {
    _reduceAllPinnedPopups();
  }

  state.currentDate = isoDate;
  state.currentDay = null;   // pas de store périmé d'un autre jour pendant le chargement
  document.getElementById("date-picker").value = isoDate;
  updateDatePickerDayLabel(isoDate);  // v2026.5.16 : label "Mardi" à côté

  // v2026.5.46 — le jeton d'annulation se prend DÈS L'ENTRÉE, avant le
  // moindre await. Pris après la lecture du store (comme avant), deux
  // navigations rapprochées pouvaient s'inverser : si la lecture du jour
  // cliqué EN PREMIER répondait après celle du second, le premier prenait un
  // jeton plus récent et invalidait le jour réellement affiché
  // (state.currentDay corrompu, enrichissement du jour à l'écran stoppé).
  // L'ordre des jetons suit désormais l'ordre des clics.
  const myToken = startNewRefresh();

  // Ordre de chargement (perf) : on ne bloque le rendu sur la
  // réconciliation dossier QUE si c'est indispensable :
  //   - jour passé SANS store local → besoin du dossier pour afficher qqch ;
  //   - session absente → pas de fetch EV pour rafraîchir, autant réconcilier.
  // Sinon → rendu immédiat depuis le store, convergence dossier en arrière-plan.
  let day = await storeLoad(isoDate);
  if (isRefreshAborted(myToken)) return;   // v2026.5.46 — navigation entre-temps
  state.currentDay = day;
  const _staleSavedAt = day ? (day.savedAt || 0) : 0;   // âge du store AVANT ce chargement
  // v2026.5.46 — la convergence dossier vit DANS le pipeline (étape 3bis, juste
  // après le fetch EV) ; on ne la fait EN AMONT que dans les deux cas où le
  // dossier est la seule chose à montrer d'emblée :
  //   - session absente → pas de fetch EV possible ;
  //   - v2026.5.47 — store local VIDE mais jour présent dans le dossier :
  //     sans ça, le pipeline rendait le SQUELETTE EV puis « rafraîchissait » en
  //     3bis (lecture du partage ~plusieurs secondes) → l'utilisateur voyait un
  //     re-remplissage inutile alors que le dossier avait déjà tout. On lit donc
  //     le dossier d'abord et on affiche directement les cartes complètes.
  //     (Le commentaire d'ordre de chargement plus haut prévoyait déjà ce cas
  //     « jour sans store local → besoin du dossier », jamais implémenté.)
  const _reconcileUpFront = !state.session || !day;
  if (_reconcileUpFront) {
    await reconcileCacheForDate(isoDate);
    if (isRefreshAborted(myToken)) return;   // v2026.5.46 — navigation entre-temps
    day = await storeLoad(isoDate);
    if (isRefreshAborted(myToken)) return;   // v2026.5.46 — navigation entre-temps
    state.currentDay = day;
  }

  if (!state.session) {
    // v2026.5.46 — rien ne se charge dans cet état : ne pas laisser un
    // bouton « Arrêter » fantôme d'un pipeline mort (session tombée en vol,
    // pipeline supplanté → son finally ne masque plus le bouton lui-même).
    showAbortButton(false);
    // afficher le store + bannière, plutôt que l'écran "session"
    if (day) {
      renderFromData({
        techs: storeProject(day, isoDate),
        targetDate: isoDate,
        captureTime: day.savedAt || null,
        source: "store"
      });
      showSessionExpiredBanner();
    } else {
      showSessionNeeded();
    }
    return;
  }

  // (v3.1.1) Le bouton "Arrêter" apparaît pour TOUT refresh ; il disparaît
  // quand le chargement est vraiment fini (finally). Le jeton d'annulation,
  // lui, est pris dès l'entrée de la fonction (ordre des clics).
  _loadPipelineDate = isoDate;   // suspend la convergence dossier le temps du pipeline
  _loadPipelineToken = myToken;  // ce pipeline devient propriétaire du report
  showAbortButton(true);
  const t0 = performance.now();
  LOG.info("load", `début pour ${isoDate} (token=${myToken})`);

  try {
    // 1. Bouton qui tourne + rendu immédiat depuis le store si disponible
    if (!opts._fromPartialBtn) {
      if (opts.doStatusRefresh) {
        setActiveRefreshButton("total");
      } else {
        setActiveRefreshButton(day ? "partial" : "total");
      }
    }
    if (day && !opts.forceRefetch) {
      renderFromData({
        techs: storeProject(day, isoDate),
        targetDate: isoDate,
        captureTime: day.savedAt || null,
        source: "store"
      });
      // on NE retourne PAS : le fetch XML détecte nouveautés et disparitions.
    } else {
      showLoading();
    }

    if (isRefreshAborted(myToken)) return;

    // 2. Fetch frais du planning (XML calendar_block — rapide, ~40 ko)
    const tXml = performance.now();
    const fresh = await fetchPlanningForDate(isoDate);
    LOG.info("load", `XML planning récupéré en ${Math.round(performance.now() - tXml)} ms`);
    if (!fresh) return;
    if (isRefreshAborted(myToken)) return;

    // 3. Ingestion dans le store : LA fusion (présence = vie, absence =
    //    disparue à analyser, résa/absence disparue = retirée propagée).
    const applied = storeApplyFresh(day, fresh.techs, isoDate);
    day = applied.day;
    state.currentDay = day;

    // 4. Rendu immédiat (le XML donne déjà tout le visuel de base : ref,
    //    contact, lieu, catégorie) + sauvegarde du squelette.
    renderFromData({
      techs: storeProject(day, isoDate),
      targetDate: isoDate,
      captureTime: Date.now(),
      source: "fresh",
      lastRefreshKind: activeRefreshButton  // v4.1.20
    });
    LOG.info("load", `1er rendu complet à ${Math.round(performance.now() - t0)} ms`);
    await storeSave(isoDate, day);

    // 3bis. v2026.5.46 — CONVERGENCE DOSSIER AVANT tout enrichissement :
    // les statuts ✓/✓✓, descriptions, popups et verdicts déjà connus des
    // autres postes habillent les cartes SANS re-fetch EV. La phase A/B ne
    // traitera plus que ce qui MANQUE encore après cette fusion.
    if (!isRefreshAborted(myToken)) {
      const tSync = performance.now();
      try { await storeSyncFolder(isoDate, { fromPipeline: true, myToken }); } catch (e) { /* best-effort */ }
      // v2026.5.46 — re-test après l'attente du host natif.
      // La sync dossier vient d'attendre le partage réseau (secondes) : un
      // autre jour a pu être chargé entre-temps ; sans ce re-test, le rendu
      // ci-dessous réaffichait le jour quitté par-dessus celui à l'écran.
      if (isRefreshAborted(myToken)) return;
      if (state.currentDay && state.currentDay.date === isoDate) day = state.currentDay;
      renderFromData({
        techs: storeProject(day, isoDate),
        targetDate: isoDate,
        captureTime: Date.now(),
        source: "fresh+dossier",
        lastRefreshKind: activeRefreshButton
      });
      LOG.info("load", `convergence dossier en ${Math.round(performance.now() - tSync)} ms`);
    }

    // file d'analyse calculée APRÈS la fusion dossier : les verdicts déjà
    // connus d'un autre poste évitent autant d'analyses. « Tout recharger »
    // ré-analyse aussi les fait/clos.
    const toAnalyze = [];
    for (const rec of day.ivs) {
      if (ivIsDead(rec) || !rec.missingSince) continue;
      if (rec.type !== "AL-Intervention") continue;
      const vs = ivVStatus(rec);
      if (vs === "gone" || vs === "moved") continue;
      if (!opts.doStatusRefresh && (vs === "closed" || vs === "done")) continue;
      toAnalyze.push(rec);
    }

    const notFetched = day.ivs.filter(r => !ivIsDead(r) && r.type === "AL-Intervention" && !r.ficheFetched).length;
    LOG.info("load", `store : ${day.techs.length} techs, ${day.ivs.length} iv, ${notFetched} sans fiche, ${toAnalyze.length} disparue(s) à analyser`);

    // v2026.5.34 : si le user n'est pas encore connu (badge "?"), on tente
    // un fetch immédiatement puisque le planning a réussi = session valide.
    _maybeRetryFetchUser("after_load_success");

    // Phase A : prefetch xhr2 EN PARALLÈLE (concurrency=6, rapide) → toutes
    // les cartes ont leurs infos courtes contact/lieu en bloc dès le 1er
    // chargement. (La projection exclut d'office tombstones et disparues.)
    if (!isRefreshAborted(myToken)) {
      await prefetchAllXhr2(storeProject(day, isoDate), myToken, opts.doStatusRefresh);
    }

    // Phase B : fiches complètes + analyse des disparues en séquentiel strict
    // (1 à la fois, ordre d'affichage), sauvegarde périodique.
    if (!isRefreshAborted(myToken)) {
      const cacheAgeMs = _staleSavedAt ? (Date.now() - _staleSavedAt) : Infinity;
      const cacheTooOld = cacheAgeMs > 24 * 3600 * 1000;
      const useFreshChecksum = !!(opts.forceRefetch || opts.doStatusRefresh || opts._fromPartialBtn || cacheTooOld);
      const tSeq = performance.now();
      LOG.info("load", `phase B séquentielle (forceAll=${!!opts.doStatusRefresh}, freshChecksum=${useFreshChecksum})`);
      await processInterventionsSequentially(day, isoDate, {
        forceAll: !!opts.doStatusRefresh,
        myToken,
        useFreshChecksum,
        toAnalyze
      });
      LOG.info("load", `phase B finie en ${Math.round(performance.now() - tSeq)} ms`);
    }

    // 5. Sauvegarde finale (tout est enrichi) + convergence dossier différée
    //    (non bloquante — re-render via la projection si le dossier est plus
    //    frais, cf. storeSyncFolder).
    if (!isRefreshAborted(myToken)) {
      // sauvegarde finale ; le push débounce (storeSave → scheduleFolderPush)
      // propage l'enrichissement au dossier → le prochain poste n'aura rien
      // à re-fetcher. (La convergence d'entrée a eu lieu à l'étape 3bis.)
      await storeSave(isoDate, day);
    }

    if (!isRefreshAborted(myToken)) {
      showRefreshDone();
      LOG.info("load", `TOTAL: ${Math.round(performance.now() - t0)} ms`);
    } else {
      // toast "annulé" uniquement si c'était un vrai clic "Arrêter".
      const wasExplicitAbort = (abortedToken === myToken);
      LOG.info("load", `annulé à ${Math.round(performance.now() - t0)} ms (explicite=${wasExplicitAbort})`);
      if (wasExplicitAbort) showAbortToast();
    }
  } finally {
    // v2026.5.46 — seul le pipeline PROPRIÉTAIRE nettoie le report de
    // convergence ET masque le bouton « Arrêter » : un pipeline avorté de la
    // même date ne doit pas retirer le verrou posé par son successeur, et le
    // bouton appartient au pipeline (un successeur l'a soit repris à son
    // compte, soit masqué lui-même sur son chemin sans session).
    if (_loadPipelineToken === myToken) {
      _loadPipelineDate = null;
      _loadPipelineToken = null;
      showAbortButton(false);
    }
    cleanupAbortResolver(myToken);
  }
}

async function refreshPlanning(opts = {}) {
  if (!state.session) {
    await refreshSessionAndLoad();
    return;
  }
  if (opts.partial) {
    // v4.1.13 : _fromPartialBtn empêche loadForDate de reset activeRefreshButton à "total"
    await loadForDate(state.currentDate, { doStatusRefresh: false, _fromPartialBtn: true });
  } else {
    await loadForDate(state.currentDate, { doStatusRefresh: true });
  }
}

// ============================================================================
// Fetch du planning (via background)
// ============================================================================

async function fetchPlanningForDate(isoDate) {
  setRefreshing(true);
  try {
    const unixDate = isoToUnixDate(isoDate);
    const resp = await sendMessage({
      type: "fetchPlanning",
      session: state.session,
      unixDate: unixDate
    });
    if (!resp.ok) {
      // v4.2.5 : si le planning du jour est DÉJÀ rendu (cache), on affiche
      // une bannière non bloquante en haut, le cache reste visible.
      // Si rien n'est rendu (1er chargement, pas de cache), on affiche
      // l'écran plein comme avant.
      const hasCacheRendered =
        document.getElementById("cards") &&
        document.getElementById("cards").children.length > 0;
      if (resp.error === "no_session" || resp.error === "session_expired") {
        state.session = null;
        if (hasCacheRendered) {
          showSessionExpiredBanner();
        } else {
          showSessionNeeded();
        }
      } else if (resp.error === "ev_unreachable") {
        if (hasCacheRendered) {
          showEvUnreachableBanner();
        } else {
          showEvUnreachable();
        }
      } else if (resp.error === "no_team_configured") {
        // v2026.5.46 — récup. fix « 4a » (cycle v46 avorté) : si on n'a pas
        // encore d'utilisateur identifié (fetchCurrentUser pas encore revenu OU
        // session SSO périmée), on attend un instant pour savoir. Sans user après
        // l'attente → la session EV n'est PAS valide, on propose la connexion
        // plutôt que la config d'équipe (que l'user ne pourra pas remplir sans
        // session, vu que la liste des techs vient d'EV).
        if (!state.currentUser) {
          await new Promise(r => setTimeout(r, 1500));
        }
        if (!state.currentUser) {
          // NE PAS toucher à state.session ici : la session technique
          // (PHPSESSID) peut être valide côté cookie, c'est juste
          // l'authentification SSO derrière qui n'a pas abouti. Forcer
          // state.session = null déclencherait la boucle infinie de
          // _checkForRestoredSession.
          if (hasCacheRendered) {
            showSessionExpiredBanner();
          } else {
            showSessionNeeded();
          }
        } else {
          // libellé bouton simplifié à "Ouvrir paramètres".
          showError(
            "Choisissez votre groupe EasyVista et cochez les techniciens que " +
            "vous voulez voir apparaître dans le planning. La configuration est " +
            "enregistrée localement et restera persistante entre les sessions.",
            {
              centered: true,
              icon: "👥",
              title: "Aucune équipe configurée",
              actionLabel: "Ouvrir paramètres",
              actionHandler: () => {
                if (typeof showAdminPanel === "function") showAdminPanel("team");
              }
            }
          );
        }
      } else {
        showError("Erreur de fetch : " + (resp.error || "inconnue"));
      }
      return null;
    }

    // Safeguard (v3.1) : le serveur EasyVista répond parfois 200 avec un
    // corps vide — typiquement quand la sesson vient d'être invalidée, ou
    // quand il soupçonne du scraping (trop de requêtes parallèles). Dans
    // les deux cas, on traite ça comme une sesson expirée : inutile de
    // parser (ça ferait "Document is empty") ni de retry en boucle.
    if (!resp.xml || resp.xml.length < 20) {
      LOG.warn("viewer", "XML planning vide — session probablement invalide");
      state.session = null;
      const hasCacheRendered =
        document.getElementById("cards") &&
        document.getElementById("cards").children.length > 0;
      if (hasCacheRendered) {
        showSessionExpiredBanner();
      } else {
        showSessionNeeded();
      }
      return null;
    }

    // Parser le HTML complet du planning (contient TOUT : ref, catégorie,
    // contact, lieu, description, formLinks, request_id + checksum)
    const techs = parsePlanningXml(resp.xml, isoDate);

    return { techs };
  } catch (err) {
    showError("Erreur inattendue : " + (err.message || err));
    return null;
  } finally {
    setRefreshing(false);
  }
}

// ============================================================================
// Parsing du XML du planning
// ============================================================================

/**
 * Parse le XML retourné par planning_xhr.php?div=calendar_block.
 * Contient les interventions (actions) par technicien, avec :
 *   - action_id, done_by_id, action_label (parfois juste "AL-Intervention"),
 *   - start_time / end_time, start_date / end_date,
 *   - formLink (eventName=formEvent&target=ACTIONID&checksum=...) pour ouvrir l'action,
 *   - request_id (ID de la fiche SD_REQUEST, utilisé pour ouvrir la fiche).
 */
function parsePlanningXml(xml, isoDate) {
  const doc = new DOMParser().parseFromString(xml, "text/xml");

  const parserError = doc.querySelector("parsererror");
  if (parserError) {
    LOG.warn("parse", "Parser error:", parserError.textContent);
  }

  const actionNodes = doc.querySelectorAll("action");
  const byTechId = new Map();
  for (const id of Object.keys(TEAM)) {
    byTechId.set(id, { id, name: TEAM[id], interventions: [] });
  }

  // v2026.5.46 — logs verbeux du parse : on trace CHAQUE <action> et la
  // raison d'un éventuel rejet (null / tech hors équipe / mauvaise date), avec
  // la présence du formLink. Indispensable pour repérer une iv « disparue ».
  LOG.info("parse", `parse XML : ${actionNodes.length} nœud(s) <action> trouvé(s) pour ${isoDate}`);
  let _kept = 0, _skipNull = 0, _skipTech = 0, _skipDate = 0;
  for (const node of actionNodes) {
    const iv = actionNodeToIntervention(node);
    if (!iv) {
      _skipNull++;
      LOG.info("parse", "↳ action IGNORÉE : non convertible (actionNodeToIntervention=null)",
        { action_id: node.getAttribute("action_id"), event_id: node.getAttribute("event_id") });
      continue;
    }
    if (!byTechId.has(iv.techId)) {
      _skipTech++;
      LOG.info("parse", `↳ iv IGNORÉE : tech ${iv.techId} hors équipe`,
        { ref: iv.ref, actionId: iv.actionId, techId: iv.techId, type: iv.type });
      continue;
    }
    if (!actionCoversDate(iv, isoDate)) {
      _skipDate++;
      LOG.info("parse", `↳ iv IGNORÉE : ne couvre pas ${isoDate}`,
        { ref: iv.ref, actionId: iv.actionId, startDate: iv.startDate, endDate: iv.endDate, startTime: iv.startTime });
      continue;
    }
    _kept++;
    LOG.info("parse", `↳ iv gardée → ${iv.ref || iv.type}`,
      { ref: iv.ref, actionId: iv.actionId, requestId: iv.requestId, type: iv.type, techId: iv.techId,
        formLink: iv.formLink ? "présent" : "ABSENT", startTime: iv.startTime, endTime: iv.endTime, status: iv.status });
    byTechId.get(iv.techId).interventions.push(iv);
  }
  LOG.info("parse",
    `parse XML terminé : ${_kept} gardée(s) ; ignorées : ${_skipNull} null + ${_skipTech} hors-équipe + ${_skipDate} hors-date (sur ${actionNodes.length})`,
    { total: actionNodes.length, kept: _kept, skipNull: _skipNull, skipTech: _skipTech, skipDate: _skipDate });

  for (const tech of byTechId.values()) {
    tech.interventions.sort((a, b) =>
      (a.startTime || "").localeCompare(b.startTime || "")
    );
  }

  return [...byTechId.values()];
}

function actionNodeToIntervention(node) {
  const get = name => node.getAttribute(name) || "";

  const actionId = get("action_id");
  if (!actionId) return null;

  const actionType = get("action_type");
  const techId = get("done_by_id");
  const label = get("action_label");
  const cssClass = get("Css_Class");
  const startDate = get("start_date");
  const endDate = get("end_date");
  const startTime = get("start_time");
  const endTime = get("end_time");
  const currentDate = get("current_date");
  const formLink = get("formLink");
  const deadline = get("max_resolution_date") || get("max_intervention_date");
  const requestId = get("request_id");

  // ─── v4 : infos enrichies disponibles directement dans le XML ──────────────
  // EasyVista envoie déjà contact/lieu/catégorie dans attr1/attr2/attr3.
  // La ref est dans le textContent du nœud (format "SYYMMDD_NNNNN (CM)" ou
  // "IYYMMDD_NNNNN (SD)"). Plus besoin de fetcher xhr2 ni la fiche pour ça.
  const attr1 = get("attr1");  // contact
  const attr2 = get("attr2");  // lieu
  const attr3 = get("attr3");  // catégorie complète
  const nodeText = (node.textContent || "").trim();

  // Extraire la ref en priorité du textContent (où elle est complète), sinon
  // fallback sur le label. v4.1.9 : pattern générique [SI]\d+_\d+ (plus
  // hardcodé sur "2..." qui était pour 2020-2029).
  let ref = null;
  const refFromText = nodeText.match(/\b([SI]\d{5,8}_\d{4,6})\b/);
  if (refFromText) {
    ref = refFromText[1];
  } else {
    const refFromLabel = label.match(/\b([SI]\d{5,8}_\d{4,6})\b/);
    if (refFromLabel) ref = refFromLabel[1];
  }

  // Détection du type "Réservation" vs "Absence".
  //
  // v5.0.3 (simplifiée) : le label suit le pattern "Nom / Créé par : X Y".
  //
  //   - Congés / Maladie / Pompier         → AL-Absence (tech réellement absent)
  //   - TOUT LE RESTE (Ecrans, PC, MAC, Rollout, Téléphones, UTP, Réunion,
  //     Déménagement, Evènements spéciaux, Formation, ...)
  //                                         → AL-Reservation (créneau bloqué, tech pas absent)
  //
  // Cette règle simple évite les cas "absence toute la journée" déclenchés
  // par erreur pour des réservations de type événement / réunion.
  const ABSENCE_LABELS = /^(cong[ée]s|maladie|pompier)$/i;
  let effectiveType = actionType;
  let reservationLabel = null;
  let reservationCreator = null;
  const reservationMatch = label.match(/^([^/]+?)\s*\/\s*Créé par\s*:\s*(.+)$/i);
  // v2026.5.46 — une VRAIE intervention porte une réf S…/I… : on ne la
  // reclasse JAMAIS en résa/absence, même si son libellé matche
  // "X / Créé par : Y". BUG corrigé : une intervention dont le libellé matchait
  // était classée AL-Reservation → SAUTÉE en phase B (type ≠ AL-Intervention)
  // → fiche jamais récupérée → carte bloquée sur « Chargement des détails… ».
  // Les résa/absences, elles, n'ont pas de réf (leur n° est dans la meta).
  if (reservationMatch && !ref) {
    const label1 = reservationMatch[1].trim();
    const creator = reservationMatch[2].trim();
    if (ABSENCE_LABELS.test(label1)) {
      // Vraie absence du tech
      effectiveType = "AL-Absence";
    } else {
      // Réservation : créneau bloqué (matériel ou activité), tech pas absent
      effectiveType = "AL-Reservation";
      reservationLabel = label1;
      reservationCreator = creator;
    }
    LOG.info("parse", `reclassé via libellé → ${effectiveType}`, { label1, actionType, ref: ref || null });
  } else if (reservationMatch && ref) {
    LOG.info("parse", `libellé « Créé par » mais réf ${ref} présente → reste ${effectiveType || "AL-Intervention"}`, { actionType });
  }

  // v2026.5.46 — toute iv portant une VRAIE réf (S…/I…) et qui n'est pas une
  // absence/réservation est une INTERVENTION pour nous (à afficher + fetcher la
  // fiche), QUEL QUE SOIT le type brut EV. EasyVista a des types non standard
  // (ex. « AL-Communication incident majeur ») qui restaient hors de
  // "AL-Intervention" → phase B les sautait → carte bloquée « Chargement… ».
  if (ref && effectiveType !== "AL-Absence" && effectiveType !== "AL-Reservation" && effectiveType !== "AL-Intervention") {
    LOG.info("parse", `type EV non standard « ${effectiveType} » + réf ${ref} → normalisé en AL-Intervention`, { actionType });
    effectiveType = "AL-Intervention";
  }

  // ─── v4 : pré-remplissage immédiat depuis les attributs XML ─────────────────
  // On renseigne bulleContact/bulleLieu/categoryLine DÈS la création de l'objet.
  // Plus besoin d'attendre xhr2 ou la fiche pour avoir l'affichage de base.
  // Seuls restent à fetcher (en arrière-plan, sur fiche) : status.
  // Et sur hover (lazy, seulement si l'user survole) : bulleDescription complet.
  const isIntervention = effectiveType === "AL-Intervention";
  const bulleContact = isIntervention && attr1 ? attr1 : null;
  const bulleLieu    = isIntervention && attr2 ? attr2 : null;
  const categoryLine = isIntervention && attr3 ? attr3 : null;

  // v2026.5.46 — réservation : réappliquer la meta persistante (n° DS,
  // ville, rue, catégorie saisis dans la modal) à chaque parse, repérée par
  // tech + date + heure de début. Survit aux refresh EV et au recyclage d'actionId.
  let resNumero = "", resVille = "", resRue = "", resCategorie = "";
  if (effectiveType === "AL-Reservation") {
    const meta = _resMetaGet(String(techId), startDate, startTime);
    if (meta) {
      resNumero = meta.numero || ""; resVille = meta.ville || "";
      resRue = meta.rue || ""; resCategorie = meta.categorie || "";
    }
  }

  return {
    actionId: actionId,
    requestId: requestId,
    techId: techId,
    label: label,
    type: effectiveType,              // "AL-Intervention" | "AL-Absence" | "AL-Reservation"
    originalType: actionType,         // type brut (pour debug)
    reservationLabel: reservationLabel,    // "Ecrans", "Rollout", etc.
    reservationCreator: reservationCreator, // "Nom, Prénom" du coordinateur
    // v2026.5.46 — meta réservation (depuis le store persistant)
    resNumero: resNumero, resVille: resVille, resRue: resRue, resCategorie: resCategorie,
    cssClass: cssClass,
    isPompier: /pompier/i.test(label) || /pompier/i.test(actionType),
    // v2026.5.27 : catégorie d'absence pour classification visuelle
    //   "maladie" | "conge" | "pompier" | null
    absenceCategory: (function() {
      if (effectiveType !== "AL-Absence") return null;
      const lblTest = reservationMatch ? reservationMatch[1].trim() : label;
      if (/pompier/i.test(lblTest) || /pompier/i.test(actionType)) return "pompier";
      if (/maladie/i.test(lblTest)) return "maladie";
      if (/cong[ée]s?/i.test(lblTest)) return "conge";
      return null;
    })(),
    ref: ref,
    startDate: startDate,
    endDate: endDate,
    startTime: startTime,
    endTime: endTime,
    currentDate: currentDate,
    formLink: formLink,
    deadline: deadline,
    // v4 : renseignés directement depuis le XML (plus d'attente de xhr2)
    bulleContact: bulleContact,
    bulleLieu: bulleLieu,
    categoryLine: categoryLine,
    bulleDescription: null,   // reste null, rempli lazy au premier hover (xhr2)
    infobulle: null,          // reste null, rempli lazy aussi
    status: null,             // toujours rempli par fetch fiche (en arrière-plan)
    // v4 : ficheTarget/Checksum déjà présents dans formLink (extraits à la demande)
    ficheTarget: null,
    ficheChecksum: null,
    ficheFetched: false,
    ficheFetchError: null,
    xhr2Fetched: false,       // lazy : passe à true après le 1er hover
    xhr2Fetching: false       // évite les doubles fetchs simultanés
  };
}

/**
 * Parse le body de planning_xhr_2.php?id=ACTIONID (ou similaire).
 * Format observé :
 *   @@DESCRIPTION_S@@...texte complet de l'action...@@DESCRIPTION_E@@
 *   @@LABEL_S@@AL-Intervention@@LABEL_E@@
 *   @@LAST_S@@Nom, Prénom@@LAST_E@@
 *   @@PLANNED_TIME_S@@@@PLANNED_TIME_E@@
 *   @@PLANNED_CHANGE_S@@@@PLANNED_CHANGE_E@@
 */
function parseXhr2Body(body) {
  if (!body || typeof body !== "string") return null;
  const out = { description: null, label: null, last: null };
  const rxD = /@@DESCRIPTION_S@@([\s\S]*?)@@DESCRIPTION_E@@/;
  const rxL = /@@LABEL_S@@([\s\S]*?)@@LABEL_E@@/;
  const rxLa = /@@LAST_S@@([\s\S]*?)@@LAST_E@@/;
  const md = body.match(rxD);
  const ml = body.match(rxL);
  const mla = body.match(rxLa);
  if (md) out.description = md[1].trim();
  if (ml) out.label = ml[1].trim();
  if (mla) out.last = mla[1].trim();
  return out;
}

// v4 : fetchBullesForInterventions (fetch xhr2 en masse au chargement) a été
// supprimée. Le contact/lieu/catégorie viennent maintenant directement des
// attributs attr1/attr2/attr3 du calendar_block. Pour le TEXTE complet de
// l'action (Problème/À faire/Matériel/TFS/...), voir ensureBulleDescription()
// qui lazy-load UNIQUEMENT au premier hover de l'intervention.

function actionCoversDate(iv, isoDate) {
  if (!iv.startDate || !iv.endDate) return true;  // manque info → on garde
  const target = isoToDDMMYYYY(isoDate);
  return ddmmyyyyLE(iv.startDate, target) && ddmmyyyyLE(target, iv.endDate);
}

function ddmmyyyyLE(a, b) {
  // Compare deux dates JJ/MM/AAAA
  const toNum = s => {
    const m = s.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
    return m ? parseInt(m[3] + m[2] + m[1], 10) : 0;
  };
  return toNum(a) <= toNum(b);
}

// ============================================================================
// Fusion EV ↔ store
// ============================================================================
// v2026.5.46 — la fusion du planning EV frais avec le jour connu est
// désormais faite par storeApplyFresh (couche données v2, plus haut) : UNE
// seule fusion pour tout le système (présence = vie, absence = disparition à
// analyser, résa/absences disparues = retirées propagées, filets contre le
// recyclage d'actionId par réf + signature composite).

// ============================================================================
// v4.2.5 : analyse des tickets disparus du planning
// ============================================================================
//
// Pour chaque ticket qui était dans le cache mais n'est plus dans le XML
// fresh, on doit décider s'il faut :
//   1. Le GARDER en vert double ✓✓ → clôturé / résolu dans EasyVista
//   2. Le GARDER en vert simple ✓  → terminé par le tech (commentaire LOGIN:)
//   3. Le RETIRER → déplacé sur un autre jour / annulé / autre
//
// Logique (validée avec l'utilisateur) :
//   a) Re-fetch la fiche
//   b) Si statut global = CLOS ou RÉSOLU → garder, vert ✓✓
//   c) Sinon parcourir les actions OUVERTES de la fiche :
//      - Si action ouverte au nom du tech sur JOUR DIFFÉRENT → retirer (déplacée)
//      - Sinon passer à l'étape d
//   d) Parcourir les actions FERMÉES au nom du tech :
//      - Si une action fermée contient un commentaire tech (pattern `LOGIN:
//        commentaire` où LOGIN = alphanumérique 3-12 chars minuscule) → garder, vert ✓
//      - Sinon → retirer
//
// Distinction action ouverte/fermée :
//   Observation sur les HTML fournis : dans le JSON timeline de la fiche,
//   l'action "AL-Intervention" apparaît SEULEMENT si elle a été complétée
//   (fermée). Si elle est toujours ouverte, elle n'est pas dans le timeline.
//   Les autres types d'actions ("Ajout d'informations", "Envoi de mail", etc.)
//   apparaissent dès leur création.

// Regex pour détecter un commentaire tech dans le texte d'une action.
// Pattern : début de ligne OU <br> suivi d'un login court (3-12 caractères
// alphanumériques MINUSCULES) + ":" + espace + texte.
// Exemples qui matchent : "vyjuva: Casque remplacé", "awr: ok".
// Exemples qui NE matchent PAS :
//   - "Service : X" (majuscule + pas un login)
//   - "Nom2, Prénom2" (contient une virgule, pas un login)
//   - "AWR 16/04/26" (pas de deux-points)
//   - "Date : vendredi 17.04" (majuscule au début, c'est un champ)
const RX_LOGIN_COMMENTAIRE = /(?:^|\n|<br\s*\/?>)\s*([a-z0-9_]{3,12})\s*:\s+(\S[^\n<]{2,})/im;

/**
 * Extrait toutes les actions d'une fiche en parsant les blocs "rows" du HTML.
 * Une action a 14 values. Indices stables :
 *   [2]  = Intervenant (ex: "Nom, Prénom" ou "EZV_WS_REST_USER")
 *   [4]  = Type d'action (ex: "AL-Intervention", "Ajout d'informations")
 *   [13] = JSON stringifié contenant ACTION_ID, AM_DONE_BY_ID, …
 *
 * v2026.5.45 — la position des dates et de la description varie selon le
 * layout EV (anciennement [8]/[9]/[11], aujourd'hui [6]/[7]/[9] sur les
 * fiches AL-Intervention récentes). On les détecte par scan plutôt que par
 * indices fixes :
 *   - dates création/fin = les 2 DERNIÈRES valeurs matchant
 *     "DD/MM/YYYY HH:MM:SS" (ignore la colonne d'affichage en [1] qui
 *     réplique parfois la création).
 *   - description = 2 colonnes après la date de fin (cellule intercalée
 *     vide).
 *
 * Retourne : [ { intervenant, type, dateCreation, dateFin, description, ... }, ... ]
 */
function parseAllActionsFromFicheHtml(html) {
  if (!html) return [];
  // Décoder : dans le HTML, les JSON imbriqués ont \u0022 pour " et \/ pour /
  const decoded = html
    .replace(/\\\//g, '/');
  // on NE pré-décode PAS " ici — les " littéraux à l'intérieur
  // d'une valeur sont encodés " (Unicode escape) dans le JSON et le
  // parser doit les voir comme du texte (6 chars), pas comme des " réels.
  // Les délimiteurs JSON (autour de "value", "rows", etc.) sont déjà des "
  // bare et restent intacts. Le décodage \uXXXX se fait par
  // decodeUnicodeEscapes() en aval, sur chaque valeur déjà extraite.

  const actions = [];
  const rowsRegex = /"rows":\[/g;
  let m;
  while ((m = rowsRegex.exec(decoded)) !== null) {
    const start = m.index + m[0].length;
    // Trouver la fin du array [...] correspondant (balance des crochets)
    let j = start;
    let depth = 1;
    while (j < decoded.length && depth > 0) {
      const c = decoded[j];
      if (c === '[') depth++;
      else if (c === ']') depth--;
      j++;
    }
    const block = decoded.substring(start, j - 1);
    const values = extractValuesFromRowBlock(block);
    if (values.length < 12) continue;
    // Une "vraie" action a 14 valeurs. On se contente de 12 minimum
    // pour avoir au moins la description.
    //
    // v2026.5.44 on extrait aussi actionId / amDoneById depuis values[13]
    // qui est un JSON stringifié contenant {NAME, ACTION_ID, AM_DONE_BY_ID, …}.
    // Permet de filtrer la "bonne action" par ACTION_ID au lieu de matcher
    // par nom de tech (le matching par nom échouait par exemple sur les
    // actions où l'intervenant est noté "EZV_WS_REST_USER" ou un format
    // qui ne correspond pas exactement au tech.name de la config).
    let actionId = null;
    let amDoneById = null;
    if (values.length >= 14 && values[13]) {
      // v2026.5.46 — BUG : dans le HTML, les guillemets du JSON imbriqué sont
      // encodés " (pas des " littéraux). Le regex cherchait des " littéraux
      // → ACTION_ID et surtout AM_DONE_BY_ID étaient TOUJOURS null → le matching
      // d'action par id (le plus fiable, indépendant du nom) ne marchait JAMAIS.
      // On DÉCODE values[13] d'abord pour que le regex matche.
      const raw13 = decodeUnicodeEscapes(values[13]);
      // Parsing tolérant via regex (on accepte avec ou sans guillemets autour
      // des valeurs numériques) — robuste aux formats JSON avec ou sans
      // échappements résiduels.
      const mAid = raw13.match(/"ACTION_ID"\s*:\s*"?(\d+)"?/);
      const mDid = raw13.match(/"AM_DONE_BY_ID"\s*:\s*"?(\d*)"?/);
      if (mAid) actionId = mAid[1];
      if (mDid && mDid[1]) amDoneById = mDid[1];
    }
    // v2026.5.45 — détection robuste des dates et de la description.
    // On scanne values pour trouver les valeurs qui matchent
    // "DD/MM/YYYY HH:MM:SS" et on garde les 2 DERNIÈRES = (création, fin).
    // La description est 2 colonnes après la fin (cellule intermédiaire
    // toujours vide). Survit aux variations de layout EV (avant: [8]/[9]/[11],
    // aujourd'hui: [6]/[7]/[9] pour les fiches AL-Intervention).
    const RX_ACTION_DATE = /^\d{1,2}\/\d{1,2}\/\d{4}\s+\d{1,2}:\d{2}:\d{2}$/;
    const dateIdxs = [];
    for (let k = 0; k < values.length; k++) {
      if (RX_ACTION_DATE.test(values[k] || "")) dateIdxs.push(k);
    }
    let dateCreation = "", dateFin = "", descIdx = -1;
    if (dateIdxs.length >= 2) {
      const iCreate = dateIdxs[dateIdxs.length - 2];
      const iFin    = dateIdxs[dateIdxs.length - 1];
      dateCreation = values[iCreate] || "";
      dateFin      = values[iFin] || "";
      descIdx      = iFin + 2;
    } else if (dateIdxs.length === 1) {
      dateCreation = values[dateIdxs[0]] || "";
      dateFin      = dateCreation;
      descIdx      = dateIdxs[0] + 2;
    }
    const description = (descIdx >= 0 && descIdx < values.length)
      ? (values[descIdx] || "") : "";

    actions.push({
      actionId,                                 // ID unique pour matching exact
      amDoneById,                               // ID du tech ayant fait l'action
      intervenant: decodeUnicodeEscapes(values[2] || ""),
      type:        decodeUnicodeEscapes(values[4] || ""),
      dateCreation,
      dateFin,
      description
    });
  }
  return actions;
}

/**
 * Extrait les valeurs "value":"..." d'un bloc JSON row, gère les guillemets
 * échappés (\").
 */
function extractValuesFromRowBlock(block) {
  const values = [];
  let i = 0;
  while (i < block.length) {
    const mIdx = block.indexOf('"value":"', i);
    if (mIdx < 0) break;
    const start = mIdx + '"value":"'.length;
    // on lit jusqu'au prochain " non échappé.
    // Les escapes \X (\\, \") avancent de 2.
    // Les " littéraux internes sont encodés " dans le block (parce
    // qu'on n'a PAS pré-décodé) → 6 chars qui ne déclenchent pas le break.
    let j = start;
    while (j < block.length) {
      if (block[j] === '\\') { j += 2; continue; }
      if (block[j] === '"') break;
      j++;
    }
    values.push(block.substring(start, j));
    i = j + 1;
  }
  return values;
}

/**
 * Décode les échappements Unicode \u00XX présents dans les valeurs extraites.
 */
function decodeUnicodeEscapes(s) {
  if (!s) return s;
  return s.replace(/\\u([0-9a-fA-F]{4})/g, (_, h) => String.fromCharCode(parseInt(h, 16)));
}


/**
 * Préfixes des lignes structurelles à ignorer dans la description d'une
 * action EV avant de chercher le commentaire tech. Insensible à la casse
 * et aux accents. Le `...` final permet n'importe quel suffixe avant ` :`
 * (ex: `Date prévue :`, `TFS-IT :`).
 */
const _TECH_COMMENT_EXCLUDED_PREFIXES = [
  "service", "contact", "bénéficiaire", "beneficiaire",
  "étage", "etage", "bureau", "problème", "probleme",
  "à faire", "a faire", "matériel", "materiel",
];
const _TECH_COMMENT_EXCLUDED_WILDCARDS = ["tfs", "date"];
// Ligne meta = (préfixe exact OU wildcard suivi de n'importe quoi) puis ` :`
const _RX_TECH_META_LINE = new RegExp(
  "^\\s*(?:" +
  _TECH_COMMENT_EXCLUDED_PREFIXES
    .map(p => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
    .join("|") +
  "|(?:" + _TECH_COMMENT_EXCLUDED_WILDCARDS.join("|") + ")[^:]*?" +
  ")\\s*:",
  "i"
);
// Signature en queue de bloc : 3 lettres maj/min suivies optionnellement
// d'une date (24.04 / 23/04/26 / 28.04.2026). La date peut être absente.
const _RX_TECH_SIGNATURE = /^\s*([A-Za-zÀ-ÿ]{3})(?:\s+(\d{1,2}[.\/]\d{1,2}(?:[.\/]\d{2,4})?))?\s*$/;

/**
 * Retourne le commentaire tech d'une action EV ou null.
 *
 * Algorithme :
 *   1. Nettoyage HTML → texte plat, découpage par lignes.
 *   2. Filtrage des lignes meta (Service :, Contact :, Bénéficiaire :,
 *      Étage :, Bureau :, Problème :, À Faire :, TFS… :, Matériel :,
 *      Date… :) — insensible casse et accents.
 *   3. Identification de la dernière ligne "signature" du gros bloc
 *      (3 lettres + date optionnelle).
 *   4. Le commentaire = la 1re ligne non-vide qui suit la signature,
 *      séparée par exactement UN saut de ligne (la fin du bloc descriptif).
 *
 * Fallback : pattern legacy `login: texte` si aucune signature détectée.
 */
function extractTechCommentFromDescription(description) {
  if (!description) return null;

  const raw = decodeUnicodeEscapes(description)
    .replace(/<br\s*\/?>/gi, "\n")
    .replace(/<\/?p[^>]*>/gi, "\n")
    .replace(/<[^>]+>/g, "")
    .replace(/&nbsp;/g, " ")
    .replace(/&amp;/g, "&");

  const lines = raw.split(/\r?\n/);

  // Index de la dernière ligne signature dans le flux brut (en ignorant
  // les lignes meta pour ne pas casser sur un pattern accidentel dans
  // un libellé Service: / Contact:).
  let lastSigIdx = -1;
  for (let i = 0; i < lines.length; i++) {
    const ln = lines[i];
    if (_RX_TECH_META_LINE.test(ln)) continue;
    if (_RX_TECH_SIGNATURE.test(ln)) {
      lastSigIdx = i;
    }
  }

  if (lastSigIdx >= 0) {
    const sigLine = lines[lastSigIdx].trim();
    // Le commentaire = première ligne non vide après la signature.
    for (let i = lastSigIdx + 1; i < lines.length; i++) {
      const next = lines[i];
      if (next == null) continue;
      const trimmed = next.trim();
      if (!trimmed) continue;
      // Ligne meta après signature = pas le commentaire (cas rare où une
      // section Date :/Matériel : suivrait la signature).
      if (_RX_TECH_META_LINE.test(next)) continue;
      if (trimmed.length < 3) continue;
      return { signature: sigLine, commentaire: trimmed, full: trimmed };
    }
  }

  // Fallback 1 : pattern legacy plus permissif — signature 2-5 lettres
  // majuscules + date n'importe où dans le texte (pas forcément seule sur
  // sa ligne), suivie d'un \n et d'un commentaire. Récupère les fiches où
  // la signature est collée à du texte avant.
  const rxLegacy = /\b([A-Z]{2,5})\s+(\d{1,2}[.\/]\d{1,2}(?:[.\/]\d{2,4})?)\s*\n+([\s\S]+)/;
  const m1 = raw.match(rxLegacy);
  if (m1) {
    const commentaire = (m1[3] || "").trim();
    if (commentaire && commentaire.length >= 3) {
      return { signature: `${m1[1]} ${m1[2]}`, commentaire, full: commentaire };
    }
  }

  // Fallback 2 : pattern legacy "login: texte"
  const m2 = raw.match(RX_LOGIN_COMMENTAIRE);
  if (m2) {
    const commentaire = (m2[2] || "").trim();
    if (commentaire && commentaire.length >= 3) {
      return { signature: m2[1], commentaire, full: commentaire };
    }
  }

  return null;
}

/**
 * Normalise un nom "Nom, Prénom" (insensible à la casse, accents ignorés)
 * v2026.5.44 récupère un formLink FRAIS pour une référence (S260…/I260…)
 * via les APIs EV basicAutoComplete + redirectHeader. Garantit un checksum
 * valide pour la session en cours. Retourne null si erreur/iv inconnue.
 *
 * Le formLink retourné est dans le format attendu par fetchFiche :
 *   "internalurltime=…&eventName=formEvent&target=…&checksum=…&sender=…"
 * (sans PHPSESSID — il sera ajouté par background.js).
 */
async function getFreshFicheFormLinkForRef(ref) {
  if (!ref) return null;
  const origin = (state.session && state.session.origin) || state.lastKnownOrigin;
  const sid = state.session && state.session.phpsessid;
  if (!origin || !sid) return null;
  try {
    const r1 = await fetch(`${origin}/api/v1/internal/search/basicAutoComplete?search=${encodeURIComponent(ref)}&PHPSESSID=${encodeURIComponent(sid)}`, { credentials: "include" });
    const j1 = await r1.json();
    const meta = j1 && j1.data && j1.data.METAOBJECTS && j1.data.METAOBJECTS[0];
    const line = meta && meta.LINES && meta.LINES[0];
    if (!meta || !line || !line.PK || !meta.TYPE_GUID || !line.CHECKSUM) return null;
    const r2 = await fetch(`${origin}/api/v1/internal/search/redirectHeader?pk=${encodeURIComponent(line.PK)}&guid=${encodeURIComponent(meta.TYPE_GUID)}&checksum=${encodeURIComponent(line.CHECKSUM)}&PHPSESSID=${encodeURIComponent(sid)}`, { credentials: "include" });
    const j2 = await r2.json();
    const urlStr = (typeof j2 === "string") ? j2 : (j2 && j2.url) || "";
    if (!urlStr || !urlStr.includes("checksum=")) return null;
    const qIdx = urlStr.indexOf("?");
    const queryStr = qIdx >= 0 ? urlStr.substring(qIdx + 1) : urlStr;
    return queryStr.split("&").filter(p => !p.startsWith("PHPSESSID=")).join("&");
  } catch (e) {
    LOG.info("freshLink", `getFreshFicheFormLinkForRef erreur pour ${ref}`, { err: e && e.message });
    return null;
  }
}

function normalizeName(s) {
  if (!s) return "";
  return s
    .toLowerCase()
    .normalize("NFD").replace(/[\u0300-\u036f]/g, "")
    .replace(/\s+/g, " ")
    .trim();
}

/**
 * Détermine si une action est au nom du technicien donné.
 * Compare l'intervenant de l'action avec le nom du tech (insensible casse/accents).
 * Ignore les actions système (EZV_WS_REST_USER, vide).
 */
function actionBelongsToTech(action, techName, techId) {
  // on accepte 2 voies d'attribution :
  //   1. action.amDoneById === techId (le tech a réalisé/modifié l'action,
  //      même si elle a été créée par RPH ou un autre intervenant)
  //   2. intervenant matche le nom du tech (ancien comportement)
  if (techId && action.amDoneById && String(action.amDoneById) === String(techId)) {
    return true;
  }
  const interv = normalizeName(action.intervenant);
  if (!interv || interv === "ezv_ws_rest_user") return false;
  const tech = normalizeName(techName);
  if (!tech) return false;
  const techParts = tech.split(/[\s,]+/).filter(p => p.length >= 3);
  if (techParts.length === 0) return false;
  return techParts.every(p => interv.includes(p));
}

/**
 * Analyse les tickets disparus du planning et décide pour chacun s'il faut
 * le garder en vert (terminé tech ou clôturé) ou le retirer.
 *
 * Modifie directement les tech.interventions en place (retire les ghosts à
 * retirer, met à jour les propriétés des ghosts à garder).
 */
/**
 * Analyse une intervention DISPARUE du planning EV (missingSince posé par
 * storeApplyFresh) et conclut par UN verdict v2 :
 *   "closed"    clôturée/résolue officiellement (✓✓ vert) — final ;
 *   "done"      terminée par le tech, pas encore close (✓ gris) — ré-analysée ;
 *   "suspended" terminée mais statut EV Suspendu (✓ jaune) — ré-analysée ;
 *   "gone"      annulée / sans trace → goneAt (tombstone propagé) ;
 *   "unknown"   analyse impossible (fiche illisible, session, réseau) →
 *               l'iv reste visible, retentée au prochain refresh.
 * Le commentaire du tech et l'action correspondante sont rangés DANS le
 * verdict (verdict.techComment / verdict.actionInfo / verdict.officialClosed).
 *
 * Case diagnostic « Garder les disparitions » (Paramètres → Diagnostics) :
 * le verdict est posé normalement mais goneAt N'est PAS posé → l'iv reste
 * visible pour la mise au point, rien n'est retiré ni propagé.
 *
 * Mécanique réseau conservée de l'éprouvé (ex-analyzeOneDisappearedIv) :
 *   A) URL fraîche via basicAutoComplete + redirectHeader (réf → checksum) ;
 *   B) fetchFiche complet (fallback fiche request si tronquée) ;
 *   2) statut global de la fiche ;
 *   3-4) actions de la fiche : du tech ? même jour ? commentaire « login: » ?
 *   4bis) action de PLANIFICATION via xhr2 (la fiche ne la contient pas).
 *
 * @author Quentin Rouiller
 */
async function analyzeMissingIv(iv) {
  const techName = iv.techName || "";
  const techId = iv.techId;
  const reasons = [];
  const tag = `ref=${iv.ref || "?"} actionId=${iv.actionId} requestId=${iv.requestId || "?"} tech='${techName || "?"}'`;
  const reason = (msg) => { reasons.push(msg); LOG.info("disparition", `   ↳ ${tag} | ${msg}`); };

  // Conclusion unique : pose le verdict v2 + (hors mode diagnostic) la mort
  // pour gone. extra = { techComment, actionInfo, officialClosed }.
  const conclude = (status, why, extra) => {
    iv._analyzing = false;
    if (why) reasons.push(why);
    const isDiag = !!KEEP_DIAG_GHOSTS;
    ivSetVerdict(iv, status, "fiche", why || "", extra);
    if (status === "gone" && !isDiag) iv.goneAt = Date.now();   // tombstone propagé
    LOG.warn("disparition",
      `VERDICT ${tag} → ${status.toUpperCase()}${(status === "gone" && isDiag) ? " (case diagnostic : gardée visible, rien retiré)" : ""}`,
      { ref: iv.ref, actionId: iv.actionId, requestId: iv.requestId, type: iv.type, raisons: reasons });
    return iv.verdict;
  };

  // décode le HTML d'une description d'action + retire la ligne « login: … »
  // (le commentaire tech est affiché à part dans le popup, pas en double).
  const cleanActionDesc = (desc) => decodeUnicodeEscapes(desc)
    .replace(/<br\s*\/?>/gi, "\n")
    .replace(/<\/?p[^>]*>/gi, "\n")
    .replace(/<[^>]+>/g, "")
    .replace(/&nbsp;/g, " ")
    .replace(/&amp;/g, "&")
    // strict lowercase (sans /i) pour ne pas matcher "Lieu : "/"Service :".
    .replace(/\n+\s*[a-z0-9_]{3,12}\s*:\s+[\s\S]*$/, "")
    .replace(/\s+$/, "");

  LOG.info("disparition", `DÉBUT analyse ${tag} type=${iv.type} formLink=${iv.formLink ? "(présent)" : "ABSENT"}`,
    { ref: iv.ref, actionId: iv.actionId, requestId: iv.requestId, type: iv.type, status: iv.status });

  // Garde-fou : les résa/absences sont retirées dès l'ingestion
  // (storeApplyFresh) et ne passent normalement jamais ici.
  if (iv.type !== "AL-Intervention") {
    return conclude("gone", `${iv.type} disparue du planning (pas de fiche à consulter)`);
  }

  // ─── Étape A : récupérer URL fresh via basicAutoComplete + redirectHeader
  if (!iv.ref) {
    return conclude("unknown", "Étape A — iv.ref absente, impossible de chercher via basicAutoComplete");
  }
  const origin = (state.session && state.session.origin) || state.lastKnownOrigin;
  const sid = (state.session && state.session.phpsessid);
  if (!origin || !sid) {
    return conclude("unknown", `Étape A — session incomplète (origin=${origin}, sid=${sid ? "(présent)" : "ABSENT"})`);
  }

  reason(`Étape A1 — basicAutoComplete?search=${iv.ref}`);
  let pk, guid, freshChecksumInternal;
  try {
    const r1 = await fetch(`${origin}/api/v1/internal/search/basicAutoComplete?search=${encodeURIComponent(iv.ref)}&PHPSESSID=${encodeURIComponent(sid)}`, { credentials: "include" });
    const j1 = await r1.json();
    const meta = j1 && j1.data && j1.data.METAOBJECTS && j1.data.METAOBJECTS[0];
    const line = meta && meta.LINES && meta.LINES[0];
    if (!meta || !line || !line.PK || !meta.TYPE_GUID || !line.CHECKSUM) {
      LOG.warn("disparition", `   ↳ ${tag} | ✗ Étape A1 — JSON inattendu`, { json: j1 });
      return conclude("unknown", `Étape A1 — pas de pk/guid/checksum dans la réponse basicAutoComplete pour ref=${iv.ref}`);
    }
    pk = line.PK;
    guid = meta.TYPE_GUID;
    freshChecksumInternal = line.CHECKSUM;
    reason(`✓ Étape A1 — pk=${pk} guid=${guid} checksum_interne=${freshChecksumInternal.substring(0, 12)}…`);
  } catch (err) {
    return conclude("unknown", `Étape A1 — exception : ${err && err.message}`);
  }

  reason(`Étape A2 — redirectHeader?pk=${pk}&guid=${guid}&checksum=${freshChecksumInternal.substring(0, 12)}…`);
  let freshFormLink, freshFullUrl;
  try {
    const r2 = await fetch(`${origin}/api/v1/internal/search/redirectHeader?pk=${encodeURIComponent(pk)}&guid=${encodeURIComponent(guid)}&checksum=${encodeURIComponent(freshChecksumInternal)}&PHPSESSID=${encodeURIComponent(sid)}`, { credentials: "include" });
    const j2 = await r2.json();
    // j2 est une string : "index.php?PHPSESSID=...&internalurltime=...&eventName=formEvent&target=...&checksum=...&sender=..."
    const urlStr = (typeof j2 === "string") ? j2 : (j2 && j2.url) || "";
    if (!urlStr || !urlStr.includes("checksum=")) {
      LOG.warn("disparition", `   ↳ ${tag} | ✗ Étape A2 — URL redirectHeader invalide`, { json: j2 });
      return conclude("unknown", `Étape A2 — URL invalide retournée par redirectHeader`);
    }
    freshFullUrl = `${origin}/${urlStr}`;
    // Extraire le formLink (sans le PHPSESSID qui sera ajouté par background)
    const qIdx = urlStr.indexOf("?");
    const queryStr = qIdx >= 0 ? urlStr.substring(qIdx + 1) : urlStr;
    // background.js construit `${origin}/index.php?${formLink}&PHPSESSID=...` donc on
    // retire le PHPSESSID du formLink pour éviter le doublon.
    freshFormLink = queryStr.split("&").filter(p => !p.startsWith("PHPSESSID=")).join("&");
    reason(`✓ Étape A2 — URL fresh obtenue, formLink="${freshFormLink.substring(0, 100)}…"`);
    LOG.info("disparition", `   ↳ ${tag} | URL fresh :`, { url: freshFullUrl });
    // Sauvegarder pour réutilisation (ouverture au clic, etc.)
    iv.ficheFreshFormLink = freshFormLink;
    iv.ficheFreshFullUrl = freshFullUrl;
  } catch (err) {
    return conclude("unknown", `Étape A2 — exception : ${err && err.message}`);
  }

  // ─── Étape B : fetchFiche avec le formLink fresh ───────────────────
  const MIN_FICHE_BYTES = 20000;
  reason(`Étape B — fetchFiche avec formLink fresh`);
  const respB = await sendMessage({ type: "fetchFiche", formLink: freshFormLink });
  if (!respB || !respB.ok) {
    return conclude("unknown", `Étape B — fetchFiche a échoué (resp=${respB ? JSON.stringify({ ok: respB.ok, error: respB.error }) : "null"})`);
  }
  const html = respB.html || "";
  if (html.length < MIN_FICHE_BYTES) {
    LOG.warn("disparition", `   ↳ ${tag} | Contenu de la fiche tronquée (500 chars)`,
      { snippet: html.substring(0, 500).replace(/\s+/g, " ") });
    return conclude("unknown", `Étape B — fiche reçue ${html.length} octets (< ${MIN_FICHE_BYTES}) malgré checksum frais — anomalie EV`);
  }
  reason(`✓ Étape B — fiche complète reçue (${html.length} octets)`);
  // succès complet → retirer un « fiche tronquée » périmé (posé par un
  // fetch LIVE antérieur, jamais effacé ici).
  if (iv._fetchWarning) { delete iv._fetchWarning; delete iv.ficheFetchError; }

  // ─── Étape 2 : statut global de la fiche (Clôturé/Résolu) ────────
  const ficheData = parseFicheHtml(html);
  const ficheStatus = ficheData.status || iv.status || null;
  iv.status = ficheStatus;
  iv.updatedAt = Date.now();
  // v2026.5.46 — Localisation officielle de la fiche (aussi pour les
  // disparues : la carte « fait »/« clos » affiche la bonne adresse).
  const _ficheLoc = _extractFicheLocation(html);
  if (_ficheLoc) iv.ficheLocation = _ficheLoc;
  _updateLocMismatch(iv);
  const isOfficiallyClosed = isClosedStatus(ficheStatus) || isResolvedStatus(ficheStatus);
  reason(`Étape 2 — statut global = ${JSON.stringify(ficheStatus)}, officiellementClos=${isOfficiallyClosed}`);

  // statut "Clôturé/Résolu" (libellés de la config admin) → ticket fermé côté
  // EV. Le tech a-t-il laissé un commentaire ?
  //   - oui → closed (✓✓ vert), commentaire affiché ;
  //   - non → gone : ticket clos sans trace du tech = il n'a rien à voir avec
  //     ce planning, on le retire.
  if (isOfficiallyClosed) {
    const allActions = parseAllActionsFromFicheHtml(html);
    const techActions = allActions.filter(a => actionBelongsToTech(a, techName, techId));
    const techActionWithComment = techActions
      .map(a => ({ a, c: extractTechCommentFromDescription(a.description) }))
      .filter(x => x.c);
    if (techActionWithComment.length === 0) {
      return conclude("gone",
        `Statut "${ficheStatus}" = clos officiel MAIS aucune action du tech avec commentaire → ticket fermé sans trace du tech, on retire`);
    }
    const best = techActionWithComment[0];
    if (best.a.description) {
      const cleaned = cleanActionDesc(best.a.description);
      iv.bulleDescription = cleaned;
      iv.ficheActionText = cleaned;
    }
    return conclude("closed",
      `Statut "${ficheStatus}" = clos + commentaire tech récupéré → terminée officielle`,
      { techComment: best.c.full, officialClosed: true,
        actionInfo: { intervenant: best.a.intervenant, dateCreation: best.a.dateCreation, dateFin: best.a.dateFin, type: best.a.type } });
  }

  // ─── Étape 3 : parser TOUTES les actions de la fiche ────────────────────
  const actions = parseAllActionsFromFicheHtml(html);
  reason(`Étape 3 — parseAllActionsFromFicheHtml a trouvé ${actions.length} action(s) dans la fiche`);
  const actionsBrief = actions.map((a, idx) => ({
    idx,
    actionId: a.actionId,
    amDoneById: a.amDoneById,
    type: a.type,
    intervenant: a.intervenant,
    dateCreation: a.dateCreation,
    dateFin: a.dateFin,
    descSnippet: (a.description || "").substring(0, 100).replace(/\s+/g, " ")
  }));
  LOG.info("disparition", `   ↳ ${tag} | DÉTAIL des ${actions.length} actions`, actionsBrief);

  // ─── Étape 4 : filtrer par tech + date + commentaire ──────────────
  const ghostDate = iv.startDate || iv.endDate || iv.currentDate || null; // JJ/MM/AAAA
  const ghostDateShort = ghostDate ? ghostDate.substring(0, 10) : null;
  reason(`Étape 4 — recherche actions du tech '${techName}' avec date ≈ ${ghostDateShort || "?"}`);

  // on passe aussi techId pour matcher via amDoneById quand l'action a été
  // créée par RPH/un autre intervenant mais réalisée par le tech.
  const techActions = actions.filter(a => actionBelongsToTech(a, techName, techId));
  reason(`Étape 4 — ${techActions.length} action(s) au tech (sur ${actions.length} totales)`);

  // si AUCUNE action n'est attribuée au tech alors que la fiche en contient,
  // on dump intervenant + amDoneById de TOUTES les actions pour voir POURQUOI
  // le matching échoue. C'est ce qui décide « fait » vs « retiré ».
  if (techActions.length === 0 && actions.length > 0) {
    LOG.warn("disparition",
      `   ↳ ${tag} | AUCUNE action attribuée au tech '${techName}' (id=${techId}) — dump diagnostic des ${actions.length} actions`,
      { techName, techId, actions: actions.map(a => ({
          intervenant: a.intervenant, amDoneById: a.amDoneById, type: a.type,
          dateCreation: a.dateCreation, dateFin: a.dateFin,
          hasComment: !!extractTechCommentFromDescription(a.description) })) });
  }

  const techActionsBrief = techActions.map(a => {
    const c = extractTechCommentFromDescription(a.description);
    return {
      type: a.type,
      intervenant: a.intervenant,
      dateCreation: a.dateCreation,
      dateFin: a.dateFin,
      hasComment: !!c,
      commentaire: c ? c.full : null,
      descSnippet: (a.description || "").substring(0, 200).replace(/\s+/g, " ")
    };
  });
  LOG.info("disparition", `   ↳ ${tag} | ACTIONS DU TECH (avec dates + commentaires)`, techActionsBrief);

  // Filtrer celles dont la date matche le jour de l'iv disparue
  const matchDate = (dStr) => {
    if (!dStr || !ghostDateShort) return false;
    return dStr.startsWith(ghostDateShort);
  };
  const sameDay = techActions.filter(a => matchDate(a.dateCreation) || matchDate(a.dateFin));
  reason(`Étape 4 — actions du tech sur le jour ${ghostDateShort} : ${sameDay.length}`);

  const sameDayWithComment = sameDay.map(a => ({ a, c: extractTechCommentFromDescription(a.description) })).filter(x => x.c);
  if (sameDayWithComment.length > 0) {
    const best = sameDayWithComment[0];
    // alimenter bulleDescription décodée pour le tooltip + l'extraction de
    // signature (pattern "XXX JJ.MM") sur la carte.
    if (best.a.description) {
      const cleaned = cleanActionDesc(best.a.description);
      iv.bulleDescription = cleaned;
      iv.ficheActionText = cleaned;
    }
    const extra = { techComment: best.c.full, officialClosed: isOfficiallyClosed,
      actionInfo: { intervenant: best.a.intervenant, dateCreation: best.a.dateCreation, dateFin: best.a.dateFin, type: best.a.type } };
    if (isOfficiallyClosed) {
      return conclude("closed",
        `Action du tech le ${ghostDateShort} + commentaire + statut "${ficheStatus}" → terminée et validée`, extra);
    }
    // statut "Suspendu" → ✓ jaune avec label "Suspendu" (au lieu de "Fait")
    if (isSuspendedStatus(ficheStatus)) {
      return conclude("suspended",
        `Action du tech le ${ghostDateShort} + commentaire mais statut "${ficheStatus}" → suspendue (commentaire affiché)`, extra);
    }
    return conclude("done",
      `Action du tech le ${ghostDateShort} + commentaire mais statut "${ficheStatus}" pas encore clos → terminée par tech, en attente de clôture officielle`, extra);
  }

  if (sameDay.length > 0) {
    // on log les descriptions COMPLÈTES des actions sameDay qui n'ont
    // pas matché pour qu'on puisse adapter le pattern d'extraction.
    const descDump = sameDay.map((a, i) => ({
      idx: i,
      intervenant: a.intervenant,
      dateCreation: a.dateCreation,
      dateFin: a.dateFin,
      type: a.type,
      descLen: (a.description || "").length,
      descRaw: (a.description || "").substring(0, 1500)
    }));
    LOG.warn("disparition",
      `   ↳ ${tag} | aucune action sameDay n'a matché extractTechCommentFromDescription — voir descRaw ci-dessous`,
      { sameDayCount: sameDay.length, actions: descDump });
    return conclude("gone",
      `Action du tech le ${ghostDateShort} mais SANS commentaire "login: …" → présumée annulée`);
  }

  // action tech avec commentaire mais sur un autre jour → on traite
  // quand même comme "Fait" (le tech a fait le travail, juste avant) avec
  // commentaire affiché dans le tooltip. Si statut Suspendu → ✓ jaune.
  const techActionWithComment = techActions.map(a => ({ a, c: extractTechCommentFromDescription(a.description) })).filter(x => x.c);
  if (techActionWithComment.length > 0) {
    const best = techActionWithComment[0];
    if (best.a.description) {
      const cleaned = cleanActionDesc(best.a.description);
      iv.bulleDescription = cleaned;
      iv.ficheActionText = cleaned;
    }
    const extra = { techComment: best.c.full, officialClosed: isOfficiallyClosed,
      actionInfo: { intervenant: best.a.intervenant, dateCreation: best.a.dateCreation, dateFin: best.a.dateFin, type: best.a.type } };
    if (isOfficiallyClosed) {
      return conclude("closed",
        `Action AVEC commentaire (autre jour ${best.a.dateCreation || best.a.dateFin}) + statut "${ficheStatus}" clos → ✓✓`, extra);
    }
    if (isSuspendedStatus(ficheStatus)) {
      return conclude("suspended",
        `Action AVEC commentaire (autre jour ${best.a.dateCreation || best.a.dateFin}) mais statut "${ficheStatus}" → suspendue`, extra);
    }
    return conclude("done",
      `Action AVEC commentaire (autre jour ${best.a.dateCreation || best.a.dateFin}) → terminée par tech, statut "${ficheStatus}" pas encore clos`, extra);
  }

  // ─── Étape 4bis : commentaire via l'ACTION DE PLANIFICATION (xhr2) ────────
  // Le commentaire du tech est sur l'action AL-Intervention = le créneau
  // planifié lui-même (iv.actionId), récupérable via planning_xhr_2.php (LA
  // MÊME source que le survol). parseXhr2Body renvoie
  //   - `description` = le work-order (… A faire … AWR 27/05/26  c5b6gy: ok)
  //   - `last`        = l'intervenant "Nom, Prénom" de l'action.
  // Ni la fiche DS ni son timeline (todo/done, toutes sections) ne contiennent
  // cette action (vérifié par diagnostic réseau). On VALIDE donc `last == tech` (toujours
  // juste) PUIS on cherche le commentaire dans la description.
  if (iv.actionId) {
    reason(`Étape 4bis — action de planification via xhr2 (actionId=${iv.actionId})`);
    try {
      const xr = await sendMessage({ type: "fetchXhr2", actionId: iv.actionId });
      if (xr && xr.ok) {
        const px = parseXhr2Body(xr.body) || {};
        const last = (px.last || "").trim();
        const desc = px.description || "";
        const belongs = actionBelongsToTech({ intervenant: last }, techName, techId);
        const c = extractTechCommentFromDescription(desc);
        reason(`xhr2 last="${last}" label="${px.label || ""}" appartientAuTech=${belongs} commentaire=${c ? JSON.stringify(c.full.slice(0, 70)) : "non"} descLen=${desc.length}`);
        if (belongs && c) {
          // bulle = work-order nettoyé, SANS la ligne "login: …" (le commentaire
          // est affiché à part) → évite le « bordel » dans le popup.
          const cleaned = cleanActionDesc(desc);
          iv.bulleDescription = cleaned;
          iv.ficheActionText = cleaned;
          const extra = { techComment: c.full, officialClosed: isOfficiallyClosed,
            actionInfo: { intervenant: last, dateCreation: ghostDate, dateFin: null, type: px.label || "AL-Intervention" } };
          if (isOfficiallyClosed) {
            return conclude("closed",
              `Action AL-Intervention de '${last}' (= tech) + commentaire + statut "${ficheStatus}" clos → ✓✓`, extra);
          }
          if (isSuspendedStatus(ficheStatus)) {
            return conclude("suspended",
              `Action AL-Intervention de '${last}' (= tech) + commentaire mais statut "${ficheStatus}" → suspendue`, extra);
          }
          return conclude("done",
            `Action AL-Intervention de '${last}' (= tech planifié) + commentaire → terminée par tech, statut "${ficheStatus}" pas encore clos`, extra);
        }
        if (c && !belongs) {
          reason(`Étape 4bis — commentaire présent mais intervenant "${last}" ≠ tech '${techName}' → NON validé (on retire)`);
        }
      } else {
        reason(`Étape 4bis — xhr2 KO (${xr ? xr.error : "null"})`);
      }
    } catch (err) {
      reason(`Étape 4bis — exception xhr2 : ${err && err.message}`);
    }
  }

  return conclude("gone",
    `Aucune action du tech '${techName}' avec commentaire trouvée → présumée annulée/orpheline`);
}

// ============================================================================
// Orchestrateur séquentiel (phase B)                          // 2026.5.46
// ============================================================================
// Une seule passe, dans l'ordre d'affichage des cartes :
//   1. pompier(s) en premier
//   2. autres techs par ordre alphabétique (nom de famille)
//   3. au sein de chaque tech : matin → après-midi (par startTime)
//
// File = fiches des iv AFFICHÉES (statut + commentaire + checksum), puis
// disparues à analyser (opts.toAnalyze, listées par storeApplyFresh) →
// analyzeMissingIv. Une iv à la fois (le serveur EV sérialise de toute façon,
// l'abort devient instantané, pas de races de DOM). Sauvegarde du store toutes
// les 5 iv + à la fin (si l'user change de date en cours, rien n'est perdu).
async function processInterventionsSequentially(day, isoDate, opts = {}) {
  const myToken = opts.myToken;
  const forceAll = !!opts.forceAll;
  const useFreshChecksum = !!opts.useFreshChecksum;

  // 1. fiches des iv AFFICHÉES, dans l'ordre des cartes. Le xhr2 (rapide,
  // parallèle) est lancé séparément AVANT, par prefetchAllXhr2 (phase A).
  const techs = storeProject(day, isoDate);
  const sortedTechs = [...techs].sort((a, b) => compareTechs(a, b, isoDate));
  const ficheQueue = [];

  for (const tech of sortedTechs) {
    const sortedIvs = [...(tech.interventions || [])].sort((a, b) =>
      (a.startTime || "").localeCompare(b.startTime || "")
    );
    for (const iv of sortedIvs) {
      if (iv.missingSince) continue;  // disparues → file d'analyse (opts.toAnalyze)
      if (iv.type !== "AL-Intervention") continue;
      if (!iv.actionId) {
        LOG.info("seq", `↳ NON mise en file : pas d'actionId`, { ref: iv.ref, type: iv.type });
        continue;
      }
      const statClos = isClosedStatus(iv.status) || isResolvedStatus(iv.status);
      // "Tout recharger" (forceAll=true) doit ré-analyser MÊME les iv
      // déjà closes — pour rafraîchir un éventuel changement (réouverture,
      // nouveau commentaire, etc.). On ne skip que sur "Actualiser" simple.
      if (statClos && iv.ficheFetched && !forceAll) {
        LOG.info("seq", `↳ NON mise en file : déjà close + fiche connue → ${iv.ref || iv.actionId}`,
          { ref: iv.ref, actionId: iv.actionId, status: iv.status });
        continue;
      }
      // v2026.5.46 — on peut récupérer la fiche via la RÉF même sans
      // formLink stocké (certaines iv du XML n'en ont pas → avant, elles étaient
      // « sautées comme si elles n'existaient pas »). fetchAndUpdateIntervention
      // régénère alors le formLink depuis la réf.
      const canFetch = !!(iv.formLink || iv.ref);
      let needFiche = false;
      if (canFetch) {
        if (forceAll) needFiche = true;
        else if (!iv.ficheFetched) needFiche = true;
        else if (iv._timeChanged) needFiche = true;
      }
      if (needFiche) {
        ficheQueue.push({ iv, kind: "fiche" });
        LOG.info("seq", `↳ EN FILE (fiche) → ${iv.ref || iv.actionId}`,
          { ref: iv.ref, actionId: iv.actionId, source: iv.formLink ? "formLink" : "réf", ficheFetched: !!iv.ficheFetched, timeChanged: !!iv._timeChanged });
      } else {
        LOG.info("seq", `↳ NON mise en file → ${iv.ref || iv.actionId}`,
          { ref: iv.ref, actionId: iv.actionId,
            raison: !canFetch ? "ni formLink ni réf" : (iv.ficheFetched ? "fiche déjà connue" : "inconnue"),
            formLink: !!iv.formLink, ficheFetched: !!iv.ficheFetched });
      }
    }
  }

  // 2. disparues à analyser (listées par storeApplyFresh : vivantes, verdict
  //    non final). _analyzing = spinner sur les cartes encore affichées
  //    (done/suspended/unknown ré-analysées pour détecter une clôture).
  const toAnalyze = opts.toAnalyze || [];
  for (const rec of toAnalyze) {
    rec._analyzing = true;
    // rafraîchir la carte tout de suite : spinner _checking visible pendant
    // l'analyse (les done/suspended ré-analysées restent affichées).
    try { updateInterventionRow(rec); } catch (e) { /* carte pas rendue */ }
    ficheQueue.push({ iv: rec, kind: "ghost" });
  }
  if (toAnalyze.length) {
    LOG.info("disparition", `${toAnalyze.length} disparue(s) en file d'analyse`,
      { ivs: toAnalyze.map(r => ({ ref: r.ref, tech: r.techName, verdict: ivVStatus(r) })) });
  }

  const total = ficheQueue.length;
  if (total === 0) {
    LOG.info("seq", `rien à traiter (fiches+disparues)`);
    return;
  }

  LOG.info("seq", `${total} iv à traiter (fiches+disparues, séquentiel)`);
  setRefreshing(true);

  let done = 0;
  const showBar = (state.currentDate === isoDate) && !opts.skipBuiltinProgressBar;
  if (showBar) {
    showProgressBar();
    updateProgressBar(0, total);
  }

  const STORE_WRITE_EVERY = 5;
  let sinceLastWrite = 0;

  try {
    for (const { iv, kind } of ficheQueue) {
      if (isRefreshAborted(myToken)) break;
      try {
        if (kind === "ghost") {
          await analyzeMissingIv(iv);
        } else if (kind === "fiche") {
          await fetchAndUpdateIntervention(iv, myToken, { useFreshChecksum });
        }
      } catch (err) {
        LOG.warn("seq", `iv ${iv.actionId} (${kind}) erreur:`, err);
        if (kind === "ghost") {
          iv._analyzing = false;
          ivSetVerdict(iv, "unknown", "fiche", `exception pendant l'analyse : ${err && err.message}`);
        }
      }
      try { updateInterventionRow(iv); } catch (e) { /* ignore */ }
      done++;
      if (showBar && state.currentDate === isoDate) {
        updateProgressBar(done, total);
      }
      if (typeof opts.onProgress === "function") {
        try { opts.onProgress(); } catch (e) { /* ignore */ }
      }
      sinceLastWrite++;
      if (sinceLastWrite >= STORE_WRITE_EVERY) {
        try { await storeSave(isoDate, day); sinceLastWrite = 0; }
        catch (err) { LOG.warn("seq", "écriture intermédiaire échouée:", err); }
      }
    }

    // Sauvegarde finale (même si abort → on persiste ce qui a été fait)
    try { await storeSave(isoDate, day); }
    catch (e) { LOG.warn("store", "storeSave fail (final seq)", { err: e && e.message }); }

    // Re-rendre via la projection : les verdicts gone viennent de masquer
    // leurs cartes, les ✓/✓✓ sont posés, le tri est à jour.
    if (!isRefreshAborted(myToken)) {
      renderFromData({
        techs: storeProject(day, isoDate),
        targetDate: isoDate,
        captureTime: Date.now(),
        source: "fresh+sequential",
        lastRefreshKind: activeRefreshButton
      });
    }
  } finally {
    setRefreshing(false);
    if (showBar) hideProgressBar();
  }
}

async function fetchAndUpdateIntervention(iv, myToken, opts = {}) {
  try {
    // Bail-out coopératif : si l'utilisateur a cliqué sur "Arrêter" ou a
    // changé de date, on ne fetch pas cette intervention.
    if (isRefreshAborted(myToken)) {
      iv.ficheFetched = true;
      iv.ficheFetchError = "aborted";
      return;
    }

    // v2026.5.44 si demandé (cache > 24h ou refresh manuel), on
    // récupère un formLink avec checksum FRAIS via basicAutoComplete +
    // redirectHeader avant de fetch la fiche. Garantit qu'EV nous sert
    // bien la fiche complète et pas une page tronquée.
    let formLinkToUse = iv.formLink;
    // v2026.5.46 — régénère un formLink frais via la réf si demandé
    // (useFreshChecksum) OU si l'iv N'A PAS de formLink (certaines iv du XML
    // n'en fournissent pas → sans ça, leur fiche n'était jamais récupérée et la
    // carte restait vide « Chargement des détails… »).
    if ((opts.useFreshChecksum || !formLinkToUse) && iv.ref) {
      const fresh = await getFreshFicheFormLinkForRef(iv.ref);
      if (fresh) {
        formLinkToUse = fresh;
        iv.formLink = fresh; // on persiste pour les prochains usages (ouverture, etc.)
      }
    }

    // v4.1.2 : pour chaque interventoin on fait xhr2 PUIS fiche.
    //  - xhr2 : récupère les VRAIES infos contact/lieu (attr1/attr2 du XML
    //           sont parfois erronées si le tech a corrigé après planif).
    //           On met à jour la carte tout de suite avec les vraies infos.
    //  - fiche : récupère statut Clôturé/Résolu + commentaire tech + checksum
    //            valide pour l'ouverture au clic.

    // ─── Étape 1 : xhr2 (rapide, ~400 o) ────────────────────────────────
    if (!iv.xhr2Fetched && !isRefreshAborted(myToken)) {
      try {
        const xhr2Resp = await sendMessage({ type: "fetchXhr2", actionId: iv.actionId });
        // v4.1.9 : si on a été aborté pendant l'attente, ne PAS appliquer
        // le résultat au DOM (on ne doit plus toucher à une ligne qui
        // appartient à la date précédente).
        if (isRefreshAborted(myToken)) return;
        if (xhr2Resp && xhr2Resp.ok) {
          const parsed = parseXhr2Body(xhr2Resp.body);
          if (parsed) {
            if (parsed.description) {
              iv.bulleDescription = parsed.description;
              const infob = parseActionText(parsed.description);
              if (infob) iv.infobulle = infob;
              _updateLocMismatch(iv);   // v2026.5.46 — lieu action vs fiche
            }
            if (parsed.label) iv.label = parsed.label;
            iv.xhr2Fetched = true;
            iv.updatedAt = Date.now();   // fraîcheur de fusion (store v2)
            // Met à jour la carte avec les vraies infos xhr2
            updateInterventionRow(iv);
          }
        }
      } catch (err) {
        LOG.warn("xhr2", "erreur iv", iv.actionId, err);
      }
    }

    if (isRefreshAborted(myToken)) return;

    // ─── Étape 2 : fetch fiche (statut + commentaire + checksum) ──────────
    // Retry léger : une erreur réseau ponctuelle (timeout, 5xx) ne doit pas
    // perdre la ligne. 1 seul retry après 400ms. Session expirée n'est PAS
    // retryée (ça ne passera pas mieux la 2e fois).
    let ficheResp = await sendMessage({ type: "fetchFiche", formLink: formLinkToUse });
    if (isRefreshAborted(myToken)) return;
    if (!ficheResp.ok && ficheResp.error !== "session_expired" && !isRefreshAborted(myToken)) {
      await new Promise(r => setTimeout(r, 400));
      if (!isRefreshAborted(myToken)) {
        ficheResp = await sendMessage({ type: "fetchFiche", formLink: formLinkToUse });
      }
    }
    if (isRefreshAborted(myToken)) return;

    if (!ficheResp.ok) {
      iv.ficheFetched = true;
      iv.ficheFetchError = ficheResp.error || "fetch_failed";
      if (ficheResp.error === "session_expired") {
        state.session = null;
        // session expirée → + bannière + abort de tout le refresh.
        iv._fetchWarning = true;
        showSessionExpiredBanner();
        abortCurrentRefresh();
      }
      return;
    }

    // réponse OK mais TRONQUÉE (< 20 Ko). Avant de probe session, on
    // tente un fallback automatique sur la fiche REQUEST (parente) via
    // basicAutoComplete + redirectHeader. EZV sert souvent une fiche action
    // minimaliste (~8 Ko) pour les iv clôturées, alors que la fiche request
    // contient la description complète et le commentaire de résolution.
    if (ficheResp.truncated) {
      const triedRequestFallback = formLinkToUse !== iv.formLink;
      if (!triedRequestFallback && iv.ref) {
        LOG.info("seq", `iv ${iv.actionId} (ref=${iv.ref}) fiche action tronquée (${ficheResp.size} o) → fallback fiche request via ref…`);
        const fresh = await getFreshFicheFormLinkForRef(iv.ref);
        if (fresh && fresh !== formLinkToUse) {
          formLinkToUse = fresh;
          iv.formLink = fresh;
          ficheResp = await sendMessage({ type: "fetchFiche", formLink: formLinkToUse });
          if (isRefreshAborted(myToken)) return;
          if (ficheResp && ficheResp.ok && !ficheResp.truncated) {
            LOG.info("seq", `fallback fiche request OK (${ficheResp.size} o)`);
            // tombe naturellement dans le parsing en dessous
          } else {
            LOG.warn("seq", `fallback fiche request encore tronqué (${ficheResp && ficheResp.size} o)`);
          }
        }
      }
    }

    // Toujours tronquée après le fallback ? On marque + probe session.
    if (ficheResp.truncated) {
      iv._fetchWarning = true;
      iv.ficheFetchError = "truncated";
      LOG.warn("seq", `iv ${iv.actionId} (ref=${iv.ref}) fiche tronquée définitive (${ficheResp.size} octets) → probe session…`);
      try {
        const probe = await sendMessage({ type: "checkSession" });
        if (!probe || !probe.ok) {
          LOG.warn("seq", `session morte (probe=${probe && probe.error}) → abort + bannière`);
          state.session = null;
          showSessionExpiredBanner();
          abortCurrentRefresh();
          return;
        }
      } catch (e) {
        LOG.warn("seq", "probe session échouée :", e);
      }
      iv.ficheFetched = true;
      return;
    }

    const fiche = parseFicheHtml(ficheResp.html);
    iv.status = fiche.status;
    // v2026.5.46 — Localisation OFFICIELLE de la fiche (onglet Détail,
    // AM_LOCATION.LOCATION_FR « Ville/Adresse ») : devient l'adresse affichée
    // sur la carte + comparée au lieu écrit dans l'action (rouge si différent).
    const _ficheLoc = _extractFicheLocation(ficheResp.html);
    if (_ficheLoc) iv.ficheLocation = _ficheLoc;
    _updateLocMismatch(iv);
    // v4.2.5 : on retire définitivement le champ commentaireTech (obsolète
    // depuis qu'on récupère l'action complète via l'API timeline).
    delete iv.commentaireTech;
    // Fallback : si l'XML n'avait pas la ref (rare, mais possible pour des
    // actions hors-standard), on prend celle de la fiche.
    if (fiche.rfc && !iv.ref) {
      iv.ref = fiche.rfc;
    }
    // v4.1.18 : persister le formSenderGuid sur l'iv pour qu'il soit
    // disponible au clic pour ouvrir la fiche avec le bon sender (S vs I).
    if (fiche.formSenderGuid) {
      iv.formSenderGuid = fiche.formSenderGuid;
    }

    // ─── Étape 3 : API timeline → texte complet de l'action ─────────────
    // Le HTML brut de la fiche ne contient PAS les valeurs d'action (elles
    // sont injectées côté client par Angular via un apel REST). On appelle
    // donc le même endpoint REST qu'Angular pour récupérer la description
    // complète, match par ACTION_ID === iv.actionId (fiable, numérique).
    //
    // Ce texte REMPLACE le texte xhr2 tronqué dans le tooltip.
    // Si l'appel échoue ou ne trouve rien, on garde le fallback xhr2 dans
    // iv.bulleDescription (déjà stocké à l'étape 1).
    if (fiche.formId && fiche.formChecksum && fiche.formSenderGuid &&
        iv.actionId && !isRefreshAborted(myToken)) {
      try {
        const tlResp = await sendMessage({
          type: "fetchTimelineApi",
          guid: fiche.formSenderGuid,
          formId: fiche.formId,
          formChecksum: fiche.formChecksum
        });
        if (isRefreshAborted(myToken)) return;
        if (tlResp && tlResp.ok) {
          const fullText = parseTimelineJsonForAction(tlResp.body, iv.actionId);
          if (fullText) {
            iv.ficheActionText = fullText;
          }
        } else if (tlResp && tlResp.error === "session_expired") {
          state.session = null;
          showSessionExpiredBanner();
        }
      } catch (err) {
        LOG.warn("timeline", "erreur iv", iv.actionId, err);
      }
    }

    // ─── Extraire le checksum pour ouvrir la fiche ─────────────────────
    // STRICTEMENT IDENTIQUE à v4 originale (qui fonctionne pour l'ouverture) :
    //   - On n'extrait QUE si ficheChecksum n'est pas déjà là (une fois trouvé
    //     c'est bon, pas la peine de ré-extraire à chaque refresh et risquer
    //     de l'écraser avec une mauvaise valeur).
    //   - Pas de "Tentative 3" ultime : elle peut matcher le checksum du form
    //     principal qui n'est PAS le bon pour l'action → casse l'ouverture.
    if (iv.requestId && !iv.ficheChecksum) {
      // Tentative 1 : target=ID&checksum=... (pattern le plus courant)
      const rx1 = new RegExp(`target=${iv.requestId}&(?:amp;)?checksum=([a-f0-9]{40})`);
      const m1 = ficheResp.html.match(rx1);
      if (m1) {
        iv.ficheTarget = iv.requestId;
        iv.ficheChecksum = m1[1];
      } else {
        // Tentative 2 : JSON formData
        const rx2a = new RegExp(`"id"\\s*:\\s*"${iv.requestId}"[\\s\\S]{0,200}?"checksum"\\s*:\\s*"([a-f0-9]{40})"`);
        const m2a = ficheResp.html.match(rx2a);
        if (m2a) {
          iv.ficheTarget = iv.requestId;
          iv.ficheChecksum = m2a[1];
        } else {
          const rx2b = new RegExp(`"checksum"\\s*:\\s*"([a-f0-9]{40})"[\\s\\S]{0,200}?"id"\\s*:\\s*"${iv.requestId}"`);
          const m2b = ficheResp.html.match(rx2b);
          if (m2b) {
            iv.ficheTarget = iv.requestId;
            iv.ficheChecksum = m2b[1];
          }
        }
      }
    }
    iv.ficheFetched = true;
    iv.updatedAt = Date.now();   // fraîcheur de fusion (store v2)
    // succès complet → on retire le s'il y en avait un.
    if (iv._fetchWarning) { delete iv._fetchWarning; delete iv.ficheFetchError; }

    // Rendu incrémental : mettre à jour la ligne dans le DOM immédiatement
    // (statut clos → fond vert + ✓, commentaire tech dans le tooltip).
    // v4.1.9 : ne touche au DOM que si on est toujours sur la même date
    // qui a été demandée initialement (sinon on corromprait la nouvelle vue).
    if (!isRefreshAborted(myToken)) {
      updateInterventionRow(iv);
    }
  } catch (err) {
    iv.ficheFetched = true;
    iv.ficheFetchError = String(err);
    LOG.warn("fetch", "fetchAndUpdate error:", err);
  }
}

/**
 * v4 : Lazy-load du texte d'action détaillé au premier survol d'une intervention.
 *
 * Le calendar_block nous donne déjà contact/lieu/catégorie via attr1/attr2/attr3
 * (planification initiale), mais pas le TEXTE COMPLET de l'action (Problème/
 * À faire/Matériel/TFS/...) et surtout pas les VRAIES infos à jour : un tech
 * peut avoir mis à jour le contact ou le lieu après la planification initiale,
 * et ces vraies infos ne sont PAS dans attr1/attr2.
 *
 * Ce texte vient de planning_xhr_2.php. On le fetch à la demande (premier hover)
 * pour ne pas surcharger le serveur au chargement initial.
 *
 * v4.1.2 : quand les infos arrivent, on MET À JOUR la carte car ces infos
 * (venant du texte d'action validé par le tech) sont plus fiables que
 * attr1/attr2 (planification initiale parfois erronée).
 */
// v4.3.2 : pré-fetch de tous les xhr2 en parallèle (batch).
// Objectif : avoir les VRAIES infos contact/lieu pour toutes les interventions
// AVANT que l'utilisateur se mette à les survoler. Comme le xhr2 est léger
// (2-5 KB), on peut en faire plusieurs en parallèle sans écrouler EasyVista.
//
// Params :
//   techs    : liste des techs avec leurs interventions
//   myToken  : jeton d'annulation (si l'user change de date, on s'arrête)
//   forceAll : si true, re-fait le xhr2 même pour les inter déjà xhr2Fetched
//              (utilisé par "Tout recharger")
async function prefetchAllXhr2(techs, myToken, forceAll) {
  if (!techs) return;
  // retour au comportement v42 — PARALLÈLE (concurrency=6) pour avoir
  // les infos courtes (contact/lieu) sur TOUTES les cartes en bloc dès le
  // 1er chargement. Chaque xhr2 fait ~400 octets, donc même 30 iv en
  // parallèle reste léger pour EV.
  const needed = [];
  for (const tech of techs) {
    for (const iv of tech.interventions || []) {
      if (iv.type !== "AL-Intervention") continue;
      if (!iv.actionId || iv.missingSince) continue;   // disparues : pas de xhr2 en masse
      if (iv.xhr2Fetching) continue;
      if (iv.xhr2Fetched && !forceAll) continue;
      needed.push(iv);
    }
  }
  if (needed.length === 0) return;

  LOG.info("load", `pré-fetch xhr2 batch : ${needed.length} iv (parallèle, concurrency=6)…`);
  const t0 = performance.now();

  if (forceAll) {
    for (const iv of needed) iv.xhr2Fetched = false;
  }

  const concurrency = 6;
  const queue = [...needed];
  const workers = [];
  for (let w = 0; w < concurrency; w++) {
    workers.push((async () => {
      while (queue.length > 0) {
        if (isRefreshAborted(myToken)) return;
        const iv = queue.shift();
        try {
          await ensureBulleDescription(iv);
        } catch (err) {
          LOG.warn("prefetch xhr2", "iv", iv.actionId, err);
        }
      }
    })());
  }
  await Promise.all(workers);
  LOG.info("load", `pré-fetch xhr2 fini en ${Math.round(performance.now() - t0)} ms`);
}

async function ensureBulleDescription(iv) {
  // Déjà chargé : rien à faire
  if (iv.xhr2Fetched) return true;
  // Fetch déjà en cours (évite les races si l'utilisateur survole plusieurs fois)
  if (iv.xhr2Fetching) return false;
  // Pas applicable (réservation, absence, disparue, ou pas d'actionId)
  if (iv.type !== "AL-Intervention") return false;
  if (!iv.actionId || iv.missingSince) return false;

  iv.xhr2Fetching = true;
  try {
    const resp = await sendMessage({ type: "fetchXhr2", actionId: iv.actionId });
    if (!resp || !resp.ok) return false;
    const parsed = parseXhr2Body(resp.body);
    if (!parsed) return false;

    if (parsed.description) {
      iv.bulleDescription = parsed.description;
      const infob = parseActionText(parsed.description);
      if (infob) {
        iv.infobulle = infob;
      }
      _updateLocMismatch(iv);   // v2026.5.46 — lieu action vs fiche
    }
    if (parsed.label) iv.label = parsed.label;
    iv.xhr2Fetched = true;
    iv.updatedAt = Date.now();   // fraîcheur de fusion (store v2)

    // Mettre à jour la carte : lieu/contact du xhr2 sont les VRAIES infos à
    // jour (le tech les a peut-être corrigées après la planification initiale).
    updateInterventionRow(iv);
    return true;
  } catch (err) {
    LOG.warn("xhr2 lazy", "erreur iv", iv.actionId, err);
    return false;
  } finally {
    iv.xhr2Fetching = false;
  }
}

// normalise + stem un libellé statut pour comparaison TRÈS souple.
//   - lowercase
//   - suppression des accents
//   - suppression des terminaisons verbales courantes (er, ée, ées, és,
//     ent, e, s) pour rapprocher "Terminé/Terminer/Termine/Terminée".
// Du coup l'user saisit "Terminé" une fois et toutes les conjugaisons /
// variantes orthographiques matchent automatiquement.
function _normalizeStatus(s) {
  if (!s) return "";
  return String(s).toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "");
}
function _stemStatus(s) {
  let n = _normalizeStatus(s);
  // Boucle pour gérer les terminaisons multiples (ex: "terminees" → "terminee" → "terminee")
  for (let i = 0; i < 3; i++) {
    const nn = n.replace(/(ees|ent|ees|ee|er|es|s|e)$/, "");
    if (nn === n || nn.length < 4) break;
    n = nn;
  }
  return n;
}
function _statusMatchesAny(s, list) {
  if (!s || !list || !list.length) return false;
  const stemS = _stemStatus(s);
  const normS = _normalizeStatus(s);
  for (const x of list) {
    if (!x) continue;
    const stemX = _stemStatus(x);
    if (stemX && (stemS.includes(stemX) || normS.includes(stemX))) return true;
  }
  return false;
}
function isClosedStatus(s) { return _statusMatchesAny(s, CLOSED_STATUS); }
function isResolvedStatus(s) { return _statusMatchesAny(s, RESOLVED_STATUS); }
// statut "Suspendu" (en attente d'info bénéficiaire/demandeur etc.)
// → ✓ jaune avec label "Suspendu" au lieu de "Fait".
function isSuspendedStatus(s) { return _statusMatchesAny(s, ["Suspendu"]); }

// ============================================================================
// Parsing d'une fiche individuelle (HTML)
// ============================================================================
// v4 : simplifié. On ne cherche plus dans la fiche que :
//   - le statut Clôturé/Résolu (pour le ✓ vert)
//   - le commentaire technicien (affiché dans le tooltip)
//   - la ref RFC_NUMBER (utilisée seulement en fallback, si le XML n'avait pas)
// Les autres extractions (categoryLine, intervenant, actionDescription) sont
// supprimées car ces infos viennent maintenant du XML attr1/attr2/attr3 ou du
// lazy-load xhr2 au hover.

/**
 * Parse le HTML brut d'une fiche EasyVista (rendu serveur, ~460 Ko, NON hydraté
 * par Angular donc ne contient PAS les valeurs d'actions — celles-ci sont
 * chargées séparément via l'API timeline).
 *
 * Rôle : extraire les champs nécessaires :
 *   - status          : STATUS_FR (affichage ✓ et fond vert si clos)
 *   - rfc             : RFC_NUMBER (fallback si pas dans XML)
 *   - formId          : id numérique du form (SD_REQUEST pour S... ou incident)
 *   - formChecksum    : checksum du form (pour appel API timeline)
 *   - formSenderGuid  : v4.1.9 — GUID du form (différent pour incident I...
 *                       vs demande S...). Extrait dynamiquement depuis les
 *                       liens target=FORM_ID&checksum=...&sender={GUID} du
 *                       HTML lui-même. Pour les demandes S → C99ECD05..., pour
 *                       les incidents I → 07ED9C68... (ou autre selon config).
 */
function parseFicheHtml(html) {
  const out = {
    status: null,
    rfc: null,
    formId: null,
    formChecksum: null,
    formSenderGuid: null
  };

  // STATUS_FR (valeur parfois encodée en \u00XX)
  // limite portée à 200 chars — certains statuts EV sont longs
  // (ex: "Suspendu : Attente info bénéficiaire/demandeur" = 47 chars).
  // L'ancienne limite 30 chars les ratait → status=null → pas de
  // détection terminated-suspended.
  let m = html.match(/"dbFieldName"\s*:\s*"STATUS_FR"[^}]*?"value"\s*:\s*"([^"]{2,200})"/);
  if (m) out.status = decodeJsonString(m[1]);

  // RFC_NUMBER (fallback au cas où le XML n'aurait pas la ref)
  m = html.match(/"dbFieldName"\s*:\s*"RFC_NUMBER"[^}]*?"value"\s*:\s*"([^"]{5,30})"/);
  if (m) out.rfc = m[1];

  // formData.form.{id,checksum} : indispensable pour l'API timeline.
  // On matche dans les deux ordres possibles.
  m = html.match(/var formData\s*=\s*\{"form":\{[^}]*?"checksum":"([a-f0-9]{40})"[^}]*?"id":"(\d+)"/);
  if (m) {
    out.formChecksum = m[1];
    out.formId = m[2];
  } else {
    m = html.match(/var formData\s*=\s*\{"form":\{[^}]*?"id":"(\d+)"[^}]*?"checksum":"([a-f0-9]{40})"/);
    if (m) {
      out.formId = m[1];
      out.formChecksum = m[2];
    }
  }

  // v4.1.9 : déduire le GUID du form. On cherche dans le HTML un lien qui
  // référence notre formId (target=FORM_ID...) avec un sender. C'est le GUID
  // du form principal utilisé pour l'API timeline :
  //   - demande S... → {C99ECD05-3D48-4C62-ABF0-66292053AED6}
  //   - incident I... → {07ED9C68-6172-48EA-8A58-90912B0A283E}
  // v4.1.10 (fix) : regex robuste qui accepte &, &amp;, et parcourt jusqu'à
  // 300 chars entre target=ID et sender= (au lieu de stopper au 1er "/'/espace
  // ce qui peut échouer sur certains HTML).
  if (out.formId) {
    const rx = new RegExp(
      `target=${out.formId}(?:&(?:amp;)?\\w+=[^&"'\\s<>]*){0,10}?&(?:amp;)?sender=(%7B[A-F0-9\\-]{36}%7D)`,
      "i"
    );
    const sm = html.match(rx);
    if (sm) {
      out.formSenderGuid = sm[1];  // garder encodé (déjà prêt pour URL)
    } else {
      // Fallback : chercher le GUID le plus fréquent associé à notre formId
      // dans tout le HTML (tolérant à n'importe quelle séquence entre les 2).
      const rxLoose = new RegExp(
        `target=${out.formId}[\\s\\S]{0,300}?sender=(%7B[A-F0-9\\-]{36}%7D)`,
        "gi"
      );
      const counts = new Map();
      let lm;
      while ((lm = rxLoose.exec(html)) !== null) {
        counts.set(lm[1], (counts.get(lm[1]) || 0) + 1);
      }
      // Prendre le plus fréquent
      let best = null;
      let bestCount = 0;
      for (const [guid, c] of counts) {
        if (c > bestCount) { best = guid; bestCount = c; }
      }
      if (best) out.formSenderGuid = best;
    }

    // v4.1.10 (fix définitif) : si toujours pas trouvé, fallback par défaut
    // sur le GUID des demandes S... (le plus courant). Pour les rares
    // incidents I... où le HTML brut n'aurait aucun lien target=FORM_ID, le
    // timeline ne sera pas chargé mais le reste fonctionne.
    if (!out.formSenderGuid && out.rfc) {
      if (/^S/i.test(out.rfc)) {
        out.formSenderGuid = "%7BC99ECD05-3D48-4C62-ABF0-66292053AED6%7D";
      } else if (/^I/i.test(out.rfc)) {
        out.formSenderGuid = "%7B07ED9C68-6172-48EA-8A58-90912B0A283E%7D";
      }
    }
  }

  return out;
}

/**
 * Parse le JSON renvoyé par /api/v1/internal/forms/{GUID}/timeline et en
 * extrait le texte de description complet pour UNE action donnée.
 *
 * Structure du JSON :
 *   { data: { data: {
 *       columns: [...13 cols],
 *       values: [                     ← 1 entrée par action dans la fiche
 *         { rows: [
 *             {value:"..."},  // [0..10] statut, groupe, dates, etc.
 *             {value:"Date : ... Heure : ... Lieu : ..."},  // [11] DESCRIPTION
 *             {value:""},
 *             {value:"{\"ACTION_ID\":\"57700033\",...}"}    // [13] JSON stringifié
 *           ] }
 *       ] }}}
 *
 * On cherche l'action dont rows[13].ACTION_ID === actionId ; si trouvée, on
 * retourne rows[11] nettoyé (br→\n, entités décodées) ; sinon null.
 */
function parseTimelineJsonForAction(jsonText, actionId) {
  if (!jsonText || !actionId) return null;
  let data;
  try {
    data = JSON.parse(jsonText);
  } catch (e) {
    LOG.warn("timeline", "JSON parse failed:", e);
    return null;
  }

  const values = data?.data?.data?.values;
  if (!Array.isArray(values)) return null;

  const targetId = String(actionId);

  for (const entry of values) {
    const rows = entry?.rows;
    if (!Array.isArray(rows) || rows.length < 14) continue;

    // rows[13] = JSON stringifié qui contient ACTION_ID
    const extraRaw = rows[13]?.value;
    if (!extraRaw || typeof extraRaw !== "string") continue;

    let extra;
    try {
      extra = JSON.parse(extraRaw);
    } catch (e) {
      // v2026.5.38 : on logue le contenu (tronqué) pour pouvoir reproduire
      // qd le serveur EV renvoie du JSON cassé (ça arrive après MAJ EV).
      LOG.warn("timeline", "JSON.parse failed sur extraRaw",
        { snippet: extraRaw.substring(0, 120), err: e && e.message });
      continue;
    }

    if (String(extra.ACTION_ID) !== targetId) continue;

    // Trouvé : extraire la description (rows[11]) et la nettoyer.
    const rawDesc = rows[11]?.value || extra["AM_ACTION.DESCRIPTION"] || "";
    const cleaned = cleanHtmlBlock(rawDesc);
    return cleaned || null;
  }

  return null;
}


/**
 * Nettoie un bloc HTML pour obtenir du texte brut lisible.
 *   - <br> (avec ou sans attributs) → \n
 *   - entités HTML décodées (&nbsp; &gt; etc.)
 *   - tags HTML restants supprimés
 *   - espaces multiples compactés
 */
function cleanHtmlBlock(html) {
  if (!html) return "";
  let s = html;
  // <br>, <br/>, <br id="...">, <br style="..."> → \n
  s = s.replace(/<br\b[^>]*>/gi, "\n");
  // Entités HTML
  s = s.replace(/&nbsp;/g, " ")
       .replace(/&gt;/g, ">")
       .replace(/&lt;/g, "<")
       .replace(/&quot;/g, '"')
       .replace(/&#39;/g, "'")
       .replace(/&apos;/g, "'")
       .replace(/&amp;/g, "&")
       .replace(/\u200b/g, ""); // zero-width space
  // Tags HTML restants
  s = s.replace(/<[^>]+>/g, "");
  // Espaces compactés, lignes trimmed, lignes vides retirées
  s = s.split("\n").map(l => l.trim().replace(/[ \t]+/g, " ")).filter(Boolean).join("\n");
  return s;
}

function decodeJsonString(s) {
  return s
    .replace(/\\r/g, "")
    .replace(/\\n/g, "\n")
    .replace(/\\t/g, "\t")
    .replace(/\\\//g, "/")
    .replace(/\\"/g, '"')
    .replace(/\\\\/g, "\\")
    .replace(/\\u([0-9a-fA-F]{4})/g, (_, hex) => {
      try { return String.fromCharCode(parseInt(hex, 16)); }
      catch { return _; }
    });
}

/**
 * Parse le texte d'une action au format :
 *   Date : lundi 20.04 Heure : matin
 *   Lieu : Ville1/Rue1 1
 *   Service : Service1/...
 *   Contact : Nom1, Prénom1 +41000000001
 *   ...
 *
 * → renvoie un objet { date, heure, lieu, service, contact, etage, bureau,
 *                      probleme, aFaire, tfsAncien, tfsNouveau, materiel, dateProposee, autres }
 */
function parseActionText(text) {
  if (!text) return null;
  const out = { _raw: text };
  // v4.2 : on track toutes les occurrences de "Contact" / "Personne de contact"
  //        pour détecter l'anomalie (les 2 présents = situation suspecte).
  const contactOccurrences = [];  // { kind: "contact"|"personne", value: string }
  // Pré-filtrer les lignes "Date proposée par ..." : on NE prend PAS ce champ
  // nulle part (ni en infobulle.dateProposee, ni dans autres).
  const lines = text.split(/\n+/)
    .map(l => l.trim())
    .filter(Boolean)
    .filter(l => !/^\s*date\s+propos[ée]e\s+par\b/i.test(l));
  const labelMap = {
    "date": "date",
    "heure": "heure",
    "lieu": "lieu",
    "service": "service",
    "contact": "contact",
    "bénéficiaire": "beneficiaire",
    "beneficiaire": "beneficiaire",
    "étage": "etage",
    "etage": "etage",
    "bureau": "bureau",
    "problème": "probleme",
    "probleme": "probleme",
    "a faire": "aFaire",
    "à faire": "aFaire",
    "matériel": "materiel",
    "materiel": "materiel",
    "tfs ancien poste": "tfsAncien",
    "tfs nouveau poste": "tfsNouveau"
  };

  const autres = [];
  for (const line of lines) {
    // Si la ligne CONTIENT "Date proposée par ..." à l'intérieur (pas juste au
    // début), on coupe cette partie-là avant de parser le reste.
    let cleanLine = line.replace(/\bdate\s+propos[ée]e\s+par\s+(?:le\s+|la\s+)?contact\s*[:?]\s*\S+.*$/i, "").trim();
    if (!cleanLine) continue;

    // v4.2 : on détecte aussi "Personne de contact..." (spécifique à la demande
    // / sur site / de l'entité quittée / interne / etc.). On la marque comme
    // un 2e candidat possible pour le contact affiché.
    const rxPersonne = /Personne\s+de\s+contact(?:\s+(?:sur\s+site|sp[ée]cifique[^:]*|de\s+l[''`]?entit[ée][^:]*|interne[^:]*))?\s*:\s*/gi;
    let pm;
    while ((pm = rxPersonne.exec(cleanLine)) !== null) {
      // Valeur = jusqu'au prochain label connu OU fin de ligne
      const after = cleanLine.substring(pm.index + pm[0].length);
      const stop = after.search(/\b(Date|Heure|Lieu|Service|Contact|B[ée]n[ée]ficiaire|[ÉE]tage|Bureau|Probl[èe]me|A\s*faire|À\s*faire|Mat[ée]riel|TFS|Personne\s+de\s+contact|Num[ée]ro\s+de\s+t[ée]l[ée]phone)\s*:/i);
      const val = (stop >= 0 ? after.substring(0, stop) : after).trim()
                   .replace(/[,;]+$/, "").trim();
      if (val) {
        contactOccurrences.push({ kind: "personne", value: val });
      }
    }

    // "Date : lundi 20.04 Heure : matin" → split en plusieurs paires
    const markers = [];
    // v4.2 : on ajoute un lookbehind négatif (?<!Personne\s+de\s+) pour ne
    //         PAS matcher "Contact" à l'intérieur de "Personne de Contact".
    //         Sans ça on aurait un double match.
    const rx = /(?<!Personne\s+de\s+)(Date|Heure|Lieu|Service|Contact|B[ée]n[ée]ficiaire|[ÉE]tage|Bureau|Probl[èe]me|A\s*faire|À\s*faire|Mat[ée]riel|TFS\s+ancien\s+poste|TFS\s+nouveau\s+poste)\s*:\s*/gi;
    let m;
    while ((m = rx.exec(cleanLine)) !== null) {
      markers.push({ label: m[1], valueStart: m.index + m[0].length });
    }
    if (markers.length === 0) {
      autres.push(cleanLine);
      continue;
    }
    for (let i = 0; i < markers.length; i++) {
      const mk = markers[i];
      let val;
      if (i + 1 < markers.length) {
        const nextStart = cleanLine.indexOf(markers[i + 1].label, mk.valueStart);
        val = cleanLine.substring(mk.valueStart, nextStart).trim();
      } else {
        val = cleanLine.substring(mk.valueStart).trim();
      }
      const keyNorm = mk.label.toLowerCase().replace(/\s+/g, " ");
      const outKey = labelMap[keyNorm];
      if (outKey && val) {
        // v4.2 : on track aussi les "Contact" rencontrés dans contactOccurrences
        if (outKey === "contact") {
          contactOccurrences.push({ kind: "contact", value: val });
        } else {
          out[outKey] = out[outKey] ? out[outKey] + " / " + val : val;
        }
      }
    }
  }

  // v4.2 : logique de sélection du contact + détection d'anomalie
  //  - 0 occurrence     → rien
  //  - 1 "contact"      → OK
  //  - 1 "personne"     → OK (fallback)
  //  - ≥ 2 occurrences  → anomalie : on garde la 1re mais on marque anomalie
  //                       pour que l'UI affiche en rouge et que le caller sache
  //                       qu'il vaut mieux garder l'ancien contact (xhr2).
  if (contactOccurrences.length === 1) {
    out.contact = contactOccurrences[0].value;
  } else if (contactOccurrences.length >= 2) {
    out.contactAnomalie = true;
    // On prend quand même le 1er "contact" pur (pas "personne") si possible
    const firstReal = contactOccurrences.find(x => x.kind === "contact");
    out.contact = (firstReal || contactOccurrences[0]).value;
  }

  if (autres.length) out.autres = autres.join("\n");
  return out;
}

// ============================================================================
// Rendu général
// ============================================================================

// Compteur de fetches en cours. La flèche tourne tant que ce compteur > 0.
// On le maintient manuellement au lieu d'un booléen pour gérer correctement
// les appels imbriqués.
let refreshCounter = 0;
// Timer pour effacer le ✓ vert après 5 s
let refreshDoneTimer = null;

// v4.1.13 : quel bouton doit tourner pendant le refresh en cours.
// Valeurs : "total" (par défaut / chargement auto), "partial", ou "xml_only".
let activeRefreshButton = "total";

function setActiveRefreshButton(kind) {
  activeRefreshButton = kind || "total";
  // v4.1.20 : si le bouton Arrêter est affiché, le repositionner selon
  // le nouveau type de refresh actif. Sinon rien à faire (il prendra sa
  // position au prochain showAbortButton(true)).
  positionAbortButton();
}

// v4.1.20 : place le bouton Arrêter à sa position correcte selon
// activeRefreshButton. Fonction idempotente, sûre à appeler plusieurs fois.
function positionAbortButton() {
  const btn = document.getElementById("abort-btn");
  if (!btn) return;
  const partialBtn = document.getElementById("refresh-partial-btn");
  const totalBtn = document.getElementById("refresh-btn");
  if (!partialBtn || !totalBtn) return;
  if (activeRefreshButton === "partial") {
    // Entre Actualiser (partial) et Tout recharger (total)
    if (btn.previousElementSibling !== partialBtn) {
      totalBtn.parentNode.insertBefore(btn, totalBtn);
    }
  } else {
    // Après Tout recharger
    if (totalBtn.nextSibling !== btn) {
      totalBtn.parentNode.insertBefore(btn, totalBtn.nextSibling);
    }
  }
}

function setRefreshing(on) {
  const iconTotal = document.getElementById("refresh-icon");
  const iconPartial = document.getElementById("refresh-partial-icon");
  // Quel icône doit tourner ? Seulement celui correspondant au bouton
  // qui a lancé le refresh (ou "total" par défaut).
  const targetIcon = (activeRefreshButton === "partial") ? iconPartial : iconTotal;
  if (on) {
    refreshCounter++;
    if (targetIcon) targetIcon.classList.add("spinning");
    clearCheckMark();
    // Afficher "rafraichissement en cours…" si on n'a pas déjà les données
    updateCaptureInfoText();
  } else {
    refreshCounter = Math.max(0, refreshCounter - 1);
    if (refreshCounter === 0) {
      // Arrêt : stopper les deux icônes au cas où
      if (iconTotal) iconTotal.classList.remove("spinning");
      if (iconPartial) iconPartial.classList.remove("spinning");
    }
    updateCaptureInfoText();
  }
}

// Force le rafraichissement du texte "MAJ HH:MM" ou "rafraichissement en cours…"
// selon refreshCounter.
function updateCaptureInfoText() {
  if (state.currentData) {
    renderCaptureInfo(state.currentData);
  }
}

/**
 * Appelé quand TOUS les fetches (y compris les fetches fiches en
 * arrière-plan) sont terminés. Affiche un ✓ vert à côté de l'heure MAJ
 * pendant 5 secondes.
 */
function showRefreshDone() {
  const check = document.getElementById("refresh-check");
  if (!check) return;
  check.classList.remove("hidden");
  check.classList.add("visible");
  if (refreshDoneTimer) clearTimeout(refreshDoneTimer);
  refreshDoneTimer = setTimeout(() => {
    check.classList.remove("visible");
    setTimeout(() => check.classList.add("hidden"), 300); // après transition
  }, 5000);
}

function clearCheckMark() {
  const check = document.getElementById("refresh-check");
  if (check) {
    check.classList.remove("visible");
    check.classList.add("hidden");
  }
  if (refreshDoneTimer) {
    clearTimeout(refreshDoneTimer);
    refreshDoneTimer = null;
  }
}

// ─── Barre de progression (v4.1.7) ─────────────────────────────────────
// État global : on affiche la progression du fetch en cours, uniquement si
// c'est le fetch de la page actuellement visible. Si l'utilisateur change
// de date, la barre suit la nouvelle date (son propre état).
function showProgressBar() {
  const bar = document.getElementById("progress-bar");
  if (bar) bar.classList.remove("hidden");
  // v2026.5.47 — en vue horizontale, la barre est un overlay en haut de la
  // sidebar : cette classe réserve sa hauteur (CSS) pour que les initiales/titre
  // passent DESSOUS au lieu d'être recouverts.
  document.documentElement.classList.add("planif-refreshing");
  if (typeof _srSyncStickyOffsets === "function") _srSyncStickyOffsets();
}

function hideProgressBar() {
  const bar = document.getElementById("progress-bar");
  if (bar) bar.classList.add("hidden");
  document.documentElement.classList.remove("planif-refreshing");
  updateProgressBar(0, 0);
  if (typeof _srSyncStickyOffsets === "function") _srSyncStickyOffsets();
}

function updateProgressBar(done, total) {
  const fill = document.getElementById("progress-bar-fill");
  const label = document.getElementById("progress-bar-label");
  if (!fill || !label) return;
  if (total <= 0) {
    fill.style.width = "0%";
    label.textContent = "";
    return;
  }
  const pct = Math.min(100, Math.round((done / total) * 100));
  fill.style.width = pct + "%";
  // v4.1.20 : message différencié selon le type de refresh actif
  const prefix = (activeRefreshButton === "partial") ? "Actualisation" : "Rafraîchissement";
  label.textContent = `${prefix}… ${done} / ${total}`;
}

// Affiche/masque le bouton "Arrêter". N'est montré que pdt un refresh
// manuel (clic utilisateur), pas pendant les chargements normaux ni les
// refresh auto 12h/15h.
function showAbortButton(on) {
  const btn = document.getElementById("abort-btn");
  if (!btn) return;
  if (on) {
    positionAbortButton();
    btn.classList.remove("hidden");
  } else {
    btn.classList.add("hidden");
  }
}

/**
 * Toast de feedback quand l'user clique Arrêter. Les fetches en cours peuvent
 * encore prendre 1-2 secondes avant de se terminer (on ne peut pas vriament
 * annuler un fetch() en cours), mais du point de vue de l'interface tout
 * est arrêté : plus de mise à jour, plus de cache, plus rien.
 */
function showAbortToast() {
  showToast("Rafraîchissement", "arrêté");
}

// v2026.5.46 — l'anti-flash des disparitions vit dans storeProject : une
// iv absente du planning EV et JAMAIS analysée (verdict encore live +
// missingSince) est masquée jusqu'au verdict ; une iv déjà confirmée « à
// garder » (done / suspended / closed / unknown) reste affichée pendant sa
// ré-analyse. Les verdicts gone/moved et les tombstones ne sont jamais rendus
// (sauf case diagnostic « Garder les disparitions »).
function renderFromData(data) {
  // v2026.5.46 — filet global anti-rendu périmé.
  // Un rendu construit pour un AUTRE jour que celui à l'écran est refusé
  // (chargement ou synchro asynchrone qui aboutit après une navigation
  // rapide entre dates ; tous les appelants légitimes passent le jour
  // affiché en targetDate — vérifié sur les 7 appels existants).
  // (re-rendre CE QUI EST DÉJÀ À L'ÉCRAN reste permis pendant un
  // chargement d'une autre date — les réglages repassent state.currentData
  // tel quel, même référence, pour rafraîchir vue/stats/bandeaux.
  // CONTRAT : l'exemption exige le MÊME OBJET — pas de copie, pas de capture
  // avant un await. L'identité de référence est un choix : une comparaison
  // par date laisserait passer un rendu périmé tant que l'écran affiche
  // encore l'ancienne date, picker et cartes mélangés — le bug d'origine.)
  if (data && data.targetDate && state.currentDate &&
      data.targetDate !== state.currentDate && data !== state.currentData) {
    LOG.warn("render", "rendu périmé refusé (autre date que celle à l'écran)",
      { targetDate: data.targetDate, currentDate: state.currentDate, source: data.source });
    return;
  }
  // v2026.5.46 — TOUS les filtres d'affichage vivent dans storeProject
  // (tombstones, verdicts gone/moved, disparues jamais analysées, dock,
  // déplacées récentes) : les appelants passent une projection. On garde ici
  // un unique filet de sécurité (tombstones) au cas où une source non-store
  // alimenterait encore le rendu.
  if (data && Array.isArray(data.techs)) {
    data = { ...data, techs: data.techs.map(t => ({
      ...t,
      interventions: (t.interventions || []).filter(iv => !ivIsDead(iv))
    })) };
  }
  // v2026.5.38 : on wrappe tout le rendu dans un try/catch global. Si l'une
  // des étapes plante (ex: tech sans interventions, données XML cassées),
  // on logue tout et on affiche un message à l'user au lieu de laisser un
  // écran blanc.
  const _tStart = performance.now();
  LOG.info("render", "renderFromData début",
    { date: data && data.targetDate, source: data && data.source, techsCount: data && data.techs && data.techs.length });
  try {
    state.currentData = data;

    // Null checks défensifs sur les éléments UI critiques
    const elLoading       = document.getElementById("loading");
    const elErrorBox      = document.getElementById("error-box");
    const elSessionNeeded = document.getElementById("session-needed");
    const elCards         = document.getElementById("cards");
    if (!elLoading || !elErrorBox || !elSessionNeeded || !elCards) {
      LOG.error("render", "éléments DOM manquants",
        { loading: !!elLoading, errorBox: !!elErrorBox, sessionNeeded: !!elSessionNeeded, cards: !!elCards });
      return;
    }
    elLoading.classList.add("hidden");
    elErrorBox.classList.add("hidden");
    elSessionNeeded.classList.add("hidden");
    elCards.classList.remove("hidden");

    // v4.3.0 : détecter les conflits d'horaire entre interventions d'un même
    // tech (même heure de début OU chevauchement).
    detectOverlaps(data.techs);

    // Calculer les stats
    const stats = computeStats(data.techs, data.targetDate);
    renderCaptureInfo(data, stats);
    renderStats(stats);
    renderCards(data);
    // Détection post-rendu : si une mini-card iv déborde son contenu,
    // on masque les gap-placeholder-mini de la même ligne pour
    // libérer la place. Appelé via rAF pour avoir les dimensions
    // après layout flex.
    if (typeof _trimMiniGapsForFit === "function") {
      requestAnimationFrame(() => _trimMiniGapsForFit());
    }
    // v2026.5.46 — mise en avant recherche : après chaque rendu, on applique
    // une éventuelle demande de surbrillance en attente (accrochée au rendu réel
    // plutôt qu'à un timing deviné).
    if (typeof _srApplyPendingHighlight === "function") {
      requestAnimationFrame(() => _srApplyPendingHighlight());
    }
    LOG.info("render", "renderFromData OK", { ms: Math.round(performance.now() - _tStart) });
  } catch (err) {
    LOG.exception("render", "renderFromData a planté",
      err, { date: data && data.targetDate, techsCount: data && data.techs && data.techs.length });
    if (typeof showError === "function") {
      showError("Erreur d'affichage : " + (err.message || "voir console F12"));
    }
  }
}

// v4.3.0 : détection des conflits d'horaire entre interventions d'un même tech.
// Marque iv._hasOverlap = true pour chaque intervention en conflit avec une
// autre (même heure de début OU chevauchement de créneaux).
// Les absences récurrentes, tickets fantômes à retirer, et réservations
// sont ignorés (pas de conflit pertinent pour eux).
function detectOverlaps(techs) {
  if (!techs) return;
  for (const tech of techs) {
    // on inclut maintenant les AL-Reservation pour détecter les
    // conflits Réservation × Intervention (les 2 marqués rouge).
    const ivs = (tech.interventions || []).filter(iv =>
      iv && _ivShownStart(iv) && _ivShownEnd(iv) &&
      // v4.3.2 : le pompier est une absence "tolérée" qui chevauche par
      // nature les heures de travail — on l'exclut des conflits.
      // (v2026.5.46 : les retirées/disparues sont déjà filtrées en amont
      // par storeProject, plus de flag _disappearRemove.)
      !iv.isPompier
    );
    // Reset flag sur toutes les inters du tech (y compris celles ignorées)
    for (const iv of (tech.interventions || [])) {
      iv._hasOverlap = false;
    }
    // Convertir HH:MM en minutes pour comparaison rapide
    const toMin = (hhmm) => {
      if (!hhmm) return null;
      const parts = hhmm.split(":");
      if (parts.length < 2) return null;
      const h = parseInt(parts[0], 10);
      const m = parseInt(parts[1], 10);
      if (isNaN(h) || isNaN(m)) return null;
      return h * 60 + m;
    };
    // Comparer chaque paire
    for (let i = 0; i < ivs.length; i++) {
      for (let j = i + 1; j < ivs.length; j++) {
        const a = ivs[i], b = ivs[j];
        const aStart = toMin(_ivShownStart(a)), aEnd = toMin(_ivShownEnd(a));
        const bStart = toMin(_ivShownStart(b)), bEnd = toMin(_ivShownEnd(b));
        if (aStart === null || aEnd === null || bStart === null || bEnd === null) continue;
        // Chevauchement = a commence avant que b finisse ET b commence avant que a finisse.
        // Inclut aussi le cas "même heure de début" (aStart === bStart).
        if (aStart < bEnd && bStart < aEnd) {
          a._hasOverlap = true;
          b._hasOverlap = true;
        }
      }
    }
  }
}

function renderCaptureInfo(data, stats) {
  const info = document.getElementById("capture-info");
  if (refreshCounter > 0) {
    // v4.1.20 : message différencié selon le type de refresh actif
    //  - partial (Actualiser) → "Actualisation en cours…"
    //  - total  (Tout recharger) → "rafraichissement en cours…"
    if (activeRefreshButton === "partial") {
      info.textContent = "Actualisation en cours…";
    } else {
      info.textContent = "Rafraîchissement en cours…";
    }
    info.classList.add("refreshing");
    return;
  }
  info.classList.remove("refreshing");
  const parts = [];
  if (data.captureTime) {
    const d = new Date(data.captureTime);
    const hh = String(d.getHours()).padStart(2, "0");
    const mm = String(d.getMinutes()).padStart(2, "0");
    const today = new Date();
    const isSameDay = d.getFullYear() === today.getFullYear() &&
                      d.getMonth() === today.getMonth() &&
                      d.getDate() === today.getDate();
    // v4.1.20 : préfixe selon le type de refresh qui a généré cette capture
    //  - lastRefreshKind === "partial" → "Actualisé à HH:MM"
    //  - lastRefreshKind === "total"   → "Synchronisé à HH:MM"
    //  - data.source === "cache"       → "Cache de HH:MM"
    let prefix;
    if (data.source === "cache") {
      prefix = "Cache de ";
    } else if (data.lastRefreshKind === "partial") {
      prefix = "Actualisé à ";
    } else {
      prefix = "Synchronisé à ";
    }
    if (isSameDay) {
      parts.push(`${prefix}${hh}:${mm}`);
    } else {
      const dd = String(d.getDate()).padStart(2, "0");
      const mo = String(d.getMonth() + 1).padStart(2, "0");
      let prefixDate;
      if (data.source === "cache") {
        prefixDate = "Cache du ";
      } else if (data.lastRefreshKind === "partial") {
        prefixDate = "Actualisé le ";
      } else {
        prefixDate = "Synchronisé le ";
      }
      parts.push(`${prefixDate}${dd}.${mo} ${hh}:${mm}`);
    }
  }
  info.textContent = parts.join(" · ");
}

function computeStats(techs, targetDate) {
  let pompiers = 0, absents = 0, available = 0;
  let totalInterventions = 0, morning = 0, afternoon = 0;
  let closed = 0, resolved = 0, done = 0;
  for (const tech of techs) {
    const isPompier = tech.interventions.some(iv => iv.isPompier);
    const isAbsent = isTechAbsent(tech, targetDate);
    // v2026.5.45 (issue #8) : un pompier absent TOUTE la journée ne doit
    // pas compter comme pompier disponible. Avant : `if (isPompier) pompiers++`
    // → le compteur "1 pompier" restait à 1 même si la personne était en
    // congé/maladie sur la journée entière. Maintenant on le compte uniquement
    // s'il n'est pas absent toute la journée.
    if (isPompier && !isAbsent) pompiers++;
    if (isAbsent) absents++;

    // v2026.5.39 : tech disponible = pas absent/malade ET pas réservé toute
    // la journée. Pompier compte comme disponible (le user peut quand même
    // intervenir entre 2 départs).
    const reservedAllDay = tech.interventions.some(iv => {
      if (iv.type !== "AL-Reservation") return false;
      const s = timeToMinutes(iv.startTime);
      const e = timeToMinutes(iv.endTime);
      if (s === null || e === null) return false;
      return s <= DAY_START && e >= DAY_END;
    });
    if (!isAbsent && !reservedAllDay) {
      available++;
    }

    const real = tech.interventions.filter(iv =>
      iv.type !== "AL-Absence" && !iv.isPompier
    );
    for (const iv of real) {
      totalInterventions++;
      const s = timeToMinutes(_ivShownStart(iv));
      if (s !== null && s < 12 * 60) morning++;
      else if (s !== null) afternoon++;
      // v2026.5.46 — rideau horaire : on ne COMPTE le verdict (fait/clos)
      // dans les stats que s'il est révélé (12h matin / 15h aprèm), pour rester
      // cohérent avec le ✓/✓✓ masqué sur les cartes. Sinon le compteur de la
      // barre de stats trahissait le verdict de l'après-midi avant 15h.
      if (_isVerdictRevealed(iv)) {
        const isStClosed = isClosedStatus(iv.status);
        const isStResolved = isResolvedStatus(iv.status);
        if (isStClosed) closed++;
        else if (isStResolved) resolved++;
        // compter les "faits" — englobe les ✓✓ (closed) ET les ✓ (done /
        // suspended) du verdict v2.
        const vs = ivVStatus(iv);
        const isDone = isStClosed || isStResolved ||
          vs === "closed" || vs === "done" || vs === "suspended";
        if (isDone) done++;
      }
    }
  }
  return { totalTechs: techs.length, available, pompiers, absents, totalInterventions, morning, afternoon, closed, resolved, done };
}

function renderStats(s) {
  const el = document.getElementById("stats");
  el.innerHTML = `
    <span class="global-stat global-stat-main"><b>${s.totalInterventions}</b> intervention${s.totalInterventions > 1 ? "s" : ""}</span>
    <span class="global-stat global-stat-sub">(${s.morning} matin · ${s.afternoon} après-midi)</span>
    ${(s.done > 0) ? `<span class="global-stat-sep">·</span><span class="global-stat"><b>${s.done}</b> fait${s.done > 1 ? "s" : ""}</span>` : ""}
    ${(s.closed + s.resolved > 0) ? `<span class="global-stat-sep">/</span><span class="global-stat"><b>${s.closed + s.resolved}</b> clos</span>` : ""}
    <span class="global-stat-sep global-stat-sep-keep global-stat-sep-after-clos">//</span>
    <span class="global-stat" title="Techs réellement disponibles aujourd'hui (hors absents et réservés toute la journée — les pompiers comptent)"><b>${s.available}</b> tech. dispo</span>
    <span class="global-stat-sep global-stat-sep-keep sep-pompier">+</span>
    <span class="global-stat"><b>${s.pompiers}</b> pompier${s.pompiers > 1 ? "s" : ""}</span>
    <span class="global-stat-sep sep-absent">/</span>
    <span class="global-stat"><b>${s.absents}</b> absent${s.absents > 1 ? "s" : ""}</span>
    ${(() => {
      // v2026.5.46 — pompier couvrant la date affichée (période début→fin).
      const pm = _pompierForDate(state.currentDate || todayISO());
      return (pm && pm.name)
        ? `<span class="global-stat-sep global-stat-sep-keep">//</span><span class="global-stat global-stat-pompier-mois" title="Technicien pompier pour la période couvrant le jour affiché">🚒 Pompier du mois : <b>${escapeHtml(pm.name)}</b></span>`
        : "";
    })()}
  `;
  el.classList.remove("hidden");
  // v2026.5.46 — bouton « Mes actions » (mode coordinateur) : rendu dans la
  // 3e colonne (#topline-coord), calé complètement À DROITE de la ligne (avant il
  // était dans #stats à gauche, et margin-left:auto ne poussait plus rien depuis
  // que #stats est en largeur-contenu dans la grille).
  const coordEl = document.getElementById("topline-coord");
  if (coordEl) {
    coordEl.innerHTML = COORDINATOR_MODE
      ? `<button type="button" id="my-actions-badge" class="my-actions-badge" title="Mes actions : interventions où j'ai une action. Cliquer pour la liste."><span class="fa-light fa-list-ul" aria-hidden="true">📋</span> Mes actions${(typeof _myActionsCount === "number") ? ` <b>${_myActionsCount}</b>` : ""}</button>`
      : "";
  }
  // v2026.5.46 — révèle la barre de recherche (sous le sélecteur de date, à la
  // hauteur des stats) et l'initialise une seule fois.
  const _searchZone = document.getElementById("search-zone");
  if (_searchZone) _searchZone.classList.remove("hidden");
  if (typeof initSearchBar === "function") initSearchBar();
  if (typeof _srSyncTopbarHeight === "function") _srSyncTopbarHeight();
  // v2026.5.46 — clic sur le badge "Mes actions" → liste détaillée.
  // Et au 1er affichage du badge, on déclenche le fetch du compteur (sans modal).
  if (COORDINATOR_MODE) {
    const mab = document.getElementById("my-actions-badge");
    if (mab) mab.addEventListener("click", openMyActionsTab);
    if (_myActionsCount === null && !_myActionsLoading) _loadMyActions();
  }
}

// v2026.5.46 — page "Mes actions" : liste (haut→bas) des interventions où le
// coordinateur a une action. POUR L'INSTANT on ne construit que la STRUCTURE
// (colonnes) ; le contenu réel sera branché depuis la page EV "Mes actions"
// (General_MyActionsItem). Colonnes demandées dans l'ordre.
const MY_ACTIONS_COLUMNS = ["N°", "Situation", "Nb appels", "Contact", "Adresse", "SLO", "Date intervention", "Suspension", "Commentaire"];

// URL de la page EV "Mes actions" (filtre À faire). q2_f/q2_r = GUID du filtre
// (relevés sur la session ; ajustables si EV change).
// v2026.5.46 — fetchFiche/fetchFicheHtml construit déjà `${origin}/index.php?
// ${formLink}&PHPSESSID=…`. On ne renvoie donc QUE la query (sinon double URL).
function _myActionsUrl() {
  const F = "%7BF400EEA4-E1A4-44FF-A8D1-FD690103ADD1%7D";
  const R = "%7B43282140-F301-412C-A07F-73D83908985E%7D";
  return `eventName=General_MyActionsItem&q2_f=${F}&q2_r=${R}`;
}
// Fetch + parse de la page "Mes actions" PAR L'EXTENSION (réutilise fetchFiche).
// Récupère le compteur ("A faire : N") + les n° d'intervention de la grille.
// v2026.5.46 — vraie source de données : (1) GET de la coquille pour extraire
// les jetons (dialogGuid + checksums, qui changent à chaque chargement), (2) POST
// sur l'API ag-Grid /api/v1/internal/evGrid/<GRID_ID> qui renvoie {rowData:[…]}.
const MYACTIONS_GRID_ID = "EB1A169E-7D69-4A35-9E94-6271BE116AC5";
const MYACTIONS_FILTER_ID = "{F400EEA4-E1A4-44FF-A8D1-FD690103ADD1}"; // = q2_f
const MYACTIONS_VIEW_ID = "{43282140-F301-412C-A07F-73D83908985E}";   // = q2_r
async function _loadMyActions(opts = {}) {
  if (_myActionsLoading) return;
  _myActionsLoading = true;
  const _setDiag = (s) => { _myActionsDiag = s; const d = document.getElementById("myactions-diag"); if (d) d.textContent = s; };
  try {
    // Session (origine + PHPSESSID).
    let s = state.session;
    if (!s || !s.origin || !s.phpsessid) { const r = await sendMessage({ type: "getSession" }); s = (r && r.session) || s; }
    if (!s || !s.origin || !s.phpsessid) { _setDiag("Pas de session EasyVista active."); return; }

    // 1) Coquille → jetons dialogGuid + checksum/2/3 (changent à chaque chargement).
    const resp = await sendMessage({ type: "fetchFiche", formLink: _myActionsUrl() });
    const html = resp && resp.ok ? (resp.html || "") : "";
    if (!html) { _setDiag(`Échec coquille (err=${(resp && resp.error) || "?"}). Session active ?`); return; }
    const mGuid = html.match(/dialogGuid["']?\s*:\s*["']({[^}]+})["']/);
    const mC1 = html.match(/"checksum"\s*:\s*"([0-9a-f]{40})"/);
    const mC2 = html.match(/"checksum2"\s*:\s*"([0-9a-f]{40})"/);
    const mC3 = html.match(/"checksum3"\s*:\s*"([0-9a-f]{40})"/);
    if (!mGuid || !mC1) { _setDiag(`Jetons introuvables (dialogGuid=${!!mGuid}, checksum=${!!mC1}) — regex à caler.`); return; }

    // 2) POST API evGrid → rowData (les vraies lignes filtrées "À faire").
    const body = {
      endRow: 50, rowGroupCols: [], valueCols: [], pivotCols: [], pivotMode: false, groupKeys: [],
      filterModel: {}, clearAll: false, pageDirection: "first", advancedFilter: {},
      sortModel: [{ sort: "asc", colId: "C6ksSK0Jiw92iQ9yDQx1DQ6JD4kMcI139vfxD9JDMAE=0" }],
      parameters: {
        filterId: MYACTIONS_FILTER_ID, viewId: MYACTIONS_VIEW_ID, taskGuid: "", dialogGuid: mGuid[1],
        showGridLineNumbers: false, eventName: "General_MyActionsItem",
        dynamicFilter: null, hasDynamicFields: false, userFilterId: null, metaObjectGuid: null,
        searchSqlValue: null, hasShowGridLineNumbersChanged: false,
        filterEditor: {
          guid: "new", displayDynamicFilter: false, context: "evGrid", filter_name: "",
          id_q: MYACTIONS_GRID_ID, checksum: mC1[1], checksum2: mC2 ? mC2[1] : "", checksum3: mC3 ? mC3[1] : "",
          filterChanged: false
        },
        autoDrillDownType: "NONE"
      },
      refresh: false, barcodes: null,
      drillDownModel: { expandLevel: 0, currentLevel: 0, lastLevel: 0, nextLevel: 1, canDrillDown: false, currentDrillDown: null, displayMode: null }
    };
    const apiUrl = `${s.origin}/api/v1/internal/evGrid/${MYACTIONS_GRID_ID}?PHPSESSID=${encodeURIComponent(s.phpsessid)}`;
    const r2 = await fetch(apiUrl, { method: "POST", credentials: "include", headers: { "Content-Type": "application/json; charset=utf-8" }, body: JSON.stringify(body) });
    if (!r2.ok) { _setDiag(`API evGrid : HTTP ${r2.status}`); LOG.warn("myactions", "evGrid HTTP", { status: r2.status }); return; }
    const j = await r2.json();
    const rowData = (j && Array.isArray(j.rowData)) ? j.rowData : [];
    // N° d'action = la seule valeur string au format S…_… / I…_… dans la ligne.
    const rows = [];
    for (const row of rowData) {
      const num = Object.values(row || {}).find(v => typeof v === "string" && /^[SI]\d+_\d+$/.test(v));
      if (num) rows.push({ numero: num });
    }
    _myActionsRows = rows;
    _myActionsCount = rows.length;
    const id = _effectiveIdentity();
    const diag = `OK · rowData=${rowData.length} · n° parsés=${rows.length} · compteur=${_myActionsCount} · identité=${id.impersonated ? "SIMULÉE(" + (id.name || id.initials || id.memberId) + ")" : "réelle"}`;
    _setDiag(diag);
    LOG.info("myactions", diag);
    if (state.currentData) { try { renderFromData(state.currentData); } catch (e) {} }
    const tbody = document.getElementById("my-actions-tbody");
    if (tbody) _fillMyActionsTable(tbody);
    // Enrichissement (Partie A) : seulement dans l'onglet dédié (lourd : 1 fetch/fiche).
    if (opts.enrich) await _enrichMyActionsRows();
  } catch (e) {
    _setDiag("Erreur : " + ((e && e.message) || e));
    LOG.warn("myactions", "fetch Mes actions échoué", { err: e && e.message });
  } finally { _myActionsLoading = false; }
}
// Remplit le <tbody> de la modal avec les lignes parsées. N° cliquable (ouvrir
// l'intervention) + copie. Les autres colonnes restent à brancher.
function _fillMyActionsTable(tbody) {
  tbody.innerHTML = "";
  if (_myActionsRows === null) {
    const tr = document.createElement("tr"); const td = document.createElement("td");
    td.colSpan = MY_ACTIONS_COLUMNS.length; td.className = "my-actions-empty"; td.textContent = "Chargement…";
    tr.appendChild(td); tbody.appendChild(tr); return;
  }
  if (!_myActionsRows.length) {
    const tr = document.createElement("tr"); const td = document.createElement("td");
    td.colSpan = MY_ACTIONS_COLUMNS.length; td.className = "my-actions-empty"; td.textContent = "Aucune action trouvée sur la page Mes actions.";
    tr.appendChild(td); tbody.appendChild(tr); return;
  }
  const _td = (val, wrap) => {
    const td = document.createElement("td");
    td.textContent = (val === undefined || val === null || val === "") ? "—" : String(val);
    if (wrap) { td.style.whiteSpace = "normal"; td.style.maxWidth = "340px"; }
    return td;
  };
  for (const r of _myActionsRows) {
    const tr = document.createElement("tr");
    // col 0 — N° (cliquable + copie)
    const tdNum = document.createElement("td");
    const openBtn = document.createElement("button"); openBtn.type = "button"; openBtn.className = "my-actions-num"; openBtn.textContent = r.numero; openBtn.title = "Ouvrir l'intervention";
    openBtn.addEventListener("click", () => _openInterventionByRef(r.numero));
    const copyB = document.createElement("button"); copyB.type = "button"; copyB.className = "tooltip-edit-btn"; copyB.style.cssText = "padding:1px 6px; margin-left:6px;"; copyB.textContent = "📋"; copyB.title = "Copier le n°";
    copyB.addEventListener("click", (e) => { e.stopPropagation(); copyRef(r.numero, copyB); });
    tdNum.appendChild(openBtn); tdNum.appendChild(copyB);
    tr.appendChild(tdNum);
    const loading = r.enriching ? "…" : undefined;
    tr.appendChild(_td(loading !== undefined ? loading : r.situation));                       // 1 Situation
    tr.appendChild(_td(loading !== undefined ? loading : (r.nbAppels != null ? r.nbAppels : undefined))); // 2 Nb appels
    tr.appendChild(_td(loading !== undefined ? loading : r.contact));                          // 3 Contact
    tr.appendChild(_td(loading !== undefined ? loading : r.adresse));                          // 4 Adresse
    tr.appendChild(_td(loading !== undefined ? loading : r.slo));                              // 5 SLO
    tr.appendChild(_td(loading !== undefined ? loading : r.rdv));                              // 6 Date intervention
    tr.appendChild(_td(loading !== undefined ? loading : r.suspension));                       // 7 Suspension
    tr.appendChild(_td(loading !== undefined ? loading : r.commentaire, true));                // 8 Commentaire
    tbody.appendChild(tr);
  }
}
// v2026.5.46 — parse l'« Historique » du coordinateur dans le HTML d'une fiche.
// Gère le HTML rendu ET la forme JSON échappée (\\uXXXX). Renvoie {nbAppels, rdv,
// commentaire} ou null si pas d'historique.
function _parseHistorique(html) {
  let txt = html
    .replace(/\\u([0-9a-fA-F]{4})/g, (m, h) => String.fromCharCode(parseInt(h, 16)))
    .replace(/\\\//g, "/")
    .replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, " ")
    .replace(/&nbsp;/g, " ").replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&")
    .replace(/​/g, "");
  const i = txt.search(/Historique\s*:/i);
  if (i < 0) return null;
  const seg = txt.slice(i, i + 1800);
  const lines = seg.split("\n").map(x => x.replace(/[ \t]+/g, " ").trim())
    .filter(x => /^\d{1,2}[\/.]\d{1,2}[\/.]\d{2,4}/.test(x));
  if (!lines.length) return null;
  let rdv = "";
  for (const l of lines) {
    const m = l.match(/RDV\s*(?:le\s*)?:?\s*(\d{1,2}[\/.]\d{1,2}(?:[\/.]\d{2,4})?)/i);
    if (m) rdv = m[1];
  }
  return { nbAppels: lines.length, rdv, commentaire: lines.join(" · ") };
}

// v2026.5.46 — enrichit chaque ligne « Mes actions » : fetch de la fiche →
// Historique (Nb appels, RDV, commentaire) + adresse (LOCATION_FR) + contact
// (bénéficiaire). Séquentiel, avec logs détaillés (visibles en mode debug).
async function _enrichMyActionsRows() {
  if (!_myActionsRows || !_myActionsRows.length) return;
  const id = _effectiveIdentity();
  LOG.info("myactions", `enrichissement de ${_myActionsRows.length} fiche(s) — identité ${id.impersonated ? "SIMULÉE" : "réelle"} : ${id.name || id.initials || id.memberId || "(courant)"}`);
  for (const row of _myActionsRows) {
    row.enriching = true;
    let tb = document.getElementById("my-actions-tbody"); if (tb) _fillMyActionsTable(tb);
    try {
      const formLink = await getFreshFicheFormLinkForRef(row.numero);
      if (!formLink) { LOG.warn("myactions", `${row.numero} : formLink introuvable`); row.enriching = false; continue; }
      const resp = await sendMessage({ type: "fetchFiche", formLink });
      const html = resp && resp.ok ? (resp.html || "") : "";
      if (!html) { LOG.warn("myactions", `${row.numero} : fiche vide (err=${resp && resp.error})`); row.enriching = false; continue; }
      const h = _parseHistorique(html);
      let adresse = "";
      const locM = html.match(/"dbFieldName"\s*:\s*"[^"]*LOCATION[^"]*"[^}]*?"value"\s*:\s*"([^"]{3,160})"/i);
      if (locM) adresse = (typeof decodeJsonString === "function" ? decodeJsonString(locM[1]) : locM[1]).replace(/\\\//g, "/").trim();
      let contact = "";
      const benM = html.match(/"dbFieldName"\s*:\s*"E_BEN_CA"[^}]*?"value"\s*:\s*"([^"]{2,80})"/i)
        || html.match(/"dbFieldName"\s*:\s*"LAST_NAME"[^}]*?"value"\s*:\s*"([^"]{2,80})"/i);
      if (benM) contact = (typeof decodeJsonString === "function" ? decodeJsonString(benM[1]) : benM[1]).trim();
      row.nbAppels = h ? h.nbAppels : 0;
      row.rdv = h ? h.rdv : "";
      row.commentaire = h ? h.commentaire : "";
      row.adresse = adresse;
      row.contact = contact;
      row.enriching = false;
      LOG.info("myactions", `${row.numero} : historique=${h ? "oui" : "NON"} · appels=${row.nbAppels} · rdv='${row.rdv}' · adresse='${adresse}' · contact='${contact}' · fiche=${html.length}o`);
      tb = document.getElementById("my-actions-tbody"); if (tb) _fillMyActionsTable(tb);
    } catch (e) {
      row.enriching = false;
      LOG.warn("myactions", `${row.numero} : erreur enrichissement`, { err: e && e.message });
    }
  }
  LOG.info("myactions", "enrichissement terminé.");
}

// v2026.5.46 — clic sur le badge → ouvre un NOUVEL ONGLET (page de l'extension
// viewer.html?view=myactions), en plus de l'onglet planning. Aucune fenêtre EV.
function openMyActionsTab() {
  try {
    const url = chrome.runtime.getURL("viewer.html?view=myactions");
    window.open(url, "_blank");
  } catch (e) {
    LOG.warn("myactions", "ouverture onglet échouée", { err: e && e.message });
  }
}

// v2026.5.46 — rendu de la page dédiée "Mes actions" (dans son propre onglet).
// Réutilise le fetch/parse (_loadMyActions + _fillMyActionsTable).
async function initMyActionsPage() {
  try { await initTheme(); } catch (e) {}
  document.title = "Mes actions — Planification";
  document.body.innerHTML = `
    <div class="myactions-page">
      <div class="myactions-page-head">
        <h1 class="myactions-page-title">📋 Mes actions</h1>
        <button type="button" id="myactions-refresh" class="btn btn-secondary">↻ Rafraîchir</button>
      </div>
      <div id="myactions-diag" class="myactions-diag">Chargement…</div>
      <div class="my-actions-table-wrap">
        <table class="my-actions-table">
          <thead><tr>${MY_ACTIONS_COLUMNS.map(c => `<th>${escapeHtml(c)}</th>`).join("")}</tr></thead>
          <tbody id="my-actions-tbody"></tbody>
        </table>
      </div>
    </div>`;
  const tbody = document.getElementById("my-actions-tbody");
  _fillMyActionsTable(tbody);
  // Récupérer la session (cet onglet est neuf) puis charger.
  try {
    const resp = await sendMessage({ type: "getSession" });
    if (resp && resp.session) state.session = resp.session;
  } catch (e) {}
  _loadMyActions({ enrich: true });
  const rb = document.getElementById("myactions-refresh");
  if (rb) rb.addEventListener("click", () => { _myActionsRows = null; _myActionsCount = null; _fillMyActionsTable(tbody); _loadMyActions({ enrich: true }); });
}

function renderCards(data) {
  const container = document.getElementById("cards");
  container.innerHTML = "";

  // v2026.5.46 — mode « échelle exacte » : la règle des heures est rendue
  // UNE fois en tête de liste (sticky). Construite même en vue classique
  // (masquée par CSS) : le toggle classique/horizontal ne re-rend pas.
  if (HORIZONTAL_EXACT_MODE && typeof _buildExactRuler === "function") {
    container.appendChild(_buildExactRuler());
  }

  // Tri : pompier(s) > actifs alphabétique nom de famille > absents alphabétique
  const sorted = [...data.techs].sort((a, b) => compareTechs(a, b, data.targetDate));
  for (const tech of sorted) {
    container.appendChild(buildCard(tech, data.targetDate));
  }

  // v2026.5.46 — caler la règle des heures sur la géométrie réelle des
  // bandes, une fois le layout posé.
  // v2026.5.46 — et REPOSER la ligne « maintenant » : chaque rendu vide
  // #cards (la ligne est détruite avec) et le tick d'horloge ne la remettait
  // que toutes les 30 s → elle manquait longtemps après chaque chargement.
  if (HORIZONTAL_EXACT_MODE && typeof _alignExactRuler === "function") {
    requestAnimationFrame(() => { _alignExactRuler(); if (typeof _layoutExactGrid === "function") _layoutExactGrid(); if (typeof updateNowLine === "function") updateNowLine(); });
  } else if (typeof updateNowLine === "function") {
    requestAnimationFrame(() => updateNowLine());
  }
}

function compareTechs(a, b, targetDate) {
  const aP = a.interventions.some(iv => iv.isPompier);
  const bP = b.interventions.some(iv => iv.isPompier);
  if (aP && !bP) return -1;
  if (bP && !aP) return 1;

  const aAbs = isTechAbsent(a, targetDate);
  const bAbs = isTechAbsent(b, targetDate);
  if (aAbs && !bAbs) return 1;
  if (bAbs && !aAbs) return -1;

  // Sinon : alphabétique sur le nom de famille
  // Les noms sont stockés au format "Nom, Prénom"
  const aLast = (a.name || "").split(",")[0].trim();
  const bLast = (b.name || "").split(",")[0].trim();
  return aLast.localeCompare(bLast, "fr");
}

// v5.0.13 : un tech est considéré "absent toute la journée" uniquement si une
// absence couvre RÉELLEMENT du matin au soir (ou quasi), pas juste s'il a des
// absences (éventuellement partielles). Avant, une absence matin 08-12 seule
// faisait passer le tech en "absent toute la journée" car il n'avait QUE des
// absences. Maintenant on check explicitement que l'absence couvre ≥ 90% de
// la plage AFFICHÉE (DAY_START-DAY_END, réglable ; 8h-18h par défaut).
function isTechAbsent(tech, isoDate) {
  const recurring = RECURRING_ABSENCES[tech.id];
  if (recurring && isoDate) {
    const day = isoToDate(isoDate).getDay();
    if (recurring.includes(day)) return true;
  }
  if (tech.interventions.length === 0) return false;
  const { dayS, dayE, dayLen } = _dayRange();   // invariant : hors de la boucle (tri à chaud)
  const TRAVAIL_DEBUT = 8 * 60, TRAVAIL_FIN = 18 * 60;   // journée de travail standard
  // Parmi les absences (hors pompier), est-ce qu'une seule couvre la journée ?
  const fullDayAbsences = tech.interventions.filter(iv => {
    if (iv.type !== "AL-Absence" || iv.isPompier) return false;
    const startMin = timeToMinutes(iv.startTime);
    const endMin = timeToMinutes(iv.endTime);
    if (startMin == null || endMin == null) {
      // Si on n'a pas d'horaires, on considère que c'est toute la journée
      // (cas des absences multi-jours sans horaires précis)
      return true;
    }
    // Absence couvre toute la journée si son créneau déborde largement
    // la plage affichée (≥ 90%). Une demi-journée (4h) sur 10h = 40% → ne
    // passera pas, donc on ne marquera pas le tech comme absent toute la journée.
    // v2026.5.46 — « toute la journée » se juge sur DEUX plages ; il
    // suffit d'en couvrir une à 90 % ou plus :
    //  - la plage AFFICHÉE (DAY_START/DAY_END, réglable) : une absence qui
    //    remplit visuellement la journée à l'écran classe le tech absent
    //    (l'ancienne plage 8-18 figée créait des faux négatifs dès que les
    //    heures configurées changeaient) ;
    //  - la journée de travail STANDARD 08:00-18:00 : une absence EV posée
    //    sur toute la journée de travail reste « toute la journée » même si
    //    l'écran affiche une plage plus large (ex. 06:00-20:00).
    const covAffichee = Math.max(0, Math.min(endMin, dayE) - Math.max(startMin, dayS));
    const covTravail = Math.max(0, Math.min(endMin, TRAVAIL_FIN) - Math.max(startMin, TRAVAIL_DEBUT));
    return covAffichee >= 0.9 * dayLen || covTravail >= 0.9 * (TRAVAIL_FIN - TRAVAIL_DEBUT);
  });
  return fullDayAbsences.length > 0;
}

// ============================================================================
// Construction d'une carte
// ============================================================================

// v2026.5.41 : générique. Plus aucun nom hardcodé. Lit cfg.recurringAbsences
// (chargé depuis admin_config) : pour chaque tech.id, un tableau de jours JS
// (0=dim, 1=lun, …, 6=sam) où il est marqué absent récurrent.
function isRecurringAbsence(tech, isoDate) {
  if (!tech || !tech.id) return false;
  const days = RECURRING_ABSENCES[tech.id];
  if (!Array.isArray(days) || days.length === 0) return false;
  const day = isoToDate(isoDate).getDay();
  return days.includes(day);
}

// Libellé "Absent le <jour>" — calculé depuis la date au lieu d'être hardcodé.
function _recurringAbsenceLabel(isoDate) {
  const names = ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"];
  return "Absent le " + names[isoToDate(isoDate).getDay()];
}

// v2026.5.46 — menu contextuel (clic droit) sur le nom d'un technicien :
// ouvre directement Réservation / Absence / Pompier / Sync douchette avec CE
// tech pré-sélectionné (la liste/sélecteur de tech est masquée dans la modal).
// Les boutons « Ajouter » du haut restent inchangés.  Auteur : Quentin Rouiller.
let _techCtxMenuEl = null;
function _closeTechContextMenu() {
  if (_techCtxMenuEl) { _techCtxMenuEl.remove(); _techCtxMenuEl = null; }
  document.removeEventListener("click", _closeTechContextMenu, true);
  document.removeEventListener("contextmenu", _closeTechContextMenu, true);
  window.removeEventListener("blur", _closeTechContextMenu);
}
function showTechContextMenu(ev, techId, techName) {
  ev.preventDefault();
  ev.stopPropagation();
  _closeTechContextMenu();
  const menu = document.createElement("div");
  menu.className = "tech-context-menu";
  menu.setAttribute("role", "menu");
  const header = document.createElement("div");
  header.className = "tech-context-menu-header";
  header.textContent = techName || TEAM[String(techId)] || "Technicien";
  menu.appendChild(header);
  // Une responsabilité par entrée : (label, modal pré-sélectionnée sur ce tech).
  const items = [
    { label: "📅 Réservation", fn: () => showReservationModal(techId) },
    { label: "🌴 Absence", fn: () => showAbsenceModal(techId) },
    { label: "🚒 Pompier", fn: () => showPompierModal(techId) },
    { label: "🎯 Sync douchette", fn: () => showDouchetteModal(techId) }
  ];
  for (const it of items) {
    const btn = document.createElement("button");
    btn.type = "button";
    btn.className = "tech-context-menu-item";
    btn.textContent = it.label;
    btn.addEventListener("click", (e) => { e.stopPropagation(); _closeTechContextMenu(); it.fn(); });
    menu.appendChild(btn);
  }
  document.body.appendChild(menu);
  // Positionnement au curseur en gardant le menu dans la fenêtre (position:fixed).
  const mw = menu.offsetWidth, mh = menu.offsetHeight;
  let x = ev.clientX, y = ev.clientY;
  if (x + mw > window.innerWidth - 8) x = window.innerWidth - mw - 8;
  if (y + mh > window.innerHeight - 8) y = window.innerHeight - mh - 8;
  menu.style.left = Math.max(8, x) + "px";
  menu.style.top = Math.max(8, y) + "px";
  _techCtxMenuEl = menu;
  // Fermeture au prochain clic / clic droit ailleurs / perte de focus.
  setTimeout(() => {
    document.addEventListener("click", _closeTechContextMenu, true);
    document.addEventListener("contextmenu", _closeTechContextMenu, true);
    window.addEventListener("blur", _closeTechContextMenu);
  }, 0);
}

// v2026.5.46 — menu rapide au clic droit sur la ZONE VIDE d'une carte :
// choisir Réservation OU Absence, ouvertes avec le tech pré-sélectionné et le
// créneau libre le plus proche du curseur. Réutilise le même conteneur que le
// menu contextuel du nom (_techCtxMenuEl) → un seul menu ouvert à la fois.
function _showQuickAddMenu(ev, tech, startHHMM, endHHMM, disabledReason) {
  _closeTechContextMenu();
  const menu = document.createElement("div");
  menu.className = "tech-context-menu";
  menu.setAttribute("role", "menu");
  const header = document.createElement("div");
  header.className = "tech-context-menu-header";
  header.textContent = (tech.name || TEAM[String(tech.id)] || "Technicien") + (disabledReason ? "" : " — " + startHHMM);
  menu.appendChild(header);
  // v2026.5.46 — journée complète : les deux actions restent visibles mais
  // GRISÉES, avec la raison courte affichée sous l'en-tête.
  if (disabledReason) {
    const why = document.createElement("div");
    why.className = "tech-context-menu-reason";
    why.textContent = disabledReason;
    menu.appendChild(why);
  }
  const items = [
    { label: "📅 Réservation", fn: () => showReservationModal(tech.id, { startTime: startHHMM, endTime: endHHMM }) },
    { label: "🌴 Absence",     fn: () => showAbsenceModal(tech.id, { startTime: startHHMM, endTime: endHHMM }) }
  ];
  for (const it of items) {
    const btn = document.createElement("button");
    btn.type = "button";
    btn.className = "tech-context-menu-item";
    btn.textContent = it.label;
    if (disabledReason) {
      btn.disabled = true;
      btn.classList.add("is-disabled");
      btn.title = disabledReason;
    } else {
      btn.addEventListener("click", (e) => { e.stopPropagation(); _closeTechContextMenu(); it.fn(); });
    }
    menu.appendChild(btn);
  }
  document.body.appendChild(menu);
  const mw = menu.offsetWidth, mh = menu.offsetHeight;
  let x = ev.clientX, y = ev.clientY;
  if (x + mw > window.innerWidth - 8) x = window.innerWidth - mw - 8;
  if (y + mh > window.innerHeight - 8) y = window.innerHeight - mh - 8;
  menu.style.left = Math.max(8, x) + "px";
  menu.style.top = Math.max(8, y) + "px";
  _techCtxMenuEl = menu;
  setTimeout(() => {
    document.addEventListener("click", _closeTechContextMenu, true);
    document.addEventListener("contextmenu", _closeTechContextMenu, true);
    window.addEventListener("blur", _closeTechContextMenu);
  }, 0);
}

/**
 * Construit la card HTML d'un technicien (header, timeline, interventions, absences).
 *
 * @author Quentin Rouiller
 */
function buildCard(tech, isoDate) {
  const card = document.createElement("section");
  card.className = "card";
  card.dataset.techId = tech.id;

  // v2026.5.46 — clic droit "entre les cases" (zone vide de la carte) →
  // modal Réservation directe : tech pré-sélectionné (on est sur sa ligne, la
  // liste est masquée) + heure de début = créneau LIBRE le plus proche du
  // curseur (même projection que le drag&drop), durée 1 h par défaut.
  // Le clic droit sur le NOM garde son menu (stopPropagation), et sur une
  // intervention/mini-card on laisse le menu natif du navigateur.
  card.addEventListener("contextmenu", (ev) => {
    if (ev.target.closest(".intervention-v2, .iv-mini-card, .tech-context-menu")) return;
    ev.preventDefault();
    ev.stopPropagation();
    // v2026.5.46 — ferme la petite popup de survol des trous (« temps
    // disponible ») qui resterait affichée sous le menu.
    try { _cancelPendingTimelinePopover(); _cancelPendingShowTooltip(); hideTooltip(); } catch (e) { /* ignore */ }
    const isHorizontal = document.documentElement.classList.contains("view-horizontal");
    let startMin = null;
    // v2026.5.46 — mode exact : la bande est une projection linéaire du
    // temps -> l'heure proposée = l'heure sous le curseur (snap 30 min).
    if (HORIZONTAL_EXACT_MODE && isHorizontal && typeof _cursorToTimeOnTimeline === "function") {
      const exactRow = card.querySelector(".iv-exact-row");
      if (exactRow) {
        const t = _cursorToTimeOnTimeline(exactRow, ev.clientX);
        if (t) startMin = t.totalMin;
      }
    }
    const bar = ev.target.closest(".timeline-bar") || (ev.target.closest(".timeline") ? card.querySelector(".timeline-bar") : null);
    if (startMin == null && bar && typeof _cursorToTimeOnTimeline === "function") {
      const t = _cursorToTimeOnTimeline(bar, ev.clientX);
      if (t) startMin = t.totalMin;
    }
    if (startMin == null && typeof _cardCursorToProjectedStart === "function") {
      startMin = _cardCursorToProjectedStart(card, ev, 60, isHorizontal, { noVirtualPeriods: true });
    }
    const { dayS, dayE } = _dayRange();
    if (startMin == null) startMin = dayS;
    startMin = Math.max(dayS, Math.min(startMin, dayE - 30));
    const endMin = Math.min(startMin + 60, dayE);
    // v2026.5.46 — journée déjà COMPLÈTE (l'union des créneaux affichés
    // couvre toute la plage) → le menu s'affiche quand même, mais boutons
    // grisés avec la raison.
    let disabledReason = null;
    {
      // v2026.5.46 — seules les INTERVENTIONS et RÉSERVATIONS occupent la
      // journée : une absence (AL-Absence, récurrente…) ne bloque PAS la pose
      // d'une réservation/congé (le menu restait grisé « Journée complète »
      // sur un tech absent dont la carte était pourtant vide).
      const spans = (tech.interventions || [])
        .filter(iv2 => iv2.type === "AL-Intervention" || iv2.type === "AL-Reservation")
        .map(iv2 => [timeToMinutes(_ivShownStart(iv2)), timeToMinutes(_ivShownEnd(iv2))])
        .filter(p => p[0] !== null && p[1] !== null && p[1] > p[0])
        .sort((x, y) => x[0] - y[0]);
      let cov = dayS;
      for (const p of spans) {
        if (p[0] > cov) break;
        if (p[1] > cov) cov = p[1];
      }
      if (cov >= dayE) disabledReason = "Journée complète — aucun créneau libre";
    }
    // v2026.5.47 — un rendez-vous EN ERREUR (début == fin, ex. 10:00→10:00)
    // dans la zone qu'on créerait → on BLOQUE le menu (boutons grisés) pour
    // forcer sa correction avant d'empiler un autre RDV par-dessus (prioritaire
    // sur « journée complète »).
    for (const iv2 of (tech.interventions || [])) {
      if (iv2.type !== "AL-Intervention") continue;
      const s2 = timeToMinutes(_ivShownStart(iv2));
      const e2 = timeToMinutes(_ivShownEnd(iv2));
      if (s2 === null || e2 === null || e2 > s2) continue;   // pas une erreur durée nulle
      if (s2 >= startMin && s2 <= endMin) {
        disabledReason = "Rendez-vous en erreur (début = fin) à corriger d'abord";
        break;
      }
    }
    LOG.info("reservation", `clic droit carte → menu rapide`, { techId: tech.id, startMin, endMin, bloque: disabledReason || false });
    _showQuickAddMenu(ev, tech, _minToHHMMSafe(startMin), _minToHHMMSafe(endMin), disabledReason);
  });

  const isPompier = tech.interventions.some(iv => iv.isPompier);
  const isAbsent = isTechAbsent(tech, isoDate);
  // v2026.5.41 : absence récurrente générique (configurée par tech dans
  // Paramètres → Équipe). Code couleur cyan (comme Congé).
  const isRecurring = isRecurringAbsence(tech, isoDate);
  // v2026.5.46 — pas de DOUBLON absence récurrente + vraie absence : si le
  // tech a une VRAIE absence EV ce jour (congé/maladie, hors pompier), on
  // n'affiche PAS en plus l'absence récurrente configurée (la vraie prime).
  // showRecurring pilote fond, badge et note « Absent le <jour> ».
  const hasRealAbsence = tech.interventions.some(iv => iv.type === "AL-Absence" && !iv.isPompier);
  const showRecurring = isRecurring && !hasRealAbsence;

  if (isPompier) card.classList.add("is-pompier");
  if (isAbsent) card.classList.add("is-absent");

  // v2026.5.27 : déterminer la catégorie d'absence principale (maladie/conge/pompier)
  // pour appliquer le bon code couleur sur la carte entière.
  // v2026.5.30 : les absences récurrentes hardcodées prennent la catégorie
  //              "recurring" (même cyan que Congé, texte distinct).
  let absenceCategory = null;  // "maladie" | "conge" | "pompier" | "recurring" | null
  if (showRecurring) {
    absenceCategory = "recurring";
  } else if (isPompier) {
    absenceCategory = "pompier";
  } else if (isAbsent) {
    const catBlock = tech.interventions.find(iv => iv.type === "AL-Absence" && iv.absenceCategory);
    if (catBlock) absenceCategory = catBlock.absenceCategory;
  }
  if (absenceCategory) {
    card.classList.add("absence-cat-" + absenceCategory);
  }

  // (issue #1) : un tech peut être Pompier ET avoir une autre absence
  // (maladie, congé, etc.). Avant, le statut Pompier masquait l'absence.
  // On capte ici la catégorie de l'absence NON-pompier pour pouvoir afficher
  // les deux côte à côte.
  let extraAbsenceCategory = null;
  let extraAbsenceBlock = null;
  if (isPompier && isAbsent) {
    const real = tech.interventions.find(iv => iv.type === "AL-Absence" && !iv.isPompier);
    if (real) {
      extraAbsenceBlock = real;
      extraAbsenceCategory = real.absenceCategory || "absent";
    }
  }
  if (extraAbsenceCategory) {
    card.classList.add("absence-cat-" + extraAbsenceCategory);
  }

  const realInterventions = tech.interventions.filter(iv =>
    iv.type !== "AL-Absence" && !iv.isPompier
  );
  const absenceBlocks = tech.interventions.filter(iv => iv.type === "AL-Absence");
  const pompierBlocks = tech.interventions.filter(iv => iv.isPompier);

  // v2026.5.41 : conflit absence/réservation × intervention.
  // Si une intervention est planifiée alors que le tech a une absence (non-pompier)
  // ou une réservation au même créneau, on marque la carte de l'intervention en
  // rouge plein. Cas full-day : toutes les interv réelles sont marquées.
  const conflictPeriods = [];
  for (const iv of tech.interventions) {
    const isAbsenceConflict = iv.type === "AL-Absence" && !iv.isPompier;
    const isReservationConflict = iv.type === "AL-Reservation";
    if (!isAbsenceConflict && !isReservationConflict) continue;
    const s = timeToMinutes(_ivShownStart(iv));
    const e = timeToMinutes(_ivShownEnd(iv));
    if (s === null || e === null) {
      // Pas d'horaires précis → on considère que ça couvre toute la journée
      conflictPeriods.push([DAY_START, DAY_END]);
    } else {
      conflictPeriods.push([s, e]);
    }
  }
  // Absence récurrente ce jour ou full-day → toute la journée est en conflit
  if (isAbsent || isRecurring) {
    conflictPeriods.push([DAY_START, DAY_END]);
  }
  // Stamp chaque intervention réelle (uniquement type AL-Intervention)
  for (const iv of realInterventions) {
    if (iv.type !== "AL-Intervention") { iv._absenceConflict = false; continue; }
    const ivS = timeToMinutes(_ivShownStart(iv));
    const ivE = timeToMinutes(_ivShownEnd(iv));
    if (ivS === null || ivE === null) { iv._absenceConflict = false; continue; }
    iv._absenceConflict = conflictPeriods.some(([cs, ce]) => ivS < ce && ivE > cs);
  }

  const morning = realInterventions.filter(iv => {
    const s = timeToMinutes(_ivShownStart(iv));
    return s !== null && s < 12 * 60;
  }).length;
  const afternoon = realInterventions.length - morning;

  // --- Header ---
  const header = document.createElement("div");
  header.className = "card-header";

  // v2026.5.27 : pastille colorée supprimée (v2026.5.28) — la barre gauche de la
  // carte + le badge à droite suffisent pour indiquer la catégorie d'absence.

  const nameEl = document.createElement("div");
  nameEl.className = "card-tech-name";
  nameEl.textContent = tech.name;
  // v2026.5.40 : si le nom est très long, ajouter la classe -tight pour
  // baisser légèrement la font-size (11.5px au lieu de 13px) et lui permettre
  // de tenir sur 2-3 lignes proprement. Seuil empirique 24 chars.
  if (typeof tech.name === "string" && tech.name.length > 24) {
    nameEl.classList.add("card-tech-name-tight");
  }
  // v2026.5.46 — clic droit sur le nom → menu (résa/absence/pompier/douchette)
  // pré-sélectionnant ce tech.
  nameEl.classList.add("tech-name-ctx");
  nameEl.title = "Clic droit : réservation / absence / pompier / douchette pour ce technicien";
  nameEl.addEventListener("contextmenu", (e) => showTechContextMenu(e, tech.id, tech.name));
  header.appendChild(nameEl);

  if (isPompier || isAbsent || isRecurring) {
    // on regroupe le(s) badge(s) dans un container collé à droite
    // (flex parent .card-header est space-between, le wrapper est aligné
    // automatiquement à l'opposé du nom du tech).
    const badgeWrap = document.createElement("div");
    badgeWrap.className = "card-tech-badge-wrap";

    const badge = document.createElement("div");
    badge.className = "card-tech-badge";
    if (showRecurring) {
      badge.classList.add("badge-recurring");
      badge.textContent = "Absent";
    } else if (isPompier) {
      badge.classList.add("badge-pompier");
      badge.textContent = "Pompier";
    } else if (absenceCategory === "maladie") {
      badge.classList.add("badge-maladie");
      badge.textContent = "Maladie/Accident";
    } else if (absenceCategory === "conge") {
      const ab = absenceBlocks.find(a => a.absenceCategory === "conge") || absenceBlocks[0];
      const multiDay = ab && ab.startDate && ab.endDate && ab.startDate !== ab.endDate;
      badge.classList.add("badge-conge");
      badge.textContent = multiDay ? "Congés" : "Congé";
    } else {
      badge.classList.add("badge-absent");
      badge.textContent = "Absent";
    }
    badgeWrap.appendChild(badge);

    // /f (issue #1) : badge SUPPLÉMENTAIRE Pompier + autre absence,
    // séparé par "/" et collé à droite avec le badge principal.
    if (isPompier && extraAbsenceCategory) {
      const sep = document.createElement("span");
      sep.className = "card-tech-badge-sep";
      sep.textContent = "/";
      badgeWrap.appendChild(sep);

      const badge2 = document.createElement("div");
      badge2.className = "card-tech-badge";
      if (extraAbsenceCategory === "maladie") {
        badge2.classList.add("badge-maladie");
        badge2.textContent = "Maladie/Accident";
      } else if (extraAbsenceCategory === "conge") {
        const multiDay = extraAbsenceBlock
          && extraAbsenceBlock.startDate && extraAbsenceBlock.endDate
          && extraAbsenceBlock.startDate !== extraAbsenceBlock.endDate;
        badge2.classList.add("badge-conge");
        badge2.textContent = multiDay ? "Congés" : "Congé";
      } else {
        badge2.classList.add("badge-absent");
        badge2.textContent = "Absent";
      }
      badgeWrap.appendChild(badge2);
    }
    header.appendChild(badgeWrap);
  }

  // v2026.5.32 : stats rapides pour la vue horizontale (cachées en classique)
  // v2026.5.40 :
  //  - chiffre du total mis en évidence (plus gros) via class .stat-pill-big-num
  //  - libellé matin/aprem raccourci ("3 mat. · 4 a-midi")
  //  - PAS DE PILL si tech absent toute la journée OU réservé toute la journée
  //    (info redondante avec le badge "Absent" / "Pompier" et la timeline vide)
  const reservedAllDay = realInterventions.some(iv => {
    if (iv.type !== "AL-Reservation") return false;
    const sm = timeToMinutes(_ivShownStart(iv));
    const em = timeToMinutes(_ivShownEnd(iv));
    return sm !== null && em !== null && sm <= DAY_START && em >= DAY_END;
  });
  if (!isAbsent && !reservedAllDay) {
    const rowStats = document.createElement("div");
    rowStats.className = "tech-row-stats";
    const totalInterv = realInterventions.length;
    const pill1 = document.createElement("span");
    pill1.className = "stat-pill";
    // Chiffre en avant via span dédié (style .stat-pill-big-num)
    const numSpan = document.createElement("span");
    numSpan.className = "stat-pill-big-num";
    numSpan.textContent = String(totalInterv);
    pill1.appendChild(numSpan);
    pill1.appendChild(document.createTextNode(" intervention" + (totalInterv > 1 ? "s" : "")));
    rowStats.appendChild(pill1);
    if (morning > 0 || afternoon > 0) {
      const pill2 = document.createElement("span");
      pill2.className = "stat-pill";
      pill2.textContent = morning + " mat. · " + afternoon + " a-midi";
      rowStats.appendChild(pill2);
    }
    header.appendChild(rowStats);
  }

  card.appendChild(header);

  // --- Body ---
  const body = document.createElement("div");
  body.className = "card-body";

  // Note statut
  if (isPompier && pompierBlocks.length) {
    const note = document.createElement("div");
    note.className = "card-status-note pompier";
    const pb = pompierBlocks[0];
    if (pb.startDate && pb.endDate && pb.startDate !== pb.endDate) {
      note.textContent = `En pompier du ${pb.startDate.substring(0, 5)} au ${pb.endDate.substring(0, 5)}`;
    } else {
      note.textContent = "En pompier aujourd'hui";
    }
    body.appendChild(note);

    // (issue #1) : si tech aussi absent (autre que pompier), afficher
    // une note absence supplémentaire EN DESSOUS de la note pompier.
    if (extraAbsenceBlock) {
      const note2 = document.createElement("div");
      note2.className = "card-status-note absent";
      if (extraAbsenceCategory) note2.classList.add("absent-" + extraAbsenceCategory);
      const ab = extraAbsenceBlock;
      const multiDay = ab.startDate && ab.endDate && ab.startDate !== ab.endDate;
      const catLabel = extraAbsenceCategory === "maladie" ? "Maladie/Accident"
                     : extraAbsenceCategory === "conge"   ? (multiDay ? "Congés" : "Congé")
                     : null;
      let txt = multiDay
        ? `Absent du ${ab.startDate.substring(0, 5)} au ${ab.endDate.substring(0, 5)}`
        : "Absent toute la journée";
      if (catLabel) txt += ` — ${catLabel}`;
      note2.textContent = txt;
      body.appendChild(note2);
    }
  } else if (isAbsent && absenceBlocks.length) {
    const note = document.createElement("div");
    note.className = "card-status-note absent";
    if (absenceCategory) {
      note.classList.add("absent-" + absenceCategory);
    }
    const ab = absenceBlocks[0];
    // v2026.5.27 : libellé enrichi "Absent du XX au YY — Maladie" ou "Absent — Congé"
    const multiDay = ab.startDate && ab.endDate && ab.startDate !== ab.endDate;
    const catLabel = absenceCategory === "maladie" ? "Maladie/Accident"
                   : absenceCategory === "conge"   ? (multiDay ? "Congés" : "Congé")
                   : null;
    let txt;
    if (multiDay) {
      txt = `Absent du ${ab.startDate.substring(0, 5)} au ${ab.endDate.substring(0, 5)}`;
    } else {
      txt = "Absent toute la journée";
    }
    if (catLabel) txt += ` — ${catLabel}`;
    note.textContent = txt;
    body.appendChild(note);

    // v5.0.4 : tooltip au hover sur toute la carte absent (pas juste un
    // bouton visible). Contient : détail période + bouton supprimer si
    // c'est une absence supprimable (actionId réel, pas pompier récurrent).
    // v2026.5.33 : en vue horizontale, attacher le hover SEULEMENT au badge
    // (Congé / Maladie/Accident / Absent) pour éviter que la popup s'affiche
    // dès qu'on approche de la ligne du tech. En vue classique, on garde la
    // carte entière comme zone de hover (comportement d'origine).
    if (ab.actionId && !ab.isPompier && !ab._recurring) {
      const ivCopy = {
        ...ab,
        type: "AL-Absence"
      };
      const _isHorizontalView = () => document.documentElement.classList.contains("view-horizontal");
      // Hover sur la carte entière : actif SEULEMENT en vue classique
      card.addEventListener("mouseenter", (e) => {
        if (_isHorizontalView()) return;  // bloqué en horizontal
        showTooltip(e, ivCopy, card);
      });
      card.addEventListener("mouseleave", () => {
        if (_isHorizontalView()) return;
        hideTooltip();
      });
      // Hover sur le badge (Congé / Maladie/Accident / Absent) : actif
      // SEULEMENT en vue horizontale.
      const badgeEl = card.querySelector(".card-tech-badge");
      if (badgeEl) {
        badgeEl.addEventListener("mouseenter", (e) => {
          if (!_isHorizontalView()) return;  // bloqué en classique
          showTooltip(e, ivCopy, badgeEl);
        });
        badgeEl.addEventListener("mouseleave", () => {
          if (!_isHorizontalView()) return;
          hideTooltip();
        });
      }
    }
  }

  // v2026.5.41 : absence récurrente générique — message "Absent le <jour>".
  // v2026.5.46 : ne s'affiche QUE s'il n'y a pas déjà une vraie absence EV
  // ce jour (showRecurring) — plus de doublon « Absent le vendredi » + « Congé ».
  const isRecurringDay = showRecurring;

  // Absent sans interv → on stop là (après avoir posé le message récurrent si applicable).
  if (isAbsent && realInterventions.length === 0) {
    if (isRecurringDay) {
      const note = document.createElement("div");
      note.className = "tech-absence-recurring";
      note.textContent = _recurringAbsenceLabel(isoDate);
      body.appendChild(note);
    }
    card.appendChild(body);
    return card;
  }

  // v5.0.14 : si le tech n'a aucune intervention mais a des absences
  // partielles (demi-journée) ou pompier, on veut quand même afficher la
  // timeline avec les blocs absence visibles. Sans ça, une absence 08-12
  // seule n'apparaissait jamais sur la carte (affichait juste "Pas
  // d'intervention planifiée").
  const hasPartialAbsences = absenceBlocks.some(ab => {
    if (ab.isPompier) return false;
    const s = timeToMinutes(ab.startTime);
    const e = timeToMinutes(ab.endTime);
    if (s === null || e === null) return false;
    // Absence qui couvre PAS toute la journée → c'est partiel
    return !(s <= DAY_START && e >= DAY_END);
  });

  if (realInterventions.length === 0 && !isPompier && !hasPartialAbsences) {
    if (isRecurringDay) {
      const note = document.createElement("div");
      note.className = "tech-absence-recurring";
      note.textContent = _recurringAbsenceLabel(isoDate);
      body.appendChild(note);
    } else {
      const empty = document.createElement("div");
      empty.className = "card-empty";
      empty.textContent = "Pas d'intervention planifiée";
      body.appendChild(empty);
    }
    // v2026.5.46 — vue par heure : ce chemin sortait AVANT de construire
    // la bande → sur une journée totalement VIDE, pas de trous survolables
    // (« Libre 08:00–12:00 » au survol), pas de clic droit au créneau, et le
    // DROP du drag n'avait ni projection précise ni marqueur vert. On
    // construit donc la bande même vide : deux trous pleine largeur
    // (matin/après-midi, découpe à midi comme partout). La vue classique
    // garde son message « Pas d'intervention planifiée » (bande cachée).
    if (HORIZONTAL_EXACT_MODE && !isRecurringDay) {
      body.appendChild(_buildExactRow([], card, isAbsent));
    }
    card.appendChild(body);
    return card;
  }

  // Tech avec absence récurrente ce jour mais quand même des interv planifiées ? Rare mais possible.
  if (isRecurringDay && realInterventions.length > 0) {
    const note = document.createElement("div");
    note.className = "tech-absence-recurring";
    note.textContent = _recurringAbsenceLabel(isoDate);
    body.appendChild(note);
  }

  // Timeline
  body.appendChild(buildTimeline(realInterventions, pompierBlocks, absenceBlocks, card, isPompier, isAbsent));

  // v2026.5.40 : conteneur mini-cards (visible en vue horizontale uniquement
  // via CSS). Sous la timeline, alignées dans l'ordre des interventions, avec
  // une largeur proportionnelle à la durée (flex-grow), un min-width pour
  // garantir la lisibilité, et des trous représentés par des espaces vides
  // (préserve l'alignement visuel avec la timeline du dessus).
  // on inclut aussi les absences partielles (congés d'une heure ou
  // demi-journée) ET les réservations dans les mini-cards horizontales,
  // pour que le coordinateur les voie sur la vue.
  const partialAbsences = absenceBlocks.filter(iv => {
    if (iv.isPompier) return false;
    const s = timeToMinutes(_ivShownStart(iv));
    const e = timeToMinutes(_ivShownEnd(iv));
    if (s == null || e == null) return false; // multi-jours sans horaires = full
    const DAY_LEN_MIN = 10 * 60;
    const cs = Math.max(s, 8 * 60);
    const ce = Math.min(e, 18 * 60);
    const covered = Math.max(0, ce - cs);
    return covered < 0.9 * DAY_LEN_MIN;
  });
  const miniCardsList = realInterventions.concat(partialAbsences);
  // v2026.5.46 — mode « échelle exacte » : bande continue positionnée à
  // la place des blocs Matin/Après-midi. Rendue MÊME VIDE (lignes de grille +
  // trou pleine journée survolable/cliquable). Mode flux inchangé sinon.
  if (HORIZONTAL_EXACT_MODE) {
    body.appendChild(_buildExactRow(miniCardsList, card, isAbsent));
  } else if (miniCardsList.length > 0) {
    body.appendChild(_buildMiniCardsRow(miniCardsList, card));
  }

  // Stats de carte
  if (realInterventions.length > 0) {
    const stats = document.createElement("div");
    stats.className = "card-stats";
    stats.innerHTML = `
      <div class="stat-total">
        <span class="stat-total-num">${realInterventions.length}</span>
        <span class="stat-total-lbl">intervention${realInterventions.length > 1 ? "s" : ""}</span>
      </div>
      <div class="stat-split">
        <span class="stat-split-item"><b>${morning}</b> matin</span>
        <span class="stat-split-sep">·</span>
        <span class="stat-split-item"><b>${afternoon}</b> après-midi</span>
      </div>
    `;
    body.appendChild(stats);
  }

  // v2026.5.39 : séparateur Matin / Après-midi entre les interventions.
  // Les interv sont déjà triées par startTime (cf. parseXML), donc on insère
  // un séparateur dès qu'on bascule de "matin" (<12h) à "après-midi" (>=12h).
  // Si une période est vide, son séparateur n'est pas affiché.
  // (Caché en vue horizontale via CSS, vu que les rows sont masquées.)
  // refonte — on rend Matin et Après-midi en 2 blocs séparés.
  // Chaque période est TOUJOURS rendue (séparateur + iv + gaps), même
  // si elle est totalement vide → un gap-placeholder couvre alors toute
  // la période (à taille standard, pas de stretch en vue classique).
  const MID = 12 * 60;
  const _addGap = (sMin, eMin) => {
    if (sMin == null || eMin == null || eMin <= sMin) return;
    const ph = document.createElement("div");
    ph.className = "gap-placeholder";
    ph.dataset.startMin = String(sMin);
    ph.dataset.endMin = String(eMin);
    ph.dataset.kind = "hole";
    ph.textContent = "—";
    body.appendChild(ph);
    _bindGapPlaceholder(ph, card);
    if (typeof bindTimelinePopover === "function") bindTimelinePopover(ph);
  };
  // v2026.5.46 — FLUX CHRONOLOGIQUE UNIQUE (plus de découpage en deux
  // listes Matin/Après-midi) : les éléments sont rendus dans l'ordre des
  // heures AFFICHÉES, chaque carte garde toute sa place, et le séparateur
  // « Après-midi » est posé ENTRE deux éléments — jamais en coupant un
  // élément qui chevauche midi (11h→13h : la séparation se décale après lui ;
  // 8h→18h : elle disparaît, la carte occupe la journée).
  const _addSep = (periodKey, text) => {
    const sep = document.createElement("div");
    sep.className = "day-period-sep day-period-" + periodKey;
    sep.innerHTML = `<span class="day-period-label">${text}</span>`;
    body.appendChild(sep);
  };
  const _addFullGap = (sMin, eMin) => {
    // demi-journée entièrement vide → gap visible même quand l'option
    // « Afficher les pauses » est désactivée (gap-placeholder-full).
    const ph = document.createElement("div");
    ph.className = "gap-placeholder gap-placeholder-full";
    ph.dataset.startMin = String(sMin);
    ph.dataset.endMin = String(eMin);
    ph.dataset.kind = "hole";
    ph.textContent = "—";
    body.appendChild(ph);
    _bindGapPlaceholder(ph, card);
    if (typeof bindTimelinePopover === "function") bindTimelinePopover(ph);
  };

  const _renderDayFlow = (items) => {
    _addSep("morning", "Matin");

    let prev = DAY_START;
    let afternoonPosted = false;
    let renderedAny = false;
    for (const it of items) {
      const sMin = timeToMinutes(_ivShownStart(it));
      const eMin = timeToMinutes(_ivShownEnd(it));
      if (sMin === null || eMin === null) continue;
      // franchissement de midi ENTRE deux éléments → séparateur Après-midi
      if (!afternoonPosted && sMin >= MID) {
        if (prev < MID) {
          if (prev <= DAY_START && !renderedAny) _addFullGap(DAY_START, MID);
          else _addGap(prev, MID);
          prev = MID;
        }
        _addSep("afternoon", "Après-midi");
        afternoonPosted = true;
      }
      if (sMin > prev) _addGap(prev, sMin);
      body.appendChild(buildInterventionRow(it, card));
      renderedAny = true;
      if (eMin > prev) prev = eMin;
    }
    // fin de journée
    if (!afternoonPosted) {
      if (prev < MID) {
        if (prev <= DAY_START && !renderedAny) _addFullGap(DAY_START, MID);
        else _addGap(prev, MID);
        prev = MID;
      }
      if (prev < DAY_END) {
        // il reste de l'après-midi non couvert → séparateur + trou
        _addSep("afternoon", "Après-midi");
        if (prev <= MID) _addFullGap(MID, DAY_END);
        else _addGap(prev, DAY_END);
      }
      // prev >= DAY_END : un élément couvre jusqu'au soir → PAS de
      // séparateur Après-midi (la carte « prend toute la place »).
    } else if (prev < DAY_END) {
      _addGap(prev, DAY_END);
    }
  };

  // on inclut aussi les absences partielles (1 h, demi-journée) dans
  // la séquence triée par heure pour qu'elles s'affichent au bon endroit
  // chronologiquement et que les gaps les contournent.
  const allItems = realInterventions.slice();
  if (!isAbsent) {
    for (const ab of absenceBlocks) {
      if (ab.isPompier) continue;
      const s = timeToMinutes(ab.startTime);
      const e = timeToMinutes(ab.endTime);
      if (s === null || e === null) continue;
      if (s <= DAY_START && e >= DAY_END) continue; // full-day déjà géré plus haut
      allItems.push(ab);
    }
  }
  // tri par heures AFFICHÉES (multi-jours : la journée du jour courant).
  allItems.sort((a, b) => (_ivShownStart(a) || "").localeCompare(_ivShownStart(b) || ""));

  // v2026.5.46 — quand un élément couvre TOUTE la journée affichée :
  // les éléments du MATIN s'affichent D'ABORD (pilule Matin), puis ceux de
  // l'APRÈS-MIDI — sections vides OMISES (pas de « — » trompeur : la journée
  // est déjà occupée) — et la section « JOURNÉE » vient EN DERNIER.
  // Sans élément pleine journée : flux habituel (gaps + séparation décalée).
  const fullDayItems = allItems.filter(it => _ivIsFullDayShown(it));
  const restItems = allItems.filter(it => !_ivIsFullDayShown(it));
  if (!fullDayItems.length) {
    _renderDayFlow(allItems);
  } else {
    const morningRest = restItems.filter(it => { const m = timeToMinutes(_ivShownStart(it)); return m !== null && m < MID; });
    const afternoonRest = restItems.filter(it => { const m = timeToMinutes(_ivShownStart(it)); return m === null || m >= MID; });
    if (morningRest.length) {
      _addSep("morning", "Matin");
      for (const it of morningRest) body.appendChild(buildInterventionRow(it, card));
    }
    if (afternoonRest.length) {
      _addSep("afternoon", "Après-midi");
      for (const it of afternoonRest) body.appendChild(buildInterventionRow(it, card));
    }
    _addSep("day", "Journée");
    for (const it of fullDayItems) body.appendChild(buildInterventionRow(it, card));
  }

  // les absences partielles sont incluses dans allItems ci-dessus (rendues
  // par _renderDayFlow en chronologie). Pas de bloc séparé à la fin.

  // le séparateur per-card "X faites" introduit en a été retiré
  // — l'information est désormais dans la barre stats globale au format
  // "… · X faits / Y clos · …", visible aussi bien en classique qu'en
  // sidebar horizontale (où l'élément #stats est relocalisé).

  card.appendChild(body);
  return card;
}

// ============================================================================
// Timeline
// ============================================================================

// v5.0.0 : constantes timeline globales (avant : locales à buildTimeline),
// pour que updateNowLine puisse les utiliser aussi.
// v2026.5.39 : DAY_START/END deviennent let pour pouvoir être actualisées
// depuis admin_config (cfg.dayStart, cfg.dayEnd). Lecture faite au boot
// dans init(). Défaut 8h-18h.
let DAY_START = 8 * 60;     // 08:00 en minutes
let DAY_END = 18 * 60;      // 18:00 en minutes

let DAY_LEN = DAY_END - DAY_START;

// v2026.5.46 — accès canonique à la plage horaire affichée (remplace les
// copies dispersées de « typeof DAY_START === "number" ? ... : 8 * 60 » :
// une seule définition des valeurs de repli).
function _dayRange() {
  const dayS = (typeof DAY_START === "number") ? DAY_START : 8 * 60;
  const dayE = (typeof DAY_END === "number") ? DAY_END : 18 * 60;
  const dayLen = (typeof DAY_LEN === "number" && DAY_LEN > 0)
    ? DAY_LEN
    : Math.max(1, dayE - dayS);
  return { dayS, dayE, dayLen };
}
async function _initDayBoundsFromConfig() {
  try {
    const cfg = await loadAdminConfig();
    const s = (typeof cfg.dayStart === "number" && cfg.dayStart >= 0 && cfg.dayStart <= 23) ? cfg.dayStart : 8;
    const e = (typeof cfg.dayEnd === "number" && cfg.dayEnd > s && cfg.dayEnd <= 24) ? cfg.dayEnd : 18;
    DAY_START = s * 60;
    DAY_END = e * 60;
    DAY_LEN = DAY_END - DAY_START;
  } catch (err) {
    LOG.warn("dayBounds", "init failed, fallback 8h-18h", { err: err && err.message });
  }
}

// v2026.5.46 — abrège une adresse pour les cartes étroites du mode
// exact : retire le TYPE de voie et sa particule (« Rue de l'Université 5 »
// devient « Université 5 », « Av. de la Gare 14 » devient « Gare 14 »).
// Si tout disparaît (« Grand-Rue » seule), on garde l'adresse d'origine.
function _shortAddress(adresse) {
  const a = String(adresse || "").trim();
  if (!a) return "";
  const short = a.replace(
    /^\s*(?:rue|av(?:enue)?\.?|ch(?:emin)?\.?|r(?:ou)?te\.?|pl(?:ace)?\.?|b(?:oulevar)?d\.?|impasse|quai|sentier|all[ée]e|passage|promenade|esplanade|square)\s*(?:de\s+la\s+|de\s+l['’]\s*|du\s+|des\s+|de\s+|d['’]\s*|la\s+|le\s+|les\s+)?/i,
    ""
  ).trim();
  if (!short) return a;
  return short.charAt(0).toUpperCase() + short.slice(1);
}

// v2026.5.46 — fabrique d'UNE mini-carte, extraite de _buildMiniCardsRow
// pour être partagée avec le mode « échelle de temps exacte » (_buildExactRow) :
// barre couleur + heures verticales + texte (réf/ville/adresse ou libellé
// Absence/Réservation) + ✓/✓✓ + tooltip/clic/reschedule. Aucun placement ici :
// le mode flux pose ensuite un flex proportionnel, le mode exact du left/width.
// v2026.5.46 — opts.exactHandle (mode exact) : PAS de bloc d'heures (la
// position sur l'échelle donne l'heure) ; à la place, une POIGNÉE-barre à
// gauche pour les interventions déplaçables (clic = fenêtre de modification,
// glisser = drag & drop). Barre décorative pour les non-déplaçables
// (réservations, absences, faites/closes).
function _buildOneMiniCard(iv, realInterventions, cardEl, opts) {
  const colorKey = deriveColorKey(iv) || "autre";
  const ivIdx = realInterventions.indexOf(iv);
  const card = document.createElement("div");
  card.className = "iv-mini-card color-" + colorKey;
  // v2026.5.41 : conflit avec absence/réservation → mini-card rouge plein
  if (iv._absenceConflict) card.classList.add("intervention-conflict-absence");
  // conflit horaire avec une autre iv → mini-card rouge
  if (iv._hasOverlap) card.classList.add("intervention-conflict-overlap");
  card.dataset.ivIdx = String(ivIdx);
  if (iv.ref) card.dataset.ref = iv.ref;
  // actionId sur la mini-card pour permettre au reschedule de
  // localiser la mini-card source / cible en vue horizontale.
  if (iv.actionId) card.dataset.actionId = String(iv.actionId);
  if (iv.ref) card.dataset.ref = String(iv.ref);   // v2026.5.46 — surbrillance recherche par réf

  const lieu = splitLieu(iv.ficheLocation || (iv.infobulle && iv.infobulle.lieu) || iv.bulleLieu);   //
  const ville = (lieu && lieu.ville) ? lieu.ville.toUpperCase() : "";
  const adresse = (lieu && lieu.adresse) ? lieu.adresse : "";
  const ref = iv.ref || "";
  const startTime = _ivShownStart(iv);
  const endTime = _ivShownEnd(iv);
  // v2026.5.47 — intervention à durée NULLE (début == fin, ex. 10:00→10:00) :
  // erreur de saisie EV → rouge « comme un conflit » (classe iv-zero-duration).
  // Sans ça elle est invisible en vue exacte (largeur 0) et rien ne signale
  // l'erreur dans les autres vues.
  if (iv.type === "AL-Intervention") {
    const _sMin = timeToMinutes(startTime);
    const _eMin = timeToMinutes(endTime);
    if (_sMin !== null && _eMin !== null && _eMin <= _sMin) {
      card.classList.add("iv-zero-duration");
    }
  }

  // Barre couleur (4px à gauche)
  // v2026.5.46 — mode exact : pour une intervention déplaçable, la
  // barre de gauche devient la POIGNÉE de déplacement (toujours présente,
  // même sur une carte étroite — l'ancienne poignée-heures disparaissait).
  // v2026.5.46 — mode exact : le BORD GAUCHE à points colorés (poignée)
  // est présent sur TOUTES les cartes, pour un rendu uniforme. Le DÉPLACEMENT
  // n'est branché que sur les interventions déplaçables ; les faites/
  // clôturées, réservations et absences ont le même look mais restent
  // BLOQUÉES (classe -locked : curseur normal, aucun handler de drag).
  if (opts && opts.exactHandle) {
    const handle = document.createElement("div");
    handle.className = "iv-exact-handle";
    const _draggable = typeof _canRescheduleIv === "function" && _canRescheduleIv(iv)
      && typeof _attachRescheduleHandlers === "function";
    if (_draggable) {
      _attachRescheduleHandlers(handle, iv);
    } else {
      handle.classList.add("iv-exact-handle-locked");
    }
    card.appendChild(handle);
  } else {
    const bar = document.createElement("div");
    bar.className = "iv-mini-card-bar";
    card.appendChild(bar);
  }

  // v2026.5.40 : bloc heure VERTICAL (haut→bas) : 09:00 / ↓ / 10:00
  // v2026.5.46 — omis en mode exact : l'échelle et la position donnent
  // l'heure, la poignée ci-dessus porte le reschedule (le badge multi-jours
  // reste accessible au survol via le tooltip, période complète).
  if (!(opts && opts.exactHandle) && startTime && endTime) {
    const timeCol = document.createElement("div");
    timeCol.className = "iv-mini-time-vertical";
    const tStart = document.createElement("span");
    tStart.className = "iv-mini-time-start";
    tStart.textContent = startTime;
    timeCol.appendChild(tStart);
    const tArrow = document.createElement("span");
    tArrow.className = "iv-mini-time-arrow";
    tArrow.textContent = "↓";
    timeCol.appendChild(tArrow);
    const tEnd = document.createElement("span");
    tEnd.className = "iv-mini-time-end";
    tEnd.textContent = endTime;
    timeCol.appendChild(tEnd);
    // v2026.5.46 — multi-jours : badge pilule bien visible sous l'heure.
    if (ivIsMultiDay(iv)) {
      timeCol.appendChild(_makeMultiDayBadge(iv, true));
    }
    // (feature reschedule) : attach handlers sur le bloc heure
    // pour clic (modal édition) + drag (déplacement).
    if (typeof _attachRescheduleHandlers === "function") {
      _attachRescheduleHandlers(timeCol, iv);
    }
    card.appendChild(timeCol);
  }

  // rendu différencié selon le type d'iv
  //   - AL-Absence (= congé partiel) → "Congé" (ou catégorie d'absence)
  //                                   centré, pas d'autres infos
  //   - AL-Reservation → reservationLabel (ex "Écrans") + creator si dispo
  //   - AL-Intervention → ref + ville + adresse (rendu standard)
  const txt = document.createElement("div");
  txt.className = "iv-mini-card-text";

  if (iv.type === "AL-Absence") {
    card.classList.add("iv-mini-card-absence");
    const lbl = document.createElement("div");
    lbl.className = "iv-mini-line iv-mini-absence-label";
    // libellé unique "Absence" pour toutes les catégories.
    // Détails (maladie/congé/...) restent dans le tooltip au survol.
    lbl.textContent = "Absence";
    txt.appendChild(lbl);
  } else if (iv.type === "AL-Reservation") {
    card.classList.add("iv-mini-card-reservation");
    const lbl = document.createElement("div");
    lbl.className = "iv-mini-line iv-mini-reservation-label";
    lbl.textContent = "Réservation";
    txt.appendChild(lbl);
    // v2026.5.46 — vue par heure (mode exact) : sous « Réservation »,
    // le LIEU (meta ville/rue saisie à la création) si renseigné, SINON qui
    // a réservé (« Créé par » EV). Le mode flux garde le rendu historique.
    if (opts && opts.exactHandle) {
      const rvVille = String(iv.resVille || "").trim();
      const rvRue = String(iv.resRue || "").trim();
      if (rvVille || rvRue) {
        if (rvVille) {
          const lv = document.createElement("div");
          lv.className = "iv-mini-line iv-mini-ville";
          lv.textContent = rvVille.toUpperCase();
          txt.appendChild(lv);
        }
        if (rvRue) {
          const lr = document.createElement("div");
          lr.className = "iv-mini-line iv-mini-adresse";
          lr.textContent = rvRue;
          txt.appendChild(lr);
        }
      } else if (iv.reservationCreator) {
        const lc = document.createElement("div");
        lc.className = "iv-mini-line iv-mini-adresse";
        lc.textContent = iv.reservationCreator;
        txt.appendChild(lc);
      }
    }
  } else {
    // Fallback : si la ref n'a pas été extraite du XML (rare), on
    // affiche au moins l'actionId pour que la mini-card ne soit pas
    // visuellement vide.
    const lineRef = document.createElement("div");
    lineRef.className = "iv-mini-line iv-mini-ref";
    lineRef.textContent = ref || (iv.actionId ? "#" + iv.actionId : "(sans réf)");
    txt.appendChild(lineRef);

    const _locMismTitle = iv.locMismatch
      ? "⚠ L'adresse de la fiche ne correspond pas à celle écrite dans l'action" + String.fromCharCode(10) +
        "Fiche : " + iv.locMismatch.fiche + String.fromCharCode(10) +
        "Action : " + iv.locMismatch.action + String.fromCharCode(10) +
        "(comparaison déjà tolérante : ordre, casse, accents, abréviations et précisions en plus sont ignorés)"
      : null;
    if (ville) {
      const lineVille = document.createElement("div");
      lineVille.className = "iv-mini-line iv-mini-ville";
      lineVille.textContent = ville;
      if (_locMismTitle) { lineVille.classList.add("iv-lieu-mismatch-txt"); lineVille.title = _locMismTitle; }
      txt.appendChild(lineVille);
    }

    if (adresse) {
      const lineAdr = document.createElement("div");
      lineAdr.className = "iv-mini-line iv-mini-adresse";
      lineAdr.textContent = adresse;
      if (_locMismTitle) { lineAdr.classList.add("iv-lieu-mismatch-txt"); lineAdr.title = _locMismTitle; }
      txt.appendChild(lineAdr);
    }
  }

  card.appendChild(txt);

  // v2026.5.46 — variante COMPACTE du texte (mode exact) : ville +
  // fin de l'adresse sans le type de voie. Le CSS bascule texte normal ↔
  // compact selon la largeur RÉELLE de la carte (container query) — une
  // carte courte n'est plus jamais vide tant qu'il reste ~36 px.
  // v2026.5.46 — même variante compacte pour une RÉSERVATION étroite :
  // lieu abrégé si renseigné, sinon qui a réservé (jamais une carte vide).
  if (opts && opts.exactHandle && iv.type === "AL-Reservation") {
    const rvVille = String(iv.resVille || "").trim();
    const rvRue = String(iv.resRue || "").trim();
    const l1 = rvVille || (rvRue ? "" : String(iv.reservationCreator || "").trim());
    const l2 = rvRue ? _shortAddress(rvRue) : "";
    if (l1 || l2) {
      const mini = document.createElement("div");
      mini.className = "iv-mini-card-text-mini";
      if (l1) {
        const a = document.createElement("div");
        a.className = "iv-mini-line iv-mini-mini-ville";
        a.textContent = rvVille ? rvVille.toUpperCase() : l1;
        mini.appendChild(a);
      }
      if (l2) {
        const b = document.createElement("div");
        b.className = "iv-mini-line iv-mini-mini-adresse";
        b.textContent = l2;
        mini.appendChild(b);
      }
      card.appendChild(mini);
    }
  }
  if (opts && opts.exactHandle
      && iv.type !== "AL-Absence" && iv.type !== "AL-Reservation"
      && (ville || adresse)) {
    const mini = document.createElement("div");
    mini.className = "iv-mini-card-text-mini";
    if (ville) {
      const lv = document.createElement("div");
      lv.className = "iv-mini-line iv-mini-mini-ville";
      lv.textContent = ville;
      mini.appendChild(lv);
    }
    if (adresse) {
      const la = document.createElement("div");
      la.className = "iv-mini-line iv-mini-mini-adresse";
      la.textContent = _shortAddress(adresse);
      mini.appendChild(la);
    }
    card.appendChild(mini);
  }

  // ✓✓ pour clos/résolu, ✓ pour done (gris), ✓ jaune pour suspended.
  // rideau horaire — masquer le ✓/✓✓ tant que le seuil n'est pas
  // atteint (12h pour le matin, 15h pour l'aprèm).
  const miniRevealed = _isVerdictRevealed(iv);
  const miniSc = getStatusClass(iv);
  const miniPending = miniRevealed && ivVStatus(iv) === "done";
  const miniSuspended = miniRevealed && ivVStatus(iv) === "suspended";
  if (miniSc || miniPending || miniSuspended) {
    const checkEl = document.createElement("div");
    checkEl.className = "iv-mini-status-check";
    if (miniSuspended) checkEl.classList.add("suspended");
    if (miniSc === "status-closed" || miniSc === "status-resolved") {
      checkEl.textContent = "✓✓";
      checkEl.classList.add("double");
    } else {
      checkEl.textContent = "✓";
    }
    card.appendChild(checkEl);
    if (miniSc) card.classList.add(miniSc);
    if (miniPending || miniSuspended) card.classList.add("has-pending-check");
    if (miniSuspended) card.classList.add("status-suspended");
  }

  // v2026.5.40 : hover sur la mini-card = comportement comme une row
  // .intervention-v2 en vue classique → ouvre la GRANDE popup ancrée.
  // r9 : pas d'épinglage si réservation (clic sans effet).
  const isReservation = iv && iv.type === "AL-Reservation";
  card.addEventListener("mouseenter", (e) => {
    highlightIntervention(cardEl, ivIdx, true);
    showTooltip(e, iv, card);
  });
  card.addEventListener("mouseleave", () => {
    highlightIntervention(cardEl, ivIdx, false);
    hideTooltip();
  });
  if (!isReservation) {
    card.addEventListener("click", (e) => {
      // Ctrl/Cmd/middle → fiche EV en arrière-plan
      if (e.ctrlKey || e.metaKey || e.button === 1) {
        e.preventDefault();
        e.stopPropagation();
        openInterventionFromTimeline(card, { background: true });
        return;
      }
      // v2026.5.41 : en vue horizontale, le clic simple ouvre la fiche EV
      // dans un nouvel onglet (au lieu d'épingler la popup, comportement
      // peu utile en horizontal car la popup est déjà visible au survol).
      const isHorizontal = document.documentElement.classList.contains("view-horizontal");
      if (isHorizontal) {
        e.preventDefault();
        e.stopPropagation();
        openInterventionFromTimeline(card, { background: false });
        return;
      }
      // Vue classique : clic = épingle la grande popup ancrée.
      e.stopPropagation();
      _cancelPendingShowTooltip();
      _cancelPendingTimelinePopover();
      _showTooltipImpl(e, iv, card);
      pinTooltip();
    });
  }
  return card;
}

// v2026.5.40 : construit le rangée des mini-cartes (visible en vue
// horizontale uniquement, masquée en classique via CSS).
// Chaque intervention donne une mini-carte avec : barre couleur catégorie +
// référence + heure début→fin + ville + adresse. Les trous entre interventions
// sont représentés par des espaces vides (flex-grow proportionnel au temps),
// pour conserver l'alignement visuel avec la timeline du dessus.
function _buildMiniCardsRow(realInterventions, cardEl) {
  const row = document.createElement("div");
  row.className = "iv-mini-cards";

  // v2026.5.40 : on n'utilise plus la largeur proportionnelle à la durée
  // (= alignement avec la timeline). À la place, chaque mini-card a la
  // MÊME largeur (flex: 1 1 0), pour que toutes soient visibles d'un coup
  // et lisibles. La position temporelle est déjà donnée par la timeline
  // au-dessus.
  const sorted = [...realInterventions]
    .map(iv => {
      const s = timeToMinutes(_ivShownStart(iv));
      const e = timeToMinutes(_ivShownEnd(iv));
      return { iv, s, e };
    })
    .filter(o => o.s !== null && o.e !== null && o.e > o.s)
    .sort((a, b) => a.s - b.s);

  // v2026.5.45 : on crée TOUJOURS les 2 blocs (Matin + Après-midi) même
  // si l'un est vide, séparés par un élément visuel dédié (.iv-mini-sep).
  // Garantit que les coordinateurs voient toujours les 2 demi-journées,
  // alignées de la même façon d'une carte tech à l'autre.
  const blocks = {
    morning: null,
    afternoon: null,
    day: null,
    cont: null
  };
  function _ensureBlock(period) {
    if (blocks[period]) return blocks[period];
    const block = document.createElement("div");
    block.className = "iv-mini-block period-" + period;
    const label = document.createElement("div");
    label.className = "iv-mini-block-label";
    label.textContent = period === "morning" ? "Matin"
      : period === "day" ? "Journée"
      : period === "cont" ? "Matin – Après-midi"
      : "Après-midi";
    block.appendChild(label);
    const cards = document.createElement("div");
    cards.className = "iv-mini-block-cards";
    block.appendChild(cards);
    blocks[period] = { root: block, cards };
    return blocks[period];
  }
  // v2026.5.46 — les éléments couvrant TOUTE la journée affichée vont
  // dans un bloc « JOURNÉE » dédié, en tête de rangée ; le reste suit dans
  // les blocs Matin | 12h | Après-midi habituels — ou dans un bloc continu
  // « Matin – Après-midi » si un élément restant chevauche midi (11h→13h :
  // carte entière, pas de coupure). Journée seule → un seul bloc pleine largeur.
  const MIDI = 12 * 60;
  const { dayS, dayE } = _dayRange();
  const fullDay = sorted.filter(o => o.s <= dayS && o.e >= dayE);
  const rest = sorted.filter(o => !(o.s <= dayS && o.e >= dayE));
  const crossesMid = rest.some(o => o.s < MIDI && o.e > MIDI);
  // v2026.5.46 — le reste D'ABORD (Matin puis Après-midi, blocs vides
  // OMIS quand une « Journée » occupe déjà tout), le bloc JOURNÉE en DERNIER.
  if (rest.length || !fullDay.length) {
    if (crossesMid) {
      row.appendChild(_ensureBlock("cont").root);
    } else if (fullDay.length) {
      const hasM = rest.some(o => o.s < MIDI);
      const hasA = rest.some(o => o.s >= MIDI);
      if (hasM) row.appendChild(_ensureBlock("morning").root);
      if (hasM && hasA) {
        const sepEl = document.createElement("div");
        sepEl.className = "iv-mini-sep";
        sepEl.setAttribute("aria-hidden", "true");
        row.appendChild(sepEl);
      }
      if (hasA) row.appendChild(_ensureBlock("afternoon").root);
    } else {
      const morningBlock = _ensureBlock("morning");
      const sepEl = document.createElement("div");
      sepEl.className = "iv-mini-sep";
      sepEl.setAttribute("aria-hidden", "true");
      const afternoonBlock = _ensureBlock("afternoon");
      row.appendChild(morningBlock.root);
      row.appendChild(sepEl);
      row.appendChild(afternoonBlock.root);
    }
  }
  if (fullDay.length) {
    row.appendChild(_ensureBlock("day").root);
  }
  const placements = [];
  for (const o of fullDay) placements.push({ iv: o.iv, s: o.s, e: o.e, period: "day" });
  for (const o of rest) {
    if (crossesMid) placements.push({ iv: o.iv, s: o.s, e: o.e, period: "cont" });
    else placements.push({ iv: o.iv, s: o.s, e: o.e, period: (o.s < MIDI) ? "morning" : "afternoon" });
  }
  for (const { iv, s, e, period } of placements) {
    _ensureBlock(period);
    const card = _buildOneMiniCard(iv, realInterventions, cardEl);
    // priorité MODÉRÉE aux iv : équilibre entre lisibilité iv et
    // visibilité des gaps proportionnelle à leur durée.
    // - iv  : flex-grow = durée × 3 (boost ×3 pour favoriser les iv,
    //         tout en gardant un long gap visible), shrink 0, basis 100 px.
    //         Entre 2 iv elles restent proportionnelles à leur durée.
    // - gap : flex-grow = durée (proportionnel → un long gap est plus
    //         large qu'un court), shrink 100 (compresse en priorité
    //         quand espace serré), basis 30 px.
    const blkInfo = blocks[period];
    if (blkInfo) {
      const _addMiniGap = (sMin, eMin) => {
        if (sMin == null || eMin == null || eMin <= sMin) return;
        const dur = eMin - sMin;
        const ph = document.createElement("div");
        ph.className = "gap-placeholder gap-placeholder-mini";
        ph.dataset.startMin = String(sMin);
        ph.dataset.endMin = String(eMin);
        ph.dataset.kind = "hole";
        ph.style.flex = dur + " 100 30px";
        ph.textContent = "—";
        blkInfo.cards.appendChild(ph);
        if (cardEl) _bindGapPlaceholder(ph, cardEl);
        if (typeof bindTimelinePopover === "function") bindTimelinePopover(ph);
      };
      if (blkInfo._lastEndMin == null) {
        const pStart = period === "afternoon" ? 12 * 60 : DAY_START;   // morning + day → début de journée
        if (s !== null && s > pStart) _addMiniGap(pStart, s);
      } else if (s !== null && s > blkInfo._lastEndMin) {
        _addMiniGap(blkInfo._lastEndMin, s);
      }
    }
    const ivDuration = (e - s);
    if (ivDuration > 0) card.style.flex = (ivDuration * 3) + " 0 100px";
    blocks[period].cards.appendChild(card);
    // fin du SEGMENT dans ce bloc (pas la fin réelle de l'iv : une full-day
    // mettrait _lastEndMin=18h dans le bloc matin et casserait les gaps).
    if (e !== null) blocks[period]._lastEndMin = e;
  }

  // à la fin de chaque bloc, gap [endLastMini, fin_période] si
  // la dernière mini-card ne finit pas pile à la fin de la période.
  // Si le bloc n'a aucune mini-card (totalement vide), on couvre TOUTE
  // la période avec un seul gap-placeholder — remplace l'ancien
  // .iv-mini-block-empty.
  for (const period of ["morning", "afternoon", "day", "cont"]) {
    const blk = blocks[period];
    if (!blk) continue;
    const pStart = period === "afternoon" ? 12 * 60 : DAY_START;
    const pEnd = period === "morning" ? 12 * 60 : DAY_END;
    if (blk.cards.children.length === 0) {
      const ph = document.createElement("div");
      // .gap-placeholder-full → CSS étire à toute la largeur du
      // bloc en horizontal (uniquement quand bloc complètement vide).
      ph.className = "gap-placeholder gap-placeholder-mini gap-placeholder-full";
      ph.dataset.startMin = String(pStart);
      ph.dataset.endMin = String(pEnd);
      ph.dataset.kind = "hole";
      ph.textContent = "—";
      blk.cards.appendChild(ph);
      if (cardEl) _bindGapPlaceholder(ph, cardEl);
      if (typeof bindTimelinePopover === "function") bindTimelinePopover(ph);
    } else if (blk._lastEndMin != null && blk._lastEndMin < pEnd) {
      // Gap "après dernière mini-card" du bloc (ex: dernière iv finit
      // à 11h30 → gap [11h30, 12h00] visible en fin de matinée).
      const dur = pEnd - blk._lastEndMin;
      const ph = document.createElement("div");
      ph.className = "gap-placeholder gap-placeholder-mini";
      ph.dataset.startMin = String(blk._lastEndMin);
      ph.dataset.endMin = String(pEnd);
      ph.dataset.kind = "hole";
      ph.style.flex = dur + " 100 30px";
      ph.textContent = "—";
      blk.cards.appendChild(ph);
      if (cardEl) _bindGapPlaceholder(ph, cardEl);
      if (typeof bindTimelinePopover === "function") bindTimelinePopover(ph);
    }
  }

  return row;
}

// v2026.5.46 — VUE HORIZONTALE « ÉCHELLE DE TEMPS EXACTE » (option
// Apparence, exclusive avec « Afficher les pauses »). Remplace les blocs
// Matin/Après-midi par UNE bande continue DAY_START -> DAY_END où chaque carte
// est posée en position ABSOLUE à son heure réelle (left/width en %, comme
// les segments de la timeline — masquée dans ce mode : les cartes portent le
// temps elles-mêmes). Deux éléments qui se chevauchent s'empilent en
// sous-lignes (le second est décalé SOUS le premier, demande explicite).
// Des lignes de grille à chaque heure pleine (midi renforcé) + la règle des
// heures rendue une fois en tête de liste (cf. _buildExactRuler) donnent
// l'alignement. Les trous restent des zones survolables/cliquables invisibles
// (popover « Libre HH:MM–HH:MM », clic droit -> Réservation/Absence, drop).
function _buildExactRow(realInterventions, cardEl, isAbsent) {
  const row = document.createElement("div");
  row.className = "iv-exact-row";

  // 1) éléments datés, clampés à la plage affichée. Un élément totalement
  //    hors plage reste VISIBLE (pastille 15 min plaquée au bord) : il
  //    existait en mode flux, il ne doit pas disparaître en mode exact.
  const items = [];
  for (const iv of realInterventions) {
    const s0 = timeToMinutes(_ivShownStart(iv));
    const e0 = timeToMinutes(_ivShownEnd(iv));
    if (s0 === null || e0 === null) continue;
    let cs = Math.max(s0, DAY_START);
    let ce = Math.min(e0, DAY_END);
    if (e0 <= s0) {
      // v2026.5.47 — durée NULLE/incohérente (début >= fin, ex. 10:00→10:00 :
      // erreur de saisie EV). Avant : sautée (continue) → INVISIBLE en vue exacte.
      // On la garde en pastille au point de début (clampé à la plage) ; sa largeur
      // 0 est rendue visible par le min-width CSS de .iv-exact-card, et
      // _buildOneMiniCard la passe en rouge (classe iv-zero-duration).
      cs = Math.min(Math.max(s0, DAY_START), DAY_END);
      ce = cs;
    } else if (ce <= cs) {
      // Durée POSITIVE mais entièrement hors de la plage affichée : pastille
      // 15 min plaquée au bord le plus proche (comportement existant).
      if (e0 <= DAY_START) { cs = DAY_START; ce = DAY_START + 15; }
      else { cs = DAY_END - 15; ce = DAY_END; }
    }
    // v2026.5.47 — repère les rendez-vous EN ERREUR (durée nulle : début ==
    // fin) pour l'avertissement de survol + le blocage du clic droit ci-dessous.
    const zero = (e0 <= s0) && iv.type === "AL-Intervention";
    items.push({ iv, s: cs, e: ce, zero });
  }
  items.sort((a, b) => a.s - b.s || a.e - b.e);
  // v2026.5.47 — positions (minutes) des rendez-vous en erreur (durée nulle),
  // pour signaler/bloquer quand la zone d'un futur RDV les chevaucherait.
  const zeroErrPts = items.filter(it => it.zero).map(it => it.s);

  // 2) sous-lignes (lanes) : glouton — première sous-ligne libre à l'heure
  //    de début, sinon nouvelle sous-ligne en dessous.
  // v2026.5.46 — TOLÉRANCE d'empilement : deux éléments qui
  // s'enchaînent (fin 09:30 → début 09:30) ou se recouvrent de quelques
  // minutes (heures de PLANIFICATION réelles, ex. 09:28→10:05, sous des
  // heures de fiche rondes) restent sur la MÊME ligne — on n'empile
  // qu'au-delà de 10 min de recouvrement réel. Le chevauchement visuel
  // résiduel est négligeable et un vrai conflit reste marqué en rouge.
  const EXACT_STACK_TOLERANCE_MIN = 10;
  const laneEnds = [];
  for (const it of items) {
    let l = 0;
    while (l < laneEnds.length && it.s < laneEnds[l] - EXACT_STACK_TOLERANCE_MIN) l++;
    if (l === laneEnds.length) laneEnds.push(0);
    laneEnds[l] = Math.max(laneEnds[l], it.e);
    it.lane = l;
  }
  const laneCount = Math.max(1, laneEnds.length);
  // v2026.5.46 — chaque sous-ligne devient un VRAI élément empilé en
  // flux : la bande a par construction la hauteur de TOUTES ses sous-lignes
  // (la 2e ne peut plus être coupée, la zone s'agrandit d'elle-même), et la
  // hauteur d'une sous-ligne suit la taille de texte (CSS --text-scale).
  // Remplace l'ancien positionnement vertical par variables calc(), qui
  // s'était montré fragile (cartes rognées chez l'utilisateur).
  const laneEls = [];
  for (let i = 0; i < laneCount; i++) {
    const laneEl = document.createElement("div");
    laneEl.className = "iv-exact-lane";
    laneEls.push(laneEl);
  }

  // 3) v2026.5.46 — les lignes d'heures ne sont plus dessinées PAR bande
  //    (elles s'arrêtaient à chaque tech). Un calque GLOBAL (_layoutExactGrid)
  //    pose des lignes verticales CONTINUES qui traversent tout le tableau.

  // 4) trous survolables/cliquables — mêmes règles que la timeline : découpe
  //    à midi (gap-idx identiques aux autres représentations), mini 15 min,
  //    aucun trou pour un tech absent toute la journée.
  if (!isAbsent) {
    const merged = _fusionnerPlages(items.map(it => [it.s, it.e]));
    const MIDI_EX = 12 * 60;
    const pushHole = (arr, s, e) => {
      if (s < MIDI_EX && e > MIDI_EX) { arr.push([s, MIDI_EX]); arr.push([MIDI_EX, e]); }
      else arr.push([s, e]);
    };
    const holes = [];
    let cursor = DAY_START;
    for (const [s, e] of merged) {
      if (s > cursor) pushHole(holes, cursor, s);
      cursor = Math.max(cursor, e);
    }
    if (cursor < DAY_END) pushHole(holes, cursor, DAY_END);

    // v2026.5.47 — surbrillance de survol : montre la ZONE (1 h par défaut,
    // à l'heure snappée sous le curseur) qu'un clic droit poserait en rendez-vous
    // ou absence, en suivant la souris sur les créneaux libres. Purement visuel
    // (pointer-events:none) : n'affecte pas le popover « Libre / durée » ni le
    // clic. Reflète le calcul du menu clic droit (start snappé, +60 min clampé).
    const selPreview = document.createElement("div");
    selPreview.className = "iv-exact-selpreview";
    selPreview.setAttribute("aria-hidden", "true");
    selPreview.style.display = "none";
    // v2026.5.47 — bulle FIXE en haut de la bande : plage LIBRE + DURÉE
    // disponible du créneau survolé (comme le popover, mais immédiat et fixe).
    // La ZONE de sélection mobile porte, elle, l'HEURE choisie (début–fin) qui
    // suit le curseur dynamiquement. Rouge si un RDV en erreur (durée nulle)
    // tombe dans la zone.
    const selInfo = document.createElement("div");
    selInfo.className = "iv-exact-selinfo";
    selInfo.setAttribute("aria-hidden", "true");
    selInfo.style.display = "none";
    const selInfoMain = document.createElement("div");
    selInfoMain.className = "iv-exact-selinfo-main";
    const selInfoSub = document.createElement("div");
    selInfoSub.className = "iv-exact-selinfo-sub";
    selInfo.appendChild(selInfoMain);
    selInfo.appendChild(selInfoSub);
    const selHour = document.createElement("div");
    selHour.className = "iv-exact-selpreview-hour";
    selPreview.appendChild(selHour);
    const _moveSelPreview = (ev) => {
      if (typeof _cursorToTimeOnTimeline !== "function") return;
      const t = _cursorToTimeOnTimeline(row, ev.clientX);
      if (!t) { selPreview.style.display = "none"; selInfo.style.display = "none"; return; }
      const sm = Math.max(DAY_START, Math.min(t.totalMin, DAY_END - 30));
      const em = Math.min(sm + 60, DAY_END);
      selPreview.style.left = ((sm - DAY_START) / DAY_LEN) * 100 + "%";
      selPreview.style.width = ((em - sm) / DAY_LEN) * 100 + "%";
      selHour.textContent = minutesToTime(sm) + "–" + minutesToTime(em);
      const hs = parseInt(ev.currentTarget.dataset.startMin, 10);
      const he = parseInt(ev.currentTarget.dataset.endMin, 10);
      // v2026.5.47 — la bulle info fixe se cale au CENTRE du créneau libre
      // survolé (zone SANS rendez-vous) → jamais par-dessus une intervention.
      // (Le popover mobile « Libre / durée » a été retiré des trous, ci-dessous.)
      selInfo.style.left = (((hs + he) / 2 - DAY_START) / DAY_LEN) * 100 + "%";
      const hasErr = zeroErrPts.some(p => p >= sm && p <= em);
      selPreview.classList.toggle("danger", hasErr);
      selInfo.classList.toggle("danger", hasErr);
      if (hasErr) {
        selInfoMain.textContent = "Erreur : rendez-vous début = fin";
        selInfoSub.textContent = "à corriger avant de réserver";
      } else {
        const dur = he - hs;
        const dh = Math.floor(dur / 60), dm = dur % 60;
        const dtxt = dh === 0 ? (dm + " min") : dm === 0 ? (dh + " h") : (dh + " h " + dm + " min");
        selInfoMain.textContent = "Libre " + minutesToTime(hs) + "–" + minutesToTime(he);
        selInfoSub.textContent = dtxt + " disponible";
      }
      selPreview.style.display = "block";
      // v2026.5.47 — selInfo (temps total dispo) n'apparaît qu'après 500 ms
      // (timer armé au mouseenter du trou) ; selPreview + selHour (la zone de
      // réservation/absence) restent EN DIRECT, sans délai.
    };
    let _selInfoTimer = null;
    const _armSelInfo = () => {
      if (_selInfoTimer) clearTimeout(_selInfoTimer);
      _selInfoTimer = setTimeout(() => { selInfo.style.display = "block"; }, 500);
    };
    const _hideSelPreview = () => {
      if (_selInfoTimer) { clearTimeout(_selInfoTimer); _selInfoTimer = null; }
      selPreview.style.display = "none";
      selInfo.style.display = "none";
    };

    for (const [s, e] of holes) {
      if (e - s < 15) continue;
      const h = document.createElement("div");
      h.className = "iv-exact-hole";
      h.style.left = ((s - DAY_START) / DAY_LEN) * 100 + "%";
      h.style.width = ((e - s) / DAY_LEN) * 100 + "%";
      h.dataset.startMin = String(s);
      h.dataset.endMin = String(e);
      h.dataset.kind = "hole";
      const gapIdx = s + "-" + e;
      h.dataset.gapIdx = gapIdx;
      h.addEventListener("mouseenter", (e) => { highlightGap(cardEl, gapIdx, true); _moveSelPreview(e); _armSelInfo(); });
      h.addEventListener("mousemove", _moveSelPreview);
      h.addEventListener("mouseleave", () => { highlightGap(cardEl, gapIdx, false); _hideSelPreview(); });
      // v2026.5.47 — plus de popover mobile « Libre / durée » sur les trous :
      // la bulle info FIXE (selInfo) porte désormais cette info. (Le popover
      // reste actif sur les INTERVENTIONS, hors de cette boucle.)
      row.appendChild(h);
    }
    // Posée APRÈS les trous → visible au-dessus d'eux ; sous les bulles
    // (z-index 1) qui la recouvrent si la zone d'1 h déborde sur une occupation.
    row.appendChild(selPreview);
    // Bulle info FIXE (temps disponible / alerte), au-dessus de tout (z-index 3).
    row.appendChild(selInfo);
  }

  // 5) cartes posées en absolu : MÊMES mini-cards que le mode flux (mêmes
  //    classes/données -> tooltip, clic, recherche, reschedule, coches et
  //    conflits inchangés), seul le placement change.
  for (const el of laneEls) row.appendChild(el);
  for (const it of items) {
    const card = _buildOneMiniCard(it.iv, realInterventions, cardEl, { exactHandle: true });
    card.classList.add("iv-exact-card");
    card.style.left = ((it.s - DAY_START) / DAY_LEN) * 100 + "%";
    card.style.width = ((it.e - it.s) / DAY_LEN) * 100 + "%";
    laneEls[it.lane].appendChild(card);
  }

  return row;
}

// v2026.5.46 — règle des heures du mode exact : rendue UNE seule fois en
// tête de #cards (sticky sous topbar/bandeaux via --stack-top), alignée sur
// les bandes par le CSS (fantôme de la colonne noms + mêmes marges). Toutes
// les heures pleines de la plage affichée sont marquées.
function _buildExactRuler() {
  const ruler = document.createElement("div");
  ruler.className = "exact-hours-ruler";
  const scale = document.createElement("div");
  scale.className = "exact-ruler-scale";
  for (let m = Math.ceil(DAY_START / 60) * 60; m <= DAY_END; m += 60) {
    const t = document.createElement("span");
    t.className = "exact-ruler-tick" + (m === 12 * 60 ? " exact-ruler-tick-noon" : "");
    t.style.left = ((m - DAY_START) / DAY_LEN) * 100 + "%";
    t.textContent = (m / 60) + "h";
    scale.appendChild(t);
  }
  ruler.appendChild(scale);
  return ruler;
}

// v2026.5.46 — ALIGNEMENT MESURÉ de la règle des heures : le calcul
// théorique de l'offset (bordures + colonne noms + marges) s'est avéré faux
// au pixel selon la machine (zoom, taille de texte, scrollbar) → repères
// d'heures décalés par rapport aux cartes. On mesure donc au runtime la
// position RÉELLE de la première bande (.iv-exact-row) et on cale la zone
// des ticks dessus. Appelée après chaque rendu, au toggle de vue et à
// chaque resize (ResizeObserver global).
// v2026.5.46 — LIGNES D'HEURES CONTINUES : un calque de traits verticaux
// posé dans #cards (comme la ligne « maintenant »), du haut de la première
// carte au bas de la dernière → les repères d'heures traversent TOUS les techs
// d'un seul trait, sur toute la longueur. Recalculé au rendu et au resize
// (mêmes moments que _alignExactRuler). Les traits scrollent avec le contenu.
// v2026.5.46 — fusionne des intervalles [début, fin] (tri inclus) ;
// ecartMax > 0 soude aussi les intervalles séparés d'au plus cet écart.
// Remplace trois copies inline du même algorithme (trous du mode exact,
// trous de la timeline, _findNearestFreeSlot) + le saut des absents.
function _fusionnerPlages(plages, ecartMax = 0) {
  const fusion = [];
  for (const [s, e] of plages.slice().sort((a, b) => a[0] - b[0])) {
    const derniere = fusion[fusion.length - 1];
    if (derniere && s - derniere[1] <= ecartMax) derniere[1] = Math.max(derniere[1], e);
    else fusion.push([s, e]);
  }
  return fusion;
}

// v2026.5.46 — helper partagé (lignes d'heures ET ligne « maintenant ») :
// découpe la tranche verticale [top, bottom] en segments qui SAUTENT les
// cartes des techs absents (.card.is-absent).
function _exactAbsentSegments(container, top, bottom) {
  // v2026.5.46 — les lignes s'arrêtent AVANT le bloc des absents.
  // Retirer la seule hauteur des cartes .is-absent laissait des tronçons
  // dans les interstices (gap 6 px de la vue horizontale) entre deux cartes
  // absentes, et la borne basse était le bas de la DERNIÈRE carte — une
  // carte absente (tri : absents en dernier). On borne donc au bas de la
  // dernière carte NON absente ; le découpage ci-dessous reste utile pour
  // une carte absente située au-dessus (cas pompier + absent, trié en tête).
  let lastActiveBottom = null;
  const skip = [];
  container.querySelectorAll(".card").forEach(c => {
    if (c.classList.contains("is-absent")) {
      skip.push([c.offsetTop, c.offsetTop + c.offsetHeight]);
    } else {
      lastActiveBottom = c.offsetTop + c.offsetHeight;
    }
  });
  if (lastActiveBottom === null) return [];   // que des absents → aucune ligne
  bottom = Math.min(bottom, lastActiveBottom);
  // v2026.5.46 — fusionner les plages voisines : l'interstice entre deux
  // cartes absentes ADJACENTES ne doit pas laisser de tronçon de ligne
  // orphelin (ex. deux pompiers absents triés en tête). Tolérance dérivée du
  // layout réel (gap de flex entre cartes), doublée pour les arrondis.
  const gapPx = parseFloat(getComputedStyle(container).rowGap) || 6;
  const zones = _fusionnerPlages(skip, gapPx * 2);
  let segs = [[top, bottom]];
  for (const [rs, re] of zones) {
    const next = [];
    for (const [s, e] of segs) {
      if (re <= s || rs >= e) { next.push([s, e]); continue; }  // pas de recouvrement
      if (rs > s) next.push([s, rs]);   // tranche avant l'absence
      if (re < e) next.push([re, e]);   // tranche après l'absence
    }
    segs = next;
  }
  return segs;
}

function _layoutExactGrid() {
  const container = document.getElementById("cards");
  if (!container) return;
  container.querySelectorAll(".exact-grid-vline").forEach(el => el.remove());
  const isExact = (typeof HORIZONTAL_EXACT_MODE !== "undefined") && HORIZONTAL_EXACT_MODE
    && document.documentElement.classList.contains("view-horizontal");
  if (!isExact) return;
  const firstRow = container.querySelector(".iv-exact-row");
  if (!firstRow) return;
  const contRect = container.getBoundingClientRect();
  const rowRect = firstRow.getBoundingClientRect();
  if (rowRect.width <= 0 || contRect.width <= 0) return;
  const cards = container.querySelectorAll(".card");
  if (!cards.length) return;
  const topPx = cards[0].offsetTop;
  const lastCard = cards[cards.length - 1];
  const bottomPx = lastCard.offsetTop + lastCard.offsetHeight;
  const leftBase = rowRect.left - contRect.left;
  const { dayS: dayStart, dayE: dayEnd, dayLen } = _dayRange();
  // v2026.5.46 — les lignes ne traversent pas les techs absents ; logique
  // partagée avec la ligne « maintenant » (_exactAbsentSegments). Segments
  // calculés UNE fois : bornes invariantes dans la boucle, et un appel par
  // graduation forcerait un reflow lecture/écriture à chaque trait.
  const segments = _exactAbsentSegments(container, topPx, bottomPx);
  // v2026.5.46 — pas de 30 min : trait plein à chaque heure, trait FIN à
  // chaque demi-heure (h30), césure renforcée à midi.
  for (let m = Math.ceil(dayStart / 60) * 60; m <= dayEnd; m += 30) {
    const isHalf = (m % 60 !== 0);
    const isNoon = (m === 12 * 60);
    const x = leftBase + ((m - dayStart) / dayLen) * rowRect.width;
    const cls = "exact-grid-vline"
      + (isNoon ? " exact-grid-vline-noon" : (isHalf ? " exact-grid-vline-half" : ""));
    for (const [s, e] of segments) {
      if (e - s <= 0) continue;
      const line = document.createElement("div");
      line.className = cls;
      line.style.left = Math.round(x) + "px";
      line.style.top = s + "px";
      line.style.height = (e - s) + "px";
      container.appendChild(line);
    }
  }
}

function _alignExactRuler() {
  const ruler = document.querySelector(".exact-hours-ruler");
  if (!ruler || ruler.offsetParent === null) return;   // masquée (classique / mode flux)
  const scale = ruler.querySelector(".exact-ruler-scale");
  const row = document.querySelector(".iv-exact-row");
  if (!scale || !row) return;
  const rowRect = row.getBoundingClientRect();
  const rulerRect = ruler.getBoundingClientRect();
  if (rowRect.width <= 0 || rulerRect.width <= 0) return;
  scale.style.marginLeft = Math.max(0, Math.round(rowRect.left - rulerRect.left)) + "px";
  scale.style.marginRight = Math.max(0, Math.round(rulerRect.right - rowRect.right)) + "px";
}

function buildTimeline(realInterventions, pompierBlocks, absenceBlocks, cardEl, isPompier, isAbsent) {

  const wrap = document.createElement("div");
  wrap.className = "timeline";
  if (isPompier) wrap.classList.add("timeline-pompier");

  const bar = document.createElement("div");
  bar.className = "timeline-bar";

  const segments = [];
  for (let i = 0; i < realInterventions.length; i++) {
    const iv = realInterventions[i];
    const s = timeToMinutes(_ivShownStart(iv));
    const e = timeToMinutes(_ivShownEnd(iv));
    if (s === null || e === null) continue;
    const cs = Math.max(s, DAY_START);
    const ce = Math.min(e, DAY_END);
    if (ce <= cs) continue;
    segments.push({
      kind: "intervention",
      colorKey: deriveColorKey(iv),
      iv, ivIdx: i,
      start: cs, end: ce,
      statusClass: getStatusClass(iv)
    });
  }

  for (const ab of absenceBlocks || []) {
    const s = timeToMinutes(ab.startTime);
    const e = timeToMinutes(ab.endTime);
    if (s === null || e === null) continue;
    const cs = Math.max(s, DAY_START);
    const ce = Math.min(e, DAY_END);
    if (cs <= DAY_START && ce >= DAY_END) continue;
    if (ce <= cs) continue;
    segments.push({ kind: "absence", start: cs, end: ce, iv: ab });
  }

  // Calcul des trous (que si pas absent complet)
  const merged = _fusionnerPlages(segments.map(s => [s.start, s.end]));
  // on découpe TOUJOURS les holes à 12h00 pour qu'ils correspondent
  // exactement aux gap-placeholder par demi-journée (sinon un hole qui
  // chevauche midi se retrouve avec un data-gap-idx différent du gap
  // côté carte → pas de surbrillance bidirectionnelle).
  const _MID_TIMELINE = 12 * 60;
  const _pushHole = (arr, s, e) => {
    if (s < _MID_TIMELINE && e > _MID_TIMELINE) {
      arr.push([s, _MID_TIMELINE]);
      arr.push([_MID_TIMELINE, e]);
    } else {
      arr.push([s, e]);
    }
  };
  const holes = [];
  let cursor = DAY_START;
  for (const [s, e] of merged) {
    if (s > cursor) _pushHole(holes, cursor, s);
    cursor = Math.max(cursor, e);
  }
  if (cursor < DAY_END) _pushHole(holes, cursor, DAY_END);

  if (!isAbsent) {
    for (const [s, e] of holes) {
      if (e - s < 15) continue;
      const h = document.createElement("div");
      h.className = "timeline-hole";
      h.style.left = ((s - DAY_START) / DAY_LEN) * 100 + "%";
      h.style.width = ((e - s) / DAY_LEN) * 100 + "%";
      h.dataset.startMin = s;
      h.dataset.endMin = e;
      h.dataset.kind = "hole";
      // idx dérivé des bornes — identique au gap-placeholder qui
      // a les mêmes bornes. Permet le highlight bidirectionnel même
      // si _bindGapPlaceholder ne retrouve pas le hole (les listeners
      // sont attachés ici au hole, indépendamment).
      const gapIdx = s + "-" + e;
      h.dataset.gapIdx = gapIdx;
      h.addEventListener("mouseenter", () => highlightGap(cardEl, gapIdx, true));
      h.addEventListener("mouseleave", () => highlightGap(cardEl, gapIdx, false));
      bindTimelinePopover(h);
      bar.appendChild(h);
    }
  }

  for (const seg of segments) {
    const el = document.createElement("div");
    el.className = "timeline-slot kind-" + seg.kind;
    if (seg.colorKey) el.classList.add("color-" + seg.colorKey);
    if (seg.statusClass) el.classList.add(seg.statusClass);
    el.style.left = ((seg.start - DAY_START) / DAY_LEN) * 100 + "%";
    el.style.width = ((seg.end - seg.start) / DAY_LEN) * 100 + "%";
    el.dataset.startMin = seg.start;
    el.dataset.endMin = seg.end;
    el.dataset.kind = seg.kind;
    if (seg.iv) {
      el.dataset.title = deriveShortTitle(seg.iv);
      if (seg.iv.ref) el.dataset.ref = seg.iv.ref;
    }

    // v2026.5.40 : la timeline reprend son comportement classique (segments
    // colorés simples). Les infos détaillées (ref/heure/ville/adresse) sont
    // maintenant rendues dans un conteneur SÉPARÉ sous la timeline (cf.
    // .iv-mini-cards plus bas dans buildCard, visible en vue horizontale).

    if (seg.ivIdx !== undefined) {
      el.dataset.ivIdx = seg.ivIdx;
      el.addEventListener("mouseenter", () => highlightIntervention(cardEl, seg.ivIdx, true));
      el.addEventListener("mouseleave", () => highlightIntervention(cardEl, seg.ivIdx, false));
    }
    bindTimelinePopover(el);
    bar.appendChild(el);
  }

  // v2026.5.39 : séparateur midi plus marqué (avant : ligne 1px discrète).
  // On dessine maintenant une bande de 4px + un petit label "12h" au-dessus
  // pour bien visualiser la pause de midi sur la timeline (utile surtout en
  // vue horizontale où la timeline est la seule représentation).
  const noon = document.createElement("div");
  noon.className = "timeline-noon";
  noon.style.left = (((12 * 60) - DAY_START) / DAY_LEN) * 100 + "%";
  noon.title = "Midi";
  bar.appendChild(noon);

  wrap.appendChild(bar);

  const scale = document.createElement("div");
  scale.className = "timeline-scale";
  for (const h of [8, 10, 12, 14, 16, 18]) {
    const t = document.createElement("span");
    t.className = "timeline-tick";
    t.style.left = (((h * 60) - DAY_START) / DAY_LEN * 100) + "%";
    t.textContent = h + "h";
    scale.appendChild(t);
  }
  wrap.appendChild(scale);

  return wrap;
}

// RIDEAU HORAIRE — on continue de fetcher les statuts mais on RETARDE
// leur affichage. Une intervention du matin (start < 12h) ne montre son
// verdict (✓ / ✓✓ / Fait / Suspendu / commentaire) qu'à partir de 12:00.
// Une intervention de l'après-midi (start ≥ 12h) attend 15:00.
//   - Avant le seuil : aucun marqueur, aucune couleur de clôture, pas de
//     commentaire dans le tooltip → comme si la fiche n'avait pas encore
//     été analysée.
//   - Après le seuil : on affiche tel quel le statut courant, qu'il soit
//     "Fait", "✓✓", "Suspendu" ou même encore "À faire".
// Le rideau ne s'applique QUE quand on regarde le planning d'aujourd'hui.
// En mode debug, tout est révélé pour pouvoir tester les verdicts.
//
// PAS de tick automatique : la transition se fait UNIQUEMENT quand le
// coordinateur recharge la page (F5) ou clique "Actualiser". À ce moment-là
// updateInterventionRow / buildInterventionRow / buildTooltipHTML rejouent
// leur logique avec l'heure courante et le rideau s'ouvre.
function _isVerdictRevealed(iv) {
  try {
    if (LOG && LOG.isDebug && LOG.isDebug()) return true;
  } catch (_) {}
  // Pas d'iv → on révèle (pas de raison de cacher).
  if (!iv) return true;
  // Date affichée différente d'aujourd'hui → pas de rideau (passé/futur).
  if (state && state.currentDate && state.currentDate !== todayISO()) return true;
  // Réservation / absence : pas concerné par le rideau.
  if (iv.type === "AL-Reservation" || iv.type === "AL-Absence") return true;
  // Pas d'heure de début exploitable → on révèle (on ne peut pas décider).
  // (multi-jours : heure d'affichage du jour courant, pas celle du 1er jour)
  const start = _ivShownStart(iv) || iv.startTime;
  if (!start) return true;
  const m = String(start).match(/^(\d{1,2}):(\d{2})/);
  if (!m) return true;
  const startMin = parseInt(m[1], 10) * 60 + parseInt(m[2], 10);
  const now = new Date();
  const nowMin = now.getHours() * 60 + now.getMinutes();
  // < 12h = matin → rideau jusqu'à 12:00 ; ≥ 12h = aprèm → rideau jusqu'à 15:00.
  const threshold = (startMin < 12 * 60) ? (12 * 60) : (15 * 60);
  return nowMin >= threshold;
}

function getStatusClass(iv) {
  // tant que le rideau n'est pas levé, on retourne null → la card ne
  // prend pas la classe verte/violette. Le statut reste stocké dans iv.status,
  // simplement non visible.
  if (!_isVerdictRevealed(iv)) return null;
  // v2026.5.46 — priorité au verdict v2 :
  //   closed → carte verte (clôturé officiel) ;
  //   done / suspended → PAS de fond, juste le check ✓ gris / jaune ;
  //   unknown → neutre (analyse non aboutie, retentée au prochain refresh).
  const vs = ivVStatus(iv);
  if (vs === "closed") return "status-closed";
  if (vs === "done" || vs === "suspended" || vs === "unknown") return null;
  if (isClosedStatus(iv.status)) return "status-closed";
  if (isResolvedStatus(iv.status)) return "status-resolved";
  return null;
}

/**
 * Lie les segments timeline à un popover persistant au clic (depuis v4.2.3).
 *
 * @author Quentin Rouiller
 */
function bindTimelinePopover(el) {
  // v2026.5.40 : comportement UNIFIÉ vue classique + vue horizontale.
  //   - hover        : petite popup qui suit la souris
  //   - clic simple  : grande popup persistante
  //   - double-clic  : fiche EasyVista nouvel onglet
  //   - Ctrl+clic    : fiche EasyVista en arrière-plan

  el.addEventListener("mouseenter", (e) => {
    showTimelinePopover(e, el);
  });
  // v4.2.3 : la petite popup timeline SUIT la souris (différent de la grande
  // popup des lignes d'intervention qui est ancrée). On n'utilise pas
  // moveTooltip() (no-op depuis v4.1.12) mais une fonction dédiée.
  el.addEventListener("mousemove", (e) => {
    moveTimelineTooltip(e);
  });
  el.addEventListener("mouseleave", () => {
    hideTooltip();
  });

  const kind = el.dataset.kind;
  const ivIdxStr = el.dataset.ivIdx;
  // Seulement sur les segments avec une interventoin (pas les "hole" libres
  // ni certaines absences sans ivIdx)
  if (ivIdxStr === undefined) return;
  // v2026.5.40 : pas d'épinglage des absences ni des réservations.
  // Ces segments restent en hover (petite popup timeline) seulement.
  if (kind === "absence" || kind === "reservation") return;

  let singleClickTimer = null;
  el.addEventListener("click", (e) => {
    // Ctrl / Cmd / molette → ouvrir fiche en arrière-plan
    if (e.ctrlKey || e.metaKey || e.button === 1) {
      e.preventDefault();
      e.stopPropagation();
      openInterventionFromTimeline(el, { background: true });
      return;
    }
    // Clic simple (sans Ctrl) : on attend un éventuel double-clic avant
    // d'ouvrir la grande popup persistante.
    e.stopPropagation();
    if (singleClickTimer) clearTimeout(singleClickTimer);
    singleClickTimer = setTimeout(() => {
      singleClickTimer = null;
      openPersistentTimelinePopup(el);
    }, 250);
  });
  el.addEventListener("dblclick", (e) => {
    // En vue horizontale le clic simple fait déjà l'ouverture, le dblclick
    // devient inutile — on le laisse par sécurité (comportement idem).
    if (singleClickTimer) { clearTimeout(singleClickTimer); singleClickTimer = null; }
    if (_isHorizontalView()) return;
    e.preventDefault();
    e.stopPropagation();
    openInterventionFromTimeline(el, { background: false });
  });
}

/**
 * v4.2.3 : positionne la petite popup timeline à côté du curseur.
 * Utilisée UNIQUEMENT en vue classique pour la petite popup qui suit la souris
 * quand on survole un segment timeline (informations courtes : durée, ref).
 *
 * v2026.5.34 : documentation + logs. Le clamp dans le viewport reste local
 * (pas unifié avec positionTooltipAnchored car la logique "suit-souris" est
 * fondamentalement différente d'un ancrage fixe à une source).
 *
 * @param {MouseEvent} e - événement souris pour position courante
 */
function moveTimelineTooltip(e) {
  const tip = tooltipEl();
  if (!tip || !tip.classList.contains("visible")) return;
  // La popup ancrée (grande bulle) ne doit pas être déplacée par la souris
  if (bulleState.pinned) return;
  // Si la popup affiche une grande bulle d'intervention (mode anchored),
  // on ne la bouge pas non plus : on la laisse ancrée.
  if (tip.dataset.mode === "anchored") return;

  const offsetX = 14, offsetY = 16;
  let x = e.clientX + offsetX;
  let y = e.clientY + offsetY;
  const rect = tip.getBoundingClientRect();

  // Ajuster si on sort de la fenêtre (logique simple : flip autour du curseur)
  if (x + rect.width  > window.innerWidth  - 8) x = e.clientX - rect.width  - offsetX;
  if (y + rect.height > window.innerHeight - 8) y = e.clientY - rect.height - offsetY;
  if (x < 4) x = 4;
  if (y < 4) y = 4;

  // setTooltipViewportPosition gère la détection auto fixed vs abs.
  setTooltipViewportPosition(x, y);
}

// v4.2.3 : trouve l'iv correspondant au segment timeline et ouvre sa fiche
function openInterventionFromTimeline(el, opts) {
  const ivIdx = el.dataset.ivIdx;
  if (ivIdx === undefined) return;
  const cardEl = el.closest(".card");
  if (!cardEl) return;
  const row = cardEl.querySelector(`.intervention-v2[data-iv-idx="${ivIdx}"]`);
  if (!row) return;
  const actionId = row.dataset.actionId;
  if (!actionId) return;
  // recupere l'iv depuis state
  const iv = findIvByActionId(actionId);
  if (!iv) return;
  openInterventionInNewTab(iv, opts || {});
}

function findIvByActionId(actionId) {
  const data = state.currentData;
  if (!data || !data.techs) return null;
  for (const tech of data.techs) {
    for (const iv of (tech.interventions || [])) {
      if (String(iv.actionId) === String(actionId)) return iv;
    }
  }
  return null;
}

// v4.2.3/4 : ouvre la GRANDE popup au clic sur un segment timeline, ancrée
// juste en dessous du segment. Pas épinglée : se ferme sur clic ailleurs,
// Échap, OU quand la souris quitte la popup elle-même (mouseleave).
// v4.2.3/4 : ouvre la GRANDE popup au clic sur un segment timeline (vue
// classique) ou au hover (vue horizontale). Ancrée à côté du segment, pas
// sur. Se ferme au clic ailleurs.
//
// v2026.5.34 : utilise positionTooltipAnchored() unifié au lieu de recalculer
// sa propre position. Plus de code dupliqué.
/**
 * Ouvre une grande popup détaillée pour un segment timeline.
 *
 * @author Quentin Rouiller
 */
function openPersistentTimelinePopup(el) {
  if (!el) {
    LOG.warn("persistentTimeline", "segment el null — abandon");
    return;
  }
  const ivIdx = el.dataset.ivIdx;
  if (ivIdx === undefined) {
    LOG.info("persistentTimeline", "segment sans ivIdx (hole/absence vide) — abandon");
    return;
  }
  const cardEl = el.closest(".card");
  if (!cardEl) {
    LOG.warn("persistentTimeline", "pas de .card parent trouvée");
    return;
  }
  const row = cardEl.querySelector(`.intervention-v2[data-iv-idx="${ivIdx}"]`);
  if (!row) {
    LOG.warn("persistentTimeline", `row intervention-v2[data-iv-idx="${ivIdx}"] introuvable`);
    return;
  }
  const actionId = row.dataset.actionId;
  const iv = findIvByActionId(actionId);
  if (!iv) {
    LOG.warn("persistentTimeline", `iv pour actionId=${actionId} introuvable`);
    return;
  }

  const tip = tooltipEl();
  if (!tip) {
    LOG.warn("persistentTimeline", "tooltipEl() null");
    return;
  }

  LOG.info("persistentTimeline", `ouverture grande popup pour iv actionId=${actionId}`);

  // Nettoyer tout état précédent (ancrage, épinglage, timers)
  bulleState.pinned = false;
  bulleState.hoveredInBulle = false;
  bulleState.hoveredInRow = false;
  if (bulleState.hideTimer) { clearTimeout(bulleState.hideTimer); bulleState.hideTimer = null; }
  tip.classList.remove("pinned");

  // Construire la grande bulle
  tip.innerHTML = buildTooltipHTML(iv);
  tip.classList.remove("hidden");
  tip.classList.add("visible");
  // mode "anchored" : le hover timeline ne doit pas la remplacer par la petite popup
  tip.dataset.mode = "anchored";
  state.currentTooltipIv = iv;

  // v2026.5.34 : utiliser positionTooltipAnchored() unifié, en préférant
  // dessous (sous le segment timeline) via opts.anchorBelow = true.
  //
  // D'abord on reset les coords pour que le tipRect soit correctement mesuré
  // avec le nouveau contenu.
  tip.style.left = "-9999px";
  tip.style.top = "0px";
  // Force reflow
  void tip.offsetWidth;
  positionTooltipAnchored(el, { anchorBelow: true });
}

// v2026.5.40 : délai d'apparition 500 ms sur la petite popup timeline
// (cohérent avec showTooltip). Pendant ces 500 ms, si la souris quitte
// (mouseleave / autre élément), le timer est annulé.
let _showTimelinePopoverTimer = null;
function _cancelPendingTimelinePopover() {
  if (_showTimelinePopoverTimer) {
    clearTimeout(_showTimelinePopoverTimer);
    _showTimelinePopoverTimer = null;
  }
}
function showTimelinePopover(e, el) {
  // v2026.5.46 — un menu contextuel (clic droit) est ouvert → la petite
  // popup ne doit PAS s'afficher par-dessus (la souris passe sur les trous en
  // allant vers le menu).
  if (_techCtxMenuEl) return;
  _cancelPendingTimelinePopover();
  _cancelPendingShowTooltip();
  // v2026.5.40 : dès qu'on hover un segment timeline, fermer IMMÉDIATEMENT
  // TOUTE grande popup non épinglée (peu importe son mode), sinon elle restait
  // visible pendant les 500ms du timer hide → effet "grande popup pendant 1s".
  // On respecte uniquement les popups épinglés (pin = action explicite user).
  const tip = tooltipEl();
  if (tip && tip.classList.contains("visible") && !bulleState.pinned) {
    tip.classList.remove("visible");
    tip.classList.add("hidden");
    if (tip.dataset) delete tip.dataset.mode;
    bulleState.hoveredInRow = false;
    bulleState.hoveredInBulle = false;
    state.currentTooltipIv = null;
    if (bulleState.hideTimer) {
      clearTimeout(bulleState.hideTimer);
      bulleState.hideTimer = null;
    }
  }
  const _ev = { clientX: e.clientX, clientY: e.clientY };
  _showTimelinePopoverTimer = setTimeout(() => {
    _showTimelinePopoverTimer = null;
    _showTimelinePopoverImpl(_ev, el);
  }, 500);
}
function _showTimelinePopoverImpl(e, el) {
  const s = parseInt(el.dataset.startMin, 10);
  const eMin = parseInt(el.dataset.endMin, 10);
  const kind = el.dataset.kind;
  const dur = eMin - s;
  let html;
  if (kind === "hole") {
    const h = Math.floor(dur / 60);
    const min = dur % 60;
    let d;
    if (h === 0) d = `${min} min`;
    else if (min === 0) d = `${h} h`;
    else d = `${h} h ${min} min`;
    html = `<dl>
      <dt>Libre</dt><dd>${minutesToTime(s)}–${minutesToTime(eMin)}</dd>
      <dt>Durée</dt><dd>${d} disponible</dd>
    </dl>`;
  } else {
    const t = el.dataset.title || "";
    const ref = el.dataset.ref || "";
    const k = kind === "absence" ? "Absence" : "Intervention";
    html = `<dl>
      <dt>${k}</dt><dd>${minutesToTime(s)}–${minutesToTime(eMin)}</dd>
      ${t ? `<dt>Type</dt><dd>${escapeHtml(t)}</dd>` : ""}
      ${ref ? `<dt>Réf</dt><dd>${escapeHtml(ref)}</dd>` : ""}
    </dl>`;
  }
  const tip = tooltipEl();
  // v2026.5.40 : si une grande bulle ancrée (depuis la mini-card ou
  // une row classique) est ouverte, on la REMPLACE par la petite popup
  // qui suit la souris quand l'user hover un segment timeline.
  // Ancien comportement (return si anchored) gardait la grande popup et
  // empêchait le hover timeline d'afficher quoi que ce soit.
  // Si la bulle est ÉPINGLÉE (clic explicite), on respecte l'épinglage.
  if (tip.dataset.mode === "anchored" && bulleState.pinned) return;
  // v4.2.4 : annuler tout hideTimer en cours pour éviter que la popup
  // précédente, en train d'être masquée, masque AUSSI celle-ci juste après.
  // Problème typique quand on passe rapidement d'un segment à un autre.
  if (bulleState.hideTimer) {
    clearTimeout(bulleState.hideTimer);
    bulleState.hideTimer = null;
  }
  tip.innerHTML = html;
  tip.classList.remove("hidden", "pinned");
  tip.classList.add("visible");
  // v4.2.3 : mode "hover" = petite popup qui suit la souris
  tip.dataset.mode = "hover";
  moveTimelineTooltip(e);
}

// ============================================================================
// Feature reschedule (modifier horaire / déplacer iv) — viewer side
// ============================================================================
//
// L'utilisateur peut, depuis le bloc heure (à gauche) d'une intervention :
//   - cliquer pour ouvrir un modal d'édition (date, heure début, heure fin, tech)
//   - drag pour déplacer la card sur le planning, avec preview visuel sur la
//     timeline du tech survolé. Mouseup → modal de confirmation, puis appel
//     à l'API EZV (Planning_schedule_action_Employee + éventuellement
//     fc_save_inspector si la durée a changé).
//
// Désactivé pour : non-AL-Intervention, et iv déjà clos / résolu / fait /
// suspendu (rien à modifier sur un ticket fini).

function _canRescheduleIv(iv) {
  // Conditions strictement nécessaires : il faut une vraie intervention
  // avec un actionId et des horaires pour pouvoir construire la requête
  // de reschedule API.
  if (!iv) return false;
  if (iv.type !== "AL-Intervention") return false;
  if (!iv.actionId) return false;
  if (!iv.startTime || !iv.endTime) return false;
  // v2026.5.46 — bloque le drag d'une iv FAIT (done, gris « fait ») ou
  // CLOSE (✓✓ vert / statut EV Clôturé/Résolu/Terminé). On ne bloque PAS
  // "suspended" (jaune ✓) qui reste déplaçable. Les iv revenues dans le
  // planning EV repassent en verdict live à l'ingestion (storeApplyFresh),
  // donc pas de blocage sur du périmé.
  const vs = ivVStatus(iv);
  if (vs === "done" || vs === "closed") return false;
  if (typeof isClosedStatus === "function" && isClosedStatus(iv.status)) return false;
  if (typeof isResolvedStatus === "function" && isResolvedStatus(iv.status)) return false;
  // bloque aussi tant que l'analyse de disparition est en cours (_analyzing).
  // On évite de déplacer une iv dont l'état réel n'est pas encore déterminé —
  // sinon on pourrait drop un ticket qui sera retiré juste après (gone).
  if (iv._analyzing === true) return false;
  if (iv.missingSince) return false;   // absente du planning EV → pas déplaçable
  // v2026.5.46 — intervention sur PLUSIEURS jours : le drag ne sait
  // déplacer qu'un créneau d'un jour — à modifier dans EasyVista directement.
  if (ivIsMultiDay(iv)) return false;
  return true;
}

// Helpers de format / conversion
function _isoToDDMMYYYY(iso) {
  // "2026-05-04" → "04/05/2026"
  if (!iso || typeof iso !== "string") return "";
  const m = iso.match(/^(\d{4})-(\d{2})-(\d{2})$/);
  return m ? `${m[3]}/${m[2]}/${m[1]}` : "";
}
function _isoToDDMMYYYYNoSep(iso) {
  // "2026-05-04" → "04052026"
  if (!iso) return "";
  const m = String(iso).match(/^(\d{4})-(\d{2})-(\d{2})$/);
  return m ? `${m[3]}${m[2]}${m[1]}` : "";
}
function _ddmmyyyyToIso(ddmmyyyy) {
  // "04/05/2026" → "2026-05-04"
  if (!ddmmyyyy) return "";
  const m = String(ddmmyyyy).match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
  return m ? `${m[3]}-${m[2]}-${m[1]}` : "";
}
function _hhmmToMin(hhmm) {
  if (!hhmm) return null;
  const m = String(hhmm).match(/^(\d{1,2}):(\d{2})$/);
  if (!m) return null;
  return parseInt(m[1], 10) * 60 + parseInt(m[2], 10);
}
function _minToHHMM(min) {
  if (typeof min !== "number" || isNaN(min)) return "";
  const h = Math.floor(min / 60);
  const m = min % 60;
  return String(h).padStart(2, "0") + ":" + String(m).padStart(2, "0");
}

// Snap à 30 min (granularité EZV par défaut).
function _snap30(min) {
  return Math.round(min / 30) * 30;
}

// Trouve le tech destinataire à partir d'un élément DOM (pour le drag).
// Retourne {techId, techName, cardEl} ou null.
function _findTechTargetFromElement(el) {
  if (!el || !el.closest) return null;
  const card = el.closest(".card");
  if (!card) return null;
  const techId = card.dataset.techId;
  if (!techId) return null;
  // Récupère le nom depuis l'objet état
  let techName = "";
  if (state.currentData && state.currentData.techs) {
    const t = state.currentData.techs.find(t => String(t.id) === String(techId));
    if (t) techName = t.name || techId;
  }
  return { techId, techName, cardEl: card };
}

// Convertit la position X du curseur sur la timeline d'un tech en heure
// (snappée à 30 min). Retourne {hour, minute, totalMin}.
// on accepte aussi clientX hors plage de la timeline-bar (le user
// peut être sur la card-body, à gauche/droite des heures) — on clampe
// xRatio à [0, 1] au lieu de retourner null. Permet de droper depuis
// n'importe où dans la card, pas seulement sur la timeline.
// check si le tech cible est absent toute la journée — refuse le
// drop dans ce cas (pas d'iv possible).
function _isTargetTechAbsentAllDay(techId) {
  if (!state.currentData || !state.currentData.techs) return false;
  const tech = state.currentData.techs.find(t => String(t.id) === String(techId));
  if (!tech) return false;
  try {
    return typeof isTechAbsent === "function"
      ? !!isTechAbsent(tech, state.currentDate || "")
      : false;
  } catch (e) { return false; }
}

// retire à la fois le clone in-card et la barre timeline.
function _clearReschedulePlaceholders() {
  if (_rescheduleDrag.placeholder) {
    try { _rescheduleDrag.placeholder.el.remove(); } catch (e) {}
    _rescheduleDrag.placeholder = null;
  }
  if (_rescheduleDrag.timelineMark) {
    try { _rescheduleDrag.timelineMark.el.remove(); } catch (e) {}
    _rescheduleDrag.timelineMark = null;
  }
}

function _cursorToTimeOnTimeline(timelineBarEl, clientX) {
  if (!timelineBarEl) return null;
  const r = timelineBarEl.getBoundingClientRect();
  if (r.width <= 0) return null;
  let xRatio = (clientX - r.left) / r.width;
  if (xRatio < 0) xRatio = 0;
  else if (xRatio > 1) xRatio = 1;
  const { dayS: dayStart, dayE: dayEnd, dayLen } = _dayRange();
  let totalMin = dayStart + xRatio * dayLen;
  totalMin = _snap30(totalMin);
  if (totalMin < dayStart) totalMin = dayStart;
  if (totalMin > dayEnd) totalMin = dayEnd;
  return { hour: Math.floor(totalMin / 60), minute: totalMin % 60, totalMin };
}

// calcule l'heure projetée quand le curseur est dans la card-body
// (pas sur la timeline). Logique simple : "au-dessus / en-dessous" des iv
// existantes — l'heure se cale pour s'enchaîner avec la voisine sans
// chevauchement. Pour la précision exacte, le user repasse sur la
// timeline.
//
//  - Vue classique : l'ordre est vertical (clientY)
//  - Vue horizontale : l'ordre est horizontal (clientX) dans le bloc
//    Matin/Après-midi survolé
function _cardCursorToProjectedStart(targetCard, ev, durationMin, isHorizontal, opts) {
  if (!targetCard) return null;

  // Scope = card-body en classique, bloc Matin/Aprèm en horizontal
  let scope = targetCard;
  let blockPeriod = null;
  if (isHorizontal) {
    // les blocs Matin/Aprèm sont côte à côte horizontalement →
    // discrimination par clientX, pas clientY (avant on prenait toujours
    // le 1er bloc, donc impossible de cibler l'aprèm).
    const blocks = targetCard.querySelectorAll(".iv-mini-block");
    for (const b of blocks) {
      const r = b.getBoundingClientRect();
      if (ev.clientX >= r.left && ev.clientX <= r.right
          && ev.clientY >= r.top && ev.clientY <= r.bottom) {
        scope = b;
        if (b.classList.contains("period-morning")) blockPeriod = "morning";
        else if (b.classList.contains("period-afternoon")) blockPeriod = "afternoon";
        break;
      }
    }
  }

  const childSel = isHorizontal ? ".iv-mini-card" : ".intervention-v2";
  const techId = targetCard.dataset.techId;
  const tech = (state.currentData && state.currentData.techs)
    ? state.currentData.techs.find(t => String(t.id) === String(techId))
    : null;

  const items = [];
  if (tech) {
    const children = Array.from(scope.querySelectorAll(childSel)).filter(c =>
      !c.classList.contains("reschedule-source-hidden") &&
      !c.classList.contains("reschedule-drop-ghost"));
    for (const child of children) {
      const aid = child.dataset.actionId;
      if (!aid) continue;
      const iv = (tech.interventions || []).find(it => String(it.actionId) === String(aid));
      if (!iv || !_ivShownStart(iv) || !_ivShownEnd(iv)) continue;
      const sMin = _hhmmToMin(_ivShownStart(iv));
      const eMin = _hhmmToMin(_ivShownEnd(iv));
      if (sMin == null || eMin == null) continue;
      const r = child.getBoundingClientRect();
      items.push({
        startMin: sMin,
        endMin: eMin,
        top: isHorizontal ? r.left : r.top,
        bottom: isHorizontal ? r.right : r.bottom
      });
    }
  }
  items.sort((a, b) => a.startMin - b.startMin);

  const { dayS: dayStart, dayE: dayEnd } = _dayRange();

  if (items.length === 0) {
    // si on est sur un bloc horizontal vide → heure d'aprèm/matin
    // (13h00 / 8h00) pour permettre le placement même quand le bloc est
    // vide. En vue classique, on retombe sur l'heure d'origine.
    if (blockPeriod === "afternoon") return 13 * 60;
    if (blockPeriod === "morning") return Math.max(dayStart, 8 * 60);
    // v2026.5.46 — appelée aussi HORS drag (clic droit → résa) : ne
    // dépend plus d'un drag actif pour le repli (carte vide en classique).
    const orig = (_rescheduleDrag && _rescheduleDrag.iv) ? _hhmmToMin(_rescheduleDrag.iv.startTime) : null;
    return orig != null ? orig : dayStart;
  }

  const cursor = isHorizontal ? ev.clientX : ev.clientY;

  // logique fondée sur les bords, pas les centres :
  //   • cursor < top du 1er → avant le 1er
  //   • cursor dans le gap entre items[i] et items[i+1] → après items[i]
  //   • cursor sur items[i] → moitié haute = avant items[i] (= après i-1),
  //                           moitié basse = après items[i]
  //   • cursor > bottom du dernier → après le dernier
  // Beaucoup plus permissif pour insérer entre 2 iv collées : il suffit
  // de viser n'importe quelle des moitiés concernées (haut de la 2e ou
  // bas de la 1re).
  // (vue classique) : zones virtuelles Matin/Aprèm — si toutes les iv
  // visibles sont au matin et le curseur est sous la dernière → on cible
  // l'aprèm vide (13h00). Symétriquement matin si toutes en aprèm + curseur
  // au-dessus de la 1re. Évite d'avoir à ajouter une ligne séparatrice au
  // rendu de la card pour exposer la zone aprèm.
  const last = items[items.length - 1];
  const allMorning = !isHorizontal && items.every(it => it.startMin < 12 * 60);
  const allAfternoon = !isHorizontal && items.every(it => it.startMin >= 12 * 60);

  if (cursor < items[0].top) {
    if (allAfternoon) return Math.max(dayStart, 8 * 60);
    return Math.max(dayStart, items[0].startMin - durationMin);
  }
  for (let i = 0; i < items.length; i++) {
    const it = items[i];
    if (cursor < it.top) {
      return items[i - 1].endMin;
    }
    if (cursor <= it.bottom) {
      const mid = (it.top + it.bottom) / 2;
      if (cursor < mid) {
        if (i === 0) return Math.max(dayStart, it.startMin - durationMin);
        return items[i - 1].endMin;
      }
      return it.endMin;
    }
  }
  // zone virtuelle « après-midi vide » (13h) : utile au DRAG en vue classique,
  // mais PAS au clic droit (une iv 9h→10h cliquée en dessous doit
  // proposer la fin de l'iv, pas 13h).
  if (!(opts && opts.noVirtualPeriods) && allMorning && cursor > last.bottom + 4) return 13 * 60;
  return Math.min(dayEnd - durationMin, last.endMin);
}

// Liste des techs visibles dans le planning courant — pour le select de la
// modal d'édition. Inclut le tech de l'iv même si pas dans la liste actuelle.
function _getRescheduleTechOptions(currentIv) {
  const out = [];
  if (state.currentData && state.currentData.techs) {
    for (const t of state.currentData.techs) {
      out.push({ id: String(t.id), name: t.name || String(t.id) });
    }
  }
  // Si le tech actuel n'est pas dans la liste (rare mais possible) → l'ajouter
  if (currentIv && currentIv.techId && !out.some(o => o.id === String(currentIv.techId))) {
    out.unshift({ id: String(currentIv.techId), name: currentIv.techName || String(currentIv.techId) });
  }
  return out;
}

// ─── Modal d'édition (clic court sur le bloc heure) ─────────────────────────

function _showRescheduleEditModal(iv) {
  const existing = document.getElementById("reschedule-edit-modal");
  if (existing) existing.remove();

  const overlay = document.createElement("div");
  overlay.id = "reschedule-edit-modal";
  overlay.className = "modal-overlay";
  const card = document.createElement("div");
  card.className = "modal-card reschedule-modal";

  const h = document.createElement("h2");
  h.className = "modal-title";
  h.textContent = "Modifier l'horaire / déplacer";
  card.appendChild(h);

  const sub = document.createElement("p");
  sub.className = "modal-message";
  sub.style.cssText = "font-size:12px; color:var(--text-muted); margin:0 0 14px 0;";
  sub.textContent = `${iv.ref || "(sans ref)"} — ${iv.techName || ""}`;
  card.appendChild(sub);

  // Form layout
  const form = document.createElement("div");
  form.style.cssText = "display:flex; flex-direction:column; gap:10px; margin-bottom:18px;";

  // Date
  const dateRow = document.createElement("label");
  dateRow.style.cssText = "display:flex; align-items:center; gap:10px;";
  const dateLabel = document.createElement("span");
  dateLabel.textContent = "Date";
  dateLabel.style.cssText = "min-width:90px; font-size:13px; color:var(--text-muted);";
  const dateInput = document.createElement("input");
  dateInput.type = "date";
  dateInput.className = "admin-input";
  dateInput.value = state.currentDate || "";
  dateRow.appendChild(dateLabel);
  dateRow.appendChild(dateInput);
  form.appendChild(dateRow);

  // "Heure début" en 2 selects (heure 8-18 + minute 00/15/30/45)
  // pour que les minutes soient toujours logiques. + champ "Durée" en
  // slider 30 min → 4h par tranche de 15 min. endTime se calcule à
  // partir de startTime + durée.
  const ivStartMin = _hhmmToMin(iv.startTime) || (8 * 60);
  const ivEndMin = _hhmmToMin(iv.endTime) || (ivStartMin + 60);
  const ivDurationMin = Math.max(15, ivEndMin - ivStartMin);

  const startRow = document.createElement("label");
  startRow.style.cssText = "display:flex; align-items:center; gap:10px;";
  const startLabel = document.createElement("span");
  startLabel.textContent = "Heure début";
  startLabel.style.cssText = "min-width:90px; font-size:13px; color:var(--text-muted);";

  const hourSelect = document.createElement("select");
  hourSelect.className = "admin-select";
  hourSelect.style.cssText = "min-width:64px;";
  for (let h = 8; h <= 18; h++) {
    const o = document.createElement("option");
    o.value = String(h);
    o.textContent = String(h).padStart(2, "0") + " h";
    if (h === Math.floor(ivStartMin / 60)) o.selected = true;
    hourSelect.appendChild(o);
  }

  const minSelect = document.createElement("select");
  minSelect.className = "admin-select";
  minSelect.style.cssText = "min-width:64px;";
  for (const m of [0, 15, 30, 45]) {
    const o = document.createElement("option");
    o.value = String(m);
    o.textContent = String(m).padStart(2, "0");
    if (m === ivStartMin % 60) o.selected = true;
    minSelect.appendChild(o);
  }

  const sep = document.createElement("span");
  sep.textContent = ":";
  sep.style.cssText = "color:var(--text-muted); font-weight:700;";

  startRow.appendChild(startLabel);
  startRow.appendChild(hourSelect);
  startRow.appendChild(sep);
  startRow.appendChild(minSelect);
  form.appendChild(startRow);

  // Durée — slider 15 min → 4h (240 min), step 15 min
  const durRow = document.createElement("label");
  durRow.style.cssText = "display:flex; align-items:center; gap:10px;";
  const durLabel = document.createElement("span");
  durLabel.textContent = "Durée";
  durLabel.style.cssText = "min-width:90px; font-size:13px; color:var(--text-muted);";
  const durSlider = document.createElement("input");
  durSlider.type = "range";
  durSlider.min = "15";
  durSlider.max = "240";
  durSlider.step = "15";
  durSlider.value = String(Math.min(240, Math.max(15, ivDurationMin)));
  durSlider.style.cssText = "flex:1 1 auto;";
  const durDisplay = document.createElement("span");
  durDisplay.style.cssText = "min-width:64px; font-family:var(--mono,monospace); font-weight:700;";
  function _fmtDur(min) {
    const h = Math.floor(min / 60);
    const m = min % 60;
    if (h === 0) return `${m} min`;
    if (m === 0) return `${h} h`;
    return `${h} h ${String(m).padStart(2, "0")}`;
  }
  durDisplay.textContent = _fmtDur(parseInt(durSlider.value, 10));
  durSlider.addEventListener("input", () => {
    durDisplay.textContent = _fmtDur(parseInt(durSlider.value, 10));
  });
  durRow.appendChild(durLabel);
  durRow.appendChild(durSlider);
  durRow.appendChild(durDisplay);
  form.appendChild(durRow);

  // Tech
  const techRow = document.createElement("label");
  techRow.style.cssText = "display:flex; align-items:center; gap:10px;";
  const techLabel = document.createElement("span");
  techLabel.textContent = "Technicien";
  techLabel.style.cssText = "min-width:90px; font-size:13px; color:var(--text-muted);";
  const techSelect = document.createElement("select");
  techSelect.className = "admin-select";
  for (const opt of _getRescheduleTechOptions(iv)) {
    const o = document.createElement("option");
    o.value = opt.id;
    o.textContent = opt.name;
    if (String(iv.techId) === opt.id) o.selected = true;
    techSelect.appendChild(o);
  }
  techRow.appendChild(techLabel);
  techRow.appendChild(techSelect);
  form.appendChild(techRow);

  card.appendChild(form);

  // Boutons
  const actions = document.createElement("div");
  actions.className = "modal-actions";
  const cancelBtn = document.createElement("button");
  cancelBtn.type = "button";
  cancelBtn.className = "btn";
  cancelBtn.textContent = "Annuler";
  cancelBtn.addEventListener("click", () => overlay.remove());
  const saveBtn = document.createElement("button");
  saveBtn.type = "button";
  saveBtn.className = "btn btn-primary";
  saveBtn.textContent = "Enregistrer";
  saveBtn.addEventListener("click", async () => {
    const newDateIso = dateInput.value;
    const sH = parseInt(hourSelect.value, 10);
    const sM = parseInt(minSelect.value, 10);
    const dur = parseInt(durSlider.value, 10);
    const sMin = sH * 60 + sM;
    const eMin = sMin + dur;
    const newStart = `${String(sH).padStart(2, "0")}:${String(sM).padStart(2, "0")}`;
    const newEnd = `${String(Math.floor(eMin / 60)).padStart(2, "0")}:${String(eMin % 60).padStart(2, "0")}`;
    const newTechId = techSelect.value;
    if (!newDateIso || isNaN(sMin) || isNaN(dur) || dur <= 0) {
      showToast("Champs invalides", "Vérifie date / heure / durée");
      return;
    }
    if (eMin > 24 * 60) {
      showToast("Durée invalide", "L'heure de fin dépasse minuit");
      return;
    }
    saveBtn.disabled = true;
    saveBtn.textContent = "…";
    // on ferme la modal 1 seconde après le clic — le user voit le
    // feedback "…" puis la modal disparaît, sans rester figée pendant
    // toute la durée de l'API call + refresh.
    setTimeout(() => { try { overlay.remove(); } catch (e) {} }, 1000);
    try {
      await _applyReschedule(iv, {
        newDateIso,
        newStartTime: newStart,
        newEndTime: newEnd,
        newTechId
      });
    } catch (err) {
      LOG.warn("reschedule", "edit modal apply err", { err: err && err.message });
      showToast("Échec", err.message || "Impossible d'appliquer la modification");
    }
  });
  actions.appendChild(cancelBtn);
  actions.appendChild(saveBtn);
  card.appendChild(actions);

  overlay.appendChild(card);
  document.body.appendChild(overlay);

  // Échap ferme
  const escHandler = (e) => {
    if (e.key === "Escape") {
      overlay.remove();
      document.removeEventListener("keydown", escHandler);
    }
  };
  document.addEventListener("keydown", escHandler);
}

// ─── Drag tracking + ghost flottant + drop-ghost à destination ──────────────

const _rescheduleDrag = {
  active: false,
  iv: null,
  startX: 0, startY: 0,
  durationMin: 0,
  ghost: null,         // ghost flottant qui suit le curseur (clone visuel)
  placeholder: null,   // clone in-card grisé à la position chrono cible
  timelineMark: null,  // petite barre verte sur la timeline-bar cible
  hiddenSourceEls: null,
  lastTarget: null     // { techId, techName, cardEl, startMin, endMin }
};

function _attachRescheduleHandlers(timeEl, iv) {
  if (!_canRescheduleIv(iv)) return;
  timeEl.classList.add("editable-time");
  timeEl.setAttribute("title", "Cliquer pour modifier — glisser pour déplacer");

  // Empêcher le tooltip live de s'afficher quand la souris est sur ce bloc.
  timeEl.addEventListener("mouseenter", (e) => {
    e.stopPropagation();
    if (typeof hideTooltip === "function") {
      try { hideTooltip({ force: true }); } catch (err) {}
    }
  });
  // quand la souris quitte la zone heure pour revenir dans le
  // reste de la carte (zone texte, etc.), le mouseenter de la card
  // parente ne se redéclenche pas (on n'est jamais ressorti). Du coup
  // le tooltip force-hidé ci-dessus ne se ré-affichait plus tant qu'on
  // ne sortait pas complètement de la card. On le re-déclenche
  // manuellement ici.
  timeEl.addEventListener("mouseleave", (e) => {
    const container = timeEl.closest(".intervention-v2, .iv-mini-card");
    if (!container) return;
    if (e.relatedTarget && container.contains(e.relatedTarget)) {
      if (typeof showTooltip === "function") {
        try { showTooltip(e, iv, container); } catch (err) {}
      }
    }
  });

  // mousedown → setup, on attend le mousemove pour basculer en drag réel.
  timeEl.addEventListener("mousedown", (e) => {
    if (e.button !== 0) return; // bouton gauche uniquement
    e.preventDefault();
    e.stopPropagation();
    _startReschedulePotentialDrag(iv, e);
  });

  // Click direct (sans drag) → modal d'édition.
  timeEl.addEventListener("click", (e) => {
    e.stopPropagation();
    e.preventDefault();
    if (_rescheduleDrag.justDragged) {
      _rescheduleDrag.justDragged = false;
      return;
    }
    _showRescheduleEditModal(iv);
  });
}

function _startReschedulePotentialDrag(iv, ev) {
  const sMin = _hhmmToMin(iv.startTime);
  const eMin = _hhmmToMin(iv.endTime);
  if (sMin == null || eMin == null) return;
  _rescheduleDrag.active = false;
  _rescheduleDrag.justDragged = false;
  _rescheduleDrag.iv = iv;
  _rescheduleDrag.startX = ev.clientX;
  _rescheduleDrag.startY = ev.clientY;
  _rescheduleDrag.durationMin = Math.max(30, eMin - sMin);

  const onMove = (e) => {
    if (!_rescheduleDrag.iv) return;
    const dx = e.clientX - _rescheduleDrag.startX;
    const dy = e.clientY - _rescheduleDrag.startY;
    if (!_rescheduleDrag.active) {
      // Seuil de déclenchement du drag : 5 px
      if (Math.hypot(dx, dy) < 5) return;
      _activateRescheduleDrag(e);
    }
    _updateRescheduleGhost(e);
    _ivDockOnDragMove(e);
  };
  const detach = () => {
    document.removeEventListener("mousemove", onMove);
    document.removeEventListener("mouseup", onUp);
    document.removeEventListener("keydown", onKey, true);
  };
  const onUp = (e) => {
    detach();
    if (_rescheduleDrag.active) {
      _finalizeRescheduleDrag(e);
      _rescheduleDrag.justDragged = true;
    }
    _cleanupRescheduleDrag();
  };
  // Échap annule le drag — pas de POST EZV, pas de modal de
  // confirmation, on remet l'iv source à sa place visuellement (cleanup
  // restaure les éléments masqués).
  const onKey = (e) => {
    if (e.key !== "Escape") return;
    e.preventDefault();
    e.stopPropagation();
    detach();
    if (_rescheduleDrag.active) {
      LOG.info("reschedule", "drag cancelled (Escape)",
        { actionId: _rescheduleDrag.iv && _rescheduleDrag.iv.actionId });
      _rescheduleDrag.justDragged = true; // évite que le mouseup résiduel re-trigger un click
    }
    // Si on draguait depuis le dock, on remet l'iv dedans.
    if (_ivDockPendingRestore) {
      _ivDock.items.set(String(_ivDockPendingRestore.actionId), _ivDockPendingRestore);
      _ivDockPendingRestore = null;
      _ivDockRender();
      _ivDockUpdateVisibility();
    }
    _cleanupRescheduleDrag();
  };
  document.addEventListener("mousemove", onMove);
  document.addEventListener("mouseup", onUp);
  document.addEventListener("keydown", onKey, true);
}

function _activateRescheduleDrag(ev) {
  _rescheduleDrag.active = true;
  document.documentElement.classList.add("reschedule-dragging");
  // v2026.5.45 — drag effectivement démarré (5 px franchi) : si l'iv
  // vient du dock, c'est MAINTENANT qu'on la retire (mémorisée dans
  // _ivDockPendingRestore pour les chemins d'annulation : Échap / drop hors
  // zone / refus EV → restauration dans le dock).
  const _ivDrag = _rescheduleDrag.iv;
  if (_ivDrag && _ivDrag._fromDock && _ivDrag._dockSnap) {
    const _aid = String(_ivDrag._dockSnap.actionId);
    if (_ivDock.items.has(_aid)) {
      _ivDock.items.delete(_aid);
      _ivDockPendingRestore = _ivDrag._dockSnap;
      _ivDockRender();
    }
  }
  // Dès qu'un drag commence, le dock latéral apparaît (peep s'il a déjà
  // des cartes, dropzone si vide).
  if (typeof _ivDockUpdateVisibility === "function") _ivDockUpdateVisibility();

  const iv = _rescheduleDrag.iv;
  const aid = String(iv.actionId);

  // le ghost flottant intègre un CLONE VISUEL de la carte source
  // (row .intervention-v2 en vue classique, mini-card .iv-mini-card en
  // horizontale) — ainsi le user voit littéralement "sa carte" suivre
  // le curseur et pas juste un encadré texte. Le clone est figé à la
  // taille de la source au moment du drag pour rester reconnaissable.
  const isHorizontal = document.documentElement.classList.contains("view-horizontal");
  const srcSel = isHorizontal
    ? `.iv-mini-card[data-action-id="${aid}"]`
    : `.intervention-v2[data-action-id="${aid}"]`;
  let srcEl = document.querySelector(srcSel);
  let measuredWidth = 0;
  // Iv venant du dock : pas de DOM source dans le planning courant. On
  // reconstruit le visuel à partir du HTML capturé au dock-add → la carte
  // reprend sa forme standard pendant le drag.
  if (!srcEl && iv._dockHtml) {
    const tmp = document.createElement("div");
    tmp.innerHTML = iv._dockHtml;
    srcEl = tmp.firstElementChild;
  }
  if (srcEl && srcEl.isConnected) {
    measuredWidth = srcEl.getBoundingClientRect().width;
  }

  const ghost = document.createElement("div");
  ghost.className = "reschedule-ghost";
  if (isHorizontal) ghost.classList.add("reschedule-ghost-horizontal");

  if (srcEl) {
    const visual = srcEl.cloneNode(true);
    visual.classList.add("reschedule-ghost-visual");
    visual.classList.remove("reschedule-source-hidden");
    visual.removeAttribute("data-iv-idx");
    visual.removeAttribute("data-action-id");
    visual.removeAttribute("data-click-bound");
    if (measuredWidth > 0) visual.style.width = Math.round(measuredWidth) + "px";
    // v2026.5.45 — drag DEPUIS le dock : l'heure d'origine n'a plus de
    // sens (l'iv attend d'être reposée à un nouveau créneau). On retire le
    // bloc heure à gauche (.iv-time-vertical en classique, .iv-mini-time-vertical
    // en horizontale). Référence, adresse, contact, problème, etc. restent
    // visibles pour identifier la carte. La projection horaire pendant le
    // drag s'affiche dans le rg-meta du ghost flottant.
    if (iv._fromDock) {
      visual.querySelectorAll(".iv-time-vertical, .iv-mini-time-vertical").forEach(el => el.remove());
    }
    ghost.appendChild(visual);
  }

  const meta = document.createElement("div");
  meta.className = "rg-meta";
  meta.innerHTML =
    `<div class="rg-times" data-projected="">${escapeHtml(iv.startTime)} → ${escapeHtml(iv.endTime)}</div>` +
    `<div class="rg-dur">durée ${_rescheduleDrag.durationMin} min</div>`;
  ghost.appendChild(meta);

  document.body.appendChild(ghost);
  _rescheduleDrag.ghost = ghost;
  _positionRescheduleGhost(ev);

  // ordre important pour ne pas rétrécir la card d'origine —
  // 1. d'abord on insère le clone à destination à la position d'origine
  //    (mêmes heures, même tech), pour qu'il prenne déjà la place,
  // 2. puis on hide la source en display:none. La place perdue par la
  //    source est immédiatement reprise par le clone (même tick DOM).
  const srcCard = (() => {
    const aid = String(iv.actionId);
    const srcEl = document.querySelector(
      `.intervention-v2[data-action-id="${aid}"], .iv-mini-card[data-action-id="${aid}"]`);
    return srcEl ? srcEl.closest(".card") : null;
  })();
  if (srcCard) {
    const sStart = _hhmmToMin(iv.startTime);
    const sEnd = _hhmmToMin(iv.endTime);
    if (sStart != null && sEnd != null) {
      _updateReschedulePlaceholder(srcCard, sStart, sEnd);
    }
  }
  _hideRescheduleSource(iv);

  LOG.info("reschedule", "drag started",
    { actionId: iv.actionId, durationMin: _rescheduleDrag.durationMin });
}

function _hideRescheduleSource(iv) {
  const aid = String(iv.actionId);
  _rescheduleDrag.hiddenSourceEls = [];

  // Rows .intervention-v2 + mini-cards .iv-mini-card portant l'actionId source.
  document.querySelectorAll(
    `.intervention-v2[data-action-id="${aid}"], ` +
    `.iv-mini-card[data-action-id="${aid}"]`
  ).forEach(el => {
    el.classList.add("reschedule-source-hidden");
    _rescheduleDrag.hiddenSourceEls.push(el);
  });

  // Segments timeline (classique + horizontale) : pas de data-action-id
  // direct, on les retrouve via la row .intervention-v2 ayant le même
  // ivIdx dans la même card.
  document.querySelectorAll(`.intervention-v2[data-action-id="${aid}"]`).forEach(row => {
    const card = row.closest(".card");
    const ivIdx = row.dataset.ivIdx;
    if (!card || ivIdx == null) return;
    card.querySelectorAll(`.timeline-slot[data-iv-idx="${ivIdx}"]`).forEach(slot => {
      slot.classList.add("reschedule-source-hidden");
      _rescheduleDrag.hiddenSourceEls.push(slot);
    });
  });
}

function _restoreRescheduleSource() {
  if (_rescheduleDrag.hiddenSourceEls) {
    for (const el of _rescheduleDrag.hiddenSourceEls) {
      el.classList.remove("reschedule-source-hidden");
    }
  }
  _rescheduleDrag.hiddenSourceEls = null;
}

function _positionRescheduleGhost(ev) {
  const g = _rescheduleDrag.ghost;
  if (!g) return;
  g.style.left = (ev.clientX + 14) + "px";
  g.style.top = (ev.clientY + 14) + "px";
}

function _updateRescheduleGhost(ev) {
  _positionRescheduleGhost(ev);

  const g = _rescheduleDrag.ghost;
  if (!g) return;

  // v2026.5.45 — si le curseur est dans le rect visible du dock latéral,
  // on coupe net : pas de placeholder ni de marqueur timeline sur le tech qui
  // se trouve "en dessous" visuellement. Le drop sur le dock reste géré par
  // _ivDockHitTest dans le mouseup. getBoundingClientRect tient compte du
  // transform (peep-min / peep / expanded) donc on a le rect réel à l'écran.
  const dockEl = document.getElementById("iv-dock");
  if (dockEl && !dockEl.classList.contains("iv-dock--hidden")) {
    const dr = dockEl.getBoundingClientRect();
    if (dr.width > 0 && dr.height > 0
        && ev.clientX >= dr.left && ev.clientX <= dr.right
        && ev.clientY >= dr.top && ev.clientY <= dr.bottom) {
      _rescheduleDrag.lastTarget = null;
      g.classList.remove("on-target", "on-blocked");
      _clearReschedulePlaceholders();
      _updateRescheduleGhostText(null);
      return;
    }
  }

  // On masque temporairement le ghost pour que elementFromPoint trouve
  // l'élément dessous (sinon il pointe sur le ghost lui-même).
  g.style.pointerEvents = "none";
  const under = document.elementFromPoint(ev.clientX, ev.clientY);
  g.style.pointerEvents = "";

  const techTarget = _findTechTargetFromElement(under);
  if (!techTarget) {
    _rescheduleDrag.lastTarget = null;
    g.classList.remove("on-target", "on-blocked"); // reset rouge dehors
    _clearReschedulePlaceholders();
    _updateRescheduleGhostText(null);
    return;
  }

  // refuser le drop si le tech cible est absent toute la journée.
  // badge "absent" affiché UNIQUEMENT tant qu'on est dans la zone
  // de cette card (retiré dès qu'on sort, géré par le branch !techTarget).
  if (_isTargetTechAbsentAllDay(techTarget.techId)) {
    _rescheduleDrag.lastTarget = null;
    g.classList.remove("on-target");
    g.classList.add("on-blocked");
    _clearReschedulePlaceholders();
    _updateRescheduleGhostText(null);
    return;
  } else {
    g.classList.remove("on-blocked");
  }

  const bar = techTarget.cardEl.querySelector(".timeline-bar");

  // 2 modes — sur la timeline-bar = heure PRÉCISE (snap 30 min selon X) ;
  // ailleurs dans la card = ordre simple "au-dessus / en-dessous" des iv
  // existantes (heure auto-calée pour s'enchaîner sans chevauchement).
  const onTimeline = !!(under && under.closest && under.closest(".timeline-bar"));
  const isHorizontal = document.documentElement.classList.contains("view-horizontal");

  // v2026.5.46 — mode exact : la bande .iv-exact-row est une projection
  // linéaire du temps -> heure PRÉCISE (snap 30 min selon X) sur TOUTE la
  // ligne du tech (la timeline-bar, masquée dans ce mode, ne peut plus servir
  // de zone précise). Si la bande est cachée (vue classique), largeur nulle
  // -> projection nulle -> on retombe sur les modes historiques.
  const exactRowDrop = (HORIZONTAL_EXACT_MODE && isHorizontal)
    ? techTarget.cardEl.querySelector(".iv-exact-row") : null;
  const tExact = exactRowDrop ? _cursorToTimeOnTimeline(exactRowDrop, ev.clientX) : null;

  let startMin;
  if (tExact) {
    startMin = tExact.totalMin;
  } else if (onTimeline && bar) {
    const t = _cursorToTimeOnTimeline(bar, ev.clientX);
    if (!t) {
      g.classList.remove("on-target");
      _rescheduleDrag.lastTarget = null;
      _updateRescheduleGhostText(null);
      return;
    }
    startMin = t.totalMin;
  } else {
    startMin = _cardCursorToProjectedStart(
      techTarget.cardEl, ev, _rescheduleDrag.durationMin, isHorizontal);
    if (startMin == null) {
      g.classList.remove("on-target");
      _rescheduleDrag.lastTarget = null;
      _updateRescheduleGhostText(null);
      return;
    }
  }

  g.classList.add("on-target");

  const endMin = startMin + _rescheduleDrag.durationMin;

  // ghost de placement = overlay sur la timeline-bar du tech cible.
  // Visible que le curseur soit sur la timeline ou sur la card-body — on
  // détermine la card via elementFromPoint, et l'overlay reste collé sur
  // la timeline-bar de cette card jusqu'à ce qu'on change de tech.
  _updateReschedulePlaceholder(techTarget.cardEl, startMin, endMin);

  // Texte du ghost mis à jour avec NOUVEAU créneau + tech cible.
  _updateRescheduleGhostText({
    startMin, endMin,
    techName: techTarget.techName,
    techChanged: String(_rescheduleDrag.iv.techId) !== String(techTarget.techId)
  });

  _rescheduleDrag.lastTarget = {
    techId: techTarget.techId,
    techName: techTarget.techName,
    cardEl: techTarget.cardEl,
    hour: Math.floor(startMin / 60),
    minute: startMin % 60,
    totalMin: startMin,
    startMin, endMin
  };
}

// Met à jour le texte du ghost pour refléter le créneau projeté (vert) ou
// l'heure d'origine (gris si pas de cible valide).
function _updateRescheduleGhostText(projection) {
  const g = _rescheduleDrag.ghost;
  if (!g) return;
  const tEl = g.querySelector(".rg-times");
  const techEl = g.querySelector(".rg-tech");
  const iv = _rescheduleDrag.iv;
  if (!projection) {
    if (tEl) {
      tEl.textContent = `${iv.startTime} → ${iv.endTime}`;
      tEl.removeAttribute("data-projected");
    }
    if (techEl) techEl.textContent = iv.techName || "";
    return;
  }
  if (tEl) {
    tEl.textContent = `${_minToHHMM(projection.startMin)} → ${_minToHHMM(projection.endMin)}`;
    tEl.setAttribute("data-projected", "1");
  }
  if (techEl) {
    techEl.textContent = projection.techName || "";
    if (projection.techChanged) techEl.classList.add("rg-tech-changed");
    else techEl.classList.remove("rg-tech-changed");
  }
}

// Retour visuel à destination = (1) clone visuel grisé de la carte
// inséré dans la card-body / bloc Matin-Après-midi du tech cible à la
// bonne position chronologique + (2) petit rectangle vert sur la timeline
// pour repérer la position horaire précise. Plus de overlay timeline
// "complet". Le clone donne le retour visuel "voici la carte qui se
// loge ici", la barre verte donne la précision horaire.
function _updateReschedulePlaceholder(targetCard, newStartMin, newEndMin) {
  if (!targetCard) {
    if (_rescheduleDrag.placeholder) {
      try { _rescheduleDrag.placeholder.el.remove(); } catch (e) {}
      _rescheduleDrag.placeholder = null;
    }
    if (_rescheduleDrag.timelineMark) {
      try { _rescheduleDrag.timelineMark.el.remove(); } catch (e) {}
      _rescheduleDrag.timelineMark = null;
    }
    return;
  }

  // ─── 1. Marqueur sur la timeline-bar du tech cible ────────────────────────
  const bar = targetCard.querySelector(".timeline-bar");
  // v2026.5.46 — mode exact : le marqueur vert se pose sur la bande
  // continue (pleine hauteur), la timeline-bar étant masquée dans ce mode.
  const exactRow = HORIZONTAL_EXACT_MODE ? targetCard.querySelector(".iv-exact-row") : null;
  const markHost = exactRow || bar;
  if (markHost) {
    const { dayS: dayStart, dayE: dayEnd, dayLen } = _dayRange();
    const leftPct = ((newStartMin - dayStart) / dayLen) * 100;
    const widthPct = ((Math.min(newEndMin, dayEnd) - newStartMin) / dayLen) * 100;

    let mark;
    if (_rescheduleDrag.timelineMark && _rescheduleDrag.timelineMark.parentBar === markHost) {
      mark = _rescheduleDrag.timelineMark.el;
    } else {
      if (_rescheduleDrag.timelineMark) {
        try { _rescheduleDrag.timelineMark.el.remove(); } catch (e) {}
      }
      mark = document.createElement("div");
      mark.className = "reschedule-timeline-mark" + (exactRow ? " reschedule-exact-mark" : "");
      markHost.appendChild(mark);
      _rescheduleDrag.timelineMark = { el: mark, parentBar: markHost };
    }
    mark.style.left = leftPct + "%";
    mark.style.width = Math.max(1.5, widthPct) + "%";
  }

  // ─── 2. Clone visuel grisé de la carte dans la card-body / bloc ───────────
  // v2026.5.46 — mode exact : pas de clone (les blocs Matin/Après-midi
  // n'existent pas), le marqueur pleine hauteur ci-dessus donne le retour.
  if (exactRow) {
    if (_rescheduleDrag.placeholder) {
      try { _rescheduleDrag.placeholder.el.remove(); } catch (e) {}
      _rescheduleDrag.placeholder = null;
    }
    return;
  }
  const isHorizontal = document.documentElement.classList.contains("view-horizontal");
  const iv = _rescheduleDrag.iv;
  const aid = String(iv.actionId);

  let container;
  if (isHorizontal) {
    const period = newStartMin < 12 * 60 ? "morning" : "afternoon";
    container = targetCard.querySelector(`.iv-mini-block.period-${period} .iv-mini-block-cards`);
  } else {
    container = targetCard.querySelector(".card-body");
  }
  if (!container) return;

  const wantedKind = isHorizontal ? "horizontal" : "classic";

  let ph;
  if (_rescheduleDrag.placeholder
      && _rescheduleDrag.placeholder.kind === wantedKind
      && _rescheduleDrag.placeholder.container === container) {
    ph = _rescheduleDrag.placeholder.el;
  } else {
    if (_rescheduleDrag.placeholder) {
      try { _rescheduleDrag.placeholder.el.remove(); } catch (e) {}
    }
    const srcSel = isHorizontal
      ? `.iv-mini-card[data-action-id="${aid}"]`
      : `.intervention-v2[data-action-id="${aid}"]`;
    let srcEl = document.querySelector(srcSel);
    // v2026.5.45 — drag DEPUIS le dock : l'iv a été retirée du planning,
    // pas de srcEl trouvable. On reconstruit depuis iv._dockHtml (HTML capturé
    // au moment de l'ajout au dock) pour pouvoir afficher le ghost cloné dans
    // la card-body / bloc du tech survolé, exactement comme un drag normal.
    if (!srcEl && iv._dockHtml) {
      const tmp = document.createElement("div");
      tmp.innerHTML = iv._dockHtml;
      srcEl = tmp.firstElementChild;
    }
    if (!srcEl) return;
    ph = srcEl.cloneNode(true);
    // Le clone hérite des classes de la source, dont reschedule-source-hidden
    // (display:none) — on la retire impérativement, et on retire data-action-id
    // pour qu'il ne soit pas re-capté par les sélecteurs de la source.
    ph.classList.remove("reschedule-source-hidden");
    ph.classList.add("reschedule-drop-ghost");
    if (isHorizontal) ph.classList.add("reschedule-drop-ghost-mini");
    ph.removeAttribute("data-action-id");
    ph.removeAttribute("data-iv-idx");
    ph.removeAttribute("data-click-bound");
    _rescheduleDrag.placeholder = { el: ph, container, kind: wantedKind };
  }

  // Met à jour les heures dans le clone pour refléter le créneau projeté.
  const startSel = isHorizontal ? ".iv-mini-time-start" : ".iv-time-start";
  const endSel = isHorizontal ? ".iv-mini-time-end" : ".iv-time-end";
  const sEl = ph.querySelector(startSel);
  const eEl = ph.querySelector(endSel);
  if (sEl) sEl.textContent = _minToHHMM(newStartMin);
  if (eEl) eEl.textContent = _minToHHMM(newEndMin);

  // Insertion chronologique — avant la 1re iv dont startTime >= newStartMin
  // (>= au lieu de > : permet d'insérer entre 2 iv collées où la 2e
  // commence pile à l'heure de fin de la 1re). On filtre aussi la source
  // masquée pour qu'elle ne fausse pas l'ordre.
  const childSel = isHorizontal ? ".iv-mini-card" : ".intervention-v2";
  const children = Array.from(container.querySelectorAll(childSel)).filter(c =>
    !c.classList.contains("reschedule-source-hidden"));
  const startMinByActionId = new Map();
  if (state.currentData && state.currentData.techs) {
    for (const tech of state.currentData.techs) {
      for (const it of tech.interventions || []) {
        if (it.actionId && it.startTime) {
          const m = _hhmmToMin(it.startTime);
          if (m != null) startMinByActionId.set(String(it.actionId), m);
        }
      }
    }
  }
  let insertBefore = null;
  for (const c of children) {
    if (c === ph) continue;
    const childAid = c.dataset.actionId;
    const s = childAid ? startMinByActionId.get(String(childAid)) : null;
    if (s != null && s >= newStartMin) { insertBefore = c; break; }
  }
  if (ph.parentNode !== container || ph.nextSibling !== insertBefore) {
    if (insertBefore) container.insertBefore(ph, insertBefore);
    else container.appendChild(ph);
  }

  // Vue horizontale : cache l'éventuel placeholder "—" du bloc vide pour
  // que le clone occupe seul la place.
  if (isHorizontal) {
    const empty = container.parentElement.querySelector(".iv-mini-block-empty");
    if (empty) empty.style.display = "none";
  }
}

function _finalizeRescheduleDrag(ev) {
  const iv = _rescheduleDrag.iv;

  // Drop dans le dock latéral ?
  if (iv && _ivDockHitTest(ev.clientX, ev.clientY)) {
    if (iv._fromDock) {
      // déjà dans le dock — on ré-injecte le snapshot original
      if (_ivDockPendingRestore) {
        _ivDock.items.set(String(_ivDockPendingRestore.actionId), _ivDockPendingRestore);
        _ivDockPendingRestore = null;
        _ivDockRender();
        _ivDockUpdateVisibility();
      }
    } else {
      // Capture du DOM source AVANT le re-render (qui le ferait disparaître).
      const aid = String(iv.actionId);
      const srcEl = document.querySelector(
        `.intervention-v2[data-action-id="${aid}"], .iv-mini-card[data-action-id="${aid}"]`
      );
      const added = _ivDockAddItem(iv, srcEl);
      // v2026.5.46 — le dock est un filtre d'affichage : on ne touche
      // PLUS aux données, on re-projette simplement (storeProject saute les
      // iv parquées).
      if (added) {
        try { storeRenderCurrent("dock"); } catch (e) { /* render fail tolérée */ }
      }
    }
    return;
  }

  const tgt = _rescheduleDrag.lastTarget;
  if (!iv || !tgt) {
    LOG.info("reschedule", "drag canceled (no valid target)");
    // Si l'iv venait du dock et n'a pas de cible valide → la remettre
    if (iv && iv._fromDock && _ivDockPendingRestore) {
      _ivDock.items.set(String(_ivDockPendingRestore.actionId), _ivDockPendingRestore);
      _ivDockPendingRestore = null;
      _ivDockRender();
      _ivDockUpdateVisibility();
    }
    return;
  }
  // Date courante (drag = même jour)
  const isoDate = state.currentDate || "";
  const newStart = _minToHHMM(tgt.startMin);
  const newEnd = _minToHHMM(tgt.endMin);
  // Confirmation modal minimaliste
  _showRescheduleConfirmModal(iv, {
    newDateIso: isoDate,
    newStartTime: newStart,
    newEndTime: newEnd,
    newTechId: tgt.techId,
    newTechName: tgt.techName
  });
}

function _cleanupRescheduleDrag() {
  if (_rescheduleDrag.ghost) {
    try { _rescheduleDrag.ghost.remove(); } catch (e) {}
  }
  if (_rescheduleDrag.placeholder) {
    try { _rescheduleDrag.placeholder.el.remove(); } catch (e) {}
  }
  if (_rescheduleDrag.timelineMark) {
    try { _rescheduleDrag.timelineMark.el.remove(); } catch (e) {}
  }
  // Sécurité : retire tout orphelin restant
  document.querySelectorAll(
    ".reschedule-drop-ghost, .reschedule-timeline-mark, .reschedule-preview"
  ).forEach(p => { try { p.remove(); } catch (e) {} });
  _restoreRescheduleSource();
  // Restaure les placeholders "—" des blocs vides en horizontale qu'on
  // avait masqués pour laisser la place au clone.
  document.querySelectorAll(".iv-mini-block-empty").forEach(e => {
    e.style.display = "";
  });
  document.documentElement.classList.remove("reschedule-dragging");
  _rescheduleDrag.active = false;
  _rescheduleDrag.iv = null;
  _rescheduleDrag.ghost = null;
  _rescheduleDrag.placeholder = null;
  _rescheduleDrag.timelineMark = null;
  _rescheduleDrag.lastTarget = null;
  // Cleanup ne TOUCHE PAS _ivDockPendingRestore : le modal de confirmation
  // peut être encore ouvert (cleanup est synchrone, modal async). C'est le
  // modal (ou le handler Escape) qui décide du sort du pending.
  _ivDockSetExpanded(false);
  _ivDockUpdateVisibility();
}


// v2026.5.46 — badge « plusieurs jours » COMPACT : emoji calendrier +
// la date suivante (« 📅 ⇢ 16/06 »), ou la date de DEBUT quand on regarde le
// dernier jour (« 📅 ⇠ 10/06 »). Le format long debordait de la
// colonne des heures et passait par-dessus le texte de la carte. Periode
// complete au survol (title). Partage par les deux vues.
function _makeMultiDayBadge(iv, mini) {
  const here = _isoToDDMMYYYY(state.currentDate || "") || "";
  const sd = String(iv.startDate || "");
  const ed = String(iv.endDate || "");
  const isLastDay = (ed === here);
  const txt = isLastDay ? "\u21E0 " + sd.slice(0, 5) : "\u21E2 " + ed.slice(0, 5);
  // vertical : l'icone au-dessus, la date en dessous (l'horizontal
  // etait encore coupe dans la colonne des heures).
  const b = document.createElement("span");
  b.className = "iv-multiday-badge" + (mini ? " iv-multiday-badge-mini" : "");
  const ico = document.createElement("span");
  ico.className = "iv-multiday-ico";
  ico.textContent = "\u{1F4C5}";
  const dt = document.createElement("span");
  dt.className = "iv-multiday-date";
  dt.textContent = txt;
  b.appendChild(ico);
  b.appendChild(dt);
  b.title = "Intervention sur plusieurs jours : du " + sd + " " + (iv.startTime || "") +
    " au " + ed + " " + (iv.endTime || "");
  return b;
}

// v2026.5.46 — le tech CIBLE d'un deplacement a-t-il deja une
// intervention ou une reservation qui chevauche le creneau vise (jour cible) ?
// Retourne { hits: occupations en conflit (textes courts), slot: creneau
// libre le plus proche ou null } — ou null si aucun conflit.
// Best-effort : toute erreur → null (le modal de confirmation standard suffit).
async function _moveTargetBusy(iv, change) {
  try {
    const iso = change.newDateIso || state.currentDate;
    let ivs = null;
    if (iso === state.currentDate && state.currentDay) {
      ivs = state.currentDay.ivs || [];
    } else if (typeof storeLoad === "function") {
      const day = await storeLoad(iso);
      ivs = (day && day.ivs) || [];
    }
    if (!ivs || !ivs.length) return null;
    const ns = timeToMinutes(change.newStartTime);
    const ne = timeToMinutes(change.newEndTime);
    if (ns === null || ne === null || ne <= ns) return null;
    const { dayS, dayE } = _dayRange();
    const hits = [];
    const spans = [];   // toutes les occupations (pour chercher un trou)
    for (const o of ivs) {
      if (!o || String(o.techId) !== String(change.newTechId)) continue;
      if (o.type !== "AL-Intervention" && o.type !== "AL-Reservation") continue;
      if (String(o.actionId) === String(iv.actionId)) continue;
      if (typeof ivIsDead === "function" && ivIsDead(o)) continue;
      const st = (o.verdict && o.verdict.status) || "live";
      if (st !== "live" && st !== "done" && st !== "unknown") continue;
      let os, oe;
      if (typeof ivIsMultiDay === "function" && ivIsMultiDay(o)) {
        if (typeof _ivStampDisplayTimes === "function") _ivStampDisplayTimes(o, iso);
        os = timeToMinutes(_ivShownStart(o));
        oe = timeToMinutes(_ivShownEnd(o));
      } else {
        os = timeToMinutes(o.startTime);
        oe = timeToMinutes(o.endTime);
      }
      if (os === null || oe === null || oe <= os) continue;
      spans.push([os, oe]);
      if (os < ne && oe > ns) {
        const full = os <= dayS && oe >= dayE;
        const what = (o.type === "AL-Reservation") ? "reservation" : "intervention";
        hits.push((o.ref ? o.ref + " \u2014 " : "") + what +
          (full ? " TOUTE LA JOURNEE" : " " + _minToHHMMSafe(os) + "\u2013" + _minToHHMMSafe(oe)));
      }
    }
    if (!hits.length) return null;
    // creneau libre le plus proche pouvant accueillir la meme duree
    const slot = _findNearestFreeSlot(spans, ns, ne, dayS, dayE);
    return { hits, slot };
  } catch (e) {
    return null;
  }
}
// v2026.5.46 — cherche le creneau libre le plus PROCHE du creneau demande
// (avant ou apres) pouvant accueillir la meme duree, dans la plage du jour.
// spans = intervalles occupes [startMin, endMin] ; retourne {startMin, endMin}
// ou null si aucun trou assez long.
function _findNearestFreeSlot(spans, ns, ne, dayS, dayE) {
  const dur = ne - ns;
  if (dur <= 0) return null;
  const merged = _fusionnerPlages(spans);
  const holes = [];
  let cur = dayS;
  for (const m of merged) {
    if (m[0] > cur) holes.push([cur, Math.min(m[0], dayE)]);
    cur = Math.max(cur, m[1]);
    if (cur >= dayE) break;
  }
  if (cur < dayE) holes.push([cur, dayE]);
  let best = null;
  for (const h of holes) {
    if (h[1] - h[0] < dur) continue;
    const st = Math.max(h[0], Math.min(ns, h[1] - dur));
    const dist = Math.abs(st - ns);
    if (!best || dist < best.dist) best = { startMin: st, endMin: st + dur, dist };
  }
  return best;
}


// ─── Modal de confirmation post-drag ────────────────────────────────────────

function _showRescheduleConfirmModal(iv, change) {
  const fromTxt = `${iv.startTime}→${iv.endTime} · ${iv.techName || iv.techId || "?"}`;
  const toTxt = `${change.newStartTime}→${change.newEndTime} · ${change.newTechName || change.newTechId}`;
  const sameTech = String(iv.techId) === String(change.newTechId);
  const sameTimes = (iv.startTime === change.newStartTime && iv.endTime === change.newEndTime);
  if (sameTech && sameTimes) {
    LOG.info("reschedule", "no change detected → ignore");
    // v2026.5.45 — si l'iv venait du dock et que le drop tombe sur un
    // créneau identique à son origine (tech + heures), on n'ouvre pas le
    // modal. Mais SANS restauration explicite ici, l'iv reste en limbo
    // (retirée du dock à l'activation, jamais réinjectée) → invisible. Fix.
    if (iv && iv._fromDock && _ivDockPendingRestore) {
      _ivDock.items.set(String(_ivDockPendingRestore.actionId), _ivDockPendingRestore);
      _ivDockPendingRestore = null;
      _ivDockRender();
      _ivDockUpdateVisibility();
    }
    return;
  }
  // v2026.5.46 — avertissement si le tech cible a déjà une intervention
  // ou une réservation sur le créneau visé (journée complète incluse) :
  // Confirmer applique quand même le déplacement, Annuler ne touche pas EV
  // (et remet l'iv au dock si elle en venait — comportement existant).
  (async () => {
  let busy = null, freeSlot = null;
  try {
    const r = await _moveTargetBusy(iv, change);
    if (r) { busy = r.hits; freeSlot = r.slot; }
  } catch (e) { busy = null; }
  const hasConflict = !!(busy && busy.length);
  // v2026.5.46 — en plus du détail du conflit, proposer le créneau libre
  // le plus proche (avant ou après) qui peut accueillir la même durée.
  const busyHtml = hasConflict
    ? `<div style="margin-top:8px; padding:6px 8px; border-radius:6px; background:rgba(220,48,48,.08); border:1px solid rgba(220,48,48,.35); color:#dc3030; font-weight:600;">⚠ ${escapeHtml(change.newTechName || "Ce technicien")} est déjà occupé sur ce créneau :<br>` +
      busy.map(h => `• ${escapeHtml(h)}`).join("<br>") + `</div>` +
      (freeSlot
        ? `<div style="margin-top:6px; color:#0a7a3d; font-weight:600;">Créneau libre le plus proche : ${_minToHHMMSafe(freeSlot.startMin)}–${_minToHHMMSafe(freeSlot.endMin)}</div>`
        : `<div style="margin-top:6px; color:var(--text-muted);">Aucun créneau libre assez long ce jour-là.</div>`)
    : "";
  showAlertModal({
    title: hasConflict ? "⚠ Conflit — déplacer quand même ?" : "Confirmer le déplacement ?",
    message: `<div style="font-size:13px; line-height:1.7;">` +
             `<div><strong>De &nbsp;&nbsp;:</strong> ${escapeHtml(fromTxt)}</div>` +
             `<div><strong>Vers :</strong> ${escapeHtml(toTxt)}</div>` +
             busyHtml +
             `</div>`,
    html: true,
    buttons: (() => {
      // Annuler : rien ne part vers EV, l'iv revient à sa place (dock inclus).
      const restoreDock = () => {
        if (iv && iv._fromDock && _ivDockPendingRestore) {
          _ivDock.items.set(String(_ivDockPendingRestore.actionId), _ivDockPendingRestore);
          _ivDockPendingRestore = null;
          _ivDockRender();
          _ivDockUpdateVisibility();
        }
      };
      const doApply = async (chg) => {
        try {
          await _applyReschedule(iv, chg);
        } catch (err) {
          LOG.warn("reschedule", "confirm modal apply err", { err: err && err.message });
          showToast("Échec", err.message || "Impossible d'appliquer le déplacement");
          restoreDock();
        }
      };
      const btns = [{ label: "Annuler", variant: "secondary", action: restoreDock }];
      // v2026.5.46 — conflit + créneau libre trouvé : le bouton mis en
      // avant déplace vers le créneau LIBRE ; « quand même » garde le choix.
      if (hasConflict && freeSlot) {
        btns.push({ label: "Déplacer quand même", variant: "secondary", action: () => doApply(change) });
        btns.push({
          label: "Déplacer à " + _minToHHMMSafe(freeSlot.startMin) + " (libre)",
          variant: "primary",
          action: () => doApply(Object.assign({}, change, {
            newStartTime: _minToHHMMSafe(freeSlot.startMin),
            newEndTime: _minToHHMMSafe(freeSlot.endMin)
          }))
        });
      } else {
        btns.push({ label: hasConflict ? "Déplacer quand même" : "Confirmer", variant: "primary", action: () => doApply(change) });
      }
      return btns;
    })()
  });
  })();
}

// ─── Application : appel API + refresh ──────────────────────────────────────

async function _applyReschedule(iv, change) {
  const oldStart = iv.startTime;
  const oldEnd = iv.endTime;
  // v2026.5.46 — capture AVANT mutation du store (les projections
  // partagent les references : apres storeMarkMoved, iv.techId est deja le
  // nouveau tech) ; sert a la resynchronisation douchette automatique.
  const douchOldTechId = String(iv.techId);
  const douchOldTechName = iv.techName || "";
  const douchSourceIso = (iv._fromDock && iv._originalDate) ? iv._originalDate : state.currentDate;
  const newDateDDMM = _isoToDDMMYYYY(change.newDateIso);
  const newDateNoSep = _isoToDDMMYYYYNoSep(change.newDateIso);
  const sNewMin = _hhmmToMin(change.newStartTime);
  const eNewMin = _hhmmToMin(change.newEndTime);
  const sOldMin = _hhmmToMin(oldStart);
  const eOldMin = _hhmmToMin(oldEnd);
  const oldDuration = (sOldMin != null && eOldMin != null) ? (eOldMin - sOldMin) : null;
  const newDuration = (sNewMin != null && eNewMin != null) ? (eNewMin - sNewMin) : null;
  const techChanged = String(iv.techId) !== String(change.newTechId);
  const startChanged = oldStart !== change.newStartTime;
  const dateChanged = (state.currentDate || "") !== change.newDateIso;
  const durationChanged = (oldDuration !== null && newDuration !== null && oldDuration !== newDuration);

  showToast("Modification en cours", "Application sur EasyVista…");

  // Étape 1 : si tech / date / heure début ont changé → Planning_schedule_action_Employee
  if (techChanged || startChanged || dateChanged) {
    const r1 = await sendMessage({
      type: "rescheduleAction",
      actionId: iv.actionId,
      employeeId: change.newTechId,
      date: newDateDDMM,
      hour: Math.floor(sNewMin / 60),
      minute: sNewMin % 60
    });
    if (!r1 || !r1.ok) {
      const err = (r1 && r1.error) || "rescheduleAction failed";
      throw new Error(err);
    }
  }

  // Étape 2 : si la durée a changé → fc_save_inspector pour ajuster end_time
  if (durationChanged) {
    const suffix = `act_${iv.actionId}_nb_0_date_${newDateNoSep}`;
    const r2 = await sendMessage({
      type: "updateActionTimes",
      actionId: iv.actionId,
      suffix,
      startDate: newDateDDMM,
      endDate: newDateDDMM,
      startTime: change.newStartTime,
      endTime: change.newEndTime
    });
    if (!r2 || !r2.ok) {
      const err = (r2 && r2.error) || "updateActionTimes failed";
      throw new Error(err);
    }
  }

  showToast("Déplacement appliqué", "Rafraîchissement du planning…");

  // v2026.5.46 — le déplacement passe par le STORE (storeMarkMoved) :
  //   - autre date  → verdict moved + goneAt sur le store du jour SOURCE
  //     (mort propagée au dossier, plus d'analyse inutile) + fenêtre anti
  //     cache-serveur EV (_registerRecentMove, via storeMarkMoved) ;
  //   - même jour   → movedAt (la version déplacée gagne la fusion) + maj
  //     heure/tech directement sur l'enregistrement.
  // Le jour SOURCE est celui d'origine de l'iv : pour une iv venue du dock
  // (_fromDock), c'est _originalDate (elle a pu être parquée un autre jour),
  // sinon le jour affiché.
  try {
    const aid = String(iv.actionId);
    const sourceDateIso = (iv._fromDock && iv._originalDate) ? iv._originalDate : state.currentDate;
    const isSourceCurrent = (state.currentDate === sourceDateIso && state.currentDay &&
                             state.currentDay.date === sourceDateIso);
    const srcDay = isSourceCurrent ? state.currentDay : await storeLoad(sourceDateIso);
    const rec = srcDay ? (srcDay.ivs || []).find(r => String(r.actionId) === aid) : null;
    if (srcDay && rec) {
      // storeMarkMoved compare change.newDateIso à srcDay.date : autre date →
      // moved+goneAt+fenêtre ; même jour → movedAt + heures/tech.
      storeMarkMoved(srcDay, rec, change);
      await storeSave(sourceDateIso, srcDay);
    } else {
      // record introuvable (jour source jamais chargé ?) → au minimum la
      // fenêtre anti cache-serveur pour le jour source.
      if (change.newDateIso && change.newDateIso !== sourceDateIso) {
        _registerRecentMove(iv.actionId, sourceDateIso, change.newDateIso);
      }
      LOG.warn("reschedule", "record source introuvable dans le store (fenêtre posée)",
        { actionId: iv.actionId, sourceDateIso, target: change.newDateIso });
    }
    if (state.currentDate === sourceDateIso) {
      try { storeRenderCurrent("reschedule"); } catch (e) { /* render fail tolérée */ }
    }
  } catch (e) {
    LOG.warn("reschedule", "marquage store du déplacement échoué (best-effort)", { err: e && e.message });
  }

  // v2026.5.46 — resynchronisation douchette automatique des techniciens
  // impactes (jour source + jour cible), en parallele du refresh : le compte
  // rendu (toast confirme / modal probleme) s'affiche des que les envois
  // aboutissent, sans retarder le rafraichissement du planning.
  try {
    _douchetteAutoAfterMove(douchOldTechId, douchOldTechName, change, douchSourceIso).catch((e) => {
      LOG.warn("douchette", "resynchronisation auto apres deplacement : echec inattendu", { err: e && e.message });
    });
  } catch (e) { /* best-effort, le deplacement reste applique */ }

  // Refresh local pour refléter (le fresh EV confirme — ou la fenêtre
  // _recentlyMovedAway neutralise son cache serveur en retard).
  if (typeof loadForDate === "function") {
    await loadForDate(state.currentDate, { forceRefetch: true });
  }

  // Reschedule réussi : si l'iv venait du dock, on n'a plus à la restaurer.
  if (iv && iv._fromDock) _ivDockPendingRestore = null;
}

// v2026.5.46 — apres un deplacement reussi, la douchette des techniciens
// impactes est resynchronisee automatiquement : jour SOURCE pour l'ancien
// tech, jour CIBLE pour le nouveau — un seul envoi s'ils partagent le meme
// jour (empl_ids CSV), un seul couple si rien d'autre n'a change que l'heure.
// Compte-rendu : toast si tous les envois sont confirmes par EV (marqueur
//), modal detaillee si l'un d'eux echoue ou n'est pas confirme.
async function _douchetteAutoAfterMove(oldTechId, oldTechName, change, sourceIso) {
  const newTechId = String(change.newTechId || "");
  const targetIso = change.newDateIso || sourceIso;
  const nameOf = (id, hint) =>
    hint || (typeof TEAM !== "undefined" && TEAM && TEAM[id]) || ("tech " + id);
  // regroupe par jour : iso -> Map(techId -> nom affichable)
  const byDay = new Map();
  const add = (iso, id, hint) => {
    if (!iso || !id) return;
    if (!byDay.has(iso)) byDay.set(iso, new Map());
    byDay.get(iso).set(String(id), nameOf(String(id), hint));
  };
  add(sourceIso, oldTechId, oldTechName);
  add(targetIso, newTechId, change.newTechName);
  if (!byDay.size) return;
  const okParts = [];
  const koParts = [];
  for (const [iso, techs] of byDay) {
    const ids = [...techs.keys()];
    const label = [...techs.values()].join(" + ") + " (" + _isoToDDMMYYYY(iso).slice(0, 5) + ")";
    try {
      const r = await submitDouchette(ids, iso);
      if (r && r.okCount > 0 && r.confirmed) okParts.push(label);
      else if (r && r.okCount > 0) koParts.push(label + " : envoye mais sans la confirmation EV habituelle — verifie le planning");
      else koParts.push(label + " : echec de l'envoi");
    } catch (e) {
      koParts.push(label + " : " + ((e && e.message) || "erreur"));
    }
  }
  if (!koParts.length) {
    showToast("Douchette à jour — confirmé par EasyVista ✓", okParts.join(" · "));
  } else {
    showAlertModal({
      title: "Mise à jour douchette incomplète",
      message: '<div style="font-size:13px; line-height:1.7;">' +
        "<div>Le déplacement est bien appliqué, mais la synchronisation douchette n'est pas entièrement confirmée :</div>" +
        okParts.map(p => "<div>✓ " + escapeHtml(p) + "</div>").join("") +
        koParts.map(p => '<div style="color:#dc3030;">✗ ' + escapeHtml(p) + "</div>").join("") +
        '<div style="margin-top:8px;">Tu peux relancer à tout moment via le bouton douchette.</div>' +
        "</div>",
      html: true,
      buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
    });
  }
}


// ============================================================================
// Dock latéral — interventions mises de côté
// État client uniquement (vidé à chaque rechargement). Permet au coordinateur
// de glisser une iv dans une zone tampon à droite, naviguer entre les jours,
// puis la déposer sur une autre date. Aucun appel EV tant qu'aucun drop final
// n'est validé : l'iv reste sur EV à sa date d'origine et est juste filtrée
// du rendu local.
// ============================================================================

const _ivDock = {
  items: new Map(),     // actionId → snapshot iv
  maxItems: 12,
  expanded: false,
  visible: false,
};
let _ivDockPendingRestore = null; // iv qui vient du dock, à remettre si le drop n'aboutit pas

function _ivDockInit() {
  if (document.getElementById("iv-dock")) return;
  const dock = document.createElement("aside");
  dock.id = "iv-dock";
  dock.className = "iv-dock iv-dock--hidden";
  dock.innerHTML =
    `<button type="button" class="iv-dock-clear-all" id="iv-dock-clear-btn"
             title="Vide le dock — toutes les iv reviennent à leur jour d'origine">Tout annuler</button>
     <div class="iv-dock-list" id="iv-dock-list"></div>`;
  document.body.appendChild(dock);

  document.getElementById("iv-dock-clear-btn").addEventListener("click", _ivDockClearAll);

  // v2026.5.45 — debouncé 500 ms (anti-flicker quand le curseur effleure
  // le bord du dock).
  dock.addEventListener("mouseenter", () => {
    if (_ivDock.items.size > 0 || _rescheduleDrag.active) _ivDockSetExpandedDebounced(true);
  });
  dock.addEventListener("mouseleave", () => {
    if (!_rescheduleDrag.active) _ivDockSetExpandedDebounced(false);
  });

  _ivDockUpdateVisibility();
}

function _ivDockUpdateVisibility() {
  const dock = document.getElementById("iv-dock");
  if (!dock) return;
  const dragging = _rescheduleDrag.active;
  const hasItems = _ivDock.items.size > 0;

  // Aucune raison d'afficher : caché complet
  if (!dragging && !hasItems) {
    dock.classList.add("iv-dock--hidden");
    dock.classList.remove("iv-dock--peep-min", "iv-dock--peep", "iv-dock--expanded");
    _ivDock.visible = false;
    return;
  }
  dock.classList.remove("iv-dock--hidden");
  _ivDock.visible = true;

  // Hover sur le dock OU curseur proche du bord droit pendant un drag
  // → déploiement complet
  if (_ivDock.expanded) {
    dock.classList.add("iv-dock--expanded");
    dock.classList.remove("iv-dock--peep", "iv-dock--peep-min");
    return;
  }

  // Drag commencé alors qu'aucune iv n'est dans le dock → simple petit
  // onglet pour signaler la présence du dock sans cacher le planning
  if (dragging && !hasItems) {
    dock.classList.add("iv-dock--peep-min");
    dock.classList.remove("iv-dock--peep", "iv-dock--expanded");
    return;
  }

  // Le dock contient au moins une iv (drag actif ou pas) → mode
  // intermédiaire qui laisse voir le numéro de la DS sans pour autant
  // masquer le planning
  dock.classList.add("iv-dock--peep");
  dock.classList.remove("iv-dock--peep-min", "iv-dock--expanded");
}

function _ivDockSetExpanded(expanded) {
  // v2026.5.45 — toute mutation immédiate annule un éventuel délai
  // debouncé en cours (cas des callers de cleanup : drop committé, abort).
  if (_ivDockExpandTimer) {
    clearTimeout(_ivDockExpandTimer);
    _ivDockExpandTimer = null;
    _ivDockExpandTarget = null;
  }
  _ivDock.expanded = !!expanded;
  _ivDockUpdateVisibility();
}

// v2026.5.45 — délai de 500 ms pour expand/collapse, anti-flicker quand
// la souris s'approche/quitte le dock (drag) ou rentre/sort par hover.
//   - re-call vers la même cible : ignoré (timer déjà programmé OU état stable).
//   - re-call vers la cible opposée : annule le timer en cours, et reprogramme
//     ou no-op si l'état courant est déjà la nouvelle cible.
// Les callers de cleanup utilisent _ivDockSetExpanded directement (immédiat).
let _ivDockExpandTimer = null;
let _ivDockExpandTarget = null;
const _IV_DOCK_EXPAND_DELAY_MS = 500;
function _ivDockSetExpandedDebounced(expanded) {
  const target = !!expanded;
  if (_ivDockExpandTarget === target) return;                      // déjà en route
  if (_ivDockExpandTarget === null && _ivDock.expanded === target) return; // déjà arrivé
  if (_ivDockExpandTimer) {                                        // changement d'avis
    clearTimeout(_ivDockExpandTimer);
    _ivDockExpandTimer = null;
    _ivDockExpandTarget = null;
  }
  if (_ivDock.expanded === target) return;                         // l'annulation suffit
  _ivDockExpandTarget = target;
  _ivDockExpandTimer = setTimeout(() => {
    _ivDockExpandTimer = null;
    _ivDockExpandTarget = null;
    _ivDock.expanded = target;
    _ivDockUpdateVisibility();
  }, _IV_DOCK_EXPAND_DELAY_MS);
}

function _ivDockOnDragMove(ev) {
  if (!_rescheduleDrag.active) return;
  if (!_ivDock.visible) _ivDockUpdateVisibility();
  const w = window.innerWidth;
  const nearRight = ev.clientX > w - 140;
  // v2026.5.45 — on alimente le wrapper debouncé avec la cible voulue.
  // Le wrapper gère l'annulation si l'intention change avant 500 ms (le
  // curseur frôle le bord puis repart sans entrer franchement).
  _ivDockSetExpandedDebounced(nearRight);
}

function _ivDockHitTest(clientX, clientY) {
  const dock = document.getElementById("iv-dock");
  if (!dock || dock.classList.contains("iv-dock--hidden")) return false;
  // Pendant un drag, on est tolérant : tout drop dans la zone droite
  // de la fenêtre (≤200 px du bord) compte comme drop sur le dock,
  // peu importe que l'animation d'expansion soit terminée ou pas.
  // Évite les "ratés" quand l'utilisateur lâche pile pendant la
  // transition peep → expanded (200 ms de fenêtre sinon).
  if (_rescheduleDrag.active) {
    const w = window.innerWidth;
    if (clientX >= w - 200) return true;
  }
  const r = dock.getBoundingClientRect();
  return clientX >= r.left && clientX <= r.right && clientY >= r.top && clientY <= r.bottom;
}

function _ivDockAddItem(iv, sourceEl) {
  if (!iv || iv.actionId == null) return false;
  const aid = String(iv.actionId);
  if (_ivDock.items.has(aid)) return true;
  if (_ivDock.items.size >= _ivDock.maxItems) {
    if (typeof showToast === "function") {
      showToast("Dock plein", `Maximum ${_ivDock.maxItems} interventions à la fois — déposez d'abord celles déjà en attente.`);
    }
    return false;
  }
  // Capture du HTML rendu de la card source : on aura un look identique au
  // planning (mêmes classes, même structure interne) sans devoir le ré-bâtir.
  // On clone d'abord pour pouvoir retirer la classe `reschedule-source-hidden`
  // (display:none) appliquée pendant le drag — sinon le clone serait invisible.
  let html = null;
  let srcNode = sourceEl;
  if (!srcNode) {
    srcNode = document.querySelector(
      `.intervention-v2[data-action-id="${aid}"], .iv-mini-card[data-action-id="${aid}"]`
    );
  }
  if (srcNode) {
    const clone = srcNode.cloneNode(true);
    clone.classList.remove("reschedule-source-hidden");
    clone.removeAttribute("data-click-bound");
    html = clone.outerHTML;
  }
  // v2026.5.45 — couleur catégorie : on LIT directement la classe
  // color-* posée sur la card source du planning. C'est la source de vérité
  // visuelle (calculée au render, donc avec toutes les données disponibles).
  // Garantit que le dock affiche exactement la même couleur que la planif.
  let colorKeyFromSrc = null;
  if (srcNode && srcNode.classList) {
    for (const cls of srcNode.classList) {
      if (cls.indexOf("color-") === 0) { colorKeyFromSrc = cls.slice(6); break; }
    }
  }
  const snapshot = {
    actionId: iv.actionId,
    requestId: iv.requestId,
    techId: iv.techId,
    techName: iv.techName,
    type: iv.type,
    ref: iv.ref,
    label: iv.label,
    startDate: iv.startDate,
    endDate: iv.endDate,
    startTime: iv.startTime,
    endTime: iv.endTime,
    bulleContact: iv.bulleContact,
    bulleLieu: iv.bulleLieu,
    categoryLine: iv.categoryLine,
    formLink: iv.formLink,
    deadline: iv.deadline,
    cssClass: iv.cssClass,
    isPompier: iv.isPompier,
    // v2026.5.45 — on capture la couleur catégorie AU MOMENT de l'add,
    // tant qu'on a l'iv complète (avec bulleDescription/infobulle, dont
    // dépendent isRollOut et isRecupAction). Sans ça, _ivDockRender qui
    // rappelle deriveColorKey(snap) tombe sur "autre" → trait gris.
    colorKey: colorKeyFromSrc
      || (typeof deriveColorKey === "function" ? deriveColorKey(iv) : "")
      || "autre",
    // state.currentDate est toujours ISO (YYYY-MM-DD) → format sûr pour
    // formatDateDM. iv.startDate peut être au format DD/MM/YYYY EV → on
    // privilégie state.currentDate qui est l'origine effective d'affichage.
    _originalDate: state.currentDate || iv.startDate || null,
    _html: html,
  };
  _ivDock.items.set(aid, snapshot);
  _ivDockRender();
  _ivDockUpdateVisibility();
  return true;
}

// v2026.5.46 — le dock est un PUR filtre d'affichage (storeProject saute
// les iv parquées) : les données du store ne sont jamais trouées. Retirer une
// iv du dock = simple re-projection, aucun rechargement réseau nécessaire.
function _ivDockRemoveItem(actionId) {
  if (!_ivDock.items.delete(String(actionId))) return;
  _ivDockRender();
  _ivDockUpdateVisibility();
  storeRenderCurrent("dock");
}

function _ivDockClearAll() {
  if (_ivDock.items.size === 0) return;
  _ivDock.items.clear();
  _ivDockRender();
  _ivDockUpdateVisibility();
  storeRenderCurrent("dock");
}

function _ivDockRender() {
  const list = document.getElementById("iv-dock-list");
  if (!list) return;
  list.innerHTML = "";
  for (const [aid, snap] of _ivDock.items) {
    // Layout dock minimaliste : juste la ref + la date d'origine, fond
    // teinté par la couleur de la catégorie de l'iv. Pas d'heure (elle
    // réapparaîtra au drag, dans la forme standard de la carte).
    const wrapper = document.createElement("div");
    wrapper.className = "iv-dock-card reschedule-ghost";
    wrapper.dataset.actionId = aid;
    // v2026.5.45 — la classe color-* + règle CSS ne s'appliquent visiblement
    // pas (cause non identifiée). On force le style inline du border-left avec
    // var(--c-<key>) qui résout au niveau du wrapper. Inline > toute règle.
    // data-color-key permet d'inspecter ce qui a été détecté.
    const colorKey = snap.colorKey
      || (typeof deriveColorKey === "function" ? deriveColorKey(snap) : "")
      || "autre";
    wrapper.classList.add("color-" + colorKey);
    wrapper.dataset.colorKey = colorKey;
    wrapper.style.borderLeft = "4px solid var(--c-" + colorKey + ")";
    // v2026.5.45 — pas de title (= pas de tooltip natif au hover).

    const ref = snap.ref || (snap.actionId ? "#" + snap.actionId : "(sans réf)");
    // v2026.5.45 — durée prévue calculée depuis snap.startTime/endTime, on
    // n'affiche plus la date d'origine. Format compact : "1h", "1h30", "45min".
    let durationLabel = "";
    const sMin = _hhmmToMin(snap.startTime);
    const eMin = _hhmmToMin(snap.endTime);
    if (Number.isFinite(sMin) && Number.isFinite(eMin) && eMin > sMin) {
      const total = eMin - sMin;
      const h = Math.floor(total / 60);
      const m = total % 60;
      if (h === 0) durationLabel = m + "min";
      else if (m === 0) durationLabel = h + "h";
      else durationLabel = h + "h" + (m < 10 ? "0" + m : String(m));
    }

    wrapper.innerHTML =
      `<div class="iv-dock-card-info">
         <div class="iv-dock-card-ref">${escapeHtml(ref)}</div>
         ${durationLabel ? `<div class="iv-dock-card-meta">${escapeHtml(durationLabel)}</div>` : ""}
       </div>`;

    const removeBtn = document.createElement("button");
    removeBtn.type = "button";
    removeBtn.className = "iv-dock-card-remove";
    removeBtn.textContent = "×";
    wrapper.appendChild(removeBtn);
    // v2026.5.45 — retrait par appui long (2 s) sur le bouton ×.
    // Un clic simple ne fait RIEN (le mouseup avant 2 s annule le timer).
    // mouseleave et bouton hors-zone annulent aussi pour éviter les retraits
    // accidentels si l'utilisateur garde le doigt et déplace la souris.
    let _holdRemoveTimer = null;
    const _cancelHoldRemove = () => {
      if (_holdRemoveTimer) { clearTimeout(_holdRemoveTimer); _holdRemoveTimer = null; }
      removeBtn.classList.remove("holding");
    };
    removeBtn.addEventListener("mousedown", (e) => {
      if (e.button !== 0) return;
      e.stopPropagation();
      e.preventDefault();
      _cancelHoldRemove();
      removeBtn.classList.add("holding");
      _holdRemoveTimer = setTimeout(() => {
        _holdRemoveTimer = null;
        removeBtn.classList.remove("holding");
        _ivDockRemoveItem(aid);
      }, 2000);
    });
    removeBtn.addEventListener("mouseup",    (e) => { e.stopPropagation(); _cancelHoldRemove(); });
    removeBtn.addEventListener("mouseleave", _cancelHoldRemove);
    // Bloquer le click natif (qui se déclenche après mousedown+mouseup) pour
    // éviter qu'il remonte au wrapper et qu'il déclenche autre chose.
    removeBtn.addEventListener("click", (e) => { e.stopPropagation(); e.preventDefault(); });

    list.appendChild(wrapper);

    // Drag handle = la carte entière. Maintenir + bouger > 5 px lance le
    // drag avec la carte sous sa forme standard. Clic seul = rien (pas
    // de listener click).
    wrapper.addEventListener("mousedown", (e) => {
      if (e.button !== 0) return;
      // Clic sur le bouton × : laisser le bouton gérer.
      if (e.target.closest(".iv-dock-card-remove")) return;
      e.preventDefault();
      e.stopPropagation();
      _ivDockStartDragFromDock(snap, e);
    });
  }
}

function _ivDockStartDragFromDock(snap, ev) {
  // v2026.5.45 — on n'enlève PAS l'iv du dock au mousedown. Un clic
  // simple (mousedown puis mouseup sans déplacement) ne doit rien faire et
  // l'iv doit rester visible dans le dock — d'où l'absence de flicker.
  // Le retrait effectif est différé à _activateRescheduleDrag, déclenché
  // quand le seuil de 5 px est franchi (= vrai drag). _dockSnap permet à
  // l'activation de retrouver le snap exact à retirer + à mémoriser pour
  // restauration en cas d'annulation.
  const ivForDrag = { ...snap, _fromDock: true, _dockHtml: snap._html, _dockSnap: snap };
  _startReschedulePotentialDrag(ivForDrag, ev);
}

function buildInterventionRow(iv, cardEl) {
  const row = document.createElement("div");
  row.className = "intervention-v2";
  row.dataset.actionId = iv.actionId;
  if (iv.ref) row.dataset.ref = String(iv.ref);   // v2026.5.46 — surbrillance recherche par réf
  if (iv.isPompier) row.classList.add("is-pompier-line");
  // v2026.5.41 : intervention en conflit avec une absence/réservation → rouge plein
  if (iv._absenceConflict) row.classList.add("intervention-conflict-absence");
  // conflit horaire entre 2 interventions → carte rouge
  if (iv._hasOverlap) row.classList.add("intervention-conflict-overlap");
  // indicateur visuel "en cours d'analyse" — disparue en attente/en cours de
  // verdict (missingSince sans verdict, ou analyse active) → carte grisée.
  if (iv._analyzing || (iv.missingSince && ivVStatus(iv) === "live")) row.classList.add("_checking");
  // marqueur pour décaler la signature à gauche quand un ✓ est ajouté
  // (sinon le check se superpose à la signature).
  // terminated-suspended a aussi un ✓ (jaune), même décalage.
  // rideau horaire — on n'ajoute le marqueur que si le verdict est
  // révélé (sinon on n'affiche rien du tout pour cette iv).
  const _rowRevealed = _isVerdictRevealed(iv);
  if (_rowRevealed && (ivVStatus(iv) === "done" || ivVStatus(iv) === "suspended")) {
    row.classList.add("has-pending-check");
  }
  if (_rowRevealed && ivVStatus(iv) === "suspended") row.classList.add("status-suspended");

  const colorKey = deriveColorKey(iv);
  row.classList.add("color-" + colorKey);

  const statusClass = getStatusClass(iv);
  if (statusClass) row.classList.add(statusClass);

  const ivIdx = cardEl._rowIdxCounter || 0;
  cardEl._rowIdxCounter = ivIdx + 1;
  row.dataset.ivIdx = ivIdx;

  if (iv.formLink && !iv._analyzing && iv.type !== "AL-Absence") {
    row.classList.add("clickable");
    row.dataset.clickBound = "1";
    // v4.1.8 : plus de title au survol (info déjà dans le tooltip en bas)

    // Clic normal : ouvre l'onglet et change de page
    // Ctrl/Cmd+Clic : ouvre en arrière-plan (reste sur le planning)
    row.addEventListener("click", (e) => {
      if (e.target.closest(".intervention-copy")) return;
      const background = !!(e.ctrlKey || e.metaKey);
      openInterventionInNewTab(iv, { background });
    });

    // Clic molette (button === 1) : ouvre en arrière-plan
    // On utilise 'auxclick' pour les boutons du milieu/droite (standard W3C).
    row.addEventListener("auxclick", (e) => {
      if (e.button !== 1) return; // que la molette
      if (e.target.closest(".intervention-copy")) return;
      e.preventDefault();
      openInterventionInNewTab(iv, { background: true });
    });

    // Empêcher le scroll auto quand on clique la molette sur la ligne
    row.addEventListener("mousedown", (e) => {
      if (e.button === 1) e.preventDefault();
    });
  }

  // Pastille colorée à gauche (barre verticale, toute la hauteur)
  const dot = document.createElement("div");
  dot.className = "intervention-dot";
  row.appendChild(dot);

  // ─── Ligne 1 : Ref centrée (TITRE en gros + gras) ────────────────────────
  const refHeader = document.createElement("div");
  refHeader.className = "iv-ref-header";
  if (iv.type === "AL-Reservation") {
    const _hasResMeta = !!(iv.resNumero || iv.resVille || iv.resRue || iv.resCategorie);
    // v2026.5.46 — titre = « Réservé » seul ; le n° DS passe sur sa propre
    // ligne juste en dessous (rendu dans rightCol). Sans meta (réservation créée
    // directement dans EV) → « Réservation ».
    refHeader.textContent = _hasResMeta ? "Réservé" : "Réservation";
    refHeader.classList.add("is-reservation-title");
  } else if (iv.type === "AL-Absence") {
    // v5.0.15 : absence partielle (demi-journée) affichée comme une row
    refHeader.textContent = "Absence";
    refHeader.classList.add("is-absence-title");
  } else if (iv.ref) {
    refHeader.textContent = iv.ref;
  } else {
    refHeader.textContent = "—";
    refHeader.classList.add("no-ref");
  }
  row.appendChild(refHeader);

  // Check ✓ + bouton copier à droite de la ref (pas pour réservation / absence)
  // on ajoute aussi un ✓ pour "terminated-pending" (gris) et un
  // ✓ pour "terminated-suspended" (jaune) — sans rendre la carte verte.
  // rideau horaire — pas de ✓ tant que pas révélé.
  const showPendingCheck = _rowRevealed && ivVStatus(iv) === "done";
  const showSuspendedCheck = _rowRevealed && ivVStatus(iv) === "suspended";
  if ((statusClass || showPendingCheck || showSuspendedCheck) &&
      iv.type !== "AL-Reservation" && iv.type !== "AL-Absence") {
    const statusEl = document.createElement("div");
    statusEl.className = "iv-status-check";
    if (showSuspendedCheck) statusEl.classList.add("suspended");
    if (statusClass === "status-closed" || statusClass === "status-resolved") {
      statusEl.textContent = "✓✓";
      statusEl.classList.add("double");
    } else {
      statusEl.textContent = "✓";
    }
    row.appendChild(statusEl);
  }
  if (iv.ref && iv.type !== "AL-Reservation" && iv.type !== "AL-Absence") {
    const copyBtn = document.createElement("button");
    copyBtn.className = "intervention-copy";
    copyBtn.type = "button";
    copyBtn.title = "Copier la référence";
    copyBtn.innerHTML = "📋";
    copyBtn.addEventListener("click", (e) => {
      e.stopPropagation();
      copyRef(iv.ref, copyBtn);
    });
    row.appendChild(copyBtn);
  }

  // si la fiche n'a pas pu être récupérée correctement.
  // v2026.5.46 — masqué si le est périmé (fiche finalement lue : verdict
  // réussi / statut clos).
  if (iv._fetchWarning && !_staleFetchWarning(iv)) {
    const warnEl = document.createElement("div");
    warnEl.className = "iv-fetch-warning";
    warnEl.textContent = "⚠";
    warnEl.title = "Fiche partiellement récupérée — vérifie ta session EasyVista";
    row.appendChild(warnEl);
  }

  // ─── Ligne 2 gauche : heures VERTICALES (début / ↓ / fin) ─────────────────
  const timeEl = document.createElement("div");
  timeEl.className = "iv-time-vertical";
  // v4.3.0 : marquer rouge + icône si conflit horaire détecté
  if (iv._hasOverlap) {
    timeEl.classList.add("iv-time-overlap");
  }
  if (_ivShownStart(iv) && _ivShownEnd(iv)) {
    const s = document.createElement("div");
    s.className = "iv-time-start";
    s.textContent = _ivShownStart(iv);
    const sep = document.createElement("div");
    sep.className = "iv-time-arrow";
    sep.textContent = "↓";
    const e = document.createElement("div");
    e.className = "iv-time-end";
    e.textContent = _ivShownEnd(iv);
    timeEl.appendChild(s);
    timeEl.appendChild(sep);
    timeEl.appendChild(e);
    // v2026.5.46 — intervention sur PLUSIEURS jours : badge pilule bien
    // visible sous les heures (période complète dans le title + le tooltip).
    if (ivIsMultiDay(iv)) {
      timeEl.appendChild(_makeMultiDayBadge(iv, false));
    }
    // v4.3.0 : icône d'alerte à côté des heures si conflit
    if (iv._hasOverlap) {
      const warn = document.createElement("div");
      warn.className = "iv-time-overlap-warn";
      warn.textContent = "⚠";
      warn.title = "Conflit d'horaire avec une autre intervention";
      timeEl.appendChild(warn);
    }
  } else {
    timeEl.textContent = "—";
  }
  // (feature reschedule) : si l'iv est éditable, on attache les handlers
  // de clic (modal) + drag (déplacement vers autre tech / créneau).
  if (typeof _attachRescheduleHandlers === "function") {
    _attachRescheduleHandlers(timeEl, iv);
  }
  row.appendChild(timeEl);

  // ─── Ligne 2 droite : lieu / contact+tél / catégorie+signature ───────────
  // Pour une RÉSERVATION : affichage différent (par + sujet)
  const rightCol = document.createElement("div");
  rightCol.className = "iv-right";

  if (iv.type === "AL-Reservation") {
    const _hasResMeta = !!(iv.resNumero || iv.resVille || iv.resRue || iv.resCategorie);
    if (_hasResMeta) {
      // v2026.5.46 — ordre demandé : n° DS (sous « Réservé »), puis adresse
      // (rendue comme une intervention planifiée), puis le type en pastille
      // colorée. Pas de « Par » ni « Sujet » pour les réservations de l'extension.
      if (iv.resNumero) {
        const numEl = document.createElement("div");
        numEl.className = "iv-reservation-ds";
        numEl.textContent = iv.resNumero;
        rightCol.appendChild(numEl);
      }
      // v2026.5.46 — séparateur « / » (et non «, ») pour que splitLieu
      // découpe VILLE (gras majuscules) + adresse (italique), exactement comme
      // une intervention planifiée.
      const _resAdr = [iv.resVille, iv.resRue].filter(Boolean).join(" / ");
      if (_resAdr && typeof renderLieuContactBlocks === "function") {
        try { renderLieuContactBlocks(rightCol, _resAdr, null); } catch (e) {}
      }
      if (iv.resCategorie) {
        const ckRes = _resTypeColorKey(iv.resCategorie) || "autre";
        const tEl = document.createElement("div");
        tEl.className = "iv-reservation-sujet";
        tEl.style.cssText = "margin-top:3px;";
        const pill = document.createElement("span");
        pill.textContent = iv.resCategorie;
        pill.style.cssText = "display:inline-block; padding:2px 9px; border-radius:10px; font-weight:600; font-size:11px; background:var(--c-" + ckRes + "-soft); color:var(--c-" + ckRes + ");";
        tEl.appendChild(pill);
        rightCol.appendChild(tEl);
      }
      // v2026.5.46 — qui a créé la réservation, affiché aussi sur la carte.
      if (iv.reservationCreator) {
        const parEl = document.createElement("div");
        parEl.className = "iv-reservation-par";
        parEl.style.marginTop = "3px";
        parEl.textContent = "Par " + iv.reservationCreator;
        rightCol.appendChild(parEl);
      }
    } else {
      // Réservation créée DIRECTEMENT dans EV (pas de meta extension) → on garde
      // l'ancien affichage « Par … » + « Sujet : … ».
      if (iv.reservationCreator) {
        const parEl = document.createElement("div");
        parEl.className = "iv-reservation-par";
        parEl.textContent = "Par " + iv.reservationCreator;
        rightCol.appendChild(parEl);
      }
      if (iv.reservationLabel) {
        const sujetEl = document.createElement("div");
        sujetEl.className = "iv-reservation-sujet";
        sujetEl.textContent = "Sujet : " + iv.reservationLabel;
        rightCol.appendChild(sujetEl);
      }
    }
    row.appendChild(rightCol);

    // Tooltip (fixe, ne suit pas la souris — v4.1.12)
    row.addEventListener("mouseenter", (e) => {
      showTooltip(e, iv, row);
      highlightIntervention(cardEl, ivIdx, true);
    });
    row.addEventListener("mouseleave", () => {
      hideTooltip();
      highlightIntervention(cardEl, ivIdx, false);
    });
    return row;
  }

  // v5.0.15 : absence partielle (demi-journée) affichée comme une row au
  // même style que les réservations mais en gris foncé, avec le type d'absence
  // (Congés, Maladie, Pompier) comme sujet.
  if (iv.type === "AL-Absence") {
    // Bloc "Par Nom, Prénom" si on a un créateur
    if (iv.reservationCreator) {
      const parEl = document.createElement("div");
      parEl.className = "iv-reservation-par";
      parEl.textContent = "Par " + iv.reservationCreator;
      rightCol.appendChild(parEl);
    }
    // Type d'absence (Congés, Maladie, Pompier) si dispo dans label
    const absenceTypeMatch = (iv.label || "").match(/^([^/]+?)\s*(?:\/|$)/);
    const absenceType = absenceTypeMatch ? absenceTypeMatch[1].trim() : null;
    if (absenceType) {
      const sujetEl = document.createElement("div");
      sujetEl.className = "iv-reservation-sujet";
      sujetEl.textContent = "Type : " + absenceType;
      rightCol.appendChild(sujetEl);
    }
    row.appendChild(rightCol);

    // Tooltip au hover (avec bouton supprimer)
    row.addEventListener("mouseenter", (e) => {
      showTooltip(e, iv, row);
      highlightIntervention(cardEl, ivIdx, true);
    });
    row.addEventListener("mouseleave", () => {
      hideTooltip();
      highlightIntervention(cardEl, ivIdx, false);
    });
    return row;
  }

  // v4.1.2 : priorité à iv.infobulle (venant du xhr2 = données réelles vérifiées
  // par le tech sur place) puis fallback sur iv.bulleContact/iv.bulleLieu
  // (venant de attr1/attr2 = planification initiale, parfois incorrecte).
  const info = iv.infobulle || {};
  const contactRaw = info.contact || iv.bulleContact || null;
  // v2026.5.46 — la Localisation de la FICHE prime sur le lieu de
  // l'action et sur attr2 (planif initiale).
  const lieuRaw = iv.ficheLocation || info.lieu || iv.bulleLieu || null;

  // Rendu initial de lieu + contacts dans rightCol
  renderLieuContactBlocks(rightCol, lieuRaw, contactRaw, info.contactAnomalie, iv.locMismatch);

  // ── Bas : Catégorie (à gauche) + Signature planificateur (à droite) ──────
  const bottomEl = document.createElement("div");
  bottomEl.className = "iv-bottom-line";

  const categoryEl = document.createElement("span");
  categoryEl.className = "iv-category";
  categoryEl.textContent = deriveShortTitle(iv);
  bottomEl.appendChild(categoryEl);

  // v4.1.8 : extraire la signature depuis le texte COMPLET (fiche) en
  // priorité, sinon depuis le xhr2 tronqué. Le xhr2 tronqué peut couper la
  // signature, la fiche a toujours le texte complet.
  const signature = extractPlanifSignature(iv.ficheActionText || iv.bulleDescription);
  if (signature) {
    const sigEl = document.createElement("span");
    sigEl.className = "iv-signature";
    sigEl.textContent = signature;
    bottomEl.appendChild(sigEl);
  }

  rightCol.appendChild(bottomEl);
  row.appendChild(rightCol);

  // Tooltip (fixe, ne suit pas la souris — v4.1.12)
  row.addEventListener("mouseenter", (e) => {
    showTooltip(e, iv, row);
    highlightIntervention(cardEl, ivIdx, true);
  });
  row.addEventListener("mouseleave", () => {
    hideTooltip();
    highlightIntervention(cardEl, ivIdx, false);
  });

  return row;
}

// Sender correct pour ouvrir une fiche EasyVista (vu dans les URLs qui marchent)
const FICHE_SENDER = "%7BC99ECD05-3D48-4C62-ABF0-66292053AED6%7D";

// v2026.5.46 — ouvre la fiche d'une intervention à partir de son n° (réf),
// utilisé par une réservation liée à une intervention. Récupère un formLink frais
// puis réutilise openInterventionInNewTab.
async function _openInterventionByRef(ref) {
  const n = String(ref || "").trim();
  if (!n) return;
  showToast("Ouverture", n);
  try {
    const formLink = await getFreshFicheFormLinkForRef(n);
    if (!formLink) { showToast("Introuvable", n); return; }
    // v2026.5.46 — openInterventionInNewTab exige un requestId (garde-fou
    // « identifiant manquant » qui bloquait l'ouverture depuis une réservation).
    // Le formLink frais porte déjà « target=<requestId> » : on l'extrait pour
    // débloquer la garde ET pour que le fallback (si basicAutoComplete échoue)
    // construise une URL EV valide.
    const mTarget = formLink.match(/(?:^|&)target=([^&]+)/);
    const requestId = mTarget ? decodeURIComponent(mTarget[1]) : undefined;
    await openInterventionInNewTab({ ref: n, formLink, requestId });
  } catch (e) {
    showAlertModal({ title: "Impossible d'ouvrir", message: "Intervention " + n + " introuvable : " + ((e && e.message) || e), buttons: [{ label: "OK", variant: "secondary", action: () => {} }] });
  }
}

async function openInterventionInNewTab(iv, opts = {}) {
  // v2026.5.46 — une intervention FAITE/CLÔTURÉE reprise du dossier
  // partagé a perdu son formLink (IV_FOLDER_DROP_FIELDS : plomberie de
  // session, régénérée au clic via la réf). L'ancienne garde « if
  // (!iv.formLink) return » abandonnait alors EN SILENCE → la fiche ne
  // s'ouvrait plus. Or la voie préférée ci-dessous (basicAutoComplete +
  // redirectHeader) n'a besoin QUE de la réf. On n'abandonne donc que si NI
  // formLink NI réf ; le fallback fetchFiche (qui, lui, exige formLink) est
  // conditionné plus bas.
  if (!iv.formLink && !iv.ref) {
    showAlertModal({
      title: "Impossible d'ouvrir la fiche",
      message: "Cette intervention n'a ni lien ni référence exploitable. Actualisez le planning (bouton Actualiser) puis réessayez.",
      buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
    });
    return;
  }

  // Toast de feedback visuel dès le clic
  showToast("Ouverture", iv.ref || iv.actionId);

  // Récupérer la session actuelle pour construire une URL valide
  let session = state.session;
  if (!session) {
    const resp = await sendMessage({ type: "getSession" });
    session = resp && resp.session;
  }
  if (!session) {
    // on appelle triggerReconnect() au lieu de openEasyVista() —
    // déclenche la reconnexion SSO (ouvre un onglet EZV) ET surveille la
    // nouvelle session pour recharger le viewer auto, exactement comme
    // le bouton "Me reconnecter" de la bannière.
    showAlertModal({
      title: "Impossible d'ouvrir la fiche",
      message: "Votre session EasyVista a expiré. Reconnectez-vous à EasyVista puis réessayez.",
      injectCookiesPrompt: true,
      buttons: [
        { label: "🔄 Me reconnecter", variant: "primary", action: () => triggerReconnect() },
        { label: "Annuler", variant: "secondary", action: () => {} }
      ]
    });
    return;
  }

  if (!iv.requestId) {
    showAlertModal({
      title: "Impossible d'ouvrir la fiche",
      message: "L'identifiant de la fiche est manquant. Essayez d'actualiser le planning (bouton Actualiser).",
      buttons: [
        { label: "OK", variant: "secondary", action: () => {} }
      ]
    });
    return;
  }

  let target = null;
  let checksum = null;

  // v2026.5.44 Tentative préférée : basicAutoComplete + redirectHeader
  // (méthode officielle EV pour transformer une référence en URL fiche).
  // Si iv.ref est dispo, on demande à EV un checksum FRAIS sans fetcher la
  // fiche entière. C'est plus rapide et plus fiable.
  if (iv.ref) {
    try {
      LOG.info("click", "basicAutoComplete pour ref=", iv.ref);
      const r1 = await fetch(`${session.origin}/api/v1/internal/search/basicAutoComplete?search=${encodeURIComponent(iv.ref)}&PHPSESSID=${encodeURIComponent(session.phpsessid)}`, { credentials: "include" });
      const j1 = await r1.json();
      const meta = j1 && j1.data && j1.data.METAOBJECTS && j1.data.METAOBJECTS[0];
      const line = meta && meta.LINES && meta.LINES[0];
      if (meta && line && line.PK && meta.TYPE_GUID && line.CHECKSUM) {
        const r2 = await fetch(`${session.origin}/api/v1/internal/search/redirectHeader?pk=${encodeURIComponent(line.PK)}&guid=${encodeURIComponent(meta.TYPE_GUID)}&checksum=${encodeURIComponent(line.CHECKSUM)}&PHPSESSID=${encodeURIComponent(session.phpsessid)}`, { credentials: "include" });
        const j2 = await r2.json();
        const urlStr = (typeof j2 === "string") ? j2 : (j2 && j2.url) || "";
        // Extraire target & checksum frais de l'URL retournée
        const mTarget = urlStr.match(/[?&]target=([^&]+)/);
        const mChecksum = urlStr.match(/[?&]checksum=([a-f0-9]+)/);
        if (mTarget && mChecksum) {
          target = decodeURIComponent(mTarget[1]);
          checksum = mChecksum[1];
          LOG.info("click", `✓ checksum frais via redirectHeader : target=${target} checksum=${checksum}`);
          iv.ficheTarget = target;
          iv.ficheChecksum = checksum;
        } else {
          LOG.warn("click", "redirectHeader URL sans target/checksum :", urlStr);
        }
      } else {
        LOG.warn("click", "basicAutoComplete sans pk/guid/checksum, fallback sur fetch fiche");
      }
    } catch (err) {
      LOG.warn("click", "erreur basicAutoComplete/redirectHeader, fallback :", err && err.message);
    }
  }

  // v4.1.4 (fallback navigation) : on fetch la fiche pour extraire le
  // checksum dans le HTML. Comportement legacy.
  // v2026.5.46 — ce fallback exige formLink : on ne le tente QUE s'il
  // est présent. Sans formLink (iv du dossier), la voie réf ci-dessus a
  // normalement déjà donné target+checksum ; sinon le filet plus bas ouvre
  // via le requestId seul.
  if ((!target || !checksum) && iv.formLink) {
    LOG.info("click", `fetch fiche fraîche pour iv ${iv.actionId} requestId=${iv.requestId}`);
    let attempts = 0;
    const maxAttempts = 2;
    while (attempts < maxAttempts && (!target || !checksum)) {
      attempts++;
      try {
        const ficheResp = await sendMessage({
          type: "fetchFiche",
          formLink: iv.formLink
        });
        if (!ficheResp.ok) {
          if (attempts >= maxAttempts) {
            // v4.2.5 : popup modale selon le type d'erreur
            if (ficheResp.error === "no_session" || ficheResp.error === "session_expired") {
              showAlertModal({
                title: "Session EasyVista expirée",
                message: "Votre session a expiré pendant l'ouverture de la fiche. Reconnectez-vous à EasyVista puis réessayez.",
                injectCookiesPrompt: true,
                buttons: [
                  { label: "🔄 Me reconnecter", variant: "primary", action: () => triggerReconnect() },
                  { label: "Annuler", variant: "secondary", action: () => {} }
                ]
              });
            } else if (ficheResp.error === "ev_unreachable") {
              showAlertModal({
                title: "EasyVista inaccessible",
                message: "EasyVista est inaccessible pour le moment. Réessayez dans quelques instants.",
                buttons: [
                  { label: "Réessayer", variant: "primary", action: () => openInterventionInNewTab(iv, opts) },
                  { label: "🔄 Me reconnecter", variant: "secondary", action: () => triggerReconnect() },
                  { label: "Annuler", variant: "secondary", action: () => {} }
                ]
              });
            } else {
              showAlertModal({
                title: "Impossible d'ouvrir la fiche",
                message: "Une erreur est survenue : " + (ficheResp.error || "inconnue"),
                buttons: [
                  { label: "OK", variant: "secondary", action: () => {} }
                ]
              });
            }
            return;
          }
          continue; // retry
        }
        // Extraire le checksum lié au requestId précis
        const rx = new RegExp(`target=${iv.requestId}&(?:amp;)?checksum=([a-f0-9]{40})`, 'g');
        const allMatches = [...ficheResp.html.matchAll(rx)];
        LOG.info("click", `Trouvé ${allMatches.length} occurrence(s) de target=${iv.requestId}&checksum=... dans HTML de la fiche (taille ${ficheResp.html.length})`);
        allMatches.forEach((m, idx) => LOG.info("click", `checksum ${idx} = ${m[1]}`));

        if (allMatches.length === 0) {
          // v4.2.5 : le warning précédent était alarmiste pour rien.
          // Tentative 1 peut légitimement échouer (cache stale côté EV).
          // On log en info, on retry, et en dernier recours on ouvre quand
          // même la fiche (avec un target de fallback) plutôt que de bloquer.
          LOG.info("click", `tentative ${attempts}/${maxAttempts}: pattern target=${iv.requestId}&checksum=... introuvable dans HTML de la fiche (taille ${ficheResp.html.length})`);
          if (attempts >= maxAttempts) {
            // Fallback : tenter avec le requestId seul, sans checksum précis.
            // Ça ouvre une URL EasyVista valide qui redirige vers la fiche.
            LOG.info("click", `fallback sans checksum précis pour ${iv.requestId}`);
            target = iv.requestId;
            checksum = null;
            break;
          }
          await new Promise(r => setTimeout(r, 300));
          continue;
        }
        // On prend le PREMIER checksum trouvé (comme avant, comportement v4)
        target = iv.requestId;
        checksum = allMatches[0][1];
        LOG.info("click", `checksum retenu: ${checksum}`);
        // On stocke aussi en cache pour accélérer le prochain clic (au cas où)
        iv.ficheTarget = target;
        iv.ficheChecksum = checksum;
      } catch (err) {
        if (attempts >= maxAttempts) {
          // v4.2.5 : popup modale au lieu d'alert
          showAlertModal({
            title: "Erreur lors de l'ouverture de la fiche",
            message: "Une erreur s'est produite : " + (err && err.message ? err.message : String(err)),
            buttons: [
              { label: "Réessayer", variant: "primary", action: () => openInterventionInNewTab(iv, opts) },
              { label: "Annuler", variant: "secondary", action: () => {} }
            ]
          });
          return;
        }
      }
    }
  }

  // v2026.5.46 — filet ultime : si aucune des voies n'a fourni de
  // target (iv du dossier sans formLink ET voie réf infructueuse), on ouvre
  // via le requestId seul (sans checksum) — EV redirige vers la fiche.
  if (!target) { target = iv.requestId; checksum = null; }

  // v4.1.18 : sender à utiliser dépend du type de fiche :
  //  - demande S... → {C99ECD05-...}
  //  - incident I... → {07ED9C68-...}
  // On préfère le formSenderGuid extrait du HTML de la fiche si connu, sinon
  // fallback sur préfixe de la ref.
  let sender = FICHE_SENDER;
  if (iv.formSenderGuid) {
    sender = iv.formSenderGuid;
  } else if (iv.ref && /^I/i.test(iv.ref)) {
    sender = "%7B07ED9C68-6172-48EA-8A58-90912B0A283E%7D";
  }

  // Construire l'URL qui fonctionne (format identique à l'URL manuelle qui
  // marche dans le navigateur quand on ouvre une fiche depuis l'UI EasyVista).
  const internalurltime = Math.floor(Date.now() / 1000);
  // v4.2.5 : si on n'a pas pu extraire le checksum précis (fallback après
  // retry), on omet le paramètre checksum. EasyVista acceptera l'URL et
  // redirigera vers la fiche correspondant au target.
  const urlParts = [
    `${session.origin}/index.php`,
    `?PHPSESSID=${encodeURIComponent(session.phpsessid)}`,
    `&internalurltime=${internalurltime}`,
    `&eventName=formEvent`,
    `&target=${encodeURIComponent(target)}`,
  ];
  if (checksum) {
    urlParts.push(`&checksum=${encodeURIComponent(checksum)}`);
  }
  urlParts.push(`&sender=${sender}`);
  const url = urlParts.join("");

  LOG.info("click", `ouverture fiche iv=${iv.actionId} ref=${iv.ref} target=${target} bg=${!!opts.background}`);
  // Si background (Ctrl+Clic ou clic molette) : onglet ouvert mais pas actif,
  // on reste sur la page du planning.
  await chrome.tabs.create({ url, active: !opts.background });
}

const TOAST_MAX = 3;
const TOAST_DURATION_MS = 2400;

/**
 * Affiche un toast en bas à droite. S'empile, max 3, animations in/out.
 */
function showToast(label, ref, onClick) {
  const stack = document.getElementById("toast-stack");
  if (!stack) return;

  // Si on dépasse le max, supprimer le plus ancien (= premier enfant)
  while (stack.children.length >= TOAST_MAX) {
    const oldest = stack.firstChild;
    if (oldest) stack.removeChild(oldest);
  }

  const toast = document.createElement("div");
  toast.className = "toast";
  const labelEl = document.createElement("span");
  labelEl.className = "toast-label";
  labelEl.textContent = label;
  const refEl = document.createElement("span");
  refEl.className = "toast-ref";
  refEl.textContent = ref || "…";
  toast.appendChild(labelEl);
  toast.appendChild(refEl);

  // v2026.5.46 : toast cliquable (ex. erreur sync → ouvrir le journal).
  if (typeof onClick === "function") {
    toast.style.cursor = "pointer";
    toast.addEventListener("click", () => { try { onClick(); } catch (e) {} });
  }

  stack.appendChild(toast);

  // Forcer reflow puis animer en entrée
  void toast.offsetWidth;
  toast.classList.add("visible");

  // Auto-disparition après TOAST_DURATION_MS
  setTimeout(() => {
    toast.classList.remove("visible");
    toast.classList.add("leaving");
    setTimeout(() => {
      if (toast.parentNode === stack) stack.removeChild(toast);
    }, 220);
  }, TOAST_DURATION_MS);
}

/**
 * Formate un numéro de téléphone suisse / français.
 *   079 123 45 67   (mobile CH)
 *   021 123 45 67   (fixe CH)
 *   +41 79 123 45 67
 *   +33 1 23 45 67 89
 * Si le format n'est pas reconnu, renvoie le numéro tel quel (avec les chiffres seuls).
 */
// v2026.5.46 — un même « numéro » capturé par splitOneContact peut en
// fait contenir PLUSIEURS numéros collés : la regex de capture est greedy sur
// [chiffres espaces . -], donc deux numéros séparés par un simple espace
// (« 0215571162 0791726885 ») étaient avalés d'un bloc puis affichés collés
// (« 02155711620791726885 »). On re-découpe le bloc en numéros reconnus
// (0X + 9, 41/33 + 9, +41/+33 + 9) ; ce qui reste (non reconnu) est rendu tel
// quel. Chaque numéro repart ensuite dans formatPhone.
function _splitPhoneDigits(rawTel) {
  const digits = String(rawTel).replace(/[^\d+]/g, "");
  const out = [];
  let rest = digits, guard = 0;
  const pats = [/^\+41\d{9}/, /^\+33\d{9}/, /^41\d{9}/, /^33\d{9}/, /^0\d{9}/];
  while (rest.length && guard++ < 10) {
    let m = null;
    for (const p of pats) { const x = rest.match(p); if (x) { m = x[0]; break; } }
    if (!m) { out.push(rest); break; }   // reste non reconnu → tel quel
    out.push(m);
    rest = rest.slice(m.length);
  }
  return out.length ? out : [digits];
}

function formatPhone(raw) {
  if (!raw) return null;
  const digits = String(raw).replace(/[^\d+]/g, "");
  if (!digits) return null;

  // +41 (Suisse international, 9 chiffres après +41)
  let m = digits.match(/^\+41(\d{9})$/);
  if (m) {
    const d = m[1];
    return `+41 ${d.slice(0, 2)} ${d.slice(2, 5)} ${d.slice(5, 7)} ${d.slice(7, 9)}`;
  }
  // v4.2 : 41XXXXXXXXX sans + (format EasyVista qui colle parfois le préfixe)
  m = digits.match(/^41(\d{9})$/);
  if (m) {
    const d = m[1];
    return `+41 ${d.slice(0, 2)} ${d.slice(2, 5)} ${d.slice(5, 7)} ${d.slice(7, 9)}`;
  }
  // +33 (France)
  m = digits.match(/^\+33(\d{9})$/);
  if (m) {
    const d = m[1];
    return `+33 ${d.slice(0, 1)} ${d.slice(1, 3)} ${d.slice(3, 5)} ${d.slice(5, 7)} ${d.slice(7, 9)}`;
  }
  // v4.2 : 33XXXXXXXXX sans +
  m = digits.match(/^33(\d{9})$/);
  if (m) {
    const d = m[1];
    return `+33 ${d.slice(0, 1)} ${d.slice(1, 3)} ${d.slice(3, 5)} ${d.slice(5, 7)} ${d.slice(7, 9)}`;
  }
  // 0XX XXX XX XX (fixe ou mobile CH, 10 chiffres commençant par 0)
  m = digits.match(/^0(\d{9})$/);
  if (m) {
    const d = m[1];
    return `0${d.slice(0, 2)} ${d.slice(2, 5)} ${d.slice(5, 7)} ${d.slice(7, 9)}`;
  }
  // Numéro court interne (5 chiffres) : 78999, 68999, 88999, etc.
  m = digits.match(/^(\d{5})$/);
  if (m) {
    return m[1]; // tel quel (déjà court et lisible)
  }
  // Fallback : retour brut
  return digits;
}


/**
 * Extrait TOUS les contacts d'une chaîne (potentiellement plusieurs séparés
 * par "ou", "/", des retours à la ligne, etc.).
 * Retourne un tableau [{ name, phone }, { name, phone }, ...]
 * Format d'entrée typique :
 *   "Nom1, Prénom1 +41000000001"
 *   "Nom1, Prénom1 +41000000001 ou Nom2, Prénom2 +41000000002"
 *   "Nom1, Prénom1 +41...\nNom2, Prénom2 +41..."
 */
function extractContacts(raw) {
  if (!raw) return [];
  let s = String(raw).trim();
  // v2026.5.45 — tronquer au 1er label fiche colle au contact, deux cas:
  //   1) Label suivi de : ("Etage:", "Bureau:", etc.).
  //   2) Label colle a un mot minuscule sans espace ni : ("secretariatEtage")
  //      cas frequent quand le \\n entre la valeur du contact et le label
  //      suivant a saute dans la source EV.
  const _LABEL_RX = "[\u00C9E]tage|Bureau|Service|Mat[\u00E9e]riel|Probl[\u00E8e]me|TFS|Date|Heure|Lieu|Nom\\s+utilisateur|B[\u00E9e]n[\u00E9e]ficiaire";
  let _cutAt = -1;
  const _mColon = s.match(new RegExp("(" + _LABEL_RX + ")\\s*:"));
  if (_mColon) _cutAt = _mColon.index;
  const _mGlued = s.match(new RegExp("[a-z\u00E0-\u00FF](" + _LABEL_RX + ")"));
  if (_mGlued) {
    const _gluedLabelStart = _mGlued.index + 1;
    if (_cutAt < 0 || _gluedLabelStart < _cutAt) _cutAt = _gluedLabelStart;
  }
  if (_cutAt >= 0) s = s.substring(0, _cutAt).trim();
  // Virer les labels parasites (Nom utilisateur, etc.) qui traînent
  s = s.replace(/\b(Nom utilisateur|Utilisateur)\s*:\s*[^\n]+/gi, "");

  // v4.2.3 : séparer sur plus de délimiteurs pour gérer les cas type
  //   "Nom1 Prénom1 +41XXXXXXXXX et Nom2 Prénom2 0XXXXXXXXX"
  // Délimiteurs acceptés :
  //   - " ou " / " et " / " and " (mots de liaison)
  //   - " / " suivi d'une majuscule (nouveau contact)
  //   - " ; " (point-virgule)
  //   - saut de ligne
  // IMPORTANT : on ne touche PAS aux virgules (car "Nom, Prénom" en contient).
  const parts = s.split(/\s+ou\s+|\s+et\s+|\s+and\s+|\s*;\s*|\n+|\s*\/\s*(?=[A-ZÉÈÀÂÎÔÛÇ])/i)
    .map(p => p.trim())
    .filter(Boolean);

  const results = [];
  for (const part of parts) {
    const { name, phone } = splitOneContact(part);
    if (name || phone) results.push({ name, phone });
  }
  return results;
}

/**
 * Split UN seul bloc "Nom Prénom +41... [autres tels] [commentaires]" en
 * { name, phone }.
 *
 * Stratégie robuste (v4.1.8) :
 *  - On cherche TOUS les numéros de téléphone (long ou court).
 *  - Le nom = ce qui précède le PREMIER numéro.
 *  - Le champ phone concatène les numéros trouvés (séparés par " / ").
 *  - Ce qui suit les numéros (commentaires "S'annoncer à la réception...",
 *    "téléphone à l'utilisateur") est JETÉ : ça ne fait pas partie du contact.
 *
 * Pattern numéro (inchangé, connu pour marcher) :
 *   Long : +41 / +33 / 0X suivi de 8+ caractères de [chiffres espaces . -]
 *   Court: 5 chiffres isolés (entre espaces, parenthèses, ou début/fin)
 */
function splitOneContact(raw) {
  if (!raw) return { name: null, phone: null };

  // v2026.5.25 : avant d'extraire les numéros, on REMPLACE les séquences qui
  // sont des identifiants de matériel (LETTRES_CHIFFRES) par des espaces.
  // Exemples : XXXX_NNNNNNNNNNN, XNNNNNN (1-2 lettres + 5+ chiffres).
  // Sans ça, XXXX_NNNNNNNNNNN laisse des "NNNN NNN NN NN" qui se font prendre
  // pour un numéro de téléphone par le regex qui greedy sur [0-9\s.\-].
  // On remplace par des espaces de même longueur pour préserver les offsets
  // (important pour le calcul de position du nom avant le 1er numéro).
  raw = String(raw);
  raw = raw.replace(/\b[A-Z]{1,6}_\d+/g, (m) => " ".repeat(m.length));
  // Idem pour les identifiants sans underscore style XNNNNNN (1-2 lettres
  // majuscules suivies de 5+ chiffres collés). On garde assez permissif
  // pour matcher les variantes sans enlever des vrais mots.
  raw = raw.replace(/\b[A-Z]{1,3}\d{5,}\b/g, (m) => " ".repeat(m.length));

  // v4.1.20 : regex plus permissives pour tolérer les erreurs humaines :
  //  - pas d'espace après le numéro (ex: "0XXXXXXXXTextecoller")
  //  - pas d'espace/parenthèse avant un court numéro
  // LONG : +41 / +33 / 0X suivis de chiffres/espaces/points/tirets
  //        On ne limite plus par séparateur après — on laisse le moteur
  //        consommer le numéro le plus long possible (greedy) puis on
  //        s'arrête dès qu'on tombe sur un caractère non numérique.
  // v4.2 : on accepte aussi le format "41XXXXXXXXX" sans + devant (fréquent
  //        quand EasyVista concatène "prefixe+tel" sans espace : "Nom,
  //        Prénom 41XXXXXXXXX" → extraire 41XXXXXXXXX puis reformater en
  //        +41 XX XXX XX XX). On exige exactement 11 chiffres collés pour
  //        éviter de matcher des codes postaux ou autres nombres.
  // v2026.5.16 : ne PAS matcher si le numéro est précédé d'une lettre ou
  //        d'un underscore (identifiants style XXXX_NNNNNNNN, XXX0123456,
  //        SERIAL_0123456789). On ajoute un lookbehind négatif (?<![A-Za-z_]).
  const rxLong = /(?<![A-Za-z_])(\+41\s?\d(?:[\d\s.\-]*\d)?|\+33\s?\d(?:[\d\s.\-]*\d)?|0\d(?:[\d\s.\-]*\d)?|(?<!\d)41\d{9}(?!\d)|(?<!\d)33\d{9}(?!\d))/g;
  // SHORT : numéro interne court (5 chiffres).
  //  - v4.1.20 : accepte "12345Texte" (pas de séparateur après)
  //  - v4.2.3 : accepte aussi les formats AVEC ESPACES au sein du numéro,
  //    typique du Canton de Vaud : "7 68 43", "6 12 34", "8 90 12".
  //    Doit commencer par 6, 7 ou 8 (plan de numérotation interne VD).
  //    Pattern : [678] + (4 autres chiffres, avec ou sans espaces/points
  //    intercalés, mais pas plus d'un séparateur à la fois entre 2 chiffres).
  //  - v4.2.3 : la version "collée" classique (5 chiffres sans espace, tout
  //    chiffre de début) reste acceptée comme fallback.
  const rxShort = /(?:^|[\s(\/])([678](?:[\s.\-]?\d){4})(?!\d)|(?:^|[\s(\/])(\d{5})(?!\d)/g;

  // Trouver toutes les positions de match pour LONG et SHORT
  const matches = [];
  let mm;
  while ((mm = rxLong.exec(raw)) !== null) {
    // v4.1.20 : on ne garde que si au moins 8 chiffres pour un long
    //   (élimine les fausses captures "0 1" ou "01 2")
    const digitsOnly = mm[1].replace(/\D/g, "");
    if (digitsOnly.length >= 9) {
      matches.push({ start: mm.index, end: mm.index + mm[1].length, tel: mm[1] });
    }
  }
  while ((mm = rxShort.exec(raw)) !== null) {
    // v4.2.3 : soit le 1er groupe (format avec espaces "7 68 43"), soit le
    // 2e groupe (format collé "12345") a matché.
    const rawTel = mm[1] || mm[2];
    if (!rawTel) continue;
    // On normalise en 5 chiffres sans séparateur
    const shortTel = rawTel.replace(/[\s.\-]/g, "");
    if (!/^\d{5}$/.test(shortTel)) continue;
    const rawStart = mm.index + mm[0].indexOf(rawTel);
    const rawEnd = rawStart + rawTel.length;
    const overlaps = matches.some(x => rawStart < x.end && rawEnd > x.start);
    if (!overlaps) {
      matches.push({ start: rawStart, end: rawEnd, tel: shortTel });
    }
  }
  matches.sort((a, b) => a.start - b.start);

  let name = raw;
  let phone = null;
  if (matches.length > 0) {
    name = raw.substring(0, matches[0].start).trim();
    // v2026.5.46 — chaque bloc capturé peut contenir plusieurs numéros
    // collés (espace séparateur avalé par la regex greedy) → on re-découpe.
    const tels = matches.flatMap(x => _splitPhoneDigits(x.tel)).map(formatPhone).filter(Boolean);
    phone = tels.length > 0 ? tels.join(" / ") : null;
  }

  name = cleanContactName(name);

  // v2026.5.16 : dernier garde-fou — rejeter les "noms" qui ressemblent
  // à des fragments de description technique plutôt qu'à des vrais contacts.
  // Exemples rejetés :
  //   - "1x" (quantité isolée)
  //   - "1x pc" (quantité + type matériel)
  //   - "pc XNNNNNN" (type + numéro de série)
  //   - "XXXX_NNNNNNNN" (identifiant matériel)
  // Critères d'un vrai nom : contient au moins un mot qui commence par une
  // majuscule ET n'est pas juste un identifiant technique.
  if (name) {
    const looksLikeIdentifier = /^[A-Z]{2,}[_\-]\d+$/.test(name);  // ex: XXXX_NNNNNNNN
    const startsWithQuantity = /^\d+x(\s|$)/i.test(name);            // "1x" ou "1x pc"
    const noCapitalWord = !/\b[A-ZÉÈÀÂÎÔÛÇ][a-zéèàâîôûç]+/.test(name);  // aucun mot "Xxxxx"
    const hasOnlyTechTokens = /^(\d+x|pc|mac|t[ée]l[ée]phone|ecran|docking|rollout)(\s+(\d+x|pc|mac|t[ée]l[ée]phone|ecran|docking|rollout|[A-Z]\d+))*\s*$/i.test(name);
    if (looksLikeIdentifier || startsWithQuantity || hasOnlyTechTokens || (noCapitalWord && !phone)) {
      name = null;
    }
  }

  return { name, phone };
}

/**
 * Nettoie le nom du contact :
 *   - retire tout ce qui est dans des parenthèses (...)
 *   - retire les éventuels "Nom utilisateur :" ou libellés
 *   - retire les virgules en trop en fin
 *   - v4.1.8 : tronque les commentaires parasites après le nom
 *     (ex: "Nom, Prénom S'annoncer à la réception" → "Nom, Prénom")
 *   - Conserve juste "Nom, Prénom" (ou "Nom Prénom" si pas de virgule)
 */
function cleanContactName(raw) {
  if (!raw) return null;
  let s = String(raw);
  // Retirer parenthèses COMPLÈTES et leur contenu : (RH), (support)...
  s = s.replace(/\s*\([^)]*\)\s*/g, " ");
  // Retirer parenthèses non fermées en fin : "Nom, Prénom (" → "Nom, Prénom"
  s = s.replace(/\s*\([^)]*$/g, " ");
  // Retirer parenthèses non ouvertes en début : ")Nom" → "Nom"
  s = s.replace(/^[^(]*\)\s*/g, "");
  // Retirer tout caractère parenthèse isolé restant
  s = s.replace(/[()]/g, " ");
  // Retirer labels type "Nom utilisateur :", "Utilisateur :", "Bénéficiaire :"
  s = s.replace(/\b(Nom utilisateur|Utilisateur|B[ée]n[ée]ficiaire)\s*:\s*[^\n,]*/gi, "");

  // v4.1.20 : virer les commentaires parasites fréquents AVANT la logique
  // des 4-mots (ils peuvent apparaître au tout début quand EasyVista n'a
  // pas de nom saisi et commence directement par un commentaire).
  // On détecte et coupe DÈS que ces expressions apparaissent.
  // NOTE: on évite \b avant/après les caractères accentués (à, é) car
  //       \b est basé sur [a-zA-Z0-9_] et donne de faux négatifs.
  const parasitePhrases = [
    // Instructions d'appel (avec "à" ou "a")
    /t[ée]l[ée]phone(?:r)?\s*[àa]\s*l[''`]?utilisateur/gi,
    /t[ée]l[ée]phone(?:r)?\s*[àa](?:\s|$)/gi,
    /t[ée]l[ée]phone(?:r)?\s*[àa]$/gi,
    /\bappeler?\s+l[''`]?utilisateur\b/gi,
    /\bappeler?\s+(?:le\s+)?b[ée]n[ée]ficiaire\b/gi,
    /\bappeler?\s+la\s+personne\b/gi,
    /\bappeler?\s+[àa]\s+/gi,
    /\brappeler?\s+l[''`]?utilisateur\b/gi,
    /\brappeler?\s+(?:le\s+)?b[ée]n[ée]ficiaire\b/gi,
    // Instructions de présentation
    /s[''`]annoncer?\s+[àa]\s+(?:la\s+r[ée]ception|l[''`]?accueil|.+?)(?=\.|,|$)/gi,
    /\bse\s+pr[ée]senter\s+[àa]\s+.+?(?=\.|,|$)/gi,
    // Autres
    /\bbonjour\b/gi,
    /\bmerci\b/gi,
    // v4.1.20 : mots isolés qui restent parfois après les nettoyages ci-dessus
    /\butilisateur\b/gi,
    /\bb[ée]n[ée]ficiaire\b/gi
  ];
  for (const rx of parasitePhrases) {
    s = s.replace(rx, " ");
  }

  // Espaces multiples → un seul
  s = s.replace(/\s{2,}/g, " ").trim();
  // Ponctuation en bord
  s = s.replace(/^[\s,;:.\-]+|[\s,;:.\-]+$/g, "").trim();
  if (!s) return null;

  // v4.1.8 : tronquer les commentaires parasites qui suivent le nom.
  const words = s.split(/\s+/);
  const keep = [];
  for (let i = 0; i < words.length; i++) {
    const w = words[i];
    if (i === 0) { keep.push(w); continue; }
    if (/^(de|da|du|van|von|le|la|del|di|der)$/i.test(w)) { keep.push(w); continue; }
    if (keep.length >= 2 && /^[a-zéèêàâîôûç]/.test(w)) break;
    if (keep.length >= 4) break;
    keep.push(w);
  }
  s = keep.join(" ");
  s = s.replace(/[\s,;:.\-]+$/, "").trim();

  // v4.1.20 : dernier garde-fou : si le résultat final est juste un mot
  // parasite (ex: "téléphone" tout seul, "appeler" tout seul), on retourne
  // null plutôt qu'afficher un faux nom.
  if (/^(t[ée]l[ée]phone|t[ée]l|appeler?|rappeler?|s[''`]?annoncer|bonjour|merci)$/i.test(s)) {
    return null;
  }

  return s || null;
}

/**
 * Split un lieu du type "<Ville>/<Rue> <N°>" en
 *   { ville: "<Ville>", adresse: "<Rue> <N°>" }
 * Si format inconnu, retourne { ville: null, adresse: raw }.
 */
function splitLieu(raw) {
  if (!raw) return { ville: null, adresse: null };
  let s = String(raw).trim();
  // Retirer un / final (avec ou sans espaces)
  s = s.replace(/\s*\/\s*$/, "").trim();
  if (!s) return { ville: null, adresse: null };

  // v2026.5.16 : le format EasyVista peut avoir jusqu'à 3 parties séparées
  // par "/" : VILLE / ADRESSE / PRÉCISIONS (étage, bureau, indications).
  // Exemple : "<VILLE> / <Av. nom-rue n°> / <précisions étage/bureau>"
  // On ne garde que VILLE + ADRESSE. Les précisions (3e partie et suivantes)
  // sont strippées — elles alourdissent la carte et sont disponibles dans
  // le tooltip détaillé.
  const parts = s.split("/").map(p => p.trim()).filter(Boolean);

  let ville, adresse;
  if (parts.length === 0) {
    return { ville: null, adresse: null };
  } else if (parts.length === 1) {
    // Pas de slash : tout est l'adresse
    ville = null;
    adresse = parts[0];
  } else {
    // 2+ parties : ville = 1ère, adresse = 2e, on ignore le reste
    ville = parts[0];
    adresse = parts[1];
  }

  // Capitaliser la 1ère lettre des mots de voie (Rue, Chemin, Route, Avenue,
  // Boulevard, Place, Quai, Impasse + abréviations Av., Ch., Rte, Bd)
  if (adresse) {
    adresse = adresse.replace(
      /\b(rue|chemin|route|avenue|boulevard|place|quai|impasse|ruelle|allée|allee|passage|sentier|av\.?|ch\.?|rte\.?|bd\.?)\b/gi,
      (match) => {
        if (/^[A-ZÉÈÀÂÎÔÛÇ]/.test(match)) return match;
        return match.charAt(0).toUpperCase() + match.slice(1).toLowerCase();
      }
    );
  }
  return { ville: ville || null, adresse: adresse || null };
}

/**
 * Extrait la "signature planificateur" de la description d'action.
 * Formats acceptés : "ECM 16.04", "JKF 17.04", "AWR 13/04/26", "ECM 16.04.2026".
 * Parcourt d'abord les lignes depuis la fin (si la signature est sur sa ligne),
 * sinon cherche à la fin de la description entière.
 * Retourne null si rien trouvé.
 */
/**
 * Normalise une date trouvée dans une signature :
 *   - "27/03"      → "27.03"
 *   - "27.03"      → "27.03"
 *   - "10/04/26"   → "10.04"  (on retire l'année)
 *   - "13/04/2026" → "13.04"
 */
function normalizeSignatureDate(date) {
  if (!date) return "";
  // Prendre les 2 premiers blocs de chiffres (JJ et MM) et les joindre avec "."
  const parts = String(date).split(/[./]/);
  if (parts.length < 2) return date;
  const dd = parts[0].padStart(2, "0");
  const mm = parts[1].padStart(2, "0");
  return `${dd}.${mm}`;
}

function extractPlanifSignature(actionText) {
  if (!actionText) return null;
  // Formater le texte d'abord pour avoir des lignes séparées
  const text = formatActionTextMultiline(String(actionText)).trim();

  // 1. Dernière ligne non vide : regarder si c'est une signature (avec ou sans date)
  const lines = text.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
  if (lines.length > 0) {
    const last = lines[lines.length - 1];

    // 1a. Lettres (majuscules OU minuscules) + date
    //     Ex: "FRD 07/04", "csh 27.03", "AWR 13/04/26", "JKF 17.04"
    const mFull = last.match(/^([A-Za-z]{2,4})\s+(\d{1,2}[./]\d{1,2}(?:[./]\d{2,4})?)$/);
    if (mFull) {
      return `${mFull[1].toUpperCase()} ${normalizeSignatureDate(mFull[2])}`;
    }

    // 1b. Juste les lettres seules (JKF, NDV) sur leur propre ligne
    const mSolo = last.match(/^([A-Za-z]{2,4})$/);
    if (mSolo) return mSolo[1].toUpperCase();
  }

  // 2. Sinon chercher la dernière signature "lettres + date" collée en fin
  let lastMatch = null;
  let m;
  const rxGlobal = /([A-Za-z]{2,4})\s+(\d{1,2}[./]\d{1,2}(?:[./]\d{2,4})?)/g;
  while ((m = rxGlobal.exec(text)) !== null) {
    lastMatch = { sigs: m[1], date: m[2], pos: m.index };
  }
  if (lastMatch && lastMatch.pos >= text.length - 100) {
    return `${lastMatch.sigs.toUpperCase()} ${normalizeSignatureDate(lastMatch.date)}`;
  }
  return null;
}

// v4.1.1 : shortMeta() et buildMetaDom() supprimées (code mort, héritage v1).
// Le rendu actuel utilise renderLieuContactBlocks() + buildInterventionRow().

async function copyRef(ref, btn) {
  if (!ref) return;
  try {
    await navigator.clipboard.writeText(ref);
    btn.classList.add("copied");
    btn.textContent = "✓";
    setTimeout(() => { btn.classList.remove("copied"); btn.textContent = "📋"; }, 1200);
  } catch {
    alert("Référence : " + ref);
  }
}

// ─── Rendu incrémental (v3.1) ───────────────────────────────────────────────
// Met à jour UNE ligne d'interventoin dans le DOM (après qu'un fetch fiche
// ait enrichi l'objet iv avec sa ref, son statut, etc.). Appelée par
// fetchAndUpdateIntervention pour afficher la ref dès qu'elle arrive, sans
// attendre que tous les workers aient fini ni re-rendre toute la vue.
//
// Doit rester en phase avec la structure DOM construite par
// buildInterventionRow (classes iv-ref-header, iv-status-check,
// intervention-copy, intervention-dot, timeline-slot...).
const ALL_COLOR_CLASSES = [
  "color-livraison", "color-installation", "color-recup",
  "color-remplacement", "color-incident", "color-rollout",
  "color-reservation", "color-autre"
];

/**
 * (Re)génère les blocs Lieu et Contact(s) dans le conteneur .iv-right.
 * Supprime d'abord les anciens blocs (.iv-lieu-block + .iv-contact-line),
 * puis insère les nouveaux AVANT le bloc .iv-bottom-line (si présent) pour
 * conserver l'ordre d'affichage. Utilisé à la création ET lors de la
 * mise à jour après fetch de la fiche.
 */
function renderLieuContactBlocks(rightCol, lieuRaw, contactRaw, contactAnomalie, locMismatch) {
  // Supprime les anciens blocs lieu/contact
  rightCol.querySelectorAll(".iv-lieu-block, .iv-contact-line").forEach(el => el.remove());

  const contacts = extractContacts(contactRaw);
  const { ville, adresse } = splitLieu(lieuRaw);

  // Point d'insertion : avant .iv-bottom-line (catégorie + signature), sinon à la fin
  const anchor = rightCol.querySelector(".iv-bottom-line");
  const insert = (el) => {
    if (anchor) rightCol.insertBefore(el, anchor);
    else rightCol.appendChild(el);
  };

  // ── Lieu : ville (MAJUSCULES GRAS) puis adresse (italique noir) ──────────
  if (ville || adresse) {
    const lieuBlock = document.createElement("div");
    lieuBlock.className = "iv-lieu-block";
    // v2026.5.46 — adresse fiche ≠ adresse action → lieu en ROUGE, avec
    // l'explication au survol (comparaison ignorant casse/accents/tirets).
    if (locMismatch) {
      lieuBlock.classList.add("iv-lieu-mismatch");
      lieuBlock.title = "⚠ L'adresse de la fiche ne correspond pas à celle écrite dans l'action" + String.fromCharCode(10) +
        "Fiche : " + locMismatch.fiche + String.fromCharCode(10) +
        "Action : " + locMismatch.action + String.fromCharCode(10) +
        "(comparaison déjà tolérante : ordre, casse, accents, abréviations et précisions en plus sont ignorés)";
    }
    if (ville) {
      const villeEl = document.createElement("div");
      villeEl.className = "iv-lieu-ville";
      villeEl.textContent = ville.toUpperCase();
      lieuBlock.appendChild(villeEl);
    }
    if (adresse) {
      const addrEl = document.createElement("div");
      addrEl.className = "iv-lieu-adresse";
      addrEl.textContent = adresse;
      lieuBlock.appendChild(addrEl);
    }
    insert(lieuBlock);
  }

  // ── Contact(s) + téléphone — un par ligne si plusieurs ──────────────────
  for (const c of contacts) {
    if (!c.name && !c.phone) continue;
    const contactEl = document.createElement("div");
    contactEl.className = "iv-contact-line";
    // v4.2 : si anomalie (les 2 champs Contact + Personne de contact existent
    // dans l'action), afficher en rouge pour signaler à l'user de vérifier.
    if (contactAnomalie) contactEl.classList.add("iv-contact-anomalie");
    if (c.name) {
      const nameSpan = document.createElement("span");
      nameSpan.className = "iv-contact";
      nameSpan.textContent = c.name;
      contactEl.appendChild(nameSpan);
    }
    if (c.phone) {
      if (c.name) {
        const sep = document.createElement("span");
        sep.className = "iv-sep";
        sep.textContent = " | ";
        contactEl.appendChild(sep);
      }
      const phoneSpan = document.createElement("span");
      phoneSpan.className = "iv-phone";
      phoneSpan.textContent = c.phone;
      contactEl.appendChild(phoneSpan);
    }
    insert(contactEl);
  }
}

function updateInterventionRow(iv) {
  // Réservations : pas concerné (pas de fetch fiche pour elles)
  if (iv.type === "AL-Reservation") return;

  const row = document.querySelector(
    `.intervention-v2[data-action-id="${iv.actionId}"]`
  );
  if (!row) return;

  // Classes de statut sur la ligne
  const sc = getStatusClass(iv);
  row.classList.remove("status-closed", "status-resolved", "status-terminated");
  if (sc) row.classList.add(sc);

  // retirer/ajouter l'animation "en cours d'analyse" et le marqueur
  // décalage signature pour le ✓ pending.
  row.classList.toggle("_checking", !!(iv._analyzing || (iv.missingSince && ivVStatus(iv) === "live")));
  // rideau horaire pour les marqueurs pending/suspended.
  const _updRevealed = _isVerdictRevealed(iv);
  row.classList.toggle("has-pending-check",
    _updRevealed && (
      ivVStatus(iv) === "done" ||
      ivVStatus(iv) === "suspended"));

  // dès qu'une disparue a son verdict (analyzeMissingIv retire _analyzing),
  // on attache le click handler s'il n'existait pas — l'user peut cliquer
  // sur la carte pour ouvrir la fiche, sans attendre la fin de l'actualisation.
  if (iv.formLink && !iv._analyzing && iv.type !== "AL-Absence" && !row.dataset.clickBound) {
    row.classList.add("clickable");
    row.dataset.clickBound = "1";
    row.addEventListener("click", (e) => {
      if (e.target.closest(".intervention-copy")) return;
      const background = !!(e.ctrlKey || e.metaKey);
      openInterventionInNewTab(iv, { background });
    });
    row.addEventListener("auxclick", (e) => {
      if (e.button !== 1) return;
      if (e.target.closest(".intervention-copy")) return;
      e.preventDefault();
      openInterventionInNewTab(iv, { background: true });
    });
    row.addEventListener("mousedown", (e) => {
      if (e.button === 1) e.preventDefault();
    });
  }

  // si la fiche n'a pas pu être récupérée correctement (tronquée /
  // session expirée). On l'insère/met à jour dans le coin haut-droit de la row.
  // v2026.5.46 — masqué si périmé (fiche finalement lue : verdict / clos).
  let warnEl = row.querySelector(".iv-fetch-warning");
  if (iv._fetchWarning && !_staleFetchWarning(iv)) {
    if (!warnEl) {
      warnEl = document.createElement("div");
      warnEl.className = "iv-fetch-warning";
      warnEl.textContent = "⚠";
      warnEl.title = "Fiche partiellement récupérée — vérifie ta session EasyVista";
      row.appendChild(warnEl);
    }
  } else if (warnEl) {
    warnEl.remove();
  }

  // Classe de couleur sur la ligne (la pastille hérite via CSS)
  const colorKey = deriveColorKey(iv);
  row.classList.remove(...ALL_COLOR_CLASSES);
  row.classList.add("color-" + colorKey);

  // Ref (le titre gros en haut de la ligne)
  const refEl = row.querySelector(".iv-ref-header");
  if (refEl) {
    if (iv.ref) {
      refEl.textContent = iv.ref;
      refEl.classList.remove("no-ref");
    } else {
      refEl.textContent = "—";
      refEl.classList.add("no-ref");
    }
  }

  // Check ✓ : ajouter/retirer/mettre à jour selon statut
  // on gère AUSSI le ✓ pour terminated-pending en direct (avant on
  // ne créait le ✓ pending qu'au renderFromData final → l'user voyait les
  // ✓✓ apparaître au fur et à mesure mais les ✓ seulement à la fin).
  // rideau horaire — pas de ✓ tant que le seuil n'est pas atteint.
  let checkEl = row.querySelector(".iv-status-check");
  const showPendingCheck = _updRevealed && ivVStatus(iv) === "done";
  const showSuspendedCheck = _updRevealed && ivVStatus(iv) === "suspended";
  // ajout du ✓ jaune pour terminated-suspended.
  if (sc || showPendingCheck || showSuspendedCheck) {
    const isDouble = (sc === "status-closed" || sc === "status-resolved");
    const desiredText = isDouble ? "✓✓" : "✓";
    if (!checkEl) {
      checkEl = document.createElement("div");
      checkEl.className = "iv-status-check";
      const copy = row.querySelector(".intervention-copy");
      if (copy) row.insertBefore(checkEl, copy);
      else if (refEl && refEl.nextSibling) row.insertBefore(checkEl, refEl.nextSibling);
      else row.appendChild(checkEl);
    }
    checkEl.textContent = desiredText;
    checkEl.classList.toggle("double", isDouble);
    checkEl.classList.toggle("suspended", showSuspendedCheck);
    row.classList.toggle("status-suspended", showSuspendedCheck);
  } else if (checkEl) {
    checkEl.remove();
    row.classList.remove("status-suspended");
  }

  // Bouton copier : ajouter si on a maintenant une ref et qu'il n'existe pas
  let copyBtn = row.querySelector(".intervention-copy");
  if (iv.ref && !copyBtn) {
    copyBtn = document.createElement("button");
    copyBtn.className = "intervention-copy";
    copyBtn.type = "button";
    copyBtn.title = "Copier la référence";
    copyBtn.innerHTML = "📋";
    copyBtn.addEventListener("click", (e) => {
      e.stopPropagation();
      copyRef(iv.ref, copyBtn);
    });
    row.appendChild(copyBtn);
  }

  // Catégorie affichée en bas (dépend de la ref pour Incident, etc.)
  const catEl = row.querySelector(".iv-category");
  if (catEl) catEl.textContent = deriveShortTitle(iv);

  // v4.1.8 : signature planificateur (XXX JJ.MM). Si le texte fiche (complet)
  // est arrivé, il peut maintenant fournir une signature que le xhr2 tronqué
  // n'avait pas. On met à jour le span .iv-signature en conséquence.
  const bottomEl = row.querySelector(".iv-bottom-line");
  if (bottomEl) {
    let sigEl = bottomEl.querySelector(".iv-signature");
    const sig = extractPlanifSignature(iv.ficheActionText || iv.bulleDescription);
    if (sig) {
      if (!sigEl) {
        sigEl = document.createElement("span");
        sigEl.className = "iv-signature";
        bottomEl.appendChild(sigEl);
      }
      sigEl.textContent = sig;
    } else if (sigEl) {
      sigEl.remove();
    }
  }

  // v4.1.2 : régénérer les blocs lieu/contact depuis les valeurs actuelles.
  // Priorité à iv.infobulle (xhr2 lazy, vraies infos) puis attr1/attr2 (planif).
  const rightCol = row.querySelector(".iv-right");
  if (rightCol) {
    const info = iv.infobulle || {};
    const contactRaw = info.contact || iv.bulleContact || null;
    const lieuRaw = iv.ficheLocation || info.lieu || iv.bulleLieu || null;   //
    renderLieuContactBlocks(rightCol, lieuRaw, contactRaw, info.contactAnomalie, iv.locMismatch);
  }

  // Segment timeline correspondant : même couleur + même classe statut
  const card = row.closest(".card");
  if (card && row.dataset.ivIdx !== undefined) {
    const slot = card.querySelector(
      `.timeline-slot[data-iv-idx="${row.dataset.ivIdx}"]`
    );
    if (slot) {
      slot.classList.remove("status-closed", "status-resolved", "status-terminated", ...ALL_COLOR_CLASSES);
      slot.classList.add("color-" + colorKey);
      if (sc) slot.classList.add(sc);
      // Maj du dataset pour le popover (titre + ref)
      slot.dataset.title = deriveShortTitle(iv);
      if (iv.ref) slot.dataset.ref = iv.ref;
    }

    // mini-card timeline (vue horizontale) — ✓/✓✓ live aussi.
    const miniCard = card.querySelector(
      `.iv-mini-card[data-iv-idx="${row.dataset.ivIdx}"]`
    );
    if (miniCard) {
      miniCard.classList.remove("status-closed", "status-resolved", "status-terminated", "has-pending-check");
      if (sc) miniCard.classList.add(sc);
      if (showPendingCheck || showSuspendedCheck) miniCard.classList.add("has-pending-check");
      miniCard.classList.toggle("status-suspended", showSuspendedCheck);
      let miniCheck = miniCard.querySelector(".iv-mini-status-check");
      if (sc || showPendingCheck || showSuspendedCheck) {
        const isDouble = (sc === "status-closed" || sc === "status-resolved");
        if (!miniCheck) {
          miniCheck = document.createElement("div");
          miniCheck.className = "iv-mini-status-check";
          miniCard.appendChild(miniCheck);
        }
        miniCheck.textContent = isDouble ? "✓✓" : "✓";
        miniCheck.classList.toggle("double", isDouble);
        miniCheck.classList.toggle("suspended", showSuspendedCheck);
      } else if (miniCheck) {
        miniCheck.remove();
        miniCard.classList.remove("status-suspended");
      }
    }
  }

  // régénérer le HTML des popups épinglés ouverts pour CETTE iv
  // — sans ça, un popup ouvert AVANT le verdict ne montre jamais le
  // commentaire/badge même si l'analyse a réussi en arrière-plan.
  try {
    if (typeof pinnedPopups !== "undefined" && Array.isArray(pinnedPopups)) {
      for (const p of pinnedPopups) {
        if (!p || !p.iv || !p.el) continue;
        const sameIv = (p.iv === iv) ||
          (iv.actionId && String(p.iv.actionId) === String(iv.actionId)) ||
          (iv.ref && p.iv.ref === iv.ref);
        if (!sameIv) continue;
        // Mettre à jour la référence iv (au cas où l'objet a changé)
        p.iv = iv;
        const topbar = p.el.querySelector(".pinned-popup-topbar");
        const dragbar = p.el.querySelector(".pinned-popup-dragbar");
        try {
          p.el.innerHTML = buildTooltipHTML(iv);
        } catch (e) { /* ignore */ }
        // Virer les boutons pin résiduels du tooltip de base, restaurer
        // topbar/dragbar propres au popup.
        const oldPin = p.el.querySelector('.tooltip-pinbtn[data-action="pin"]');
        if (oldPin) oldPin.remove();
        if (topbar) p.el.appendChild(topbar);
        if (dragbar) p.el.appendChild(dragbar);
      }
    }
  } catch (e) { /* ignore */ }

  // si l'iv survolée actuellement (tooltip "live") = celle qu'on
  // vient d'updater, on régénère son contenu aussi.
  try {
    if (state && state.currentTooltipIv && (
        state.currentTooltipIv === iv ||
        (iv.actionId && String(state.currentTooltipIv.actionId) === String(iv.actionId))
    )) {
      const tip = tooltipEl();
      if (tip && tip.classList.contains("visible")) {
        tip.innerHTML = buildTooltipHTML(iv);
      }
    }
  } catch (e) { /* ignore */ }
}

// ============================================================================
// Tooltip
// ============================================================================

const tooltipEl = () => document.getElementById("tooltip");

// v4.1.10 : état persistant de la bulle
//  - pinned : une fois épinglée (double Ctrl), la bulle reste à sa position,
//             ne suit plus la souris, et ne se ferme ni au mouseleave ni au
//             mouseleave suivant. On peut sélectionner le texte dedans.
//             Clic hors bulle (ailleurs que sur une autre intervention) ou
//             nouveau double-Ctrl → désépingle.
//  - hoveredInBulle : si la souris entre DANS la bulle elle-même, la bulle
//             reste visible même si elle n'est pas épinglée. Elle ne
//             disparaît que quand la souris sort à la fois de la carte ET
//             de la bulle.
let bulleState = {
  pinned: false,
  hoveredInBulle: false,
  hoveredInRow: false,
  hideTimer: null
};

// v2026.5.39 : délai d'apparition tooltip (500ms). Permet à l'user de
// passer rapidement la souris sur plusieurs cartes sans déclencher des
// popups intempestifs.
const TOOLTIP_SHOW_DELAY_MS = 500;
let _showTooltipTimer = null;
function _cancelPendingShowTooltip() {
  if (_showTooltipTimer) {
    clearTimeout(_showTooltipTimer);
    _showTooltipTimer = null;
  }
}

/**
 * Affiche un tooltip au survol d'une intervention/réservation.
 *
 * @author Quentin Rouiller
 */
function showTooltip(e, iv, rowEl, posOpts) {
  if (_techCtxMenuEl) return;   // v2026.5.46 — menu contextuel ouvert : pas de popup par-dessus
  // v2026.5.46 — si on survole une intervention DU PLANNING (≠ un résultat
  // de recherche), on programme la fermeture du popup de recherche (~0,5 s).
  if (rowEl && !(rowEl.closest && rowEl.closest("#ev-search-results")) && typeof _srScheduleCloseFromPlanning === "function") {
    _srScheduleCloseFromPlanning();
  }
  // v2026.5.39 : on planifie l'affichage à +500ms.
  // v2026.5.40 : on annule aussi un éventuel hide timer en cours
  // (cas typique : la souris revient sur la row pendant les 500ms après
  // mouseleave précédent → on garde la popup ouverte).
  _cancelPendingShowTooltip();
  _cancelHideTooltip();
  // Capturer les valeurs sérialisables maintenant (l'event peut être recyclé)
  const _ev = { clientX: e.clientX, clientY: e.clientY };
  _showTooltipTimer = setTimeout(() => {
    _showTooltipTimer = null;
    _showTooltipImpl(_ev, iv, rowEl, posOpts);
  }, TOOLTIP_SHOW_DELAY_MS);
}

function _showTooltipImpl(e, iv, rowEl, posOpts) {
  // v2026.5.19 : pendant qu'un popup épinglé est en cours de drag, on ignore
  // les mouseenter sur les cartes — sinon en survolant une carte on déclenche
  // l'ouverture d'un nouveau tooltip par-dessus ce qu'on est en train de bouger.
  if (state._popupDragging) {
    LOG.info("showTooltip", "ignoré : popup drag en cours");
    return;
  }

  // v2026.5.27 : fermer tout popup "soft-unpinned" encore visible (il traîne
  // parce que la souris était dessus). Dès qu'on survole autre chose, on veut
  // que seul le popup actuel ou les popups épinglés restent.
  // v2026.5.34 : le softUnpin ne supprime plus le popup au mouseleave, donc
  // ici on les supprime explicitement quand un nouveau tooltip démarre.
  const softUnpinned = document.querySelectorAll(".soft-unpinned");
  if (softUnpinned.length) {
    LOG.info("showTooltip", `suppression de ${softUnpinned.length} popup(s) soft-unpinned`);
    softUnpinned.forEach(el => {
      try { el.remove(); } catch (err) {}
    });
  }

  // v4.1.15 : si la bulle est épinglée sur une autre iv, on NE REMPLACE PAS
  // son contenu (l'user veut garder la fiche épinglée même en survolant
  // d'autres cartes).
  if (bulleState.pinned && state.currentTooltipIv && state.currentTooltipIv !== iv) {
    LOG.info("showTooltip", "ignoré : tooltip épinglé sur une autre iv");
    return;
  }

  const el = tooltipEl();
  el.innerHTML = buildTooltipHTML(iv);
  // v2026.5.46 — flag : ce tooltip provient-il du popup de RECHERCHE ?
  // (sert à coordonner la fermeture groupée recherche + tooltip).
  if (posOpts && posOpts.anchorRowEl) el.dataset.fromSearch = "1";
  else if (el.dataset) delete el.dataset.fromSearch;
  el.classList.remove("hidden");
  el.classList.add("visible");
  // Conserver le pinned si on revient sur la même iv
  if (bulleState.pinned && state.currentTooltipIv === iv) {
    el.classList.add("pinned");
  } else {
    el.classList.remove("pinned");
  }
  if (bulleState.hideTimer) {
    clearTimeout(bulleState.hideTimer);
    bulleState.hideTimer = null;
  }
  bulleState.hoveredInRow = true;
  // v4.1.12 : positionner la bulle UNE SEULE FOIS au mouseenter, près de la
  // carte (row) et pas du curseur. Elle ne bouge plus pdt le survol.
  // v4.1.15 : si pinned, NE PAS repositionner (la bulle doit rester fixe).
  if (!bulleState.pinned) {
    positionTooltipAnchored(rowEl || (e && e.currentTarget), posOpts || {});
  }

  // v4 : lazy-load du texte complet de l'action au premier hover.
  // Sans await : on affiche le tooltip IMMÉDIATEMENT avec ce qu'on a (lieu,
  // contact, catégorie, ref venant du XML) ; quand le xhr2 arrive (50-200 ms
  // plus tard typiquement), on régénère le tooltip s'il est encore visible.
  if (iv && iv.type === "AL-Intervention" && !iv.xhr2Fetched && !iv.xhr2Fetching) {
    ensureBulleDescription(iv).then(ok => {
      // Si ça a marché ET que le tooltip est toujours visible sur CETTE iv,
      // on régénère le HTML pour afficher les détails Problème/À faire/Matériel.
      if (!ok) return;
      const tip = tooltipEl();
      if (!tip.classList.contains("visible")) return;
      // Vérifie qu'on affiche toujours la même interventoin (pas un autre hover
      // intervenu entretemps)
      if (state.currentTooltipIv === iv) {
        tip.innerHTML = buildTooltipHTML(iv);
      }
    });
  }
  // Mémoriser quelle iv est actuellement affichée (utilisé pour éviter
  // d'écraser un tooltip différent si un autre hover s'est produit entretemps)
  state.currentTooltipIv = iv;
}

function hideTooltip(opts = {}) {
  // v2026.5.40 : version SIMPLE.
  // - annuler les éventuels timers de show planifiés
  // - sauf si épinglé (clic explicite), démarrer un timer 500ms qui ferme
  // - si la souris revient sur la row/popup, le timer est annulé via les
  //   listeners mouseenter (pas via flags / elementFromPoint)
  _cancelPendingShowTooltip();
  _cancelPendingTimelinePopover();
  if (bulleState.pinned && !opts.force) return;
  if (bulleState.hideTimer) clearTimeout(bulleState.hideTimer);
  bulleState.hideTimer = setTimeout(() => {
    bulleState.hideTimer = null;
    if (bulleState.pinned) return;
    // Sélection de texte active : on garde (sauf si force).
    if (!opts.force && hasTextSelectionInTooltip()) return;
    const el = tooltipEl();
    el.classList.remove("visible", "pinned");
    el.classList.add("hidden");
    if (el.dataset) delete el.dataset.mode;
    state.currentTooltipIv = null;
    currentTooltipPos = null;
    tooltipPositionMode = null;
    // reset l'ancre tooltip pour ne pas reposition sur une source
    // obsolète au prochain scroll.
    _currentTooltipAnchorEl = null;
    _currentTooltipAnchorOpts = null;
    bulleState.hoveredInBulle = false;
    bulleState.hoveredInRow = false;
  }, 500);
}

/** v2026.5.40 : annule un timer de fermeture en cours. Appelé par les
 *  mouseenter sur row et sur popup pour garder la popup ouverte. */
function _cancelHideTooltip() {
  if (bulleState.hideTimer) {
    clearTimeout(bulleState.hideTimer);
    bulleState.hideTimer = null;
  }
}

// v4.2 : détecte si l'utilisateur a une sélection de texte active dans la bulle.
// Utilisé pour empêcher la fermeture automatique tant qu'on n'a pas fini de
// sélectionner/copier.
function hasTextSelectionInTooltip() {
  try {
    const sel = window.getSelection();
    if (!sel || sel.isCollapsed || sel.rangeCount === 0) return false;
    const tip = tooltipEl();
    if (!tip) return false;
    const range = sel.getRangeAt(0);
    // La sélection est dans la bulle si au moins un endpoint y est
    return tip.contains(range.startContainer) || tip.contains(range.endContainer);
  } catch {
    return false;
  }
}

function moveTooltip(e) {
  // Historique : avant on suivait la souris. Maintenant la bulle est fixe
  // (placée une seule fois au mouseenter). Cette fonction est là juste pour
  // pas casser les appels existants.
}

// ============================================================================
// Positionnement du tooltip
// ============================================================================
// On positionne avec style.left/top en coords VIEWPORT (comme position:fixed).
// Si un ancêtre casse position:fixed (transform, filter, backdrop-filter ou
// contain), on détecte ça empiriquement au 1er placement via
// getBoundingClientRect — et on bascule en "abs" : mêmes coords mais on
// compense le scroll manuellement pour garder la bulle stable à l'écran.
// ============================================================================

// Position stockée : targetLeft / targetTop = coordonnées VIEWPORT désirées
// (où la popup doit apparaître à l'écran, peu importe le scroll).
let currentTooltipPos = null;

// Mode de positionnement, détecté empiriquement :
//   null    : pas encore détecté
//   "fixed" : position:fixed marche → on laisse le navigateur gérer au scroll
//   "abs"   : position:fixed cassée → on compense manuellement au scroll
let tooltipPositionMode = null;

function setTooltipViewportPosition(viewportX, viewportY) {
  const el = tooltipEl();
  if (!el) return;
  currentTooltipPos = { x: viewportX, y: viewportY };

  // Appliquer la position en supposant que position:fixed marche
  el.style.left = viewportX + "px";
  el.style.top = viewportY + "px";

  // Détection empirique au 1er positionnement : on compare la position
  // réelle du tooltip (getBoundingClientRect) à la position demandée.
  // Si ça correspond (à 1px près), position:fixed fonctionne. Sinon
  // c'est qu'un ancêtre a cassé le containing block.
  if (tooltipPositionMode === null) {
    const r = el.getBoundingClientRect();
    const deltaX = Math.abs(r.left - viewportX);
    const deltaY = Math.abs(r.top - viewportY);
    if (deltaX <= 1 && deltaY <= 1) {
      tooltipPositionMode = "fixed";
    } else {
      tooltipPositionMode = "abs";
      LOG.info("tooltip",
        "position:fixed cassée par un ancêtre, passage en mode compensé au scroll. " +
        `delta=(${deltaX.toFixed(1)}, ${deltaY.toFixed(1)})`
      );
    }
  }

  // Si mode "abs" : le top/left qu'on vient de poser est en réalité interprété
  // par rapport au containing block (pas le viewport). On doit compenser
  // immédiatement pour placer la popup au bon endroit visuellement.
  if (tooltipPositionMode === "abs") {
    const r = el.getBoundingClientRect();
    const offsetX = viewportX - r.left;  // écart à corriger
    const offsetY = viewportY - r.top;
    // Nouvelle valeur absolute qui produit la position viewport voulue
    const absLeft = parseFloat(el.style.left) + offsetX;
    const absTop = parseFloat(el.style.top) + offsetY;
    el.style.left = absLeft + "px";
    el.style.top = absTop + "px";
    // Mémoriser pour compenser au scroll
    el._absBasisLeft = absLeft;
    el._absBasisTop = absTop;
    el._absBasisScrollX = window.scrollX || window.pageXOffset || 0;
    el._absBasisScrollY = window.scrollY || window.pageYOffset || 0;
  }
}

// Listener global scroll : si on est en mode "abs", on compense pour que la
// popup reste visuellement au même endroit pendant le scroll.
// référence à la source actuellement ancrée + options, pour permettre
// au scroll handler de réancrer le tooltip live à chaque scroll. Sans ça,
// position:fixed gardait le tooltip collé au viewport pendant que la source
// (absence/réservation/iv) défilait avec le contenu → décalage visuel.
let _currentTooltipAnchorEl = null;
let _currentTooltipAnchorOpts = null;

function reapplyTooltipPosition() {
  const el = tooltipEl();
  if (!el || !el.classList.contains("visible")) return;
  // Si la popup est épinglée (.pinned-popup), elle a sa propre logique de
  // positionnement (le user peut la déplacer) — on ne touche pas.
  if (el.classList.contains("pinned-popup")) return;

  // repositionner par rapport à la source ancrée pour suivre le
  // scroll de la page (la source bouge, le tooltip suit).
  if (_currentTooltipAnchorEl && _currentTooltipAnchorEl.isConnected) {
    // Si la source est sortie de la zone visible → cacher le tooltip
    // (sinon il flotterait collé en haut/bas du viewport hors contexte).
    const r = _currentTooltipAnchorEl.getBoundingClientRect();
    const visible = r.bottom > 0 && r.top < window.innerHeight
                 && r.right > 0 && r.left < window.innerWidth;
    if (!visible) {
      hideTooltip({ force: true });
      return;
    }
    positionTooltipAnchored(_currentTooltipAnchorEl, _currentTooltipAnchorOpts || {});
    return;
  }

  // Fallback ancien chemin : si pas d'ancre stockée, on garde la
  // compensation manuelle (mode "abs") qui existait déjà.
  if (!currentTooltipPos) return;
  if (tooltipPositionMode !== "abs") return;
  const scrollX = window.scrollX || window.pageXOffset || 0;
  const scrollY = window.scrollY || window.pageYOffset || 0;
  const dx = scrollX - (el._absBasisScrollX || 0);
  const dy = scrollY - (el._absBasisScrollY || 0);
  el.style.left = ((el._absBasisLeft || 0) + dx) + "px";
  el.style.top  = ((el._absBasisTop  || 0) + dy) + "px";
}

/**
 * v2026.5.34 : fonction UNIQUE et unifiée de positionnement ancré du tooltip.
 *
 * Utilisée par :
 *   - showTooltip() — hover d'une row intervention en vue classique
 *   - openPersistentTimelinePopup() — clic (classique) ou hover (horizontal)
 *     d'un segment timeline
 *   - showTooltip() pour les cartes/badges absence
 *
 * Algorithme :
 *   1. Essaie 4 positions dans l'ordre : droite, gauche, dessous, dessus
 *   2. Chaque position : padding de 8px min par rapport à la source
 *   3. Chaque position : doit tenir dans la safe area (pas sous topbar/dock)
 *   4. Chaque position : ne doit pas chevaucher les popups épinglés existants
 *   5. Première position qui satisfait tout → on la prend
 *   6. Fallback si aucune ne marche : droite clampée (la moins pire)
 *
 * La popup ne couvre JAMAIS la source (pad >= 8px en distance euclidienne).
 *
 * @param {HTMLElement} sourceEl - l'élément déclencheur (row, card, segment)
 * @param {object} opts - options { anchorBelow: true pour préférer dessous }
 *
 * @author Quentin Rouiller
 */
function positionTooltipAnchored(sourceEl, opts) {
  opts = opts || {};
  const el = tooltipEl();
  if (!el) {
    LOG.warn("positionTooltip", "tooltip DOM introuvable");
    return;
  }
  if (!sourceEl) {
    LOG.warn("positionTooltip", "sourceEl null — pas de positionnement");
    return;
  }
  // on mémorise la source ancrée pour pouvoir repositionner le
  // tooltip à chaque scroll (sinon il reste collé au viewport en
  // position:fixed alors que la source bouge avec le scroll → décalage).
  _currentTooltipAnchorEl = sourceEl;
  _currentTooltipAnchorOpts = opts;

  const pad = 10;                           // padding entre source et popup
  const viewportMargin = 8;                 // marge par rapport aux bords
  // v2026.5.46 — rect d'ancrage custom possible (ex. tooltip d'un résultat
  // de recherche : X = bords du POPUP de recherche (sourceEl), Y = la carte
  // survolée (opts.anchorRowEl) → le tooltip sort À CÔTÉ du popup, jamais
  // par-dessus les autres résultats, mais aligné verticalement sur la carte.
  let srcRect;
  if (opts.anchorRowEl) {
    const br = sourceEl.getBoundingClientRect();
    const rr = opts.anchorRowEl.getBoundingClientRect();
    srcRect = { left: br.left, right: br.right, top: rr.top, bottom: rr.bottom, width: br.width, height: rr.height };
  } else {
    srcRect = opts.anchorRect || sourceEl.getBoundingClientRect();
  }
  const tipRect = el.getBoundingClientRect();
  const tipW = tipRect.width  || 320;       // fallback taille si pas encore rendu
  const tipH = tipRect.height || 200;

  // Safe area : respecter topbar en haut, dock en bas
  const safe = (typeof _getPopupSafeArea === "function")
    ? _getPopupSafeArea()
    : { left: viewportMargin, top: viewportMargin,
        right: window.innerWidth - viewportMargin,
        bottom: window.innerHeight - viewportMargin };

  // 4 candidats (ordre : droite → gauche → dessous → dessus)
  //   Préférence opts.anchorBelow = true : dessous en premier (ex: clic timeline)
  // v2026.5.41 : en vue horizontale, on n'autorise QUE dessous/dessus (la
  // sidebar à gauche et la timeline pleine largeur rendent gauche/droite
  // peu praticables et le popup masquerait la row source).
  const rightCandidate  = { x: srcRect.right + pad, y: srcRect.top,             label: "droite"  };
  const leftCandidate   = { x: srcRect.left - tipW - pad, y: srcRect.top,       label: "gauche"  };
  const belowCandidate  = { x: srcRect.left, y: srcRect.bottom + pad,           label: "dessous" };
  const aboveCandidate  = { x: srcRect.left, y: srcRect.top - tipH - pad,       label: "dessus"  };

  const isHorizontal = document.documentElement.classList.contains("view-horizontal");
  let candidates;
  if (opts.forceSides) {
    // v2026.5.46 — priorité DROITE puis GAUCHE, dans toutes les vues (cas
    // du tooltip d'un résultat de recherche : doit sortir à côté du popup,
    // jamais par-dessus les autres résultats — y compris en horizontal).
    candidates = [rightCandidate, leftCandidate];
  } else if (isHorizontal) {
    candidates = [belowCandidate, aboveCandidate];
  } else if (opts.anchorBelow) {
    candidates = [belowCandidate, aboveCandidate, rightCandidate, leftCandidate];
  } else {
    candidates = [rightCandidate, leftCandidate, belowCandidate, aboveCandidate];
  }

  const pinnedRects = (typeof _getPinnedPopupsViewportRects === "function")
    ? _getPinnedPopupsViewportRects()
    : [];

  let chosen = null;
  for (const c of candidates) {
    // Clamp dans la safe area
    let cx = c.x, cy = c.y;
    if (cx < safe.left) cx = safe.left;
    if (cx + tipW > safe.right) cx = safe.right - tipW;
    if (cx < safe.left) continue; // popup plus large que safe area — skip
    if (cy < safe.top) cy = safe.top;
    if (cy + tipH > safe.bottom) cy = safe.bottom - tipH;
    if (cy < safe.top) continue;

    // Ne chevauche PAS la source (garantit qu'on ne la cache pas)
    const candRect = { left: cx, top: cy, right: cx + tipW, bottom: cy + tipH };
    if (_rectsOverlap(candRect, srcRect)) continue;

    // Ne chevauche pas les popups épinglés existants
    const hitsPinned = pinnedRects.some(pr => _rectsOverlap(candRect, pr));
    if (hitsPinned) continue;

    chosen = { x: cx, y: cy, label: c.label };
    break;
  }

  if (!chosen) {
    // Fallback : en horizontal, dessous clampé. En classique, droite clampée.
    // Même si ça chevauche (cas rare : écran minuscule ou beaucoup de popups épinglés).
    let fx, fy;
    if (isHorizontal) {
      fx = srcRect.left;
      fy = srcRect.bottom + pad;
    } else {
      fx = srcRect.right + pad;
      fy = srcRect.top;
    }
    if (fx + tipW > safe.right) fx = safe.right - tipW;
    if (fx < safe.left) fx = safe.left;
    if (fy + tipH > safe.bottom) fy = safe.bottom - tipH;
    if (fy < safe.top) fy = safe.top;
    chosen = { x: fx, y: fy, label: "fallback" };
    LOG.info("positionTooltip", "fallback utilisé (aucun candidat optimal trouvé)");
  } else {
    LOG.info("positionTooltip", `position choisie : ${chosen.label} (${Math.round(chosen.x)}, ${Math.round(chosen.y)})`);
  }

  setTooltipViewportPosition(chosen.x, chosen.y);
}

/**
 * v2026.5.17 : retourne les rectangles (en coords viewport) de tous les popups
 * actuellement épinglés et visibles (non réduits). Utilisé pour anti-chevauchement.
 */
function _getPinnedPopupsViewportRects() {
  const rects = [];
  document.querySelectorAll(".pinned-popup").forEach(p => {
    if (p.classList.contains("pinned-popup-reduced")) return; // docké, pas à l'écran
    const r = p.getBoundingClientRect();
    if (r.width > 0 && r.height > 0) rects.push(r);
  });
  return rects;
}

// ============================================================================
// v4.3.0 : système de popups épinglés détachés
// ============================================================================
//
// Au lieu d'épingler le tooltip unique (qui empêchait d'afficher d'autres
// infos au survol), on clone son contenu en un popup indépendant :
//   - Ancré DANS le contenu de la page (position: absolute + coordonnées
//     document) → scrolle avec le contenu, pas avec le viewport.
//   - Peut coexister avec d'autres popups épinglés (jusqu'à ce qu'il n'y
//     ait plus de place disponible).
//   - Persiste jusqu'à fermeture explicite (bouton ×, Échap, ou Ctrl×2 si 1 seul).
//
// Le tooltip live (#tooltip) garde son rôle initial : il se ferme au mouseleave.

const pinnedPopups = [];  // [{el, iv, rect}]

/**
 * Ancre la popup au contenu : ajoute le scrollY actuel au top viewport pour
 * obtenir une position absolute document, qui scrolle avec le contenu.
 */
function _viewportToDocumentY(y) {
  return y + (window.scrollY || window.pageYOffset || 0);
}
function _viewportToDocumentX(x) {
  return x + (window.scrollX || window.pageXOffset || 0);
}

/**
 * Teste si un rectangle {left, top, right, bottom} (en coords document)
 * chevauche avec un popup déjà épinglé.
 */
function _rectsOverlap(a, b) {
  return !(a.right <= b.left || a.left >= b.right ||
           a.bottom <= b.top || a.top >= b.bottom);
}

/**
 * v2026.5.45 (issue #6) : amène un popup épinglé au premier plan en
 * réinitialisant le z-index de tous les autres popups épinglés. Le popup
 * cliqué passe à z-index 9 (juste sous la topbar à 10), les autres reprennent
 * le z-index par défaut hérité du CSS (5).
 *
 * IMPORTANT : la règle CSS `.tooltip.pinned-popup { z-index: 5 !important; }`
 * empêche un simple `style.zIndex = "9"` de prendre effet. Il FAUT utiliser
 * `setProperty(..., 'important')` pour battre le `!important` du CSS.
 *
 * @author Quentin Rouiller
 */
function _bringPinnedPopupToFront(popup) {
  if (!popup) return;
  document.querySelectorAll('.pinned-popup').forEach(p => {
    if (p !== popup) p.style.removeProperty('z-index');
  });
  popup.style.setProperty('z-index', '9', 'important');
}

// v2026.5.45 : mémorisation des dimensions resizées par l'utilisateur,
// keyée par "actionId|date". Persiste durant la session (pas en storage).
// Permet à un popup re-créé (re-pin après unpin, retour depuis le dock, etc.)
// de retrouver la taille que l'utilisateur lui avait donnée précédemment.
const _userPopupSizes = new Map();
function _userPopupSizeKey(iv, date) {
  if (!iv || !iv.actionId) return null;
  return iv.actionId + "|" + (date || state.currentDate || "");
}
function _rememberPopupSize(popup, iv) {
  if (!popup || !iv) return;
  const key = _userPopupSizeKey(iv, popup.dataset.originDate);
  if (!key) return;
  if (typeof ResizeObserver === "undefined") return;
  if (popup._sizeObserver) {
    try { popup._sizeObserver.disconnect(); } catch (_) {}
  }
  // box-sizing global est border-box → quand on lit la taille pour
  // la ré-appliquer plus tard via style.width/height, il faut prendre la
  // dimension BORDER-BOX (= offsetWidth/offsetHeight) sinon on stocke la
  // taille du content-box (sans padding+border) → au re-pin on applique
  // une valeur trop petite et le popup rétrécit à chaque cycle.
  const ro = new ResizeObserver((entries) => {
    for (const e of entries) {
      const target = e.target;
      const w = Math.round(target.offsetWidth);
      const h = Math.round(target.offsetHeight);
      if (w > 0 && h > 0 && (target.classList.contains("pinned-popup") ||
                              target.classList.contains("soft-unpinned"))) {
        _userPopupSizes.set(key, { w, h });
      }
    }
  });
  ro.observe(popup);
  popup._sizeObserver = ro;
}
function _applyRememberedPopupSize(popup, iv, date) {
  if (!popup || !iv) return false;
  const key = _userPopupSizeKey(iv, date);
  if (!key) return false;
  const sz = _userPopupSizes.get(key);
  if (!sz) return false;
  popup.style.width = sz.w + "px";
  popup.style.height = sz.h + "px";
  return true;
}

/**
 * Cherche une position libre pour un popup de dimensions {w, h} près de la
 * ligne source `rowEl`. Essaie dans l'ordre : droite, gauche, dessous, dessus.
 * Retourne {x, y} en coordonnées document, ou null si aucune position libre.
 *
 * @author Quentin Rouiller
 */
function _findFreePopupPosition(rowEl, w, h) {
  const pad = 14;
  const rowRect = rowEl.getBoundingClientRect();
  // v2026.5.20 : utiliser la safe area (en dessous topbar, au-dessus dock)
  const safe = _getPopupSafeArea();

  // 4 candidats d'abord, autour de la row source (en coords viewport).
  // v2026.5.41 : en vue horizontale, on n'autorise QUE dessous/dessus.
  const isHorizontal = document.documentElement.classList.contains("view-horizontal");
  const candidates = isHorizontal
    ? [
        { x: rowRect.left, y: rowRect.bottom + pad,       name: "dessous" },
        { x: rowRect.left, y: rowRect.top - h - pad,      name: "dessus"  }
      ]
    : [
        { x: rowRect.right + pad, y: rowRect.top,         name: "droite"  },
        { x: rowRect.left - w - pad, y: rowRect.top,      name: "gauche"  },
        { x: rowRect.left, y: rowRect.bottom + pad,       name: "dessous" },
        { x: rowRect.left, y: rowRect.top - h - pad,      name: "dessus"  }
      ];

  // v2026.5.20 : ajouter une grille de positions de fallback couvrant toute
  // la safe area (pas de 60px × 60px) — garantit qu'on trouve ~toujours une
  // place, sauf si vraiment trop de popups actifs.
  const availW = safe.right - safe.left;
  const availH = safe.bottom - safe.top;
  if (availW > w + 20 && availH > h + 20) {
    for (let y = safe.top; y + h <= safe.bottom; y += 60) {
      for (let x = safe.left; x + w <= safe.right; x += 60) {
        candidates.push({ x, y, name: "grid" });
      }
    }
  }

  // Tester chaque candidat dans l'ordre
  for (const c of candidates) {
    let x = c.x, y = c.y;
    // Clamp dans la safe area
    if (x < safe.left) x = safe.left;
    if (x + w > safe.right) x = safe.right - w;
    if (x < safe.left) continue; // popup plus large que safe area
    if (y < safe.top) y = safe.top;
    if (y + h > safe.bottom) y = safe.bottom - h;
    if (y < safe.top) continue;

    // Si, après clamp, la popup chevaucherait la ligne source elle-même,
    // on ignore ce candidat (on préfère une direction qui la laisse visible).
    const rowRectClamped = {
      left: rowRect.left, top: rowRect.top,
      right: rowRect.right, bottom: rowRect.bottom
    };
    const candRect = { left: x, top: y, right: x + w, bottom: y + h };
    // v2026.5.20 : pour les 4 candidats principaux, on refuse de chevaucher
    // la row ; pour les candidats "grid" de fallback, on l'accepte
    // (on veut une place à tout prix).
    if (c.name !== "grid" && _rectsOverlap(candRect, rowRectClamped)) continue;

    // Test chevauchement avec les popups déjà épinglés (coords document)
    const docRect = {
      left: _viewportToDocumentX(x),
      top: _viewportToDocumentY(y),
      right: _viewportToDocumentX(x + w),
      bottom: _viewportToDocumentY(y + h)
    };
    let overlapsOther = false;
    for (const p of pinnedPopups) {
      // Ne pas comparer avec un popup qui est dans le dock (réduit)
      if (p.el && p.el.classList && p.el.classList.contains("pinned-popup-reduced")) continue;
      if (_rectsOverlap(docRect, p.rect)) {
        overlapsOther = true;
        break;
      }
    }
    if (!overlapsOther) {
      return {
        viewportX: x, viewportY: y,
        docX: docRect.left, docY: docRect.top,
        rect: docRect
      };
    }
  }

  // v2026.5.20 : ultime fallback — accepter de chevaucher mais décaler
  // un peu par rapport au 1er popup épinglé existant. Évite complètement
  // le "Pas de place" injuste.
  if (pinnedPopups.length > 0) {
    const last = pinnedPopups[pinnedPopups.length - 1];
    let x = (last.rect.left - (window.scrollX || 0)) + 30;
    let y = (last.rect.top  - (window.scrollY || 0)) + 30;
    if (x + w > safe.right) x = safe.right - w;
    if (y + h > safe.bottom) y = safe.bottom - h;
    if (x < safe.left) x = safe.left;
    if (y < safe.top) y = safe.top;
    const docRect = {
      left: _viewportToDocumentX(x),
      top: _viewportToDocumentY(y),
      right: _viewportToDocumentX(x + w),
      bottom: _viewportToDocumentY(y + h)
    };
    return {
      viewportX: x, viewportY: y,
      docX: docRect.left, docY: docRect.top,
      rect: docRect
    };
  }
  return null;
}

/**
 * v4.3.0 : épingle la bulle courante en la clonant dans un popup détaché
 * ancré au contenu. Le tooltip live redevient disponible.
 *
 * @author Quentin Rouiller
 */
function pinTooltip() {
  if (!state.currentTooltipIv) return;
  const srcEl = tooltipEl();
  if (!srcEl) return;
  const iv = state.currentTooltipIv;

  // v2026.5.21 : unicité actionId + date. Si un popup pour la même ref
  // ET la même date est déjà épinglé, on le supprime et on re-crée un nouveau
  // (user a choisi ce comportement : "tu supprime le popup actuellement
  // épinglé et tu répingle la nouvelle fenêtre").
  const currentDate = state.currentDate || "";
  const existingKey = (iv.actionId || "") + "|" + currentDate;
  for (let i = pinnedPopups.length - 1; i >= 0; i--) {
    const p = pinnedPopups[i];
    if (!p || !p.el) continue;
    const aid = p.el.dataset.actionId || "";
    const d = p.el.dataset.originDate || "";
    if (aid + "|" + d === existingKey) {
      // Retirer l'ancien (popup + pastille dock éventuelle)
      if (p.el._linkedPill) {
        try { p.el._linkedPill.remove(); } catch (e) {}
      }
      try { p.el.remove(); } catch (e) {}
      pinnedPopups.splice(i, 1);
    }
  }
  // Nettoyer un éventuel dock devenu vide
  const dockEl = document.getElementById("pinned-popups-dock");
  if (dockEl && dockEl.querySelectorAll(".pinned-popup-dock-pill").length === 0) {
    dockEl.classList.remove("visible");
    const closeAllBtn = document.getElementById("pinned-popups-close-all");
    if (closeAllBtn) closeAllBtn.remove();
  }

  // Chercher la ligne source pour le positionnement.
  // v2026.5.35 : en vue horizontale, les rows .intervention-v2 sont CACHÉES
  // (display: none via CSS .view-horizontal). getBoundingClientRect d'un
  // élément caché retourne (0,0,0,0) → popup part en haut à gauche.
  // Solution : priorité au tooltip actuellement visible (qui EST la vraie
  // source visuelle du clic/hover). Fallback sur le segment timeline. Enfin
  // la row (qui marche en vue classique).
  let rowEl = null;
  const _isHorizontalView = document.documentElement.classList.contains("view-horizontal");

  if (_isHorizontalView) {
    LOG.info("pinTooltip", "vue horizontale → source = tooltip visible ou segment timeline");
    // Priorité 1 : le tooltip actuellement affiché (meilleure source visuelle)
    const currentTip = tooltipEl();
    if (currentTip && currentTip.classList.contains("visible")) {
      const r = currentTip.getBoundingClientRect();
      if (r.width > 0 && r.height > 0) {
        rowEl = currentTip;
        LOG.info("pinTooltip", `source = tooltip visible (${Math.round(r.left)}, ${Math.round(r.top)})`);
      }
    }
    // Priorité 2 : segment timeline pour cette actionId
    if (!rowEl && iv.actionId) {
      // Il peut y avoir plusieurs .timeline-slot avec le même ivIdx si plusieurs
      // cartes. On prend celui dont la row parente a le bon actionId.
      const allSlots = document.querySelectorAll(".timeline-slot[data-iv-idx]");
      for (const slot of allSlots) {
        const card = slot.closest(".card");
        if (!card) continue;
        const ivIdx = slot.dataset.ivIdx;
        const row = card.querySelector(`.intervention-v2[data-iv-idx="${ivIdx}"]`);
        if (row && row.dataset.actionId === iv.actionId) {
          const r = slot.getBoundingClientRect();
          if (r.width > 0 && r.height > 0) {
            rowEl = slot;
            LOG.info("pinTooltip", `source = segment timeline actionId=${iv.actionId}`);
            break;
          }
        }
      }
    }
  } else {
    // Vue classique : chercher la row .intervention-v2 (comportement d'origine)
    if (iv.actionId) {
      rowEl = document.querySelector(`.intervention-v2[data-action-id="${iv.actionId}"]`);
      if (rowEl) {
        LOG.info("pinTooltip", `vue classique → source = row intervention-v2`);
      }
    }
  }

  // Fallback final : le tooltip live (même s'il n'est pas visible) — position actuelle
  if (!rowEl) {
    LOG.warn("pinTooltip", "aucune source visible trouvée → fallback tooltip live");
    rowEl = srcEl;
  }

  // Cloner le contenu du tooltip actuel en popup détaché
  const popup = document.createElement("div");
  popup.className = "tooltip pinned-popup visible";
  popup.dataset.actionId = iv.actionId || "";
  popup.innerHTML = srcEl.innerHTML;

  // Largeur/hauteur du popup épinglé. Priorité à la taille préservée
  // d'un cycle dépingle → ré-épingle (pour que pinning/unpinning multiples
  // ne change pas la taille). Sinon, on prend la largeur du tooltip live.
  if (_pinTooltipPreservedSize) {
    popup.style.width = _pinTooltipPreservedSize.width + "px";
    popup.style.height = _pinTooltipPreservedSize.height + "px";
    _pinTooltipPreservedSize = null;
  } else {
    try {
      const liveRect = srcEl.getBoundingClientRect();
      if (liveRect && liveRect.width > 100) {
        popup.style.width = Math.round(liveRect.width) + "px";
      }
    } catch (e) { /* ignore — fallback CSS 520px */ }
  }

  // v2026.5.18 : mémoriser la ref et la couleur pour le dock (pastille avec
  // couleur de catégorie + texte ref)
  popup.dataset.ref = iv.ref || "";
  popup.dataset.colorKey = (typeof deriveColorKey === "function" ? deriveColorKey(iv) : "autre") || "autre";

  // v2026.5.19 : mémoriser aussi la date pour l'afficher sur la pastille dock
  popup.dataset.originDate = state.currentDate || "";

  // v2026.5.25 : mémoriser aussi lieu + service pour la pastille enrichie
  try {
    const info = iv.infobulle || {};
    const lieuRaw = info.lieu || iv.bulleLieu || "";
    // Format pour pastille : "VILLE, Adresse" (on extrait les 2 premières parties)
    const { ville, adresse } = (typeof splitLieu === "function")
      ? splitLieu(lieuRaw)
      : { ville: null, adresse: null };
    let lieuFmt = "";
    if (ville && adresse) lieuFmt = ville.toUpperCase() + ", " + adresse;
    else if (adresse) lieuFmt = adresse;
    else if (ville) lieuFmt = ville.toUpperCase();
    popup.dataset.lieu = lieuFmt;

    // Service : prendre les 2 dernières parties séparées par "/"
    // Ex: "AdmCV/DJES/SSCM/SSCM - Admin/TEO - OS" → "SSCM - Admin/TEO - OS"
    //     "AdmCV/OJV/JPX/JPX Lavaux-Oron" → "JPX/JPX Lavaux-Oron"
    // v2026.5.26 : dans le DERNIER segment seulement, couper au " - " (espace
    //              tiret espace) pour retirer les descriptions longues. Les
    //              noms propres comme "Lavaux-Oron" (sans espaces) sont préservés.
    //   Ex: "AdmCV/DJES/SSCM/SPOP - Centre administratif" → "SSCM/SPOP"
    //       "AdmCV/OJV/JPX/JPX Lavaux-Oron" → "JPX/JPX Lavaux-Oron" (inchangé)
    const serviceRaw = (info.service) || iv.categoryLine || "";
    if (serviceRaw) {
      const parts = serviceRaw.split("/").map(s => s.trim()).filter(Boolean);
      let last2 = parts.slice(-2);
      // Couper au " - " dans le DERNIER élément de last2
      if (last2.length > 0) {
        const lastIdx = last2.length - 1;
        const lastSeg = last2[lastIdx];
        const dashIdx = lastSeg.indexOf(" - ");
        if (dashIdx > 0) {
          last2[lastIdx] = lastSeg.substring(0, dashIdx).trim();
        }
      }
      popup.dataset.service = last2.join("/");
    } else {
      popup.dataset.service = "";
    }
  } catch (err) {
    LOG.warn("pin", "lieu/service build failed", err);
  }

  // v2026.5.17 : masquer l'icône du contenu cloné (redondante car le
  // popup a sa propre topbar avec le bouton "désépingler" explicite)
  const oldPin = popup.querySelector('.tooltip-pinbtn[data-action="pin"]');
  if (oldPin) oldPin.remove();

  // v2026.5.17 : topbar avec 3 boutons pour un popup épinglé :
  // v2026.5.18 : swap des actions — _ réduit dans le dock, ▭ minimise flottant
  //   _  = Réduire (docké dans la taskbar du bas)
  //   ▭  = Minimiser (popup reste flottant mais compact, juste la ref)
  //   = Désépingler (l'icône d'épingle "plantée" ; clic = retire l'épingle)
  const topbar = document.createElement("div");
  topbar.className = "pinned-popup-topbar";

  // Bouton Réduire (icône _ )
  const reduceBtn = document.createElement("button");
  reduceBtn.type = "button";
  reduceBtn.className = "pinned-popup-btn pinned-popup-reduce";
  reduceBtn.innerHTML = "_";
  reduceBtn.title = "Réduire (docké en bas de l'écran)";
  reduceBtn.addEventListener("click", (e) => {
    e.stopPropagation();
    _reducePinnedPopup(popup);
  });
  topbar.appendChild(reduceBtn);

  // Bouton Minimiser (icône ▭ )
  const minBtn = document.createElement("button");
  minBtn.type = "button";
  minBtn.className = "pinned-popup-btn pinned-popup-minimize";
  minBtn.innerHTML = "▭";
  minBtn.title = "Minimiser (reste flottant mais compact)";
  minBtn.addEventListener("click", (e) => {
    e.stopPropagation();
    _minimizePinnedPopup(popup);
  });
  topbar.appendChild(minBtn);

  // v2026.5.19 : Bouton Actualiser (même icône SVG que le tooltip standard)
  // Re-fetch la fiche de l'intervention pour mettre à jour les infos (statut,
  // commentaires, action text) sans recharger le planning entier.
  const refreshBtn = document.createElement("button");
  refreshBtn.type = "button";
  refreshBtn.className = "pinned-popup-btn pinned-popup-refresh";
  refreshBtn.innerHTML = '<svg viewBox="0 0 16 16" fill="none" aria-hidden="true"><path d="M2 8a6 6 0 1 0 1.76-4.24M2 3v3h3" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/></svg>';
  refreshBtn.title = "Actualiser les informations de cette intervention";
  refreshBtn.addEventListener("click", async (e) => {
    e.stopPropagation();
    if (refreshBtn.classList.contains("spinning")) return;
    refreshBtn.classList.add("spinning");
    try {
      await _refreshPinnedPopupIv(popup, iv);
    } finally {
      setTimeout(() => refreshBtn.classList.remove("spinning"), 300);
    }
  });
  topbar.appendChild(refreshBtn);

  // Bouton Désépingler (icône épingle plantée)
  const unpinBtn = document.createElement("button");
  unpinBtn.type = "button";
  unpinBtn.className = "pinned-popup-btn pinned-popup-unpin";
  unpinBtn.innerHTML = "📍";
  unpinBtn.title = "Désépingler (se ferme quand la souris sort)";
  unpinBtn.addEventListener("click", (e) => {
    e.stopPropagation();
    _softUnpinPopup(popup);
  });
  topbar.appendChild(unpinBtn);

  popup.appendChild(topbar);

  // v4.3.3 : barre de drag en haut, pour déplacer la popup à la souris.
  // Ancrée en haut à 22px de haut ; le padding-top de la popup est augmenté
  // côté CSS pour ne pas que le contenu soit caché derrière.
  const dragbar = document.createElement("div");
  dragbar.className = "pinned-popup-dragbar";
  dragbar.title = "Glissez pour déplacer";
  popup.appendChild(dragbar);
  _attachPopupDragHandler(popup, dragbar);

  // v2026.5.45 (issue #6) : amener au PREMIER PLAN le popup au clic.
  // Avant, tous les popups épinglés partageaient z-index 5 (sous la topbar)
  // et l'ordre était figé par l'ordre d'épinglage → cliquer sur un popup en
  // arrière ne le ramenait pas devant. Maintenant, au mousedown, on remet
  // tous les autres au défaut et on monte celui cliqué à z-index 9 (juste
  // sous la topbar qui est à 10).
  popup.addEventListener("mousedown", () => {
    _bringPinnedPopupToFront(popup);
  });

  // v4.3.0 : le popup contient un clone du tooltip live, qui inclut le
  // bouton . Dans un popup déjà épinglé, ce bouton devient "désépingler".
  // On intercepte le clic ici, avant qu'il remonte.
  // v2026.5.45 : on gère aussi `copy-ref` (issue #5) et `reload` à
  // l'intérieur du popup épinglé. Avant, seul `pin` était traité ; le
  // bouton copie de référence ne réagissait pas aux clics dans un
  // popup épinglé (le handler était uniquement sur le tooltip live).
  popup.addEventListener("click", (e) => {
    const btn = e.target.closest('[data-action]');
    if (!btn) return;
    const action = btn.dataset.action;
    if (action === "pin") {
      e.stopPropagation();
      e.preventDefault();
      _softUnpinPopup(popup);
      return;
    }
    if (action === "copy-ref") {
      e.stopPropagation();
      e.preventDefault();
      const ref = btn.dataset.ref;
      if (ref) {
        navigator.clipboard.writeText(ref).then(() => {
          btn.classList.add("copied");
          const original = btn.textContent;
          btn.textContent = "✓";
          setTimeout(() => {
            btn.classList.remove("copied");
            btn.textContent = original;
          }, 1200);
        }).catch(err => LOG.warn("clipboard", "copie ref échouée (popup épinglé)",
          { ref, err: err && err.message }));
      }
      return;
    }
    if (action === "reload") {
      e.stopPropagation();
      e.preventDefault();
      const iv = popup._linkedIv;
      if (iv) reloadSingleIntervention(iv, btn);
      return;
    }
    if (action === "hide-iv") {
      e.stopPropagation();
      e.preventDefault();
      _triggerHideIv(btn.dataset.actionId || (popup._linkedIv && popup._linkedIv.actionId), btn);
      return;
    }
    if (action === "open-fiche") {
      e.stopPropagation();
      e.preventDefault();
      const iv = popup._linkedIv;
      if (iv) {
        const background = !!(e.ctrlKey || e.metaKey || e.button === 1);
        openInterventionInNewTab(iv, { background });
      }
      return;
    }
    if (action === "delete-item") {
      e.stopPropagation();
      e.preventDefault();
      const actionId = btn.dataset.actionId;
      const kind = btn.dataset.kind || "absence";
      _triggerDeleteItem(actionId, kind, btn);
      return;
    }
  });

  // Placer en (0,0) temporairement pour mesurer la taille
  popup.style.position = "absolute";
  popup.style.left = "-9999px";
  popup.style.top = "-9999px";
  popup.style.visibility = "hidden";
  document.body.appendChild(popup);

  // Mesurer après rendu
  const pRect = popup.getBoundingClientRect();
  const w = pRect.width;
  const h = pRect.height;

  // v2026.5.40 : on essaie d'abord de garder le popup à la MÊME POSITION
  // que le tooltip live actuel (pour que l'utilisateur ne voie pas le popup
  // sauter à droite/gauche/haut/bas après le clic). Si pour une raison
  // quelconque la position du tooltip n'est pas exploitable, fallback sur
  // _findFreePopupPosition.
  let pos = null;
  // v2026.5.46 — priorité ABSOLUE : position préservée d'un cycle
  // désépingle → ré-épingle → le popup reste EXACTEMENT au même endroit.
  if (_pinTooltipPreservedPos) {
    pos = _pinTooltipPreservedPos;
    _pinTooltipPreservedPos = null;
  }
  try {
    const liveTip = tooltipEl();
    if (!pos && liveTip && liveTip.classList.contains("visible")) {
      const r = liveTip.getBoundingClientRect();
      if (r.width > 0 && r.height > 0) {
        pos = {
          docX: r.left + window.scrollX,
          docY: r.top + window.scrollY,
          rect: { left: r.left, top: r.top, right: r.right, bottom: r.bottom }
        };
      }
    }
  } catch (e) { /* on retombera sur _findFreePopupPosition */ }
  if (!pos) {
    pos = _findFreePopupPosition(rowEl, w, h);
  }

  if (!pos) {
    // Pas de place : retirer et afficher un toast
    popup.remove();
    showToast("Pas de place", "Fermez une popup épinglée");
    return;
  }

  // Appliquer la position (coords document = position: absolute)
  popup.style.left = pos.docX + "px";
  popup.style.top = pos.docY + "px";
  popup.style.visibility = "visible";

  // v2026.5.20 : clamper dans la safe area (topbar + dock)
  _clampPopupInSafeArea(popup);

  // Enregistrer dans la liste
  pinnedPopups.push({ el: popup, iv: iv, rect: pos.rect });
  // v2026.5.34 : stocker une référence à l'iv sur l'élément DOM — utilisée
  // par _softUnpinPopup pour pouvoir ré-épingler via le bouton restauré.
  popup._linkedIv = iv;

  // v2026.5.45 : restaurer la taille mémorisée de l'utilisateur (issue
  // resize qui se perdait après pin → unpin → re-pin), puis brancher l'observer
  // pour mémoriser les futures modifications de taille.
  _applyRememberedPopupSize(popup, iv, popup.dataset.originDate);
  _rememberPopupSize(popup, iv);

  // v2026.5.40 : si la souris passe sur un popup épinglé, on ferme
  // IMMÉDIATEMENT toute petite popup timeline ou tooltip ouvert. Évite
  // que le contenu derrière le popup épinglé reste affiché parasitement.
  popup.addEventListener("mouseenter", () => {
    _cancelPendingShowTooltip();
    _cancelPendingTimelinePopover();
    const tip = tooltipEl();
    // On ne ferme que les tooltips "live" (hover/anchored), pas les
    // popups épinglés eux-mêmes.
    if (tip && !tip.classList.contains("pinned") && tip.classList.contains("visible")) {
      tip.classList.remove("visible");
      tip.classList.add("hidden");
      if (tip.dataset) delete tip.dataset.mode;
    }
  });

  // v4.3.0 : libérer le tooltip live (il redevient utilisable pour d'autres survols)
  bulleState.pinned = false;
  bulleState.hoveredInRow = false;
  bulleState.hoveredInBulle = false;
  srcEl.classList.remove("visible", "pinned");
  srcEl.classList.add("hidden");
  if (srcEl.dataset) delete srcEl.dataset.mode;
  state.currentTooltipIv = null;
  currentTooltipPos = null;
  tooltipPositionMode = null;
  if (bulleState.hideTimer) {
    clearTimeout(bulleState.hideTimer);
    bulleState.hideTimer = null;
  }
}


/**
 * v2026.5.19 : re-fetch les infos d'une intervention et met à jour le contenu
 * du popup épinglé correspondant. Utilise fetchAndUpdateIntervention qui fait
 * xhr2 + fiche, puis régénère le HTML du tooltip avec buildTooltipHTML.
 */
async function _refreshPinnedPopupIv(popup, iv) {
  if (!popup || !iv) return;
  // v2026.5.46 — feedback immédiat : l'utilisateur signalait que la roue
  // « ne réagissait pas ». On confirme le clic (toast + log diag) AVANT le
  // fetch, pour qu'il y ait toujours un retour visuel même si le fetch est lent
  // ou ne change rien.
  showToast("Actualisation", iv.ref || iv.reservationLabel || iv.actionId || "intervention");
  LOG.info("refresh-popup", "refresh iv unique (popup épinglé)",
    { actionId: iv.actionId, type: iv.type, ref: iv.ref, verdict: ivVStatus(iv), hasFormLink: !!iv.formLink });
  try {
    // Forcer le refetch : on invalide les flags qui disent "déjà fetché"
    iv.xhr2Fetched = false;
    iv.xhr2Fetching = false;
    iv.ficheFetched = false;
    iv.ficheFetching = false;

    // Token de refresh actuel (pour que fetchAndUpdateIntervention ne soit
    // pas abortée par les checks isRefreshAborted)
    const token = (typeof currentRefreshToken !== "undefined") ? currentRefreshToken : 0;

    // refresh manuel d'une seule iv depuis le popup.
    //   - iv DISPARUE du planning (missingSince / verdict d'analyse) → analyse
    //     complète (fiche + statut + commentaire tech) via analyzeMissingIv
    //     pour rafraîchir le verdict ✓✓ / ✓ et le commentaire du popup ;
    //   - sinon → fetchAndUpdateIntervention classique (xhr2 + fiche).
    if (iv.missingSince || ivVStatus(iv) !== "live") {
      iv._analyzing = true;
      await analyzeMissingIv(iv);
      if (state.currentDate && state.currentDay) {
        await storeSave(state.currentDate, state.currentDay);
      }
    } else {
      await fetchAndUpdateIntervention(iv, token, { useFreshChecksum: true });
    }

    // Régénérer le HTML du tooltip avec les nouvelles infos.
    // On doit réinjecter juste le contenu, en gardant la topbar et la dragbar
    // (qui ne sont PAS dans le tooltip source, elles sont propres au popup).
    const topbar = popup.querySelector(".pinned-popup-topbar");
    const dragbar = popup.querySelector(".pinned-popup-dragbar");
    const newHtml = buildTooltipHTML(iv);
    popup.innerHTML = newHtml;
    // Virer aussi la vieille icône si elle revient dans le rebuild
    const oldPin = popup.querySelector('.tooltip-pinbtn[data-action="pin"]');
    if (oldPin) oldPin.remove();
    // Remettre topbar et dragbar
    if (topbar) popup.appendChild(topbar);
    if (dragbar) popup.appendChild(dragbar);
  } catch (err) {
    LOG.warn("refresh-popup", "échec du rafraîchissement", err);
  }
}

/**
 * Désépinglage "mou" (v4.3.3) : transforme un popup épinglé en tooltip simple.
 *
 * v2026.5.34 : refonte — le popup ne disparaît PLUS au mouseleave. À la place,
 * il redevient un tooltip normal avec ses boutons ↻ (Actualiser) et
 * (Épingler) restaurés dans .tooltip-actions, et reste visible à l'écran
 * comme un tooltip classique. L'user peut le re-cliquer sur pour le
 * ré-épingler, ou cliquer ailleurs pour s'en débarrasser normalement.
 *
 * @param {HTMLElement} el - le popup à désépingler
 *
 * @author Quentin Rouiller
 */
function _softUnpinPopup(el) {
  if (!el) {
    LOG.warn("softUnpin", "elément null — abandon");
    return;
  }
  LOG.info("softUnpin", "désépinglage du popup", el.dataset.actionId || "(sans actionId)");

  // 1. Retirer de la liste des popups épinglés (pour Ctrl×2 etc.)
  const idx = pinnedPopups.findIndex(p => p.el === el);
  if (idx >= 0) {
    pinnedPopups.splice(idx, 1);
    LOG.info("softUnpin", `retiré de pinnedPopups (reste ${pinnedPopups.length})`);
  }

  // 2. Reset le flag global bulleState.pinned si plus aucun popup épinglé.
  //    Sans ça, le tooltip live "croit" toujours qu'il est pinned et son
  //    handler click (notamment ↻ reload) peut partir en cacahuète.
  if (pinnedPopups.length === 0) {
    bulleState.pinned = false;
  }

  // 3. Retirer les éléments propres au mode épinglé : topbar, dragbar,
  //    close btn, et classes minimized/reduced.
  const dragbar = el.querySelector(".pinned-popup-dragbar");
  if (dragbar) dragbar.remove();
  const closeBtn = el.querySelector(".pinned-popup-close");
  if (closeBtn) closeBtn.remove();
  const topbar = el.querySelector(".pinned-popup-topbar");
  if (topbar) topbar.remove();
  el.classList.remove("pinned-popup-minimized");
  el.classList.remove("pinned-popup-reduced");

  // 4. Retirer la pastille du dock si elle existe
  if (el._linkedPill) {
    try { el._linkedPill.remove(); } catch (e) {
      LOG.warn("softUnpin", "erreur remove pill:", e);
    }
    el._linkedPill = null;
  }
  // Si le dock est vide, le cacher ; mettre à jour le bouton "Fermer tous"
  const dock = document.getElementById("pinned-popups-dock");
  if (dock && dock.querySelectorAll(".pinned-popup-dock-pill").length === 0) {
    dock.classList.remove("visible");
    const closeAllBtn = document.getElementById("pinned-popups-close-all");
    if (closeAllBtn) closeAllBtn.remove();
  } else {
    _ensureDockCloseAllBtn();
  }

  // 5. Restaurer le bouton dans .tooltip-actions
  //    Lors de l'épinglage, ce bouton a été SUPPRIMÉ du DOM (voir pinTooltip
  //    v2026.5.17 ligne 6921). Il faut le recréer pour que l'user puisse
  //    ré-épingler ou que l'icône revienne visible.
  const actionsEl = el.querySelector('.tooltip-actions');
  if (actionsEl) {
    const existingPin = actionsEl.querySelector('.tooltip-pinbtn[data-action="pin"]');
    if (!existingPin) {
      LOG.info("softUnpin", "restauration du bouton dans .tooltip-actions");
      const pinBtn = document.createElement('div');
      pinBtn.className = 'tooltip-actionbtn tooltip-pinbtn';
      pinBtn.setAttribute('data-action', 'pin');
      pinBtn.title = 'Épingler la bulle (ou double-Ctrl). Cliquer à nouveau pour libérer.';
      pinBtn.textContent = '📌';
      actionsEl.appendChild(pinBtn);
    } else {
      LOG.info("softUnpin", "bouton déjà présent, mise à jour visuelle");
      existingPin.textContent = '📌';
      existingPin.classList.remove('tooltip-pinbtn-active');
    }
  } else {
    LOG.warn("softUnpin", ".tooltip-actions introuvable dans le popup — boutons pas restaurés");
  }

  // 5bis. v2026.5.34 : attacher un nouveau handler click sur .tooltip-actions
  //       du popup soft-unpinned pour ré-épinglement / actualisation.
  //       L'ancien handler du popup épinglé (qui faisait softUnpin au clic
  //       sur pin) est encore attaché, mais notre nouveau handler utilise
  //       stopPropagation avant pour l'empêcher de s'exécuter.
  //       On garde une référence à l'iv pour pouvoir ré-épingler proprement.
  const ivForRepin = el._linkedIv || null;
  if (actionsEl && ivForRepin) {
    // Retirer d'éventuels handlers précédents en remplaçant l'element
    const newActions = actionsEl.cloneNode(true);
    actionsEl.parentNode.replaceChild(newActions, actionsEl);

    newActions.addEventListener("click", (e) => {
      const btn = e.target.closest('[data-action]');
      if (!btn) return;
      const action = btn.dataset.action;
      e.stopPropagation();
      e.preventDefault();

      if (action === "pin") {
        LOG.info("softUnpin", "clic sur d'un popup soft-unpinned → ré-épinglage");
        // Capture la taille du popup soft-unpinned pour la transmettre au
        // nouveau popup épinglé (sinon il repart à la taille du tooltip live).
        try {
          const r = el.getBoundingClientRect();
          if (r && r.width > 100 && r.height > 50) {
            _pinTooltipPreservedSize = {
              width: Math.round(r.width),
              height: Math.round(r.height),
            };
            // v2026.5.46 — garder aussi la position exacte (coords document).
            _pinTooltipPreservedPos = {
              docX: Math.round(r.left + window.scrollX),
              docY: Math.round(r.top + window.scrollY),
              rect: { left: r.left, top: r.top, right: r.right, bottom: r.bottom },
            };
          }
        } catch (err) { _pinTooltipPreservedSize = null; _pinTooltipPreservedPos = null; }
        try { el.remove(); } catch (err) {}
        state.currentTooltipIv = ivForRepin;
        pinTooltip();
      } else if (action === "reload") {
        LOG.info("softUnpin", "clic sur ↻ d'un popup soft-unpinned → recharger intervention");
        if (typeof reloadSingleIntervention === "function") {
          reloadSingleIntervention(ivForRepin, btn);
        } else {
          LOG.warn("softUnpin", "reloadSingleIntervention indisponible");
        }
      }
    });
  }

  // 6. Basculer visuellement : retirer pinned-popup, mettre soft-unpinned.
  //    La classe .soft-unpinned applique les styles "tooltip normal"
  //    (pas de bordure bleue, pas de padding-top pour topbar disparue, etc.)
  // On capture la taille AVANT le changement de classe pour pouvoir la
  // restaurer si l'utilisateur ré-épingle (sinon le popup repart à la
  // taille par défaut du tooltip live).
  try {
    const r = el.getBoundingClientRect();
    if (r && r.width > 100 && r.height > 50) {
      el._lastPinnedSize = { width: Math.round(r.width), height: Math.round(r.height) };
    }
  } catch (e) { /* ignore */ }
  el.classList.remove("pinned-popup");
  el.classList.add("soft-unpinned");
  // Conserve la largeur/hauteur en inline pour ne pas que la perte de
  // .pinned-popup (resize:both, min-width/height) fasse rétrécir le popup.
  if (el._lastPinnedSize) {
    el.style.width = el._lastPinnedSize.width + "px";
    el.style.height = el._lastPinnedSize.height + "px";
  }
  // v2026.5.45 — auto-fermeture réactivée : le popup se ferme quand la
  // souris quitte la zone (popup + cartes liées), ainsi que sur clic ailleurs
  // / Échap. Pour ne pas interférer avec le drag&drop des cartes, le hit-test
  // est ignoré tant que la classe documentElement.reschedule-dragging est posée.
  _attachSoftUnpinAutoHide(el);

  // 7. Régénérer le tooltip hover si on est en train de survoler la même iv
  //    (pour synchroniser l'icône /dans le tooltip live).
  //    Aussi, reset iv._reloading qui pourrait rester bloqué à true.
  const tip = tooltipEl();
  if (tip && tip.classList.contains("visible") && state.currentTooltipIv) {
    try {
      state.currentTooltipIv._reloading = false;
      tip.innerHTML = buildTooltipHTML(state.currentTooltipIv);
    } catch (err) {
      LOG.warn("softUnpin", "buildTooltipHTML failed:", err);
    }
  }

  // 8. v2026.5.34 : ne PAS programmer de suppression automatique au mouseleave.
  //    Le popup reste visible comme un tooltip normal. L'user le ferme en
  //    cliquant ailleurs ou en appuyant sur Échap. Il peut aussi re-cliquer
  //    sur pour le ré-épingler.
  //
  //    Pour que le popup disparaisse quand l'user clique ailleurs, on ajoute
  //    un handler de clic document qui supprime tous les .soft-unpinned si
  //    le clic est hors du popup. Ce handler ne s'arme QU'UNE FOIS (au premier
  //    désépinglage) et reste globalement.
  _ensureSoftUnpinnedCleanupHandler();

  LOG.info("softUnpin", "terminé — popup reste visible en mode tooltip normal");
}

// Taille préservée à travers un cycle dépingle → ré-épingle. Sans ça, le
// nouveau popup épinglé reprend la taille du tooltip live (par défaut),
// pas celle qu'avait le popup épinglé que l'utilisateur venait de
// désépingler — donc la taille "saute" à chaque cycle pin/unpin.
let _pinTooltipPreservedSize = null;
// v2026.5.46 — pareil pour la POSITION : au cycle désépingle → ré-épingle,
// on garde le popup EXACTEMENT où il était (sinon _findFreePopupPosition le
// déplace à chaque fois — surtout pour un popup issu de la recherche).
let _pinTooltipPreservedPos = null;

/**
 * Auto-fermeture du popup soft-unpinned quand la souris quitte sa zone
 * et n'est plus sur aucune carte de la même iv. Utilise un mousemove
 * document avec hit-test géométrique (plus fiable que mouseleave qui
 * peut rater si la souris quitte par un bord en diagonale).
 */
function _attachSoftUnpinAutoHide(el) {
  if (!el || el._autoHideAttached) return;
  el._autoHideAttached = true;
  const aid = el.dataset.actionId || "";
  let hideTimer = null;
  const cancel = () => {
    if (hideTimer) { clearTimeout(hideTimer); hideTimer = null; }
  };
  const onMove = (e) => {
    if (!document.body.contains(el) || !el.classList.contains("soft-unpinned")) {
      cancel();
      document.removeEventListener("mousemove", onMove);
      return;
    }
    // v2026.5.45 — pendant un drag de carte, on ne touche à rien : pas de
    // hit-test, pas de timer démarré ni annulé. Le popup reste tel quel le
    // temps du drag, on reprend l'évaluation à la mousemove suivante.
    if (document.documentElement.classList.contains("reschedule-dragging")) {
      return;
    }
    // Souris dans le popup ?
    const r = el.getBoundingClientRect();
    const inPopup = e.clientX >= r.left && e.clientX <= r.right
                 && e.clientY >= r.top && e.clientY <= r.bottom;
    // Souris dans une carte qui matche la même iv ?
    let inCard = false;
    if (!inPopup && aid) {
      const cards = document.querySelectorAll(
        `.intervention-v2[data-action-id="${aid}"], .iv-mini-card[data-action-id="${aid}"]`
      );
      for (const c of cards) {
        const cr = c.getBoundingClientRect();
        if (cr.width === 0 && cr.height === 0) continue;
        if (e.clientX >= cr.left && e.clientX <= cr.right
         && e.clientY >= cr.top && e.clientY <= cr.bottom) { inCard = true; break; }
      }
    }
    if (inPopup || inCard) {
      cancel();
    } else if (!hideTimer) {
      hideTimer = setTimeout(() => {
        if (!document.body.contains(el)) return;
        el.classList.add("unpinning");
        setTimeout(() => {
          try { el.remove(); } catch (e2) {}
          document.removeEventListener("mousemove", onMove);
        }, 180);
      }, 300);
    }
  };
  document.addEventListener("mousemove", onMove);
}

/**
 * v2026.5.34 : pose un handler global (une seule fois) qui ferme les popups
 * en état .soft-unpinned quand l'user clique ailleurs, ou appuie sur Échap.
 */
let _softUnpinnedCleanupHandlerInstalled = false;
function _ensureSoftUnpinnedCleanupHandler() {
  if (_softUnpinnedCleanupHandlerInstalled) return;
  _softUnpinnedCleanupHandlerInstalled = true;

  // Clic hors d'un popup soft-unpinned → supprimer
  document.addEventListener("mousedown", (e) => {
    const softPopups = document.querySelectorAll(".soft-unpinned");
    if (softPopups.length === 0) return;
    softPopups.forEach(el => {
      // Ne pas fermer si le clic est DANS le popup lui-même
      if (el.contains(e.target)) return;
      LOG.info("softUnpin cleanup", "clic hors du popup — suppression");
      el.classList.add("unpinning");
      setTimeout(() => { try { el.remove(); } catch (err) {} }, 180);
    });
  }, true);  // phase capture pour attraper avant d'autres handlers

  LOG.info("softUnpin", "handler cleanup global installé");
}

// ============================================================================
// v2026.5.17 : États d'un popup épinglé
//   - Normal (complet, flottant)
//   - Minimisé (compact, flottant, juste la ref + topbar)
//   - Réduit (docké dans la taskbar en bas de l'écran)
// ============================================================================

/**
 * Passe un popup épinglé en mode Minimisé : on ne montre plus que la ref,
 * dans un petit cadre flottant toujours drag-able.
 *
 * v2026.5.19 : au lieu de masquer tout le contenu via CSS et tenter de
 * réafficher la ref (fragile), on crée un élément dédié `.pinned-popup-minref`
 * qui contient juste la ref + la date. Cet élément est ajouté/retiré au besoin.
 */
function _minimizePinnedPopup(popup) {
  if (!popup) return;
  popup.classList.add("pinned-popup-minimized");

  // Adapter les boutons topbar : [▭] devient [] (agrandir)
  const minBtn = popup.querySelector(".pinned-popup-minimize");
  if (minBtn) {
    minBtn.innerHTML = "⬆";
    minBtn.title = "Agrandir";
    // On retire les anciens listeners en clonant l'élément
    const newBtn = minBtn.cloneNode(true);
    minBtn.replaceWith(newBtn);
    newBtn.addEventListener("click", (e) => {
      e.stopPropagation();
      _expandPinnedPopup(popup);
    });
  }

  // Créer un élément dédié pour afficher la ref en mode minimisé
  let minRef = popup.querySelector(".pinned-popup-minref");
  if (!minRef) {
    minRef = document.createElement("div");
    minRef.className = "pinned-popup-minref";
    const refText = popup.dataset.ref || "(sans ref)";
    minRef.textContent = refText;
    minRef.title = "Cliquer pour agrandir";
    minRef.addEventListener("click", (e) => {
      e.stopPropagation();
      _expandPinnedPopup(popup);
    });
    popup.appendChild(minRef);
  }
}

/**
 * Repasse un popup minimisé en mode Normal (complet).
 */
function _expandPinnedPopup(popup) {
  if (!popup) return;
  popup.classList.remove("pinned-popup-minimized");

  // Restaurer bouton Minimiser
  const minBtn = popup.querySelector(".pinned-popup-minimize");
  if (minBtn) {
    minBtn.innerHTML = "▭";
    minBtn.title = "Minimiser (reste flottant mais compact)";
    const newBtn = minBtn.cloneNode(true);
    minBtn.replaceWith(newBtn);
    newBtn.addEventListener("click", (e) => {
      e.stopPropagation();
      _minimizePinnedPopup(popup);
    });
  }

  // Retirer l'élément ref dédié (s'il existe)
  const minRef = popup.querySelector(".pinned-popup-minref");
  if (minRef) minRef.remove();
}

/**
 * Passe un popup épinglé en mode Réduit : il disparaît de son emplacement
 * flottant et vient s'ajouter dans une taskbar en bas de l'écran sous forme
 * de pastille cliquable.
 */
function _reducePinnedPopup(popup) {
  if (!popup) return;

  // Récupérer la référence pour le label de la pastille
  // v2026.5.18 : préférer le dataset.ref mémorisé à la création plutôt que
  // le textContent (qui peut contenir "—" si la ref n'était pas encore
  // disponible à l'épinglage)
  const refEl = popup.querySelector(".iv-ref-header");
  const label = popup.dataset.ref
              || (refEl ? (refEl.textContent || "").trim() : "")
              || "Popup";
  const colorKey = popup.dataset.colorKey || "autre";

  // S'assurer que la taskbar du bas existe
  let dock = document.getElementById("pinned-popups-dock");
  if (!dock) {
    dock = document.createElement("div");
    dock.id = "pinned-popups-dock";
    dock.className = "pinned-popups-dock";
    document.body.appendChild(dock);
  }

  // Créer la pastille dock
  // v2026.5.18 : le fond de la pastille prend la couleur de catégorie
  // v2026.5.25 : pastille à 3 lignes — lieu (fort), service (petit), date (petit)
  //              La référence est affichée dans le mini-menu au survol.
  const pill = document.createElement("button");
  pill.type = "button";
  pill.className = "pinned-popup-dock-pill color-" + colorKey;
  pill.title = "Cliquer pour agrandir";

  // Ligne 1 : lieu (ou ref si pas de lieu)
  const pillLieu = document.createElement("span");
  pillLieu.className = "pinned-popup-dock-pill-lieu";
  pillLieu.textContent = popup.dataset.lieu || label || "—";
  pill.appendChild(pillLieu);

  // Ligne 2 : service (2 dernières parties)
  const serviceTxt = popup.dataset.service || "";
  if (serviceTxt) {
    const pillService = document.createElement("span");
    pillService.className = "pinned-popup-dock-pill-service";
    pillService.textContent = serviceTxt;
    pill.appendChild(pillService);
  }

  // Ligne 3 : date "Mardi 22.04"
  const originDate = popup.dataset.originDate || "";
  if (originDate) {
    const pillDate = document.createElement("span");
    pillDate.className = "pinned-popup-dock-pill-date";
    pillDate.textContent = _formatDateForPill(originDate);
    pill.appendChild(pillDate);
  }

  // Mémoriser la position/taille du popup avant de le masquer
  const rect = popup.getBoundingClientRect();
  popup.dataset.prevLeft = popup.style.left || (rect.left + "px");
  popup.dataset.prevTop = popup.style.top || (rect.top + "px");
  popup.dataset.prevWidth = popup.style.width || "";

  // Cacher le popup (on le garde en DOM pour conserver son état et restaurer
  // instantanément)
  popup.classList.add("pinned-popup-reduced");

  // Associer pill ↔ popup
  pill._linkedPopup = popup;
  popup._linkedPill = pill;

  pill.addEventListener("click", (e) => {
    // v2026.5.23 : si on était en train de drag, ne pas déclencher le clic
    if (pill._justDragged) {
      pill._justDragged = false;
      return;
    }
    e.stopPropagation();
    // v2026.5.45 : fermer le mini-menu de survol s'il était visible.
    // Sans ça, cliquer directement sur la pill restaurait le popup mais le
    // menu (Agrandir / Fermer) restait orphelin à l'écran.
    _hidePillHoverMenu();
    _restorePinnedPopupFromDock(popup);
  });

  // v2026.5.20 : mini-menu au survol (Agrandir / Fermer)
  pill.addEventListener("mouseenter", () => {
    if (pill._dragging) return;  // pas de menu pendant le drag
    _showPillHoverMenu(pill, popup);
  });
  pill.addEventListener("mouseleave", (e) => {
    // Le menu peut être sous la souris — on ne ferme pas si on entre dans le menu
    _schedulePillMenuClose();
  });

  // v2026.5.23 : drag & drop — réordonne dans le dock, ou restaure hors du dock
  _attachPillDragHandler(pill, popup);

  dock.appendChild(pill);
  dock.classList.add("visible");

  // v2026.5.18 : s'assurer qu'il y a un bouton "Fermer tous" si 2+ popups
  _ensureDockCloseAllBtn();

  // v2026.5.20 : le dock qui apparaît peut chevaucher des popups flottants —
  // les reclamper pour qu'ils restent dans la safe area.
  _reclampAllFloatingPopups();
}

/**
 * v2026.5.20 : affiche un mini-menu au-dessus d'une pastille dock au survol.
 * Contient 2 actions : Agrandir, Fermer.
 */
let _pillMenuCloseTimer = null;
function _showPillHoverMenu(pill, popup) {
  // Annuler une fermeture en cours
  if (_pillMenuCloseTimer) {
    clearTimeout(_pillMenuCloseTimer);
    _pillMenuCloseTimer = null;
  }
  // S'il existe déjà un menu pour un autre pill, le fermer
  const existing = document.getElementById("pill-hover-menu");
  if (existing) {
    if (existing._linkedPill === pill) return; // déjà pour ce pill
    existing.remove();
  }

  const menu = document.createElement("div");
  menu.id = "pill-hover-menu";
  menu.className = "pill-hover-menu";
  menu._linkedPill = pill;
  menu._linkedPopup = popup;

  // v2026.5.25 : REF en haut du menu (info seulement, centrée)
  const refText = popup.dataset.ref || "";
  if (refText) {
    const refLabel = document.createElement("div");
    refLabel.className = "pill-hover-menu-ref";
    refLabel.textContent = refText;
    menu.appendChild(refLabel);
  }

  const restoreBtn = document.createElement("button");
  restoreBtn.type = "button";
  restoreBtn.className = "pill-hover-menu-btn";
  restoreBtn.innerHTML = '<span class="pill-menu-ico">⬆</span> Agrandir';
  restoreBtn.addEventListener("click", (e) => {
    e.stopPropagation();
    _hidePillHoverMenu();
    _restorePinnedPopupFromDock(popup);
  });
  menu.appendChild(restoreBtn);

  const closeBtn = document.createElement("button");
  closeBtn.type = "button";
  closeBtn.className = "pill-hover-menu-btn pill-hover-menu-close";
  closeBtn.innerHTML = '<span class="pill-menu-ico">✕</span> Fermer';
  closeBtn.addEventListener("click", (e) => {
    e.stopPropagation();
    _hidePillHoverMenu();
    // Retirer le popup de la liste et supprimer le DOM
    const idx = pinnedPopups.findIndex(p => p.el === popup);
    if (idx >= 0) pinnedPopups.splice(idx, 1);
    try { popup.remove(); } catch (err) {}
    try { pill.remove(); } catch (err) {}
    const dock = document.getElementById("pinned-popups-dock");
    if (dock && dock.querySelectorAll(".pinned-popup-dock-pill").length === 0) {
      dock.classList.remove("visible");
      const closeAllBtn = document.getElementById("pinned-popups-close-all");
      if (closeAllBtn) closeAllBtn.remove();
      _reclampAllFloatingPopups();
    } else {
      _ensureDockCloseAllBtn();
    }
  });
  menu.appendChild(closeBtn);

  // v2026.5.43 (Firefox-fix) : positionner le menu HORS écran d'abord pour
  // qu'il soit layouté sans flash, puis mesurer ses dimensions, puis poser
  // la position finale. Sans ça, Firefox lit parfois des dimensions à 0
  // (timing de l'animation `pill-hover-menu-appear` + transform initial),
  // ce qui projette le menu n'importe où sur l'écran.
  menu.style.left = "-9999px";
  menu.style.top = "-9999px";
  menu.style.visibility = "hidden";
  document.body.appendChild(menu);
  // Force le navigateur à calculer la mise en page maintenant (Firefox ne
  // le fait pas toujours sur getBoundingClientRect immédiat après append).
  void menu.offsetHeight;

  const r = pill.getBoundingClientRect();
  const menuR = menu.getBoundingClientRect();
  let left = r.left + (r.width / 2) - (menuR.width / 2);
  if (left < 4) left = 4;
  if (left + menuR.width > window.innerWidth - 4) left = window.innerWidth - menuR.width - 4;
  menu.style.left = left + "px";
  menu.style.top = (r.top - menuR.height - 8) + "px";
  menu.style.visibility = "";

  // Garder ouvert si la souris entre dans le menu
  menu.addEventListener("mouseenter", () => {
    if (_pillMenuCloseTimer) {
      clearTimeout(_pillMenuCloseTimer);
      _pillMenuCloseTimer = null;
    }
  });
  menu.addEventListener("mouseleave", () => {
    _schedulePillMenuClose();
  });
}

function _schedulePillMenuClose() {
  if (_pillMenuCloseTimer) clearTimeout(_pillMenuCloseTimer);
  _pillMenuCloseTimer = setTimeout(() => {
    _hidePillHoverMenu();
    _pillMenuCloseTimer = null;
  }, 250);
}

function _hidePillHoverMenu() {
  const existing = document.getElementById("pill-hover-menu");
  if (existing) existing.remove();
}

/**
 * v2026.5.20 : calcule la safe area pour les popups épinglés.
 * Retourne {top, bottom, left, right} en coords viewport.
 *  - top : hauteur de la topbar (les popups ne doivent pas passer dessous)
 *  - bottom : top du dock si visible, sinon hauteur viewport
 */
function _getPopupSafeArea() {
  let topLimit = 4;
  const topbar = document.querySelector("header.topbar");
  if (topbar) {
    const r = topbar.getBoundingClientRect();
    if (r.bottom > topLimit) topLimit = r.bottom + 4;
  }
  // v2026.5.46 — la ligne collante stats+recherche (#topline, vue classique)
  // fait AUSSI partie du « mur » : aucun popup (épinglé, tooltip, drag) ne doit
  // passer derrière. On prend le bas de l'élément collant le plus bas.
  const topline = document.getElementById("topline");
  if (topline && topline.offsetParent !== null) {
    const r = topline.getBoundingClientRect();
    if (r.bottom > topLimit) topLimit = r.bottom + 4;
  }
  let bottomLimit = window.innerHeight - 4;
  const dock = document.getElementById("pinned-popups-dock");
  if (dock && dock.classList.contains("visible")) {
    const r = dock.getBoundingClientRect();
    if (r.top < bottomLimit) bottomLimit = r.top - 4;
  }
  // v2026.5.40 : en vue horizontale, on bloque le bord gauche pour ne pas
  // laisser un popup glisser sous la sidebar fixe (200px, ou 170px en
  // breakpoint étroit < 1400px).
  let leftLimit = 4;
  if (document.documentElement.classList.contains("view-horizontal")) {
    const sidebar = document.querySelector(".horizontal-sidebar");
    if (sidebar) {
      const r = sidebar.getBoundingClientRect();
      if (r.right > leftLimit) leftLimit = r.right + 4;
    } else {
      leftLimit = (window.innerWidth <= 1400) ? 174 : 204;
    }
  }
  return { top: topLimit, bottom: bottomLimit, left: leftLimit, right: window.innerWidth - 4 };
}

/**
 * v2026.5.20 : contraint un popup flottant (en coords document via style.left/top)
 * dans la safe area. Appelé à l'épinglage, pendant le drag, et quand le dock
 * apparaît/disparaît.
 *
 * @author Quentin Rouiller
 */
function _clampPopupInSafeArea(popup) {
  if (!popup) return;
  if (popup.classList.contains("pinned-popup-reduced")) return; // pas clamp si docké
  const safe = _getPopupSafeArea();
  const rect = popup.getBoundingClientRect();
  const w = rect.width || popup.offsetWidth || 280;
  const h = rect.height || popup.offsetHeight || 200;

  // Les coords viewport actuelles
  const vLeft = rect.left;
  const vTop = rect.top;

  // Calcul des coords viewport cibles après clamp
  // v2026.5.28 : si le popup est plus large que la zone dispo (fenêtre rétrécie
  //              depuis le côté droit), on le garde à sa position actuelle —
  //              l'user redimensionnera ou bougera manuellement. On préfère
  //              "déborder" à droite plutôt que rétrécir le popup.
  let newVLeft = vLeft;
  let newVTop = vTop;
  const safeWidth = safe.right - safe.left;
  const safeHeight = safe.bottom - safe.top;
  if (w <= safeWidth) {
    // Popup rentre : on clamp normalement
    if (newVLeft < safe.left) newVLeft = safe.left;
    if (newVLeft + w > safe.right) newVLeft = safe.right - w;
    if (newVLeft < safe.left) newVLeft = safe.left;
  }
  // Sinon : popup plus large que la zone → on laisse où il est, user libre
  if (h <= safeHeight) {
    if (newVTop < safe.top) newVTop = safe.top;
    if (newVTop + h > safe.bottom) newVTop = safe.bottom - h;
    if (newVTop < safe.top) newVTop = safe.top;
  }

  if (newVLeft === vLeft && newVTop === vTop) return; // rien à faire

  // Différence = appliquer au style.left / style.top (qui sont en document coords)
  const dx = newVLeft - vLeft;
  const dy = newVTop - vTop;
  const curLeft = parseFloat(popup.style.left) || 0;
  const curTop = parseFloat(popup.style.top) || 0;
  popup.style.left = (curLeft + dx) + "px";
  popup.style.top = (curTop + dy) + "px";
}

/**
 * Réclampe tous les popups flottants (utile après apparition/disparition du dock).
 */
function _reclampAllFloatingPopups() {
  document.querySelectorAll(".pinned-popup:not(.pinned-popup-reduced)").forEach(p => {
    _clampPopupInSafeArea(p);
  });
}

/**
 * v2026.5.23 : drag & drop d'une pastille du dock.
 * - Drag dans le dock : réordonne les pastilles (drop = insérer à la nouvelle
 *   position). Les autres se décalent en live.
 * - Drop HORS du dock : restaure le popup en mode Normal à la position de la
 *   souris.
 * Semi-transparent pendant le drag.
 */
function _attachPillDragHandler(pill, popup) {
  const DRAG_THRESHOLD = 4;  // px avant de considérer un vrai drag
  let isDown = false;
  let isDragging = false;
  let startX = 0, startY = 0;
  let ghostEl = null;
  let pillOriginalNext = null;  // voisin d'origine pour restaurer l'ordre

  const onMouseMove = (e) => {
    if (!isDown) return;
    const dx = e.clientX - startX;
    const dy = e.clientY - startY;
    if (!isDragging) {
      if (Math.abs(dx) < DRAG_THRESHOLD && Math.abs(dy) < DRAG_THRESHOLD) return;
      // Début du drag
      isDragging = true;
      pill._dragging = true;
      pill._justDragged = true;
      _hidePillHoverMenu();
      pill.classList.add("pill-dragging");

      // Créer un "ghost" flottant qui suit la souris
      const r = pill.getBoundingClientRect();
      ghostEl = pill.cloneNode(true);
      ghostEl.style.position = "fixed";
      ghostEl.style.left = r.left + "px";
      ghostEl.style.top = r.top + "px";
      ghostEl.style.width = r.width + "px";
      ghostEl.style.height = r.height + "px";
      ghostEl.style.zIndex = "1100";
      ghostEl.style.opacity = "0.85";
      ghostEl.style.pointerEvents = "none";
      ghostEl.classList.add("pill-dragging-ghost");
      document.body.appendChild(ghostEl);

      // Mémoriser le voisin d'origine pour restaurer si drop hors dock
      pillOriginalNext = pill.nextSibling;
    }
    // Déplacer le ghost avec la souris
    if (ghostEl) {
      ghostEl.style.left = (e.clientX - ghostEl.offsetWidth / 2) + "px";
      ghostEl.style.top  = (e.clientY - ghostEl.offsetHeight / 2) + "px";
    }

    // Détecter si on est au-dessus du dock
    const dock = document.getElementById("pinned-popups-dock");
    if (!dock) return;
    const dockRect = dock.getBoundingClientRect();
    const insideDock = (
      e.clientX >= dockRect.left && e.clientX <= dockRect.right &&
      e.clientY >= dockRect.top && e.clientY <= dockRect.bottom
    );

    if (insideDock) {
      // Trouver où insérer parmi les autres pastilles
      const pills = Array.from(dock.querySelectorAll(".pinned-popup-dock-pill"))
                          .filter(p => p !== pill);
      let inserted = false;
      for (const other of pills) {
        const or = other.getBoundingClientRect();
        const midX = or.left + or.width / 2;
        if (e.clientX < midX) {
          dock.insertBefore(pill, other);
          inserted = true;
          break;
        }
      }
      if (!inserted) {
        // Insérer juste avant le bouton "Fermer tous" s'il existe, sinon en fin
        const closeAllBtn = document.getElementById("pinned-popups-close-all");
        if (closeAllBtn) {
          dock.insertBefore(pill, closeAllBtn);
        } else {
          dock.appendChild(pill);
        }
      }
    }
  };

  const onMouseUp = (e) => {
    if (!isDown) return;
    isDown = false;
    document.removeEventListener("mousemove", onMouseMove);
    document.removeEventListener("mouseup", onMouseUp);

    if (!isDragging) return;  // juste un clic simple, pas un drag

    isDragging = false;
    setTimeout(() => { pill._dragging = false; }, 10);
    pill.classList.remove("pill-dragging");
    if (ghostEl) {
      try { ghostEl.remove(); } catch (err) {}
      ghostEl = null;
    }

    // Vérifier si drop dans le dock ou hors
    const dock = document.getElementById("pinned-popups-dock");
    let insideDock = false;
    if (dock) {
      const dockRect = dock.getBoundingClientRect();
      insideDock = (
        e.clientX >= dockRect.left && e.clientX <= dockRect.right &&
        e.clientY >= dockRect.top && e.clientY <= dockRect.bottom
      );
    }

    if (insideDock) {
      // Drop dans le dock = réordonnage déjà fait pendant onMouseMove. OK.
      return;
    }

    // Drop HORS du dock : restaurer le popup en mode Normal à la position souris
    // Le popup est actuellement en état "réduit" — on le réaffiche.
    popup.classList.remove("pinned-popup-reduced");
    popup.classList.remove("pinned-popup-minimized");
    // Positionner à la souris (coords document)
    const popupW = popup.offsetWidth || 320;
    const popupH = popup.offsetHeight || 200;
    const docX = _viewportToDocumentX(e.clientX - popupW / 2);
    const docY = _viewportToDocumentY(e.clientY - 20);
    popup.style.left = docX + "px";
    popup.style.top = docY + "px";
    // Clamper dans la safe area
    _clampPopupInSafeArea(popup);

    // Retirer la pastille et nettoyer le dock si vide
    try { pill.remove(); } catch (err) {}
    popup._linkedPill = null;
    if (dock && dock.querySelectorAll(".pinned-popup-dock-pill").length === 0) {
      dock.classList.remove("visible");
      const closeAllBtn = document.getElementById("pinned-popups-close-all");
      if (closeAllBtn) closeAllBtn.remove();
    } else {
      _ensureDockCloseAllBtn();
    }
    // Restaurer le bouton Minimiser (si c'était en mode minimisé avant réduction)
    const minBtn = popup.querySelector(".pinned-popup-minimize");
    if (minBtn) {
      minBtn.innerHTML = "▭";
      minBtn.title = "Minimiser (reste flottant mais compact)";
      const newBtn = minBtn.cloneNode(true);
      minBtn.replaceWith(newBtn);
      newBtn.addEventListener("click", (ev) => {
        ev.stopPropagation();
        _minimizePinnedPopup(popup);
      });
    }

    // v2026.5.23 : mettre à jour le rect dans pinnedPopups pour que l'anti-
    // chevauchement tienne compte de la nouvelle position
    const entry = pinnedPopups.find(p => p.el === popup);
    if (entry) {
      const l = parseFloat(popup.style.left) || 0;
      const t = parseFloat(popup.style.top) || 0;
      const w = popup.offsetWidth;
      const h = popup.offsetHeight;
      entry.rect = { left: l, top: t, right: l + w, bottom: t + h };
    }
  };

  pill.addEventListener("mousedown", (e) => {
    if (e.button !== 0) return;
    isDown = true;
    isDragging = false;
    startX = e.clientX;
    startY = e.clientY;
    document.addEventListener("mousemove", onMouseMove);
    document.addEventListener("mouseup", onMouseUp);
  });
}

/**
 * v2026.5.19 : réduit TOUS les popups épinglés actuellement ouverts (en mode
 * normal ou minimisé) dans la taskbar du bas. Appelé au changement de date.
 */
function _reduceAllPinnedPopups() {
  const popups = document.querySelectorAll(".pinned-popup:not(.pinned-popup-reduced)");
  popups.forEach(popup => {
    try { _reducePinnedPopup(popup); } catch (e) {}
  });
}


/**
 * v2026.5.25 : formatte une date ISO en "Mardi 22.04" pour la pastille dock.
 */
function _formatDateForPill(iso) {
  if (!iso) return "";
  const m = String(iso).match(/^(\d{4})-(\d{2})-(\d{2})$/);
  if (!m) return iso;
  try {
    const d = new Date(parseInt(m[1]), parseInt(m[2]) - 1, parseInt(m[3]));
    const dayName = (typeof DAY_NAMES_FULL !== "undefined" && DAY_NAMES_FULL[d.getDay()])
                      ? DAY_NAMES_FULL[d.getDay()]
                      : "";
    return (dayName ? dayName + " " : "") + m[3] + "." + m[2];
  } catch (e) {
    return m[3] + "." + m[2];
  }
}

/**
 * v2026.5.18 : ajoute (ou met à jour) le bouton "Fermer tous" dans le dock
 * quand au moins 2 popups épinglés existent (réduits OU affichés).
 * Le bouton est placé à droite du dock.
 */
function _ensureDockCloseAllBtn() {
  const dock = document.getElementById("pinned-popups-dock");
  if (!dock) return;
  // v2026.5.40 : bouton "Fermer tous" seulement si PLUS DE DEUX (>= 3)
  // popups réduits dans le dock. Avec 1 ou 2, le user les ferme à la main.
  const reducedCount = document.querySelectorAll(".pinned-popup-dock-pill").length;
  let closeAllBtn = document.getElementById("pinned-popups-close-all");
  if (reducedCount >= 3) {
    if (!closeAllBtn) {
      closeAllBtn = document.createElement("button");
      closeAllBtn.type = "button";
      closeAllBtn.id = "pinned-popups-close-all";
      closeAllBtn.className = "pinned-popups-close-all";
      closeAllBtn.textContent = "✕ Fermer tous";
      closeAllBtn.title = "Fermer tous les popups épinglés";
      closeAllBtn.addEventListener("click", (e) => {
        e.stopPropagation();
        closeAllPinnedPopups();
      });
      dock.appendChild(closeAllBtn);
    } else {
      // Remettre à la fin (après les pastilles éventuellement ajoutées)
      dock.appendChild(closeAllBtn);
    }
    dock.classList.add("visible");
  } else if (closeAllBtn) {
    closeAllBtn.remove();
  }
}

/**
 * Ramène un popup réduit en mode Normal : retire la pastille du dock et
 * réaffiche le popup flottant à sa position d'avant réduction.
 */
function _restorePinnedPopupFromDock(popup) {
  if (!popup) return;
  popup.classList.remove("pinned-popup-reduced");
  // Si le popup était minimisé avant d'être réduit, on l'agrandit direct
  // (la demande était : "Si la reduit et rappeller s'affiche en grand direct")
  popup.classList.remove("pinned-popup-minimized");
  const minBtn = popup.querySelector(".pinned-popup-minimize");
  if (minBtn) {
    minBtn.innerHTML = "▭";
    minBtn.title = "Minimiser (reste flottant mais compact)";
    const newBtn = minBtn.cloneNode(true);
    minBtn.replaceWith(newBtn);
    newBtn.addEventListener("click", (e) => {
      e.stopPropagation();
      _minimizePinnedPopup(popup);
    });
  }

  // Supprimer la pastille associée
  if (popup._linkedPill) {
    popup._linkedPill.remove();
    popup._linkedPill = null;
  }

  // Si le dock est vide (sauf le bouton "Fermer tous"), le masquer
  const dock = document.getElementById("pinned-popups-dock");
  if (dock) {
    const remainingPills = dock.querySelectorAll(".pinned-popup-dock-pill").length;
    if (remainingPills === 0) {
      dock.classList.remove("visible");
      const closeAllBtn = document.getElementById("pinned-popups-close-all");
      if (closeAllBtn) closeAllBtn.remove();
    } else {
      _ensureDockCloseAllBtn();
    }
  }
}

/** Ferme toutes les popups épinglées (appelé par Échap ou changement de date). */
/**
 * v5.0.1 : helper pour déclencher la suppression d'une absence ou réservation.
 * Affiche la modal de confirmation, puis appelle le background.
 */
function _triggerDeleteItem(actionId, kind, triggerBtn) {
  if (!actionId) return;
  const label = kind === "reservation" ? "cette réservation" : "cette absence";
  showAlertModal({
    title: "Confirmer la suppression",
    message: `Voulez-vous vraiment supprimer ${label} ? Cette action est irréversible.`,
    buttons: [
      { label: "Annuler", variant: "secondary", action: () => {} },
      {
        label: "Supprimer",
        variant: "danger",
        action: async () => {
          if (triggerBtn) {
            triggerBtn.disabled = true;
            triggerBtn.textContent = "Suppression…";
          }
          try {
            const resp = await sendMessage({
              type: "deletePlanningItem",
              actionId: actionId,
              kind: kind
            });
            if (!resp || !resp.ok) {
              throw new Error(resp && resp.error ? resp.error : "erreur inconnue");
            }
            showToast("Supprimé", "L'élément a été retiré du planning.");
            unpinTooltip();
            closeAllPinnedPopups();
            // v2026.5.46 — tombstone AVANT le refresh : empêche la sync
            // dossier de réinjecter la résa/absence supprimée (réapparition
            // fantôme de quelques secondes au retour sur la date).
            await _markDeletedInCache(actionId, state.currentDate);
            if (state.session) {
              await loadForDate(state.currentDate, { forceRefetch: true });
            }
          } catch (err) {
            showAlertModal({
              title: "Erreur lors de la suppression",
              message: "Impossible de supprimer : " + (err.message || err),
              buttons: [{ label: "OK", variant: "secondary", action: () => {} }]
            });
            if (triggerBtn) {
              triggerBtn.disabled = false;
              triggerBtn.textContent = "🗑 Supprimer l'absence";
            }
          }
        }
      }
    ]
  });
}

// v2026.5.46 — pose un tombstone (deletedAt + verdict gone) sur une iv du
// store d'un jour, via storeMarkDeleted. Réutilisé par la suppression EV
// (résa/absence) et par _triggerHideIv. Le tombstone empêche la sync dossier
// de réinjecter l'élément supprimé (modèle vie/mort) et est filtré au rendu.
// Renvoie true si l'iv a été trouvée et marquée.
async function _markDeletedInCache(actionId, date) {
  return storeMarkDeleted(date, actionId);
}

// suppression PURE CLIENT d'une intervention Fait/Clos : tombstone deletedAt
// dans le store → l'iv disparaît du planning et la suppression se propage au
// dossier partagé. AUCUN effet sur EasyVista.
function _triggerHideIv(actionId, triggerBtn) {
  if (!actionId) return;
  showAlertModal({
    title: "Retirer cette intervention ?",
    message: "Voulez-vous vraiment retirer cette intervention du planning ? Sans effet sur EasyVista.",
    buttons: [
      { label: "Annuler", variant: "secondary", action: () => {} },
      {
        label: "Retirer",
        variant: "danger",
        action: async () => {
          try {
            const found = await storeMarkDeleted(state.currentDate, actionId);
            if (found) storeRenderCurrent("store");
            unpinTooltip();
            closeAllPinnedPopups();
            showToast("Intervention retirée", found ? "Retirée du planning" : "introuvable");
          } catch (err) {
            LOG.warn("hide-iv", "suppression locale échouée", { actionId, err: err && err.message });
            showToast("Erreur", "Impossible de retirer (voir console F12)");
          }
        }
      }
    ]
  });
}

function closeAllPinnedPopups() {
  for (const p of pinnedPopups.slice()) {
    p.el.remove();
  }
  pinnedPopups.length = 0;
  // Fermer aussi les popups en état soft-unpinned qui trainent encore
  document.querySelectorAll(".pinned-popup.soft-unpinned").forEach(el => el.remove());
  // v2026.5.18 : supprimer aussi les éléments du dock
  document.querySelectorAll(".pinned-popup").forEach(el => el.remove());
  document.querySelectorAll(".pinned-popup-dock-pill").forEach(el => el.remove());
  const closeAllBtn = document.getElementById("pinned-popups-close-all");
  if (closeAllBtn) closeAllBtn.remove();
  const dock = document.getElementById("pinned-popups-dock");
  if (dock) dock.classList.remove("visible");
}

/**
 * v4.3.3 : permet de déplacer une popup épinglée à la souris via sa barre
 * de drag. Met à jour les coords document (position absolute) et le rect
 * mémorisé dans pinnedPopups pour que les nouvelles popups évitent bien
 * la nouvelle position.
 */
function _attachPopupDragHandler(popup, dragbar) {
  let dragging = false;
  let startMouseX = 0, startMouseY = 0;
  let startLeft = 0, startTop = 0;

  const onMouseMove = (e) => {
    if (!dragging) return;
    const dx = e.clientX - startMouseX;
    const dy = e.clientY - startMouseY;
    let newLeft = startLeft + dx;
    let newTop = startTop + dy;

    // v2026.5.20 : clamper dans la safe area (topbar en haut, dock en bas,
    // bordures viewport gauche/droite). On calcule en coords viewport puis
    // on applique en coords document.
    popup.style.left = newLeft + "px";
    popup.style.top = newTop + "px";
    _clampPopupInSafeArea(popup);
  };

  const onMouseUp = () => {
    if (!dragging) return;
    dragging = false;
    popup.classList.remove("dragging");
    document.removeEventListener("mousemove", onMouseMove);
    document.removeEventListener("mouseup", onMouseUp);
    // v2026.5.19 : retirer la classe body et le flag global après un petit
    // délai pour laisser le temps au mouseleave de la carte de se propager
    // sans déclencher de tooltip parasite.
    document.body.classList.remove("popup-dragging");
    setTimeout(() => { state._popupDragging = false; }, 50);

    // Mettre à jour le rect mémorisé pour la détection de chevauchement
    const entry = pinnedPopups.find(p => p.el === popup);
    if (entry) {
      const l = parseFloat(popup.style.left) || 0;
      const t = parseFloat(popup.style.top) || 0;
      const w = popup.offsetWidth;
      const h = popup.offsetHeight;
      entry.rect = { left: l, top: t, right: l + w, bottom: t + h };
    }
  };

  dragbar.addEventListener("mousedown", (e) => {
    // Seulement bouton gauche
    if (e.button !== 0) return;
    e.preventDefault();
    dragging = true;
    startMouseX = e.clientX;
    startMouseY = e.clientY;
    startLeft = parseFloat(popup.style.left) || 0;
    startTop  = parseFloat(popup.style.top)  || 0;
    popup.classList.add("dragging");
    // v2026.5.19 : flag global pour que showTooltip ignore les mouseenter
    // pendant le drag. Ajout d'une classe sur <body> qui désactive les
    // pointer-events sur les cartes.
    state._popupDragging = true;
    document.body.classList.add("popup-dragging");
    document.addEventListener("mousemove", onMouseMove);
    document.addEventListener("mouseup", onMouseUp);
  });
}

// v4.1.14/19 : recharger UNIQUEMENT cette intervention. Fetch DIRECT sans
// passer par isRefreshAborted (pour ne pas être bloqué par un abort global
// ou un refresh précédent). Animation sur le bouton ↻ de la bulle.
async function reloadSingleIntervention(iv, btnEl) {
  if (!iv) return;
  // v2026.5.46 — réservation : pas de fiche EV à actualiser, mais on ne
  // reste plus SILENCIEUX (la roue semblait « ne pas réagir »). On donne un
  // retour visuel explicite.
  if (iv.type === "AL-Reservation") {
    showToast("Réservation", "Aucune fiche à actualiser");
    return;
  }
  // Empêcher double-clic en cours
  if (iv._reloading) return;
  iv._reloading = true;

  // v4.1.19 : NE PAS reset les champs AVANT le fetch (sinon si le fetch
  // échoue ou est interrompu, on perd les données précédentes). On les
  // mettra à jour uniquement si le fetch réussit.
  const previousState = {
    xhr2Fetched: iv.xhr2Fetched,
    ficheFetched: iv.ficheFetched,
    ficheActionText: iv.ficheActionText,
    ficheFetchError: iv.ficheFetchError,
    bulleDescription: iv.bulleDescription,
    infobulle: iv.infobulle,
    status: iv.status,
    label: iv.label,
    ficheChecksum: iv.ficheChecksum,
    ficheTarget: iv.ficheTarget,
    formSenderGuid: iv.formSenderGuid
  };

  // Marquer le bouton ↻ comme en cours (visuel immédiat)
  if (btnEl) btnEl.classList.add("spinning");
  // v4.1.19 : toast de feedback en bas à droite
  showToast("Rafraîchissement", iv.ref || iv.actionId);

  try {
    // ─── xhr2 (rapide) ─────────────────────────────────────────────────
    try {
      const xhr2Resp = await sendMessage({ type: "fetchXhr2", actionId: iv.actionId });
      if (xhr2Resp && xhr2Resp.ok) {
        const parsed = parseXhr2Body(xhr2Resp.body);
        if (parsed) {
          if (parsed.description) {
            iv.bulleDescription = parsed.description;
            const infob = parseActionText(parsed.description);
            if (infob) iv.infobulle = infob;
          }
          if (parsed.label) iv.label = parsed.label;
          iv.xhr2Fetched = true;
        }
      }
    } catch (err) {
      LOG.warn("reloadSingle/xhr2", "iv", iv.actionId, err);
    }

    // ─── fiche HTML ────────────────────────────────────────────────────
    const ficheResp = await sendMessage({ type: "fetchFiche", formLink: iv.formLink });
    if (ficheResp.ok) {
      const fiche = parseFicheHtml(ficheResp.html);
      iv.status = fiche.status;
      if (fiche.rfc && !iv.ref) iv.ref = fiche.rfc;
      if (fiche.formSenderGuid) iv.formSenderGuid = fiche.formSenderGuid;

      // ─── timeline API : texte complet ──────────────────────────────
      if (fiche.formId && fiche.formChecksum && fiche.formSenderGuid && iv.actionId) {
        try {
          const tlResp = await sendMessage({
            type: "fetchTimelineApi",
            guid: fiche.formSenderGuid,
            formId: fiche.formId,
            formChecksum: fiche.formChecksum
          });
          if (tlResp && tlResp.ok) {
            const fullText = parseTimelineJsonForAction(tlResp.body, iv.actionId);
            if (fullText) iv.ficheActionText = fullText;
          }
        } catch (err) {
          LOG.warn("reloadSingle/timeline", "iv", iv.actionId, err);
        }
      }

      // ─── Extraire checksum pour ouverture ───────────────────────────
      if (iv.requestId && !iv.ficheChecksum) {
        const rx1 = new RegExp(`target=${iv.requestId}&(?:amp;)?checksum=([a-f0-9]{40})`);
        const m1 = ficheResp.html.match(rx1);
        if (m1) {
          iv.ficheTarget = iv.requestId;
          iv.ficheChecksum = m1[1];
        }
      }
      iv.ficheFetched = true;
      iv.ficheFetchError = null;
    } else {
      iv.ficheFetchError = ficheResp.error || "fetch_failed";
      if (ficheResp.error === "session_expired") {
        state.session = null;
        showSessionExpiredBanner();
      }
    }

    // Mettre à jour la carte (statut clos → ✓ vert, catégorie, etc.)
    updateInterventionRow(iv);

    // Si la bulle est toujours ouverte sur cette iv, régénérer son HTML
    const tip = tooltipEl();
    if (tip.classList.contains("visible") && state.currentTooltipIv === iv) {
      tip.innerHTML = buildTooltipHTML(iv);
    }

    // Sauvegarder le store — l'iv affichée EST l'enregistrement du store
    // (projection par référence), il suffit de persister le jour.
    try {
      iv.updatedAt = Date.now();
      if (state.currentDay) {
        await storeSave(state.currentDate, state.currentDay);
      }
    } catch (err) {
      LOG.warn("reloadSingle", "écriture store en échec", err);
    }

    // v4.1.19 : toast de succès
    showToast("Mis à jour", iv.ref || iv.actionId);
  } catch (err) {
    LOG.warn("reloadSingle", "erreur iv", iv.actionId, err);
    // Restaurer l'état précédent en cas d'erreur globale
    Object.assign(iv, previousState);
  } finally {
    iv._reloading = false;
    if (btnEl) btnEl.classList.remove("spinning");
  }
}
function unpinTooltip() {
  bulleState.pinned = false;
  const el = tooltipEl();
  el.classList.remove("pinned");
  // v4.1.13 : test immédiat si la souris est toujours dans la bulle ou sur
  // la ligne. Si ni l'un ni l'autre, on ferme tout de suite (sans timer).
  if (!bulleState.hoveredInBulle && !bulleState.hoveredInRow) {
    el.classList.remove("visible");
    el.classList.add("hidden");
    if (el.dataset) delete el.dataset.mode;
    state.currentTooltipIv = null;
    currentTooltipPos = null;
    tooltipPositionMode = null;
    if (bulleState.hideTimer) {
      clearTimeout(bulleState.hideTimer);
      bulleState.hideTimer = null;
    }
  }
  // Sinon : la bulle reste visible, et c'est le mouseleave qui la fermera
  // normalement quand la souris sortira.
}

// v4.1.10 : interactions bulle (double-Ctrl pour pin/unpin, hover dans la
// bulle pour persistance, clic hors pour unpin).
function bindTooltipInteractions() {
  const el = tooltipEl();
  if (!el) return;

  // v2026.5.27 : quand la souris entre dans un popup épinglé, fermer tout
  // popup non-épinglé (tooltip live ou soft-unpinned) pour garder l'écran clair.
  document.addEventListener("mouseover", (e) => {
    const target = e.target;
    if (!target || !target.closest) return;
    const pinned = target.closest(".pinned-popup");
    if (!pinned) return;
    // On survole un popup épinglé → fermer tooltip live s'il n'est pas pinned
    if (!bulleState.pinned) {
      const tip = tooltipEl();
      if (tip && tip.classList.contains("visible")) {
        tip.classList.remove("visible");
        tip.classList.add("hidden");
        if (tip.dataset) delete tip.dataset.mode;
        state.currentTooltipIv = null;
        currentTooltipPos = null;
        tooltipPositionMode = null;
      }
    }
    // Fermer les soft-unpinned qui traînent
    document.querySelectorAll(".soft-unpinned").forEach(el => {
      try { el.remove(); } catch (err) {}
    });
  });

  // v4.1.17 : ré-applique la position au scroll de la page (safety net
  // contre un ancêtre qui casserait position:fixed silencieusement).
  window.addEventListener("scroll", reapplyTooltipPosition, { passive: true });
  window.addEventListener("resize", () => {
    // Au resize, on laisse fermer la bulle (position probablement invalidée)
    if (bulleState.pinned) return;
    hideTooltip({ force: true });
  });

  // v4.1.17 : bloquer le scroll de la page quand la souris est DANS la
  // bulle. Le scroll interne de la bulle (overflow-y auto) reste OK.
  // On utilise "wheel" non-passif pour pouvoir preventDefault.
  el.addEventListener("wheel", (e) => {
    // Si la bulle a un scroll interne et n'est pas à la limite, laisser
    // le scroll naturel se faire. Sinon, bloquer le scroll global.
    const canScrollDown = el.scrollTop + el.clientHeight < el.scrollHeight;
    const canScrollUp = el.scrollTop > 0;
    if ((e.deltaY > 0 && !canScrollDown) || (e.deltaY < 0 && !canScrollUp)) {
      e.preventDefault();
    }
    // Ne pas laisser le scroll se propager au body
    e.stopPropagation();
  }, { passive: false });

  // v2026.5.40 : Hover sur la bulle empêche la fermeture (pour la
  // sélection de texte). Quand on quitte la bulle, hideTooltip démarre
  // un nouveau timer 500ms — si la souris revient sur la row avant 500ms,
  // showTooltip annule le timer (via _cancelHideTooltip).
  el.addEventListener("mouseenter", () => {
    _cancelHideTooltip();
  });
  el.addEventListener("mouseleave", () => {
    if (!bulleState.pinned) hideTooltip();
  });

  // v2026.5.40 : raccourci double-Ctrl pour épingler/désépingler RETIRÉ
  // (peu utilisé, source de confusion). Pour épingler : clic sur la card /
  // mini-card ou bouton du tooltip. Pour désépingler : bouton du popup.

  // v4.1.13 : clic sur le bouton ou ↻ (bouton d'action de la bulle)
  el.addEventListener("click", (e) => {
    const btn = e.target.closest('[data-action]');
    if (!btn) return;
    e.stopPropagation();
    e.preventDefault();
    const action = btn.dataset.action;
    if (action === "pin") {
      // v2026.5.22 : clic sur /dans le tooltip hover = TOUJOURS réépingler
      // à la position actuelle. Si un popup existe déjà pour cette iv+date,
      // il est supprimé avant d'en créer un nouveau à côté de la carte survolée.
      // (La suppression de l'ancien est faite dans pinTooltip() qui gère
      // l'unicité actionId+date — v2026.5.21.)
      // Pour désépingler : bouton dans la topbar du popup, double-Ctrl, ou Échap.
      if (state.currentTooltipIv) {
        pinTooltip();
      }
    } else if (action === "reload") {
      // v4.1.14 : recharger uniquement l'intervention actuellement affichée
      if (state.currentTooltipIv) {
        reloadSingleIntervention(state.currentTooltipIv, btn);
      }
    } else if (action === "copy-ref") {
      // v4.1.15 : copier la référence depuis la bulle
      const ref = btn.dataset.ref;
      if (ref) {
        navigator.clipboard.writeText(ref).then(() => {
          btn.classList.add("copied");
          const original = btn.textContent;
          btn.textContent = "✓";
          setTimeout(() => {
            btn.classList.remove("copied");
            btn.textContent = original;
          }, 1200);
        }).catch(e => LOG.warn("clipboard", "copie ref échouée (permission ?)", { ref, err: e && e.message }));
      }
    } else if (action === "delete-item") {
      // v5.0.0 : supprimer absence/réservation (depuis tooltip)
      const actionId = btn.dataset.actionId;
      const kind = btn.dataset.kind || "absence";
      _triggerDeleteItem(actionId, kind, btn);
    } else if (action === "edit-reservation") {
      // v2026.5.46 — modifier les infos (n°/catégorie/adresse) d'une réservation.
      e.preventDefault(); e.stopPropagation();
      const iv = state.currentTooltipIv;
      if (iv) showReservationEditModal(iv);
    } else if (action === "open-res-iv") {
      // v2026.5.46 — ouvrir la fiche de l'intervention liée à la réservation.
      e.preventDefault(); e.stopPropagation();
      _openInterventionByRef(btn.dataset.ref);
    } else if (action === "copy-res-num") {
      // v2026.5.46 — copier le n° d'intervention de la réservation.
      e.preventDefault(); e.stopPropagation();
      copyRef(btn.dataset.ref, btn);
    } else if (action === "hide-iv") {
      // v2026.1.6 — QRO : retirer une intervention Fait/Clos (pur client).
      _triggerHideIv(btn.dataset.actionId, btn);
    } else if (action === "open-fiche") {
      // clic sur la référence → utilise openInterventionInNewTab qui
      // génère un checksum FRAIS via basicAutoComplete + redirectHeader.
      e.preventDefault();
      e.stopPropagation();
      const iv = state.currentTooltipIv;
      if (iv) {
        const background = !!(e.ctrlKey || e.metaKey || e.button === 1);
        openInterventionInNewTab(iv, { background });
      }
    }
  });

  // Clic hors bulle : unpin si épinglé.
  // Attention : ne pas déclencher sur clic DANS la bulle (elle contient du
  // texte sélectionnable), ni sur clic sur une interventoin (qui ouvre la
  // fiche — le user n'attend pas que la bulle reste épinglée dans ce cas
  // mais le comportement "ouvrir la fiche" reste prioritaire).
  document.addEventListener("mousedown", (e) => {
    if (!bulleState.pinned) return;
    // Clic dans la bulle → on laisse (sélection de texte)
    if (el.contains(e.target)) return;
    // Dans tous les autres cas (y compris clic sur une autre interventoin),
    // on désépingle. Si c'était un clic sur intervention, le handler
    // d'ouverture de la fiche s'exécutera ensuite normalement.
    unpinTooltip();
  });
}

/**
 * Construit le HTML du tooltip détaillé pour une intervention/réservation.
 *
 * @author Quentin Rouiller
 */
function buildTooltipHTML(iv) {
  if (!iv) return '<dl><dt>Info</dt><dd>—</dd></dl>';
  const i = iv.infobulle || {};
  const rows = [];

  // Cas spécial : réservation (créneau bloqué par un coordinateur)
  if (iv.type === "AL-Reservation") {
    const _hasResMeta = !!(iv.resNumero || iv.resVille || iv.resRue || iv.resCategorie);
    rows.push(`<dt>Type</dt><dd><span class="status-pill other" style="background:var(--c-reservation);color:#fff">Réservation</span></dd>`);
    if (iv.startTime && iv.endTime) {
      rows.push(row("Horaire", ivIsMultiDay(iv) ? `du ${iv.startDate} ${iv.startTime} au ${iv.endDate} ${iv.endTime}` : `${iv.startTime}–${iv.endTime}`));
    }
    // v2026.5.46 — « Sujet » affiché UNIQUEMENT pour les réservations créées
    // directement dans EasyVista (sans meta de l'extension). Pour celles faites
    // via l'extension (n°/adresse/type), on montre ces infos à la place.
    if (!_hasResMeta && iv.reservationLabel) rows.push(row("Sujet", iv.reservationLabel));
    if (iv.reservationCreator) rows.push(row("Par", iv.reservationCreator));
    // v2026.1.6 — QRO : infos client de la réservation (n°, catégorie, adresse)
    if (iv.resNumero) rows.push(row("N° intervention", iv.resNumero));
    if (iv.resCategorie) rows.push(row("Catégorie", iv.resCategorie));
    if (iv.resVille) rows.push(row("Ville", iv.resVille));
    if (iv.resRue) rows.push(row("Rue / route", iv.resRue));
    // v2026.5.46 — si un n° d'intervention est renseigné : ouvrir la fiche
    // de cette intervention + copier le n°.
    if (iv.resNumero) {
      rows.push(`<dt></dt><dd><button type="button" class="tooltip-edit-btn" data-action="open-res-iv" data-ref="${escapeHtml(iv.resNumero)}">↗ Ouvrir l'intervention</button> <button type="button" class="tooltip-edit-btn" data-action="copy-res-num" data-ref="${escapeHtml(iv.resNumero)}">📋 Copier le n°</button></dd>`);
    }
    // v2026.5.46 — bouton Modifier (édite n°/catégorie/adresse) + Supprimer.
    rows.push(`<dt></dt><dd><button type="button" class="tooltip-edit-btn" data-action="edit-reservation" data-action-id="${escapeHtml(iv.actionId || "")}">✏️ Modifier</button></dd>`);
    rows.push(`<dt></dt><dd><button type="button" class="tooltip-delete-btn" data-action="delete-item" data-action-id="${escapeHtml(iv.actionId || "")}" data-kind="reservation">🗑 Supprimer cette réservation</button></dd>`);
    return `<dl>${rows.join("")}</dl>`;
  }

  // v5.0.0 : cas spécial absence (congé, maladie, formation, pompier, ...)
  if (iv.type === "AL-Absence") {
    const label = iv.label || "Absence";
    rows.push(`<dt>Type</dt><dd><span class="status-pill other">${escapeHtml(label)}</span></dd>`);
    if (iv.startTime && iv.endTime) {
      rows.push(row("Horaire", ivIsMultiDay(iv) ? `du ${iv.startDate} ${iv.startTime} au ${iv.endDate} ${iv.endTime}` : `${iv.startTime}–${iv.endTime}`));
    }
    // Pour les absences récurrentes (configurées par tech), pas d'actionId réel
    // → pas de bouton supprimer. Pour les autres → oui.
    if (iv.actionId) {
      rows.push(`<dt></dt><dd><button type="button" class="tooltip-delete-btn" data-action="delete-item" data-action-id="${escapeHtml(iv.actionId)}" data-kind="absence">🗑 Supprimer cette absence</button></dd>`);
    }
    return `<dl>${rows.join("")}</dl>`;
  }

  // Statut en premier (si connu)
  // v2026.5.46 — rideau horaire : tant que le verdict n'est pas révélé
  // (12h matin / 15h aprèm), on masque un statut clos/résolu — sinon le tooltip
  // trahit le verdict de l'après-midi avant 15h. Les statuts non-verdict
  // (En cours, À faire…) restent visibles.
  if (iv.status) {
    const _statusIsVerdict = isClosedStatus(iv.status) || isResolvedStatus(iv.status);
    if (!_statusIsVerdict || _isVerdictRevealed(iv)) {
      let cls = "other";
      if (isClosedStatus(iv.status)) cls = "closed";
      else if (isResolvedStatus(iv.status)) cls = "resolved";
      else if (/en cours|ex[ée]cution/i.test(iv.status)) cls = "ongoing";
      rows.push(`<dt>Statut</dt><dd><span class="status-pill ${cls}">${escapeHtml(iv.status)}</span></dd>`);
    }
  }

  if (iv.startTime && iv.endTime) {
    rows.push(row("Horaire", ivIsMultiDay(iv) ? `du ${iv.startDate} ${iv.startTime} au ${iv.endDate} ${iv.endTime}` : `${iv.startTime}–${iv.endTime}`));
  }

  // ─── Texte d'action : fiche (complet) en priorité, sinon xhr2 (tronqué) ──
  // v4.1.8 : un seul bloc "Action" qui s'enrichit automatiquement. Au début,
  // le xhr2 tronqué s'affiche ; dès que le fetch timeline est revenu,
  // iv.ficheActionText remplace le texte dans le même bloc.
  const actionText = _sanitizeActionText(iv.ficheActionText ||
                     (iv.bulleDescription ? formatActionTextMultiline(iv.bulleDescription) : null));
  if (actionText) {
    const htmlAction = escapeHtml(actionText).replace(/\n/g, "<br>");
    rows.push(`<dt>Action</dt><dd class="description">${htmlAction}</dd>`);
  } else {
    // Si pas de description (même pas de xhr2), afficher les infos structurées qu'on a
    const hasAction = !!(i.date || i.heure || i.lieu || i.contact || i.service ||
                         i.probleme || i.aFaire || i.materiel);
    if (i.date || i.heure) {
      const dh = [i.date, i.heure].filter(Boolean).join(" · ");
      if (dh) rows.push(row("Quand", dh));
    }
    const contact = i.contact || iv.bulleContact;
    if (contact) rows.push(row("Contact", contact));
    const lieu = iv.ficheLocation || i.lieu || iv.bulleLieu;   // fiche d'abord
    if (lieu) rows.push(row("Lieu", lieu));
    if (iv.locMismatch) {
      rows.push(row("⚠ Adresse", `Fiche : ${iv.locMismatch.fiche} — Action : ${iv.locMismatch.action}`));
    }
    if (i.service) rows.push(row("Service", i.service));
    if (i.probleme) rows.push(row("Problème", i.probleme));
    if (i.aFaire) rows.push(row("À faire", i.aFaire));
    if (!hasAction && !contact && !lieu) {
      if (iv.ficheFetched) {
        rows.push(`<dt>Info</dt><dd style="color:var(--text-faint)">Aucun détail pour cette intervention.</dd>`);
      } else {
        rows.push(`<dt>Info</dt><dd style="color:var(--text-faint)">Chargement des détails…</dd>`);
      }
    }
  }

  // Deadline (si connue et différente)
  if (iv.deadline && !i.date) rows.push(row("Deadline", iv.deadline));

  if (iv.ref) {
    rows.push(`<hr>`);
    // v2026.5.40 : la référence devient cliquable pour ouvrir la fiche EV.
    // Plus besoin du message "Cliquer pour ouvrir" — la ref est maintenant
    // un lien stylé (souligné + couleur accent + cursor pointer).
    const refSafe = escapeHtml(iv.ref);
    const canOpen = !iv._analyzing && !!iv.formLink;
    if (canOpen) {
      rows.push(`<dt>Référence</dt><dd class="tt-ref-cell"><a href="#" class="tt-ref-link" data-action="open-fiche" title="Ouvrir la fiche dans EasyVista">${refSafe}</a><button class="tt-copy-btn" data-action="copy-ref" data-ref="${refSafe}" title="Copier la référence">📋</button></dd>`);
    } else {
      rows.push(`<dt>Référence</dt><dd class="tt-ref-cell"><span class="tt-ref-val">${refSafe}</span><button class="tt-copy-btn" data-action="copy-ref" data-ref="${refSafe}" title="Copier la référence">📋</button></dd>`);
    }
    // séparateur après la Référence pour aérer le tooltip.
    rows.push(`<hr>`);
  }

  if (iv._analyzing) {
    rows.push(`<hr>`);
    rows.push(`<dt>⚠</dt><dd>Intervention disparue d'EasyVista — analyse en cours (clôturée, déplacée ou annulée ?)</dd>`);
  } else if (iv.missingSince && ivVStatus(iv) === "unknown") {
    rows.push(`<hr>`);
    rows.push(`<dt>⚠</dt><dd>Intervention disparue d'EasyVista — sort indéterminé (fiche illisible)</dd>`);
  }

  // v2026.5.46 — retirer du planning (pur client) : iv FAITE/SUSPENDUE/
  // CLOSE (verdict v2 ou statut EV clos/résolu), ou disparue au sort
  // indéterminé (unknown) que l'utilisateur veut écarter à la main.
  const _vsTooltip = ivVStatus(iv);
  const _canHide = _vsTooltip === "done" || _vsTooltip === "suspended" || _vsTooltip === "closed" ||
    (_vsTooltip === "unknown" && !!iv.missingSince) ||
    isClosedStatus(iv.status) || isResolvedStatus(iv.status);
  if (iv.actionId && _canHide) {
    rows.push(`<dt></dt><dd><button type="button" class="tooltip-delete-btn" data-action="hide-iv" data-action-id="${escapeHtml(iv.actionId)}">🗑 Retirer du planning</button></dd>`);
  }

  // v2026.5.21 : icône épingle adaptative
  //   (épingle couchée) = pas encore épinglée, clic pour épingler
  //   (épingle plantée, rouge) = déjà épinglée pour cette (ref + date)
  //     — clic pour désépingler. NB : le popup a sa propre topbar avec un
  //     bouton explicite ; celui-ci dans le tooltip hover sert surtout
  //     à montrer visuellement l'état à l'user au survol.
  const _pinState = _getPinStateForIv(iv);
  const _pinIcon = _pinState.isPinned ? "📍" : "📌";
  const _pinTitle = _pinState.isPinned
      ? "Cette intervention est déjà épinglée pour ce jour. Cliquer pour désépingler."
      : "Épingler la bulle (ou double-Ctrl). Cliquer à nouveau pour libérer.";
  const _pinClass = _pinState.isPinned ? " tooltip-pinbtn-active" : "";

  if (rows.length === 0) {
    return `<div class="tooltip-actions">
  <div class="tooltip-actionbtn" data-action="reload" title="Recharger uniquement cette intervention">
    <svg viewBox="0 0 16 16" fill="none" aria-hidden="true"><path d="M2 8a6 6 0 1 0 1.76-4.24M2 3v3h3" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/></svg>
  </div>
  <div class="tooltip-actionbtn tooltip-pinbtn${_pinClass}" data-action="pin" title="${_pinTitle}">${_pinIcon}</div>
</div><dl><dt>Info</dt><dd>Aucun détail disponible</dd></dl>`;
  }
  // commentaire tech extrait par l'analyse de disparition (verdict v2).
  //   - Statut officiellement clos/résolu → vert (terminé + validé)
  //   - Statut pas clos → "Fait" / "Suspendu" (jaune)
  // rideau horaire — on n'affiche le bloc commentaire qu'une fois le
  //        seuil franchi (12h matin / 15h aprèm). Avant ça, le commentaire
  //        existe en mémoire mais reste invisible.
  const _vd = iv.verdict || {};
  if (_vd.techComment && _isVerdictRevealed(iv)) {
    // retire le préfixe "login: " du commentaire.
    const stripped = _vd.techComment.replace(/^[a-z0-9_]{3,12}\s*:\s*/, "");
    const cmtSafe = escapeHtml(stripped);
    const info = _vd.actionInfo || {};
    // on retire l'heure du méta (dateCreation/dateFin) — l'utilisateur
    // veut juste la date, pas le HH:MM:SS qu'EasyVista accole.
    const _stripTime = (s) => String(s || "").replace(/[\sT]+\d{1,2}:\d{2}(:\d{2})?\s*$/, "").trim();
    const metaDate = _stripTime(info.dateFin || info.dateCreation || "");
    // badge selon le verdict :
    //   - closed    → "Terminé (clos)" +
    //   - suspended → "Suspendu" en JAUNE
    //   - done      → juste "Fait"
    const isSuspended = _vd.status === "suspended";
    const labelText = _vd.officialClosed
      ? "Terminé (clos)"
      : (isSuspended ? "Suspendu" : "Fait");
    const badgeContent = _vd.officialClosed
      ? `${escapeHtml(labelText)}<br>✅`
      : (isSuspended
          ? `<span style="color:#d39c00">${escapeHtml(labelText)}</span>`
          : escapeHtml(labelText));
    // layout 2 colonnes —
    //   gauche : badge "Terminé (clos)" centré vertical
    //   droite : meta (auteur+date) + commentaire empilés
    const metaHtml = (info.intervenant || metaDate)
      ? `<div style="color:var(--text-faint);font-size:0.85em;font-style:italic;margin-bottom:4px">${escapeHtml(info.intervenant || "")}${(info.intervenant && metaDate) ? " — " : ""}${escapeHtml(metaDate)}</div>`
      : "";
    const dd = `
      <dd>
        <div style="display:flex;gap:12px;align-items:center">
          <div style="flex:0 0 auto;text-align:center;font-weight:600;line-height:1.3;min-width:80px">
            ${badgeContent}
          </div>
          <div style="flex:1;min-width:0;border-left:1px solid var(--border);padding-left:10px">
            ${metaHtml}
            <div style="white-space:pre-wrap">${cmtSafe}</div>
          </div>
        </div>
      </dd>`;
    rows.push(`<dt>Commentaire</dt>${dd}`);
  }
  // v4.1.13/14 : boutons d'action en haut à droite (recharger + épingler)
  return `<div class="tooltip-actions">
  <div class="tooltip-actionbtn" data-action="reload" title="Recharger uniquement cette intervention">
    <svg viewBox="0 0 16 16" fill="none" aria-hidden="true"><path d="M2 8a6 6 0 1 0 1.76-4.24M2 3v3h3" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/></svg>
  </div>
  <div class="tooltip-actionbtn tooltip-pinbtn${_pinClass}" data-action="pin" title="${_pinTitle}">${_pinIcon}</div>
</div><dl>${rows.join("")}</dl>`;
}

/**
 * v2026.5.21 : retourne l'état d'épinglage pour une intervention donnée
 * (pour la date actuellement affichée). Utilisé pour afficher vs
 * dans le tooltip hover.
 */
function _getPinStateForIv(iv) {
  if (!iv || !iv.actionId) return { isPinned: false };
  const date = state.currentDate || "";
  const key = iv.actionId + "|" + date;
  for (const p of pinnedPopups) {
    if (!p || !p.el) continue;
    const aid = p.el.dataset.actionId || "";
    const d = p.el.dataset.originDate || "";
    if (aid + "|" + d === key) {
      return { isPinned: true, popup: p.el };
    }
  }
  return { isPinned: false };
}

/**
 * Met en forme un texte d'action EasyVista en ajoutant des retours à la ligne
 * avant chaque étiquette connue ("Date :", "Lieu :", "Contact :", etc.).
 * Transforme :
 *   "Date : 20.04 Heure : MatinLieu : Ville1/Rue1 1 bisContact : Nom..."
 * En :
 *   "Date : 20.04 Heure : Matin
 *    Lieu : Ville1/Rue1 1 bis
 *    Contact : Nom..."
 */
// v2026.5.46 — Assainit le texte d'action affiché dans le popup. Certaines
// actions (ex. mail automatique EZV « Votre demande a été effectuée ») ont une
// description ÉNORME : en-tête mail + résumé complet de la demande + formulaire +
// pied de page. On retire ce bruit pour ne garder que la partie utile au tech
// (Note / Information complémentaire / Historique), on décode les entités et on
// borne la longueur. Pour un texte déjà propre (cas normal) → quasi no-op.
function _sanitizeActionText(raw) {
  if (!raw) return raw;
  let t = String(raw);
  const isAutoMail = /Ce message est envoyé automatiquement|Résumé de la demande de service|easyvista@vd\.ch/i.test(t);
  if (isAutoMail) {
    // Garder à partir de la 1re section réellement utile au tech.
    const m = t.match(/(?:Note\s*:|Information Compl[ée]mentaire\s*:|Historique\s*:)[\s\S]*/i);
    if (m) t = m[0];
    // Retirer le pied de page EZV récurrent.
    t = t.replace(/Vous accéderez à EasyVista[\s\S]*$/i, "")
         .replace(/Support DGNSI[\s\S]*$/i, "")
         .replace(/Direction générale certifiée[\s\S]*$/i, "")
         .replace(/D[ÉE]PARTEMENT DE[\s\S]*$/i, "");
  }
  t = t.replace(/&#x0?D;?/gi, "").replace(/&nbsp;/gi, " ")
       .replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&")
       .replace(/[ \t]{2,}/g, " ").replace(/\n{3,}/g, "\n\n").trim();
  if (t.length > 1500) t = t.slice(0, 1500).trim() + " […]";
  return t;
}

function formatActionTextMultiline(text) {
  if (!text) return "";
  const newlineLabels = [
    "Lieu", "Contact",
    "Service", "Étage", "Bureau",
    "Nom utilisateur",
    "Problème", "A faire", "À faire",
    "Matériel", "Materiel",
    "Bénéficiaire", "Beneficiaire"
  ];
  let result = String(text);
  for (const label of newlineLabels) {
    const rx = new RegExp(`([^\\n])(${escapeRegex(label)}\\s*:\\s*)`, "g");
    result = result.replace(rx, "$1\n$2");
  }
  // v2026.5.45 — passe additionnelle pour les labels colles a un mot
  // minuscule SANS : derriere (cas "secretariatEtage"). On exige une lettre
  // minuscule juste avant le label en majuscule pour eviter les faux
  // positifs ("Marie Bureau" a un espace, donc pas de match).
  for (const label of newlineLabels) {
    if (!/^[A-Z\u00C9\u00C8\u00C0\u00C2\u00CE\u00D4\u00DB\u00C7]/.test(label)) continue;
    const rxG = new RegExp(`([a-z\u00E0-\u00FF])(${escapeRegex(label)})\\b`, "g");
    result = result.replace(rxG, "$1\n$2");
  }
  // Isoler la signature planificateur finale ("ECM 16.04", "csh 27.03", etc.)
  // qui se trouve typiquement en fin sans préfixe de label.
  // On utilise un look-behind pour ne PAS manger la lettre précédente
  //   (et donc ne pas couper le "F" de "FRD 07/04").
  result = result.replace(/(?<=[^\n])(\s*)([A-Za-z]{2,4}\s+\d{1,2}[./]\d{1,2}(?:[./]\d{2,4})?)\s*$/, "\n$2");
  // Nettoyer
  result = result.replace(/\n{2,}/g, "\n").trim();
  return result;
}

function escapeRegex(s) {
  return String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}

function row(label, value) {
  return `<dt>${escapeHtml(label)}</dt><dd>${escapeHtml(value)}</dd>`;
}

function escapeHtml(s) {
  return String(s)
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&#39;");
}

function highlightIntervention(cardEl, ivIdx, on) {
  // v2026.5.29 : chercher .intervention-v2 (nouveau nom) et fallback .intervention
  const row = cardEl.querySelector(`.intervention-v2[data-iv-idx="${ivIdx}"]`)
           || cardEl.querySelector(`.intervention[data-iv-idx="${ivIdx}"]`);
  const slot = cardEl.querySelector(`.timeline-slot[data-iv-idx="${ivIdx}"]`);
  // v2026.5.40 : highlight aussi la mini-card en vue horizontale
  const miniCard = cardEl.querySelector(`.iv-mini-card[data-iv-idx="${ivIdx}"]`);
  if (row) row.classList.toggle("highlight", on);
  if (slot) slot.classList.toggle("highlight", on);
  if (miniCard) miniCard.classList.toggle("highlight", on);

  // v2026.5.29 : quand on active le highlight (typiquement depuis un slot
  // timeline), faire scroller la row dans la vue pour que l'user voie la
  // carte correspondante sans avoir à chercher. On évite de scroller le
  // body, on scroll juste la row à l'intérieur de la carte si elle déborde.
  if (on && row && typeof row.scrollIntoView === "function") {
    try {
      row.scrollIntoView({ block: "nearest", inline: "nearest", behavior: "smooth" });
    } catch (e) {}
  }
}

// ============================================================================
// Helpers temps
// ============================================================================

function timeToMinutes(hhmm) {
  if (!hhmm) return null;
  const m = hhmm.match(/^(\d{1,2}):(\d{2})$/);
  if (!m) return null;
  return parseInt(m[1], 10) * 60 + parseInt(m[2], 10);
}

function minutesToTime(mins) {
  const h = Math.floor(mins / 60);
  const m = mins % 60;
  return String(h).padStart(2, "0") + ":" + String(m).padStart(2, "0");
}

// ============================================================================
// Écrans d'erreur
// ============================================================================

function showLoading() {
  document.getElementById("loading").classList.remove("hidden");
  document.getElementById("error-box").classList.add("hidden");
  document.getElementById("session-needed").classList.add("hidden");
  document.getElementById("stats").classList.add("hidden");
  document.getElementById("cards").innerHTML = "";
}

// showError accepte un 2e argument optionnel.
//   options.centered : true → carte centrée avec icône, titre, description.
//   options.icon, options.title : pour le mode centré.
//   options.actionLabel + options.actionHandler : bouton d'action.
// Mode par défaut (sans options.centered) = bandeau rouge classique.
function showError(msg, options) {
  document.getElementById("loading").classList.add("hidden");
  document.getElementById("stats").classList.add("hidden");
  document.getElementById("session-needed").classList.add("hidden");
  const evUnr = document.getElementById("ev-unreachable");
  if (evUnr) evUnr.classList.add("hidden");
  document.getElementById("cards").innerHTML = "";
  const box = document.getElementById("error-box");
  box.innerHTML = "";
  const isCentered = !!(options && options.centered);
  box.classList.toggle("error-box-centered", isCentered);

  if (isCentered) {
    if (options.icon) {
      const iconEl = document.createElement("div");
      iconEl.className = "error-icon";
      iconEl.textContent = options.icon;
      box.appendChild(iconEl);
    }
    if (options.title) {
      const titleEl = document.createElement("div");
      titleEl.className = "error-title";
      titleEl.textContent = options.title;
      box.appendChild(titleEl);
    }
    const descEl = document.createElement("div");
    descEl.className = "error-description";
    descEl.textContent = msg;
    box.appendChild(descEl);
  } else {
    const span = document.createElement("span");
    span.textContent = msg;
    span.style.marginRight = "10px";
    box.appendChild(span);
  }

  if (options && options.actionLabel && typeof options.actionHandler === "function") {
    const btn = document.createElement("button");
    btn.type = "button";
    btn.className = "btn btn-primary";
    btn.textContent = options.actionLabel;
    btn.addEventListener("click", (e) => {
      e.preventDefault();
      try { options.actionHandler(); } catch (err) { LOG.warn("showError", "action handler en échec", err); }
    });
    box.appendChild(btn);
  }
  box.classList.remove("hidden");
}

function showSessionNeeded() {
  document.getElementById("loading").classList.add("hidden");
  document.getElementById("error-box").classList.add("hidden");
  document.getElementById("stats").classList.add("hidden");
  const evUnr = document.getElementById("ev-unreachable");
  if (evUnr) evUnr.classList.add("hidden");
  // éviter le doublon — quand on affiche l'écran plein "session
  // nécessaire", on cache la bannière qui dirait la même chose.
  if (typeof hideSessionExpiredBanner === "function") hideSessionExpiredBanner();
  document.getElementById("cards").innerHTML = "";
  const sn = document.getElementById("session-needed");
  sn.classList.remove("hidden");
  // on injecte le sous-bandeau "Activer multi-onglets" dans
  // l'écran plein lui aussi — sinon en arrivant sur un jour sans
  // cache + sans session, l'utilisateur perdait l'invitation à
  // activer la lecture du cookie.
  if (typeof _injectCookiesPromptInBanner === "function") {
    try { _injectCookiesPromptInBanner(sn); } catch (e) {}
  }
}

function hideSessionNeeded() {
  document.getElementById("session-needed").classList.add("hidden");
}

// v4.2 : écran plein "EasyVista inaccessible" (différent de session expirée).
function showEvUnreachable() {
  document.getElementById("loading").classList.add("hidden");
  document.getElementById("error-box").classList.add("hidden");
  document.getElementById("stats").classList.add("hidden");
  document.getElementById("session-needed").classList.add("hidden");
  document.getElementById("cards").innerHTML = "";
  const el = document.getElementById("ev-unreachable");
  if (el) el.classList.remove("hidden");
}

function hideEvUnreachable() {
  const el = document.getElementById("ev-unreachable");
  if (el) el.classList.add("hidden");
}

// v4.1.12 : bannière non bloquante "session expirée". Affichée quand le
// fetch détecte une session morte EN COURS DE ROUTE (pas au démarrage).
// L'utilisateur voit toujours les données déjà chargées, mais est prévenu
// que les mises à jour sont arrêtées.
// v2026.5.46 — coordinateur : UN SEUL bandeau de session visible à la fois.
// Toutes les fonctions showXBanner passent par _hideAllSessionBanners() en
// premier (sauf le leur), puis recalculent l'empilement. Fini les bandeaux
// superposés au même moment.
const _SESSION_BANNER_IDS = [
  "session-expired-banner", "ev-unreachable-banner",
  "session-reconnecting-banner", "session-reconnect-failed-banner",
];
function _hideAllSessionBanners(exceptId) {
  _SESSION_BANNER_IDS.forEach(id => {
    if (id === exceptId) return;
    const b = document.getElementById(id);
    if (b) b.classList.add("hidden");
  });
}

function showSessionExpiredBanner() {
  // symétrique de showSessionNeeded — si l'écran plein "session
  // nécessaire" est visible, on le cache pour ne pas avoir un doublon
  // (la bannière en haut + l'écran plein en dessous).
  if (typeof hideSessionNeeded === "function") hideSessionNeeded();
  _hideAllSessionBanners("session-expired-banner");
  const b = document.getElementById("session-expired-banner");
  if (b) {
    b.classList.remove("hidden");
    // v5.0.10 : rebrancher le bouton "Ouvrir EasyVista" natif pour qu'il
    // appelle triggerReconnect() au lieu de juste ouvrir un onglet. Ça
    // déclenche la reconnexion SSO ET l'auto-reload du viewer quand la
    // nouvelle session est détectée.
    const btn = b.querySelector("#session-banner-reconnect");
    if (btn && !btn.dataset.boundReconnect) {
      btn.dataset.boundReconnect = "1";
      btn.textContent = "🔄 Me reconnecter";
      const clone = btn.cloneNode(true);
      btn.parentNode.replaceChild(clone, btn);
      clone.addEventListener("click", () => triggerReconnect());
    }
    // v2026.5.45 (issue #4) : si la permission "cookies" n'est pas
    // accordée ET que l'utilisateur n'a pas dit "ne plus afficher", on
    // injecte un sous-bandeau invitant à activer la gestion multi-onglets.
    _injectCookiesPromptInBanner(b);
  }
  _srSyncStickyOffsets();
}

// retire TOUTES les copies actuellement affichées du sous-bandeau
// "Activer multi-onglets" (bannière session expirée + écran plein
// "session nécessaire" + modals d'erreur fiche). Appelé quand
// l'utilisateur active la permission ou choisit "Ne plus afficher" :
// on évite que l'invitation reste visible ailleurs après l'action.
function _removeAllCookiesPrompts() {
  document.querySelectorAll(".session-banner-cookies-prompt").forEach(el => {
    try { el.remove(); } catch (e) {}
  });
}

async function _injectCookiesPromptInBanner(banner) {
  try {
    // Si déjà injecté, ne rien faire (évite doublons aux ré-affichages).
    if (banner.querySelector(".session-banner-cookies-prompt")) return;
    const has = await new Promise(r => chrome.permissions.contains({ permissions: ["cookies"] }, r));
    if (has) return; // permission OK, rien à proposer
    // Lire le flag dismiss depuis admin_config
    const cfg = await loadAdminConfig();
    if (cfg.cookiesPromptDismissed) return;

    // sous-bandeau centré, plus court et factuel — titre courte
    // + bouton clair + lien dismiss discret, dans un encart blanc
    // semi-translucide qui se détache bien du rouge de la bannière.
    const prompt = document.createElement("div");
    prompt.className = "session-banner-cookies-prompt";

    const inner = document.createElement("div");
    inner.className = "session-banner-cookies-inner";

    const promptTitle = document.createElement("div");
    promptTitle.className = "session-banner-cookies-title";
    promptTitle.innerHTML = "🔗 Multi-onglets EasyVista";
    inner.appendChild(promptTitle);

    const enableBtn = document.createElement("button");
    enableBtn.type = "button";
    enableBtn.className = "btn session-banner-cookies-btn";
    enableBtn.textContent = "Activer";
    enableBtn.title = "Permet à l'extension de lire le cookie de session EasyVista.";
    enableBtn.addEventListener("click", async () => {
      enableBtn.disabled = true;
      LOG.warn("permissions", "demande de permission cookies (bouton bannière session expirée)");
      try {
        const granted = await new Promise(r => chrome.permissions.request({ permissions: ["cookies"] }, r));
        if (granted) {
          LOG.warn("permissions", "permission cookies ACCORDÉE via bannière");
          showToast("Multi-onglets activé", "L'extension lit désormais le cookie session.");
          const adminCb = document.querySelector(".admin-cookie-row input[type='checkbox']");
          if (adminCb) adminCb.checked = true;
          cfg.cookiesPromptDismissed = false;
          await saveAdminConfig(cfg);
          // retirer TOUS les prompts ouverts (bannière + écran plein
          // + modal). Avant on ne retirait que celui-ci, donc s'il y avait
          // un sous-bandeau dans la modal et un autre dans la bannière,
          // l'autre restait visible inutilement.
          _removeAllCookiesPrompts();
        } else {
          LOG.warn("permissions", "permission cookies REFUSÉE via bannière");
          showToast("Refusé", "L'extension reste sur l'ancien comportement.");
          enableBtn.disabled = false;
        }
      } catch (err) {
        LOG.warn("permissions", "request err", { err: err && err.message });
        enableBtn.disabled = false;
      }
    });

    const dismissBtn = document.createElement("button");
    dismissBtn.type = "button";
    dismissBtn.className = "btn btn-icon session-banner-cookies-dismiss";
    dismissBtn.textContent = "Ne plus afficher";
    dismissBtn.title = "Cache cette suggestion. Réactivable depuis Paramètres → Diagnostics.";
    dismissBtn.addEventListener("click", async () => {
      LOG.warn("permissions", "utilisateur a cliqué « Ne plus afficher » dans la bannière");
      cfg.cookiesPromptDismissed = true;
      await saveAdminConfig(cfg);
      // retirer toutes les copies du sous-bandeau, pas juste celle-ci.
      _removeAllCookiesPrompts();
      if (typeof showToast === "function") {
        showToast("Suggestion masquée",
          "Réactivable dans Paramètres → Diagnostics → Multi-onglets");
      }
    });

    // explication en 2 lignes — chaque info sur sa propre ligne pour
    // éviter une coupure disgracieuse du mot "Lit" en fin de 1re ligne.
    const promptExplain = document.createElement("div");
    promptExplain.className = "session-banner-cookies-explain";
    const line1 = document.createElement("div");
    line1.textContent = "Améliore nettement la liaison entre l'extension et votre session EasyVista.";
    const line2 = document.createElement("div");
    line2.className = "session-banner-cookies-explain-sub";
    line2.textContent = "Lit uniquement le cookie de session correspondant.";
    promptExplain.appendChild(line1);
    promptExplain.appendChild(line2);
    inner.appendChild(promptExplain);

    const btnsRow = document.createElement("div");
    btnsRow.className = "session-banner-cookies-actions";
    btnsRow.appendChild(enableBtn);
    btnsRow.appendChild(dismissBtn);
    inner.appendChild(btnsRow);

    prompt.appendChild(inner);
    banner.appendChild(prompt);
  } catch (e) {
    LOG.warn("permissions", "_injectCookiesPromptInBanner err", { err: e && e.message });
  }
}
function hideSessionExpiredBanner() {
  const b = document.getElementById("session-expired-banner");
  if (b) b.classList.add("hidden");
  _srSyncStickyOffsets();
}

// v5.0.9 : bannière affichée pendant la reconnexion (remplace la bannière
// expirée après clic sur "Me reconnecter")
// v5.0.11 : ajoute un bouton "Annuler" pour interrompre le processus.
function showReconnectingBanner() {
  let b = document.getElementById("session-reconnecting-banner");
  if (!b) {
    b = document.createElement("div");
    b.id = "session-reconnecting-banner";
    b.className = "banner-reconnecting";
    const topbar = document.querySelector(".topbar") || document.querySelector("header") || document.body;
    if (topbar.nextSibling) {
      topbar.parentNode.insertBefore(b, topbar.nextSibling);
    } else {
      document.body.insertBefore(b, document.body.firstChild);
    }
  }
  b.innerHTML = `
    <span class="banner-spinner">⏳</span>
    <span class="banner-text">Reconnexion à EasyVista en cours… Connectez-vous dans l'onglet qui vient de s'ouvrir.</span>
    <button type="button" class="banner-cancel-btn">Annuler</button>
  `;
  const cancelBtn = b.querySelector(".banner-cancel-btn");
  if (cancelBtn) cancelBtn.addEventListener("click", () => cancelReconnect());
  _hideAllSessionBanners("session-reconnecting-banner");
  b.classList.remove("hidden");
  _srSyncStickyOffsets();
}
function hideReconnectingBanner() {
  const b = document.getElementById("session-reconnecting-banner");
  if (b) b.classList.add("hidden");
  _srSyncStickyOffsets();
}

// v5.0.11 : bannière "Reconnexion échouée" avec choix manuel du réseau
// (Bureau/Télétravail). Affichée après timeout 90s de reconnexion.
function showReconnectFailedBanner() {
  let b = document.getElementById("session-reconnect-failed-banner");
  if (!b) {
    b = document.createElement("div");
    b.id = "session-reconnect-failed-banner";
    b.className = "banner-reconnect-failed";
    const topbar = document.querySelector(".topbar") || document.querySelector("header") || document.body;
    if (topbar.nextSibling) {
      topbar.parentNode.insertBefore(b, topbar.nextSibling);
    } else {
      document.body.insertBefore(b, document.body.firstChild);
    }
  }
  b.innerHTML = `
    <span class="banner-icon">⚠</span>
    <span class="banner-text">
      <strong>Reconnexion échouée.</strong>
      Indiquez où vous êtes pour réessayer :
    </span>
    <button type="button" class="banner-btn-primary" data-origin="https://itsma.etat-de-vaud.ch">🏢 Au bureau</button>
    <button type="button" class="banner-btn-primary" data-origin="https://itsma.vd.ch">🏠 En télétravail</button>
    <button type="button" class="banner-cancel-btn">Annuler</button>
  `;
  // Boutons de choix de réseau : retry avec origine forcée
  b.querySelectorAll(".banner-btn-primary").forEach(btn => {
    btn.addEventListener("click", () => {
      const origin = btn.dataset.origin;
      hideReconnectFailedBanner();
      triggerReconnect(origin);
    });
  });
  // Bouton Annuler : retour à la bannière "Session expirée" simple
  const cancelBtn = b.querySelector(".banner-cancel-btn");
  if (cancelBtn) cancelBtn.addEventListener("click", () => {
    hideReconnectFailedBanner();
    showSessionExpiredBanner();
  });
  _hideAllSessionBanners("session-reconnect-failed-banner");
  b.classList.remove("hidden");
  _srSyncStickyOffsets();
}
function hideReconnectFailedBanner() {
  const b = document.getElementById("session-reconnect-failed-banner");
  if (b) b.classList.add("hidden");
  _srSyncStickyOffsets();
}

// v4.2.5 : bannière non bloquante "EasyVista inaccessible"
function showEvUnreachableBanner() {
  // 1 seul bandeau à la fois → on masque tous les autres d'abord.
  _hideAllSessionBanners("ev-unreachable-banner");
  const b = document.getElementById("ev-unreachable-banner");
  if (b) b.classList.remove("hidden");
  _srSyncStickyOffsets();
}
function hideEvUnreachableBanner() {
  const b = document.getElementById("ev-unreachable-banner");
  if (b) b.classList.add("hidden");
  _srSyncStickyOffsets();
}

// ===========================================================================
// v2026.5.46 — Recherche EasyVista (basicAutoComplete) + cache (DOSSIER puis
// LOCAL). Portage du prototype ev-search-tester, branché sur les primitives
// existantes. AUCUN fetch de fiche lourde (mémoire). Le cache est indexé
// d'abord depuis le DOSSIER partagé (hôte natif + réseau interne), et SINON
// (rien / inaccessible / externe) depuis le cache local chrome.storage.
// ===========================================================================
const SEARCH_DEBOUNCE_MS = 350;   // v2026.5.46 — attendre la fin de frappe
const SEARCH_MIN_CHARS = 2;
let _searchSeq = 0;
let _searchInflight = null;
let _searchDebTimer = null;
let _searchCacheByRef = new Map();
let _searchCacheList = [];
let _searchCacheBuiltAt = 0;
let _searchCacheSource = null;   // "dossier" | "local" | null
let _searchCacheDate = null;     // v2026.5.46 — jour indexé (rebuild si changé)
let _searchInited = false;

function _srNorm(s) { return String(s == null ? "" : s).toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").trim(); }
function _srCleanLabel(key) {
  if (typeof key !== "string") return key;
  if (key.startsWith("@@hidden_")) return key.slice(9);
  if (key.startsWith("@@")) { const i = key.lastIndexOf("$$"); if (i >= 0) return key.slice(i + 2); }
  return key;
}
function _srGetField(line, wanted) {
  if (line[wanted] !== undefined) return line[wanted];
  const t = wanted.trim().toLowerCase();
  for (const k of Object.keys(line)) if (_srCleanLabel(k).trim().toLowerCase() === t) return line[k];
  return undefined;
}
function _srParseFrDate(s) { if (!s) return null; const m = String(s).match(/(\d{2})\/(\d{2})\/(\d{4})/); return m ? new Date(+m[3], +m[2] - 1, +m[1]) : null; }
const _SR_JOURS = ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"];
function _srDayWithWeekday(s) { const d = _srParseFrDate(s); if (!d) return s || ""; const j = _SR_JOURS[d.getDay()]; return j.charAt(0).toUpperCase() + j.slice(1) + " " + s; }
function _srFrToIso(fr) { const m = String(fr || "").match(/(\d{2})\/(\d{2})\/(\d{4})/); return m ? `${m[3]}-${m[2]}-${m[1]}` : null; }
// v2026.5.46 — statut SIMPLE : seulement « Clôturé », « Fait » ou
// « En cours ». Tout ce qui n'est ni clôturé ni fait (y compris inconnu /
// annulé / en cours / exécution) → « En cours » par défaut.
function _srHumanStatus(iv) {
  if (!iv) return "En cours";
  const vs = ivVStatus(iv);
  const st = String(iv.status || "").toLowerCase();
  if (vs === "closed" || st === "clôturé" || st === "cloturé") return "Clôturé";
  if (vs === "done" || vs === "suspended" || st === "terminé" || st === "résolu" || st === "resolu" || st === "finalisation") return "Fait";
  return "En cours";
}
function _srWhenOf(day) { const d = _srParseFrDate(day); if (!d) return null; const t = new Date(); t.setHours(0, 0, 0, 0); if (d < t) return "past"; if (d.getTime() === t.getTime()) return "today"; return "future"; }
function _srStatusKey(label) { const l = String(label).toLowerCase(); if (l.includes("clôtur") || l.includes("clotur")) return "clos"; if (l.includes("fait")) return "fait"; if (l.includes("cours")) return "cours"; if (l.includes("annul")) return "annule"; return "autre"; }
function _srStatusIcon(k) { return k === "clos" ? "✓" : k === "fait" ? "✓" : k === "cours" ? "⏳" : k === "annule" ? "✕" : "•"; }
function _srWhenLabel(w) { return w === "past" ? "Planifiée (passé)" : w === "today" ? "Aujourd'hui" : "À venir"; }

const _SR_TYPE_CONFIG = {
  SD_REQUEST: { title: "Intervention / demande", fields: ["N° de demande", "Demandeur", "Bénéficiaire"] },
  AM_ASSET: { title: "Matériel", fields: ["Code matériel", "Modèle", "Marque", "Statut", "N° de série", "Login de l'utilisateur principal"] },
  AM_EMPLOYEE: { title: "Employé", fields: ["Nom", "Téléphone", "Fonction", "Login"] },
};

// --- index cache : DOSSIER d'abord, SINON local ---------------------------
function _srPushTechs(techs, dayLabel, seen) {
  for (const t of (techs || [])) {
    for (const iv of (t.interventions || [])) {
      if (iv && (ivIsDead(iv) || ((ivVStatus(iv) === "gone" || ivVStatus(iv) === "moved")))) continue;  // tombstones/retirées masqués
      // v2026.5.46 — dédup multi-source (jour courant + dossier + local) par
      // identité stable, pour ne pas indexer/afficher la même iv deux fois.
      const key = iv.requestId ? ("q:" + iv.requestId)
        : (iv.actionId != null ? ("a:" + iv.actionId) : (iv.ref ? ("r:" + iv.ref) : null));
      if (key && seen) { if (seen.has(key)) continue; seen.add(key); }
      const e = Object.assign({}, iv, { techName: iv.techName || t.name, techId: iv.techId || t.id, _day: dayLabel || iv.currentDate });
      _searchCacheList.push(e);
      if (e.ref) _searchCacheByRef.set(String(e.ref), e);
    }
  }
}
// v2026.5.46 — indexe une entrée jour v2 (liste plate d'ivs, annuaire
// techs séparé). Mêmes filtres/dédup que _srPushTechs.
function _srPushDay(day, dayLabel, seen) {
  const nameById = new Map((day.techs || []).map(t => [String(t.id), t.name]));
  for (const iv of (day.ivs || [])) {
    if (iv && (ivIsDead(iv) || ivVStatus(iv) === "gone" || ivVStatus(iv) === "moved")) continue;
    const key = iv.requestId ? ("q:" + iv.requestId)
      : (iv.actionId != null ? ("a:" + iv.actionId) : (iv.ref ? ("r:" + iv.ref) : null));
    if (key && seen) { if (seen.has(key)) continue; seen.add(key); }
    const e = Object.assign({}, iv, {
      techName: iv.techName || nameById.get(String(iv.techId)) || "",
      _day: dayLabel || iv.currentDate
    });
    _searchCacheList.push(e);
    if (e.ref) _searchCacheByRef.set(String(e.ref), e);
  }
}
async function _srBuildCacheIndex(force) {
  const FRESH_MS = 120000;
  const curDate = (state && state.currentDate) || null;
  // v2026.5.46 — reconstruit si périmé (2 min) OU si on a changé de jour
  // (sinon le jour courant fraîchement chargé manquerait à l'index).
  if (!force && _searchCacheBuiltAt && (Date.now() - _searchCacheBuiltAt) < FRESH_MS && _searchCacheDate === curDate) return;
  _searchCacheByRef = new Map(); _searchCacheList = []; _searchCacheSource = null;
  const seen = new Set();
  // 0) JOUR COURANT (state.currentData) : données les + fraîches et + complètes
  // (descriptions/contacts déjà chargés au survol) → garantit que les
  // interventions affichées sont TROUVABLES (réf, contact/tél, lieu, description).
  try {
    if (state && state.currentData && Array.isArray(state.currentData.techs)) {
      _srPushTechs(state.currentData.techs, _fmtDateFR(curDate || todayISO()), seen);
    }
  } catch (e) {}
  let dossierOk = false;
  // 1) DOSSIER d'abord (hôte natif présent + réseau interne)
  try {
    if (state.networkContext === "internal" && typeof nmProbe === "function" && await nmProbe()) {
      const path = await nmSharePath();
      if (path) {
        const lst = await nmSend({ action: "list", path });
        const days = (lst && lst.ok && Array.isArray(lst.days)) ? lst.days : [];
        if (days.length) {
          let read = 0;
          for (const d of days) {
            const iso = (d && d.date) || d;
            if (!iso) continue;
            try { const day = await nmReadDay(iso, path); if (day && Array.isArray(day.ivs)) { _srPushDay(day, _fmtDateFR(iso), seen); read++; } } catch (e) {}
          }
          if (read > 0) { dossierOk = true; _searchCacheSource = "dossier"; LOG.info("search", `index cache DOSSIER : ${read} jour(s), ${_searchCacheList.length} iv, ${_searchCacheByRef.size} réfs`); }
        }
      }
    }
  } catch (e) { LOG.info("search", "lecture dossier échouée → repli cache local", { err: e && e.message }); }
  // 2) SINON store LOCAL (v2)
  if (!dossierOk) {
    try {
      const all = await chrome.storage.local.get(null);
      let read = 0;
      for (const k of Object.keys(all)) {
        if (!k.startsWith(STORE_PREFIX)) continue;
        const day = all[k];
        if (day && Array.isArray(day.ivs)) { _srPushDay(day, _fmtDateFR(k.slice(STORE_PREFIX.length)), seen); read++; }
      }
      _searchCacheSource = "local";
      LOG.info("search", `index store LOCAL : ${read} jour(s), ${_searchCacheList.length} iv, ${_searchCacheByRef.size} réfs`);
    } catch (e) { LOG.warn("search", "lecture store local échouée", { err: e && e.message }); }
  }
  // v2026.5.46 — ne PAS mémoriser un index vide (sinon il resterait vide 2 min
  // et la recherche cache ne trouverait rien) : on retentera au prochain appel.
  _searchCacheBuiltAt = _searchCacheList.length ? Date.now() : 0;
  _searchCacheDate = curDate;
}

// --- recherche EV (basicAutoComplete) -------------------------------------
async function _srSearchEV(query, signal) {
  const sess = state.session;
  if (!sess || !sess.origin || !sess.phpsessid) { LOG.info("search", "pas de session EV — partie EV ignorée"); return []; }
  const url = `${sess.origin}/api/v1/internal/search/basicAutoComplete?search=${encodeURIComponent(query)}&PHPSESSID=${encodeURIComponent(sess.phpsessid)}`;
  let res;
  try { res = await fetch(url, { method: "GET", credentials: "include", headers: { "Accept": "application/json, text/plain, */*", "X-Requested-With": "XMLHttpRequest" }, signal }); }
  catch (e) { if (e && e.name === "AbortError") return null; LOG.warn("search", "réseau basicAutoComplete", { err: e && e.message }); return []; }
  const text = await res.text();
  if (/type="password"|iamlogin|\/iam\/accueil/i.test(text)) { LOG.warn("search", "réponse = page login (session expirée)"); if (typeof showSessionExpiredBanner === "function") showSessionExpiredBanner(); return []; }
  let json = null; try { json = JSON.parse(text); } catch (e) {}
  if (!json) { LOG.warn("search", "réponse basicAutoComplete non-JSON"); return []; }
  const metas = (json.data && json.data.METAOBJECTS) || [];
  const out = [];
  for (const meta of metas) {
    const table = meta.TABLE_NAME; const cfg = _SR_TYPE_CONFIG[table];
    for (const line of (meta.LINES || [])) {
      const fields = []; let ref = null, day = null, statusLabel = null;
      if (cfg) {
        for (const lbl of cfg.fields) {
          const v = _srGetField(line, lbl);
          if (table === "AM_EMPLOYEE" && (meta.LINES || []).length <= 1 && v != null && v !== "" && query && _srNorm(v).includes(_srNorm(query))) continue;
          fields.push([lbl, v]);
        }
        if (table === "AM_EMPLOYEE") { try { const av = line.AVATAR_INFO && JSON.parse(line.AVATAR_INFO); if (av && av.userInitials) fields.push(["Initiales", av.userInitials]); } catch (e) {} }
        if (table === "SD_REQUEST") {
          ref = _srGetField(line, "N° de demande");
          const cached = ref && _searchCacheByRef.get(String(ref));
          if (cached) {
            const add = [["Catégorie", deriveShortTitle(cached)], ["Adresse", cached.bulleLieu], ["Tech", cached.techName], ["Horaire", (cached.startTime || "") + (cached.endTime ? "–" + cached.endTime : "")], ["Jour", _srDayWithWeekday(cached.currentDate || cached._day)]];
            for (const [k, v] of add) if (v != null && v !== "" && v !== "–") fields.push([k, v]);
            day = cached.currentDate || cached._day || null; statusLabel = _srHumanStatus(cached);
          } else {
            // v2026.5.46 — pas d'info cache → statut « En cours » par défaut
            // (le statut doit toujours être l'un de En cours / Fait / Clôturé).
            statusLabel = "En cours";
          }
        }
      } else {
        for (const k of Object.keys(line)) { const v = line[k]; if (v !== null && typeof v !== "object") fields.push([_srCleanLabel(k), v]); }
      }
      out.push({ source: "ev", table, ref: ref ? String(ref) : null, typeLabel: meta.TYPE_LABEL || (cfg && cfg.title) || table, icon: meta.ICON ? sess.origin + meta.ICON : "", fields, day, statusLabel, open: { pk: line.PK, guid: meta.TYPE_GUID, checksum: line.CHECKSUM }, raw: line });
    }
  }
  return out;
}

// v2026.5.46 — concatène TOUS les champs texte utiles d'une iv pour la
// recherche, y compris les descriptions (où sont écrits les n° de matériel,
// ex. « M917469 »). Permet de retrouver les interventions LIÉES à un appareil.
function _srIvHaystack(iv) {
  const parts = [iv.ref, iv.requestId, iv.type, iv.categoryLine, iv.bulleContact,
    iv.bulleLieu, iv.bulleDescription, iv.ficheActionText, iv.label, iv.techName,
    iv.resNumero, iv.resRue, iv.resVille];
  if (iv.infobulle && typeof iv.infobulle === "object") {
    for (const v of Object.values(iv.infobulle)) if (v && typeof v === "string") parts.push(v);
  }
  return parts.filter(Boolean).join("  
  ");
}
// Extrait un court passage autour du terme trouvé dans la description (pour
// montrer POURQUOI l'intervention est liée — ex. le n° matériel en contexte).
function _srLinkSnippet(iv, query) {
  const raw = String(iv.bulleDescription || iv.ficheActionText
    || (iv.infobulle && (iv.infobulle.materiel || iv.infobulle.aFaire)) || "")
    .replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
  if (!raw) return null;
  const needle = String(query).trim();
  const i = raw.toLowerCase().indexOf(needle.toLowerCase());
  if (i < 0) return null;
  const start = Math.max(0, i - 25);
  const end = Math.min(raw.length, i + needle.length + 40);
  return (start > 0 ? "…" : "") + raw.slice(start, end) + (end < raw.length ? "…" : "");
}
// ============================================================================
// v2026.5.46 — OPÉRATEURS DE RECHERCHE (côté cache)
// ============================================================================
//   mot1 mot2      ET : chaque mot doit être présent (ordre libre)
//   %              joker dans un terme : I2606%123 (dans cet ordre), %123
//   "expression"   expression exacte (espaces compris)
//   -mot           exclusion (le mot ne doit PAS apparaître)
//   champ:valeur   cibler un champ : tech: lieu: ref: cat: contact:
// La recherche EV (basicAutoComplete) reçoit la requête NETTOYÉE (mots
// positifs sans opérateurs) — son moteur ne les comprend pas.

/** Parse la requête en termes structurés [{neg, field, parts[]}]. @author QRO */
function _srParseQuery(query) {
  const terms = [];
  const rx = /"([^"]+)"|(\S+)/g;
  let m;
  while ((m = rx.exec(String(query || '')))) {
    let raw, exact = false;
    if (m[1] !== undefined) { raw = m[1]; exact = true; }
    else raw = m[2];
    let neg = false, field = null;
    if (!exact) {
      if (raw.startsWith('-') && raw.length > 1) { neg = true; raw = raw.slice(1); }
      const fm = raw.match(/^(tech|lieu|ref|cat|contact):(.*)$/i);
      if (fm) { field = fm[1].toLowerCase(); raw = fm[2]; }
    }
    if (!raw) continue;
    // % = joker → morceaux à trouver DANS L'ORDRE ; expression exacte = 1 morceau
    const parts = exact ? [_srNorm(raw)] : _srNorm(raw).split('%').filter(Boolean);
    if (!parts.length) continue;
    terms.push({ neg, field, parts });
  }
  return terms;
}

// les morceaux (joker %) doivent apparaître dans l'ordre dans le texte normalisé
function _srPartsMatch(hayNorm, parts) {
  let idx = 0;
  for (const p of parts) {
    const i = hayNorm.indexOf(p, idx);
    if (i < 0) return false;
    idx = i + p.length;
  }
  return true;
}

// texte du champ ciblé (champ:) ou botte de foin complète
function _srTermHay(iv, field, hayNormFull) {
  switch (field) {
    case 'tech':    return _srNorm(iv.techName || '');
    case 'lieu':    return _srNorm([iv.bulleLieu, iv.resVille, iv.resRue].filter(Boolean).join(' '));
    case 'ref':     return _srNorm(String(iv.ref || ''));
    case 'cat':     return _srNorm([iv.categoryLine, (typeof deriveShortTitle === 'function' ? deriveShortTitle(iv) : ''), iv.resCategorie].filter(Boolean).join(' '));
    case 'contact': return _srNorm(iv.bulleContact || '');
    default:        return hayNormFull;
  }
}

/** Tous les termes doivent matcher (les -mot ne doivent PAS matcher). */
function _srQueryMatches(iv, terms) {
  const hayFull = _srNorm(_srIvHaystack(iv));
  for (const t of terms) {
    const ok = _srPartsMatch(_srTermHay(iv, t.field, hayFull), t.parts);
    if (t.neg ? ok : !ok) return false;
  }
  return true;
}

// premier morceau positif (pour l'extrait « Lié à » et la surbrillance)
function _srFirstNeedle(terms) {
  for (const t of terms) if (!t.neg && t.parts.length) return t.parts[0];
  return '';
}

// requête nettoyée pour EV : mots positifs non ciblés, jokers retirés
function _srCleanQueryForEV(query) {
  const words = [];
  for (const t of _srParseQuery(query)) {
    if (t.neg || t.field) continue;
    words.push(t.parts.join(' '));
  }
  const clean = words.join(' ').trim();
  return clean || String(query || '').replace(/[%"-]/g, ' ').replace(/\s+/g, ' ').trim();
}

function _srCacheMatches(query) {
  if (!_searchCacheList.length) return [];
  // v2026.5.46 — opérateurs + PLUS de plafond à 50 (le rendu pagine 15
  // par 15 au scroll, l'index est en mémoire → instantané).
  const terms = _srParseQuery(query);
  if (!terms.length) return [];
  const needle = _srFirstNeedle(terms);
  const hits = _searchCacheList.filter(iv => _srQueryMatches(iv, terms));
  return hits.map(iv => {
    const fields = [["Réf", iv.ref], ["Catégorie", deriveShortTitle(iv)],
      ["Contact", iv.bulleContact], ["Adresse", iv.bulleLieu], ["Tech", iv.techName],
      ["Horaire", (iv.startTime || "") + (iv.endTime ? "–" + iv.endTime : "")],
      ["Jour", _srDayWithWeekday(iv.currentDate || iv._day)]];
    // si le terme est dans la description → on l'affiche en contexte (« Lié à »).
    const snip = _srLinkSnippet(iv, needle || query);
    if (snip) fields.push(["Lié à", snip]);
    return {
      source: "cache", table: "SD_REQUEST", ref: iv.ref ? String(iv.ref) : null,
      typeLabel: "Cache — " + deriveShortTitle(iv), icon: "",
      fields: fields.filter(([k, v]) => v != null && v !== "" && v !== "–"),
      day: iv.currentDate || iv._day || null, statusLabel: _srHumanStatus(iv), open: { ref: iv.ref }, raw: iv,
    };
  });
}
function _srIsLocationQuery(q) {
  if (!_searchCacheList.length || !q || q.trim().length < 3) return false;
  const n = _srNorm(q);
  return _searchCacheList.some(iv => iv.bulleLieu && _srNorm(iv.bulleLieu).includes(n));
}

async function _srDoSearch(query) {
  const mySeq = ++_searchSeq;             // jeton anti-périmé (toutes branches)
  await _srBuildCacheIndex(false);
  if (mySeq !== _searchSeq) return;
  // v2026.5.46 — EV reçoit la requête NETTOYÉE (sans opérateurs % " - champ:)
  const evQuery = _srCleanQueryForEV(query);
  if (_srIsLocationQuery(evQuery)) {
    _srRender(_srCacheMatches(query), query, "résultats du cache (lieu)");  // le rendu gère la roue
    return;
  }
  // requête purement négative / ciblée → rien d'exploitable pour EV : cache seul
  if (evQuery.length < SEARCH_MIN_CHARS) {
    _srRender(_srCacheMatches(query), query, "résultats du cache");
    return;
  }
  if (_searchInflight) { try { _searchInflight.abort(); } catch (e) {} }
  _searchInflight = new AbortController();
  _srSpin(true);
  const ev = await _srSearchEV(evQuery, _searchInflight.signal);
  if (ev === null) return;                 // annulée par une frappe plus récente
  if (mySeq !== _searchSeq) return;        // réponse périmée
  const evRefs = new Set(ev.filter(it => it.ref).map(it => String(it.ref)));
  const extras = _srCacheMatches(query).filter(it => !it.ref || !evRefs.has(String(it.ref)));
  _srRender([...ev, ...extras], query);    // la roue tourne pendant le rendu progressif
}

// v2026.5.46 — iv MINIMALE à partir d'un résultat de recherche (pour le
// tooltip de survol quand l'iv n'est pas dans le cache). ficheFetched=true pour
// éviter le « Chargement des détails… » trompeur.
function _srMinimalIvFromResult(it) {
  const get = (k) => { const f = (it.fields || []).find(([kk]) => kk === k); return f ? f[1] : null; };
  return {
    ref: it.ref || null,
    type: "AL-Intervention",
    status: it.statusLabel || null,
    bulleContact: get("Demandeur") || get("Contact") || get("Bénéficiaire") || null,
    bulleLieu: get("Adresse") || null,
    label: get("Catégorie") || it.typeLabel || null,
    currentDate: it.day || null,
    ficheFetched: true,
  };
}

// v2026.5.46 — construit une carte de résultat (extrait pour le rendu
// progressif). Survol = tooltip de l'intervention ; boutons EasyVista / Jour.
function _srBuildCard(it) {
  const card = document.createElement("div"); card.className = "sr-card";
  const main = document.createElement("div"); main.className = "sr-main";
  main.innerHTML = it.fields.map(([k, v]) => `<div class="sr-field"><span class="sr-k">${escapeHtml(k)}</span><span class="sr-v">${escapeHtml(v == null || v === "" ? "—" : String(v))}</span></div>`).join("");
  if (it.statusLabel) {
    const sk = _srStatusKey(it.statusLabel); const w = _srWhenOf(it.day);
    let acc = sk; if (sk === "cours") acc = (w === "past") ? "retard" : "cours";
    card.classList.add("acc-" + acc);
    // v2026.5.46 — badge si l'intervention tombe sur le JOUR AFFICHÉ
    // (le badge À venir/Aujourd'hui/Passé reste calé sur la date réelle).
    const _hereIso = _srFrToIso(it.day);
    const _onShownDay = !!(_hereIso && state.currentDate && _hereIso === state.currentDate);
    const badge = `<div class="sr-status-row"><span class="sr-pill s-${sk}">${_srStatusIcon(sk)} ${escapeHtml(it.statusLabel)}</span>${w ? `<span class="sr-when w-${w}">${_srWhenLabel(w)}</span>` : ""}${_onShownDay ? `<span class="sr-when w-here" title="Cette intervention est sur le jour actuellement affiché">📍 Jour affiché</span>` : ""}</div>`;
    main.insertAdjacentHTML("afterbegin", badge);
  }
  const actions = document.createElement("div"); actions.className = "sr-actions";
  const evBtn = document.createElement("button"); evBtn.className = "sr-btn"; evBtn.textContent = "EasyVista ↗";
  evBtn.addEventListener("click", () => { _srOpenRecord(it); _srClear(); }); actions.appendChild(evBtn);
  if (it.day) {
    const iso = _srFrToIso(it.day);
    if (iso) {
      const dBtn = document.createElement("button"); dBtn.className = "sr-btn"; dBtn.textContent = "Jour ↗"; dBtn.title = `Ouvrir le planning du ${it.day}`;
      const ref = it.ref;
      dBtn.addEventListener("click", () => { _srClear(); _srRequestHighlight(iso, ref); });
      actions.appendChild(dBtn);
    }
  }
  // v2026.5.46 — au survol d'un résultat d'intervention, afficher le popup
  // de l'intervention après 0,5 s (showTooltip a déjà ce délai). Source de l'iv :
  // l'iv complète du cache si dispo (it.raw / par réf), sinon une iv MINIMALE
  // construite depuis les champs du résultat → marche aussi pour un résultat EV
  // pur (pas encore dans le cache).
  let ivForTip = null;
  if (it.table === "SD_REQUEST") {
    ivForTip = (it.raw && it.raw.actionId) ? it.raw
      : (it.ref && _searchCacheByRef.get(String(it.ref)))
      || _srMinimalIvFromResult(it);
  }
  if (ivForTip && typeof showTooltip === "function") {
    // v2026.5.46 — le tooltip s'ancre sur le POPUP de recherche (droite en
    // priorité, gauche sinon), jamais par-dessus les autres résultats.
    card.addEventListener("mouseenter", (ev) => {
      const box = document.getElementById("ev-search-results") || card;
      showTooltip(ev, ivForTip, box, { forceSides: true, anchorRowEl: card });
    });
    card.addEventListener("mouseleave", () => { if (typeof hideTooltip === "function") hideTooltip(); });
  }
  card.appendChild(main); card.appendChild(actions); return card;
}

// v2026.5.46 — rendu PROGRESSIF : on prépare la séquence ordonnée (entêtes +
// séparateurs + cartes), puis on l'ajoute par petits paquets via rAF. La roue
// (#ev-search-spin) tourne tant que tout n'est pas affiché → l'utilisateur voit
// que ce n'est pas fini et les résultats apparaissent au fur et à mesure.
function _srRender(items, query, note) {
  const box = document.getElementById("ev-search-results");
  if (!box) return;
  const mySeq = _searchSeq;
  box.innerHTML = "";
  _srShowResults(true);
  if (!items.length) {
    const m = document.createElement("div"); m.className = "sr-empty";
    m.textContent = `Aucun résultat pour « ${query} »`;
    box.appendChild(m); _srSpin(false); _srPositionResults(); return;
  }
  let ivs = items.filter(it => it.table === "SD_REQUEST");
  const others = items.filter(it => it.table !== "SD_REQUEST");
  const ops = [];
  const groups = new Map();
  for (const it of others) { if (!groups.has(it.typeLabel)) groups.set(it.typeLabel, []); groups.get(it.typeLabel).push(it); }
  for (const [label, list] of groups) {
    ops.push({ head: `${list[0].icon ? `<img src="${escapeHtml(list[0].icon)}" class="sr-ic">` : ""}${escapeHtml(label)} — ${list.length}`, right: (list[0].source || "").toUpperCase() });
    for (const it of list) ops.push({ card: it });
  }
  // v2026.5.46 — PAGINATION 15 par 15 au scroll (plus de troncature) :
  //   • les interventions À VENIR / aujourd'hui d'abord (tri croissant), puis
  //     « sans date » ; le PASSÉ est REPLIÉ par défaut derrière un en-tête
  //     cliquable et ne consomme pas la liste tant qu'il est fermé ;
  //   • 15 cartes max sont rendues ; arrivé en bas, une barre de chargement
  //     apparaît (~300 ms) puis les 15 suivantes s'ajoutent, jusqu'au bout.
  if (ivs.length) {
    const fut = ivs.filter(it => { const w = _srWhenOf(it.day); return w && w !== "past"; }).sort((a, b) => (_srParseFrDate(a.day) || 0) - (_srParseFrDate(b.day) || 0));
    const past = ivs.filter(it => _srWhenOf(it.day) === "past").sort((a, b) => (_srParseFrDate(b.day) || 0) - (_srParseFrDate(a.day) || 0));
    const nodate = ivs.filter(it => !_srWhenOf(it.day));
    if (fut.length) { ops.push({ head: `À venir / aujourd'hui — ${fut.length}` }); for (const it of fut) ops.push({ card: it }); }
    if (nodate.length) { ops.push({ head: `Sans date — ${nodate.length}` }); for (const it of nodate) ops.push({ card: it }); }
    _srPager.pastCards = past;
  } else {
    _srPager.pastCards = [];
  }
  _srPager.seq = mySeq;
  _srPager.box = box;
  _srPager.queue = ops;
  _srPager.budget = SR_PAGE_SIZE;
  _srPager.pastOpen = false;
  _srPager.pastHead = null;
  _srPager.loading = false;
  _srSpin(true);
  // scroll near-bottom → page suivante (handler unique, réassigné à chaque rendu)
  box.onscroll = () => {
    if (_srPager.seq !== _searchSeq) return;
    if (box.scrollTop + box.clientHeight >= box.scrollHeight - 60) _srPagerLoadMore();
  };
  _srPagerStep();
}

// ── v2026.5.46 — pager de la liste de résultats ──────────────────────────
const SR_PAGE_SIZE = 15;     // cartes par « page » de scroll
let _srPager = { seq: -1, box: null, queue: [], pastCards: [], pastOpen: false, pastHead: null, budget: SR_PAGE_SIZE, loading: false };

function _srPagerRenderOp(op) {
  const box = _srPager.box;
  if (op.head !== undefined) {
    const h = document.createElement("div"); h.className = "sr-head";
    h.innerHTML = `<span>${op.head}</span>${op.right ? `<span class="sr-src">${escapeHtml(op.right)}</span>` : ""}`;
    box.appendChild(h);
  } else if (op.sep) {
    const s = document.createElement("div"); s.className = "sr-sep"; s.textContent = op.sep; box.appendChild(s);
  } else if (op.note) {
    const n = document.createElement("div"); n.className = "sr-note"; n.textContent = "ℹ " + op.note; box.appendChild(n);
  } else if (op.card) {
    box.appendChild(_srBuildCard(op.card));
  }
}

// nb de cartes encore non rendues dans la file courante
function _srPagerRemaining() {
  return _srPager.queue.filter(op => op.card).length;
}

// retire l'indicateur « N de plus » / barre de chargement
function _srPagerClearFooter() {
  const box = _srPager.box; if (!box) return;
  box.querySelectorAll(".sr-loadmore").forEach(el => el.remove());
}

// pose le pied de liste : « ▼ N de plus » (sentinelle visuelle du scroll,
// cliquable aussi). Si la liste ne déborde pas encore (pas de scrollbar →
// impossible de scroller), on charge automatiquement la page suivante.
function _srPagerFooter() {
  _srPagerClearFooter();
  const rest = _srPagerRemaining();
  if (!rest) return;
  const f = document.createElement("div");
  f.className = "sr-loadmore";
  f.style.cursor = "pointer";
  f.title = "Afficher les suivants";
  f.innerHTML = `<span class="sr-loadmore-hint">▼ ${rest} de plus — faire défiler</span>`;
  f.addEventListener("click", () => _srPagerLoadMore());
  _srPager.box.appendChild(f);
  const box = _srPager.box;
  if (box.scrollHeight <= box.clientHeight + 4) {
    setTimeout(() => { if (_srPager.seq === _searchSeq) _srPagerLoadMore(); }, 60);
  }
}

// en-tête « Planifiée (passé) — N », repliée par défaut, cliquable
function _srPagerPastHeader() {
  if (_srPager.pastHead || !_srPager.pastCards.length) return;
  const h = document.createElement("div");
  h.className = "sr-head sr-past-toggle";
  h.setAttribute("role", "button");
  h.innerHTML = `<span>▸ Planifiée (passé) — ${_srPager.pastCards.length}</span><span class="sr-src">AFFICHER</span>`;
  h.addEventListener("click", () => _srPagerTogglePast());
  _srPager.box.appendChild(h);
  _srPager.pastHead = h;
}

function _srPagerTogglePast() {
  const p = _srPager;
  if (!p.pastHead) return;
  if (!p.pastOpen) {
    p.pastOpen = true;
    p.pastHead.innerHTML = `<span>▾ Planifiée (passé) — ${p.pastCards.length}</span><span class="sr-src">MASQUER</span>`;
    p.queue = p.pastCards.map(it => ({ card: it }));
    p.budget = SR_PAGE_SIZE;
    _srPagerStep();
  } else {
    p.pastOpen = false;
    p.pastHead.innerHTML = `<span>▸ Planifiée (passé) — ${p.pastCards.length}</span><span class="sr-src">AFFICHER</span>`;
    // retire les cartes passé rendues (tout ce qui suit l'en-tête)
    let el = p.pastHead.nextSibling;
    while (el) { const nx = el.nextSibling; el.remove(); el = nx; }
    p.queue = [];
    _srPagerClearFooter();
  }
}

// rendu progressif (paquets de 2 / 45 ms) jusqu'au plafond de la page
function _srPagerStep() {
  const p = _srPager;
  if (p.seq !== _searchSeq || !p.box) return;   // recherche plus récente
  _srPagerClearFooter();
  const CHUNK = 2, DELAY = 45;
  let n = 0;
  while (n < CHUNK && p.queue.length) {
    const op = p.queue[0];
    if (op.card) {
      if (p.budget <= 0) break;                 // plafond de page atteint
      p.budget--;
    }
    p.queue.shift();
    _srPagerRenderOp(op);
    n++;
  }
  _srPositionResults();
  if (p.queue.length && p.budget > 0) { setTimeout(_srPagerStep, DELAY); return; }
  // fin de page (plafond) ou fin de file
  if (!p.queue.length && !p.pastOpen) _srPagerPastHeader();   // file principale finie → en-tête passé
  _srPagerFooter();
  _srSpin(false);
}

// arrivée en bas : barre de chargement brève (retour visuel) puis +15
function _srPagerLoadMore() {
  const p = _srPager;
  if (p.loading || p.seq !== _searchSeq) return;
  if (!_srPagerRemaining()) return;
  p.loading = true;
  _srPagerClearFooter();
  const bar = document.createElement("div");
  bar.className = "sr-loadmore";
  bar.innerHTML = '<div class="sr-loadmore-bar"></div>';
  p.box.appendChild(bar);
  p.box.scrollTop = p.box.scrollHeight;         // garder la barre visible
  setTimeout(() => {
    if (p.seq !== _searchSeq) { p.loading = false; return; }
    bar.remove();
    p.budget = SR_PAGE_SIZE;
    p.loading = false;
    _srPagerStep();
  }, 300);
}

let _srOpening = false;
async function _srOpenRecord(it) {
  if (_srOpening) return; _srOpening = true;
  try {
    const sess = state.session;
    if (!sess || !sess.origin || !sess.phpsessid) { LOG.warn("search", "ouverture impossible : pas de session"); return; }
    let pk = it.open && it.open.pk, guid = it.open && it.open.guid, checksum = it.open && it.open.checksum;
    if ((!pk || !guid || !checksum) && it.open && it.open.ref) {
      const r = await fetch(`${sess.origin}/api/v1/internal/search/basicAutoComplete?search=${encodeURIComponent(it.open.ref)}&PHPSESSID=${encodeURIComponent(sess.phpsessid)}`, { credentials: "include" });
      const j = await r.json();
      const meta = j && j.data && j.data.METAOBJECTS && j.data.METAOBJECTS[0]; const line = meta && meta.LINES && meta.LINES[0];
      if (meta && line) { pk = line.PK; guid = meta.TYPE_GUID; checksum = line.CHECKSUM; }
    }
    if (!pk || !guid || !checksum) { LOG.warn("search", "pk/guid/checksum manquants", it.open); return; }
    const rh = await fetch(`${sess.origin}/api/v1/internal/search/redirectHeader?pk=${encodeURIComponent(pk)}&guid=${encodeURIComponent(guid)}&checksum=${encodeURIComponent(checksum)}&PHPSESSID=${encodeURIComponent(sess.phpsessid)}`, { credentials: "include" });
    const txt = await rh.text();
    let target; try { const j = JSON.parse(txt); target = (typeof j === "string") ? j : (j.url || j.URL || ""); } catch (e) { target = txt; }
    target = String(target || "").replace(/^"+|"+$/g, "").trim();
    if (target && !/^https?:\/\//i.test(target)) target = sess.origin.replace(/\/+$/, "") + "/" + target.replace(/^\/+/, "");
    if (!target || !/^https?:\/\//i.test(target)) { LOG.warn("search", "redirectHeader sans URL exploitable"); return; }
    window.open(target, "_blank", "noopener");
  } catch (e) { LOG.warn("search", "openRecord", { err: e && e.message }); }
  finally { _srOpening = false; }
}

function _srSpin(on) { const s = document.getElementById("ev-search-spin"); if (s) s.classList.toggle("hidden", !on); }
function _srShowResults(on) {
  const b = document.getElementById("ev-search-results"); if (!b) return;
  // v2026.5.46 — PORTAIL : on déplace le popup dans <body> pour qu'il ne
  // soit ni rogné par l'overflow de la sidebar (vue horizontale), ni piégé dans
  // un contexte d'empilement → garanti au PREMIER PLAN (position fixed + z-index).
  if (on && b.parentNode !== document.body) document.body.appendChild(b);
  b.classList.toggle("hidden", !on);
  if (on) _srPositionResults();
}
// v2026.5.46 — positionne le popup : ancré sous la barre (vue classique),
// ou en FIXED à DROITE de la barre (vue horizontale, barre dans la sidebar).
function _srPositionResults() {
  const b = document.getElementById("ev-search-results");
  const zone = document.getElementById("search-zone");
  if (!b || !zone) return;
  const horiz = document.documentElement.classList.contains("view-horizontal");
  if (horiz) {
    // Popup en OVERLAY, en haut à droite : juste à droite de la sidebar et calé
    // au sommet de la zone planning → passe AU-DESSUS des noms/interventions.
    const sidebar = document.getElementById("horizontal-sidebar");
    const bar = zone.querySelector(".search-bar") || zone;
    const tb = document.querySelector("header.topbar");
    const topbarBottom = tb ? Math.round(tb.getBoundingClientRect().bottom) : 56;
    const left = Math.round((sidebar ? sidebar.getBoundingClientRect().right : bar.getBoundingClientRect().right) + 12);
    const top = topbarBottom + 8;
    const width = Math.max(300, Math.min(640, window.innerWidth - left - 16));
    b.style.left = left + "px";
    b.style.top = top + "px";
    b.style.right = "auto";
    b.style.width = width + "px";
    b.style.maxHeight = Math.max(200, window.innerHeight - top - 16) + "px";
  } else {
    // Vue classique : popup ancré SOUS la barre (coords fixed car portalisé).
    const bar = zone.querySelector(".search-bar") || zone;
    const r = bar.getBoundingClientRect();
    const width = Math.max(360, Math.round(r.width));
    let left = Math.round(r.left);
    if (left + width > window.innerWidth - 12) left = Math.max(12, window.innerWidth - 12 - width);
    const top = Math.round(r.bottom + 6);
    b.style.left = left + "px";
    b.style.top = top + "px";
    b.style.right = "auto";
    b.style.width = width + "px";
    b.style.maxHeight = Math.max(180, window.innerHeight - top - 16) + "px";
  }
}
// v2026.5.46 — hauteur réelle de la topbar → variable CSS (--topbar-h) pour
// que la ligne sticky stats+recherche se cale juste dessous.
// v2026.5.46 — recalcule l'empilement collant en haut :
//   --topbar-h   = hauteur de la topbar
//   --stack-top  = topbar + hauteur des bandeaux VISIBLES (session/EV/reconnexion/
//                  progress) → la ligne stats+recherche (classique) et la sidebar
//                  (horizontal) se collent JUSTE dessous, sans chevauchement.
function _srSyncStickyOffsets() {
  const tb = document.querySelector("header.topbar") || document.querySelector(".topbar");
  const tbH = tb ? tb.offsetHeight : 56;
  let extra = 0;
  // v2026.5.46 — la barre de progression NE compte PLUS dans --stack-top :
  // elle est désormais SOUS la ligne stats+recherche (#topline), donc elle ne
  // pousse plus #topline vers le bas. Seuls les bandeaux session/EV comptent.
  ["session-expired-banner", "ev-unreachable-banner", "session-reconnecting-banner", "session-reconnect-failed-banner"]
    .forEach(id => {
      const el = document.getElementById(id);
      if (el && !el.classList.contains("hidden") && el.offsetParent !== null) extra += el.offsetHeight;
    });
  const root = document.documentElement.style;
  root.setProperty("--topbar-h", tbH + "px");
  root.setProperty("--topbar-height", tbH + "px");
  root.setProperty("--stack-top", (tbH + extra) + "px");
  // v2026.5.46 — hauteur de #topline : la barre de progression se cale juste
  // dessous (top: --stack-top + --topline-h). 0 si #topline masqué (vue horizontale).
  const tl = document.getElementById("topline");
  const tlH = (tl && tl.offsetParent !== null) ? tl.offsetHeight : 0;
  root.setProperty("--topline-h", tlH + "px");
  // v2026.5.47 — largeur RÉELLE de la sidebar horizontale → --sidebar-w :
  // la barre de progression se cale à sa DROITE (au-dessus du contenu, plus
  // par-dessus la sidebar/zone de reconnexion). Mesure robuste aux breakpoints
  // (200/160px) et au zoom. On ne l'écrit que si la sidebar est visible, sinon
  // on garde le repli CSS (200px) — évite un left:0 transitoire qui rechevaucherait.
  const sb = document.getElementById("horizontal-sidebar");
  const sbW = (sb && sb.offsetParent !== null) ? sb.offsetWidth : 0;
  if (sbW > 0) root.setProperty("--sidebar-w", sbW + "px");
}
// alias rétro-compat (anciens appels)
function _srSyncTopbarHeight() { _srSyncStickyOffsets(); }
// ───────────────────────────────────────────────────────────────────────────
// v2026.5.46 — MISE EN AVANT (refonte propre). Principe robuste : on ne
// devine plus le timing du rendu. On enregistre une DEMANDE de surbrillance
// (réf + date), on navigue si besoin via loadForDate, et c'est le RENDU
// (renderFromData → _srApplyPendingHighlight) qui applique la surbrillance dès
// que la ligne d'intervention existe dans le DOM. Repli : ré-essais courts.
// ───────────────────────────────────────────────────────────────────────────
let _srPendingHighlight = null;   // { iso, ref, scrolled, until }
let _srHlRetry = 0;
let _srHlEndTimer = null;

function _srCssEsc(s) {
  return (window.CSS && CSS.escape) ? CSS.escape(String(s)) : String(s).replace(/["\\]/g, "\\$&");
}
// résout l'actionId vivant (rendu courant) par la réf
function _srLiveActionIdForRef(ref) {
  if (!ref || !state.currentData || !state.currentData.techs) return null;
  for (const t of state.currentData.techs) {
    for (const iv of (t.interventions || [])) {
      if (iv.ref && String(iv.ref) === String(ref)) return iv.actionId;
    }
  }
  return null;
}
// Trouve la ligne d'intervention dans le DOM par 3 stratégies (de la plus fiable
// à la plus permissive) : data-ref → data-action-id → SCAN du texte (la réf est
// affichée dans la carte). La 3e garantit de trouver si l'iv est rendue.
// IMPORTANT : ne retenir que les éléments RÉELLEMENT VISIBLES. En vue classique
// les .iv-mini-card (vue horizontale) peuvent rester en display:none dans le
// DOM → scroller/surligner un élément caché ne fait rien à l'écran (bug v.préc).
function _srIvElVisible(el) {
  return !!(el && el.offsetParent !== null && el.getClientRects().length > 0);
}
function _srFindIvEl(ref) {
  if (!ref) return null;
  const r = _srCssEsc(ref);
  const pick = (sel) => { for (const el of document.querySelectorAll(sel)) if (_srIvElVisible(el)) return el; return null; };
  let el = pick(`.intervention-v2[data-ref="${r}"], .iv-mini-card[data-ref="${r}"]`);
  if (el) return el;
  const aid = _srLiveActionIdForRef(ref);
  if (aid) {
    const a = _srCssEsc(aid);
    el = pick(`.intervention-v2[data-action-id="${a}"], .iv-mini-card[data-action-id="${a}"]`);
    if (el) return el;
  }
  const needle = String(ref);
  for (const row of document.querySelectorAll(".intervention-v2, .iv-mini-card")) {
    if (_srIvElVisible(row) && row.textContent && row.textContent.indexOf(needle) >= 0) return row;
  }
  return null;
}

// Demande de mise en avant depuis un résultat de recherche (bouton « Jour ↗ »).
function _srRequestHighlight(iso, ref) {
  if (!ref) return;
  // v2026.5.46 — la demande reste ACTIVE 15 s : chaque re-rendu du
  // pipeline (fresh, dossier, séquentiel) détruit/reconstruit les cartes, on
  // ré-applique donc la surbrillance sur le nouvel élément à chaque rendu.
  _srEndHighlight();
  _srPendingHighlight = { iso: iso || null, ref: String(ref), scrolled: false, until: Date.now() + 15000 };
  _srHlRetry = 0;
  const sameDay = !iso || (state && state.currentDate === iso);
  if (sameDay) {
    _srApplyPendingHighlight();                 // déjà le bon jour → tout de suite
  } else if (typeof loadForDate === "function") {
    LOG.info("search", `mise en avant : navigation vers ${iso} pour réf=${ref}`);
    loadForDate(iso);                           // renderFromData appliquera la demande
  }
}

// Applique la demande en attente : scroll visible + contour couleur (retiré au
// survol). Appelé en fin de rendu (renderFromData) ET en repli temporisé.
function _srApplyPendingHighlight() {
  const req = _srPendingHighlight;
  if (!req || !req.ref) return;
  // si une date précise est visée, n'appliquer que si on est bien dessus
  if (req.iso && state && state.currentDate && state.currentDate !== req.iso) return;
  const el = _srFindIvEl(req.ref);
  if (!el) {
    if (_srHlRetry++ < 25) { setTimeout(_srApplyPendingHighlight, 120); return; }  // rendu pas encore prêt
    // diagnostic : pourquoi on ne trouve pas la ligne ?
    const all = document.querySelectorAll(".intervention-v2, .iv-mini-card");
    const sample = Array.from(all).slice(0, 4).map(r => (r.dataset.ref || r.dataset.actionId || (r.textContent || "").trim().slice(0, 24)));
    LOG.warn("search", `mise en avant : réf=${req.ref} INTROUVABLE`, { currentDate: state && state.currentDate, isoVisé: req.iso, lignesRendues: all.length, exemples: sample });
    _srPendingHighlight = null;
    return;
  }
  _srHlRetry = 0;
  if (Date.now() > req.until) { _srEndHighlight(); return; }   // échéance passée
  // v2026.5.46 — la demande N'est PAS consommée : les re-rendus du
  // pipeline détruisent l'élément surligné, renderFromData nous rappelle et on
  // re-pose la classe sur le NOUVEL élément. La surbrillance ne disparaît plus
  // « toute seule » : fin au clic sur la carte, ou à l'échéance (15 s).
  el.classList.add("iv-search-highlight");
  el.addEventListener("click", _srEndHighlight, { once: true });
  // UN SEUL défilement animé (le premier). Ensuite, seulement si un re-rendu a
  // déplacé le layout au point de sortir la carte de l'écran → recalage
  // INSTANTANÉ (pas d'animation → la page ne « danse » plus).
  // v2026.5.46 — block:"start" + scroll-margin-top (topbar + bandeaux +
  // ligne stats/recherche) : la carte n'est jamais cachée derrière les barres.
  const scrollTarget = el.closest(".card") || el;
  if (!req.scrolled) {
    req.scrolled = true;
    try { scrollTarget.scrollIntoView({ behavior: "smooth", block: "start", inline: "nearest" }); }
    catch (e) { try { scrollTarget.scrollIntoView(); } catch (_) {} }
  } else {
    const r = scrollTarget.getBoundingClientRect();
    if (r.bottom < 0 || r.top > window.innerHeight) {
      try { scrollTarget.scrollIntoView({ behavior: "auto", block: "start", inline: "nearest" }); } catch (e) { /* ignore */ }
    }
  }
  // fin de la mise en avant à l'échéance (timer global unique, re-armé à
  // chaque ré-application).
  if (_srHlEndTimer) clearTimeout(_srHlEndTimer);
  _srHlEndTimer = setTimeout(_srEndHighlight, Math.max(250, req.until - Date.now()));
  const _r = el.getBoundingClientRect();
  LOG.info("search", `mise en avant : réf=${req.ref} surlignée`,
    { classe: el.className, visible: _srIvElVisible(el), top: Math.round(_r.top), height: Math.round(_r.height) });
}

// fin de la mise en avant : demande annulée + classe retirée partout.
function _srEndHighlight() {
  _srPendingHighlight = null;
  if (_srHlEndTimer) { clearTimeout(_srHlEndTimer); _srHlEndTimer = null; }
  document.querySelectorAll(".iv-search-highlight").forEach(e => e.classList.remove("iv-search-highlight"));
}
function _srClear() {
  const inp = document.getElementById("ev-search"); if (inp) inp.value = "";
  _srShowResults(false); _srSpin(false);
  const c = document.getElementById("ev-search-clear"); if (c) c.classList.add("hidden");
}
// v2026.5.46 — ferme les popups TRANSITOIRES (tooltip de survol + grande
// popup ancrée non épinglée) au clic dans la recherche. On NE TOUCHE PAS aux
// popups épinglés flottants (.pinned-popup) ni au dock (.pinned-popup-reduced).
// v2026.5.46 — relance la recherche (réaffiche le popup) si la zone contient
// déjà une requête et que le popup est fermé. Utilisé au re-focus / re-survol.
function _srReopenIfQuery() {
  const box = document.getElementById("ev-search-results");
  if (box && !box.classList.contains("hidden")) return;   // déjà affiché
  const inp = document.getElementById("ev-search");
  const v = inp && inp.value.trim();
  if (v && v.length >= SEARCH_MIN_CHARS) _srDoSearch(v);
}
// v2026.5.46 — programme la fermeture du popup de recherche ~0,5 s après
// que la souris est passée sur une intervention DU PLANNING (comme un tooltip).
let _srCloseTimer = null;
function _srScheduleCloseFromPlanning() {
  const box = document.getElementById("ev-search-results");
  if (!box || box.classList.contains("hidden")) return;
  if (_srCloseTimer) clearTimeout(_srCloseTimer);
  _srCloseTimer = setTimeout(() => { _srShowResults(false); _srCloseTimer = null; }, 500);
}
function _srCancelCloseTimer() { if (_srCloseTimer) { clearTimeout(_srCloseTimer); _srCloseTimer = null; } }

// v2026.5.46 — fermeture GROUPÉE « popup de recherche + tooltip issu de la
// recherche ». Tant que la souris est dans l'un OU l'autre, on annule. Quand
// elle quitte les DEUX, on ferme après 1 s (le tooltip non épinglé suit ;
// les popups épinglés / le dock sont conservés = « le reste »).
let _srGroupCloseTimer = null;
function _srGroupCancelClose() {
  if (_srGroupCloseTimer) { clearTimeout(_srGroupCloseTimer); _srGroupCloseTimer = null; }
}
function _srGroupScheduleClose() {
  const box = document.getElementById("ev-search-results");
  if (!box || box.classList.contains("hidden")) return;   // popup déjà fermé
  _srGroupCancelClose();
  _srGroupCloseTimer = setTimeout(() => {
    _srGroupCloseTimer = null;
    _srShowResults(false);                                  // ferme le popup de recherche
    const tip = document.getElementById("tooltip");
    if (tip && tip.dataset && tip.dataset.fromSearch === "1" && typeof hideTooltip === "function") {
      hideTooltip();                                        // ferme le tooltip (sauf s'il a été épinglé)
    }
  }, 1000);
}

function _srCloseTransientPopups() {
  try { if (typeof hideTooltip === "function") hideTooltip({ force: true }); } catch (e) {}
  // Popups ancrées ouvertes mais NON épinglées (sécurité — celles épinglées et
  // celles réduites dans le dock sont conservées).
  document.querySelectorAll(".pinned-popup:not(.pinned-popup-reduced):not(.pinned-popup-pinned)").forEach(p => {
    // une popup réellement épinglée porte .pinned-popup-pinned OU est suivie
    // dans pinnedPopups ; on ne ferme que celles qui ne sont ni l'un ni l'autre.
    try {
      const tracked = (typeof pinnedPopups !== "undefined") && pinnedPopups.some(pp => pp.el === p);
      if (!tracked) p.remove();
    } catch (e) {}
  });
}
function initSearchBar() {
  if (_searchInited) return;
  const inp = document.getElementById("ev-search");
  const zone = document.getElementById("search-zone");
  if (!inp || !zone) return;
  _searchInited = true;
  inp.addEventListener("input", () => {
    const v = inp.value.trim();
    const c = document.getElementById("ev-search-clear"); if (c) c.classList.toggle("hidden", v.length === 0);
    // v2026.5.46 — CHAQUE frappe arrête immédiatement la recherche en cours :
    // on invalide le jeton (réponses périmées ignorées), on abort le fetch EV en
    // vol, on coupe la roue et on annule le debounce. La recherche n'est (re)lancée
    // qu'après une pause de frappe → « cherche quand j'ai fini d'écrire ».
    _searchSeq++;
    if (_searchInflight) { try { _searchInflight.abort(); } catch (e) {} _searchInflight = null; }
    if (_searchDebTimer) clearTimeout(_searchDebTimer);
    _srSpin(false);
    if (v.length < SEARCH_MIN_CHARS) { _srShowResults(false); return; }
    _searchDebTimer = setTimeout(() => _srDoSearch(v), SEARCH_DEBOUNCE_MS);
  });
  inp.addEventListener("keydown", (e) => {
    if (e.key === "Enter") { if (_searchDebTimer) clearTimeout(_searchDebTimer); const v = inp.value.trim(); if (v.length >= SEARCH_MIN_CHARS) _srDoSearch(v); }
    // v2026.5.46 — Échap : ferme le popup de recherche (sans vider le texte,
    // pour pouvoir le rouvrir) + ferme les popups non épinglés.
    else if (e.key === "Escape") { _srShowResults(false); _srCloseTransientPopups(); }
  });
  inp.addEventListener("focus", () => {
    _srBuildCacheIndex(false);
    _srCloseTransientPopups();
    // v2026.5.46 — re-clic dans la zone avec une recherche déjà faite →
    // on relance la recherche pour ré-afficher le popup.
    _srReopenIfQuery();
  });
  const clr = document.getElementById("ev-search-clear"); if (clr) clr.addEventListener("click", () => { _srClear(); inp.focus(); });
  // v2026.5.46 — bouton : popover d'aide sur la syntaxe de recherche.
  const helpBtn = document.getElementById("ev-search-help");
  if (helpBtn) {
    const closeHelp = () => { const p = document.getElementById("ev-search-help-pop"); if (p) p.remove(); };
    helpBtn.addEventListener("click", (e) => {
      e.stopPropagation();
      if (document.getElementById("ev-search-help-pop")) { closeHelp(); return; }
      _srShowResults(false);
      const pop = document.createElement("div");
      pop.id = "ev-search-help-pop";
      pop.className = "sr-help-pop";
      pop.innerHTML = `
        <div class="sr-help-title">🔍 Comment chercher</div>
        <table class="sr-help-table">
          <tr><td><code>mot1 mot2</code></td><td>tous les mots doivent être présents (ordre libre)</td></tr>
          <tr><td><code>%</code></td><td>joker : <code>I2606%123</code> (dans cet ordre), <code>%123</code> (contient)</td></tr>
          <tr><td><code>"…"</code></td><td>expression exacte, espaces compris</td></tr>
          <tr><td><code>-mot</code></td><td>exclure : <code>ecran -reservation</code></td></tr>
          <tr><td><code>champ:</code></td><td>cibler : <code>tech:</code> <code>lieu:</code> <code>ref:</code> <code>cat:</code> <code>contact:</code></td></tr>
        </table>
        <div class="sr-help-foot">Sources : planning en cache (réf, contact, lieu, description chargée, tech…) + recherche EasyVista (demandes, matériel, employés). Le passé est replié en bas de liste — cliquer pour l'afficher. Résultats par 15 : faire défiler pour charger la suite.</div>`;
      document.body.appendChild(pop);
      // ancré sous la barre de recherche (mêmes coordonnées que les résultats)
      const bar = zone.querySelector(".search-bar") || zone;
      const r = bar.getBoundingClientRect();
      const width = Math.max(340, Math.min(520, Math.round(r.width)));
      let left = Math.round(r.left);
      if (left + width > window.innerWidth - 12) left = Math.max(12, window.innerWidth - 12 - width);
      pop.style.left = left + "px";
      pop.style.top = Math.round(r.bottom + 6) + "px";
      pop.style.width = width + "px";
      const onDoc = (ev2) => { if (!pop.contains(ev2.target) && ev2.target !== helpBtn) { closeHelp(); document.removeEventListener("click", onDoc, true); } };
      setTimeout(() => document.addEventListener("click", onDoc, true), 0);
      const onEsc = (ev2) => { if (ev2.key === "Escape") { closeHelp(); document.removeEventListener("keydown", onEsc); } };
      document.addEventListener("keydown", onEsc);
    });
  }
  // v2026.5.46 — re-survol de la zone de recherche avec du texte → relance.
  const _bar = zone.querySelector(".search-bar");
  if (_bar) _bar.addEventListener("mouseenter", () => _srReopenIfQuery());
  // v2026.5.46 — souris dans le popup de résultats : annule la fermeture
  // programmée et ferme les autres popups (sauf épinglés / dans le dock).
  const _box = document.getElementById("ev-search-results");
  if (_box) {
    _box.addEventListener("mouseenter", () => { _srGroupCancelClose(); _srCancelCloseTimer(); _srCloseTransientPopups(); });
    // v2026.5.46 — sortie du popup de recherche : on programme la fermeture
    // groupée (1 s). Annulée si la souris entre dans le tooltip issu de la recherche.
    _box.addEventListener("mouseleave", () => _srGroupScheduleClose());
  }
  // v2026.5.46 — le tooltip issu de la recherche fait partie du « groupe » :
  // y entrer garde tout ouvert ; en sortir programme la fermeture (1 s).
  const _tip = document.getElementById("tooltip");
  if (_tip) {
    _tip.addEventListener("mouseenter", () => {
      if (_tip.dataset && _tip.dataset.fromSearch === "1") { _srGroupCancelClose(); _cancelHideTooltip(); }
    });
    _tip.addEventListener("mouseleave", () => {
      if (_tip.dataset && _tip.dataset.fromSearch === "1") _srGroupScheduleClose();
    });
  }
  document.addEventListener("click", (e) => {
    const box = document.getElementById("ev-search-results");
    if (!zone.contains(e.target) && !(box && box.contains(e.target))) _srShowResults(false);
  });
  window.addEventListener("resize", () => {
    _srSyncTopbarHeight();
    const b = document.getElementById("ev-search-results");
    if (b && !b.classList.contains("hidden")) _srPositionResults();
  });
  _srSyncTopbarHeight();
  LOG.info("search", "barre de recherche initialisée");
}