@foisit/react-wrapper 2.1.1 → 2.4.1

package/index.mjs

@@ -0,0 +1,1421 @@
+import { jsx as k } from "react/jsx-runtime";
+import { createContext as F, useState as R, useEffect as P, useContext as N } from "react";
+const W = {};
+function J() {
+  return /* @__PURE__ */ k("div", { className: W.container, children: /* @__PURE__ */ k("h1", { children: "Welcome to ReactWrapper!" }) });
+}
+class M {
+  constructor(t) {
+    this.endpoint = t || "https://foisit-ninja.netlify.app/.netlify/functions/intent";
+  }
+  async determineIntent(t, e, i) {
+    try {
+      const s = {
+        userInput: t,
+        commands: e.map((r) => ({
+          id: r.id,
+          command: r.command,
+          description: r.description,
+          parameters: r.parameters
+          // Send param schemas to AI
+        })),
+        context: i
+      }, n = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(s)
+      });
+      if (!n.ok)
+        throw new Error(`Proxy API Error: ${n.statusText}`);
+      return await n.json();
+    } catch (s) {
+      return console.error("OpenAIService Error:", s), { type: "unknown" };
+    }
+  }
+}
+class B {
+  constructor(t = !0) {
+    if (this.commands = /* @__PURE__ */ new Map(), this.openAIService = null, this.context = null, this.pendingConfirmation = null, this.enableSmartIntent = !0, this.selectOptionsCache = /* @__PURE__ */ new Map(), typeof t == "boolean") {
+      this.enableSmartIntent = t, this.enableSmartIntent && (this.openAIService = new M());
+      return;
+    }
+    this.enableSmartIntent = t.enableSmartIntent ?? !0, this.enableSmartIntent && (this.openAIService = new M(t.intentEndpoint));
+  }
+  /** Add a new command (string or object) */
+  addCommand(t, e) {
+    let i;
+    if (typeof t == "string") {
+      if (!e)
+        throw new Error("Action required when adding command by string.");
+      i = {
+        id: t.toLowerCase().replace(/\s+/g, "_"),
+        command: t.toLowerCase(),
+        action: e
+      };
+    } else
+      i = { ...t }, i.id || (i.id = i.command.toLowerCase().replace(/\s+/g, "_"));
+    this.commands.set(i.command.toLowerCase(), i), i.id && (i.id, i.command);
+  }
+  /** Remove an existing command */
+  removeCommand(t) {
+    this.commands.delete(t.toLowerCase());
+  }
+  /** Execute a command by matching input */
+  async executeCommand(t) {
+    if (typeof t == "object" && t !== null) {
+      if (this.isStructured(t)) {
+        const c = String(t.commandId), f = t.params ?? {}, o = this.getCommandById(c);
+        if (!o) return { message: "That command is not available.", type: "error" };
+        const p = this.sanitizeParamsForCommand(o, f), h = (o.parameters ?? []).filter((C) => C.required).filter((C) => p[C.name] == null || p[C.name] === "");
+        return h.length > 0 ? (this.context = { commandId: this.getCommandIdentifier(o), params: p }, {
+          message: `Please provide the required details for "${o.command}".`,
+          type: "form",
+          fields: h
+        }) : o.critical ? (this.pendingConfirmation = { commandId: this.getCommandIdentifier(o), params: p }, this.buildConfirmResponse(o)) : this.safeRunAction(o, p);
+      }
+      if (!this.context)
+        return { message: "Session expired or invalid context.", type: "error" };
+      const n = this.getCommandById(this.context.commandId);
+      if (!n)
+        return this.context = null, { message: "Session expired or invalid context.", type: "error" };
+      if (Array.isArray(t))
+        return { message: "Invalid form payload.", type: "error" };
+      const a = {
+        ...this.context.params,
+        ...t
+      };
+      if (n.critical)
+        return this.context = null, this.pendingConfirmation = {
+          commandId: this.getCommandIdentifier(n),
+          params: a
+        }, this.buildConfirmResponse(n);
+      const r = await this.safeRunAction(n, a);
+      return this.context = null, this.normalizeResponse(r);
+    }
+    const e = t.trim().toLowerCase();
+    if (this.pendingConfirmation) {
+      const n = e;
+      if (["yes", "y", "confirm", "ok", "okay"].includes(n)) {
+        const { commandId: a, params: r } = this.pendingConfirmation;
+        this.pendingConfirmation = null;
+        const c = this.getCommandById(a);
+        return c ? this.safeRunAction(c, r) : { message: "That action is no longer available.", type: "error" };
+      }
+      return ["no", "n", "cancel", "stop"].includes(n) ? (this.pendingConfirmation = null, { message: "✅ Cancelled.", type: "success" }) : {
+        message: "Please confirm: Yes or No.",
+        type: "confirm",
+        options: [
+          { label: "Yes", value: "yes" },
+          { label: "No", value: "no" }
+        ]
+      };
+    }
+    const i = this.commands.get(e);
+    if (i) {
+      const n = i, a = (n.parameters ?? []).filter((r) => r.required);
+      return a.length > 0 ? (this.context = { commandId: this.getCommandIdentifier(n), params: {} }, {
+        message: `Please provide the required details for "${n.command}".`,
+        type: "form",
+        fields: a
+      }) : n.critical ? (this.pendingConfirmation = { commandId: this.getCommandIdentifier(n), params: {} }, this.buildConfirmResponse(n)) : this.safeRunAction(n, {});
+    }
+    const s = await this.tryDeterministicMatch(e);
+    if (s) return s;
+    if (this.enableSmartIntent && this.openAIService) {
+      const n = await this.getCommandsForAI(), a = await this.openAIService.determineIntent(
+        e,
+        n,
+        this.context
+      );
+      return this.handleAIResult(a);
+    }
+    return this.enableSmartIntent ? this.listAllCommands() : { message: "I'm not sure what you mean.", type: "error" };
+  }
+  async handleAIResult(t) {
+    if (t.type === "match" && t.match) {
+      const e = this.getCommandById(t.match);
+      if (!e)
+        return { message: "I'm not sure what you mean.", type: "error" };
+      const i = t.params ?? {}, s = this.sanitizeParamsForCommand(e, i), a = (e.parameters ?? []).filter((c) => c.required).filter((c) => s[c.name] == null || s[c.name] === "");
+      if (t.incomplete || a.length > 0) {
+        this.context = { commandId: this.getCommandIdentifier(e), params: s };
+        const c = a.some((f) => f.type === "select");
+        if (a.length <= 2 && !c) {
+          const f = a.map((o) => o.name).join(" and ");
+          return {
+            message: t.message || `Please provide ${f}.`,
+            type: "question"
+          };
+        }
+        return {
+          message: t.message || `Please fill in the missing details for "${e.command}".`,
+          type: "form",
+          fields: a
+        };
+      }
+      if (e.critical)
+        return this.pendingConfirmation = {
+          commandId: this.getCommandIdentifier(e),
+          params: s
+        }, this.buildConfirmResponse(e);
+      const r = await e.action(s);
+      return this.normalizeResponse(r);
+    }
+    return t.type === "ambiguous" && t.options && t.options.length ? {
+      message: t.message || "Did you mean one of these?",
+      type: "ambiguous",
+      options: t.options.map((e) => ({
+        label: e.label,
+        value: e.commandId ?? e.label,
+        commandId: e.commandId
+      }))
+    } : this.listAllCommands();
+  }
+  sanitizeParamsForCommand(t, e) {
+    const i = { ...e ?? {} };
+    for (const s of t.parameters ?? [])
+      if (s.type === "date") {
+        const n = i[s.name];
+        if (typeof n == "string") {
+          const a = n.trim();
+          this.isIsoDateString(a) || delete i[s.name];
+        }
+      }
+    return i;
+  }
+  isIsoDateString(t) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(t)) return !1;
+    const e = /* @__PURE__ */ new Date(`${t}T00:00:00Z`);
+    return !Number.isNaN(e.getTime());
+  }
+  buildConfirmResponse(t) {
+    return {
+      message: `⚠️ Are you sure you want to run "${t.command}"?`,
+      type: "confirm",
+      options: [
+        { label: "Yes", value: "yes" },
+        { label: "No", value: "no" }
+      ]
+    };
+  }
+  async tryDeterministicMatch(t) {
+    const e = [];
+    for (const r of this.commands.values()) {
+      let c = 0;
+      const f = r.command.toLowerCase();
+      t.includes(f) && (c += 5);
+      const o = r.keywords ?? [];
+      for (const p of o) {
+        const b = p.toLowerCase().trim();
+        b && (t === b ? c += 4 : t.includes(b) && (c += 3));
+      }
+      c > 0 && e.push({ cmd: r, score: c });
+    }
+    if (e.length === 0) return null;
+    e.sort((r, c) => c.score - r.score);
+    const i = e[0].score, s = e.filter((r) => r.score === i).slice(0, 3);
+    if (s.length > 1)
+      return {
+        message: "I think you mean one of these. Which one should I run?",
+        type: "ambiguous",
+        options: s.map((r) => ({
+          label: r.cmd.command,
+          value: r.cmd.command,
+          commandId: r.cmd.id
+        }))
+      };
+    const n = s[0].cmd, a = (n.parameters ?? []).filter((r) => r.required);
+    return a.length > 0 ? (this.context = { commandId: this.getCommandIdentifier(n), params: {} }, {
+      message: `Please provide the required details for "${n.command}".`,
+      type: "form",
+      fields: a
+    }) : n.critical ? (this.pendingConfirmation = { commandId: this.getCommandIdentifier(n), params: {} }, this.buildConfirmResponse(n)) : this.safeRunAction(n, {});
+  }
+  async safeRunAction(t, e) {
+    try {
+      const i = await t.action(e ?? {});
+      return this.normalizeResponse(i);
+    } catch {
+      return { message: "Something went wrong while running that command.", type: "error" };
+    }
+  }
+  async getCommandsForAI() {
+    const t = Array.from(this.commands.values()).map((e) => ({
+      ...e,
+      parameters: e.parameters ? e.parameters.map((i) => ({ ...i })) : void 0
+    }));
+    return await Promise.all(
+      t.map(async (e) => {
+        e.parameters && await Promise.all(
+          e.parameters.map(async (i) => {
+            if (i.type !== "select" || !i.getOptions || i.options && i.options.length) return;
+            const s = `${e.id ?? e.command}:${i.name}`, n = this.selectOptionsCache.get(s), a = Date.now();
+            if (n && a - n.ts < 6e4) {
+              i.options = n.options;
+              return;
+            }
+            try {
+              const r = await i.getOptions();
+              this.selectOptionsCache.set(s, { options: r, ts: a }), i.options = r;
+            } catch {
+            }
+          })
+        );
+      })
+    ), t;
+  }
+  getCommandById(t) {
+    for (const e of this.commands.values())
+      if (e.id === t) return e;
+  }
+  listAllCommands() {
+    return {
+      message: "Here are the available commands:",
+      type: "ambiguous",
+      options: Array.from(this.commands.values()).map((e) => ({
+        label: e.command,
+        value: e.id ?? e.command,
+        commandId: e.id ?? e.command
+      }))
+    };
+  }
+  normalizeResponse(t) {
+    return typeof t == "string" ? { message: t, type: "success" } : t && typeof t == "object" ? t : { message: "Done", type: "success" };
+  }
+  isStructured(t) {
+    return typeof t.commandId == "string";
+  }
+  getCommandIdentifier(t) {
+    return t.id || (t.id = t.command.toLowerCase().replace(/\s+/g, "_")), t.id;
+  }
+  /** List all registered commands */
+  getCommands() {
+    return Array.from(this.commands.keys());
+  }
+}
+class H {
+  constructor() {
+    this.synth = window.speechSynthesis;
+  }
+  speak(t, e) {
+    if (!this.synth) {
+      console.error("SpeechSynthesis API is not supported in this browser.");
+      return;
+    }
+    const i = new SpeechSynthesisUtterance(t);
+    e && (i.pitch = e.pitch || 1, i.rate = e.rate || 1, i.volume = e.volume || 1), i.onstart = () => {
+      window.dispatchEvent(new CustomEvent("foisit:tts-start"));
+    }, i.onend = () => {
+      console.log("Speech finished."), window.dispatchEvent(new CustomEvent("foisit:tts-end"));
+    }, i.onerror = (s) => {
+      console.error("Error during speech synthesis:", s.error);
+    }, this.synth.speak(i);
+  }
+  stopSpeaking() {
+    this.synth && this.synth.cancel();
+  }
+}
+class O {
+  constructor() {
+    this.fallbackMessage = "Sorry, I didn’t understand that.";
+  }
+  setFallbackMessage(t) {
+    this.fallbackMessage = t;
+  }
+  handleFallback(t) {
+    t && console.log(`Fallback triggered for: "${t}"`), console.log(this.fallbackMessage), new H().speak(this.fallbackMessage);
+  }
+  getFallbackMessage() {
+    return this.fallbackMessage;
+  }
+}
+const T = () => {
+  const d = window;
+  return d.SpeechRecognition ?? d.webkitSpeechRecognition ?? null;
+};
+class z {
+  constructor(t = "en-US", e = {}) {
+    this.recognition = null, this.isListening = !1, this.engineActive = !1, this.intentionallyStopped = !1, this.restartAllowed = !0, this.lastStart = 0, this.backoffMs = 250, this.destroyed = !1, this.resultCallback = null, this.ttsSpeaking = !1, this.debugEnabled = !0, this.restartTimer = null, this.prewarmed = !1, this.hadResultThisSession = !1, this.onTTSStart = () => {
+      var s;
+      this.ttsSpeaking = !0;
+      try {
+        (s = this.recognition) == null || s.stop();
+      } catch {
+      }
+      this.isListening && this.emitStatus("speaking");
+    }, this.onTTSEnd = () => {
+      this.ttsSpeaking = !1, this.isListening && this.restartAllowed ? this.safeRestart() : this.emitStatus(this.isListening ? "listening" : "idle");
+    };
+    const i = T();
+    if (i) {
+      this.recognition = new i(), this.recognition.lang = t, this.recognition.interimResults = e.interimResults ?? !0, this.recognition.continuous = e.continuous ?? !0, this.recognition.onresult = (n) => this.handleResult(n, e), this.recognition.onend = () => this.handleEnd(), this.recognition.onstart = () => {
+        this.log("recognition onstart"), this.engineActive = !0, this.hadResultThisSession = !1, this.restartTimer && (clearTimeout(this.restartTimer), this.restartTimer = null), this.backoffMs = 250, this.isListening && !this.ttsSpeaking && this.emitStatus("listening");
+      };
+      const s = this.recognition;
+      s.onaudiostart = () => this.log("onaudiostart"), s.onsoundstart = () => this.log("onsoundstart"), s.onspeechstart = () => this.log("onspeechstart"), s.onspeechend = () => this.log("onspeechend"), s.onsoundend = () => this.log("onsoundend"), s.onaudioend = () => this.log("onaudioend"), this.recognition.onerror = (n) => this.handleError(n);
+    } else
+      this.recognition = null, this.emitStatus("unsupported");
+    window.addEventListener("foisit:tts-start", this.onTTSStart), window.addEventListener("foisit:tts-end", this.onTTSEnd), this.visibilityHandler = () => {
+      var s;
+      if (document.hidden) {
+        try {
+          (s = this.recognition) == null || s.stop();
+        } catch {
+        }
+        this.emitStatus(this.ttsSpeaking ? "speaking" : "idle");
+      } else this.isListening && !this.ttsSpeaking && this.safeRestart();
+    }, document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  // Debug logger helpers
+  log(t) {
+    this.debugEnabled && t && console.log("[VoiceProcessor]", t);
+  }
+  warn(t) {
+    this.debugEnabled && t && console.warn("[VoiceProcessor]", t);
+  }
+  error(t) {
+    this.debugEnabled && t && console.error("[VoiceProcessor]", t);
+  }
+  /** Check if SpeechRecognition is available */
+  isSupported() {
+    return T() !== null;
+  }
+  /** Allow consumers (wrappers) to observe status changes */
+  onStatusChange(t) {
+    this.statusCallback = t;
+  }
+  /** Start listening for speech input */
+  startListening(t) {
+    if (!this.isSupported() || !this.recognition) {
+      this.warn("VoiceProcessor: SpeechRecognition is not supported in this browser."), this.emitStatus("unsupported");
+      return;
+    }
+    if (this.isListening) {
+      this.warn("VoiceProcessor: Already listening."), this.resultCallback = t;
+      return;
+    }
+    this.resultCallback = t, this.intentionallyStopped = !1, this.restartAllowed = !0, this.isListening = !0, this.emitStatus("listening"), this.prewarmAudio().finally(() => {
+      this.safeRestart();
+    });
+  }
+  /** Stop listening for speech input */
+  stopListening() {
+    var t;
+    this.intentionallyStopped = !0, this.restartAllowed = !1, this.isListening = !1, this.emitStatus(this.ttsSpeaking ? "speaking" : "idle");
+    try {
+      (t = this.recognition) == null || t.stop();
+    } catch {
+    }
+  }
+  /** Clean up listeners */
+  destroy() {
+    this.destroyed = !0, this.stopListening(), this.resultCallback = null, window.removeEventListener("foisit:tts-start", this.onTTSStart), window.removeEventListener("foisit:tts-end", this.onTTSEnd), this.visibilityHandler && (document.removeEventListener("visibilitychange", this.visibilityHandler), this.visibilityHandler = void 0);
+  }
+  /** Handle recognized speech results */
+  handleResult(t, e) {
+    var s, n;
+    if (!this.resultCallback) return;
+    const i = e.confidenceThreshold ?? 0.6;
+    for (let a = t.resultIndex; a < t.results.length; a++) {
+      const r = t.results[a], c = r && r[0], f = ((n = (s = c == null ? void 0 : c.transcript) == null ? void 0 : s.trim) == null ? void 0 : n.call(s)) || "", o = (c == null ? void 0 : c.confidence) ?? 0;
+      if (f && !(!r.isFinal && e.interimResults === !1) && !(r.isFinal && o < i))
+        try {
+          this.hadResultThisSession = !0, this.resultCallback(f, !!r.isFinal);
+        } catch {
+          this.error("VoiceProcessor: result callback error");
+        }
+    }
+  }
+  /** Handle session end */
+  handleEnd() {
+    if (this.log("recognition onend"), this.engineActive = !1, this.destroyed || this.intentionallyStopped || !this.restartAllowed || this.ttsSpeaking) {
+      this.ttsSpeaking || (this.isListening = !1, this.emitStatus("idle"));
+      return;
+    }
+    this.isListening = !0, this.scheduleRestart();
+  }
+  /** Handle errors during speech recognition */
+  handleError(t) {
+    const e = t == null ? void 0 : t.error;
+    if (this.warn(`Error occurred: ${e ?? "unknown"}`), e && ["not-allowed", "service-not-allowed", "bad-grammar", "language-not-supported"].includes(e)) {
+      this.intentionallyStopped = !0, this.restartAllowed = !1, this.isListening = !1, this.emitStatus("error", { error: e });
+      return;
+    }
+    this.scheduleRestart();
+  }
+  safeRestart() {
+    if (!this.recognition) return;
+    if (this.engineActive) {
+      this.log("safeRestart: engine already active, skipping start");
+      return;
+    }
+    const t = Date.now();
+    if (t - this.lastStart < 300) {
+      setTimeout(() => this.safeRestart(), 300);
+      return;
+    }
+    this.lastStart = t;
+    try {
+      this.log("calling recognition.start()"), this.recognition.start(), this.backoffMs = 250, this.isListening && !this.ttsSpeaking && this.emitStatus("listening");
+    } catch {
+      this.error("recognition.start() threw; scheduling restart"), this.scheduleRestart();
+    }
+  }
+  scheduleRestart() {
+    if (this.destroyed || this.intentionallyStopped || !this.restartAllowed || this.ttsSpeaking) return;
+    if (this.engineActive) {
+      this.log("scheduleRestart: engine active, not scheduling");
+      return;
+    }
+    const t = Math.min(this.backoffMs, 2e3);
+    if (this.log(`scheduleRestart in ${t}ms`), this.restartTimer) {
+      this.log("scheduleRestart: restart already scheduled");
+      return;
+    }
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null, !(this.destroyed || this.intentionallyStopped || !this.restartAllowed || this.ttsSpeaking) && this.safeRestart();
+    }, t), this.backoffMs = Math.min(this.backoffMs * 2, 2e3);
+  }
+  async prewarmAudio() {
+    if (!this.prewarmed)
+      try {
+        if (typeof navigator > "u" || !("mediaDevices" in navigator)) return;
+        const t = navigator.mediaDevices;
+        if (!(t != null && t.getUserMedia)) return;
+        this.log("prewarmAudio: requesting mic");
+        const e = await t.getUserMedia({ audio: !0 });
+        for (const i of e.getTracks()) i.stop();
+        this.prewarmed = !0, this.log("prewarmAudio: mic ready");
+      } catch {
+        this.warn("prewarmAudio: failed to get mic");
+      }
+  }
+  emitStatus(t, e) {
+    if (this.statusCallback)
+      try {
+        this.statusCallback(t, e);
+      } catch {
+        this.error("VoiceProcessor: status callback error");
+      }
+  }
+}
+class $ {
+  constructor() {
+    this.lastTap = 0;
+  }
+  /**
+   * Sets up double-click and double-tap listeners
+   * @param onDoubleClickOrTap Callback to execute when a double-click or double-tap is detected
+   */
+  setupDoubleTapListener(t) {
+    this.destroy(), this.dblClickListener = () => {
+      t();
+    }, document.addEventListener("dblclick", this.dblClickListener), this.touchEndListener = () => {
+      const e = (/* @__PURE__ */ new Date()).getTime(), i = e - this.lastTap;
+      i < 300 && i > 0 && t(), this.lastTap = e;
+    }, document.addEventListener("touchend", this.touchEndListener);
+  }
+  destroy() {
+    this.dblClickListener && document.removeEventListener("dblclick", this.dblClickListener), this.touchEndListener && document.removeEventListener("touchend", this.touchEndListener), this.dblClickListener = void 0, this.touchEndListener = void 0;
+  }
+}
+function D() {
+  if (document.querySelector("#assistant-styles")) {
+    console.log("Styles already injected");
+    return;
+  }
+  const t = document.createElement("style");
+  t.id = "assistant-styles", t.innerHTML = `
+    /* Rounded shape with gradient animation */
+    .gradient-indicator {
+      position: fixed;
+      top: 20px;
+      right: 20px;
+      width: 60px;
+      height: 60px;
+      border-radius: 50%;
+      background: linear-gradient(135deg, #ff6ec4, #7873f5, #5e8cff, #6ed0f6);
+      box-shadow: 0 0 15px rgba(0, 0, 0, 0.2);
+      animation: amoeba 5s infinite ease-in-out;
+      z-index: 9999; /* Ensure it's above all other elements */
+    }
+
+    /* Amoeba effect for the borders */
+    @keyframes amoeba {
+      0% {
+        border-radius: 50%;
+      }
+      25% {
+        border-radius: 40% 60% 60% 40%;
+      }
+      50% {
+        border-radius: 60% 40% 40% 60%;
+      }
+      75% {
+        border-radius: 40% 60% 60% 40%;
+      }
+      100% {
+        border-radius: 50%;
+      }
+    }
+  `, document.head.appendChild(t), console.log("Gradient styles injected");
+}
+function j() {
+  if (document.querySelector("#gradient-indicator"))
+    return;
+  const d = document.createElement("div");
+  d.id = "gradient-indicator", D(), d.classList.add("gradient-indicator"), document.body.appendChild(d), console.log("Gradient indicator added to the DOM");
+}
+function U() {
+  const d = document.querySelector("#gradient-indicator");
+  d && (d.remove(), console.log("Gradient indicator removed from the DOM"));
+}
+class V {
+  constructor() {
+    this.state = "idle", this.subscribers = [];
+  }
+  getState() {
+    return this.state;
+  }
+  setState(t) {
+    this.state = t, this.notifySubscribers(), console.log("State updated:", t), t === "listening" ? j() : U();
+  }
+  // eslint-disable-next-line no-unused-vars
+  subscribe(t) {
+    this.subscribers.push(t);
+  }
+  notifySubscribers() {
+    this.subscribers.forEach((t) => t(this.state));
+  }
+}
+class G {
+  constructor(t) {
+    this.container = null, this.chatWindow = null, this.messagesContainer = null, this.input = null, this.isOpen = !1, this.loadingEl = null, this.config = t, this.init();
+  }
+  init() {
+    var e, i;
+    if (this.container) return;
+    this.injectOverlayStyles();
+    const t = document.getElementById("foisit-overlay-container");
+    if (t && t instanceof HTMLElement) {
+      this.container = t, this.chatWindow = t.querySelector(".foisit-chat"), this.messagesContainer = t.querySelector(".foisit-messages"), this.input = t.querySelector("input.foisit-input"), ((e = this.config.floatingButton) == null ? void 0 : e.visible) !== !1 && !t.querySelector(".foisit-floating-btn") && this.renderFloatingButton(), this.chatWindow || this.renderChatWindow();
+      return;
+    }
+    this.container = document.createElement("div"), this.container.id = "foisit-overlay-container", this.container.className = "foisit-overlay-container", document.body.appendChild(this.container), ((i = this.config.floatingButton) == null ? void 0 : i.visible) !== !1 && this.renderFloatingButton(), this.renderChatWindow();
+  }
+  renderFloatingButton() {
+    var s, n, a, r, c, f;
+    const t = document.createElement("button");
+    t.innerHTML = ((s = this.config.floatingButton) == null ? void 0 : s.customHtml) || "🎙️";
+    const e = ((a = (n = this.config.floatingButton) == null ? void 0 : n.position) == null ? void 0 : a.bottom) || "20px", i = ((c = (r = this.config.floatingButton) == null ? void 0 : r.position) == null ? void 0 : c.right) || "20px";
+    t.className = "foisit-floating-btn", t.style.bottom = e, t.style.right = i, t.onclick = () => this.toggle(), t.onmouseenter = () => t.style.transform = "scale(1.05)", t.onmouseleave = () => t.style.transform = "scale(1)", (f = this.container) == null || f.appendChild(t);
+  }
+  renderChatWindow() {
+    var n;
+    if (this.chatWindow) return;
+    this.chatWindow = document.createElement("div"), this.chatWindow.className = "foisit-chat";
+    const t = document.createElement("div");
+    t.className = "foisit-header";
+    const e = document.createElement("span");
+    e.className = "foisit-title", e.textContent = "Foisit";
+    const i = document.createElement("button");
+    i.type = "button", i.className = "foisit-close", i.setAttribute("aria-label", "Close"), i.innerHTML = "&times;", i.addEventListener("click", () => this.toggle()), t.appendChild(e), t.appendChild(i), this.messagesContainer = document.createElement("div"), this.messagesContainer.className = "foisit-messages";
+    const s = document.createElement("div");
+    s.className = "foisit-input-area", this.input = document.createElement("input"), this.input.placeholder = this.config.inputPlaceholder || "Type a command...", this.input.className = "foisit-input", this.input.addEventListener("keydown", (a) => {
+      var r;
+      if (a.key === "Enter" && ((r = this.input) != null && r.value.trim())) {
+        const c = this.input.value.trim();
+        this.input.value = "", this.onSubmit && this.onSubmit(c);
+      }
+    }), s.appendChild(this.input), this.chatWindow.appendChild(t), this.chatWindow.appendChild(this.messagesContainer), this.chatWindow.appendChild(s), (n = this.container) == null || n.appendChild(this.chatWindow);
+  }
+  registerCallbacks(t, e) {
+    this.onSubmit = t, this.onClose = e;
+  }
+  toggle(t, e) {
+    t && (this.onSubmit = t), e && (this.onClose = e), this.isOpen = !this.isOpen, this.chatWindow && (this.isOpen ? (this.chatWindow.style.display = "flex", requestAnimationFrame(() => {
+      this.chatWindow && (this.chatWindow.style.opacity = "1", this.chatWindow.style.transform = "translateY(0) scale(1)");
+    }), setTimeout(() => {
+      var i;
+      return (i = this.input) == null ? void 0 : i.focus();
+    }, 100)) : (this.chatWindow.style.opacity = "0", this.chatWindow.style.transform = "translateY(20px) scale(0.95)", setTimeout(() => {
+      this.chatWindow && !this.isOpen && (this.chatWindow.style.display = "none");
+    }, 200), this.onClose && this.onClose()));
+  }
+  addMessage(t, e) {
+    if (!this.messagesContainer) return;
+    const i = document.createElement("div");
+    i.textContent = t, i.className = e === "user" ? "foisit-bubble user" : "foisit-bubble system", this.messagesContainer.appendChild(i), this.scrollToBottom();
+  }
+  addOptions(t) {
+    if (!this.messagesContainer) return;
+    const e = document.createElement("div");
+    e.className = "foisit-options-container", t.forEach((i) => {
+      const s = document.createElement("button");
+      s.textContent = i.label, s.className = "foisit-option-chip", s.setAttribute("type", "button"), s.setAttribute("aria-label", i.label);
+      const n = () => {
+        if (i.commandId) {
+          this.onSubmit && this.onSubmit({ commandId: i.commandId });
+          return;
+        }
+        const a = i && typeof i.value == "string" && i.value.trim() ? i.value : i.label;
+        this.onSubmit && this.onSubmit(a);
+      };
+      s.onclick = n, s.onkeydown = (a) => {
+        (a.key === "Enter" || a.key === " ") && (a.preventDefault(), n());
+      }, e.appendChild(s);
+    }), this.messagesContainer.appendChild(e), this.scrollToBottom();
+  }
+  addForm(t, e, i) {
+    if (!this.messagesContainer) return;
+    this.addMessage(t, "system");
+    const s = document.createElement("form");
+    s.className = "foisit-form";
+    const n = [], a = (o, p) => {
+      const b = document.createElement("div");
+      return b.className = "foisit-form-label", b.innerHTML = o + (p ? ' <span class="foisit-req-star">*</span>' : ""), b;
+    }, r = () => {
+      const o = document.createElement("div");
+      return o.className = "foisit-form-error", o.style.display = "none", o;
+    };
+    (e ?? []).forEach((o) => {
+      const p = document.createElement("div");
+      p.className = "foisit-form-group";
+      const b = o.description || o.name;
+      p.appendChild(a(b, o.required));
+      let h;
+      if (o.type === "select") {
+        const l = document.createElement("select");
+        l.className = "foisit-form-input";
+        const y = document.createElement("option");
+        y.value = "", y.textContent = "Select...", l.appendChild(y);
+        const x = (m) => {
+          (m ?? []).forEach((w) => {
+            const g = document.createElement("option");
+            g.value = String(w.value ?? w.label ?? ""), g.textContent = String(w.label ?? w.value ?? ""), l.appendChild(g);
+          });
+        };
+        if (Array.isArray(o.options) && o.options.length)
+          x(o.options);
+        else if (typeof o.getOptions == "function") {
+          const m = o.getOptions, w = document.createElement("option");
+          w.value = "", w.textContent = "Loading...", l.appendChild(w), Promise.resolve().then(() => m()).then((g) => {
+            for (; l.options.length > 1; ) l.remove(1);
+            x(g);
+          }).catch(() => {
+            for (; l.options.length > 1; ) l.remove(1);
+            const g = document.createElement("option");
+            g.value = "", g.textContent = "Error loading options", l.appendChild(g);
+          });
+        }
+        o.defaultValue != null && (l.value = String(o.defaultValue)), h = l;
+      } else if (o.type === "file") {
+        const l = o, y = document.createElement("input");
+        y.className = "foisit-form-input", y.type = "file", l.accept && Array.isArray(l.accept) && (y.accept = l.accept.join(",")), l.multiple && (y.multiple = !0), l.capture && (l.capture === !0 ? y.setAttribute("capture", "") : y.setAttribute("capture", String(l.capture))), y.addEventListener("change", async () => {
+          const x = Array.from(y.files || []), m = C;
+          if (m.style.display = "none", m.textContent = "", x.length === 0) return;
+          const w = l.maxFiles ?? (l.multiple ? 10 : 1);
+          if (x.length > w) {
+            m.textContent = `Please select at most ${w} file(s).`, m.style.display = "block";
+            return;
+          }
+          const g = l.maxSizeBytes ?? 1 / 0, u = x.reduce((v, E) => v + E.size, 0);
+          if (x.some((v) => v.size > g)) {
+            m.textContent = `One or more files exceed the maximum size of ${Math.round(g / 1024)} KB.`, m.style.display = "block";
+            return;
+          }
+          const S = l.maxTotalBytes ?? 1 / 0;
+          if (u > S) {
+            m.textContent = `Total selected files exceed the maximum of ${Math.round(S / 1024)} KB.`, m.style.display = "block";
+            return;
+          }
+          if (l.accept && Array.isArray(l.accept)) {
+            const v = l.accept;
+            if (!x.every((A) => A.type ? v.some((L) => L.startsWith(".") ? A.name.toLowerCase().endsWith(L.toLowerCase()) : A.type === L || A.type.startsWith(L.split("/")[0] + "/")) : !0)) {
+              m.textContent = "One or more files have an unsupported type.", m.style.display = "block";
+              return;
+            }
+          }
+        }), h = y;
+      } else {
+        const l = document.createElement("input");
+        l.className = "foisit-form-input", o.type === "string" && (l.placeholder = o.placeholder || "Type here..."), o.type === "number" ? (l.type = "number", typeof o.min == "number" && (l.min = String(o.min)), typeof o.max == "number" && (l.max = String(o.max)), typeof o.step == "number" && (l.step = String(o.step)), o.defaultValue != null && (l.value = String(o.defaultValue))) : o.type === "date" ? (l.type = "date", typeof o.min == "string" && (l.min = o.min), typeof o.max == "string" && (l.max = o.max), o.defaultValue != null && (l.value = String(o.defaultValue))) : (l.type = "text", o.defaultValue != null && (l.value = String(o.defaultValue))), h = l;
+      }
+      const C = r();
+      p.appendChild(h), p.appendChild(C), n.push({
+        name: o.name,
+        type: o.type,
+        el: h,
+        required: o.required
+      }), s.appendChild(p);
+    });
+    const c = document.createElement("div");
+    c.className = "foisit-form-actions";
+    const f = document.createElement("button");
+    f.type = "submit", f.textContent = "Submit", f.className = "foisit-option-chip", f.style.fontWeight = "600", c.appendChild(f), s.appendChild(c), s.onsubmit = async (o) => {
+      o.preventDefault();
+      const p = {};
+      let b = !1;
+      s.querySelectorAll(".foisit-form-error").forEach((h) => {
+        h.style.display = "none", h.textContent = "";
+      }), s.querySelectorAll(".foisit-form-input").forEach((h) => {
+        h.classList.remove("foisit-error-border");
+      });
+      for (const h of n) {
+        if (h.type === "file") {
+          const x = h.el.parentElement, m = x == null ? void 0 : x.querySelector(".foisit-form-error"), w = h.el, g = Array.from(w.files || []);
+          if (h.required && g.length === 0) {
+            b = !0, w.classList.add("foisit-error-border"), m && (m.textContent = "This file is required", m.style.display = "block");
+            continue;
+          }
+          if (g.length === 0) continue;
+          const u = (e ?? []).find((v) => v.name === h.name), S = (u == null ? void 0 : u.delivery) ?? "file";
+          if (u != null && u.maxWidth || u != null && u.maxHeight)
+            try {
+              const v = await this.getImageDimensions(g[0]);
+              if (u.maxWidth && v.width > u.maxWidth) {
+                b = !0, m && (m.textContent = `Image width must be ≤ ${u.maxWidth}px`, m.style.display = "block");
+                continue;
+              }
+              if (u.maxHeight && v.height > u.maxHeight) {
+                b = !0, m && (m.textContent = `Image height must be ≤ ${u.maxHeight}px`, m.style.display = "block");
+                continue;
+              }
+            } catch {
+            }
+          if (u != null && u.maxDurationSec)
+            try {
+              const v = await this.getMediaDuration(g[0]);
+              if (v && v > u.maxDurationSec) {
+                b = !0, m && (m.textContent = `Media duration must be ≤ ${u.maxDurationSec}s`, m.style.display = "block");
+                continue;
+              }
+            } catch {
+            }
+          if (S === "file")
+            p[h.name] = u != null && u.multiple ? g : g[0];
+          else if (S === "base64")
+            try {
+              const v = await Promise.all(g.map((E) => this.readFileAsDataURL(E)));
+              p[h.name] = u != null && u.multiple ? v : v[0];
+            } catch {
+              b = !0, m && (m.textContent = "Failed to encode file(s) to base64.", m.style.display = "block");
+              continue;
+            }
+          continue;
+        }
+        const C = (h.el.value ?? "").toString().trim(), l = h.el.parentElement, y = l == null ? void 0 : l.querySelector(".foisit-form-error");
+        if (h.required && (C == null || C === "")) {
+          b = !0, h.el.classList.add("foisit-error-border"), y && (y.textContent = "This field is required", y.style.display = "block");
+          continue;
+        }
+        if (C !== "")
+          if (h.type === "number") {
+            const x = Number(C);
+            Number.isNaN(x) || (p[h.name] = x);
+          } else
+            p[h.name] = C;
+      }
+      if (b) {
+        s.classList.add("foisit-shake"), setTimeout(() => s.classList.remove("foisit-shake"), 400);
+        return;
+      }
+      f.disabled = !0, f.style.opacity = "0.6", n.forEach((h) => {
+        h.el.disabled = !0;
+      }), i(p);
+    }, this.messagesContainer.appendChild(s), this.scrollToBottom();
+  }
+  showLoading() {
+    if (this.messagesContainer && !this.loadingEl) {
+      this.loadingEl = document.createElement("div"), this.loadingEl.className = "foisit-loading-dots foisit-bubble system";
+      for (let t = 0; t < 3; t++) {
+        const e = document.createElement("div");
+        e.className = "foisit-dot", e.style.animation = `foisitPulse 1.4s infinite ease-in-out ${t * 0.2}s`, this.loadingEl.appendChild(e);
+      }
+      this.messagesContainer.appendChild(this.loadingEl), this.scrollToBottom();
+    }
+  }
+  hideLoading() {
+    var t;
+    (t = this.loadingEl) == null || t.remove(), this.loadingEl = null;
+  }
+  scrollToBottom() {
+    this.messagesContainer && (this.messagesContainer.scrollTop = this.messagesContainer.scrollHeight);
+  }
+  destroy() {
+    var t;
+    (t = this.container) == null || t.remove(), this.container = null, this.chatWindow = null, this.messagesContainer = null, this.input = null, this.isOpen = !1;
+  }
+  readFileAsDataURL(t) {
+    return new Promise((e, i) => {
+      const s = new FileReader();
+      s.onerror = () => i(new Error("Failed to read file")), s.onload = () => e(String(s.result)), s.readAsDataURL(t);
+    });
+  }
+  getImageDimensions(t) {
+    return new Promise((e) => {
+      try {
+        const i = URL.createObjectURL(t), s = new Image();
+        s.onload = () => {
+          const n = { width: s.naturalWidth || s.width, height: s.naturalHeight || s.height };
+          URL.revokeObjectURL(i), e(n);
+        }, s.onerror = () => {
+          URL.revokeObjectURL(i), e({ width: 0, height: 0 });
+        }, s.src = i;
+      } catch {
+        e({ width: 0, height: 0 });
+      }
+    });
+  }
+  getMediaDuration(t) {
+    return new Promise((e) => {
+      try {
+        const i = URL.createObjectURL(t), s = t.type.startsWith("audio") ? document.createElement("audio") : document.createElement("video");
+        let n = !1;
+        const a = setTimeout(() => {
+          n || (n = !0, URL.revokeObjectURL(i), e(0));
+        }, 5e3);
+        s.preload = "metadata", s.onloadedmetadata = () => {
+          if (n) return;
+          n = !0, clearTimeout(a);
+          const c = s.duration || 0;
+          URL.revokeObjectURL(i), e(c);
+        }, s.onerror = () => {
+          n || (n = !0, clearTimeout(a), URL.revokeObjectURL(i), e(0));
+        }, s.src = i;
+      } catch {
+        e(0);
+      }
+    });
+  }
+  injectOverlayStyles() {
+    if (document.getElementById("foisit-overlay-styles")) return;
+    const t = document.createElement("style");
+    t.id = "foisit-overlay-styles", t.textContent = `
+      :root {
+        /* LIGHT MODE (Default) - Smoother gradient */
+        /* Changed: Softer, right-focused radial highlight to avoid a heavy white bottom */
+        --foisit-bg: radial-gradient(ellipse at 75% 30%, rgba(255, 255, 255, 0.18), rgba(255, 255, 255, 0.03));
+        --foisit-border: 1px solid rgba(255, 255, 255, 0.25);
+        --foisit-shadow: 0 12px 40px rgba(0, 0, 0, 0.15);
+        --foisit-text: #333;
+
+        /* Input */
+        --foisit-input-color: #333;
+        --foisit-input-placeholder: rgba(60, 60, 67, 0.6);
+
+        /* Bubbles */
+        --foisit-bubble-user-bg: rgba(0, 0, 0, 0.04);
+        --foisit-bubble-user-text: #333;
+
+        --foisit-bubble-sys-bg: rgba(255, 255, 255, 0.45);
+        --foisit-bubble-sys-text: #333;
+
+        /* Form Colors */
+        --foisit-req-star: #ef4444; /* Red asterisk */
+        --foisit-error-text: #dc2626;
+        --foisit-error-border: #fca5a5;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        :root {
+          /* DARK MODE */
+          --foisit-bg: linear-gradient(135deg, rgba(40, 40, 40, 0.65), rgba(40, 40, 40, 0.25));
+          --foisit-border: 1px solid rgba(255, 255, 255, 0.1);
+          --foisit-shadow: 0 16px 48px rgba(0, 0, 0, 0.5);
+          --foisit-text: #fff;
+
+          /* Input */
+          --foisit-input-color: white;
+          --foisit-input-placeholder: rgba(235, 235, 245, 0.5);
+
+          /* Bubbles */
+          --foisit-bubble-user-bg: rgba(255, 255, 255, 0.1);
+          --foisit-bubble-user-text: white;
+
+          --foisit-bubble-sys-bg: rgba(255, 255, 255, 0.05);
+          --foisit-bubble-sys-text: rgba(255, 255, 255, 0.9);
+
+          /* Form Colors */
+          --foisit-req-star: #f87171;
+          --foisit-error-text: #fca5a5;
+          --foisit-error-border: #f87171;
+        }
+      }
+
+      @keyframes foisitPulse {
+        0%, 100% { transform: scale(0.8); opacity: 0.5; }
+        50% { transform: scale(1.2); opacity: 1; }
+      }
+
+      @keyframes foisitShake {
+        0%, 100% { transform: translateX(0); }
+        25% { transform: translateX(-4px); }
+        75% { transform: translateX(4px); }
+      }
+      .foisit-shake { animation: foisitShake 0.4s ease-in-out; }
+
+      /* Container */
+      .foisit-overlay-container {
+        position: fixed;
+        inset: 0;
+        z-index: 2147483647;
+        pointer-events: none;
+        display: flex;
+        flex-direction: column;
+        justify-content: flex-end;
+        align-items: flex-end;
+        padding: 20px;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      }
+
+      .foisit-overlay-container * {
+        box-sizing: border-box;
+      }
+
+      /* Chat Window - Dynamic Height */
+      .foisit-chat {
+        position: absolute;
+        top: 20px;
+        right: 20px;
+        width: min(420px, 92vw);
+
+        /* FIX: Auto height to prevent empty space */
+        height: auto;
+        min-height: 120px;
+        max-height: 80vh;
+
+        background: var(--foisit-bg);
+        border: var(--foisit-border);
+        box-shadow: var(--foisit-shadow);
+
+        backdrop-filter: blur(20px);
+        -webkit-backdrop-filter: blur(20px);
+
+        border-radius: 18px;
+        display: none;
+        flex-direction: column;
+        overflow: hidden;
+        pointer-events: auto;
+        transform-origin: top right;
+        transition: opacity 0.2s, transform 0.2s cubic-bezier(0.2, 0.9, 0.2, 1);
+      }
+
+      .foisit-header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 12px 16px;
+        font-weight: 600;
+        font-size: 14px;
+        color: var(--foisit-text);
+        border-bottom: 1px solid rgba(127,127,127,0.08); /* Subtle separator */
+      }
+
+      .foisit-close {
+        background: transparent;
+        border: none;
+        color: var(--foisit-text);
+        opacity: 0.5;
+        font-size: 24px;
+        line-height: 1;
+        cursor: pointer;
+        padding: 0;
+        width: 28px;
+        height: 28px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: opacity 0.2s;
+      }
+      .foisit-close:hover { opacity: 1; }
+
+      /* Message Area */
+      .foisit-messages {
+        flex: 1;
+        overflow-y: auto;
+        padding: 16px;
+        display: flex;
+        flex-direction: column;
+        gap: 10px;
+        /* Ensure it doesn't get too tall initially */
+        min-height: 60px;
+      }
+
+      /* Make sure empty state isn't huge */
+      .foisit-messages:empty {
+        display: none;
+      }
+
+      /* Only show messages container if it has children */
+      .foisit-messages:not(:empty) {
+        display: flex;
+      }
+
+      /* Bubbles */
+      .foisit-bubble {
+        max-width: 90%;
+        padding: 8px 14px;
+        border-radius: 14px;
+        font-size: 14px;
+        line-height: 1.4;
+        word-wrap: break-word;
+      }
+
+      .foisit-bubble.user {
+        align-self: flex-end;
+        background: var(--foisit-bubble-user-bg);
+        color: var(--foisit-bubble-user-text);
+        border-bottom-right-radius: 4px;
+      }
+
+      .foisit-bubble.system {
+        align-self: flex-start;
+        background: var(--foisit-bubble-sys-bg);
+        color: var(--foisit-bubble-sys-text);
+        border-bottom-left-radius: 4px;
+        border: 1px solid rgba(255,255,255,0.1);
+      }
+
+      /* Input Area */
+      .foisit-input-area {
+        padding: 0;
+        width: 100%;
+        border-top: 1px solid rgba(127,127,127,0.08);
+      }
+
+      .foisit-input {
+        width: 100%;
+        background: transparent;
+        border: none;
+        font-size: 16px;
+        color: var(--foisit-input-color);
+        padding: 16px 20px;
+        outline: none;
+        text-align: left;
+      }
+
+      .foisit-input::placeholder {
+        color: var(--foisit-input-placeholder);
+        font-weight: 400;
+      }
+
+      /* Options & Buttons */
+      .foisit-options-container {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin-left: 2px;
+        margin-top: 4px;
+      }
+
+      .foisit-option-chip {
+        padding: 6px 14px;
+        background: var(--foisit-bubble-sys-bg);
+        border: 1px solid rgba(127,127,127,0.1);
+        border-radius: 20px;
+        font-size: 13px;
+        color: var(--foisit-text);
+        cursor: pointer;
+        transition: all 0.2s;
+        font-weight: 500;
+      }
+      .foisit-option-chip:hover {
+        background: rgba(127,127,127,0.15);
+      }
+
+      /* Form Styling */
+      .foisit-form {
+        background: var(--foisit-bubble-sys-bg);
+        padding: 16px;
+        border-radius: 14px;
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+        width: 100%;
+        border: 1px solid rgba(127,127,127,0.1);
+      }
+
+      .foisit-form-label {
+        font-size: 12px;
+        font-weight: 600;
+        color: var(--foisit-text);
+        opacity: 0.9;
+        margin-bottom: 2px;
+      }
+
+      .foisit-req-star {
+        color: var(--foisit-req-star);
+        font-weight: bold;
+      }
+
+      .foisit-form-input {
+        width: 100%;
+        padding: 10px;
+        border-radius: 8px;
+        border: 1px solid rgba(127,127,127,0.2);
+        background: rgba(255,255,255,0.05); /* Very subtle fill */
+        color: var(--foisit-text);
+        font-size: 14px;
+        outline: none;
+        transition: border 0.2s;
+      }
+      .foisit-form-input:focus {
+        border-color: var(--foisit-text);
+        background: rgba(255,255,255,0.1);
+      }
+
+      .foisit-error-border {
+        border-color: var(--foisit-error-border) !important;
+      }
+
+      .foisit-form-error {
+        font-size: 11px;
+        color: var(--foisit-error-text);
+        margin-top: 4px;
+      }
+
+      /* Loading */
+      .foisit-loading-dots {
+        display: inline-flex;
+        gap: 4px;
+        padding: 10px 14px;
+        align-self: flex-start;
+      }
+      .foisit-dot {
+        width: 6px;
+        height: 6px;
+        border-radius: 50%;
+        background: var(--foisit-text);
+        opacity: 0.4;
+      }
+
+      /* Floating Button */
+      .foisit-floating-btn {
+        position: absolute;
+        width: 56px;
+        height: 56px;
+        border-radius: 50%;
+        border: 1px solid rgba(255,255,255,0.2);
+        background: var(--foisit-bg);
+        color: var(--foisit-text);
+        backdrop-filter: blur(10px);
+        -webkit-backdrop-filter: blur(10px);
+        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+        cursor: pointer;
+        pointer-events: auto;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 24px;
+        z-index: 100000;
+        transition: transform 0.2s;
+      }
+      .foisit-floating-btn:hover { transform: scale(1.05); }
+    `, document.head.appendChild(t);
+  }
+}
+class Y {
+  constructor(t) {
+    this.config = t, this.isActivated = !1, this.lastProcessedInput = "", this.processingLock = !1, this.defaultIntroMessage = "How can I help you?", this.commandHandler = new B({
+      enableSmartIntent: this.config.enableSmartIntent !== !1,
+      intentEndpoint: this.config.intentEndpoint
+    }), this.fallbackHandler = new O(), this.voiceProcessor = new z(), this.textToSpeech = new H(), this.stateManager = new V(), this.gestureHandler = new $(), this.overlayManager = new G({
+      floatingButton: this.config.floatingButton,
+      inputPlaceholder: this.config.inputPlaceholder
+    }), this.config.commands.forEach((e) => this.commandHandler.addCommand(e)), this.config.fallbackResponse && this.fallbackHandler.setFallbackMessage(this.config.fallbackResponse), this.gestureHandler.setupDoubleTapListener(() => this.toggle()), this.overlayManager.registerCallbacks(
+      async (e) => {
+        if (typeof e == "string") {
+          this.overlayManager.addMessage(e, "user"), await this.handleCommand(e);
+          return;
+        }
+        if (e && typeof e == "object") {
+          const i = e, s = i.label ?? i.commandId ?? "Selection";
+          this.overlayManager.addMessage(String(s), "user"), this.overlayManager.showLoading();
+          const n = await this.commandHandler.executeCommand(i);
+          this.overlayManager.hideLoading(), this.processResponse(n);
+        }
+      },
+      () => console.log("AssistantService: Overlay closed.")
+    );
+  }
+  /** Start listening for activation and commands */
+  startListening() {
+    console.log("AssistantService: Voice is disabled; startListening() is a no-op.");
+  }
+  /** Stop listening */
+  stopListening() {
+    console.log("AssistantService: Voice is disabled; stopListening() is a no-op."), this.isActivated = !1;
+  }
+  /**
+   * Reset activation state so the next activation flow can occur.
+   * This is mainly used by the wrapper UI (e.g. AssistantActivator).
+   */
+  reactivate() {
+    console.log("AssistantService: Reactivating assistant..."), this.isActivated = !1;
+    try {
+      this.startListening();
+    } catch {
+    }
+  }
+  /** Process activation command */
+  async processActivation(t) {
+    var i;
+    const e = (i = this.config.activationCommand) == null ? void 0 : i.toLowerCase();
+    e && (t === e ? (console.log("AssistantService: Activation matched."), this.isActivated = !0, this.textToSpeech.speak(
+      this.config.introMessage || this.defaultIntroMessage
+    )) : console.log("AssistantService: Activation command not recognized."));
+  }
+  /** Handle recognized commands */
+  async handleCommand(t) {
+    this.overlayManager.showLoading();
+    let e;
+    try {
+      e = await this.commandHandler.executeCommand(t);
+    } finally {
+      this.overlayManager.hideLoading();
+    }
+    if (e.type === "form" && e.fields) {
+      this.overlayManager.addForm(
+        e.message,
+        e.fields,
+        async (i) => {
+          this.overlayManager.showLoading();
+          let s;
+          try {
+            s = await this.commandHandler.executeCommand(i);
+          } finally {
+            this.overlayManager.hideLoading();
+          }
+          this.processResponse(s);
+        }
+      );
+      return;
+    }
+    if (e.type === "error") {
+      this.fallbackHandler.handleFallback(t), this.overlayManager.addMessage(this.fallbackHandler.getFallbackMessage(), "system");
+      return;
+    }
+    e.message ? this.overlayManager.addMessage(e.message, "system") : (e.type === "ambiguous" || e.type === "confirm") && e.options && this.overlayManager.addOptions(e.options);
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.voiceProcessor.stopListening(), this.gestureHandler.destroy(), this.overlayManager.destroy();
+  }
+  /** Unified response processing */
+  processResponse(t) {
+    if (t) {
+      if (t.type === "form" && t.fields) {
+        this.overlayManager.addForm(
+          t.message,
+          t.fields,
+          async (e) => {
+            this.overlayManager.showLoading();
+            let i;
+            try {
+              i = await this.commandHandler.executeCommand(e);
+            } finally {
+              this.overlayManager.hideLoading();
+            }
+            this.processResponse(i);
+          }
+        );
+        return;
+      }
+      if ((t.type === "ambiguous" || t.type === "confirm") && t.options) {
+        t.message && this.overlayManager.addMessage(t.message, "system"), this.overlayManager.addOptions(t.options);
+        return;
+      }
+      t.message && this.overlayManager.addMessage(t.message, "system");
+    }
+  }
+  /** Add a command dynamically (supports string or rich object) */
+  addCommand(t, e) {
+    console.log(typeof t == "string" ? `AssistantService: Adding command "${t}".` : `AssistantService: Adding rich command "${t.command}".`), this.commandHandler.addCommand(t, e);
+  }
+  /** Remove a command dynamically */
+  removeCommand(t) {
+    console.log(`AssistantService: Removing command "${t}".`), this.commandHandler.removeCommand(t);
+  }
+  /** Get all registered commands */
+  getCommands() {
+    return this.commandHandler.getCommands();
+  }
+  /** Toggle the assistant overlay */
+  toggle(t, e) {
+    console.log("AssistantService: Toggling overlay..."), this.overlayManager.toggle(
+      async (i) => {
+        if (typeof i == "string") {
+          this.overlayManager.addMessage(i, "user"), t && t(i), await this.handleCommand(i);
+          return;
+        }
+        if (i && typeof i == "object") {
+          const s = i, n = s.label ?? s.commandId ?? "Selection";
+          this.overlayManager.addMessage(String(n), "user"), this.overlayManager.showLoading();
+          let a;
+          try {
+            a = await this.commandHandler.executeCommand(s);
+          } finally {
+            this.overlayManager.hideLoading();
+          }
+          this.processResponse(a);
+        }
+      },
+      () => {
+        console.log("AssistantService: Overlay closed."), e && e();
+      }
+    );
+  }
+}
+const q = F(null);
+let I = null;
+const Z = ({ config: d, children: t }) => {
+  const [e, i] = R(null), [s, n] = R(!1);
+  return P(() => {
+    I ? console.warn(
+      "Multiple AssistantProvider instances detected. Reusing global AssistantService."
+    ) : (console.log("Initializing global AssistantService..."), I = new Y(d));
+    const a = I;
+    return i(a), n(!0), () => {
+      var r;
+      console.log("Cleaning up AssistantService..."), (r = a.destroy) == null || r.call(a), I = null;
+    };
+  }, [d]), !s || !e ? /* @__PURE__ */ k("div", { children: "Loading Assistant..." }) : /* @__PURE__ */ k(q.Provider, { value: e, children: t });
+}, K = () => {
+  const d = N(q);
+  if (console.log("assistant", d), !d)
+    throw new Error("useAssistant must be used within an AssistantProvider");
+  return d;
+}, Q = ({
+  label: d = "Activate Assistant",
+  onActivate: t
+}) => {
+  const e = K();
+  return /* @__PURE__ */ k("button", { onClick: () => {
+    t && t(), e.reactivate();
+  }, className: "assistant-activator", children: d });
+}, tt = (d) => {
+  const [t, e] = R(d.getState());
+  return P(() => {
+    const i = (s) => {
+      e(s);
+    };
+    return d.subscribe(i), () => {
+      d.subscribe(() => {
+      });
+    };
+  }, [d]), t;
+};
+export {
+  Q as AssistantActivator,
+  q as AssistantContext,
+  Z as AssistantProvider,
+  Y as AssistantService,
+  J as ReactWrapper,
+  K as useAssistant,
+  tt as useAssistantState
+};