callix-dialer-widget 2.5.1 → 2.7.0

package/dist-widget/callix-dialer.es.js

@@ -6,7 +6,7 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-import React, { useState, useMemo, useRef, useEffect, useCallback, forwardRef, useLayoutEffect, useId, createContext, useImperativeHandle, StrictMode, useContext } from "react";
+import React, { createContext, useMemo, useRef, useEffect, useSyncExternalStore, useCallback, useContext, useState, forwardRef, useLayoutEffect, useId, useImperativeHandle, StrictMode } from "react";
 import require$$0$2, { createPortal } from "react-dom";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getAugmentedNamespace(n) {
@@ -43725,6 +43725,790 @@ function requireClientSdkReact() {
   return clientSdkReact;
 }
 var clientSdkReactExports = requireClientSdkReact();
+class EngineSignal {
+  constructor(value) {
+    this.value = value;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  get() {
+    return this.value;
+  }
+  set(value) {
+    if (JSON.stringify(value) === JSON.stringify(this.value)) return;
+    this.value = value;
+    for (const listener of this.listeners) listener(value);
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+}
+const INITIAL_TRANSCRIPT = { segments: [], status: null, insight: null, interims: 0 };
+const MAX_SEGMENTS = 300;
+const RECONNECT_MIN_MS = 500;
+const RECONNECT_MAX_MS = 5e3;
+function engineWsUrl(baseUrl) {
+  const url = new URL(baseUrl, typeof window !== "undefined" ? window.location.href : "http://localhost");
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = `${url.pathname.replace(/\/+$/, "")}/ws`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+class EngineClient {
+  constructor(options) {
+    this.options = options;
+    this.userSignal = new EngineSignal(void 0);
+    this.listeners = /* @__PURE__ */ new Set();
+    this.sessionLostListeners = /* @__PURE__ */ new Set();
+    this.viewWaiters = [];
+    this.ws = null;
+    this.reconnectDelay = RECONNECT_MIN_MS;
+    this.reconnectTimer = null;
+    this.closed = false;
+    this.iceServers = [{ urls: "stun:stun.l.google.com:19302" }];
+    this.pc = null;
+    this.connectionId = null;
+    this.remoteSet = false;
+    this.pendingCandidates = [];
+    this.micStream = null;
+    this.audioSeq = 0;
+    this.unlockListener = null;
+    this.agentId = options.agentId;
+    this.session = options.session ?? null;
+    this.log = options.log ?? (() => void 0);
+    this.audio = options.audioElement !== void 0 ? options.audioElement : createAudioElement();
+    this.state = {
+      wsState: "idle",
+      tabId: null,
+      view: null,
+      engaged: false,
+      pcState: "idle",
+      needsUnlock: false,
+      micError: null,
+      lastError: null,
+      inputMuted: false,
+      outputMuted: false,
+      outputVolume: 100,
+      transcript: INITIAL_TRANSCRIPT,
+      sessionLost: null
+    };
+  }
+  // ------------------------------------------------------------------ store
+  getState() {
+    return this.state;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setState(patch) {
+    this.state = { ...this.state, ...patch };
+    for (const listener of this.listeners) listener();
+  }
+  get currentCall() {
+    var _a2, _b;
+    return ((_b = (_a2 = this.state.view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.call) ?? null;
+  }
+  // ------------------------------------------------------------------ conexão
+  connect() {
+    if (this.closed) this.closed = false;
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) return;
+    const Impl = this.options.WebSocketImpl ?? WebSocket;
+    this.setState({ wsState: "connecting" });
+    const ws = new Impl(engineWsUrl(this.options.url));
+    this.ws = ws;
+    ws.onopen = () => {
+      if (this.ws !== ws) return;
+      this.reconnectDelay = RECONNECT_MIN_MS;
+      this.setState({ wsState: "open" });
+      const hello = { type: "hello", role: "tab", agentId: this.agentId, token: this.options.token, label: this.options.label ?? "Discador", ...this.session ? { session: this.session } : {} };
+      this.send(hello);
+      this.log("conectado ao host do motor");
+    };
+    ws.onmessage = (event) => {
+      if (this.ws !== ws) return;
+      let message;
+      try {
+        message = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      this.handle(message);
+    };
+    ws.onclose = () => {
+      if (this.ws !== ws) return;
+      this.ws = null;
+      const wasEngaged = this.state.engaged;
+      this.setState({ wsState: "closed", tabId: null, engaged: false });
+      if (wasEngaged) this.stopAudio();
+      if (this.closed) return;
+      this.log(`conexão com o motor caiu; nova tentativa em ${this.reconnectDelay} ms`);
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectTimer = null;
+        this.connect();
+      }, this.reconnectDelay);
+      this.reconnectDelay = Math.min(this.reconnectDelay * 2, RECONNECT_MAX_MS);
+    };
+    ws.onerror = () => void 0;
+  }
+  /** fecha de vez (sem reconectar) e solta o áudio */
+  close() {
+    this.closed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.stopAudio();
+    const ws = this.ws;
+    this.ws = null;
+    if (ws) {
+      ws.onclose = null;
+      ws.close();
+    }
+    for (const waiter of this.viewWaiters.splice(0)) clearTimeout(waiter.timer);
+    this.setState({ wsState: "closed", tabId: null, engaged: false });
+  }
+  /** a view atual, ou a próxima que o host mandar (welcome/view) */
+  waitForView(timeoutMs = 15e3) {
+    if (this.state.view && this.state.tabId) return Promise.resolve(this.state.view);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const index = this.viewWaiters.findIndex((w) => w.timer === timer);
+        if (index >= 0) this.viewWaiters.splice(index, 1);
+        reject(new Error("o motor não respondeu"));
+      }, timeoutMs);
+      this.viewWaiters.push({ resolve, timer });
+    });
+  }
+  send(message) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(message));
+  }
+  handle(message) {
+    switch (message.type) {
+      case "welcome": {
+        if (Array.isArray(message.iceServers) && message.iceServers.length > 0) this.iceServers = message.iceServers;
+        this.setState({ tabId: message.tabId });
+        this.applyView(message.view);
+        this.log(`sou a aba ${message.tabId}`);
+        if (this.options.autoEngage !== false && message.view.engagedTabId !== message.tabId) this.engage();
+        break;
+      }
+      case "view":
+        this.applyView(message.view);
+        break;
+      case "engage":
+        this.setState({ engaged: message.engaged });
+        if (message.engaged) void this.startAudio();
+        else this.stopAudio();
+        break;
+      case "signal":
+        void this.onSignal(message.payload);
+        break;
+      case "error":
+        this.setState({ lastError: message.message });
+        this.log(`erro do host: ${message.message}`);
+        break;
+      case "transcript":
+        this.pushSegment(message.segment);
+        break;
+      case "transcript-sync":
+        this.setState({ transcript: { segments: message.segments ?? [], status: message.status ?? null, insight: message.insight ?? null, interims: 0 } });
+        break;
+      case "insight": {
+        const current = this.state.transcript.insight;
+        if (!current || message.insight.revision >= current.revision || message.insight.callId !== current.callId) {
+          this.setState({ transcript: { ...this.state.transcript, insight: message.insight } });
+        }
+        break;
+      }
+      case "transcript-status":
+        this.onTranscriptStatus(message.status);
+        break;
+    }
+  }
+  applyView(view) {
+    var _a2, _b;
+    const previous = this.state.view;
+    const lost = view.sessionLost ?? null;
+    const newlyLost = Boolean(lost) && !(previous == null ? void 0 : previous.sessionLost);
+    if (newlyLost) {
+      this.session = null;
+      this.log(`o Callix derrubou a sessão: ${(lost == null ? void 0 : lost.message) ?? ""}`);
+    }
+    const user = (_a2 = view.snapshot) == null ? void 0 : _a2.leg.user;
+    this.userSignal.set(user ? { ...user, sessionId: 0 } : void 0);
+    const call = (_b = view.snapshot) == null ? void 0 : _b.leg.call;
+    const patch = { view, sessionLost: lost ? { originator: lost.originator, message: lost.message } : null };
+    if (call && typeof call.muted === "boolean" && call.muted !== this.state.inputMuted && call.state !== "ended") patch.inputMuted = call.muted;
+    this.setState(patch);
+    for (const waiter of this.viewWaiters.splice(0)) {
+      clearTimeout(waiter.timer);
+      waiter.resolve(view);
+    }
+    if (newlyLost && lost) for (const listener of this.sessionLostListeners) listener(lost);
+  }
+  onSessionLost(listener) {
+    this.sessionLostListeners.add(listener);
+    return () => {
+      this.sessionLostListeners.delete(listener);
+    };
+  }
+  // ------------------------------------------------------------------ sessão e comandos
+  /** modo sdk: o widget fez login no back-end e entrega a sessão ao host */
+  setSession(session) {
+    this.session = session;
+    this.send({ type: "session", session });
+  }
+  engage() {
+    this.send({ type: "engage" });
+  }
+  release() {
+    this.send({ type: "release" });
+  }
+  command(command) {
+    this.send({ type: "command", command });
+    this.log(`comando: ${command.name}${command.phone ? ` ${command.phone}` : ""}`);
+  }
+  // ------------------------------------------------------------------ áudio
+  setInputMuted(muted) {
+    if (this.micStream) for (const track of this.micStream.getAudioTracks()) track.enabled = !muted;
+    this.setState({ inputMuted: muted });
+    if (this.currentCall) this.command({ name: muted ? "mute" : "unmute" });
+  }
+  setOutputMuted(muted) {
+    if (this.audio) this.audio.muted = muted;
+    this.setState({ outputMuted: muted });
+  }
+  setOutputVolume(volume) {
+    const clamped = Math.max(0, Math.min(100, Math.round(volume)));
+    if (this.audio) this.audio.volume = clamped / 100;
+    this.setState({ outputVolume: clamped });
+  }
+  async setOutputDevice(deviceId) {
+    const audio = this.audio;
+    if (!(audio == null ? void 0 : audio.setSinkId)) throw new Error("este navegador não permite escolher a saída de som");
+    await audio.setSinkId(deviceId);
+  }
+  /** depois de um toque do agente: tenta tocar o som do motor que o navegador segurou */
+  async unlockAudio() {
+    if (!this.audio || !this.audio.srcObject) return;
+    try {
+      await this.audio.play();
+      this.setState({ needsUnlock: false });
+    } catch {
+      this.setState({ needsUnlock: true });
+    }
+  }
+  async startAudio() {
+    const seq = ++this.audioSeq;
+    this.stopAudio();
+    const mediaDevices = this.options.mediaDevices === void 0 ? typeof navigator !== "undefined" ? navigator.mediaDevices : null : this.options.mediaDevices;
+    if (!(mediaDevices == null ? void 0 : mediaDevices.getUserMedia)) {
+      this.setState({ micError: "Este navegador não permite usar o microfone pela página." });
+      return;
+    }
+    let stream;
+    try {
+      stream = await mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true } });
+    } catch (error2) {
+      const message = `Microfone indisponível: ${error2.message}`;
+      this.setState({ micError: message });
+      this.log(message);
+      return;
+    }
+    if (seq !== this.audioSeq || !this.state.engaged) {
+      for (const track of stream.getTracks()) track.stop();
+      return;
+    }
+    this.micStream = stream;
+    for (const track of stream.getAudioTracks()) track.enabled = !this.state.inputMuted;
+    this.setState({ micError: null });
+    const Impl = this.options.PeerConnectionImpl ?? RTCPeerConnection;
+    const connection = new Impl({ iceServers: this.iceServers });
+    this.pc = connection;
+    const connectionId = Math.random().toString(36).slice(2, 10);
+    this.connectionId = connectionId;
+    this.remoteSet = false;
+    this.pendingCandidates = [];
+    for (const track of stream.getAudioTracks()) connection.addTrack(track, stream);
+    connection.onicecandidate = (event) => {
+      this.send({ type: "signal", payload: { connectionId, candidate: event.candidate ? event.candidate.toJSON() : null } });
+    };
+    connection.ontrack = (event) => {
+      const remote = event.streams[0] ?? new MediaStream([event.track]);
+      if (this.audio) {
+        this.audio.srcObject = remote;
+        this.audio.muted = this.state.outputMuted;
+        this.audio.volume = this.state.outputVolume / 100;
+        this.audio.play().then(() => this.setState({ needsUnlock: false })).catch(() => {
+          this.setState({ needsUnlock: true });
+          this.armUnlock();
+        });
+      }
+      this.log("áudio do motor chegou");
+    };
+    connection.onconnectionstatechange = () => {
+      if (this.pc !== connection) return;
+      this.setState({ pcState: connection.connectionState });
+      this.log(`WebRTC: ${connection.connectionState}`);
+      if (connection.connectionState === "failed" && this.state.engaged) {
+        this.log("conexão de áudio com o motor falhou; renegociando");
+        void this.startAudio();
+      }
+    };
+    const offer = await connection.createOffer();
+    if (this.pc !== connection) return;
+    await connection.setLocalDescription(offer);
+    this.send({ type: "signal", payload: { connectionId, description: { type: offer.type, sdp: offer.sdp } } });
+    this.setState({ pcState: connection.connectionState });
+  }
+  stopAudio() {
+    if (this.pc) {
+      this.pc.onconnectionstatechange = null;
+      this.pc.onicecandidate = null;
+      this.pc.ontrack = null;
+      this.pc.close();
+      this.pc = null;
+    }
+    this.connectionId = null;
+    if (this.micStream) {
+      for (const track of this.micStream.getTracks()) track.stop();
+      this.micStream = null;
+    }
+    if (this.audio) this.audio.srcObject = null;
+    if (this.state.pcState !== "idle") this.setState({ pcState: "idle" });
+  }
+  async onSignal(payload) {
+    const connection = this.pc;
+    if (!connection) return;
+    if (payload.connectionId && payload.connectionId !== this.connectionId) return;
+    try {
+      if (payload.description) {
+        await connection.setRemoteDescription(payload.description);
+        this.remoteSet = true;
+        for (const candidate of this.pendingCandidates.splice(0)) await connection.addIceCandidate(candidate).catch(() => void 0);
+      }
+      if (payload.candidate !== void 0) {
+        const candidate = payload.candidate ?? void 0;
+        if (!this.remoteSet && candidate) this.pendingCandidates.push(candidate);
+        else await connection.addIceCandidate(candidate).catch(() => void 0);
+      }
+    } catch (error2) {
+      this.log(`sinalização: ${error2.message}`);
+    }
+  }
+  /** o próximo toque/tecla na página libera o som (política de autoplay) */
+  armUnlock() {
+    if (this.unlockListener || typeof document === "undefined") return;
+    const listener = () => {
+      document.removeEventListener("pointerdown", listener, true);
+      document.removeEventListener("keydown", listener, true);
+      this.unlockListener = null;
+      void this.unlockAudio();
+    };
+    this.unlockListener = listener;
+    document.addEventListener("pointerdown", listener, true);
+    document.addEventListener("keydown", listener, true);
+  }
+  // ------------------------------------------------------------------ transcrição
+  pushSegment(segment) {
+    const current = this.state.transcript;
+    let segments = current.segments;
+    let insight = current.insight;
+    let interims = current.interims;
+    if (segments.length && segments[0].callId !== segment.callId) {
+      segments = [];
+      insight = null;
+      interims = 0;
+    }
+    const index = segments.findIndex((s) => s.id === segment.id);
+    const next = index >= 0 ? segments.map((s, i2) => i2 === index ? segment : s) : [...segments, segment];
+    if (next.length > MAX_SEGMENTS) next.shift();
+    if (segment.interim) interims += 1;
+    this.setState({ transcript: { ...current, segments: next, insight, interims } });
+  }
+  onTranscriptStatus(status) {
+    const current = this.state.transcript;
+    if (!current.status || current.status.recordingId === status.recordingId || status.live === "running") {
+      const fresh = current.status && current.status.recordingId !== status.recordingId;
+      this.setState({ transcript: { ...current, status, ...fresh ? { segments: [], insight: null, interims: 0 } : {} } });
+    }
+  }
+}
+function createAudioElement() {
+  if (typeof document === "undefined") return null;
+  const audio = document.createElement("audio");
+  audio.autoplay = true;
+  audio.setAttribute("playsinline", "true");
+  audio.style.display = "none";
+  audio.dataset.callixEngineAudio = "true";
+  document.body.appendChild(audio);
+  return audio;
+}
+const EngineClientContext = createContext(null);
+function EngineClientProvider({ client: client2, children: children2 }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(EngineClientContext.Provider, { value: client2, children: children2 });
+}
+function useEngineClient() {
+  return useContext(EngineClientContext);
+}
+function useEngineState(client2) {
+  return useSyncExternalStore(client2.subscribe.bind(client2), client2.getState.bind(client2), client2.getState.bind(client2));
+}
+const ENGINE_BREAKS = [{ id: 0, name: "Pausa" }];
+function toCallQualification(q) {
+  return { id: q.id, name: q.name, isSystemQualification: false, systemQualificationType: 0 };
+}
+function qualificationsFromView(view, kind) {
+  var _a2;
+  return (((_a2 = view == null ? void 0 : view.snapshot) == null ? void 0 : _a2.leg.qualifications) ?? []).filter((q) => q.kind === kind).map(toCallQualification);
+}
+class EngineCall {
+  constructor(client2, snapshot) {
+    this.client = client2;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.snapshot = snapshot;
+  }
+  get id() {
+    return this.snapshot.id;
+  }
+  get direction() {
+    return this.snapshot.direction;
+  }
+  get data() {
+    var _a2;
+    return {
+      destinationNumber: (_a2 = this.snapshot.contact) == null ? void 0 : _a2.phone,
+      campaignContactPhoneId: this.snapshot.campaignContactPhoneId,
+      answeredAt: this.snapshot.answeredAt ? new Date(this.snapshot.answeredAt) : void 0
+    };
+  }
+  get callerNumber() {
+    var _a2;
+    return (_a2 = this.snapshot.contact) == null ? void 0 : _a2.phone;
+  }
+  get peerDisplayName() {
+    var _a2;
+    return (_a2 = this.snapshot.contact) == null ? void 0 : _a2.name;
+  }
+  get isEstablished() {
+    return this.snapshot.state === "active";
+  }
+  get isEnded() {
+    return this.snapshot.state === "ended";
+  }
+  /** segundos desde o atendimento (ou desde o início, enquanto toca) */
+  get currentDurationSeconds() {
+    const from = this.snapshot.answeredAt ?? this.snapshot.startedAt;
+    return Math.max(0, Math.floor((Date.now() - from) / 1e3));
+  }
+  answer() {
+    this.client.command({ name: "answer" });
+  }
+  reject() {
+    this.client.command({ name: "reject" });
+  }
+  hangup() {
+    this.client.command({ name: "hangup" });
+  }
+  isOnHold() {
+    return { local: false, remote: false };
+  }
+  async hold() {
+  }
+  async unhold() {
+  }
+  isMuted() {
+    return this.client.getState().inputMuted;
+  }
+  mute() {
+    this.client.setInputMuted(true);
+  }
+  unmute() {
+    this.client.setInputMuted(false);
+  }
+  sendDtmf(tones) {
+    this.client.command({ name: "dtmf", tones });
+  }
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  once(event, listener) {
+    const wrapped = (...args) => {
+      this.off(event, wrapped);
+      listener(...args);
+    };
+    return this.on(event, wrapped);
+  }
+  off(event, listener) {
+    var _a2;
+    (_a2 = this.listeners.get(event)) == null ? void 0 : _a2.delete(listener);
+    return this;
+  }
+  toCallData() {
+    var _a2;
+    return {
+      id: this.snapshot.id,
+      direction: this.snapshot.direction,
+      destinationNumber: ((_a2 = this.snapshot.contact) == null ? void 0 : _a2.phone) ?? "",
+      answeredAt: this.snapshot.answeredAt ? new Date(this.snapshot.answeredAt).toISOString() : void 0,
+      campaignContactPhoneId: this.snapshot.campaignContactPhoneId,
+      isMuted: this.snapshot.muted
+    };
+  }
+}
+function operatorStateFromView(view, call) {
+  var _a2, _b, _c;
+  if (!view) return void 0;
+  if (((_a2 = view.sessionLost) == null ? void 0 : _a2.originator) === "anotherDevice") return { state: "startupError", error: "userIsAlreadyConnectedOnAnotherDevice" };
+  const leg = (_b = view.snapshot) == null ? void 0 : _b.leg;
+  if (!leg) {
+    if (view.engine === "starting") return { state: "starting" };
+    if (view.engine === "running") return { state: "starting" };
+    return { state: "offline" };
+  }
+  const asCall = call ?? void 0;
+  switch (leg.status) {
+    case "starting":
+      return { state: "starting" };
+    case "available":
+      return { state: "idle" };
+    case "ringing":
+      return { state: "callRinging", call: asCall };
+    case "dialing":
+      return ((_c = leg.call) == null ? void 0 : _c.state) === "ringing" ? { state: "manualCallRinging", call: asCall } : { state: "manualCallSetup", call: asCall };
+    case "inCall":
+      return { state: "callInProgress", call: asCall };
+    case "afterCall":
+      return { state: "afterCall" };
+    case "onBreak":
+      return { state: "onBreak", break: ENGINE_BREAKS[0] };
+    case "offline":
+      return { state: "offline" };
+    case "error":
+      return { state: "startupError", error: "unknownError" };
+  }
+}
+function callInfoFromView(view) {
+  var _a2;
+  const leg = (_a2 = view == null ? void 0 : view.snapshot) == null ? void 0 : _a2.leg;
+  const call = leg == null ? void 0 : leg.call;
+  if (!leg || !call) return void 0;
+  const successQualifications = qualificationsFromView(view, "success");
+  const discardQualifications = qualificationsFromView(view, "discard");
+  const contact = call.contact;
+  if (contact == null ? void 0 : contact.campaign) {
+    const info = {
+      campaign: {
+        id: 0,
+        name: contact.campaign,
+        type: 0,
+        requireCallComments: false,
+        enableTransfer: false,
+        enableScheduledCall: false,
+        successQualifications,
+        discardQualifications,
+        previewDuration: "",
+        showCampaignModelOnService: false,
+        skipCallQualification: false
+      },
+      campaignList: { id: 0, name: "" },
+      campaignContact: { id: call.campaignContactPhoneId ?? 0, label: contact.name, phoneNumber: contact.phone }
+    };
+    return { type: "campaign", info };
+  }
+  return { type: "manual", info: { successQualifications, discardQualifications } };
+}
+function useEngineCall(client2) {
+  var _a2, _b;
+  const state = useEngineState(client2);
+  const snapshot = ((_b = (_a2 = state.view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.call) ?? null;
+  const ref = useRef(null);
+  if (!snapshot || snapshot.state === "ended") {
+    ref.current = null;
+  } else if (!ref.current || ref.current.id !== snapshot.id) {
+    ref.current = new EngineCall(client2, snapshot);
+  } else {
+    ref.current.snapshot = snapshot;
+  }
+  return ref.current;
+}
+function useEngineOperatorState(client2) {
+  const state = useEngineState(client2);
+  const call = useEngineCall(client2);
+  return useMemo(() => operatorStateFromView(state.view, call), [state.view, call]);
+}
+function useEngineCurrentCall(client2) {
+  const call = useEngineCall(client2);
+  return call ?? void 0;
+}
+function useEngineCurrentCallInfo(client2) {
+  var _a2, _b, _c, _d, _e;
+  const state = useEngineState(client2);
+  const view = state.view;
+  const key = JSON.stringify([(_b = (_a2 = view == null ? void 0 : view.snapshot) == null ? void 0 : _a2.leg.call) == null ? void 0 : _b.id, (_d = (_c = view == null ? void 0 : view.snapshot) == null ? void 0 : _c.leg.call) == null ? void 0 : _d.contact, (_e = view == null ? void 0 : view.snapshot) == null ? void 0 : _e.leg.qualifications]);
+  return useMemo(() => callInfoFromView(view), [key]);
+}
+function useEngineQualifications(client2, kind) {
+  var _a2, _b;
+  const state = useEngineState(client2);
+  const raw = ((_b = (_a2 = state.view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.qualifications) ?? [];
+  const key = JSON.stringify(raw);
+  return useMemo(() => qualificationsFromView(state.view, kind), [key, kind]);
+}
+function useEngineControls(client2) {
+  return useMemo(
+    () => ({
+      becomeAvailable: () => {
+        var _a2, _b;
+        const status = (_b = (_a2 = client2.getState().view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.status;
+        if (status === "onBreak") client2.command({ name: "resume" });
+      },
+      goOffline: () => void 0,
+      enterOnBreak: () => client2.command({ name: "pause" }),
+      makeManualCall: (phoneNumber) => client2.command({ name: "dial", phone: phoneNumber }),
+      finishAfterCall: (data) => {
+        if (typeof data.qualificationId === "number") client2.command({ name: "qualify", qualificationId: data.qualificationId, result: data.result === "failure" ? "discard" : "success" });
+        else client2.command({ name: "finish" });
+      }
+    }),
+    [client2]
+  );
+}
+function useEngineCurrentCallControls(client2) {
+  return useMemo(
+    () => ({
+      answer: () => client2.command({ name: "answer" }),
+      reject: () => client2.command({ name: "reject" }),
+      hangup: () => client2.command({ name: "hangup" }),
+      isOnHold: () => ({ local: false, remote: false }),
+      hold: async () => void 0,
+      unhold: async () => void 0,
+      isMuted: () => client2.getState().inputMuted,
+      mute: () => client2.setInputMuted(true),
+      unmute: () => client2.setInputMuted(false)
+    }),
+    [client2]
+  );
+}
+function useEngineAudioInputMuted(client2) {
+  const state = useEngineState(client2);
+  const set = useCallback((muted) => client2.setInputMuted(muted), [client2]);
+  return [state.inputMuted, set];
+}
+function useEngineAudioOutputMuted(client2) {
+  const state = useEngineState(client2);
+  const set = useCallback((muted) => client2.setOutputMuted(muted), [client2]);
+  return [state.outputMuted, set];
+}
+function useEngineAudioOutputVolume(client2) {
+  const state = useEngineState(client2);
+  const set = useCallback((volume) => client2.setOutputVolume(volume), [client2]);
+  return [state.outputVolume, set];
+}
+function useEngineEventListener(client2, event, listener) {
+  const ref = useRef(listener);
+  ref.current = listener;
+  useEffect(() => {
+    return client2.onSessionLost((lost) => {
+      ref.current({ originator: lost.originator });
+    });
+  }, [client2, event]);
+}
+const operators = /* @__PURE__ */ new WeakMap();
+function engineOperator(client2) {
+  let operator = operators.get(client2);
+  if (!operator) {
+    const breaks = new EngineSignal(ENGINE_BREAKS);
+    operator = {
+      breaks,
+      user: client2.userSignal,
+      audioOutput: {
+        setAudioOutputDevice: (id) => void client2.setOutputDevice(id).catch(() => void 0),
+        setVolume: (volume) => client2.setOutputVolume(volume),
+        setMute: (muted) => client2.setOutputMuted(muted)
+      },
+      stop: () => void 0,
+      goOffline: () => void 0,
+      becomeAvailable: () => {
+        var _a2, _b;
+        if (((_b = (_a2 = client2.getState().view) == null ? void 0 : _a2.snapshot) == null ? void 0 : _b.leg.status) === "onBreak") client2.command({ name: "resume" });
+      },
+      enterOnBreak: () => client2.command({ name: "pause" }),
+      makeManualCall: (phoneNumber) => client2.command({ name: "dial", phone: phoneNumber }),
+      finishAfterCall: (data) => {
+        if (typeof data.qualificationId === "number") client2.command({ name: "qualify", qualificationId: data.qualificationId, result: data.result === "failure" ? "discard" : "success" });
+        else client2.command({ name: "finish" });
+      }
+    };
+    operators.set(client2, operator);
+  }
+  return operator;
+}
+function useEngineOperator(client2) {
+  return useMemo(() => engineOperator(client2), [client2]);
+}
+function useEngineTranscript(client2) {
+  return useEngineState(client2).transcript;
+}
+function useCallOperator() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineOperator(engine) : clientSdkReactExports.useCallOperator();
+}
+function useCallOperatorState() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineOperatorState(engine) : clientSdkReactExports.useCallOperatorState();
+}
+function useCallOperatorControls() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineControls(engine) : clientSdkReactExports.useCallOperatorControls();
+}
+function useCallOperatorCurrentCall() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineCurrentCall(engine) : clientSdkReactExports.useCallOperatorCurrentCall();
+}
+function useCallOperatorCurrentCallInfo() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineCurrentCallInfo(engine) : clientSdkReactExports.useCallOperatorCurrentCallInfo();
+}
+function useCallOperatorSuccessQualifications() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineQualifications(engine, "success") : clientSdkReactExports.useCallOperatorSuccessQualifications();
+}
+function useCallOperatorDiscardQualifications() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineQualifications(engine, "discard") : clientSdkReactExports.useCallOperatorDiscardQualifications();
+}
+function useCallOperatorCurrentCallControls() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineCurrentCallControls(engine) : clientSdkReactExports.useCallOperatorCurrentCallControls();
+}
+function useCallOperatorAudioInputMuted() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineAudioInputMuted(engine) : clientSdkReactExports.useCallOperatorAudioInputMuted();
+}
+function useCallOperatorAudioOutputMuted() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineAudioOutputMuted(engine) : clientSdkReactExports.useCallOperatorAudioOutputMuted();
+}
+function useCallOperatorAudioOutputVolume() {
+  const engine = useContext(EngineClientContext);
+  return engine ? useEngineAudioOutputVolume(engine) : clientSdkReactExports.useCallOperatorAudioOutputVolume();
+}
+function useCallOperatorEventListener(event, listener) {
+  const engine = useContext(EngineClientContext);
+  if (engine) useEngineEventListener(engine, event, listener);
+  else clientSdkReactExports.useCallOperatorEventListener(event, listener);
+}
 var DefaultContext = {
   color: void 0,
   size: void 0,
@@ -48745,8 +49529,8 @@ function formatPhoneValue(raw) {
 }
 function CallInfoDisplay() {
   var _a2;
-  const callInfo = clientSdkReactExports.useCallOperatorCurrentCallInfo();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
+  const callInfo = useCallOperatorCurrentCallInfo();
+  const currentCall = useCallOperatorCurrentCall();
   const campaignContactPhoneId = ((_a2 = currentCall == null ? void 0 : currentCall.data) == null ? void 0 : _a2.campaignContactPhoneId) ?? null;
   if ((callInfo == null ? void 0 : callInfo.type) === "campaign") {
     return /* @__PURE__ */ jsxRuntimeExports.jsx(CampaignCallInfoDisplay, { campaignCallInfo: callInfo.info, campaignContactPhoneId });
@@ -48892,7 +49676,7 @@ function useSignal(signal) {
   return value;
 }
 function useOperatorBreak() {
-  const { enterOnBreak, becomeAvailable } = clientSdkReactExports.useCallOperatorControls();
+  const { enterOnBreak, becomeAvailable } = useCallOperatorControls();
   return {
     // Use the SDK's native method
     goOnBreak: enterOnBreak,
@@ -51592,6 +52376,8 @@ function FloatingDialer({
   sessionStatus = null,
   loginConfirmation = null,
   onCancelLoginConfirmation,
+  onTakeOverSession,
+  onLogoutAllTabs,
   variant = "default",
   portalTarget = null
 }) {
@@ -51944,7 +52730,9 @@ function FloatingDialer({
       error: sessionError,
       statusMessage: sessionStatus,
       confirmation: loginConfirmation,
-      onCancelConfirmation: onCancelLoginConfirmation
+      onCancelConfirmation: onCancelLoginConfirmation,
+      onTakeOver: onTakeOverSession,
+      onLogoutAll: onLogoutAllTabs
     }
   );
   if (isMiniMode) {
@@ -52080,7 +52868,7 @@ function FloatingDialer({
     }
   );
 }
-function LoginForm({ defaultValue, onSubmit, isLoading, error: error2, statusMessage, confirmation, onCancelConfirmation }) {
+function LoginForm({ defaultValue, onSubmit, isLoading, error: error2, statusMessage, confirmation, onCancelConfirmation, onTakeOver, onLogoutAll }) {
   const [value, setValue] = useState(defaultValue);
   const [touched, setTouched] = useState(false);
   useEffect(() => {
@@ -52111,8 +52899,41 @@ function LoginForm({ defaultValue, onSubmit, isLoading, error: error2, statusMes
       }
     );
   }
+  if (confirmation == null ? void 0 : confirmation.elsewhere) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: tw`space-y-4`, "data-login-state": "elsewhere", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: tw`space-y-2 text-center`, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: tw`text-[11px] font-semibold uppercase tracking-wide text-slate-500`, children: "Discador ativo em outra aba" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("p", { className: tw`inline-flex items-center gap-2 rounded-full border border-slate-200 bg-slate-50 px-3 py-1 text-sm font-semibold text-slate-800`, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(FiUser, { className: tw`text-primary` }),
+          confirmation.username
+        ] })
+      ] }),
+      error2 && /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: tw`text-center text-xs text-red-500`, children: error2 }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "button",
+        {
+          type: "button",
+          id: "takeOverBtn",
+          onClick: () => onTakeOver == null ? void 0 : onTakeOver(),
+          className: tw`flex w-full items-center justify-center gap-2 rounded-xl bg-primary px-4 py-2 text-white shadow-lg transition hover:bg-primaryDark`,
+          children: "Usar o discador nesta aba"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "button",
+        {
+          type: "button",
+          id: "logoutAllBtn",
+          onClick: () => onLogoutAll == null ? void 0 : onLogoutAll(),
+          className: tw`w-full text-center text-xs font-semibold text-red-500 transition hover:text-red-600`,
+          children: "Sair em todas as abas"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: tw`text-center text-[11px] text-slate-400`, children: "O Callix aceita uma conexão por usuário: você já está conectado em outra aba deste navegador e pode continuar por lá." })
+    ] });
+  }
   if (confirmation) {
-    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: tw`space-y-4`, children: [
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: tw`space-y-4`, "data-login-state": "choose", children: [
       /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: tw`space-y-2 text-center`, children: [
         /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: tw`text-[11px] font-semibold uppercase tracking-wide text-slate-500`, children: "Entrar como" }),
         /* @__PURE__ */ jsxRuntimeExports.jsxs("p", { className: tw`inline-flex items-center gap-2 rounded-full border border-slate-200 bg-slate-50 px-3 py-1 text-sm font-semibold text-slate-800`, children: [
@@ -52121,10 +52942,12 @@ function LoginForm({ defaultValue, onSubmit, isLoading, error: error2, statusMes
         ] })
       ] }),
       error2 && /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: tw`text-center text-xs text-red-500`, children: error2 }),
+      !error2 && confirmation.note && /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: tw`text-center text-xs text-slate-500`, children: confirmation.note }),
       /* @__PURE__ */ jsxRuntimeExports.jsx(
         "button",
         {
           type: "button",
+          id: "loginConfirmBtn",
           onClick: () => void onSubmit(confirmation.username),
           className: tw`flex w-full items-center justify-center gap-2 rounded-xl bg-primary px-4 py-2 text-white shadow-lg transition hover:bg-primaryDark`,
           children: "Entrar"
@@ -52139,7 +52962,7 @@ function LoginForm({ defaultValue, onSubmit, isLoading, error: error2, statusMes
           children: "Usar outro usuário"
         }
       ),
-      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: tw`text-center text-[11px] text-slate-400`, children: "Se você já estiver conectado em outra aba, continue usando o discador por lá." })
+      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: tw`text-center text-[11px] text-slate-400`, children: "Ao entrar, todas as abas abertas passam a usar o discador. Vai usar o Callix web? Então não entre aqui: nada é conectado sem a sua confirmação." })
     ] });
   }
   return /* @__PURE__ */ jsxRuntimeExports.jsxs("form", { className: tw`space-y-4`, onSubmit: handleSubmit, children: [
@@ -52189,19 +53012,19 @@ function AuthenticatedDialer({
   const isMiniMode = variant === "min";
   const { skipManualQualification } = useDialerConfig();
   console.log("[FloatingDialer/AuthenticatedDialer] 🔧 skipManualQualification:", skipManualQualification);
-  const operator = clientSdkReactExports.useCallOperator();
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
-  const currentCallInfo = clientSdkReactExports.useCallOperatorCurrentCallInfo();
-  const rawSuccessQualifications = clientSdkReactExports.useCallOperatorSuccessQualifications();
-  const rawDiscardQualifications = clientSdkReactExports.useCallOperatorDiscardQualifications();
+  const operator = useCallOperator();
+  const operatorState = useCallOperatorState();
+  const currentCall = useCallOperatorCurrentCall();
+  const currentCallInfo = useCallOperatorCurrentCallInfo();
+  const rawSuccessQualifications = useCallOperatorSuccessQualifications();
+  const rawDiscardQualifications = useCallOperatorDiscardQualifications();
   const successQualifications = useMemo(() => rawSuccessQualifications ?? [], [rawSuccessQualifications]);
   const discardQualifications = useMemo(() => rawDiscardQualifications ?? [], [rawDiscardQualifications]);
-  const { makeManualCall, becomeAvailable, finishAfterCall } = clientSdkReactExports.useCallOperatorControls();
-  const { hangup, answer, reject } = clientSdkReactExports.useCallOperatorCurrentCallControls();
-  const [inputMuted, setInputMuted] = clientSdkReactExports.useCallOperatorAudioInputMuted();
-  const [outputMuted, setOutputMuted] = clientSdkReactExports.useCallOperatorAudioOutputMuted();
-  const [outputVolume, setOutputVolume] = clientSdkReactExports.useCallOperatorAudioOutputVolume();
+  const { makeManualCall, becomeAvailable, finishAfterCall } = useCallOperatorControls();
+  const { hangup, answer, reject } = useCallOperatorCurrentCallControls();
+  const [inputMuted, setInputMuted] = useCallOperatorAudioInputMuted();
+  const [outputMuted, setOutputMuted] = useCallOperatorAudioOutputMuted();
+  const [outputVolume, setOutputVolume] = useCallOperatorAudioOutputVolume();
   useEffect(() => {
     console.log("[FloatingDialer] Estado do operador mudou:", {
       state: operatorState == null ? void 0 : operatorState.state,
@@ -52234,7 +53057,7 @@ function AuthenticatedDialer({
   const visibleInputRef = useRef(null);
   const [callError, setCallError] = useState(null);
   const [availabilityError, setAvailabilityError] = useState(null);
-  clientSdkReactExports.useCallOperatorEventListener("userSessionDropped", (data) => {
+  useCallOperatorEventListener("userSessionDropped", (data) => {
     const notice = describeSessionDrop(data == null ? void 0 : data.originator);
     setAvailabilityError(`${notice.title}: ${notice.detail}${notice.action ? ` ${notice.action}` : ""}`);
   });
@@ -56837,9 +57660,69 @@ function DialerNoticeBanner({ notice, onDismiss, onRecheck, onHeightChange }) {
     dismissible && onDismiss && /* @__PURE__ */ jsxRuntimeExports.jsx("button", { type: "button", className: "dialer-notice-close", onClick: onDismiss, "aria-label": "Fechar aviso", children: /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-xmark", "aria-hidden": "true" }) })
   ] });
 }
+const EMOTION_LABEL = {
+  raiva: "raiva",
+  irritacao: "irritação",
+  frustracao: "frustração",
+  desconfianca: "desconfiança",
+  impaciencia: "impaciência",
+  confusao: "confusão",
+  nervosismo: "nervosismo",
+  surpresa: "surpresa",
+  desanimo: "desânimo",
+  cansaco: "cansaço",
+  interesse: "interesse",
+  entusiasmo: "entusiasmo",
+  satisfacao: "satisfação",
+  alivio: "alívio",
+  neutro: "neutro"
+};
+const STANCE_LABEL = {
+  aberto: "cliente aberto",
+  neutro: "cliente neutro",
+  resistente: "cliente resistente",
+  hostil: "cliente hostil",
+  indefinido: "lendo a conversa"
+};
+const SPEAKER_LABEL = { agent: "Você", customer: "Cliente", mixed: "" };
+function topEmotions(segment, max2 = 2) {
+  return (segment.emotions ?? []).filter((e) => e.label !== "neutro" && e.intensity >= 0.3).slice(0, max2);
+}
+function LiveCaptionPanel({ maxLines = 4 }) {
+  const client2 = useEngineClient();
+  if (!client2) return null;
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(LiveCaptionPanelInner, { client: client2, maxLines });
+}
+function LiveCaptionPanelInner({ client: client2, maxLines }) {
+  const { segments, insight, status } = useEngineTranscript(client2);
+  const listening = (status == null ? void 0 : status.live) === "running";
+  if (segments.length === 0 && !insight && !listening) return null;
+  const rows = segments.slice(-maxLines);
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "live-captions", id: "liveCaptions", "aria-live": "polite", children: [
+    insight && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: `live-insight stance-${insight.customer.stance}`, id: "liveInsight", title: insight.summary, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "live-insight-stance", children: STANCE_LABEL[insight.customer.stance] ?? insight.customer.stance }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "live-insight-interest", children: [
+        "interesse ",
+        Math.round(insight.customer.interest),
+        "%"
+      ] }),
+      insight.nextMove && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "live-insight-next", children: insight.nextMove })
+    ] }),
+    rows.length > 0 ? /* @__PURE__ */ jsxRuntimeExports.jsx("ul", { className: "live-caption-list", children: rows.map((segment) => /* @__PURE__ */ jsxRuntimeExports.jsxs("li", { className: `live-caption ${segment.speaker}${segment.interim ? " interim" : ""}${segment.refined ? " refined" : ""}`, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "live-caption-speaker", children: SPEAKER_LABEL[segment.speaker] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "live-caption-text", children: segment.text }),
+      topEmotions(segment).map((emotion) => /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: `live-caption-emotion${emotion.source === "context" ? " ctx" : ""}`, title: emotion.evidence ?? "", children: [
+        EMOTION_LABEL[emotion.label] ?? emotion.label,
+        " ",
+        Math.round(emotion.intensity * 100),
+        "%"
+      ] }, emotion.label))
+    ] }, segment.id)) }) : /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "live-caption-waiting", children: "Ouvindo a conversa…" })
+  ] });
+}
 function useDialerNotices(options = {}) {
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
+  const operatorState = useCallOperatorState();
+  const currentCall = useCallOperatorCurrentCall();
   const [deviceIssue, setDeviceIssue] = useState(null);
   const [sessionDrop, setSessionDrop] = useState(null);
   const [callFailure, setCallFailure] = useState(null);
@@ -56869,7 +57752,7 @@ function useDialerNotices(options = {}) {
       (_a3 = mediaDevices == null ? void 0 : mediaDevices.removeEventListener) == null ? void 0 : _a3.call(mediaDevices, "devicechange", handler);
     };
   }, [options.checkDevices]);
-  clientSdkReactExports.useCallOperatorEventListener("userSessionDropped", (data) => {
+  useCallOperatorEventListener("userSessionDropped", (data) => {
     setSessionDrop((data == null ? void 0 : data.originator) ?? "unknown");
   });
   useEffect(() => {
@@ -57583,6 +58466,8 @@ function MobileDialerLogin({
   sessionStatus,
   loginConfirmation,
   onCancelLoginConfirmation,
+  onTakeOverSession,
+  onLogoutAllTabs,
   density
 }) {
   const [loginInput, setLoginInput] = useState(username ?? "");
@@ -57619,19 +58504,33 @@ function MobileDialerLogin({
       /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "login-spinner", "aria-hidden": "true" }),
       loadingUser && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "login-loading-user", children: loadingUser }),
       /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "login-status", children: sessionStatus || "Conectando..." })
-    ] }) : showConfirmation && loginConfirmation ? /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "login-confirm", children: [
+    ] }) : showConfirmation && loginConfirmation ? loginConfirmation.elsewhere ? /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "login-confirm", "data-login-state": "elsewhere", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "login-confirm-label", children: "Discador ativo em outra aba" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "login-user-chip", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-user-check", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: loginConfirmation.username })
+      ] }),
+      sessionError && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "input-error", children: sessionError }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { type: "button", className: "login-confirm-btn login-confirm-btn-blue", id: "takeOverBtn", onClick: () => onTakeOverSession == null ? void 0 : onTakeOverSession(), children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-arrow-down", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Usar o discador nesta aba" })
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("button", { type: "button", className: "login-secondary-btn login-secondary-danger", id: "logoutAllBtn", onClick: () => onLogoutAllTabs == null ? void 0 : onLogoutAllTabs(), children: "Sair em todas as abas" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "login-hint", children: "O Callix aceita uma conexão por usuário: você já está conectado em outra aba deste navegador e pode continuar por lá." })
+    ] }) : /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "login-confirm", "data-login-state": "choose", children: [
       /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "login-confirm-label", children: "Entrar como" }),
       /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "login-user-chip", children: [
         /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-user", "aria-hidden": "true" }),
         /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: loginConfirmation.username })
       ] }),
       sessionError && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "input-error", children: sessionError }),
-      /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { type: "button", className: "login-confirm-btn", onClick: () => void submitLogin(loginConfirmation.username), children: [
+      !sessionError && loginConfirmation.note && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "login-note", children: loginConfirmation.note }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { type: "button", className: "login-confirm-btn", id: "loginConfirmBtn", onClick: () => void submitLogin(loginConfirmation.username), children: [
         /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-sign-in-alt", "aria-hidden": "true" }),
         /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Entrar" })
       ] }),
       !loginConfirmation.locked && onCancelLoginConfirmation && /* @__PURE__ */ jsxRuntimeExports.jsx("button", { type: "button", className: "login-secondary-btn", onClick: onCancelLoginConfirmation, children: "Usar outro usuário" }),
-      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "login-hint", children: "Se você já estiver conectado em outra aba, continue usando o discador por lá." })
+      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "login-hint", children: "Ao entrar, todas as abas abertas passam a usar o discador. Vai usar o Callix web? Então não entre aqui: nada é conectado sem a sua confirmação." })
     ] }) : /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
       /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "phone-number-display", children: /* @__PURE__ */ jsxRuntimeExports.jsx(
         "input",
@@ -57724,6 +58623,7 @@ Gostaríamos de fazer um *diagnóstico gratuito* para te apresentar os valores r
 }
 function AuthenticatedMobileDialer({
   username,
+  onLogout,
   showClientInfoModal = false,
   density
 }) {
@@ -57762,21 +58662,21 @@ function AuthenticatedMobileDialer({
   const [speakerDeviceId, setSpeakerDeviceId] = useState(null);
   const [defaultDeviceId, setDefaultDeviceId] = useState("default");
   const [speakerSupported, setSpeakerSupported] = useState(null);
-  const operator = clientSdkReactExports.useCallOperator();
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
-  const { hangup, answer, reject } = clientSdkReactExports.useCallOperatorCurrentCallControls();
-  const callInfo = clientSdkReactExports.useCallOperatorCurrentCallInfo();
-  const rawSuccessQualifications = clientSdkReactExports.useCallOperatorSuccessQualifications();
-  const rawDiscardQualifications = clientSdkReactExports.useCallOperatorDiscardQualifications();
+  const operator = useCallOperator();
+  const operatorState = useCallOperatorState();
+  const currentCall = useCallOperatorCurrentCall();
+  const { hangup, answer, reject } = useCallOperatorCurrentCallControls();
+  const callInfo = useCallOperatorCurrentCallInfo();
+  const rawSuccessQualifications = useCallOperatorSuccessQualifications();
+  const rawDiscardQualifications = useCallOperatorDiscardQualifications();
   const successQualifications = useMemo(() => rawSuccessQualifications ?? [], [rawSuccessQualifications]);
   const discardQualifications = useMemo(() => rawDiscardQualifications ?? [], [rawDiscardQualifications]);
-  const { makeManualCall, finishAfterCall } = clientSdkReactExports.useCallOperatorControls();
+  const { makeManualCall, finishAfterCall } = useCallOperatorControls();
   const { goOnBreak, goOffBreak } = useOperatorBreak();
   const breaks = useSignal(operator == null ? void 0 : operator.breaks) || [];
   const userData = useSignal(operator == null ? void 0 : operator.user);
   const isOnBreak = (operatorState == null ? void 0 : operatorState.state) === "onBreak";
-  const [inputMuted, setInputMuted] = clientSdkReactExports.useCallOperatorAudioInputMuted();
+  const [inputMuted, setInputMuted] = useCallOperatorAudioInputMuted();
   const haptic = useHaptic();
   const dtmf = useDTMF({ enabled: true });
   const keySequenceRef = useRef("");
@@ -58490,13 +59390,30 @@ function AuthenticatedMobileDialer({
             /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "pause-timer", children: pauseDurationLabel })
           ] }) : /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "status-text", children: statusBadgeText })
         ] }) }),
-        /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "status-actions", children: isOnBreak ? /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { className: "resume-btn", id: "resumeBtn", onClick: handleGoOffBreak, children: [
-          /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-play" }),
-          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Voltar" })
-        ] }) : /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { className: "pause-btn", id: "pauseBtn", onClick: () => setIsPauseModalOpen(true), children: [
-          /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-pause" }),
-          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Pausa" })
-        ] }) })
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "status-actions", children: [
+          isOnBreak ? /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { className: "resume-btn", id: "resumeBtn", onClick: handleGoOffBreak, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-play" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Voltar" })
+          ] }) : /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { className: "pause-btn", id: "pauseBtn", onClick: () => setIsPauseModalOpen(true), children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-pause" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Pausa" })
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "button",
+            {
+              type: "button",
+              className: "logout-btn",
+              id: "logoutBtn",
+              title: "Sair do discador (todas as abas)",
+              "aria-label": "Sair do discador",
+              onClick: () => {
+                if (typeof window !== "undefined" && !window.confirm("Sair do discador em todas as abas?")) return;
+                onLogout();
+              },
+              children: /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fas fa-right-from-bracket" })
+            }
+          )
+        ] })
       ] }),
       /* @__PURE__ */ jsxRuntimeExports.jsx(DialerNoticeBanner, { notice: dialerNotice, onDismiss: dismissDialerNotice, onRecheck: () => void recheckDevices(), onHeightChange: setNoticeHeight }),
       /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "phone-number-display", children: /* @__PURE__ */ jsxRuntimeExports.jsx(
@@ -58595,6 +59512,7 @@ function AuthenticatedMobileDialer({
           ] })
         ] }) })
       ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(LiveCaptionPanel, {}),
       /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "call-controls", children: [
         /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "control-row", children: [
           /* @__PURE__ */ jsxRuntimeExports.jsxs(
@@ -59049,14 +59967,14 @@ function AuthenticatedMiniDialer({
 }) {
   var _a2;
   const { skipManualQualification } = useDialerConfig();
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const currentCallInfo = clientSdkReactExports.useCallOperatorCurrentCallInfo();
-  const currentCall = clientSdkReactExports.useCallOperatorCurrentCall();
-  const rawSuccessQualifications = clientSdkReactExports.useCallOperatorSuccessQualifications();
-  const rawDiscardQualifications = clientSdkReactExports.useCallOperatorDiscardQualifications();
+  const operatorState = useCallOperatorState();
+  const currentCallInfo = useCallOperatorCurrentCallInfo();
+  const currentCall = useCallOperatorCurrentCall();
+  const rawSuccessQualifications = useCallOperatorSuccessQualifications();
+  const rawDiscardQualifications = useCallOperatorDiscardQualifications();
   const successQualifications = useMemo(() => rawSuccessQualifications ?? [], [rawSuccessQualifications]);
   const discardQualifications = useMemo(() => rawDiscardQualifications ?? [], [rawDiscardQualifications]);
-  const { finishAfterCall } = clientSdkReactExports.useCallOperatorControls();
+  const { finishAfterCall } = useCallOperatorControls();
   const [isClientInfoModalOpen, setIsClientInfoModalOpen] = useState(false);
   const [isQualificationModalOpen, setIsQualificationModalOpen] = useState(false);
   const [callDurationSeconds, setCallDurationSeconds] = useState(0);
@@ -59331,6 +60249,206 @@ function AuthenticatedMiniDialer({
     )
   ] });
 }
+const PROBE_TIMEOUT_MS = 600;
+const TAKEOVER_GRACE_MS = 3e3;
+const TAKEOVER_JITTER_MS = 600;
+const LEADER_HEARTBEAT_MS = 3e3;
+const LEADER_STALE_MS = 9e3;
+function channelName(username) {
+  return `callix-dialer:${username.trim().toLowerCase()}`;
+}
+function leaderKey(username) {
+  return `callix_dialer_${username}_leader`;
+}
+const TAB_ROLE_KEY = "callix_dialer_tab_role";
+const BUS_FALLBACK_SUFFIX = "_bus";
+function newTabId() {
+  const cryptoApi = typeof globalThis.crypto !== "undefined" ? globalThis.crypto : void 0;
+  if (cryptoApi && "randomUUID" in cryptoApi) return cryptoApi.randomUUID().slice(0, 8);
+  return Math.random().toString(36).slice(2, 10);
+}
+function defaultChannelFactory(name) {
+  if (typeof BroadcastChannel === "undefined") return null;
+  try {
+    return new BroadcastChannel(name);
+  } catch {
+    return null;
+  }
+}
+function defaultStorage() {
+  try {
+    return typeof localStorage !== "undefined" ? localStorage : null;
+  } catch {
+    return null;
+  }
+}
+class DialerTabBus {
+  constructor(options) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.storageListener = null;
+    this.closed = false;
+    this.username = options.username;
+    this.tabId = options.tabId ?? newTabId();
+    this.status = options.status;
+    this.storage = options.storage === void 0 ? defaultStorage() : options.storage;
+    const factory = options.channelFactory ?? defaultChannelFactory;
+    this.channel = factory(channelName(this.username));
+    if (this.channel) {
+      this.channel.onmessage = (event) => this.receive(event.data);
+    } else if (typeof window !== "undefined" && this.storage) {
+      const key = this.fallbackKey();
+      this.storageListener = (event) => {
+        if (event.key !== key || !event.newValue) return;
+        try {
+          const parsed = JSON.parse(event.newValue);
+          this.receive(parsed.message);
+        } catch {
+        }
+      };
+      window.addEventListener("storage", this.storageListener);
+    }
+  }
+  fallbackKey() {
+    return `callix_dialer_${this.username}${BUS_FALLBACK_SUFFIX}`;
+  }
+  on(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  post(message) {
+    if (this.closed) return;
+    const full = { ...message, from: this.tabId };
+    if (this.channel) {
+      try {
+        this.channel.postMessage(full);
+      } catch {
+      }
+      return;
+    }
+    if (this.storage) {
+      try {
+        this.storage.setItem(this.fallbackKey(), JSON.stringify({ nonce: Math.random(), at: Date.now(), message: full }));
+      } catch {
+      }
+    }
+  }
+  receive(data) {
+    if (this.closed || !data || typeof data !== "object") return;
+    const message = data;
+    if (typeof message.type !== "string" || typeof message.from !== "string" || message.from === this.tabId) return;
+    if (message.type === "ping") {
+      const status = this.status();
+      this.post({ type: "pong", role: status.role, authenticated: status.authenticated });
+    }
+    for (const listener of this.listeners) listener(message);
+  }
+  /** pergunta quem está aí; devolve as abas que responderam dentro do prazo */
+  probe(timeoutMs = PROBE_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+      const found = /* @__PURE__ */ new Map();
+      const off = this.on((message) => {
+        if (message.type === "pong") found.set(message.from, { tabId: message.from, role: message.role, authenticated: message.authenticated });
+      });
+      this.post({ type: "ping" });
+      setTimeout(() => {
+        off();
+        resolve([...found.values()]);
+      }, timeoutMs);
+    });
+  }
+  close() {
+    this.closed = true;
+    this.listeners.clear();
+    if (this.channel) {
+      this.channel.onmessage = null;
+      try {
+        this.channel.close();
+      } catch {
+      }
+    }
+    if (this.storageListener && typeof window !== "undefined") {
+      window.removeEventListener("storage", this.storageListener);
+      this.storageListener = null;
+    }
+  }
+}
+function findLeader(pongs) {
+  return pongs.find((pong) => pong.role === "leader" && pong.authenticated) ?? null;
+}
+function anyDialerTab(pongs) {
+  return pongs.some((pong) => pong.role !== null);
+}
+function readLeader(username, storage = defaultStorage(), now = Date.now()) {
+  if (!storage) return null;
+  try {
+    const raw = storage.getItem(leaderKey(username));
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.tabId !== "string" || typeof parsed.at !== "number") return null;
+    if (now - parsed.at > LEADER_STALE_MS) return null;
+    return { tabId: parsed.tabId, at: parsed.at };
+  } catch {
+    return null;
+  }
+}
+function claimLeader(username, tabId, storage = defaultStorage(), now = Date.now()) {
+  if (!storage) return true;
+  const current = readLeader(username, storage, now);
+  if (current && current.tabId !== tabId) return false;
+  try {
+    storage.setItem(leaderKey(username), JSON.stringify({ tabId, at: now }));
+  } catch {
+  }
+  return true;
+}
+function releaseLeader(username, tabId, storage = defaultStorage()) {
+  if (!storage) return;
+  try {
+    const raw = storage.getItem(leaderKey(username));
+    if (!raw) return;
+    const parsed = JSON.parse(raw);
+    if (parsed.tabId === tabId) storage.removeItem(leaderKey(username));
+  } catch {
+  }
+}
+function defaultSessionStorage() {
+  try {
+    return typeof sessionStorage !== "undefined" ? sessionStorage : null;
+  } catch {
+    return null;
+  }
+}
+function saveTabRole(username, role, storage = defaultSessionStorage()) {
+  if (!storage) return;
+  try {
+    storage.setItem(TAB_ROLE_KEY, JSON.stringify({ username, role, at: Date.now() }));
+  } catch {
+  }
+}
+function readTabRole(username, storage = defaultSessionStorage()) {
+  if (!storage) return null;
+  try {
+    const raw = storage.getItem(TAB_ROLE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (parsed.username !== username) return null;
+    return parsed.role === "leader" || parsed.role === "member" ? parsed.role : null;
+  } catch {
+    return null;
+  }
+}
+function clearTabRole(storage = defaultSessionStorage()) {
+  if (!storage) return;
+  try {
+    storage.removeItem(TAB_ROLE_KEY);
+  } catch {
+  }
+}
+function takeoverDelayMs(random = Math.random()) {
+  return TAKEOVER_GRACE_MS + Math.floor(random * TAKEOVER_JITTER_MS);
+}
 const DEFAULT_CLICK_TO_CALL_INTERVAL_MS = 4e3;
 const BUSY_INTERVAL_FACTOR = 3;
 const DISPATCH_COOLDOWN_MS = 6e3;
@@ -59350,8 +60468,8 @@ function buildHeaders(sessionToken) {
 }
 const delay = (ms2) => new Promise((resolve) => setTimeout(resolve, ms2));
 function ClickToCallAgent({ enabled = true, pollIntervalMs, sessionToken, onTask }) {
-  const operatorState = clientSdkReactExports.useCallOperatorState();
-  const { makeManualCall } = clientSdkReactExports.useCallOperatorControls();
+  const operatorState = useCallOperatorState();
+  const { makeManualCall } = useCallOperatorControls();
   const stateRef = useRef(operatorState == null ? void 0 : operatorState.state);
   stateRef.current = operatorState == null ? void 0 : operatorState.state;
   const makeManualCallRef = useRef(makeManualCall);
@@ -59553,7 +60671,7 @@ function ClickToCallAgent({ enabled = true, pollIntervalMs, sessionToken, onTask
   }, [enabled, pollIntervalMs, sessionToken]);
   return null;
 }
-const WIDGET_VERSION = "2.5.1";
+const WIDGET_VERSION = "2.7.0";
 let currentSipWebSocket = null;
 function sendSipUnregisterIfPossible(ws) {
   if (ws.readyState !== WebSocket.OPEN) return;
@@ -59679,9 +60797,23 @@ function useDialerConfig() {
   return context;
 }
 const SdkCleanupManager = forwardRef(
-  function SdkCleanupManager2({ children: children2 }, ref) {
-    const operator = clientSdkReactExports.useCallOperator();
-    const controls = clientSdkReactExports.useCallOperatorControls();
+  function SdkCleanupManager2({ children: children2, onSessionDropped }, ref) {
+    const operator = useCallOperator();
+    const controls = useCallOperatorControls();
+    const operatorState = useCallOperatorState();
+    const droppedRef = useRef(onSessionDropped);
+    droppedRef.current = onSessionDropped;
+    useCallOperatorEventListener("userSessionDropped", (data) => {
+      var _a2;
+      const originator = (data == null ? void 0 : data.originator) ?? null;
+      (_a2 = droppedRef.current) == null ? void 0 : _a2.call(droppedRef, originator, describeSessionDrop(originator));
+    });
+    const startupError = (operatorState == null ? void 0 : operatorState.state) === "startupError" ? operatorState.error ?? null : null;
+    useEffect(() => {
+      var _a2;
+      if (startupError !== "userIsAlreadyConnectedOnAnotherDevice") return;
+      (_a2 = droppedRef.current) == null ? void 0 : _a2.call(droppedRef, "anotherDevice", describeStartupError(startupError));
+    }, [startupError]);
     useImperativeHandle(ref, () => ({
       goOffline: () => {
         console.log("[Callix Dialer] 📴 Chamando goOffline() para enviar SIP UNREGISTER...");
@@ -59702,21 +60834,27 @@ const SdkCleanupManager = forwardRef(
         }
       }
     }), [operator, controls]);
+    const controlsRef = useRef(controls);
+    controlsRef.current = controls;
     useEffect(() => {
       return () => {
         console.log("[Callix Dialer] 🔌 SdkCleanupManager desmontando, chamando goOffline()...");
         try {
-          controls.goOffline();
+          controlsRef.current.goOffline();
         } catch (err) {
           console.warn("[Callix Dialer] ⚠️ Erro no cleanup automático:", err);
         }
       };
-    }, [controls]);
+    }, []);
     return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: children2 });
   }
 );
 function deriveOptionsFromElement(element) {
   const result2 = {};
+  const datasetEngineUrl = element.getAttribute("data-callix-engine-url") ?? element.dataset.callixEngineUrl;
+  if (datasetEngineUrl && datasetEngineUrl.trim()) result2.engineUrl = datasetEngineUrl.trim();
+  const datasetEngineToken = element.getAttribute("data-callix-engine-token") ?? element.dataset.callixEngineToken;
+  if (datasetEngineToken && datasetEngineToken.trim()) result2.engineToken = datasetEngineToken.trim();
   const datasetMode = element.getAttribute("data-callix-mode") || element.dataset.callixMode || element.dataset.mode;
   const datasetUsername = element.getAttribute("data-callix-username") || element.dataset.callixUsername || element.dataset.username;
   const classList = Array.from(element.classList);
@@ -59808,6 +60946,12 @@ class CallixDialerWidget {
       if (this.options.clickToCall === void 0 && derived.clickToCall !== void 0) {
         this.options.clickToCall = derived.clickToCall;
       }
+      if (!this.options.engineUrl && derived.engineUrl) {
+        this.options.engineUrl = derived.engineUrl;
+      }
+      if (!this.options.engineToken && derived.engineToken) {
+        this.options.engineToken = derived.engineToken;
+      }
       this.root = clientExports.createRoot(this.container);
       this.root.render(
         /* @__PURE__ */ jsxRuntimeExports.jsx(StrictMode, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(DialerWrapper, { options: this.options, containerEl: this.container }) })
@@ -59840,6 +60984,27 @@ const getStorageKeys = (username) => ({
   SKIP_MANUAL_QUALIFICATION: `callix_dialer_${username}_skip_manual_qualification`
 });
 const LAST_USERNAME_KEY = "callix_dialer_last_username";
+function readStoredToken(user) {
+  try {
+    return localStorage.getItem(getStorageKeys(user).SESSION_TOKEN);
+  } catch {
+    return null;
+  }
+}
+async function fetchSkipQualification(domain, token) {
+  var _a2, _b;
+  try {
+    const response = await fetch(`https://${domain}/sdk/v1/client/user-service/config`, {
+      headers: { Authorization: `Bearer ${token}` },
+      credentials: "omit"
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    return ((_b = (_a2 = data == null ? void 0 : data.service) == null ? void 0 : _a2.outboundOptions) == null ? void 0 : _b.skipQualification) === true;
+  } catch {
+    return null;
+  }
+}
 function DialerWrapper({ options, containerEl }) {
   const [username, setUsername] = useState(null);
   const [isAuthenticated, setIsAuthenticated] = useState(false);
@@ -59855,10 +61020,35 @@ function DialerWrapper({ options, containerEl }) {
   const [isDisconnecting, setIsDisconnecting] = useState(false);
   const presetUsername = options.presetUsername ? options.presetUsername.trim() : null;
   const uiVariant = options.uiVariant ?? "default";
-  const autoLogin = options.autoLogin === true;
   const portalTarget = useMemo(() => options.portalTarget ?? containerEl ?? null, [options.portalTarget, containerEl]);
-  const autoLoginAttemptedRef = useRef(false);
-  const lastPresetRef = useRef(presetUsername);
+  const tabIdRef = useRef("");
+  if (!tabIdRef.current) tabIdRef.current = newTabId();
+  const [tabRole, setTabRole] = useState(null);
+  const tabRoleRef = useRef(null);
+  tabRoleRef.current = tabRole;
+  const [tabDecided, setTabDecided] = useState(false);
+  const [tabNote, setTabNote] = useState(null);
+  const [engineWaiting, setEngineWaiting] = useState(false);
+  const busRef = useRef(null);
+  const takeoverTimerRef = useRef(null);
+  const isAuthenticatedRef = useRef(false);
+  isAuthenticatedRef.current = isAuthenticated;
+  const isLoadingRef = useRef(false);
+  isLoadingRef.current = isLoading;
+  const logoffPendingRef = useRef(false);
+  const handleLoginRef = useRef(async () => void 0);
+  const handleLogoutRef = useRef(async () => void 0);
+  const cancelTakeover = useCallback(() => {
+    if (takeoverTimerRef.current) {
+      clearTimeout(takeoverTimerRef.current);
+      takeoverTimerRef.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    if (options.autoLogin) {
+      console.info("[Callix Dialer] autoLogin: desde a 2.7.0 o widget não cria sessão sem confirmação; ele entra sozinho só quando já existe uma conexão ativa deste usuário (outra aba ou o motor).");
+    }
+  }, [options.autoLogin]);
   const currentSessionRef = useRef({
     apiUrl: options.apiUrl || "/api/user-sdk-session",
     token: null
@@ -59866,9 +61056,60 @@ function DialerWrapper({ options, containerEl }) {
   useEffect(() => {
     currentSessionRef.current.token = sessionToken;
   }, [sessionToken]);
+  const engineMode = Boolean(options.engineUrl);
+  const engineModeRef = useRef(engineMode);
+  engineModeRef.current = engineMode;
+  const engineRef = useRef(null);
+  const ensureEngine = useCallback(
+    (user) => {
+      const current = engineRef.current;
+      if (current && current.agentId === user) {
+        current.connect();
+        return current;
+      }
+      current == null ? void 0 : current.close();
+      const client2 = new EngineClient({
+        url: options.engineUrl ?? "",
+        token: options.engineToken ?? "",
+        agentId: user,
+        label: "Discador",
+        log: (message) => console.log("[Callix Dialer/motor]", message)
+      });
+      client2.onSessionLost((lost) => {
+        const notice = describeSessionDrop(lost.originator);
+        setError(`${notice.title}: ${notice.detail}${notice.action ? ` ${notice.action}` : ""}`);
+        setIsAuthenticated(false);
+        setSessionToken(null);
+        setTabNote(null);
+      });
+      client2.connect();
+      engineRef.current = client2;
+      return client2;
+    },
+    [options.engineUrl, options.engineToken]
+  );
+  useEffect(
+    () => () => {
+      var _a2;
+      (_a2 = engineRef.current) == null ? void 0 : _a2.close();
+      engineRef.current = null;
+    },
+    []
+  );
   useEffect(() => {
+    let unloadHandled = false;
     const handleBeforeUnload = () => {
+      var _a2;
+      if (engineModeRef.current || unloadHandled) return;
+      unloadHandled = true;
+      setTimeout(() => {
+        unloadHandled = false;
+      }, 2e3);
       const { apiUrl, token } = currentSessionRef.current;
+      if (tabRoleRef.current === "leader") {
+        (_a2 = busRef.current) == null ? void 0 : _a2.post({ type: "leaving" });
+        if (busRef.current) releaseLeader(busRef.current.username, tabIdRef.current);
+      }
       if (token) {
         const data = JSON.stringify({ logout: true });
         const logoutUrl = `${apiUrl}?logout=true`;
@@ -59887,8 +61128,10 @@ function DialerWrapper({ options, containerEl }) {
       }
     };
     window.addEventListener("beforeunload", handleBeforeUnload);
+    window.addEventListener("pagehide", handleBeforeUnload);
     return () => {
       window.removeEventListener("beforeunload", handleBeforeUnload);
+      window.removeEventListener("pagehide", handleBeforeUnload);
     };
   }, []);
   useEffect(() => {
@@ -59926,12 +61169,300 @@ function DialerWrapper({ options, containerEl }) {
       setUsername(presetUsername);
     }
   }, [presetUsername, username]);
+  const engineDomain = useCallback(
+    () => options.domain || new URL(options.apiUrl || "/api/user-sdk-session", window.location.href).host,
+    [options.domain, options.apiUrl]
+  );
+  const enterEngine = useCallback(async (user, domain, token) => {
+    if (token) {
+      const skip = await fetchSkipQualification(domain, token);
+      if (skip !== null) {
+        setSkipManualQualification(skip);
+        try {
+          localStorage.setItem(getStorageKeys(user).SKIP_MANUAL_QUALIFICATION, String(skip));
+        } catch {
+        }
+      }
+    }
+    try {
+      localStorage.setItem(LAST_USERNAME_KEY, user);
+      if (token) {
+        const STORAGE_KEYS = getStorageKeys(user);
+        localStorage.setItem(STORAGE_KEYS.SESSION_TOKEN, token);
+        localStorage.setItem(STORAGE_KEYS.DOMAIN, domain);
+        localStorage.setItem(STORAGE_KEYS.TIMESTAMP, Date.now().toString());
+      }
+    } catch {
+    }
+    setSessionToken(token);
+    setCallixDomain(domain);
+    setUsername(user);
+    setIsAuthenticated(true);
+    setError(null);
+    setTabNote(null);
+    setProviderKey(Date.now());
+  }, []);
+  const joinEngine = useCallback(
+    async (user) => {
+      setIsLoading(true);
+      setError(null);
+      setLoginStatus("Entrando na sessão do motor...");
+      try {
+        await enterEngine(user, engineDomain(), readStoredToken(user));
+        console.log("[Callix Dialer] Conectado ao motor como", user);
+      } catch (err) {
+        console.error("[Callix Dialer] Erro ao entrar na sessão do motor:", err);
+        setError(err instanceof Error ? err.message : "Erro ao conectar ao motor");
+      } finally {
+        setIsLoading(false);
+        setLoginStatus(null);
+      }
+    },
+    [enterEngine, engineDomain]
+  );
+  useEffect(() => {
+    if (!engineMode || !username || isRestoringSession) return;
+    const user = username;
+    const client2 = ensureEngine(user);
+    setEngineWaiting(!client2.getState().view);
+    const fallback = setTimeout(() => setEngineWaiting(false), 15e3);
+    let joining = false;
+    const sync = () => {
+      const { view, sessionLost } = client2.getState();
+      if (!view) return;
+      setEngineWaiting(false);
+      if (view.engine === "stopped" || view.engine === "crashed") logoffPendingRef.current = false;
+      const hasSession = (view.engine === "running" || view.engine === "starting") && !sessionLost;
+      if (hasSession && !logoffPendingRef.current && !isAuthenticatedRef.current && !isLoadingRef.current && !joining) {
+        joining = true;
+        console.log("[Callix Dialer] o motor já segura a sessão deste agente; entrando por aqui também");
+        void joinEngine(user).finally(() => {
+          joining = false;
+        });
+      } else if (view.engine === "stopped" && isAuthenticatedRef.current && !isLoadingRef.current) {
+        console.log("[Callix Dialer] o motor desligou (Sair em outra aba ou servidor reiniciado); voltando à tela de login");
+        setIsAuthenticated(false);
+        setSessionToken(null);
+        setCallixDomain(null);
+        setTabNote("O discador foi encerrado em outra aba ou o motor foi reiniciado.");
+      }
+    };
+    sync();
+    const off = client2.subscribe(sync);
+    return () => {
+      off();
+      clearTimeout(fallback);
+    };
+  }, [engineMode, username, isRestoringSession, ensureEngine, joinEngine]);
+  const scheduleTakeoverRef = useRef(null);
+  useEffect(() => {
+    if (engineMode || !username) {
+      setTabDecided(true);
+      return;
+    }
+    setTabDecided(false);
+    const user = username;
+    const bus = new DialerTabBus({
+      username: user,
+      tabId: tabIdRef.current,
+      status: () => ({ role: tabRoleRef.current, authenticated: isAuthenticatedRef.current })
+    });
+    busRef.current = bus;
+    const becomeMember = () => {
+      if (isAuthenticatedRef.current || tabRoleRef.current === "leader") return;
+      setTabRole("member");
+      saveTabRole(user, "member");
+      setTabNote(null);
+      setError(null);
+      setTabDecided(true);
+    };
+    const scheduleTakeover = () => {
+      cancelTakeover();
+      takeoverTimerRef.current = setTimeout(() => {
+        takeoverTimerRef.current = null;
+        if (tabRoleRef.current !== "member" || isAuthenticatedRef.current || isLoadingRef.current) return;
+        const current = readLeader(user);
+        if (current && current.tabId !== tabIdRef.current) return;
+        if (!claimLeader(user, tabIdRef.current)) return;
+        bus.post({ type: "claim" });
+        console.log("[Callix Dialer] a aba com o discador fechou; esta aba assume a conexão");
+        void handleLoginRef.current(user);
+      }, takeoverDelayMs());
+    };
+    scheduleTakeoverRef.current = scheduleTakeover;
+    const off = bus.on((message) => {
+      switch (message.type) {
+        case "login":
+        case "claim":
+          cancelTakeover();
+          becomeMember();
+          break;
+        case "leaving":
+          if (tabRoleRef.current === "member" && !isAuthenticatedRef.current) scheduleTakeover();
+          break;
+        case "takeover":
+          if (tabRoleRef.current === "leader") {
+            console.log("[Callix Dialer] outra aba pediu o discador; soltando a conexão");
+            void handleLogoutRef.current({ broadcast: false, keepDecision: true });
+          }
+          break;
+        case "logout":
+          cancelTakeover();
+          void handleLogoutRef.current({ broadcast: false });
+          setTabNote("Você saiu do discador em outra aba.");
+          break;
+        case "dropped": {
+          cancelTakeover();
+          releaseLeader(user, tabIdRef.current);
+          setTabRole(null);
+          clearTabRole();
+          const notice = describeSessionDrop(message.originator);
+          setError(`${notice.title}: ${notice.detail}${notice.action ? ` ${notice.action}` : ""}`);
+          break;
+        }
+      }
+    });
+    return () => {
+      off();
+      bus.close();
+      cancelTakeover();
+      scheduleTakeoverRef.current = null;
+      if (busRef.current === bus) busRef.current = null;
+      setTabDecided(false);
+    };
+  }, [engineMode, username, cancelTakeover]);
+  useEffect(() => {
+    if (engineMode || !username || isAuthenticated || tabDecided || isRestoringSession || isLoading) return;
+    const bus = busRef.current;
+    if (!bus) return;
+    const user = username;
+    const stored = readTabRole(user);
+    if (stored === "leader") {
+      cancelTakeover();
+      setTabDecided(true);
+      if (claimLeader(user, tabIdRef.current)) {
+        bus.post({ type: "claim" });
+        console.log("[Callix Dialer] esta aba segurava o discador antes de recarregar; reconectando");
+        void handleLoginRef.current(user);
+      } else {
+        setTabRole("member");
+        saveTabRole(user, "member");
+      }
+      return;
+    }
+    let cancelled = false;
+    void bus.probe().then((pongs) => {
+      var _a2;
+      if (cancelled) return;
+      setTabDecided(true);
+      const leaderLock = readLeader(user);
+      if (findLeader(pongs) || leaderLock && leaderLock.tabId !== tabIdRef.current || stored === "member" && anyDialerTab(pongs)) {
+        setTabRole("member");
+        saveTabRole(user, "member");
+      } else if (stored === "member") {
+        setTabRole("member");
+        (_a2 = scheduleTakeoverRef.current) == null ? void 0 : _a2.call(scheduleTakeoverRef);
+      } else {
+        setTabRole(null);
+        clearTabRole();
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [engineMode, username, isAuthenticated, tabDecided, isRestoringSession, isLoading, cancelTakeover]);
+  useEffect(() => {
+    if (engineMode || tabRole !== "leader" || !username) return;
+    const user = username;
+    claimLeader(user, tabIdRef.current);
+    const timer = setInterval(() => claimLeader(user, tabIdRef.current), LEADER_HEARTBEAT_MS);
+    return () => clearInterval(timer);
+  }, [engineMode, tabRole, username]);
+  useEffect(() => {
+    if (engineMode || tabRole !== "member" || !username) return;
+    const user = username;
+    const check = () => {
+      if (document.visibilityState !== "visible" || takeoverTimerRef.current) return;
+      const bus = busRef.current;
+      if (!bus) return;
+      void bus.probe().then((pongs) => {
+        var _a2;
+        if (tabRoleRef.current !== "member" || isAuthenticatedRef.current || takeoverTimerRef.current) return;
+        if (findLeader(pongs) || readLeader(user)) return;
+        console.log("[Callix Dialer] a aba com o discador não responde; esta aba vai assumir");
+        (_a2 = scheduleTakeoverRef.current) == null ? void 0 : _a2.call(scheduleTakeoverRef);
+      });
+    };
+    document.addEventListener("visibilitychange", check);
+    window.addEventListener("focus", check);
+    return () => {
+      document.removeEventListener("visibilitychange", check);
+      window.removeEventListener("focus", check);
+    };
+  }, [engineMode, tabRole, username]);
   const handleLogin = useCallback(async (user) => {
-    var _a2, _b;
+    var _a2, _b, _c, _d;
     setIsLoading(true);
     setError(null);
     setLoginStatus("Preparando login...");
     console.log("[Callix Dialer] 🚀 handleLogin iniciado para usuário:", user);
+    if (options.engineUrl) {
+      const engineApiUrl = options.apiUrl || "/api/user-sdk-session";
+      try {
+        setLoginStatus("Conectando ao motor...");
+        logoffPendingRef.current = false;
+        const client2 = ensureEngine(user);
+        const view = await client2.waitForView(15e3);
+        const domain = engineDomain();
+        const engineHasSession = (view.engine === "running" || view.engine === "starting") && !view.sessionLost;
+        let token = null;
+        if (engineHasSession) {
+          token = readStoredToken(user);
+          console.log("[Callix Dialer] motor já tem a sessão do agente; entrando sem novo login");
+        } else {
+          setLoginStatus("Autenticando no Callix...");
+          const response = await fetch(engineApiUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ username: user }),
+            credentials: "same-origin"
+          });
+          if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ error: "Erro desconhecido" }));
+            throw new Error(errorData.error || `Falha na autenticação: ${response.status}`);
+          }
+          const data = await response.json();
+          token = data.userSessionToken;
+          client2.setSession({ domain, userSessionToken: token });
+          setLoginStatus("Subindo o motor...");
+        }
+        await enterEngine(user, domain, token);
+        console.log("[Callix Dialer] Conectado ao motor como", user);
+      } catch (err) {
+        console.error("[Callix Dialer] Erro ao entrar pelo motor:", err);
+        setError(err instanceof Error ? err.message : "Erro ao conectar ao motor");
+        setIsAuthenticated(false);
+        setSessionToken(null);
+      } finally {
+        setIsLoading(false);
+        setLoginStatus(null);
+      }
+      return;
+    }
+    if (!claimLeader(user, tabIdRef.current)) {
+      console.log("[Callix Dialer] outra aba já segura a conexão deste usuário; esta aba vira membro");
+      setTabRole("member");
+      saveTabRole(user, "member");
+      setTabDecided(true);
+      setUsername(user);
+      setIsLoading(false);
+      setLoginStatus(null);
+      return;
+    }
+    (_a2 = busRef.current) == null ? void 0 : _a2.post({ type: "claim" });
+    cancelTakeover();
+    setTabRole("leader");
+    saveTabRole(user, "leader");
     const apiUrl = options.apiUrl || "/api/user-sdk-session";
     let previousToken;
     if (typeof window !== "undefined") {
@@ -60026,6 +61557,9 @@ function DialerWrapper({ options, containerEl }) {
       setError(null);
       setProviderKey(Date.now());
       console.log("[Callix Dialer] Nova providerKey gerada para forçar recriação do SDK");
+      setTabNote(null);
+      setTabDecided(true);
+      (_b = busRef.current) == null ? void 0 : _b.post({ type: "login" });
       try {
         const configUrl = `https://${resolvedDomain}/sdk/v1/client/user-service/config`;
         setLoginStatus("Carregando configurações...");
@@ -60040,7 +61574,7 @@ function DialerWrapper({ options, containerEl }) {
         if (configResponse.ok) {
           const configData = await configResponse.json();
           console.log("[Callix Dialer] 📦 Dados da config recebidos:", JSON.stringify(configData, null, 2));
-          const shouldSkipQualification = ((_b = (_a2 = configData == null ? void 0 : configData.service) == null ? void 0 : _a2.outboundOptions) == null ? void 0 : _b.skipQualification) === true;
+          const shouldSkipQualification = ((_d = (_c = configData == null ? void 0 : configData.service) == null ? void 0 : _c.outboundOptions) == null ? void 0 : _d.skipQualification) === true;
           console.log("[Callix Dialer] ✅ skipQualification configurado:", shouldSkipQualification);
           setSkipManualQualification(shouldSkipQualification);
           if (typeof window !== "undefined") {
@@ -60074,50 +61608,52 @@ function DialerWrapper({ options, containerEl }) {
       setError(err instanceof Error ? err.message : "Erro ao autenticar");
       setIsAuthenticated(false);
       setSessionToken(null);
+      releaseLeader(user, tabIdRef.current);
+      setTabRole(null);
+      clearTabRole();
     } finally {
       setIsLoading(false);
       setLoginStatus(null);
     }
-  }, [options.apiUrl, options.domain, isAuthenticated, sessionToken]);
-  useEffect(() => {
-    if (lastPresetRef.current !== presetUsername) {
-      lastPresetRef.current = presetUsername;
-      autoLoginAttemptedRef.current = false;
-    }
-    if (!presetUsername || !autoLogin) {
-      return;
-    }
-    if (isAuthenticated || isLoading || isRestoringSession || error2 || autoLoginAttemptedRef.current) {
-      return;
-    }
-    autoLoginAttemptedRef.current = true;
-    void handleLogin(presetUsername);
-  }, [presetUsername, autoLogin, isAuthenticated, isLoading, isRestoringSession, error2, handleLogin]);
+  }, [options.apiUrl, options.domain, options.engineUrl, isAuthenticated, sessionToken, ensureEngine, enterEngine, engineDomain, cancelTakeover]);
   useEffect(() => {
-    if (!autoLogin || presetUsername || !username || isAuthenticated || isLoading || isRestoringSession || error2 || autoLoginAttemptedRef.current) {
-      return;
-    }
-    console.log("[Callix Dialer] Auto-login com username restaurado:", username);
-    autoLoginAttemptedRef.current = true;
-    void handleLogin(username);
-  }, [autoLogin, presetUsername, username, isAuthenticated, isLoading, isRestoringSession, error2, handleLogin]);
-  const handleLogout = useCallback(async () => {
+    handleLoginRef.current = handleLogin;
+  }, [handleLogin]);
+  const handleLogout = useCallback(async (opts) => {
+    var _a2, _b;
+    const broadcast = (opts == null ? void 0 : opts.broadcast) !== false;
+    const keepDecision = (opts == null ? void 0 : opts.keepDecision) === true;
     const currentUsername = username;
-    if (cleanupRef.current) {
-      console.log("[Callix Dialer] 📴 Logout: Chamando goOffline()...");
-      cleanupRef.current.goOffline();
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      console.log("[Callix Dialer] 🛑 Logout: Chamando stop()...");
-      cleanupRef.current.stop();
-      await new Promise((resolve) => setTimeout(resolve, 500));
+    cancelTakeover();
+    if (options.engineUrl) {
+      if (isAuthenticatedRef.current) {
+        logoffPendingRef.current = true;
+        (_a2 = engineRef.current) == null ? void 0 : _a2.command({ name: "logoff" });
+      }
+    } else {
+      if (broadcast) (_b = busRef.current) == null ? void 0 : _b.post({ type: "logout" });
+      if (cleanupRef.current) {
+        console.log("[Callix Dialer] 📴 Logout: Chamando goOffline()...");
+        cleanupRef.current.goOffline();
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        console.log("[Callix Dialer] 🛑 Logout: Chamando stop()...");
+        cleanupRef.current.stop();
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+      if (currentUsername) releaseLeader(currentUsername, tabIdRef.current);
     }
-    setUsername(presetUsername ?? null);
     setIsAuthenticated(false);
     setSessionToken(null);
     setCallixDomain(null);
     setError(null);
-    autoLoginAttemptedRef.current = true;
-    lastPresetRef.current = presetUsername ?? null;
+    if (keepDecision) {
+      setTabRole("member");
+      if (currentUsername) saveTabRole(currentUsername, "member");
+      return;
+    }
+    setTabRole(null);
+    clearTabRole();
+    setUsername(presetUsername ?? null);
     if (typeof window !== "undefined" && currentUsername) {
       try {
         const STORAGE_KEYS = getStorageKeys(currentUsername);
@@ -60130,14 +61666,53 @@ function DialerWrapper({ options, containerEl }) {
         console.warn("[Callix Dialer] Não foi possível limpar sessão:", err);
       }
     }
-  }, [username, presetUsername]);
-  const pendingAutoLogin = autoLogin && Boolean(username) && !isAuthenticated && !error2 && !autoLoginAttemptedRef.current;
+  }, [username, presetUsername, options.engineUrl, cancelTakeover]);
+  useEffect(() => {
+    handleLogoutRef.current = handleLogout;
+  }, [handleLogout]);
+  const handleTakeOver = useCallback(async () => {
+    const user = username;
+    const bus = busRef.current;
+    if (!user || !bus) return;
+    setIsLoading(true);
+    setError(null);
+    setLoginStatus("Trazendo o discador para esta aba...");
+    bus.post({ type: "takeover" });
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+    const current = readLeader(user);
+    if (current && current.tabId !== tabIdRef.current) {
+      console.log("[Callix Dialer] a outra aba não soltou a conexão; continuando como membro");
+      setIsLoading(false);
+      setLoginStatus(null);
+      return;
+    }
+    await handleLoginRef.current(user);
+  }, [username]);
+  const handleLogoutAll = useCallback(() => {
+    void handleLogoutRef.current();
+  }, []);
+  const handleSdkSessionDropped = useCallback(
+    (originator, notice) => {
+      var _a2;
+      const user = username;
+      if (user) releaseLeader(user, tabIdRef.current);
+      (_a2 = busRef.current) == null ? void 0 : _a2.post({ type: "dropped", originator });
+      setTabRole(null);
+      clearTabRole();
+      setError(`${notice.title}: ${notice.detail}${notice.action ? ` ${notice.action}` : ""}`);
+      setIsAuthenticated(false);
+      setSessionToken(null);
+      setCallixDomain(null);
+    },
+    [username]
+  );
+  const deciding = Boolean(username) && !isAuthenticated && (engineMode ? engineWaiting : !tabDecided);
   const loginConfirmation = useMemo(() => {
-    if (isAuthenticated || isLoading || isRestoringSession || isDisconnecting || !username || pendingAutoLogin) {
+    if (isAuthenticated || isLoading || isRestoringSession || isDisconnecting || !username || deciding) {
       return null;
     }
-    return { username, locked: Boolean(presetUsername) };
-  }, [isAuthenticated, isLoading, isRestoringSession, isDisconnecting, username, presetUsername, pendingAutoLogin]);
+    return { username, locked: Boolean(presetUsername), elsewhere: !engineMode && tabRole === "member", note: tabNote };
+  }, [isAuthenticated, isLoading, isRestoringSession, isDisconnecting, username, presetUsername, deciding, engineMode, tabRole, tabNote]);
   const handleCancelLoginConfirmation = useCallback(() => {
     setUsername(null);
     setError(null);
@@ -60169,7 +61744,7 @@ function DialerWrapper({ options, containerEl }) {
       }
     ) });
   }
-  if (!isAuthenticated || !sessionToken || !callixDomain) {
+  if (!isAuthenticated || !engineMode && (!sessionToken || !callixDomain)) {
     return /* @__PURE__ */ jsxRuntimeExports.jsx(DialerConfigContext.Provider, { value: { skipManualQualification }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
       DialerComponent,
       {
@@ -60177,11 +61752,13 @@ function DialerWrapper({ options, containerEl }) {
         username,
         onLogin: handleLogin,
         onLogout: handleLogout,
-        isLoadingSession: isLoading || isRestoringSession || pendingAutoLogin,
+        isLoadingSession: isLoading || isRestoringSession || deciding,
         sessionError: error2,
         sessionStatus: loginStatus,
         loginConfirmation,
         onCancelLoginConfirmation: handleCancelLoginConfirmation,
+        onTakeOverSession: handleTakeOver,
+        onLogoutAllTabs: handleLogoutAll,
         variant: uiVariant,
         portalTarget,
         density: options.density,
@@ -60189,12 +61766,44 @@ function DialerWrapper({ options, containerEl }) {
       }
     ) });
   }
+  if (engineMode && engineRef.current) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(DialerConfigContext.Provider, { value: { skipManualQualification }, children: /* @__PURE__ */ jsxRuntimeExports.jsxs(EngineClientProvider, { client: engineRef.current, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        DialerComponent,
+        {
+          isAuthenticated,
+          username,
+          onLogin: handleLogin,
+          onLogout: handleLogout,
+          isLoadingSession: isLoading,
+          sessionError: error2,
+          sessionStatus: loginStatus,
+          variant: uiVariant,
+          portalTarget,
+          density: options.density,
+          mode: dialerMode
+        }
+      ),
+      sessionToken && /* @__PURE__ */ jsxRuntimeExports.jsx(
+        ClickToCallAgent,
+        {
+          enabled: clickToCall.enabled,
+          pollIntervalMs: clickToCall.pollIntervalMs,
+          sessionToken,
+          onTask: clickToCall.onTask
+        }
+      )
+    ] }, providerKey) });
+  }
+  if (!sessionToken || !callixDomain) {
+    return null;
+  }
   return /* @__PURE__ */ jsxRuntimeExports.jsx(DialerConfigContext.Provider, { value: { skipManualQualification }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
     clientSdkReactExports.CallixClientProvider,
     {
       domain: callixDomain,
       userSessionToken: sessionToken,
-      children: /* @__PURE__ */ jsxRuntimeExports.jsxs(SdkCleanupManager, { ref: cleanupRef, children: [
+      children: /* @__PURE__ */ jsxRuntimeExports.jsxs(SdkCleanupManager, { ref: cleanupRef, onSessionDropped: handleSdkSessionDropped, children: [
         /* @__PURE__ */ jsxRuntimeExports.jsx(
           DialerComponent,
           {