@ourlu/assistant-sdk 0.2.0 → 0.2.3

package/dist/iife/engine.v1.3b09dc20.js

@@ -0,0 +1,721 @@
+(function() {
+  "use strict";
+  var runtime = window.__OurluWidgetRuntimeV1 || (window.__OurluWidgetRuntimeV1 = {});
+  if (!runtime.utils || !runtime.WidgetUIManager || !runtime.WidgetAudioManager || !runtime.EventBus) {
+    throw new Error("Widget runtime UI module must be loaded first.");
+  }
+
+  var WIDGET_VERSION = "v1", WIDGET_NS = "OurluMairieWidget";
+  var trimTrailingSlash = runtime.utils.trimTrailingSlash;
+  var WidgetUIManager = runtime.WidgetUIManager, WidgetAudioManager = runtime.WidgetAudioManager;
+  var EventBus = runtime.EventBus, CONTAINER_ID = runtime.constants.CONTAINER_ID;
+var MASCOT_SPECS = JSON.parse('[["mascotSecondaryColor","mascot_secondary_color","data-mascot-secondary-color","#58878d"],["mascotSecondaryDarkColor","mascot_secondary_dark_color","data-mascot-secondary-dark-color","#355c62"],["mascotGoldColor","mascot_gold_color","data-mascot-gold-color","#f4c934"],["mascotEyeColor","mascot_eye_color","data-mascot-eye-color","#040402"],["mascotBeakColor","mascot_beak_color","data-mascot-beak-color","#ab6d46"],["mascotNeutralColor","mascot_neutral_color","data-mascot-neutral-color","#e6e6e6"]]');
+var CONFIG_STRING_ATTRS = JSON.parse('[["tenantId","data-tenant-id",""],["widgetKey","data-widget-key",""],["apiBaseUrl","data-api-base-url",""],["widgetOrigin","data-widget-origin",""],["bootstrapEndpoint","data-bootstrap-endpoint",""],["configEndpoint","data-config-endpoint",""],["sessionBootstrapToken","data-session-bootstrap-token",""],["sessionBootstrapTokenExpiresAt","data-session-bootstrap-token-expires-at",""],["chatSessionEndpoint","data-chat-session-endpoint","/v1/occe/chat/sessions"],["chatMessageTemplate","data-chat-message-template","/v1/occe/chat/sessions/{session_id}/messages"],["chatStreamTemplate","data-chat-stream-template","/v1/occe/chat/sessions/{session_id}/stream"],["chatAudioSessionTemplate","data-chat-audio-session-template","/v1/occe/chat/sessions/{session_id}/audio/session"],["chatAudioChunkTemplate","data-chat-audio-chunk-template","/v1/occe/chat/sessions/{session_id}/audio/chunk"],["chatAudioCloseTemplate","data-chat-audio-close-template","/v1/occe/chat/sessions/{session_id}/audio/close"],["chatAudioStreamTemplate","data-chat-audio-stream-template","/v1/occe/chat/sessions/{session_id}/audio/stream"],["panelWidth","data-panel-width","420"],["panelHeight","data-panel-height","640"],["panelMaxHeightVh","data-panel-max-height-vh","85"],["mascotUrl","data-mascot-url",""],["welcomeMessage","data-welcome-message","Bonjour ! Comment puis-je vous aider ?"],["disclaimerText","data-disclaimer-text","Assistant IA - Les reponses ne constituent pas une decision administrative officielle."],["transparencyText","data-transparency-text","Reponses generees par intelligence artificielle."]]');
+var RUNTIME_ENDPOINT_SPECS = JSON.parse('[["chatSessionEndpoint","chat_session_endpoint","/v1/occe/chat/sessions"],["chatMessageTemplate","chat_message_template","/v1/occe/chat/sessions/{session_id}/messages"],["chatStreamTemplate","chat_stream_template","/v1/occe/chat/sessions/{session_id}/stream"],["chatAudioSessionTemplate","chat_audio_session_template","/v1/occe/chat/sessions/{session_id}/audio/session"],["chatAudioChunkTemplate","chat_audio_chunk_template","/v1/occe/chat/sessions/{session_id}/audio/chunk"],["chatAudioCloseTemplate","chat_audio_close_template","/v1/occe/chat/sessions/{session_id}/audio/close"],["chatAudioStreamTemplate","chat_audio_stream_template","/v1/occe/chat/sessions/{session_id}/audio/stream"]]');
+function applyMascotLabelColors(config, labels) {
+  MASCOT_SPECS.forEach(function(spec) {
+    config[spec[0]] = normalizeHexColor(labels[spec[1]], config[spec[0]] || spec[3]);
+  });
+}
+function applyScriptMascotColors(config, scriptTag) {
+  MASCOT_SPECS.forEach(function(spec) {
+    config[spec[0]] = readScriptHexAttr(scriptTag, spec[2], spec[3]);
+  });
+}
+function readScriptAttr(scriptTag, attributeName, fallbackValue) {
+  var value = scriptTag.getAttribute(attributeName);
+  return value == null || value === "" ? fallbackValue : value;
+}
+function readScriptHexAttr(scriptTag, attributeName, fallbackColor) {
+  return normalizeHexColor(readScriptAttr(scriptTag, attributeName, ""), fallbackColor);
+}
+function assignRuntimeEndpoints(config, runtimeConfig) {
+  RUNTIME_ENDPOINT_SPECS.forEach(function(spec) {
+    config[spec[0]] = String(runtimeConfig[spec[1]] || config[spec[0]] || spec[2]).trim();
+  });
+}
+function resolveAbsoluteMascotUrl(mascotUrl, apiBaseUrl) {
+  if (runtime.utils && typeof runtime.utils.resolveAbsoluteMascotUrl === "function") {
+    return runtime.utils.resolveAbsoluteMascotUrl(mascotUrl, apiBaseUrl);
+  }
+  var normalized = String(mascotUrl || "").trim();
+  if (!normalized) return "";
+  if (/^https?:\/\//i.test(normalized)) return normalized;
+  var base = String(apiBaseUrl || "").trim().replace(/\/$/, "");
+  if (!base) {
+    throw new Error("[OurluMairie] mascot URL relative sans apiBaseUrl: " + normalized);
+  }
+  return normalized.startsWith("/") ? base + normalized : base + "/" + normalized;
+}
+function normalizeHexColor(rawValue, fallbackColor) {
+  var normalized = String(rawValue || "").trim().toLowerCase();
+  return /^#[0-9a-f]{6}$/.test(normalized) ? normalized : fallbackColor;
+}
+function normalizePosition(rawValue, fallbackValue) {
+  var normalized = String(rawValue || "").trim().toLowerCase();
+  return normalized === "bottom-left" || normalized === "bottom-right" ? normalized : fallbackValue;
+}
+function normalizeThemeVersion(rawValue) {
+  var parsed = Number(rawValue);
+  return !Number.isFinite(parsed) || parsed <= 0 ? 0 : Math.floor(parsed);
+}
+function normalizeThemeModeStrategy(rawValue) {
+  var normalized = String(rawValue || "").trim().toLowerCase();
+  return normalized === "manual_dark" || normalized === "auto_follow_host" || normalized === "manual_light" ? normalized : "manual_light";
+}
+function resolveHostPrefersDark(fallbackValue) {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return Boolean(fallbackValue);
+  return Boolean(window.matchMedia("(prefers-color-scheme: dark)").matches);
+}
+function resolvePreferredThemeScheme(config) {
+  var mode = normalizeThemeModeStrategy((config || {}).themeModeStrategy);
+  if (mode === "manual_dark") return "dark";
+  if (mode === "auto_follow_host") return resolveHostPrefersDark((config || {}).hostPrefersDark) ? "dark" : "light";
+  return "light";
+}
+function clampNumericString(rawValue, fallbackValue, minValue, maxValue, shouldRound) {
+  var parsed = Number(rawValue);
+  if (!Number.isFinite(parsed)) return fallbackValue;
+  if (parsed < minValue) return String(minValue);
+  if (parsed > maxValue) return String(maxValue);
+  return shouldRound ? String(Math.round(parsed)) : String(parsed);
+}
+function decodeBase64UrlPayload(rawValue) {
+  var encoded = String(rawValue || "").trim();
+  if (!encoded) return "";
+  var base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4 !== 0) base64 += "=";
+  var binary = atob(base64);
+  var percentEncoded = "";
+  for (var index = 0; index < binary.length; index += 1) {
+    percentEncoded += "%" + ("00" + binary.charCodeAt(index).toString(16)).slice(-2);
+  }
+  return decodeURIComponent(percentEncoded);
+}
+function parseThemeSnapshot(rawValue) {
+  try {
+    var decodedPayload = decodeBase64UrlPayload(rawValue);
+    if (!decodedPayload) return null;
+    var parsedPayload = JSON.parse(decodedPayload);
+    return parsedPayload && typeof parsedPayload === "object" ? parsedPayload : null;
+  } catch (_) {
+    return null;
+  }
+}
+function applyThemeConfigToRuntime(config, rawWidgetConfig) {
+  if (!rawWidgetConfig || typeof rawWidgetConfig !== "object") return false;
+  var labels = rawWidgetConfig.labels && typeof rawWidgetConfig.labels === "object" ? rawWidgetConfig.labels : {};
+  config.themeSplitEnabled = Boolean(rawWidgetConfig.theme_split_enabled);
+  config.themeModeStrategy = normalizeThemeModeStrategy(rawWidgetConfig.theme_mode_strategy || labels.theme_mode_strategy || config.themeModeStrategy);
+  config.hostPrefersDark = resolveHostPrefersDark(config.hostPrefersDark);
+  config.effectiveThemeScheme = resolvePreferredThemeScheme(config);
+  var resolvedThemeConfig = rawWidgetConfig;
+  if (config.themeSplitEnabled) {
+    var splitConfig = config.effectiveThemeScheme === "dark" ? rawWidgetConfig.dark_theme_defaults : rawWidgetConfig.light_theme_defaults;
+    if (splitConfig && typeof splitConfig === "object") {
+      var splitLabels = splitConfig.labels && typeof splitConfig.labels === "object" ? splitConfig.labels : {};
+      labels = Object.assign({}, labels, splitLabels);
+      resolvedThemeConfig = { primary_color: splitConfig.primary_color || rawWidgetConfig.primary_color, position: splitConfig.position || rawWidgetConfig.position, labels: labels };
+    }
+  }
+  config.primaryColor = normalizeHexColor(resolvedThemeConfig.primary_color, config.primaryColor || "#0066ff");
+  config.position = normalizePosition(resolvedThemeConfig.position, config.position || "bottom-right");
+  var themedAssistantName = String(labels.title || labels.assistant_name || "").trim();
+  if (themedAssistantName) {
+    config.assistantName = themedAssistantName;
+  } else if (!String(config.assistantName || "").trim()) {
+    config.assistantName = "Assistant mairie";
+  }
+  config.panelBackgroundColor = normalizeHexColor(labels.panel_background_color, config.panelBackgroundColor || "#ffffff");
+  config.panelBackgroundAlpha = clampNumericString(labels.panel_background_alpha, config.panelBackgroundAlpha || "1", 0, 1, false);
+  config.panelBorderRadius = clampNumericString(labels.panel_border_radius, config.panelBorderRadius || "16", 0, 32, true);
+  applyMascotLabelColors(config, labels);
+  var candidateVersion = normalizeThemeVersion(rawWidgetConfig.theme_updated_at);
+  if (candidateVersion > 0) config.themeVersion = candidateVersion;
+  return true;
+}
+function applyWidgetTextConfig(config, widgetConfig) {
+  if (!widgetConfig || typeof widgetConfig !== "object") return;
+  var welcomeMessage = String(widgetConfig.welcome_message || "").trim();
+  if (welcomeMessage) config.welcomeMessage = welcomeMessage;
+  var disclaimerText = String(widgetConfig.disclaimer_text || "").trim();
+  if (disclaimerText) config.disclaimerText = disclaimerText;
+  var mascotUrl = String(widgetConfig.mascot_asset_svg_url || "").trim();
+  if (mascotUrl) config.mascotUrl = resolveAbsoluteMascotUrl(mascotUrl, config.apiBaseUrl);
+  var chatbotName = String(widgetConfig.chatbot_name || "").trim();
+  if (chatbotName) config.assistantName = chatbotName;
+}
+var TURNSTILE_SCRIPT_URL = "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit";
+var TURNSTILE_CONTAINER_ID = "__ourlu_turnstile_container";
+var TURNSTILE_LOAD_TIMEOUT_MS = 10000;
+var TURNSTILE_CHALLENGE_TIMEOUT_MS = 30000;
+var TURNSTILE_TOKEN_TTL_MS = 240000;
+function TurnstileChallengeManager(siteKey) {
+  this.siteKey = String(siteKey || "").trim();
+  this.scriptLoaded = false;
+  this.scriptLoadPromise = null;
+  this.widgetId = null;
+  this.cachedToken = "";
+  this.cachedTokenTimestamp = 0;
+}
+Object.assign(TurnstileChallengeManager.prototype, {
+  isEnabled: function() { return Boolean(this.siteKey); },
+  loadScript: function() {
+    if (this.scriptLoaded) return Promise.resolve();
+    if (this.scriptLoadPromise) return this.scriptLoadPromise;
+    var self = this;
+    this.scriptLoadPromise = new Promise(function(resolve, reject) {
+      if (typeof window.turnstile !== "undefined") { self.scriptLoaded = true; return resolve(); }
+      var script = document.createElement("script");
+      script.src = TURNSTILE_SCRIPT_URL;
+      script.async = true;
+      var timeoutId = setTimeout(function() {
+        reject(new Error("Turnstile: délai de chargement dépassé"));
+      }, TURNSTILE_LOAD_TIMEOUT_MS);
+      script.onload = function() { clearTimeout(timeoutId); self.scriptLoaded = true; resolve(); };
+      script.onerror = function() { clearTimeout(timeoutId); self.scriptLoadPromise = null; reject(new Error("Turnstile: échec du chargement du script")); };
+      document.head.appendChild(script);
+    });
+    return this.scriptLoadPromise;
+  },
+  ensureContainer: function() {
+    var existing = document.getElementById(TURNSTILE_CONTAINER_ID);
+    if (existing) return existing;
+    var container = document.createElement("div");
+    container.id = TURNSTILE_CONTAINER_ID;
+    container.style.cssText = "display:none;position:fixed;bottom:90px;right:20px;z-index:2147483646;background:#fff;border-radius:12px;padding:16px;box-shadow:0 4px 24px rgba(0,0,0,0.18);";
+    document.body.appendChild(container);
+    return container;
+  },
+  showContainer: function(container) { container.style.display = "block"; },
+  hideContainer: function(container) { container.style.display = "none"; },
+  isCachedTokenValid: function() {
+    return Boolean(this.cachedToken) && (Date.now() - this.cachedTokenTimestamp) < TURNSTILE_TOKEN_TTL_MS;
+  },
+  execute: async function() {
+    if (!this.isEnabled()) return "";
+    if (this.isCachedTokenValid()) return this.cachedToken;
+    await this.loadScript();
+    if (typeof window.turnstile === "undefined") {
+      throw new Error("Turnstile: API non disponible après chargement");
+    }
+    var self = this;
+    var token = await new Promise(function(resolve, reject) {
+      var container = self.ensureContainer();
+      var timeoutId = setTimeout(function() {
+        self.hideContainer(container);
+        self.cleanup();
+        reject(new Error("Turnstile: délai de vérification dépassé"));
+      }, TURNSTILE_CHALLENGE_TIMEOUT_MS);
+      if (self.widgetId !== null) { window.turnstile.remove(self.widgetId); self.widgetId = null; }
+      self.widgetId = window.turnstile.render(container, {
+        sitekey: self.siteKey,
+        language: "fr",
+        appearance: "interaction-only",
+        "before-interactive-callback": function() {
+          self.showContainer(container);
+        },
+        callback: function(freshToken) {
+          clearTimeout(timeoutId);
+          self.hideContainer(container);
+          resolve(freshToken);
+        },
+        "error-callback": function(errorCode) {
+          clearTimeout(timeoutId);
+          self.hideContainer(container);
+          self.cleanup();
+          reject(new Error("Turnstile: erreur de vérification (" + errorCode + ")"));
+        },
+        "timeout-callback": function() {
+          clearTimeout(timeoutId);
+          self.hideContainer(container);
+          self.cleanup();
+          reject(new Error("Turnstile: expiration du challenge"));
+        }
+      });
+    });
+    this.cachedToken = token;
+    this.cachedTokenTimestamp = Date.now();
+    return token;
+  },
+  invalidateCache: function() {
+    this.cachedToken = "";
+    this.cachedTokenTimestamp = 0;
+  },
+  cleanup: function() {
+    if (this.widgetId !== null && typeof window.turnstile !== "undefined") {
+      try { window.turnstile.remove(this.widgetId); } catch (_) {}
+      this.widgetId = null;
+    }
+  },
+  reset: function() {
+    if (this.widgetId !== null && typeof window.turnstile !== "undefined") {
+      try { window.turnstile.reset(this.widgetId); } catch (_) {}
+    }
+  }
+});
+function WidgetApiManager(config, state, events, uiManager, turnstile) {
+  this.config = config;
+  this.state = state;
+  this.events = events;
+  this.uiManager = uiManager;
+  this.turnstile = turnstile || null;
+  this.prefetchedBootstrapAcked = false;
+}
+Object.assign(WidgetApiManager.prototype, {
+  resolveRuntimeUrl: function(pathTemplate, sessionId) {
+    var template = String(pathTemplate || "").trim() || "/v1/occe/chat/sessions";
+    if (sessionId) template = template.replace("{session_id}", encodeURIComponent(String(sessionId)));
+    if (/^https?:\/\//i.test(template)) return template;
+    if (template.charAt(0) !== "/") template = "/" + template;
+    return this.config.apiBaseUrl + template;
+  },
+  resolveWidgetOrigin: function() {
+    if (typeof window !== "undefined" && window.location && window.location.origin) {
+      return String(window.location.origin).trim();
+    }
+    return String(this.config.widgetOrigin || "").trim();
+  },
+  applyRuntimeConfig: function(payload, sourceLabel) {
+    var runtimeConfig = payload && payload.runtime_config ? payload.runtime_config : {};
+    assignRuntimeEndpoints(this.config, runtimeConfig);
+    var incomingTurnstileKey = String((payload && payload.turnstile_site_key) || (runtimeConfig && runtimeConfig.turnstile_site_key) || "").trim();
+    if (incomingTurnstileKey && !this.config.turnstileSiteKey) {
+      this.config.turnstileSiteKey = incomingTurnstileKey;
+      if (!this.turnstile) this.turnstile = new TurnstileChallengeManager(incomingTurnstileKey);
+    }
+    var widgetConfig = payload && payload.widget_config ? payload.widget_config : null;
+    if (!widgetConfig) return;
+    var currentThemeVersion = normalizeThemeVersion(this.config.themeVersion);
+    var incomingThemeVersion = normalizeThemeVersion(widgetConfig.theme_updated_at);
+    if (this.config.hasSnapshotTheme && incomingThemeVersion > 0 && incomingThemeVersion < currentThemeVersion) return;
+    applyWidgetTextConfig(this.config, widgetConfig);
+    applyThemeConfigToRuntime(this.config, widgetConfig);
+    this.config.themeVersion = incomingThemeVersion > 0 ? incomingThemeVersion : currentThemeVersion;
+    this.config.hasSnapshotTheme = this.config.hasSnapshotTheme && this.config.themeVersion > 0;
+    if (this.uiManager && typeof this.uiManager.updateTheme === "function") this.uiManager.updateTheme(this.config);
+    this.events.emit("theme_updated", { source: String(sourceLabel || "runtime_config"), theme_version: this.config.themeVersion || 0 });
+  },
+  buildHeaders: function(extra) {
+    var widgetOrigin = this.resolveWidgetOrigin();
+    var headers = Object.assign({
+      "X-Tenant-ID": this.config.tenantId,
+      "X-Widget-Key": String(this.config.widgetKey || "").trim(),
+      "X-Target-Language": this.config.targetLanguage || "fr"
+    }, extra || {});
+    if (widgetOrigin) headers["X-Widget-Origin"] = widgetOrigin;
+    if (this.state.token) headers.Authorization = "Bearer " + this.state.token;
+    return headers;
+  },
+  parseErrorMessage: async function(response) {
+    var bodyText = "";
+    try { bodyText = await response.text(); } catch (_) {}
+    if (!bodyText) return "HTTP " + response.status;
+    try { var parsed = JSON.parse(bodyText); return parsed.error || parsed.message || ("HTTP " + response.status); } catch (_) { return bodyText.slice(0, 300); }
+  },
+  resolvePublicConfigEndpoint: function() {
+    var endpoint = String(this.config.configEndpoint || "").trim();
+    return endpoint || this.config.apiBaseUrl + "/v1/widget/config";
+  },
+  fetchPublicConfig: async function() {
+    var endpoint = this.resolvePublicConfigEndpoint();
+    var requestUrl = endpoint + (endpoint.indexOf("?") === -1 ? "?" : "&") + [
+      "tenant_id=" + encodeURIComponent(this.config.tenantId || ""),
+      "public_widget_key=" + encodeURIComponent(this.config.widgetKey || ""),
+      "origin=" + encodeURIComponent(window.location.origin || "")
+    ].join("&");
+    var response = await fetch(requestUrl, { method: "GET" });
+    if (!response.ok) {
+      var errorMessage = await this.parseErrorMessage(response);
+      var error = new Error(errorMessage);
+      error.httpStatus = response.status;
+      if (response.status === 403 && this.isWidgetDisabledError(error)) {
+        this.events.emit("widget_disabled", { source: "public_config", code: "WIDGET_DISABLED" });
+        throw error;
+      }
+      throw error;
+    }
+    var payload = await response.json();
+    this.applyRuntimeConfig(payload || {}, "public_config");
+    this.events.emit("public_config_succeeded", payload || {});
+    return payload;
+  },
+  hydrateTheme: async function() {
+    if (this.state.themeHydrationPromise) return this.state.themeHydrationPromise;
+    var self = this;
+    this.state.themeHydrationPromise = this.fetchPublicConfig().catch(async function(publicConfigError) {
+      self.events.emit("public_config_failed", { error: publicConfigError && publicConfigError.message ? publicConfigError.message : "public config failed" });
+      try {
+        return await self.bootstrap();
+      } catch (bootstrapError) {
+        self.events.emit("theme_hydration_failed", {
+          public_config_error: publicConfigError && publicConfigError.message ? publicConfigError.message : "public config failed",
+          bootstrap_error: bootstrapError && bootstrapError.message ? bootstrapError.message : "bootstrap failed"
+        });
+        throw bootstrapError;
+      }
+    }).finally(function() { self.state.themeHydrationPromise = null; });
+    return this.state.themeHydrationPromise;
+  },
+  bootstrap: async function() {
+    if (this.state.token && this.isBootstrapTokenExpired()) {
+      this.state.token = "";
+    }
+    if (this.state.token) {
+      if (!this.prefetchedBootstrapAcked) {
+        this.prefetchedBootstrapAcked = true;
+        this.events.emit("bootstrap_succeeded", {
+          session_bootstrap_token: this.state.token,
+          token_expires_at: this.config.sessionBootstrapTokenExpiresAt || "",
+          preauthorized: true
+        });
+      }
+      return;
+    }
+    if (this.state.bootstrapPromise) return this.state.bootstrapPromise;
+    var self = this;
+    this.state.bootstrapPromise = (async function() {
+      var turnstileToken = "";
+      if (self.turnstile && self.turnstile.isEnabled()) {
+        turnstileToken = await self.turnstile.execute();
+        self.events.emit("turnstile_validated", { token_length: turnstileToken.length });
+      }
+      var bootstrapBody = { tenant_id: self.config.tenantId, public_widget_key: self.config.widgetKey, origin: self.resolveWidgetOrigin() };
+      if (turnstileToken) bootstrapBody.cf_turnstile_token = turnstileToken;
+      return fetch(self.config.bootstrapEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(bootstrapBody)
+      });
+    })().then(async function(response) {
+      if (!response.ok) {
+        var errorMessage = await self.parseErrorMessage(response);
+        var error = new Error(errorMessage);
+        error.httpStatus = response.status;
+        if (response.status === 403 && self.isWidgetDisabledError(error)) {
+          self.events.emit("widget_disabled", { source: "bootstrap", code: "WIDGET_DISABLED" });
+          self.state.bootstrapPromise = null;
+          throw error;
+        }
+        throw error;
+      }
+      var payload = await response.json();
+      self.state.token = payload.session_bootstrap_token || payload.session_token || "";
+      self.config.sessionBootstrapTokenExpiresAt = String(payload.session_bootstrap_token_expires_at || payload.expires_at || "").trim();
+      self.applyRuntimeConfig(payload, "bootstrap");
+      self.events.emit("bootstrap_succeeded", payload || {});
+      return payload;
+    }).catch(function(error) {
+      if (self.isWidgetDisabledError(error)) {
+        self.events.emit("widget_disabled", { source: "bootstrap", code: "WIDGET_DISABLED" });
+        self.state.bootstrapPromise = null;
+        throw error;
+      }
+      self.events.emit("bootstrap_failed", { error: error.message || "bootstrap failed" });
+      self.state.bootstrapPromise = null;
+      throw error;
+    });
+    return this.state.bootstrapPromise;
+  },
+  ensureSession: async function() {
+    if (this.state.sessionId) return this.state.sessionId;
+    if (this.state.sessionPromise) return this.state.sessionPromise;
+    var self = this;
+    this.state.sessionPromise = (async function() {
+      await self.bootstrap();
+      var response = await self.fetchWithBootstrapRetry("create_session", self.config.chatSessionEndpoint, function() {
+        return { method: "POST", headers: self.buildHeaders({ "Content-Type": "application/json" }), body: "{}" };
+      });
+      var payload = await response.json();
+      var sessionId = payload.session_id || payload.id || "";
+      if (!sessionId) throw new Error("chat session id absent");
+      self.state.sessionId = sessionId;
+      self.state.sessionPromise = null;
+      self.events.emit("ready", payload || {});
+      return sessionId;
+    })().catch(function(error) { self.state.sessionPromise = null; throw error; });
+    return this.state.sessionPromise;
+  },
+  isBootstrapTokenExpired: function() {
+    var rawExpiry = String(this.config.sessionBootstrapTokenExpiresAt || "").trim();
+    if (!rawExpiry) return false;
+    var expiryMs = Date.parse(rawExpiry);
+    if (!Number.isFinite(expiryMs)) return false;
+    return Date.now() >= expiryMs;
+  },
+  isWidgetDisabledError: function(error) {
+    var message = String(error && error.message ? error.message : "").toLowerCase();
+    return message.indexOf("widget_disabled") !== -1;
+  },
+  shouldRetryAfterUnauthorized: function(error) {
+    if (this.isWidgetDisabledError(error)) return false;
+    var status = Number(error && error.httpStatus);
+    if (status === 401) return true;
+    var message = String(error && error.message ? error.message : "").toLowerCase();
+    return message.indexOf("401") !== -1 || message.indexOf("unauthorized") !== -1 ||
+      message.indexOf("token expired") !== -1 || message.indexOf("invalid widget token") !== -1 ||
+      message.indexOf("token bootstrap invalide") !== -1 || message.indexOf("invalide ou expir") !== -1 ||
+      message.indexOf("auth_invalid") !== -1;
+  },
+  refreshBootstrapToken: async function() {
+    this.state.token = "";
+    this.state.bootstrapPromise = null;
+    this.prefetchedBootstrapAcked = false;
+    await this.bootstrap();
+  },
+  withBootstrapRetry: async function(operationName, operation) {
+    try {
+      return await operation(0);
+    } catch (error) {
+      if (!this.shouldRetryAfterUnauthorized(error)) throw error;
+      this.events.emit("bootstrap_refresh", { operation: operationName, reason: error && error.message ? error.message : "unauthorized", refresh_attempt: 1 });
+      await this.refreshBootstrapToken();
+      return operation(1);
+    }
+  },
+  fetchWithBootstrapRetry: async function(operationName, endpointPath, buildOptions, sessionId) {
+    var self = this;
+    return this.withBootstrapRetry(operationName, async function(refreshAttempt) {
+      var options = typeof buildOptions === "function" ? buildOptions() : (buildOptions || {});
+      var response = await fetch(self.resolveRuntimeUrl(endpointPath, sessionId), options);
+      if (!response.ok) {
+        var message = await self.parseErrorMessage(response);
+        var error = new Error(refreshAttempt > 0 ? message + " (refresh_attempt=" + refreshAttempt + ")" : message);
+        error.httpStatus = response.status;
+        throw error;
+      }
+      return response;
+    });
+  },
+  postMessage: async function(content) {
+    var sessionId = await this.ensureSession();
+    var self = this;
+    await this.fetchWithBootstrapRetry("post_message", this.config.chatMessageTemplate, function() {
+      return { method: "POST", headers: self.buildHeaders({ "Content-Type": "application/json" }), body: JSON.stringify({ content: content }) };
+    }, sessionId);
+    return sessionId;
+  },
+  consumeSSE: function(reader, callbacks, allowedEvents) {
+    var decoder = new TextDecoder();
+    var pending = "";
+    var currentEvent = "";
+    var allowed = {};
+    allowedEvents.forEach(function(name) { allowed[name] = true; });
+    function dispatch(eventName, payload) {
+      if (!allowed[eventName]) return;
+      if (eventName === "token" && callbacks.onToken) callbacks.onToken(payload.value || "");
+      if (eventName === "final" && callbacks.onFinal) callbacks.onFinal(payload);
+      if (eventName === "done" && callbacks.onDone) callbacks.onDone(payload);
+      if (eventName === "error" && callbacks.onError) callbacks.onError(payload.message || "Erreur de streaming");
+      if (eventName === "transcription_draft_delta" && callbacks.onDelta) callbacks.onDelta(payload);
+      if (eventName === "transcription_draft_complete" && callbacks.onComplete) callbacks.onComplete(payload);
+      if (eventName === "transcription_draft_error" && callbacks.onError) callbacks.onError(payload);
+    }
+    return new Promise(function(resolve, reject) {
+      function step() {
+        reader.read().then(function(result) {
+          if (result.done) return resolve();
+          pending += decoder.decode(result.value, { stream: true });
+          var lines = pending.split("\n");
+          pending = lines.pop() || "";
+          lines.forEach(function(line) {
+            if (line.startsWith("event: ")) currentEvent = line.slice(7).trim();
+            if (line.startsWith("data: ")) {
+              try { dispatch(currentEvent, JSON.parse(line.slice(6))); } catch (_) {}
+              currentEvent = "";
+            }
+          });
+          step();
+        }).catch(reject);
+      }
+      step();
+    });
+  },
+  openEventStream: async function(operationName, endpointPath, sessionId, callbacks, allowedEvents, requestOptions) {
+    var self = this;
+    var response = await this.fetchWithBootstrapRetry(operationName, endpointPath, function() {
+      var options = { method: "GET", headers: self.buildHeaders() };
+      if (requestOptions) Object.assign(options, requestOptions);
+      return options;
+    }, sessionId);
+    if (!response.body) throw new Error("stream response body is missing");
+    return this.consumeSSE(response.body.getReader(), callbacks, allowedEvents);
+  },
+  streamSession: async function(sessionId, callbacks) {
+    return this.openEventStream("stream_session", this.config.chatStreamTemplate, sessionId, callbacks, ["token", "final", "error", "done"]);
+  },
+  streamAudioDraft: async function(sessionId, callbacks) {
+    var self = this;
+    var controller = new AbortController();
+    var streamPromise = this.openEventStream(
+      "audio_stream",
+      this.config.chatAudioStreamTemplate,
+      sessionId,
+      callbacks,
+      ["transcription_draft_delta", "transcription_draft_complete", "transcription_draft_error"],
+      { signal: controller.signal }
+    );
+    streamPromise.catch(function(error) {
+      if (self.isExpectedStreamAbortError(error)) return;
+      if (callbacks.onTransportError) callbacks.onTransportError(error.message || "Erreur stream audio");
+    });
+    return function() { controller.abort(); };
+  },
+  isExpectedStreamAbortError: function(error) {
+    var message = String(error && error.message ? error.message : "").toLowerCase();
+    return message.indexOf("aborted") !== -1 ||
+      message.indexOf("aborterror") !== -1 ||
+      message.indexOf("body stream buffer was aborted") !== -1 ||
+      message.indexOf("signal is aborted") !== -1;
+  },
+  postAudioJson: async function(operationName, endpointPath, sessionId, body) {
+    var self = this;
+    return this.fetchWithBootstrapRetry(operationName, endpointPath, function() {
+      return { method: "POST", headers: self.buildHeaders({ "Content-Type": "application/json" }), body: JSON.stringify(body) };
+    }, sessionId);
+  },
+  startAudioSession: async function(sessionId) {
+    return (await this.postAudioJson("audio_session_start", this.config.chatAudioSessionTemplate, sessionId, { language: "fr", realtime: false, model: "voxtral-mini-latest" })).json();
+  },
+  sendAudioChunk: async function(sessionId, audioSessionId, chunk) {
+    await this.postAudioJson("audio_chunk_send", this.config.chatAudioChunkTemplate, sessionId, { audio_session_id: audioSessionId, chunk: chunk, index: 0 });
+  },
+  closeAudioSession: async function(sessionId, audioSessionId) {
+    await this.postAudioJson("audio_session_close", this.config.chatAudioCloseTemplate, sessionId, { audio_session_id: audioSessionId });
+  }
+});
+function buildConfig(scriptTag) {
+  var themeSnapshot = parseThemeSnapshot(readScriptAttr(scriptTag, "data-theme-snapshot", ""));
+  var initialThemeVersion = normalizeThemeVersion(readScriptAttr(scriptTag, "data-theme-version", ""));
+  var config = {
+    themeSplitEnabled: false,
+    hostPrefersDark: resolveHostPrefersDark(false),
+    effectiveThemeScheme: "light",
+    hasSnapshotTheme: false,
+    themeVersion: initialThemeVersion,
+    disclaimer: readScriptAttr(scriptTag, "data-disclaimer", "true") !== "false"
+  };
+  CONFIG_STRING_ATTRS.forEach(function(row) {
+    var value = readScriptAttr(scriptTag, row[1], row[2]);
+    config[row[0]] = row[0] === "apiBaseUrl" || row[0] === "widgetOrigin" ? trimTrailingSlash(value) : value;
+  });
+  config.primaryColor = readScriptHexAttr(scriptTag, "data-primary-color", "#0066ff");
+  config.position = normalizePosition(readScriptAttr(scriptTag, "data-position", ""), "bottom-right");
+  config.panelBackgroundColor = readScriptHexAttr(scriptTag, "data-panel-background-color", "#ffffff");
+  config.panelBackgroundAlpha = clampNumericString(readScriptAttr(scriptTag, "data-panel-background-alpha", ""), "1", 0, 1, false);
+  config.panelBorderRadius = clampNumericString(readScriptAttr(scriptTag, "data-panel-border-radius", ""), "16", 0, 32, true);
+  config.assistantName = String(readScriptAttr(scriptTag, "data-assistant-name", "Assistant mairie")).trim() || "Assistant mairie";
+  config.targetLanguage = String(readScriptAttr(scriptTag, "data-target-language", "fr")).trim() || "fr";
+  config.themeModeStrategy = normalizeThemeModeStrategy(readScriptAttr(scriptTag, "data-theme-mode-strategy", ""));
+  applyScriptMascotColors(config, scriptTag);
+  if (themeSnapshot && applyThemeConfigToRuntime(config, themeSnapshot)) {
+    config.hasSnapshotTheme = true;
+    if (normalizeThemeVersion(config.themeVersion) === 0) {
+      config.themeVersion = normalizeThemeVersion(themeSnapshot.theme_updated_at);
+    }
+  }
+  config.effectiveThemeScheme = resolvePreferredThemeScheme(config);
+  if (!config.apiBaseUrl) config.apiBaseUrl = config.widgetOrigin || trimTrailingSlash(window.location.origin);
+  if (!config.bootstrapEndpoint) config.bootstrapEndpoint = config.apiBaseUrl + "/v1/occe/chat/bootstrap";
+  if (!config.configEndpoint) config.configEndpoint = config.apiBaseUrl + "/v1/widget/config";
+  if (!config.mascotUrl) config.mascotUrl = "/v1/widget/assets/chouette_ourlu.svg";
+  config.mascotUrl = resolveAbsoluteMascotUrl(config.mascotUrl, config.apiBaseUrl);
+  return config;
+}
+function mountFromScript(scriptTag) {
+  if (!scriptTag || !scriptTag.getAttribute("data-tenant-id")) {
+    console.error("[OurluMairie] Loader: data-tenant-id is required.");
+    return;
+  }
+  if (document.getElementById(CONTAINER_ID)) return;
+  var config = buildConfig(scriptTag);
+  var events = new EventBus();
+  var state = { open: false, sessionId: "", token: config.sessionBootstrapToken || "", sending: false, listening: false, bootstrapPromise: null, sessionPromise: null };
+  var ui = new WidgetUIManager(config);
+  if (!ui.mount()) return;
+  var turnstile = config.turnstileSiteKey ? new TurnstileChallengeManager(config.turnstileSiteKey) : null;
+  var api = new WidgetApiManager(config, state, events, ui, turnstile);
+  var audio = new WidgetAudioManager(state, api, ui);
+  if (!audio.isSupported()) ui.micButton.style.display = "none";
+  api.hydrateTheme().catch(function() {});
+  var mediaQueryList = null;
+  var handleHostThemeChange = null;
+  if (typeof window.matchMedia === "function") {
+    mediaQueryList = window.matchMedia("(prefers-color-scheme: dark)");
+    handleHostThemeChange = function(event) {
+      if (normalizeThemeModeStrategy(config.themeModeStrategy) !== "auto_follow_host") return;
+      config.hostPrefersDark = Boolean(event && event.matches);
+      config.effectiveThemeScheme = resolvePreferredThemeScheme(config);
+      ui.updateTheme(config);
+    };
+    if (typeof mediaQueryList.addEventListener === "function") mediaQueryList.addEventListener("change", handleHostThemeChange);
+    else if (typeof mediaQueryList.addListener === "function") mediaQueryList.addListener(handleHostThemeChange);
+  }
+  async function handleSend(event) {
+    event.preventDefault();
+    if (state.sending || state.listening) return;
+    var message = ui.pullInput();
+    if (!message) return;
+    state.sending = true;
+    ui.showError("");
+    ui.addMessage("user", message);
+    ui.showTyping(true);
+    ui.setComposerDisabled(true);
+    try {
+      var sessionId = await api.postMessage(message);
+      ui.startAssistantStream();
+      await api.streamSession(sessionId, {
+        onToken: function(token) { ui.appendAssistantToken(token); },
+        onFinal: function(payload) { ui.finalizeAssistantMessage(payload.content || ""); },
+        onError: function(errorText) { ui.showError(errorText || "Erreur de streaming."); },
+        onDone: function() {}
+      });
+    } catch (error) {
+      ui.showError((error && error.message) || "Impossible d'envoyer le message.");
+    } finally {
+      state.sending = false;
+      ui.showTyping(false);
+      ui.setComposerDisabled(false);
+    }
+  }
+  function togglePanel() {
+    state.open = !state.open;
+    ui.setOpen(state.open);
+    events.emit(state.open ? "open" : "close", {});
+    if (state.open) {
+      api.ensureSession().catch(function(error) {
+        ui.showError((error && error.message) || "Impossible d'initialiser le chat.");
+      });
+    }
+  }
+  ui.bind({
+    onToggle: togglePanel,
+    onSend: handleSend,
+    onMicToggle: function() {
+      audio.toggle().catch(function(error) {
+        state.listening = false;
+        ui.setMicListening(false);
+        ui.showError((error && error.message) || "Erreur micro.");
+      });
+    },
+    onEscape: function(event) { if (event.key === "Escape" && state.open) togglePanel(); }
+  });
+  var instance = { version: WIDGET_VERSION, open: function() { if (!state.open) togglePanel(); }, close: function() { if (state.open) togglePanel(); }, destroy: function() {
+    if (mediaQueryList && handleHostThemeChange) {
+      if (typeof mediaQueryList.removeEventListener === "function") mediaQueryList.removeEventListener("change", handleHostThemeChange);
+      else if (typeof mediaQueryList.removeListener === "function") mediaQueryList.removeListener(handleHostThemeChange);
+    }
+    if (audio.stopDraftStream) audio.stopDraftStream();
+    audio.cleanupMedia();
+    if (ui.host && ui.host.parentNode) ui.host.parentNode.removeChild(ui.host);
+  }, on: function(eventName, handler) { events.on(eventName, handler); } };
+  events.on("widget_disabled", function() {
+    instance.destroy();
+    window[WIDGET_NS] = null;
+    window.OurluWidget = null;
+  });
+  window[WIDGET_NS] = instance;
+  window.OurluWidget = { instance: instance };
+}
+  runtime.mountFromScript = mountFromScript;
+})();