@memberjunction/realtime-widget 6.2.0-edge.5 → 6.2.0-edge.6

package/dist/embed/mj-widget.js

@@ -0,0 +1,1056 @@
+import {
+  DEFAULT_VOICE_LIMITS
+} from "./chunks/chunk-S3LX5KYE.js";
+import {
+  CreateProofOfPossessionJwt,
+  CreateProofOfPossessionKey
+} from "./chunks/chunk-ZX4SRAYD.js";
+
+// dist/ui/tokens.js
+var WIDGET_SHADOW_STYLES = `
+:host {
+    /* base semantic tokens (shadow root needs its own \u2014 it can't see the app :root) */
+    --mj-text-primary: #1f2933;
+    --mj-text-secondary: #52606d;
+    --mj-text-inverse: #ffffff;
+    --mj-bg-surface: #ffffff;
+    --mj-bg-surface-card: #f5f7fa;
+    --mj-bg-surface-sunken: #eef1f5;
+    --mj-border-default: #e2e8f0;
+    --mj-brand-primary: #264faf;
+    --mj-brand-primary-hover: #1d3f8c;
+    --mj-status-error: #dc2626;
+    --mj-status-error-text: #b91c1c;
+    --mj-status-error-bg: #fef2f2;
+
+    /* chat tokens (mirror the Angular bootstrap names) */
+    --mj-chat-bubble-user-bg: var(--mj-brand-primary);
+    --mj-chat-bubble-user-text: var(--mj-text-inverse);
+    --mj-chat-bubble-agent-bg: var(--mj-bg-surface-card);
+    --mj-chat-bubble-agent-text: var(--mj-text-primary);
+    --mj-chat-composer-bg: var(--mj-bg-surface);
+    --mj-chat-composer-border: var(--mj-border-default);
+
+    all: initial;
+    font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+    color: var(--mj-text-primary);
+}
+
+* { box-sizing: border-box; }
+
+.mj-widget-launcher {
+    position: fixed; right: 20px; bottom: 20px;
+    width: 56px; height: 56px; border-radius: 50%;
+    background: var(--mj-brand-primary); color: var(--mj-text-inverse);
+    border: none; cursor: pointer; font-size: 24px;
+    box-shadow: 0 4px 12px color-mix(in srgb, var(--mj-text-primary) 25%, transparent);
+}
+.mj-widget-launcher:hover { background: var(--mj-brand-primary-hover); }
+
+.mj-widget-panel {
+    position: fixed; right: 20px; bottom: 88px;
+    width: 360px; max-width: calc(100vw - 40px); height: 520px; max-height: calc(100vh - 120px);
+    display: flex; flex-direction: column;
+    background: var(--mj-bg-surface); border: 1px solid var(--mj-border-default);
+    border-radius: 12px; overflow: hidden;
+    box-shadow: 0 8px 28px color-mix(in srgb, var(--mj-text-primary) 22%, transparent);
+}
+.mj-widget-panel[hidden] { display: none; }
+
+.mj-widget-header {
+    padding: 12px 16px; background: var(--mj-brand-primary); color: var(--mj-text-inverse);
+    display: flex; align-items: center; justify-content: space-between; font-weight: 600;
+}
+.mj-widget-close { background: none; border: none; color: var(--mj-text-inverse); cursor: pointer; font-size: 18px; }
+
+.mj-widget-transcript {
+    flex: 1; overflow-y: auto; padding: 12px; display: flex; flex-direction: column; gap: 8px;
+    background: var(--mj-bg-surface-sunken);
+}
+.mj-widget-empty { color: var(--mj-text-secondary); text-align: center; margin: auto; padding: 16px; }
+
+.mj-widget-msg { max-width: 80%; padding: 8px 12px; border-radius: 12px; white-space: pre-wrap; word-break: break-word; }
+.mj-widget-msg.user { align-self: flex-end; background: var(--mj-chat-bubble-user-bg); color: var(--mj-chat-bubble-user-text); }
+.mj-widget-msg.agent { align-self: flex-start; background: var(--mj-chat-bubble-agent-bg); color: var(--mj-chat-bubble-agent-text); }
+.mj-widget-msg.system { align-self: center; color: var(--mj-status-error-text); font-size: 0.85em; }
+
+.mj-widget-progress { align-self: flex-start; color: var(--mj-text-secondary); font-size: 0.85em; font-style: italic; }
+.mj-widget-progress[hidden] { display: none; }
+
+/* Interactive-channel demonstration surface (Phase 2 \u2014 e.g. the Whiteboard the agent draws on during voice). */
+.mj-widget-surface { display: flex; flex-direction: column; border-bottom: 1px solid var(--mj-border-default); background: var(--mj-bg-surface); }
+.mj-widget-surface[hidden] { display: none; }
+.mj-widget-surface-title { padding: 6px 12px; font-size: 0.8em; font-weight: 600; color: var(--mj-text-secondary); background: var(--mj-bg-surface-card); }
+.mj-widget-surface-host { height: 200px; width: 100%; background: var(--mj-bg-surface); overflow: hidden; }
+.mj-widget-surface-host svg { display: block; width: 100%; height: 100%; }
+
+.mj-widget-composer {
+    display: flex; gap: 8px; padding: 10px; border-top: 1px solid var(--mj-chat-composer-border);
+    background: var(--mj-chat-composer-bg);
+}
+.mj-widget-input {
+    flex: 1; resize: none; padding: 8px 10px; border: 1px solid var(--mj-border-default);
+    border-radius: 8px; font: inherit; color: var(--mj-text-primary); background: var(--mj-bg-surface);
+}
+.mj-widget-send {
+    background: var(--mj-brand-primary); color: var(--mj-text-inverse); border: none;
+    border-radius: 8px; padding: 0 14px; cursor: pointer; font: inherit;
+}
+.mj-widget-send:disabled { opacity: 0.5; cursor: default; }
+
+/* Connection-lost banner (graceful degradation, W6) */
+.mj-widget-banner {
+    display: flex; align-items: center; gap: 8px; padding: 8px 12px;
+    background: var(--mj-status-error-bg); color: var(--mj-status-error-text);
+    border-bottom: 1px solid color-mix(in srgb, var(--mj-status-error) 35%, transparent);
+    font-size: 0.85em;
+}
+.mj-widget-banner[hidden] { display: none; }
+.mj-widget-banner-text { flex: 1; }
+.mj-widget-banner-retry {
+    background: var(--mj-status-error); color: var(--mj-text-inverse); border: none;
+    border-radius: 6px; padding: 4px 10px; cursor: pointer; font: inherit; font-size: 0.95em;
+}
+.mj-widget-banner-retry:hover { background: var(--mj-status-error-text); }
+.mj-widget-memory-notice {
+    display: flex; align-items: center; gap: 8px; padding: 6px 12px;
+    background: var(--mj-bg-surface-sunken); color: var(--mj-text-secondary);
+    border-top: 1px solid var(--mj-border-default);
+    font-size: 0.75em;
+}
+.mj-widget-memory-notice-text { flex: 1; }
+.mj-widget-forget {
+    background: none; color: var(--mj-text-secondary); border: none;
+    padding: 2px 4px; cursor: pointer; font: inherit; font-size: 1em;
+    text-decoration: underline; white-space: nowrap;
+}
+.mj-widget-forget:hover { color: var(--mj-text-primary); }
+.mj-widget-forget:disabled { opacity: 0.6; cursor: default; }
+`;
+
+// dist/ui/browser-capabilities.js
+function VoiceIsSupported(nav = typeof navigator !== "undefined" ? navigator : void 0, win = typeof window !== "undefined" ? window : void 0) {
+  if (!nav || !win)
+    return false;
+  if (win.isSecureContext !== true)
+    return false;
+  return typeof nav.mediaDevices?.getUserMedia === "function";
+}
+
+// dist/ui/support-widget-element.js
+var WIDGET_TAG_NAME = "mj-support-widget";
+var SupportWidgetElement = class extends HTMLElement {
+  constructor() {
+    super();
+    this.transport = null;
+    this.voiceController = null;
+    this.session = null;
+    this.messages = [];
+    this.sending = false;
+    this.voiceActive = false;
+    this.headerTitle = "Support";
+    this.greeting = "Hi! How can we help you today?";
+    this.pendingRetry = null;
+    this.forgetHandler = null;
+    this.forgetting = false;
+    this.voiceSupportedProbe = () => VoiceIsSupported();
+    this.trapHandler = (e) => this.onPanelKeydown(e);
+    this.root = this.attachShadow({ mode: "open" });
+  }
+  connectedCallback() {
+    this.render();
+  }
+  /** Sets the UI title + greeting (called by the loader before mount). */
+  Configure(options) {
+    if (options.title)
+      this.headerTitle = options.title;
+    if (options.greeting)
+      this.greeting = options.greeting;
+    if (this.isConnected)
+      this.render();
+  }
+  /** Injects the minted session (drives modality/agent pinning). */
+  SetSession(session) {
+    this.session = session;
+  }
+  /** Injects the transport the element sends turns through. */
+  SetTransport(transport) {
+    this.transport = transport;
+  }
+  /**
+   * Wires the RV5 "forget me" action. The loader supplies a handler that archives the visitor's
+   * server-side memory and clears the durable cookie. When set (and the widget remembers returning
+   * visitors), a privacy notice + "Forget me" control render below the composer.
+   */
+  SetForgetHandler(handler) {
+    this.forgetHandler = handler;
+    if (this.isConnected)
+      this.render();
+  }
+  /** Injects the voice controller (enables the mic button when modality allows voice). */
+  SetVoiceController(controller) {
+    this.voiceController = controller;
+    if (this.isConnected)
+      this.render();
+  }
+  /** Overrides the voice capability probe (used by tests to simulate unsupported browsers). */
+  SetVoiceSupportedProbe(probe) {
+    this.voiceSupportedProbe = probe;
+    if (this.isConnected)
+      this.render();
+  }
+  /** Opens the chat panel, traps focus inside it, and focuses the composer. */
+  Open() {
+    const panel = this.panel();
+    if (!panel)
+      return;
+    panel.removeAttribute("hidden");
+    panel.addEventListener("keydown", this.trapHandler);
+    this.input()?.focus();
+  }
+  /** Closes the chat panel, releases the focus trap, and returns focus to the launcher. */
+  Close() {
+    const panel = this.panel();
+    panel?.setAttribute("hidden", "");
+    panel?.removeEventListener("keydown", this.trapHandler);
+    this.launcher()?.focus();
+  }
+  // ── rendering ────────────────────────────────────────────────────────────
+  render() {
+    this.root.innerHTML = "";
+    const style = document.createElement("style");
+    style.textContent = WIDGET_SHADOW_STYLES;
+    this.root.append(style, this.buildLauncher(), this.buildPanel());
+    this.renderTranscript();
+  }
+  buildLauncher() {
+    const btn = document.createElement("button");
+    btn.className = "mj-widget-launcher";
+    btn.type = "button";
+    btn.textContent = "\u{1F4AC}";
+    btn.setAttribute("aria-label", "Open support chat");
+    btn.addEventListener("click", () => this.Open());
+    return btn;
+  }
+  buildPanel() {
+    const panel = document.createElement("section");
+    panel.className = "mj-widget-panel";
+    panel.setAttribute("hidden", "");
+    panel.setAttribute("role", "dialog");
+    panel.setAttribute("aria-label", `${this.headerTitle} chat`);
+    panel.append(this.buildHeader(), this.buildBanner(), this.buildDemonstrationSurface(), this.buildTranscriptContainer(), this.buildProgress(), this.buildComposer());
+    const notice = this.buildMemoryNotice();
+    if (notice) {
+      panel.append(notice);
+    }
+    return panel;
+  }
+  /**
+   * RV5 visitor-facing privacy notice + "Forget me" control. Rendered only when this widget remembers
+   * returning visitors AND a forget handler is wired — otherwise returns null (no notice, no control),
+   * keeping the default (memory-off) widget unchanged.
+   */
+  buildMemoryNotice() {
+    if (!this.session?.rememberReturningVisitors || !this.forgetHandler) {
+      return null;
+    }
+    const notice = document.createElement("div");
+    notice.className = "mj-widget-memory-notice";
+    const text = document.createElement("span");
+    text.className = "mj-widget-memory-notice-text";
+    text.textContent = "We remember your past chats to help you faster.";
+    const forget = document.createElement("button");
+    forget.className = "mj-widget-forget";
+    forget.type = "button";
+    forget.textContent = "Forget me";
+    forget.addEventListener("click", () => void this.onForgetClicked());
+    notice.append(text, forget);
+    return notice;
+  }
+  /** Invokes the wired forget handler, then surfaces a confirmation as a system line. */
+  async onForgetClicked() {
+    if (this.forgetting || !this.forgetHandler) {
+      return;
+    }
+    this.forgetting = true;
+    const forget = this.query(".mj-widget-forget");
+    if (forget) {
+      forget.disabled = true;
+    }
+    try {
+      await this.forgetHandler();
+      this.appendMessage("system", "Your saved chat history has been forgotten.");
+    } catch {
+      this.appendMessage("system", "Could not forget your history right now. Please try again later.");
+    } finally {
+      this.forgetting = false;
+      if (forget) {
+        forget.disabled = false;
+      }
+    }
+  }
+  /** The connection-lost banner (hidden until a send / token refresh fails). */
+  buildBanner() {
+    const banner = document.createElement("div");
+    banner.className = "mj-widget-banner";
+    banner.setAttribute("hidden", "");
+    banner.setAttribute("role", "alert");
+    const text = document.createElement("span");
+    text.className = "mj-widget-banner-text";
+    const retry = document.createElement("button");
+    retry.className = "mj-widget-banner-retry";
+    retry.type = "button";
+    retry.textContent = "Retry";
+    retry.addEventListener("click", () => this.onRetryClicked());
+    banner.append(text, retry);
+    return banner;
+  }
+  buildHeader() {
+    const header = document.createElement("header");
+    header.className = "mj-widget-header";
+    const title = document.createElement("span");
+    title.textContent = this.headerTitle;
+    const controls = document.createElement("span");
+    if (this.voiceEnabled()) {
+      controls.appendChild(this.buildVoiceButton());
+    }
+    const close = document.createElement("button");
+    close.className = "mj-widget-close";
+    close.type = "button";
+    close.textContent = "\xD7";
+    close.setAttribute("aria-label", "Close support chat");
+    close.addEventListener("click", () => this.Close());
+    controls.appendChild(close);
+    header.append(title, controls);
+    return header;
+  }
+  buildTranscriptContainer() {
+    const transcript = document.createElement("div");
+    transcript.className = "mj-widget-transcript";
+    transcript.setAttribute("role", "log");
+    transcript.setAttribute("aria-live", "polite");
+    return transcript;
+  }
+  /**
+   * The interactive-channel demonstration surface (Phase 2): a titled stage an MJ channel (e.g. the
+   * Whiteboard) renders into while voice is active. Hidden until a channel's first tool call reveals it
+   * via {@link RevealChannelSurface}; a widget with no enabled channels never shows it.
+   */
+  buildDemonstrationSurface() {
+    const surface = document.createElement("div");
+    surface.className = "mj-widget-surface";
+    surface.setAttribute("hidden", "");
+    const title = document.createElement("div");
+    title.className = "mj-widget-surface-title";
+    const host = document.createElement("div");
+    host.className = "mj-widget-surface-host";
+    surface.append(title, host);
+    return surface;
+  }
+  /**
+   * Reveals the demonstration surface for an interactive channel and returns the inner host element the
+   * channel renders into. Called (via the voice callbacks) the first time the agent engages a channel.
+   */
+  RevealChannelSurface(_channelName, title) {
+    const surface = this.query(".mj-widget-surface");
+    const titleEl = this.query(".mj-widget-surface-title");
+    const host = this.query(".mj-widget-surface-host");
+    if (titleEl)
+      titleEl.textContent = title;
+    surface?.removeAttribute("hidden");
+    return host ?? document.createElement("div");
+  }
+  /** Hides + clears the demonstration surface (on voice end). */
+  hideChannelSurface() {
+    const surface = this.query(".mj-widget-surface");
+    surface?.setAttribute("hidden", "");
+    const host = this.query(".mj-widget-surface-host");
+    if (host)
+      host.innerHTML = "";
+  }
+  buildProgress() {
+    const progress = document.createElement("div");
+    progress.className = "mj-widget-progress";
+    progress.setAttribute("hidden", "");
+    return progress;
+  }
+  buildComposer() {
+    const form = document.createElement("form");
+    form.className = "mj-widget-composer";
+    const input = document.createElement("textarea");
+    input.className = "mj-widget-input";
+    input.rows = 1;
+    input.setAttribute("aria-label", "Type your message");
+    input.placeholder = "Type your message\u2026";
+    input.addEventListener("keydown", (e) => this.onComposerKeydown(e));
+    const send = document.createElement("button");
+    send.className = "mj-widget-send";
+    send.type = "submit";
+    send.textContent = "Send";
+    form.append(input, send);
+    form.addEventListener("submit", (e) => {
+      e.preventDefault();
+      void this.sendCurrent();
+    });
+    return form;
+  }
+  renderTranscript() {
+    const transcript = this.query(".mj-widget-transcript");
+    if (!transcript)
+      return;
+    transcript.innerHTML = "";
+    if (this.messages.length === 0) {
+      const empty = document.createElement("div");
+      empty.className = "mj-widget-empty";
+      empty.textContent = this.greeting;
+      transcript.appendChild(empty);
+      return;
+    }
+    for (const msg of this.messages) {
+      const el = document.createElement("div");
+      el.className = `mj-widget-msg ${msg.role}`;
+      el.textContent = msg.text;
+      transcript.appendChild(el);
+    }
+    transcript.scrollTop = transcript.scrollHeight;
+  }
+  // ── interaction ──────────────────────────────────────────────────────────
+  onComposerKeydown(e) {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      void this.sendCurrent();
+    } else if (e.key === "Escape") {
+      this.Close();
+    }
+  }
+  // ── focus trap (W6 accessibility) ──────────────────────────────────────────
+  /** Keeps Tab focus cycling within the open panel; Esc still closes. */
+  onPanelKeydown(e) {
+    if (e.key === "Escape") {
+      this.Close();
+      return;
+    }
+    if (e.key !== "Tab")
+      return;
+    const focusables = this.focusableElements();
+    if (focusables.length === 0)
+      return;
+    const first = focusables[0];
+    const last = focusables[focusables.length - 1];
+    const active = this.activeWithinPanel();
+    if (e.shiftKey && active === first) {
+      e.preventDefault();
+      last.focus();
+    } else if (!e.shiftKey && active === last) {
+      e.preventDefault();
+      first.focus();
+    }
+  }
+  /** The focusable controls inside the panel, in DOM order, excluding hidden subtrees. */
+  focusableElements() {
+    const panel = this.panel();
+    if (!panel)
+      return [];
+    const selector = 'button:not([disabled]), textarea:not([disabled]), input:not([disabled]), [tabindex]:not([tabindex="-1"])';
+    return Array.from(panel.querySelectorAll(selector)).filter((el) => !this.isInHiddenSubtree(el, panel));
+  }
+  /** True when the element (or an ancestor up to the panel) carries the `hidden` attribute. */
+  isInHiddenSubtree(el, panel) {
+    let node = el;
+    while (node && node !== panel) {
+      if (node.hasAttribute("hidden"))
+        return true;
+      node = node.parentElement;
+    }
+    return false;
+  }
+  /** The currently-focused element, resolved through the shadow root. */
+  activeWithinPanel() {
+    const active = this.root.activeElement;
+    return active instanceof HTMLElement ? active : null;
+  }
+  /** Reads the composer, appends the user turn, dispatches it, renders the reply. */
+  async sendCurrent() {
+    const input = this.input();
+    const text = input?.value.trim() ?? "";
+    if (!text || this.sending)
+      return;
+    if (!this.transport) {
+      this.appendMessage("system", "Support is not connected yet. Please try again in a moment.");
+      return;
+    }
+    if (input)
+      input.value = "";
+    this.appendMessage("user", text);
+    await this.dispatchTurn(text);
+  }
+  /** Sends one turn through the transport and renders progress + the reply. */
+  async dispatchTurn(text) {
+    this.setSending(true);
+    try {
+      const result = await this.transport.SendMessage(text, (m) => this.showProgress(m));
+      if (result.success) {
+        this.clearConnectionError();
+        this.appendMessage("agent", result.reply || "(no response)");
+      } else {
+        this.ShowConnectionError(result.error ?? "Message could not be sent.", () => void this.dispatchTurn(text));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Connection lost.";
+      this.ShowConnectionError(msg, () => void this.dispatchTurn(text));
+    } finally {
+      this.hideProgress();
+      this.setSending(false);
+    }
+  }
+  appendMessage(role, text) {
+    this.messages.push({ role, text, timestampMs: Date.now() });
+    this.renderTranscript();
+  }
+  showProgress(message) {
+    const progress = this.query(".mj-widget-progress");
+    if (!progress)
+      return;
+    progress.textContent = message;
+    progress.removeAttribute("hidden");
+  }
+  hideProgress() {
+    this.query(".mj-widget-progress")?.setAttribute("hidden", "");
+  }
+  setSending(sending) {
+    this.sending = sending;
+    const send = this.query(".mj-widget-send");
+    if (send)
+      send.disabled = sending;
+  }
+  // ── voice (W4) ─────────────────────────────────────────────────────────────
+  /**
+   * Voice is offered only when a controller is wired, the instance enables Voice/Both,
+   * AND the browser can actually capture the mic (secure context + getUserMedia). On an
+   * insecure origin or an unsupported browser the mic affordance is hidden and the
+   * visitor falls back to text (graceful degradation, W6).
+   */
+  voiceEnabled() {
+    const modalityAllows = this.session?.modality === "Voice" || this.session?.modality === "Both";
+    return this.voiceController !== null && modalityAllows && this.voiceSupportedProbe();
+  }
+  buildVoiceButton() {
+    const btn = document.createElement("button");
+    btn.className = "mj-widget-close mj-widget-voice";
+    btn.type = "button";
+    btn.textContent = this.voiceActive ? "\u23F9" : "\u{1F3A4}";
+    btn.setAttribute("aria-label", this.voiceActive ? "Stop voice" : "Start voice");
+    btn.setAttribute("aria-pressed", String(this.voiceActive));
+    btn.addEventListener("click", () => void this.toggleVoice());
+    return btn;
+  }
+  /** Starts or stops a voice session via the injected controller. */
+  async toggleVoice() {
+    if (!this.voiceController)
+      return;
+    if (this.voiceActive) {
+      await this.voiceController.Stop();
+      return;
+    }
+    try {
+      await this.voiceController.Start({
+        onState: (s) => this.onVoiceState(s),
+        onTranscript: (t) => {
+          if (t.isFinal && t.text.trim())
+            this.appendMessage(t.role, t.text);
+        },
+        onEnded: (reason) => this.onVoiceEnded(reason),
+        // Phase 2: an MJ interactive channel reveals its surface here on first use.
+        getChannelSurface: (name, title) => this.RevealChannelSurface(name, title)
+      });
+    } catch (err) {
+      this.appendMessage("system", err instanceof Error ? err.message : "Could not start voice.");
+      this.onVoiceEnded();
+    }
+  }
+  onVoiceState(state) {
+    this.voiceActive = state !== "idle" && state !== "ended" && state !== "error";
+    this.refreshVoiceButton();
+    if (state === "listening")
+      this.showProgress("\u{1F399} Listening\u2026");
+    else if (state === "speaking")
+      this.showProgress("\u{1F50A} Speaking\u2026");
+    else
+      this.hideProgress();
+  }
+  onVoiceEnded(reason) {
+    this.voiceActive = false;
+    this.refreshVoiceButton();
+    this.hideProgress();
+    this.hideChannelSurface();
+    if (reason)
+      this.appendMessage("system", reason);
+  }
+  refreshVoiceButton() {
+    const btn = this.query(".mj-widget-voice");
+    if (!btn)
+      return;
+    btn.textContent = this.voiceActive ? "\u23F9" : "\u{1F3A4}";
+    btn.setAttribute("aria-label", this.voiceActive ? "Stop voice" : "Start voice");
+    btn.setAttribute("aria-pressed", String(this.voiceActive));
+  }
+  // ── small DOM accessors (testable) ─────────────────────────────────────────
+  /** Surfaces a system/notification line in the transcript (used by the notification adapter). */
+  ShowSystemMessage(text) {
+    this.appendMessage("system", text);
+  }
+  /**
+   * Shows the connection-lost banner with a retry affordance. Used when a send fails or
+   * a token refresh fails (graceful degradation, W6). Invoking the banner's Retry button
+   * (or {@link RetryConnection}) runs the supplied action and clears the banner on success.
+   *
+   * @param message  The user-facing reason shown in the banner.
+   * @param retry    The action to run when the visitor clicks Retry.
+   */
+  ShowConnectionError(message, retry) {
+    this.pendingRetry = retry;
+    const banner = this.query(".mj-widget-banner");
+    const text = this.query(".mj-widget-banner-text");
+    if (text)
+      text.textContent = message;
+    banner?.removeAttribute("hidden");
+  }
+  /** Programmatically triggers the pending retry (same effect as clicking Retry). */
+  RetryConnection() {
+    this.onRetryClicked();
+  }
+  /** Hides the connection-lost banner and drops the pending retry. */
+  clearConnectionError() {
+    this.pendingRetry = null;
+    this.query(".mj-widget-banner")?.setAttribute("hidden", "");
+  }
+  /** Runs the pending retry (if any) and hides the banner; the retry re-shows it on a repeat failure. */
+  onRetryClicked() {
+    const retry = this.pendingRetry;
+    this.clearConnectionError();
+    retry?.();
+  }
+  /** Exposes the shadow root for tests + integration code. */
+  get ShadowRootRef() {
+    return this.root;
+  }
+  query(selector) {
+    return this.root.querySelector(selector);
+  }
+  panel() {
+    return this.query(".mj-widget-panel");
+  }
+  launcher() {
+    return this.query(".mj-widget-launcher");
+  }
+  input() {
+    return this.query(".mj-widget-input");
+  }
+};
+function DefineSupportWidgetElement() {
+  if (typeof customElements !== "undefined" && !customElements.get(WIDGET_TAG_NAME)) {
+    customElements.define(WIDGET_TAG_NAME, SupportWidgetElement);
+  }
+}
+
+// dist/session/widget-session-client.js
+var WidgetSessionError = class extends Error {
+  constructor(message, Status, Code) {
+    super(message);
+    this.Status = Status;
+    this.Code = Code;
+    this.name = "WidgetSessionError";
+  }
+  /**
+   * True when the server refused for good (401/403): retrying the same request cannot succeed, so the
+   * caller must start a new session. Rate limits (429), server faults (5xx) and network failures are temporary.
+   */
+  get IsRefused() {
+    return this.Status === 401 || this.Status === 403;
+  }
+};
+var REFRESH_LEAD_MS = 6e4;
+var MIN_REFRESH_DELAY_MS = 5e3;
+var WidgetSessionClient = class {
+  constructor(apiUrl, widgetKey, fetchImpl) {
+    this.apiUrl = apiUrl;
+    this.widgetKey = widgetKey;
+    this.proofKey = null;
+    this.serverOffsetMs = 0;
+    this.fetchImpl = fetchImpl ?? ((input, init) => fetch(input, init));
+  }
+  /**
+   * Mints a fresh guest session. Throws on a non-2xx / unsuccessful response.
+   * @param visitorKey the durable returning-visitor anchor from the first-party cookie, if present —
+   *   the server uses it to chain this visit to the visitor's prior conversation (gated on the widget's
+   *   RememberReturningVisitors toggle). Omit on a first visit; the server mints one when remembering is on.
+   */
+  async Mint(visitorKey) {
+    const key = await CreateProofOfPossessionKey();
+    const session = await this.call("/widget/session", visitorKey, void 0, key);
+    this.proofKey = key;
+    return session;
+  }
+  /** Refreshes the guest session (server re-mints by the same key while verifying the current token to
+   *  preserve `mj_sid`). Carries the visitor anchor so the refreshed session keeps the same
+   *  returning-visitor identity. */
+  async Refresh(currentToken, visitorKey) {
+    if (!this.proofKey) {
+      throw new Error("Widget session refresh needs the key registered at mint; call Mint first.");
+    }
+    return this.call("/widget/session/refresh", visitorKey, currentToken, this.proofKey);
+  }
+  /**
+   * W5 magic-link upgrade ("Verify it's you"): asks the server to email a verification link scoped to
+   * the widget's app. On success the visitor receives an email; clicking it redeems a VERIFIED session
+   * JWT (via the existing `/magic-link/redeem`). The host page hands that token back to the widget,
+   * which calls `transport.UpdateToken(verifiedToken)` to swap it in — the live conversationId is
+   * preserved because the transport holds it. Never throws; returns a structured result for the UI.
+   */
+  async RequestUpgrade(email) {
+    try {
+      const res = await this.fetchImpl(`${this.trimmedApiUrl()}/widget/upgrade`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ widgetKey: this.widgetKey, email })
+      });
+      const body = await res.json();
+      if (!res.ok || !body?.success) {
+        return { success: false, error: body?.error ?? body?.errorCode ?? "Could not start verification." };
+      }
+      return { success: true, emailSent: body.emailSent };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : "Could not start verification." };
+    }
+  }
+  /**
+   * RV5 "forget me": asks the server to archive this visitor's memory and clear the VisitorKey
+   * linkage. The caller is responsible for clearing the durable cookie afterward
+   * (`clearVisitorKey`). Public endpoint — the durable key is the proof. Never throws.
+   */
+  async Forget(visitorKey) {
+    try {
+      const res = await this.fetchImpl(`${this.trimmedApiUrl()}/widget/forget`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ widgetKey: this.widgetKey, visitorKey })
+      });
+      const body = await res.json();
+      if (!res.ok || !body?.success) {
+        return { success: false, error: body?.error ?? body?.errorCode ?? "Could not forget this visitor." };
+      }
+      return { success: true, notesArchived: body.notesArchived };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : "Could not forget this visitor." };
+    }
+  }
+  /**
+   * RV4 (magic-link upgrade path): after the visitor verifies and the widget swaps in the VERIFIED
+   * token, promote their anonymous returning-visitor trail to the verified record. AUTHENTICATED —
+   * the verified token is sent as a Bearer credential; the server reads the verified email from it.
+   * Never throws; returns a structured result.
+   */
+  async ResolveIdentity(verifiedToken, visitorKey) {
+    try {
+      const res = await this.fetchImpl(`${this.trimmedApiUrl()}/widget/resolve-identity`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${verifiedToken}` },
+        body: JSON.stringify({ widgetKey: this.widgetKey, visitorKey })
+      });
+      const body = await res.json();
+      if (!res.ok || !body?.success) {
+        return { success: false, error: body?.error ?? body?.errorCode ?? "Could not resolve identity." };
+      }
+      return { success: true, mergedConversations: body.mergedConversations };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : "Could not resolve identity." };
+    }
+  }
+  /** Milliseconds until the given session should be refreshed (at least {@link MIN_REFRESH_DELAY_MS}). */
+  static MsUntilRefresh(session, nowMs) {
+    return Math.max(MIN_REFRESH_DELAY_MS, session.expiresAtMs - nowMs - REFRESH_LEAD_MS);
+  }
+  /**
+   * POSTs to a session endpoint. A mint (no `bearerToken`) registers `key`'s public half; a refresh sends the
+   * token and a proof signed by `key` for this URL and token.
+   */
+  async call(path, visitorKey, bearerToken, key) {
+    const url = `${this.trimmedApiUrl()}${path}`;
+    const headers = { "content-type": "application/json" };
+    const request = { widgetKey: this.widgetKey };
+    if (visitorKey) {
+      request.visitorKey = visitorKey;
+    }
+    if (bearerToken) {
+      headers["authorization"] = `Bearer ${bearerToken}`;
+      headers["dpop"] = await CreateProofOfPossessionJwt(key, {
+        Method: "POST",
+        Url: url,
+        AccessToken: bearerToken,
+        NowSeconds: Math.floor((Date.now() + this.serverOffsetMs) / 1e3)
+      });
+    } else {
+      request.proofKey = key.PublicJwk;
+    }
+    const res = await this.fetchImpl(url, { method: "POST", headers, body: JSON.stringify(request) });
+    const body = await res.json();
+    if (!res.ok || !body?.success || !body.token) {
+      throw new WidgetSessionError(`Widget session mint failed (${res.status}): ${body?.errorCode ?? body?.error ?? "unknown"}`, res.status, body?.errorCode ?? null);
+    }
+    this.learnServerOffset(body.token);
+    return this.toSession(body);
+  }
+  /**
+   * Records the server's clock offset from a token it just issued (`iat` is its "now"). The offset is off by the
+   * response's one-way latency, far inside the server's 60 s window. A token without a readable `iat` keeps the
+   * previous offset: the server stamps `iat` on every token it signs, so this is never a guess about server time.
+   */
+  learnServerOffset(token) {
+    const iat = ReadTokenIssuedAtSeconds(token);
+    if (iat !== null) {
+      this.serverOffsetMs = iat * 1e3 - Date.now();
+    }
+  }
+  /**
+   * Maps the API response to the in-memory session, validating required fields. `expiresAtMs` is put on this
+   * browser's clock (the server's expiry less the learned offset), so `expiresAtMs - Date.now()` is the time the
+   * token really has left even on a device whose clock is off.
+   */
+  toSession(body) {
+    if (!body.widgetId || !body.applicationId || !body.pinnedAgentId) {
+      throw new Error("Widget session response missing required fields (widgetId/applicationId/pinnedAgentId).");
+    }
+    const expiresAtMs = body.expiresAt ? Date.parse(body.expiresAt) : Number.NaN;
+    return {
+      token: body.token,
+      expiresAtMs: Number.isFinite(expiresAtMs) ? expiresAtMs - this.serverOffsetMs : Date.now() + 15 * 6e4,
+      widgetId: body.widgetId,
+      applicationId: body.applicationId,
+      pinnedAgentId: body.pinnedAgentId,
+      modality: body.modality ?? "Text",
+      sessionId: body.sessionId ?? "",
+      voiceMaxSessionMinutes: body.voiceMaxSessionMinutes,
+      rememberReturningVisitors: body.rememberReturningVisitors ?? false,
+      visitorKey: body.visitorKey,
+      lastConversationId: body.lastConversationId,
+      linkedEntityId: body.linkedEntityId,
+      linkedRecordId: body.linkedRecordId,
+      enabledChannels: Array.isArray(body.enabledChannels) ? body.enabledChannels : []
+    };
+  }
+  trimmedApiUrl() {
+    return this.apiUrl.replace(/\/+$/, "");
+  }
+};
+function ReadTokenIssuedAtSeconds(token) {
+  const part = token.split(".")[1];
+  if (!part) {
+    return null;
+  }
+  try {
+    const base64 = part.replace(/-/g, "+").replace(/_/g, "/");
+    const payload = JSON.parse(atob(base64 + "=".repeat((4 - base64.length % 4) % 4)));
+    if (typeof payload !== "object" || payload === null || !("iat" in payload)) {
+      return null;
+    }
+    return typeof payload.iat === "number" && Number.isFinite(payload.iat) ? payload.iat : null;
+  } catch {
+    return null;
+  }
+}
+
+// dist/session/visitor-key-cookie.js
+var COOKIE_PREFIX = "mjwv_";
+var COOKIE_MAX_AGE_SECONDS = 365 * 24 * 60 * 60;
+function cookieName(widgetKey) {
+  return COOKIE_PREFIX + widgetKey.replace(/[^A-Za-z0-9_-]/g, "");
+}
+function ReadVisitorKey(widgetKey) {
+  if (typeof document === "undefined" || !document.cookie) {
+    return void 0;
+  }
+  const name = cookieName(widgetKey) + "=";
+  for (const part of document.cookie.split(";")) {
+    const trimmed = part.trim();
+    if (trimmed.startsWith(name)) {
+      const raw = trimmed.slice(name.length);
+      try {
+        return decodeURIComponent(raw) || void 0;
+      } catch {
+        return raw || void 0;
+      }
+    }
+  }
+  return void 0;
+}
+function WriteVisitorKey(widgetKey, visitorKey) {
+  if (typeof document === "undefined" || !visitorKey) {
+    return;
+  }
+  const secure = typeof location !== "undefined" && location.protocol === "https:" ? "; Secure" : "";
+  document.cookie = `${cookieName(widgetKey)}=${encodeURIComponent(visitorKey)}; Max-Age=${COOKIE_MAX_AGE_SECONDS}; Path=/; SameSite=Lax${secure}`;
+}
+function ClearVisitorKey(widgetKey) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  document.cookie = `${cookieName(widgetKey)}=; Max-Age=0; Path=/; SameSite=Lax`;
+}
+
+// dist/loader.js
+async function MountWidget(options, deps = {}) {
+  DefineSupportWidgetElement();
+  const client = (deps.sessionClientFactory ?? defaultSessionClient)(options.apiUrl, options.widgetKey);
+  const presentedVisitorKey = ReadVisitorKey(options.widgetKey);
+  const session = await client.Mint(presentedVisitorKey);
+  if (session.rememberReturningVisitors && session.visitorKey) {
+    WriteVisitorKey(options.widgetKey, session.visitorKey);
+  }
+  const transport = await (deps.transportFactory ?? defaultTransport)(options.apiUrl);
+  await transport.Initialize(session);
+  const element = document.createElement(WIDGET_TAG_NAME);
+  element.Configure({ title: options.title, greeting: options.greeting });
+  element.SetSession(session);
+  element.SetTransport(transport);
+  if (session.modality === "Voice" || session.modality === "Both") {
+    element.SetVoiceController(await (deps.voiceControllerFactory ?? defaultVoiceController)(session));
+  }
+  if (session.rememberReturningVisitors && session.visitorKey) {
+    const visitorKey = session.visitorKey;
+    element.SetForgetHandler(async () => {
+      const result = await client.Forget(visitorKey);
+      if (!result.success) {
+        throw new Error(result.error ?? "forget failed");
+      }
+      ClearVisitorKey(options.widgetKey);
+    });
+  }
+  resolveMountTarget(options.mountTarget).appendChild(element);
+  registerNotificationAdapter(element);
+  scheduleRefresh(client, transport, element, session, deps.scheduler ?? defaultScheduler);
+  return element;
+}
+async function BootstrapFromDocument(doc = document) {
+  const mountEl = doc.querySelector("[data-widget-key]");
+  const widgetKey = mountEl?.dataset.widgetKey;
+  const apiUrl = mountEl?.dataset.apiUrl;
+  if (!mountEl || !widgetKey || !apiUrl) {
+    return null;
+  }
+  return MountWidget({
+    widgetKey,
+    apiUrl,
+    mountTarget: mountEl,
+    title: mountEl.dataset.title,
+    greeting: mountEl.dataset.greeting
+  });
+}
+async function StartEmbeddedWidget(doc = document) {
+  try {
+    await BootstrapFromDocument(doc);
+  } catch (error) {
+    if (typeof crypto === "undefined" || !crypto.subtle) {
+      console.error("[mj-widget] The support widget needs a secure context (HTTPS, or localhost) for the Web Crypto API, which this page does not have, so it is not shown. Serve the page over HTTPS.", error);
+      return;
+    }
+    console.error("[mj-widget] Could not start the support widget:", error);
+  }
+}
+function defaultSessionClient(apiUrl, widgetKey) {
+  return new WidgetSessionClient(apiUrl, widgetKey);
+}
+async function defaultTransport(apiUrl) {
+  const { RuntimeWidgetTransport } = await import("./chunks/runtime-widget-transport-AFGCQC7N.js");
+  return new RuntimeWidgetTransport(apiUrl);
+}
+async function defaultVoiceController(session) {
+  const [{ RealtimeVoiceController }, { createGuestVoiceMint }, { createGuestToolRelay }] = await Promise.all([
+    import("./chunks/realtime-voice-controller-PCOD3UBR.js"),
+    import("./chunks/guest-voice-mint-KJMP4VTK.js"),
+    import("./chunks/guest-tool-relay-GAWXNIUD.js")
+  ]);
+  return new RealtimeVoiceController(
+    createGuestVoiceMint(session),
+    voiceLimitsForSession(session),
+    // Phase 2: the interactive channels this widget may attach (Whiteboard, …) + the live relay for
+    // non-channel tool calls. Empty enabledChannels (the default) leaves voice behavior unchanged.
+    session.enabledChannels,
+    createGuestToolRelay()
+  );
+}
+function voiceLimitsForSession(session) {
+  if (session.voiceMaxSessionMinutes && session.voiceMaxSessionMinutes > 0) {
+    return { ...DEFAULT_VOICE_LIMITS, maxSessionMinutes: session.voiceMaxSessionMinutes };
+  }
+  return void 0;
+}
+function defaultScheduler(cb, delayMs) {
+  setTimeout(cb, delayMs);
+}
+function resolveMountTarget(target) {
+  if (target instanceof HTMLElement)
+    return target;
+  if (typeof target === "string") {
+    const found = document.querySelector(target);
+    if (found)
+      return found;
+  }
+  return document.body;
+}
+function registerNotificationAdapter(element) {
+  void import("./chunks/dist-P2JMWJFV.js").then(({ ConversationsRuntime }) => {
+    ConversationsRuntime.Instance.UseNotificationAdapter({
+      Notify: (level, message) => {
+        if (level === "error" || level === "warning") {
+          element.ShowSystemMessage(message);
+        }
+      }
+    });
+  });
+}
+function scheduleRefresh(client, transport, element, session, scheduler) {
+  const delay = WidgetSessionClient.MsUntilRefresh(session, Date.now());
+  scheduler(() => {
+    void (async () => {
+      try {
+        const refreshed = await client.Refresh(session.token, session.visitorKey);
+        transport.UpdateToken(refreshed.token);
+        scheduleRefresh(client, transport, element, refreshed, scheduler);
+      } catch (error) {
+        if (error instanceof WidgetSessionError && error.IsRefused) {
+          await restartSession(client, transport, element, session, scheduler);
+          return;
+        }
+        showRefreshRetry(client, transport, element, session, scheduler);
+      }
+    })();
+  }, delay);
+}
+async function restartSession(client, transport, element, previous, scheduler) {
+  try {
+    const fresh = await client.Mint(previous.visitorKey);
+    await transport.Initialize(fresh);
+    element.SetSession(fresh);
+    element.ShowSystemMessage("Your previous chat ended. You can start a new one.");
+    scheduleRefresh(client, transport, element, fresh, scheduler);
+  } catch (error) {
+    console.error("[mj-widget] Could not start a new session after the previous one was refused:", error);
+    showRefreshRetry(client, transport, element, previous, scheduler);
+  }
+}
+function showRefreshRetry(client, transport, element, session, scheduler) {
+  element.ShowConnectionError("Connection to support was lost.", () => scheduleRefresh(client, transport, element, session, scheduler));
+}
+
+// dist/embed.js
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+  DefineSupportWidgetElement();
+  const run = () => {
+    void StartEmbeddedWidget();
+  };
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", run, { once: true });
+  } else {
+    run();
+  }
+}