@customerhero/js 0.0.2 → 1.0.1

package/dist/index.js

@@ -10,7 +10,7 @@ var DEFAULTS = {
   title: "CustomerHero"
 };
 
-// src/i18n.ts
+// src/i18n/locales/en.ts
 var en = {
   online: "Online",
   typing: "Typing...",
@@ -22,8 +22,20 @@ var en = {
   send_message: "Send message",
   helpful: "Helpful",
   not_helpful: "Not helpful",
-  menu: "Menu"
+  menu: "Menu",
+  action_approve: "Approve",
+  action_cancel: "Cancel",
+  action_what_will_happen: "What will happen?",
+  action_already_resolved: "This action has already been resolved.",
+  action_failed: "Couldn't complete that action. Please try again.",
+  status_sending: "Sending",
+  status_sent: "Sent",
+  status_failed: "Failed to send",
+  screenshot_capture: "Capture screenshot",
+  attachment_remove: "Remove attachment"
 };
+
+// src/i18n/locales/es.ts
 var es = {
   online: "En l\xEDnea",
   typing: "Escribiendo...",
@@ -35,25 +47,471 @@ var es = {
   send_message: "Enviar mensaje",
   helpful: "\xDAtil",
   not_helpful: "No \xFAtil",
-  menu: "Men\xFA"
+  menu: "Men\xFA",
+  action_approve: "Aprobar",
+  action_cancel: "Cancelar",
+  action_what_will_happen: "\xBFQu\xE9 pasar\xE1?",
+  action_already_resolved: "Esta acci\xF3n ya se ha resuelto.",
+  action_failed: "No se pudo completar la acci\xF3n. Int\xE9ntalo de nuevo.",
+  status_sending: "Enviando",
+  status_sent: "Enviado",
+  status_failed: "Error al enviar",
+  screenshot_capture: "Capturar pantalla",
+  attachment_remove: "Quitar adjunto"
+};
+
+// src/i18n/locales/pt-BR.ts
+var ptBR = {
+  online: "Online",
+  typing: "Digitando...",
+  unable_to_load: "N\xE3o foi poss\xEDvel carregar o chat",
+  powered_by: "Desenvolvido por",
+  new_conversation: "Nova conversa",
+  open_chat: "Abrir chat",
+  close_chat: "Fechar chat",
+  send_message: "Enviar mensagem",
+  helpful: "\xDAtil",
+  not_helpful: "N\xE3o \xFAtil",
+  menu: "Menu",
+  action_approve: "Aprovar",
+  action_cancel: "Cancelar",
+  action_what_will_happen: "O que vai acontecer?",
+  action_already_resolved: "Esta a\xE7\xE3o j\xE1 foi resolvida.",
+  action_failed: "N\xE3o foi poss\xEDvel concluir a a\xE7\xE3o. Tente novamente.",
+  status_sending: "Enviando",
+  status_sent: "Enviado",
+  status_failed: "Falha no envio",
+  screenshot_capture: "Capturar tela",
+  attachment_remove: "Remover anexo"
+};
+
+// src/i18n/locales/pt-PT.ts
+var ptPT = {
+  online: "Online",
+  typing: "A escrever...",
+  unable_to_load: "N\xE3o foi poss\xEDvel carregar o chat",
+  powered_by: "Desenvolvido por",
+  new_conversation: "Nova conversa",
+  open_chat: "Abrir chat",
+  close_chat: "Fechar chat",
+  send_message: "Enviar mensagem",
+  helpful: "\xDAtil",
+  not_helpful: "N\xE3o \xFAtil",
+  menu: "Menu",
+  action_approve: "Aprovar",
+  action_cancel: "Cancelar",
+  action_what_will_happen: "O que ir\xE1 acontecer?",
+  action_already_resolved: "Esta a\xE7\xE3o j\xE1 foi resolvida.",
+  action_failed: "N\xE3o foi poss\xEDvel concluir a a\xE7\xE3o. Tente novamente.",
+  status_sending: "A enviar",
+  status_sent: "Enviada",
+  status_failed: "Falha no envio",
+  screenshot_capture: "Capturar ecr\xE3",
+  attachment_remove: "Remover anexo"
+};
+
+// src/i18n/locales/fr.ts
+var fr = {
+  online: "En ligne",
+  typing: "Saisie...",
+  unable_to_load: "Impossible de charger le chat",
+  powered_by: "Propuls\xE9 par",
+  new_conversation: "Nouvelle conversation",
+  open_chat: "Ouvrir le chat",
+  close_chat: "Fermer le chat",
+  send_message: "Envoyer le message",
+  helpful: "Utile",
+  not_helpful: "Pas utile",
+  menu: "Menu",
+  action_approve: "Approuver",
+  action_cancel: "Annuler",
+  action_what_will_happen: "Que va-t-il se passer ?",
+  action_already_resolved: "Cette action a d\xE9j\xE0 \xE9t\xE9 trait\xE9e.",
+  action_failed: "Impossible de r\xE9aliser cette action. Veuillez r\xE9essayer.",
+  status_sending: "Envoi\u2026",
+  status_sent: "Envoy\xE9",
+  status_failed: "\xC9chec de l'envoi",
+  screenshot_capture: "Capture d'\xE9cran",
+  attachment_remove: "Supprimer la pi\xE8ce jointe"
+};
+
+// src/i18n/locales/de.ts
+var de = {
+  online: "Online",
+  typing: "Schreibt...",
+  unable_to_load: "Chat konnte nicht geladen werden",
+  powered_by: "Bereitgestellt von",
+  new_conversation: "Neue Unterhaltung",
+  open_chat: "Chat \xF6ffnen",
+  close_chat: "Chat schlie\xDFen",
+  send_message: "Nachricht senden",
+  helpful: "Hilfreich",
+  not_helpful: "Nicht hilfreich",
+  menu: "Men\xFC",
+  action_approve: "Best\xE4tigen",
+  action_cancel: "Abbrechen",
+  action_what_will_happen: "Was passiert dann?",
+  action_already_resolved: "Diese Aktion wurde bereits abgeschlossen.",
+  action_failed: "Aktion konnte nicht abgeschlossen werden. Bitte erneut versuchen.",
+  status_sending: "Wird gesendet",
+  status_sent: "Gesendet",
+  status_failed: "Senden fehlgeschlagen",
+  screenshot_capture: "Bildschirmfoto erstellen",
+  attachment_remove: "Anhang entfernen"
+};
+
+// src/i18n/locales/it.ts
+var it = {
+  online: "Online",
+  typing: "Sta scrivendo...",
+  unable_to_load: "Impossibile caricare la chat",
+  powered_by: "Realizzato da",
+  new_conversation: "Nuova conversazione",
+  open_chat: "Apri chat",
+  close_chat: "Chiudi chat",
+  send_message: "Invia messaggio",
+  helpful: "Utile",
+  not_helpful: "Non utile",
+  menu: "Menu",
+  action_approve: "Approva",
+  action_cancel: "Annulla",
+  action_what_will_happen: "Cosa accadr\xE0?",
+  action_already_resolved: "Questa azione \xE8 gi\xE0 stata risolta.",
+  action_failed: "Impossibile completare l'azione. Riprova.",
+  status_sending: "Invio in corso",
+  status_sent: "Inviato",
+  status_failed: "Invio non riuscito",
+  screenshot_capture: "Cattura schermata",
+  attachment_remove: "Rimuovi allegato"
+};
+
+// src/i18n/locales/nl.ts
+var nl = {
+  online: "Online",
+  typing: "Typt...",
+  unable_to_load: "Chat kon niet worden geladen",
+  powered_by: "Mogelijk gemaakt door",
+  new_conversation: "Nieuw gesprek",
+  open_chat: "Chat openen",
+  close_chat: "Chat sluiten",
+  send_message: "Bericht verzenden",
+  helpful: "Nuttig",
+  not_helpful: "Niet nuttig",
+  menu: "Menu",
+  action_approve: "Goedkeuren",
+  action_cancel: "Annuleren",
+  action_what_will_happen: "Wat gaat er gebeuren?",
+  action_already_resolved: "Deze actie is al afgehandeld.",
+  action_failed: "Actie kon niet worden voltooid. Probeer het opnieuw.",
+  status_sending: "Verzenden",
+  status_sent: "Verzonden",
+  status_failed: "Verzenden mislukt",
+  screenshot_capture: "Schermafbeelding maken",
+  attachment_remove: "Bijlage verwijderen"
+};
+
+// src/i18n/locales/pl.ts
+var pl = {
+  online: "Online",
+  typing: "Pisze...",
+  unable_to_load: "Nie mo\u017Cna za\u0142adowa\u0107 czatu",
+  powered_by: "Dzia\u0142a dzi\u0119ki",
+  new_conversation: "Nowa rozmowa",
+  open_chat: "Otw\xF3rz czat",
+  close_chat: "Zamknij czat",
+  send_message: "Wy\u015Blij wiadomo\u015B\u0107",
+  helpful: "Pomocne",
+  not_helpful: "Niepomocne",
+  menu: "Menu",
+  action_approve: "Zatwierd\u017A",
+  action_cancel: "Anuluj",
+  action_what_will_happen: "Co si\u0119 stanie?",
+  action_already_resolved: "Ta akcja zosta\u0142a ju\u017C rozwi\u0105zana.",
+  action_failed: "Nie uda\u0142o si\u0119 wykona\u0107 akcji. Spr\xF3buj ponownie.",
+  status_sending: "Wysy\u0142anie",
+  status_sent: "Wys\u0142ano",
+  status_failed: "Nie uda\u0142o si\u0119 wys\u0142a\u0107",
+  screenshot_capture: "Zr\xF3b zrzut ekranu",
+  attachment_remove: "Usu\u0144 za\u0142\u0105cznik"
+};
+
+// src/i18n/locales/tr.ts
+var tr = {
+  online: "\xC7evrimi\xE7i",
+  typing: "Yaz\u0131yor...",
+  unable_to_load: "Sohbet y\xFCklenemedi",
+  powered_by: "Sa\u011Flayan",
+  new_conversation: "Yeni sohbet",
+  open_chat: "Sohbeti a\xE7",
+  close_chat: "Sohbeti kapat",
+  send_message: "Mesaj g\xF6nder",
+  helpful: "Yararl\u0131",
+  not_helpful: "Yararl\u0131 de\u011Fil",
+  menu: "Men\xFC",
+  action_approve: "Onayla",
+  action_cancel: "\u0130ptal",
+  action_what_will_happen: "Ne olacak?",
+  action_already_resolved: "Bu i\u015Flem zaten \xE7\xF6z\xFCld\xFC.",
+  action_failed: "\u0130\u015Flem tamamlanamad\u0131. L\xFCtfen tekrar deneyin.",
+  status_sending: "G\xF6nderiliyor",
+  status_sent: "G\xF6nderildi",
+  status_failed: "G\xF6nderilemedi",
+  screenshot_capture: "Ekran g\xF6r\xFCnt\xFCs\xFC al",
+  attachment_remove: "Eki kald\u0131r"
+};
+
+// src/i18n/locales/ar.ts
+var ar = {
+  online: "\u0645\u062A\u0635\u0644",
+  typing: "\u064A\u0643\u062A\u0628...",
+  unable_to_load: "\u062A\u0639\u0630\u0631 \u062A\u062D\u0645\u064A\u0644 \u0627\u0644\u0645\u062D\u0627\u062F\u062B\u0629",
+  powered_by: "\u0645\u062F\u0639\u0648\u0645 \u0645\u0646",
+  new_conversation: "\u0645\u062D\u0627\u062F\u062B\u0629 \u062C\u062F\u064A\u062F\u0629",
+  open_chat: "\u0641\u062A\u062D \u0627\u0644\u0645\u062D\u0627\u062F\u062B\u0629",
+  close_chat: "\u0625\u063A\u0644\u0627\u0642 \u0627\u0644\u0645\u062D\u0627\u062F\u062B\u0629",
+  send_message: "\u0625\u0631\u0633\u0627\u0644 \u0627\u0644\u0631\u0633\u0627\u0644\u0629",
+  helpful: "\u0645\u0641\u064A\u062F",
+  not_helpful: "\u063A\u064A\u0631 \u0645\u0641\u064A\u062F",
+  menu: "\u0627\u0644\u0642\u0627\u0626\u0645\u0629",
+  action_approve: "\u0645\u0648\u0627\u0641\u0642\u0629",
+  action_cancel: "\u0625\u0644\u063A\u0627\u0621",
+  action_what_will_happen: "\u0645\u0627\u0630\u0627 \u0633\u064A\u062D\u062F\u062B\u061F",
+  action_already_resolved: "\u062A\u0645 \u062D\u0644 \u0647\u0630\u0627 \u0627\u0644\u0625\u062C\u0631\u0627\u0621 \u0628\u0627\u0644\u0641\u0639\u0644.",
+  action_failed: "\u062A\u0639\u0630\u0631 \u0625\u0643\u0645\u0627\u0644 \u0627\u0644\u0625\u062C\u0631\u0627\u0621. \u064A\u0631\u062C\u0649 \u0627\u0644\u0645\u062D\u0627\u0648\u0644\u0629 \u0645\u0631\u0629 \u0623\u062E\u0631\u0649.",
+  status_sending: "\u062C\u0627\u0631\u064D \u0627\u0644\u0625\u0631\u0633\u0627\u0644",
+  status_sent: "\u062A\u0645 \u0627\u0644\u0625\u0631\u0633\u0627\u0644",
+  status_failed: "\u0641\u0634\u0644 \u0627\u0644\u0625\u0631\u0633\u0627\u0644",
+  screenshot_capture: "\u0627\u0644\u062A\u0642\u0627\u0637 \u0644\u0642\u0637\u0629 \u0634\u0627\u0634\u0629",
+  attachment_remove: "\u0625\u0632\u0627\u0644\u0629 \u0627\u0644\u0645\u0631\u0641\u0642"
+};
+
+// src/i18n/locales/ja.ts
+var ja = {
+  online: "\u30AA\u30F3\u30E9\u30A4\u30F3",
+  typing: "\u5165\u529B\u4E2D...",
+  unable_to_load: "\u30C1\u30E3\u30C3\u30C8\u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093",
+  powered_by: "\u63D0\u4F9B\uFF1A",
+  new_conversation: "\u65B0\u3057\u3044\u4F1A\u8A71",
+  open_chat: "\u30C1\u30E3\u30C3\u30C8\u3092\u958B\u304F",
+  close_chat: "\u30C1\u30E3\u30C3\u30C8\u3092\u9589\u3058\u308B",
+  send_message: "\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u9001\u4FE1",
+  helpful: "\u5F79\u306B\u7ACB\u3063\u305F",
+  not_helpful: "\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F",
+  menu: "\u30E1\u30CB\u30E5\u30FC",
+  action_approve: "\u627F\u8A8D",
+  action_cancel: "\u30AD\u30E3\u30F3\u30BB\u30EB",
+  action_what_will_happen: "\u4F55\u304C\u8D77\u3053\u308A\u307E\u3059\u304B\uFF1F",
+  action_already_resolved: "\u3053\u306E\u30A2\u30AF\u30B7\u30E7\u30F3\u306F\u65E2\u306B\u51E6\u7406\u3055\u308C\u3066\u3044\u307E\u3059\u3002",
+  action_failed: "\u30A2\u30AF\u30B7\u30E7\u30F3\u3092\u5B8C\u4E86\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u3082\u3046\u4E00\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044\u3002",
+  status_sending: "\u9001\u4FE1\u4E2D",
+  status_sent: "\u9001\u4FE1\u6E08\u307F",
+  status_failed: "\u9001\u4FE1\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  screenshot_capture: "\u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8\u3092\u64AE\u308B",
+  attachment_remove: "\u6DFB\u4ED8\u30D5\u30A1\u30A4\u30EB\u3092\u524A\u9664"
+};
+
+// src/i18n/locales/ko.ts
+var ko = {
+  online: "\uC628\uB77C\uC778",
+  typing: "\uC785\uB825 \uC911...",
+  unable_to_load: "\uCC44\uD305\uC744 \uBD88\uB7EC\uC62C \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+  powered_by: "\uC81C\uACF5:",
+  new_conversation: "\uC0C8 \uB300\uD654",
+  open_chat: "\uCC44\uD305 \uC5F4\uAE30",
+  close_chat: "\uCC44\uD305 \uB2EB\uAE30",
+  send_message: "\uBA54\uC2DC\uC9C0 \uBCF4\uB0B4\uAE30",
+  helpful: "\uB3C4\uC6C0\uC774 \uB428",
+  not_helpful: "\uB3C4\uC6C0\uC774 \uC548 \uB428",
+  menu: "\uBA54\uB274",
+  action_approve: "\uC2B9\uC778",
+  action_cancel: "\uCDE8\uC18C",
+  action_what_will_happen: "\uBB34\uC2A8 \uC77C\uC774 \uC77C\uC5B4\uB098\uB098\uC694?",
+  action_already_resolved: "\uC774 \uC791\uC5C5\uC740 \uC774\uBBF8 \uCC98\uB9AC\uB418\uC5C8\uC2B5\uB2C8\uB2E4.",
+  action_failed: "\uC791\uC5C5\uC744 \uC644\uB8CC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.",
+  status_sending: "\uBCF4\uB0B4\uB294 \uC911",
+  status_sent: "\uBCF4\uB0C8\uC74C",
+  status_failed: "\uBCF4\uB0B4\uAE30 \uC2E4\uD328",
+  screenshot_capture: "\uC2A4\uD06C\uB9B0\uC0F7 \uCC0D\uAE30",
+  attachment_remove: "\uCCA8\uBD80 \uD30C\uC77C \uC81C\uAC70"
+};
+
+// src/i18n/locales/zh-CN.ts
+var zhCN = {
+  online: "\u5728\u7EBF",
+  typing: "\u6B63\u5728\u8F93\u5165...",
+  unable_to_load: "\u65E0\u6CD5\u52A0\u8F7D\u804A\u5929",
+  powered_by: "\u6280\u672F\u652F\u6301\uFF1A",
+  new_conversation: "\u65B0\u5BF9\u8BDD",
+  open_chat: "\u6253\u5F00\u804A\u5929",
+  close_chat: "\u5173\u95ED\u804A\u5929",
+  send_message: "\u53D1\u9001\u6D88\u606F",
+  helpful: "\u6709\u7528",
+  not_helpful: "\u6CA1\u7528",
+  menu: "\u83DC\u5355",
+  action_approve: "\u6279\u51C6",
+  action_cancel: "\u53D6\u6D88",
+  action_what_will_happen: "\u4F1A\u53D1\u751F\u4EC0\u4E48\uFF1F",
+  action_already_resolved: "\u6B64\u64CD\u4F5C\u5DF2\u5904\u7406\u3002",
+  action_failed: "\u64CD\u4F5C\u672A\u80FD\u5B8C\u6210\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+  status_sending: "\u53D1\u9001\u4E2D",
+  status_sent: "\u5DF2\u53D1\u9001",
+  status_failed: "\u53D1\u9001\u5931\u8D25",
+  screenshot_capture: "\u622A\u5C4F",
+  attachment_remove: "\u79FB\u9664\u9644\u4EF6"
+};
+
+// src/i18n/locales/zh-TW.ts
+var zhTW = {
+  online: "\u5728\u7DDA",
+  typing: "\u6B63\u5728\u8F38\u5165...",
+  unable_to_load: "\u7121\u6CD5\u8F09\u5165\u804A\u5929",
+  powered_by: "\u6280\u8853\u652F\u63F4\uFF1A",
+  new_conversation: "\u65B0\u5C0D\u8A71",
+  open_chat: "\u958B\u555F\u804A\u5929",
+  close_chat: "\u95DC\u9589\u804A\u5929",
+  send_message: "\u50B3\u9001\u8A0A\u606F",
+  helpful: "\u6709\u7528",
+  not_helpful: "\u6C92\u7528",
+  menu: "\u9078\u55AE",
+  action_approve: "\u6838\u51C6",
+  action_cancel: "\u53D6\u6D88",
+  action_what_will_happen: "\u6703\u767C\u751F\u4EC0\u9EBC\uFF1F",
+  action_already_resolved: "\u6B64\u64CD\u4F5C\u5DF2\u8655\u7406\u3002",
+  action_failed: "\u64CD\u4F5C\u672A\u80FD\u5B8C\u6210\uFF0C\u8ACB\u91CD\u8A66\u3002",
+  status_sending: "\u50B3\u9001\u4E2D",
+  status_sent: "\u5DF2\u50B3\u9001",
+  status_failed: "\u50B3\u9001\u5931\u6557",
+  screenshot_capture: "\u64F7\u53D6\u756B\u9762",
+  attachment_remove: "\u79FB\u9664\u9644\u4EF6"
+};
+
+// src/i18n/index.ts
+var SUPPORTED_LOCALES = [
+  "en",
+  "es",
+  "pt-BR",
+  "pt-PT",
+  "fr",
+  "de",
+  "it",
+  "nl",
+  "pl",
+  "tr",
+  "ar",
+  "ja",
+  "ko",
+  "zh-CN",
+  "zh-TW"
+];
+var catalog = {
+  en,
+  es,
+  "pt-BR": ptBR,
+  "pt-PT": ptPT,
+  fr,
+  de,
+  it,
+  nl,
+  pl,
+  tr,
+  ar,
+  ja,
+  ko,
+  "zh-CN": zhCN,
+  "zh-TW": zhTW
 };
-var locales = { en, es };
-function createTranslate(locale) {
-  const resolved = resolveLocale(locale);
-  const translations = locales[resolved] ?? en;
-  return (key) => translations[key] ?? en[key] ?? key;
+var RTL_PRIMARY_LANGS = /* @__PURE__ */ new Set(["ar", "he", "fa", "ur"]);
+function isRtlLocale(locale) {
+  return RTL_PRIMARY_LANGS.has(locale.split("-")[0].toLowerCase());
 }
 function resolveLocale(locale) {
-  if (locale) {
-    const base = locale.split("-")[0].toLowerCase();
-    if (locales[base]) return base;
+  if (!locale) return "en";
+  if (SUPPORTED_LOCALES.includes(locale)) {
+    return locale;
+  }
+  const ciMatch = SUPPORTED_LOCALES.find(
+    (l) => l.toLowerCase() === locale.toLowerCase()
+  );
+  if (ciMatch) return ciMatch;
+  const base = locale.split("-")[0].toLowerCase();
+  if (base === "pt") return "pt-BR";
+  if (base === "zh") return "zh-CN";
+  if (SUPPORTED_LOCALES.includes(base)) {
+    return base;
+  }
+  return "en";
+}
+function detectLocale(explicit) {
+  if (explicit) return resolveLocale(explicit);
+  if (typeof window !== "undefined" && window.location?.search) {
+    try {
+      const params = new URLSearchParams(window.location.search);
+      const lang = params.get("lang");
+      if (lang) return resolveLocale(lang);
+    } catch {
+    }
   }
   if (typeof navigator !== "undefined" && navigator.language) {
-    const base = navigator.language.split("-")[0].toLowerCase();
-    if (locales[base]) return base;
+    return resolveLocale(navigator.language);
   }
   return "en";
 }
+function createTranslator(locale, overrides) {
+  const translations = catalog[locale] ?? catalog.en;
+  return (key) => {
+    const ov = overrides?.[key];
+    if (ov) {
+      const localized = ov[locale];
+      if (typeof localized === "string") return localized;
+      const enOverride = ov.en;
+      if (typeof enOverride === "string") return enOverride;
+    }
+    return translations[key] ?? catalog.en[key] ?? key;
+  };
+}
+
+// src/sse.ts
+async function* readSSEStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep = buffer.indexOf("\n\n");
+      while (sep !== -1) {
+        const raw = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        const evt = parseSSERecord(raw);
+        if (evt) yield evt;
+        sep = buffer.indexOf("\n\n");
+      }
+    }
+    const remaining = buffer.trim();
+    if (remaining.length > 0) {
+      const evt = parseSSERecord(remaining);
+      if (evt) yield evt;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseSSERecord(raw) {
+  let event = "";
+  let data = "";
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("event:")) {
+      event = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      data = data.length > 0 ? `${data}
+${line.slice(5).trim()}` : line.slice(5).trim();
+    }
+  }
+  if (!event) return null;
+  return { event, data };
+}
 
 // src/client.ts
 function resolveConfig(userConfig, fetched) {
@@ -68,7 +526,8 @@ function resolveConfig(userConfig, fetched) {
     welcomeMessage: userConfig.welcomeMessage ?? fetched?.welcomeMessage ?? DEFAULTS.welcomeMessage,
     title: userConfig.title ?? fetched?.title ?? DEFAULTS.title,
     avatarUrl: userConfig.avatarUrl ?? fetched?.avatarUrl,
-    suggestedMessages: userConfig.suggestedMessages ?? fetched?.suggestedMessages ?? []
+    suggestedMessages: userConfig.suggestedMessages ?? fetched?.suggestedMessages ?? [],
+    stringOverrides: fetched?.stringOverrides
   };
 }
 function getStorage() {
@@ -84,12 +543,18 @@ var CustomerHeroChat = class {
   storage;
   userConfig;
   identityData = null;
+  // `t` is mutable: it gets rebuilt when locale changes or when the fetched
+  // widget config delivers `stringOverrides`. The React layer reads this
+  // property directly each render rather than caching it in a state snapshot,
+  // so a `setLocale` call propagates through `useSyncExternalStore` via the
+  // accompanying `setState({ locale, isRtl })` notification.
   t;
   constructor(config) {
     this.userConfig = config;
     this.storage = getStorage();
-    this.t = createTranslate(config.locale);
+    const locale = detectLocale(config.locale);
     const resolved = resolveConfig(config);
+    this.t = createTranslator(locale, resolved.stringOverrides);
     const storedConvId = this.storage?.getItem(`ch_conv_${config.chatbotId}`);
     this.state = {
       messages: [],
@@ -100,9 +565,26 @@ var CustomerHeroChat = class {
       configLoaded: false,
       configError: null,
       error: null,
-      identity: null
+      identity: null,
+      locale,
+      isRtl: isRtlLocale(locale)
     };
   }
+  // Switch the active locale at runtime. No-op when the resolved tag matches
+  // the current locale and `stringOverrides` is unchanged. Subscribers get a
+  // single state notification with the new `locale` / `isRtl`.
+  setLocale(tag) {
+    const next = detectLocale(tag);
+    if (next === this.state.locale) return;
+    this.t = createTranslator(next, this.state.config.stringOverrides);
+    this.setState({ locale: next, isRtl: isRtlLocale(next) });
+  }
+  rebuildTranslator() {
+    this.t = createTranslator(
+      this.state.locale,
+      this.state.config.stringOverrides
+    );
+  }
   subscribe(listener) {
     this.listeners.add(listener);
     return () => {
@@ -116,6 +598,18 @@ var CustomerHeroChat = class {
     this.state = { ...this.state, ...partial };
     this.notifyListeners();
   }
+  // Mutate the last message in place and notify. Used during streaming so
+  // listeners see tokens land without allocating a new messages array per
+  // token. The array itself is still replaced so consumers using
+  // structural equality (React's useSyncExternalStore) see a new reference.
+  patchLastMessage(patch) {
+    const { messages } = this.state;
+    if (messages.length === 0) return;
+    const next = messages.slice();
+    const last = next[next.length - 1];
+    next[next.length - 1] = { ...last, ...patch };
+    this.setState({ messages: next });
+  }
   notifyListeners() {
     for (const listener of this.listeners) {
       listener(this.state);
@@ -132,6 +626,7 @@ var CustomerHeroChat = class {
       const fetched = await response.json();
       const resolved = resolveConfig(this.userConfig, fetched);
       this.setState({ config: resolved, configLoaded: true });
+      if (resolved.stringOverrides) this.rebuildTranslator();
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : "Failed to load widget config";
       console.error("CustomerHero: Failed to fetch widget config", error);
@@ -159,68 +654,322 @@ var CustomerHeroChat = class {
         return;
       }
       const data = await response.json();
-      const messages = (data.messages ?? []).map(
-        (m) => ({
-          id: m.id,
-          role: m.role,
-          content: m.content
-        })
+      const raw = data.messages ?? [];
+      const messages = raw.map((m) => ({
+        id: m.id,
+        role: m.role,
+        content: m.content,
+        ...m.sources ? { sources: m.sources } : {},
+        ...m.blocks ? { blocks: m.blocks } : {},
+        ...m.suggestions ? { suggestions: m.suggestions } : {}
+      }));
+      const lastBotIndex = findLastIndex(
+        messages,
+        (m) => m.role === "bot" && !!m.suggestions?.length
       );
+      for (let i = 0; i < messages.length; i++) {
+        if (i !== lastBotIndex && messages[i].suggestions) {
+          const { suggestions: _s, ...rest } = messages[i];
+          void _s;
+          messages[i] = rest;
+        }
+      }
       if (messages.length > 0) {
         this.setState({ messages });
       }
     } catch {
     }
   }
-  async sendMessage(message) {
+  async sendMessage(message, options) {
     const trimmed = message.trim();
+    const attachmentTokens = options?.attachmentTokens ?? [];
     if (!trimmed || this.state.isLoading) return;
-    const userMsg = { role: "user", content: trimmed };
+    const userMsg = {
+      role: "user",
+      content: trimmed,
+      status: "sending"
+    };
+    const cleanedHistory = this.state.messages.map((m) => {
+      let next = m;
+      if (next.suggestions) next = stripSuggestions(next);
+      if (next.blocks?.some((b) => b.type === "action_confirmation")) {
+        next = stripActionConfirmationBlocks(next);
+      }
+      return next;
+    });
+    const userMsgIndex = cleanedHistory.length;
     this.setState({
-      messages: [...this.state.messages, userMsg],
+      messages: [...cleanedHistory, userMsg],
       isLoading: true,
       error: null
     });
-    const { chatbotId } = this.state.config;
-    const apiBase = this.state.config.apiBase;
+    const { chatbotId, apiBase } = this.state.config;
+    let botMessageCreated = false;
     try {
       const response = await fetch(`${apiBase}/api/chat/${chatbotId}`, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
         body: JSON.stringify({
           message: trimmed,
           ...this.state.conversationId ? { conversationId: this.state.conversationId } : {},
-          ...this.identityData ? { identity: this.identityData } : {}
+          ...this.identityData ? { identity: this.identityData } : {},
+          ...attachmentTokens.length > 0 ? { attachmentTokens } : {}
         })
       });
       if (!response.ok) {
-        const data2 = await response.json().catch(() => null);
-        const errorMsg = data2?.error ?? `Request failed: ${response.status}`;
+        const data = await response.json().catch(() => null);
+        const errorMsg = data?.error ?? `Request failed: ${response.status}`;
         throw new Error(errorMsg);
       }
-      const data = await response.json();
-      const botMsg = {
-        id: data.messageId,
-        role: "bot",
-        content: data.message
-      };
-      const conversationId = data.conversationId ?? this.state.conversationId;
-      if (conversationId) {
-        this.storage?.setItem(`ch_conv_${chatbotId}`, conversationId);
+      if (!response.body) {
+        throw new Error("Empty response body");
       }
-      this.setState({
-        messages: [...this.state.messages, botMsg],
-        isLoading: false,
-        conversationId
-      });
+      let fullContent = "";
+      let messageId;
+      for await (const evt of readSSEStream(response.body)) {
+        switch (evt.event) {
+          case "metadata": {
+            const meta = safeParse(evt.data);
+            if (meta?.conversationId) {
+              this.storage?.setItem(
+                `ch_conv_${chatbotId}`,
+                meta.conversationId
+              );
+              this.setState({ conversationId: meta.conversationId });
+            }
+            this.patchMessageAt(userMsgIndex, { status: "sent" });
+            if (meta?.messageId) {
+              messageId = meta.messageId;
+            }
+            break;
+          }
+          case "token": {
+            const tok = safeParse(evt.data);
+            const text = tok?.text ?? "";
+            fullContent += text;
+            if (!botMessageCreated) {
+              const botMsg = {
+                id: messageId,
+                role: "bot",
+                content: fullContent,
+                streaming: true
+              };
+              this.setState({
+                messages: [...this.state.messages, botMsg]
+              });
+              botMessageCreated = true;
+            } else {
+              this.patchLastMessage({ content: fullContent });
+            }
+            break;
+          }
+          case "sources": {
+            const payload = safeParse(evt.data);
+            if (payload?.sources?.length && botMessageCreated) {
+              this.patchLastMessage({ sources: payload.sources });
+            }
+            break;
+          }
+          case "block": {
+            const payload = safeParse(evt.data);
+            if (payload?.block && botMessageCreated) {
+              const existing = this.state.messages.at(-1)?.blocks ?? [];
+              this.patchLastMessage({
+                blocks: [...existing, payload.block]
+              });
+            }
+            break;
+          }
+          case "suggestions": {
+            const payload = safeParse(evt.data);
+            if (payload?.suggestions?.length && botMessageCreated) {
+              this.patchLastMessage({ suggestions: payload.suggestions });
+            }
+            break;
+          }
+          case "done": {
+            if (botMessageCreated) {
+              this.patchLastMessage({
+                id: messageId,
+                streaming: false
+              });
+            }
+            break;
+          }
+          case "error": {
+            const payload = safeParse(evt.data);
+            throw new Error(payload?.error ?? "Stream failed");
+          }
+        }
+      }
+      if (!botMessageCreated && !fullContent) {
+      }
+      this.setState({ isLoading: false });
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : "Something went wrong";
+      if (botMessageCreated) {
+        this.patchLastMessage({ streaming: false });
+      }
+      const userStatus = this.state.messages[userMsgIndex]?.status;
+      if (userStatus !== "sent") {
+        this.patchMessageAt(userMsgIndex, { status: "failed" });
+      }
       this.setState({
         isLoading: false,
         error: errorMsg
       });
     }
   }
+  // Upload a screenshot blob to the public attachments endpoint and return
+  // the token the caller should pass to `sendMessage(text, { attachmentTokens })`.
+  async uploadAttachment(blob, options) {
+    const { chatbotId, apiBase } = this.state.config;
+    const filename = options?.filename ?? `screenshot.${pickExtension(blob.type)}`;
+    const form = new FormData();
+    form.append("file", blob, filename);
+    const response = await fetch(
+      `${apiBase}/api/chat/${chatbotId}/attachments`,
+      { method: "POST", body: form }
+    );
+    if (!response.ok) {
+      const data = await response.json().catch(() => null);
+      const errorMsg = data?.error ?? `Upload failed: ${response.status}`;
+      throw new Error(errorMsg);
+    }
+    const json = await response.json();
+    return json;
+  }
+  approveAction(pendingId) {
+    return this.sendDecision(pendingId, "approve");
+  }
+  cancelAction(pendingId) {
+    return this.sendDecision(pendingId, "cancel");
+  }
+  // Locate the bot bubble that carries the action_confirmation block for
+  // `pendingId`, strip the block, mark the bubble streaming, then POST the
+  // decision and stream tokens back into the same bubble.
+  async sendDecision(pendingId, decision) {
+    const targetIndex = this.findActionConfirmationMessageIndex(pendingId);
+    if (targetIndex === -1) {
+      this.setState({ error: this.t("action_already_resolved") });
+      await this.loadHistory();
+      return;
+    }
+    const messages = this.state.messages.slice();
+    const original = messages[targetIndex];
+    messages[targetIndex] = {
+      ...stripActionConfirmationBlocks(original),
+      streaming: true
+    };
+    this.setState({ messages, error: null });
+    const { chatbotId, apiBase } = this.state.config;
+    const url = `${apiBase}/api/chat/${chatbotId}/tool-calls/${pendingId}/decision`;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify({
+          decision,
+          ...this.identityData ? { identity: this.identityData } : {}
+        })
+      });
+      if (!response.ok) {
+        const data = await response.json().catch(() => null);
+        const errorMsg = data?.error ?? `Request failed: ${response.status}`;
+        throw new Error(errorMsg);
+      }
+      if (!response.body) throw new Error("Empty response body");
+      for await (const evt of readSSEStream(response.body)) {
+        switch (evt.event) {
+          case "metadata": {
+            const meta = safeParse(evt.data);
+            if (meta?.conversationId) {
+              this.storage?.setItem(
+                `ch_conv_${chatbotId}`,
+                meta.conversationId
+              );
+              this.setState({ conversationId: meta.conversationId });
+            }
+            break;
+          }
+          case "token": {
+            const tok = safeParse(evt.data);
+            const text = tok?.text ?? "";
+            if (text) {
+              this.appendToMessageAt(targetIndex, text);
+            }
+            break;
+          }
+          case "block": {
+            const payload = safeParse(evt.data);
+            if (payload?.block) {
+              this.appendBlockToMessageAt(targetIndex, payload.block);
+            }
+            break;
+          }
+          case "done": {
+            this.patchMessageAt(targetIndex, { streaming: false });
+            break;
+          }
+          case "error": {
+            const payload = safeParse(
+              evt.data
+            );
+            if (payload?.kind === "already_resolved") {
+              this.patchMessageAt(targetIndex, { streaming: false });
+              this.setState({ error: this.t("action_already_resolved") });
+              await this.loadHistory();
+              return;
+            }
+            throw new Error(payload?.error ?? "Stream failed");
+          }
+        }
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : this.t("action_failed");
+      this.patchMessageAt(targetIndex, { streaming: false });
+      this.setState({ error: errorMsg });
+    }
+  }
+  findActionConfirmationMessageIndex(pendingId) {
+    const { messages } = this.state;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const blocks = messages[i].blocks;
+      if (blocks?.some(
+        (b) => b.type === "action_confirmation" && b.pendingToolCallId === pendingId
+      )) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  patchMessageAt(index, patch) {
+    const messages = this.state.messages.slice();
+    if (!messages[index]) return;
+    messages[index] = { ...messages[index], ...patch };
+    this.setState({ messages });
+  }
+  appendToMessageAt(index, text) {
+    const messages = this.state.messages.slice();
+    const target = messages[index];
+    if (!target) return;
+    messages[index] = { ...target, content: target.content + text };
+    this.setState({ messages });
+  }
+  appendBlockToMessageAt(index, block) {
+    const messages = this.state.messages.slice();
+    const target = messages[index];
+    if (!target) return;
+    const existing = target.blocks ?? [];
+    messages[index] = { ...target, blocks: [...existing, block] };
+    this.setState({ messages });
+  }
   async rateMessage(messageId, rating) {
     const { chatbotId, apiBase } = this.state.config;
     const { conversationId } = this.state;
@@ -290,7 +1039,183 @@ var CustomerHeroChat = class {
     });
   }
 };
+function safeParse(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function stripSuggestions(message) {
+  const { suggestions: _s, ...rest } = message;
+  void _s;
+  return rest;
+}
+function stripActionConfirmationBlocks(message) {
+  if (!message.blocks?.length) return message;
+  const blocks = message.blocks.filter((b) => b.type !== "action_confirmation");
+  if (blocks.length === message.blocks.length) return message;
+  if (blocks.length === 0) {
+    const { blocks: _b, ...rest } = message;
+    void _b;
+    return rest;
+  }
+  return { ...message, blocks };
+}
+function findLastIndex(arr, pred) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (pred(arr[i])) return i;
+  }
+  return -1;
+}
+function pickExtension(mime) {
+  if (mime === "image/png") return "png";
+  if (mime === "image/webp") return "webp";
+  return "jpg";
+}
+
+// src/screenshot.ts
+var ScreenshotCancelled = class extends Error {
+  constructor(message = "Screenshot cancelled") {
+    super(message);
+    this.name = "ScreenshotCancelled";
+  }
+};
+var ScreenshotUnavailable = class extends Error {
+  constructor(message = "Screenshot unavailable") {
+    super(message);
+    this.name = "ScreenshotUnavailable";
+  }
+};
+var MAX_DIMENSION = 2048;
+var SIZE_BUDGET = 5 * 1024 * 1024;
+function canCaptureScreenshot() {
+  if (typeof navigator === "undefined" || typeof window === "undefined") {
+    return false;
+  }
+  if (!navigator.mediaDevices?.getDisplayMedia) return false;
+  if (typeof window.matchMedia !== "function") return false;
+  return window.matchMedia("(pointer: fine)").matches;
+}
+async function captureScreenshot() {
+  if (typeof navigator === "undefined" || !navigator.mediaDevices) {
+    throw new ScreenshotUnavailable("Screen capture not supported");
+  }
+  let stream;
+  try {
+    stream = await navigator.mediaDevices.getDisplayMedia({
+      video: true,
+      audio: false
+    });
+  } catch (e) {
+    if (e instanceof Error && (e.name === "NotAllowedError" || e.name === "AbortError")) {
+      throw new ScreenshotCancelled(e.message);
+    }
+    const msg = e instanceof Error ? e.message : "Screen capture failed";
+    throw new ScreenshotUnavailable(msg);
+  }
+  try {
+    const bitmap = await grabFrame(stream);
+    return await encodeJpeg(bitmap);
+  } finally {
+    for (const track of stream.getTracks()) track.stop();
+  }
+}
+async function grabFrame(stream) {
+  const [track] = stream.getVideoTracks();
+  if (!track) throw new ScreenshotUnavailable("No video track");
+  const ImageCaptureCtor = globalThis.ImageCapture;
+  if (ImageCaptureCtor) {
+    try {
+      const cap = new ImageCaptureCtor(track);
+      const bitmap = await cap.grabFrame();
+      if (bitmap.width > 0 && bitmap.height > 0) return bitmap;
+    } catch {
+    }
+  }
+  return await grabFrameFromVideo(stream);
+}
+async function grabFrameFromVideo(stream) {
+  const video = document.createElement("video");
+  video.autoplay = true;
+  video.muted = true;
+  video.playsInline = true;
+  video.srcObject = stream;
+  try {
+    await new Promise((resolve, reject) => {
+      const onReady = () => {
+        video.removeEventListener("loadedmetadata", onReady);
+        resolve();
+      };
+      const onError = () => {
+        video.removeEventListener("error", onError);
+        reject(new ScreenshotUnavailable("Video element failed"));
+      };
+      video.addEventListener("loadedmetadata", onReady);
+      video.addEventListener("error", onError);
+    });
+    await video.play().catch(() => {
+    });
+    const w = video.videoWidth;
+    const h = video.videoHeight;
+    if (w === 0 || h === 0) throw new ScreenshotUnavailable("Empty frame");
+    const canvas = document.createElement("canvas");
+    canvas.width = w;
+    canvas.height = h;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new ScreenshotUnavailable("No 2D context");
+    ctx.drawImage(video, 0, 0, w, h);
+    return await createImageBitmap(canvas);
+  } finally {
+    video.srcObject = null;
+  }
+}
+async function encodeJpeg(bitmap) {
+  const { width, height } = scaleToFit(
+    bitmap.width,
+    bitmap.height,
+    MAX_DIMENSION
+  );
+  const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(width, height) : Object.assign(document.createElement("canvas"), { width, height });
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new ScreenshotUnavailable("No 2D context");
+  ctx.drawImage(bitmap, 0, 0, width, height);
+  bitmap.close?.();
+  const blob = await canvasToBlob(canvas, 0.85);
+  if (blob.size <= SIZE_BUDGET) return blob;
+  const slim = await canvasToBlob(canvas, 0.7);
+  return slim;
+}
+function scaleToFit(w, h, max) {
+  if (w <= max && h <= max) return { width: w, height: h };
+  const ratio = w >= h ? max / w : max / h;
+  return { width: Math.round(w * ratio), height: Math.round(h * ratio) };
+}
+async function canvasToBlob(canvas, quality) {
+  if ("convertToBlob" in canvas) {
+    return await canvas.convertToBlob({
+      type: "image/jpeg",
+      quality
+    });
+  }
+  return await new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (b) => b ? resolve(b) : reject(new ScreenshotUnavailable("Encode failed")),
+      "image/jpeg",
+      quality
+    );
+  });
+}
 export {
   CustomerHeroChat,
-  DEFAULTS
+  DEFAULTS,
+  SUPPORTED_LOCALES,
+  ScreenshotCancelled,
+  ScreenshotUnavailable,
+  canCaptureScreenshot,
+  captureScreenshot,
+  createTranslator,
+  detectLocale,
+  isRtlLocale,
+  resolveLocale
 };