/* Barre d'apps commune dracodev — comportement (v0.1.0, ACC-0.2 ;
 * v0.1.3 : menu des applications ouvert par la marque ✦ ;
 * v0.1.5 : noms publics par configuration — aucun nom public d'un
 * environnement particulier n'est codé en dur, voir « URL » ci-dessous ;
 * v0.1.6 (prochaine publication — VERSION non bumpée dans cette PR,
 * la publication est séparée) : dérivation -dev par l'hôte courant,
 * menu trois points par défaut et menu compte fonctionnels, voir ci-dessous ;
 * correctif fusion #70 (SANS bump de version, publication séparée) :
 * bouton trois points et son menu par défaut SUPPRIMÉS, « Console Spark »
 * ajoutée au menu de la marque, fermeture/focus corrigés (voir
 * « Menu des applications », « Focus » et « Écouteurs globaux »).
 *
 * Aucun gestionnaire inline : un seul écouteur délégué sur le document
 * (patron validé par le prototype — les onclick du HTML généré sont
 * proscrits dans tout le programme).
 *
 * Configuration attendue avant le chargement :
 *   window.DRACO_BAR_CONFIG = {
 *     current: "tiktak",                      // app courante
 *     domain: "pro",                          // domaine actif
 *     counts: { tiktak: 3, kanbante: 3, alertes: 3, spark: 0 },
 *     user: "Bruno",                          // nom affiché (v0.1.6) ;
 *       // ou { display_name: "Bruno", username: "bruno" }
 *     urls: {                                 // bases des applications
 *       obsigate: "https://og.dracodev.net/",
 *       flowdeck: "https://flowdeck.dracodev.net/",
 *       tiktak:   "https://tiktak.dracodev.net/",
 *       kanbante: "https://kanbante.dracodev.net/",
 *       agent:    "https://agent.dracodev.net/",
 *       spark:    "https://spark.dracodev.net/"
 *     },
 *     onAction: function (act, el) { … }      // l'app relaie les actions
 *   }                                          // qu'elle ne connaît pas
 *
 * URL des applications (contrat dev/prod, v0.1.5 puis v0.1.6) —
 * résolution, dans l'ordre STRICT, pour chaque app :
 *   1. DRACO_BAR_CONFIG.urls.<app>, injectée par l'app hôte (rendu
 *      serveur ou client) depuis SA configuration d'environnement —
 *      explicite, donc prioritaire, même sur un hôte -dev ;
 *   2. (v0.1.6) SI l'hôte courant est un hôte -dev dracodev.net
 *      (première étiquette se terminant par -dev : tiktak-dev,
 *      kanbante-dev, og-dev, flowdeck-dev, agent-dev…), l'URL sœur
 *      dérivée avec -dev (voir DEV_URLS). C'est le correctif du bug
 *      constaté sur tiktak-dev / kanbante-dev, où les liens suivaient
 *      les noms SANS -dev faute de configuration explicite ;
 *   3. le href déjà rendu dans le fragment HTML, c.-à-d. le jeton
 *      {{URL_<APP>}} remplacé côté serveur par l'app hôte ;
 *   4. le défaut officiel ci-dessous (production, noms SANS suffixe).
 * Un jeton {{URL_…}} non remplacé n'est jamais une URL : il est ignoré
 * partout (config injectée comme href rendu) et ne peut pas être exposé.
 * Cas spark (v0.1.6) : AUCUNE dérivation inventée — aucun hôte
 * spark-dev connu ; sur un hôte -dev, spark retombe sur l'étape 3
 * (href rendu) puis 4 (défaut prod), sauf config explicite (étape 1).
 * La clé spark ne correspond à aucun onglet de la barre : elle est
 * résolue et exposée via DRACO_BAR.urls pour le panneau Spark
 * (panneau-agent), qui suit le même contrat d'injection. La clé agent,
 * elle, a un onglet depuis le chantier 5 (ordre : ObsiGate, Flowdeck,
 * TikTak, Kanbante, Console Spark) : elle suit donc l'étape « href
 * rendu » comme les autres onglets, en plus d'alimenter le menu de
 * la marque et DRACO_BAR.urls.
 * Actions émises (data-act) : rail, palette, domaine (data-dom),
 * alertes, spark, rappel-entete. L'app intégratrice décide de chacune
 * (ouvrir la palette, le panneau Spark, changer de domaine…).
 * Actions INTERNES (jamais relayées comme avant) : apps — la marque ✦
 * ouvre le menu des applications, construit depuis les onglets, plus
 * (depuis le correctif #70) une entrée « Console Spark » vers la
 * console de l'agent commun (URL agent résolue, voir ci-dessous) ;
 * c'est le moyen de changer d'app en mobile, où les onglets sont
 * repliés (v0.1.2). Menu compte : voir ci-dessous.
 * L'action « menu » n'est PLUS émise nulle part : le bouton trois points
 * a été supprimé (#70) ; les branches onAction("menu") des hôtes
 * (TikTak/Kanbante/Flowdeck : retour false pour le menu par défaut ;
 * ObsiGate : clic #header-menu-btn) sont donc mortes et ont été
 * retirées des gabarits hôtes — le menu natif d'ObsiGate
 * (#header-menu-btn) lui-même n'est pas touché.
 *
 * Retrait du bouton trois points (correctif fusion #70) — le bouton et
 * son menu par défaut (console agent + applications) sont supprimés
 * du fragment, du JS et du CSS. La console agent reste joignable par
 * l'entrée « Console Spark » du menu de la marque (ci-dessous) et
 * par le bouton Spark (panneau), donc aucun accès n'est perdu.
 * Menu des applications (v0.1.3, étendu #70) — construit depuis les
 * onglets présents dans la barre, puis une entrée « Console Spark »
 * (logo ✦, rôle « Agent commun ») APRÈS Kanbante, vers l'URL agent
 * résolue : 1) config explicite DRACO_BAR_CONFIG.urls.agent,
 * 2) dérivation -dev agent-dev sur hôte -dev, 3) href rendu de
 * l'onglet « Console Spark » (chantier 5, data-app="agent"),
 * 4) défaut officiel prod https://agent.dracodev.net/.
 * AUCUN hôte spark-dev n'est inventé :
 * la clé spark, elle, suit toujours son propre contrat (explicite >
 * href rendu > défaut prod) et ne sert qu'au panneau Spark.
 * Focus (correctif #70) — ouverture au clavier : Entrée sur la marque
 * (clic natif du lien) ; Espace sur la marque (keydown dédié, car un
 * lien ne s'active pas à l'Espace) : ouvre le menu et met le focus
 * sur son premier item. Fermeture : Échap (focus rendu au déclencheur
 * qui avait ouvert le menu : la marque pour le menu apps, l'avatar
 * pour le menu compte), nouvel appui sur le déclencheur (le focus y
 * est déjà), choix d'un item, ou clic extérieur — ce dernier cas ne
 * déplace VOLONTAIREMENT pas le focus (l'utilisateur vient de cliquer
 * ailleurs : recherche, tâche… ; lui voler le focus casserait son
 * geste). aria-expanded est tenu à jour sur chaque déclencheur.
 * Écouteurs globaux (correctif #70, bug tiktak-dev) — les écouteurs
 * clic/Échap de la barre sont posés via EventTarget.prototype (voir
 * addGlobalListener), PAS via document.addEventListener. Cause
 * prouvée sur TikTak (app/static/js/app.js, navigation #89) : app.js
 * remplace document/window.addEventListener par un registre
 * (__tcDocWin) et chaque navigation douce appelle tcInit() puis
 * __tcTeardown(), qui SUPPRIME tous les écouteurs du registre — y
 * compris ceux de draco-barre.js (script defer, enregistré après le
 * tcInit() initial). La barre survit à la navigation (hors .layout
 * remplacé) mais ses gestionnaires sont morts : un menu ouvert avant
 * la navigation reste ouvert (Échap et clic extérieur sans effet) et
 * la marque, lien href="/", est interceptée par l'intercepteur SPA
 * brut de TikTak (__tcDocAdd, hors registre, donc survivant) comme
 * une navigation interne au lieu de basculer le menu. Les écouteurs
 * posés sur le prototype ne figurent pas dans le registre et ne sont
 * donc jamais supprimés par le teardown ; en complément, le gabarit
 * TikTak exclut désormais .draco-bar de l'intercepteur SPA, pour que
 * la marque ne déclenche plus de navigation douce. Les autres hôtes
 * (SSR, rechargement complet) ne sont pas concernés par le teardown
 * mais bénéficient du même code ; repli : si EventTarget.prototype
 * est indisponible (mini-DOM de tests), document.addEventListener
 * classique est utilisé.
 * Menu compte (v0.1.6) — l'avatar, auparavant un <span> mort affichant
 * un « B » codé en dur dans le fragment, est un vrai <button>
 * (data-act="compte"). Son initiale vient de cfg.user ou, à défaut, de
 * la première lettre du title {{UTILISATEUR}} remplacé ; sans nom connu,
 * le neutre ✦ est conservé (jamais de lettre codée en dur). Le clic
 * ouvre un petit menu affichant le nom de l'utilisateur ; les items
 * Profil / Déconnexion sont relayés à l'hôte via onAction ou, à défaut,
 * via l'événement draco:bar (détail { act: "profil" | "deconnexion" }),
 * mais le menu affiche l'identité même sans gestionnaire hôte.
 * Accessibilité : vrais <button>, aria-haspopup / aria-expanded,
 * role="menu" / "menuitem", fermeture par Échap et clic extérieur.
 */
(function () {
  "use strict";
  var cfg = window.DRACO_BAR_CONFIG || {};

  /* Défauts OFFICIELS (production) — les seuls noms publics présents
   * dans ce fichier, documentés comme défauts (contrat dev/prod). */
  var DEFAULT_URLS = {
    obsigate: "https://og.dracodev.net/",
    flowdeck: "https://flowdeck.dracodev.net/",
    tiktak: "https://tiktak.dracodev.net/",
    kanbante: "https://kanbante.dracodev.net/",
    agent: "https://agent.dracodev.net/",
    spark: "https://spark.dracodev.net/"
  };

  /* Dérivation -dev (v0.1.6) — appliquée UNIQUEMENT quand l'hôte courant
   * est lui-même un hôte -dev dracodev.net (voir isDevHost). spark est
   * volontairement absent : aucun hôte spark-dev connu, aucune URL
   * inventée ; spark retombe sur href rendu puis défaut prod. */
  var DEV_URLS = {
    obsigate: "https://og-dev.dracodev.net/",
    flowdeck: "https://flowdeck-dev.dracodev.net/",
    tiktak: "https://tiktak-dev.dracodev.net/",
    kanbante: "https://kanbante-dev.dracodev.net/",
    agent: "https://agent-dev.dracodev.net/"
  };

  var APP_LABELS = {
    obsigate: "ObsiGate", flowdeck: "Flowdeck",
    tiktak: "TikTak", kanbante: "Kanbante"
  };

  /* Vrai si hostname est un hôte -dev dracodev.net : première étiquette
   * se terminant par -dev ET domaine dracodev.net (un suffixe -dev sur
   * un autre domaine, ou un hôte piège du type x-dev.dracodev.net.evil,
   * ne déclenche rien). Insensible à la casse. */
  function isDevHost(hostname) {
    if (!hostname) return false;
    var h = String(hostname).toLowerCase();
    if (h.slice(-13) !== ".dracodev.net") return false;
    var first = h.split(".")[0];
    return first.length > 4 && first.slice(-4) === "-dev";
  }

  /* Un jeton {{…}} non remplacé n'est pas une URL : l'ignorer. */
  function cleanUrl(u) {
    if (!u || typeof u !== "string") return null;
    if (u.indexOf("{{") !== -1) return null;
    if (!u.replace(/\s/g, "")) return null;
    return u;
  }

  function withSlash(u) {
    return u.charAt(u.length - 1) !== "/" ? u + "/" : u;
  }

  function resolveUrls() {
    var host = "";
    try { host = (window.location && window.location.hostname) || ""; } catch (e) { host = ""; }
    var dev = isDevHost(host);
    var urls = {};
    Object.keys(DEFAULT_URLS).forEach(function (app) {
      /* 1. Config explicite de l'hôte — prioritaire, même sur -dev. */
      var u = cleanUrl(cfg.urls && cfg.urls[app]);
      /* 2. Dérivation -dev par l'hôte courant (spark : pas de dérivée). */
      if (!u && dev) u = DEV_URLS[app] || null;
      /* 3. href rendu dans le fragment (jeton remplacé côté serveur). */
      if (!u) {
        var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
        var href = tab ? tab.getAttribute("href") : null;
        u = cleanUrl(href);
      }
      /* 4. Défaut officiel (production). */
      if (!u) u = DEFAULT_URLS[app];
      urls[app] = withSlash(u);
    });
    return urls;
  }
  function applyUrls(urls) {
    document.querySelectorAll(".draco-apptab, .draco-apps-item").forEach(function (t) {
      if (t.dataset.app && urls[t.dataset.app]) t.setAttribute("href", urls[t.dataset.app]);
    });
  }
  var resolvedUrls = resolveUrls();

  function setCounts(counts) {
    Object.keys(counts || {}).forEach(function (k) {
      /* Toutes les occurrences : l'onglet ET sa ligne dans le menu. */
      document.querySelectorAll('.draco-badge[data-badge="' + k + '"]').forEach(function (b) {
        b.textContent = counts[k];
        b.hidden = !(counts[k] > 0);
      });
    });
  }
  function setCurrent(app) {
    document.querySelectorAll(".draco-apptab, .draco-apps-item").forEach(function (t) {
      if (t.dataset.app) t.dataset.active = t.dataset.app === app ? "true" : "false";
    });
  }
  function setDomain(dom) {
    document.querySelectorAll('.draco-domaines [data-dom]').forEach(function (b) {
      b.dataset.on = b.dataset.dom === dom ? "true" : "false";
    });
  }

  /* ── Identité / avatar (v0.1.6) ───────────────────────────────────
   * Nom : cfg.user (chaîne, ou objet display_name / name / username),
   * sinon le title de l'avatar quand le jeton {{UTILISATEUR}} a bien été
   * remplacé côté serveur. L'initiale en découle ; sans nom, le neutre
   * ✦ du fragment est conservé — jamais de lettre codée en dur. */
  function userName() {
    var u = cfg.user;
    if (typeof u === "string" && u.replace(/\s/g, "")) return u.trim();
    if (u && typeof u === "object") {
      var n = u.display_name || u.name || u.username;
      if (n && String(n).replace(/\s/g, "")) return String(n).trim();
    }
    return null;
  }
  function titleName() {
    var av = document.querySelector(".draco-avatar");
    var t = av ? av.getAttribute("title") : null;
    if (t && t.indexOf("{{") === -1 && t.replace(/\s/g, "")) return t.trim();
    return null;
  }
  function displayName() { return userName() || titleName(); }
  function syncAvatar() {
    var av = document.querySelector(".draco-avatar");
    if (!av) return;
    /* Compatibilité avec un fragment vendangé antérieur (avatar <span>
     * sans data-act) : le rendre déclencheur du menu compte. */
    if (!av.getAttribute("data-act")) av.setAttribute("data-act", "compte");
    if (!av.getAttribute("aria-haspopup")) av.setAttribute("aria-haspopup", "menu");
    var name = displayName();
    if (name) {
      av.textContent = name.charAt(0).toUpperCase();
      av.setAttribute("title", name);
      av.setAttribute("aria-label", "Compte : " + name);
    }
  }

  /* ── Menus déroulants (apps, compte) ───────────────────────────────
   * Un seul menu ouvert à la fois ; fermeture par clic extérieur,
   * Échap, ou choix d'un item. aria-expanded tenu à jour sur chaque
   * déclencheur. Les href des menus sont (re)synchronisés avec
   * resolvedUrls à chaque ouverture, pour que setUrls et la dérivation
   * -dev s'y reflètent même si le menu a été construit avant. */
  var bar = document.querySelector(".draco-bar");
  var brand = bar ? bar.querySelector(".draco-brand") : null;
  var avatarBtn = document.querySelector(".draco-avatar");
  var appsMenu = null, compteMenu = null;
  /* Déclencheur du menu ouvert en dernier (marque ou avatar) : Échap
   * lui rend le focus à la fermeture (correctif #70). */
  var lastOpener = null;

  function setExpanded(btn, open) {
    if (btn) btn.setAttribute("aria-expanded", open ? "true" : "false");
  }
  function refreshMenuHrefs(menu) {
    if (!menu) return;
    menu.querySelectorAll(".draco-apps-item").forEach(function (a) {
      if (a.dataset.app && resolvedUrls[a.dataset.app]) a.setAttribute("href", resolvedUrls[a.dataset.app]);
    });
  }
  function togglePopup(menu, btn, force) {
    if (!menu) return;
    var open = typeof force === "boolean" ? force : menu.hidden;
    menu.hidden = !open;
    setExpanded(btn, open);
  }
  function closeAllPopups(returnFocus) {
    var anyOpen = (appsMenu && !appsMenu.hidden) || (compteMenu && !compteMenu.hidden);
    if (appsMenu) togglePopup(appsMenu, brand, false);
    if (compteMenu) togglePopup(compteMenu, avatarBtn, false);
    /* Échap seulement : le clic extérieur ne déplace pas le focus
     * (voir l'en-tête, « Focus »). */
    if (returnFocus && anyOpen && lastOpener && typeof lastOpener.focus === "function") lastOpener.focus();
  }
  function tabLabel(app) {
    var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
    var fort = tab ? tab.querySelector(".draco-apptab-txt strong") : null;
    return fort ? fort.textContent : (APP_LABELS[app] || app);
  }
  function tabRole(app) {
    var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
    var petit = tab ? tab.querySelector(".draco-apptab-txt small") : null;
    return petit ? petit.textContent : "";
  }
  /* Menu des applications (v0.1.3) — construit depuis les onglets
   * présents dans la barre : mêmes liens, mêmes icônes, mêmes badges.
   * Ouvert par la marque ✦ (data-act="apps"), fermé par un clic
   * extérieur, Échap, ou le choix d'une application (la navigation
   * suit son cours). */
  function buildAppsMenu() {
    if (!bar || !brand || appsMenu) return;
    appsMenu = document.createElement("div");
    appsMenu.className = "draco-apps-menu";
    appsMenu.hidden = true;
    appsMenu.setAttribute("role", "menu");
    appsMenu.setAttribute("aria-label", "Applications");
    document.querySelectorAll(".draco-apptab").forEach(function (t) {
      /* Chantier 5 : l'onglet agent (« Console Spark ») n'est PAS
       * repris ici — l'entrée dédiée ci-dessous le représente déjà
       * (après Kanbante, avec séparateur) ; sans ce saut, le menu
       * listerait « Console Spark » deux fois. */
      if (t.dataset.app === "agent") return;
      var a = document.createElement("a");
      a.className = "draco-apps-item";
      a.href = resolvedUrls[t.dataset.app] || t.getAttribute("href");
      a.dataset.app = t.dataset.app;
      a.setAttribute("role", "menuitem");
      var ico = t.querySelector(".draco-apptab-ico");
      if (ico) a.appendChild(ico.cloneNode(true));
      var txt = document.createElement("span");
      txt.className = "draco-apps-item-txt";
      var fort = t.querySelector(".draco-apptab-txt strong");
      var petit = t.querySelector(".draco-apptab-txt small");
      var nom = document.createElement("span");
      nom.className = "draco-apps-item-nom";
      nom.textContent = fort ? fort.textContent : t.dataset.app;
      txt.appendChild(nom);
      if (petit) {
        var role = document.createElement("span");
        role.className = "draco-apps-item-role";
        role.textContent = petit.textContent;
        txt.appendChild(role);
      }
      a.appendChild(txt);
      var badge = t.querySelector(".draco-badge");
      if (badge) a.appendChild(badge.cloneNode(true));
      appsMenu.appendChild(a);
    });
    /* Entrée « Console Spark » (#70) : après Kanbante, vers la console
     * de l'agent commun (URL agent résolue — explicite > -dev >
     * défaut prod ; aucun hôte spark-dev inventé). data-app="agent"
     * l'intègre à refreshMenuHrefs/applyUrls/setCurrent comme les
     * autres items ; l'icône ✦ reprend la couleur agent du CSS. */
    var sep = document.createElement("div");
    sep.className = "draco-menu-sep";
    sep.setAttribute("aria-hidden", "true");
    appsMenu.appendChild(sep);
    var sparkItem = document.createElement("a");
    sparkItem.className = "draco-apps-item";
    sparkItem.href = resolvedUrls.agent || "#";
    sparkItem.dataset.app = "agent";
    sparkItem.setAttribute("role", "menuitem");
    var sparkIco = document.createElement("span");
    sparkIco.className = "draco-apptab-ico";
    sparkIco.setAttribute("style", "--app:#c2437e");
    sparkIco.textContent = "✦";
    sparkItem.appendChild(sparkIco);
    var sparkTxt = document.createElement("span");
    sparkTxt.className = "draco-apps-item-txt";
    var sparkNom = document.createElement("span");
    sparkNom.className = "draco-apps-item-nom";
    sparkNom.textContent = "Console Spark";
    sparkTxt.appendChild(sparkNom);
    var sparkRole = document.createElement("span");
    sparkRole.className = "draco-apps-item-role";
    sparkRole.textContent = "Agent commun";
    sparkTxt.appendChild(sparkRole);
    sparkItem.appendChild(sparkTxt);
    appsMenu.appendChild(sparkItem);
    bar.appendChild(appsMenu);
  }
  function toggleAppsMenu(force) {
    buildAppsMenu();
    if (!appsMenu) return;
    if (force !== false) refreshMenuHrefs(appsMenu);
    togglePopup(appsMenu, brand, force);
    if (!appsMenu.hidden) lastOpener = brand;
  }

  /* Menu compte (v0.1.6) — en-tête d'identité + Profil / Déconnexion
   * relayés à l'hôte. L'en-tête est rafraîchi à chaque ouverture, pour
   * refléter un title posé après coup par l'hôte (ex. ObsiGate, qui
   * remplit l'avatar depuis /api/auth/me après chargement). */
  function buildCompteMenu() {
    if (!bar || !avatarBtn || compteMenu) return;
    compteMenu = document.createElement("div");
    compteMenu.className = "draco-compte-menu";
    compteMenu.hidden = true;
    compteMenu.setAttribute("role", "menu");
    compteMenu.setAttribute("aria-label", "Compte");
    var head = document.createElement("div");
    head.className = "draco-compte-nom";
    compteMenu.appendChild(head);
    [["profil", "Profil"], ["deconnexion", "Déconnexion"]].forEach(function (pair) {
      var b = document.createElement("button");
      b.type = "button";
      b.className = "draco-menu-item";
      b.setAttribute("data-compte-act", pair[0]);
      b.setAttribute("role", "menuitem");
      b.textContent = pair[1];
      compteMenu.appendChild(b);
    });
    bar.appendChild(compteMenu);
  }
  function refreshCompteMenu() {
    if (!compteMenu) return;
    var head = compteMenu.querySelector(".draco-compte-nom");
    var name = displayName();
    if (head) head.textContent = name || "Compte";
  }
  function toggleCompteMenu(force) {
    buildCompteMenu();
    if (!compteMenu) return;
    if (force !== false) { syncAvatar(); refreshCompteMenu(); }
    togglePopup(compteMenu, avatarBtn, force);
    if (!compteMenu.hidden) lastOpener = avatarBtn;
  }

  /* Relais d'une action vers l'hôte : onAction si présent, sinon
   * événement draco:bar (contrat historique des actions relayées). */
  function relay(act, el, ev) {
    if (typeof cfg.onAction === "function") cfg.onAction(act, el, ev);
    else document.dispatchEvent(new CustomEvent("draco:bar", { detail: { act: act, el: el } }));
  }

  /* Écouteurs globaux posés sur le prototype EventTarget quand il
   * existe, pour survivre au registre/teardown d'un hôte SPA (TikTak,
   * voir l'en-tête) ; sinon document.addEventListener classique. */
  function addGlobalListener(type, fn) {
    try {
      if (typeof EventTarget !== "undefined" && EventTarget.prototype &&
          EventTarget.prototype.addEventListener) {
        EventTarget.prototype.addEventListener.call(document, type, fn, false);
        return;
      }
    } catch (e) { /* repli ci-dessous */ }
    document.addEventListener(type, fn);
  }

  addGlobalListener("click", function (ev) {
    /* Items du menu compte : relais + fermeture, jamais de navigation. */
    var compteItem = ev.target.closest ? ev.target.closest("[data-compte-act]") : null;
    if (compteItem) {
      relay(compteItem.getAttribute("data-compte-act"), compteItem, ev);
      toggleCompteMenu(false);
      return;
    }
    var el = ev.target.closest ? ev.target.closest("[data-act]") : null;
    if (el && el.dataset.act === "apps") {
      ev.preventDefault();
      if (compteMenu) toggleCompteMenu(false);
      toggleAppsMenu();
      return;
    }
    if (el && el.dataset.act === "compte") {
      if (appsMenu) toggleAppsMenu(false);
      toggleCompteMenu();
      return;
    }
    /* Clic extérieur : ferme tout menu ouvert (clic dans un menu ou
     * sur son déclencheur déjà traité ci-dessus). */
    var inPopup = ev.target.closest ? (ev.target.closest(".draco-apps-menu") ||
      ev.target.closest(".draco-compte-menu")) : null;
    if (!inPopup && ((appsMenu && !appsMenu.hidden) || (compteMenu && !compteMenu.hidden))) {
      closeAllPopups(false);
    }
    if (!el) return;
    var act = el.dataset.act;
    if (act === "domaine") setDomain(el.dataset.dom);
    relay(act, el, ev);
  });

  addGlobalListener("keydown", function (ev) {
    if (ev.key === "Escape") { closeAllPopups(true); return; }
    /* Espace sur la marque : un lien ne s'active pas à l'Espace, donc
     * ouverture explicite + focus sur le premier item du menu (#70).
     * Entrée : clic natif du lien, déjà géré par le gestionnaire clic
     * ci-dessus (pas de double bascule ici). */
    if ((ev.key === " " || ev.key === "Spacebar") && ev.target && ev.target.closest) {
      var brandEl = ev.target.closest('[data-act="apps"]');
      if (brandEl) {
        if (ev.preventDefault) ev.preventDefault();
        toggleAppsMenu();
        if (appsMenu && !appsMenu.hidden) {
          var first = appsMenu.querySelector(".draco-apps-item");
          if (first && typeof first.focus === "function") first.focus();
        }
      }
    }
  });

  /* API publique : l'app met les compteurs à jour sans recharger.
   * setUrls(urls) fusionne de nouvelles bases (même contrat que
   * DRACO_BAR_CONFIG.urls — donc prioritaires sur la dérivation -dev)
   * et les ré-applique aux onglets et aux menus ; DRACO_BAR.urls expose
   * les bases résolues (défauts inclus), pour le panneau Spark et tout
   * autre consommateur de l'hôte. */
  window.DRACO_BAR = {
    setCounts: setCounts, setCurrent: setCurrent, setDomain: setDomain,
    urls: resolvedUrls,
    setUrls: function (urls) {
      cfg.urls = Object.assign({}, cfg.urls, urls || {});
      resolvedUrls = resolveUrls();
      window.DRACO_BAR.urls = resolvedUrls;
      applyUrls(resolvedUrls);
    }
  };

  applyUrls(resolvedUrls);
  buildAppsMenu();
  buildCompteMenu();
  syncAvatar();
  refreshCompteMenu();
  if (cfg.current) setCurrent(cfg.current);
  if (cfg.domain) setDomain(cfg.domain);
  if (cfg.counts) setCounts(cfg.counts);
})();