@ai-matrx/media 0.13.0 → 0.15.0

package/dist/speech.cjs

@@ -0,0 +1,1689 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/speech/configure.ts
+function configureSpeech(next) {
+  ports = { ...ports, ...next, adapters: { ...ports.adapters, ...next.adapters } };
+}
+function speechPorts() {
+  return ports;
+}
+function requirePort(key) {
+  const value = ports[key];
+  if (!value) {
+    throw new Error(`Speech is not set up in this app: configureSpeech({ ${String(key)} }) was never called.`);
+  }
+  return value;
+}
+function resetSpeechPortsForTests() {
+  ports = {};
+}
+var ports;
+var init_configure = __esm({
+  "src/speech/configure.ts"() {
+    "use strict";
+    ports = {};
+  }
+});
+
+// src/speech/unlock.ts
+function declarePlaybackAudioSession() {
+  if (audioSessionDeclared) return;
+  const session = navigator.audioSession;
+  if (session) {
+    try {
+      session.type = "playback";
+      audioSessionDeclared = true;
+    } catch {
+    }
+  } else {
+    audioSessionDeclared = true;
+  }
+}
+function getUnlockedAudioContext() {
+  return sharedContext && sharedContext.state !== "closed" ? sharedContext : null;
+}
+function getPrimedMediaElement() {
+  return sharedElement;
+}
+function primeAudioOutput() {
+  if (typeof window === "undefined") return;
+  declarePlaybackAudioSession();
+  try {
+    if (!sharedContext || sharedContext.state === "closed") {
+      sharedContext = new AudioContext();
+    }
+    if (sharedContext.state === "suspended") {
+      void sharedContext.resume().catch(() => {
+      });
+    }
+    const buffer = sharedContext.createBuffer(1, 1, sharedContext.sampleRate);
+    const node = sharedContext.createBufferSource();
+    node.buffer = buffer;
+    node.connect(sharedContext.destination);
+    node.start(0);
+  } catch {
+  }
+  try {
+    if (!sharedElement) {
+      const el2 = new Audio();
+      el2.setAttribute("playsinline", "true");
+      sharedElement = el2;
+    }
+    const el = sharedElement;
+    if (el.paused && !el.src.startsWith("blob:") && !el.currentSrc.startsWith("http")) {
+      el.muted = true;
+      el.src = SILENT_WAV;
+      void el.play().then(() => {
+        el.pause();
+        el.muted = false;
+      }).catch(() => {
+        el.muted = false;
+      });
+    }
+  } catch {
+  }
+}
+function installAudioUnlockListeners() {
+  if (listenersInstalled || typeof window === "undefined") return;
+  listenersInstalled = true;
+  const onGesture = () => primeAudioOutput();
+  window.addEventListener("pointerdown", onGesture, {
+    capture: true,
+    passive: true
+  });
+  window.addEventListener("keydown", onGesture, {
+    capture: true,
+    passive: true
+  });
+  window.addEventListener("touchend", onGesture, {
+    capture: true,
+    passive: true
+  });
+}
+var sharedContext, sharedElement, listenersInstalled, audioSessionDeclared, SILENT_WAV;
+var init_unlock = __esm({
+  "src/speech/unlock.ts"() {
+    "use strict";
+    sharedContext = null;
+    sharedElement = null;
+    listenersInstalled = false;
+    audioSessionDeclared = false;
+    SILENT_WAV = "data:audio/wav;base64,UklGRiQAAABXQVZFZm10IBAAAAABAAEAQB8AAIA+AAACABAAZGF0YQAAAAA=";
+  }
+});
+
+// src/voices/speech-text.ts
+function speakTables(text) {
+  const lines = text.split("\n");
+  const out = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    if (!(0, import_source.tableStartsAt)(lines, i)) {
+      out.push(lines[i] ?? "");
+      continue;
+    }
+    const end = (0, import_source.findTableEnd)(lines, i);
+    const headers = (0, import_source.rowCells)(lines[i] ?? "").map(import_source.unescapeCellPipes).filter((h) => h.length > 0);
+    const rowCount = lines.slice(i + 2, end).filter((line) => line.trim().length > 1).length;
+    const headerText = headers.length > 1 ? headers.slice(0, -1).join(", ") + ", and " + headers[headers.length - 1] : headers.length === 1 ? headers[0] : "unlabeled columns";
+    const rowText = rowCount === 1 ? "one row" : rowCount > 0 ? `${rowCount} rows` : "no rows";
+    out.push(`There is a table with ${rowText} of data provided for ${headerText}.`);
+    i = end - 1;
+  }
+  return out.join("\n");
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function spokenFormForAbbreviation(match, sourceAbbreviation, suffix = "") {
+  const abbreviation = COMMON_ABBREVIATION_BY_UPPERCASE[sourceAbbreviation.toUpperCase()];
+  if (!abbreviation) return match;
+  if (CASE_SENSITIVE_WORD_ACRONYMS.has(abbreviation) && sourceAbbreviation !== abbreviation) {
+    return match;
+  }
+  if (SPOKEN_AS_WORD.has(abbreviation)) return `${abbreviation}${suffix}`;
+  const spoken = Array.from(abbreviation.toUpperCase()).join(" ");
+  return suffix ? `${spoken}'s` : spoken;
+}
+function normalizeSpeechBlanks(text) {
+  if (!text || !text.includes("_")) return text;
+  const blank = /(?<![\p{L}\p{N}])_(?:[ \t]*_)+(?![\p{L}\p{N}])/gu;
+  return text.split("\n").map(
+    (line) => /^[ \t]*_[ \t_]*$/.test(line) ? line : line.replace(blank, ` ${SPEECH_BLANK_WORD} `)
+  ).join("\n");
+}
+function applyPronunciations(text, pairs) {
+  let out = text;
+  for (const { from, to } of pairs) {
+    const term = from.trim();
+    if (!term || !to) continue;
+    const re = new RegExp(
+      `(?<![\\p{L}\\p{N}])${escapeRegExp(term)}(?![\\p{L}\\p{N}])`,
+      "giu"
+    );
+    out = out.replace(re, to);
+  }
+  return out;
+}
+function parseMarkdownToText(markdown, options) {
+  if (!markdown || typeof markdown !== "string") return "";
+  const numberToWords = (num) => {
+    const ones = [
+      "zero",
+      "one",
+      "two",
+      "three",
+      "four",
+      "five",
+      "six",
+      "seven",
+      "eight",
+      "nine",
+      "ten",
+      "eleven",
+      "twelve",
+      "thirteen",
+      "fourteen",
+      "fifteen",
+      "sixteen",
+      "seventeen",
+      "eighteen",
+      "nineteen"
+    ];
+    const tens = [
+      "",
+      "",
+      "twenty",
+      "thirty",
+      "forty",
+      "fifty",
+      "sixty",
+      "seventy",
+      "eighty",
+      "ninety"
+    ];
+    const numInt = parseInt(num, 10);
+    if (numInt < 20) return ones[numInt] ?? num;
+    if (numInt < 100) {
+      const t = Math.floor(numInt / 10);
+      const o = numInt % 10;
+      return o === 0 ? tens[t] ?? num : `${tens[t] ?? ""}-${ones[o] ?? ""}`;
+    }
+    if (numInt < 1e3) {
+      const h = Math.floor(numInt / 100);
+      const remainder = numInt % 100;
+      return remainder === 0 ? `${ones[h]} hundred` : `${ones[h]} hundred ${numberToWords(String(remainder))}`;
+    }
+    return String(numInt);
+  };
+  const emojiMap = {
+    "\u{1F60A}": "smiling face",
+    "\u{1F602}": "laughing face",
+    "\u2764\uFE0F": "heart",
+    "\u{1F44D}": "thumbs up",
+    "\u{1F44E}": "thumbs down",
+    "\u{1F525}": "fire",
+    "\u2B50": "star",
+    "\u2705": "check mark",
+    "\u274C": "cross mark",
+    "\u26A0\uFE0F": "warning",
+    "\u{1F680}": "rocket",
+    "\u{1F4A1}": "light bulb",
+    "\u{1F3AF}": "target",
+    "\u{1F4F1}": "mobile phone",
+    "\u{1F4BB}": "laptop",
+    "\u{1F31F}": "glowing star",
+    "\u{1F517}": "link",
+    "\u{1F4E7}": "email",
+    "\u{1F4C4}": "document",
+    "\u{1F4CA}": "chart",
+    "\u{1F6E0}\uFE0F": "tools",
+    "\u2699\uFE0F": "gear",
+    "\u{1F527}": "wrench",
+    "\u{1F4C8}": "chart increasing",
+    "\u{1F4C9}": "chart decreasing",
+    "\u{1F389}": "party popper",
+    "\u{1F4AA}": "flexed biceps",
+    "\u{1F914}": "thinking face",
+    "\u{1F4AD}": "thought bubble",
+    "\u{1F440}": "eyes",
+    "\u{1F44B}": "waving hand",
+    "\u2728": "sparkles",
+    "\u{1F50D}": "magnifying mx-glass",
+    "\u{1F4DD}": "memo",
+    "\u{1F4CB}": "clipboard",
+    "\u{1F4C5}": "calendar",
+    "\u23F0": "alarm clock",
+    "\u{1F512}": "locked",
+    "\u{1F513}": "unlocked",
+    "\u{1F3C6}": "trophy",
+    "\u{1F396}\uFE0F": "military medal",
+    "\u{1F397}\uFE0F": "reminder ribbon",
+    "\u{1F3C5}": "sports medal",
+    "\u{1F947}": "first place medal",
+    "\u{1F948}": "second place medal",
+    "\u{1F949}": "third place medal"
+  };
+  const measurementUnits = {
+    // Weight
+    lbs: "pound",
+    // Changed from 'pounds'
+    lb: "pound",
+    oz: "ounce",
+    // Changed from 'ounces'
+    kg: "kilogram",
+    // Changed from 'kilograms'
+    gm: "gram",
+    // Changed from 'grams'
+    mg: "milligram",
+    // Changed from 'milligrams'
+    // Distance/Length
+    km: "kilometer",
+    // Changed from 'kilometers'
+    cm: "centimeter",
+    // Changed from 'centimeters'
+    mm: "millimeter",
+    // Changed from 'millimeters'
+    ft: "foot",
+    // Changed from 'feet' (Irregular plural)
+    mi: "mile",
+    // Changed from 'miles'
+    // Speed
+    mph: "mile per hour",
+    // Changed from 'miles per hour'
+    kph: "kilometer per hour",
+    // Changed from 'kilometers per hour'
+    kmh: "kilometer per hour",
+    // Changed from 'kilometers per hour'
+    // Volume
+    ml: "milliliter",
+    // Changed from 'milliliters'
+    mL: "milliliter",
+    // Changed from 'milliliters'
+    gal: "gallon",
+    // Changed from 'gallons'
+    qt: "quart",
+    // Changed from 'quarts'
+    tbsp: "tablespoon",
+    // Changed from 'tablespoons'
+    tsp: "teaspoon",
+    // Changed from 'teaspoons'
+    // Area
+    sqft: "square foot",
+    // Changed from 'square feet' (Irregular plural)
+    sqm: "square meter",
+    // Changed from 'square meters'
+    // Time
+    sec: "second",
+    // Changed from 'seconds'
+    min: "minute",
+    // Changed from 'minutes'
+    hr: "hour",
+    // Changed from 'hours'
+    hrs: "hour",
+    // Changed from 'hours'
+    ms: "millisecond",
+    // Changed from 'milliseconds'
+    // Other common units
+    psi: "pound per square inch",
+    // Changed from 'pounds per square inch'
+    rpm: "revolution per minute",
+    // Changed from 'revolutions per minute'
+    bpm: "beat per minute"
+    // Changed from 'beats per minute'
+  };
+  const stripReasoningTags = (input) => {
+    return input.replace(/<(thinking|reasoning|think|reason)\b[^>]*>[\s\S]*?<\/\1>/gi, "").replace(/<\/?(?:thinking|reasoning|think|reason)\b[^>]*>/gi, "");
+  };
+  const stripLeadingMarkdown = (input) => {
+    let text = input.replace(/^\uFEFF/, "").replace(/^[ \t]*\r?\n/, "");
+    text = text.replace(
+      /^[ \t]*(?:#{1,6}[ \t]+|>[ \t]*|[-*+][ \t]+|\d+\.[ \t]+|-[ \t]*\[[ xX]\][ \t]+)/,
+      ""
+    );
+    return text;
+  };
+  const source = normalizeSpeechBlanks(
+    options?.pronunciations?.length ? applyPronunciations(markdown, options.pronunciations) : markdown
+  );
+  let result = speakTables((0, import_source.unwrapCodeSpans)((0, import_source.replaceFences)(stripLeadingMarkdown(stripReasoningTags(source)), ({ lang }) => {
+    const language = lang.toLowerCase();
+    if (language === "mermaid") return "Please see the diagram provided.";
+    return SPOKEN_CODE_LANGUAGES.has(language) ? `Please see the ${language} code provided.` : "Please see the code provided.";
+  }))).split("\n").map((line) => (0, import_source.isPipeLedRow)(line) && line.trimEnd().endsWith("|") ? "" : line).join("\n").replace(
+    /\b(\d+)\s*[-–—]\s*(\d+)\b/g,
+    (_match, a, b) => `${numberToWords(a)} to ${numberToWords(b)}`
+  ).replace(
+    /^#{1,6}\s+(.+)$/gm,
+    (_m, t) => /[.!?:]$/.test(t.trim()) ? t : `${t.trim()}.`
+  ).replace(/\/\/\s*/g, "").replace(/--\s*/g, "").replace(/#\s+/g, "").replace(/;\s*/g, "").replace(/(\*\*|__)(.*?)\1/g, "$2").replace(/(\*|_)(.*?)\1/g, "$2").replace(/~~(.*?)~~/g, "$1").replace(/==(.*?)==/g, "$1").replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, text, url) => {
+    if (url.startsWith("mailto:")) {
+      return `${text}. Email address provided.`;
+    }
+    const fileExtensions = [
+      ".pdf",
+      ".doc",
+      ".docx",
+      ".xls",
+      ".xlsx",
+      ".ppt",
+      ".pptx",
+      ".txt",
+      ".md",
+      ".json",
+      ".xml",
+      ".csv",
+      ".zip"
+    ];
+    const hasFileExtension = fileExtensions.some(
+      (ext) => url.toLowerCase().includes(ext)
+    );
+    if (hasFileExtension) {
+      return `${text}. Document link provided.`;
+    }
+    return `${text}. Link provided.`;
+  }).replace(
+    /!\[([^\]]*)\]\(([^)]+)\)/g,
+    ($0, alt) => alt ? `${alt}. Image provided.` : "Image provided."
+  ).replace(/^>\s*(.+)$/gm, "Quote: $1").replace(/^-\s*\[x\]\s+(.+)$/gm, "Completed task: $1").replace(/^-\s*\[\s*\]\s+(.+)$/gm, "Pending task: $1").replace(/^([-*+])\s+(.+)$/gm, "$2").replace(
+    /^(\d+)\.\s+(.+)$/gm,
+    (_match, num, content) => `Number ${numberToWords(num)}: ${content}`
+  ).replace(/\[\^(\d+)\]/g, "Reference $1").replace(/^\[\d+\]:\s*(.+)$/gm, "Reference: $1").replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "").replace(/\$([^$]+)\$/g, "Mathematical expression: $1").replace(/\$\$([^$]+)\$\$/g, "Mathematical formula: $1").replace(
+    /(\+\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g,
+    "Phone number provided."
+  ).replace(
+    /([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/g,
+    "Email address: $1"
+  ).replace(/\$(\d+(?:,\d{3})*(?:\.\d{2})?)/g, "$1 dollars").replace(/€(\d+(?:[.,]\d{3})*(?:[.,]\d{2})?)/g, "$1 euros").replace(/£(\d+(?:,\d{3})*(?:\.\d{2})?)/g, "$1 pounds").replace(/¥(\d+(?:,\d{3})*(?:\.\d{2})?)/g, "$1 yen").replace(
+    /(\d{4})[-/](\d{1,2})[-/](\d{1,2})/g,
+    (_match, year, month, day) => {
+      const monthNames = [
+        "January",
+        "February",
+        "March",
+        "April",
+        "May",
+        "June",
+        "July",
+        "August",
+        "September",
+        "October",
+        "November",
+        "December"
+      ];
+      const monthName = monthNames[parseInt(month) - 1] || month;
+      return `${monthName} ${day}, ${year}`;
+    }
+  ).replace(
+    /(\d{1,2}):(\d{2})\s*(AM|PM|am|pm)?/g,
+    (_match, hour, minute, period) => {
+      const hourNum = parseInt(hour);
+      const periodText = period ? period.toUpperCase() === "AM" ? "A.M." : "P.M." : "";
+      return `${hourNum} ${minute} ${periodText}`.trim();
+    }
+  ).replace(
+    /[\u{1F600}-\u{1F64F}]|[\u{1F300}-\u{1F5FF}]|[\u{1F680}-\u{1F6FF}]|[\u{1F1E0}-\u{1F1FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]/gu,
+    (emoji) => {
+      return emojiMap[emoji] || "emoji";
+    }
+  ).replace(COMMON_ABBREVIATION_PATTERN, spokenFormForAbbreviation).replace(
+    /(\d+(?:\.\d+)?)\s*(lbs|lb|oz|kg|gm|mg|km|cm|mm|ft|mi|mph|kph|kmh|ml|mL|gal|qt|tbsp|tsp|sqft|sqm|sec|min|hr|hrs|ms|psi|rpm|bpm)\b/gi,
+    (match, number, unit) => {
+      const unitLower = unit.toLowerCase();
+      const unitText = measurementUnits[unitLower] || measurementUnits[unit] || unit;
+      return `${number} ${unitText}`;
+    }
+  ).replace(
+    /\b(lbs|lb|oz|kg|gm|mg|km|cm|mm|mph|kph|kmh|ml|mL|gal|qt|tbsp|tsp|sqft|sqm|psi|rpm|bpm)(?=\s|$|[.,;!?])/gi,
+    (match) => {
+      const unitLower = match.toLowerCase();
+      return measurementUnits[unitLower] || measurementUnits[match] || match;
+    }
+  ).replace(/©/g, "copyright").replace(/®/g, "registered trademark").replace(/™/g, "trademark").replace(/°/g, "degrees").replace(/±/g, "plus or minus").replace(/≈/g, "approximately").replace(/≠/g, "not equal to").replace(/≤/g, "less than or equal to").replace(/≥/g, "greater than or equal to").replace(/=/g, " equals ").replace(/→/g, "arrow").replace(/←/g, "left arrow").replace(/↑/g, "up arrow").replace(/↓/g, "down arrow").replace(/<\/?[^>]+(>|$)/g, "").replace(/([^\s.!?,;:\-])(\n)/g, "$1.\n").replace(/\s+/g, " ").trim();
+  return result;
+}
+var import_source, SPOKEN_CODE_LANGUAGES, COMMON_ABBREVIATION_EXPANSIONS, COMMON_ABBREVIATION_BY_UPPERCASE, COMMON_ABBREVIATION_PATTERN, SPOKEN_AS_WORD, CASE_SENSITIVE_WORD_ACRONYMS, SPEECH_BLANK_WORD;
+var init_speech_text = __esm({
+  "src/voices/speech-text.ts"() {
+    "use strict";
+    import_source = require("@ai-matrx/content-ir/source");
+    SPOKEN_CODE_LANGUAGES = /* @__PURE__ */ new Set([
+      "javascript",
+      "js",
+      "typescript",
+      "ts",
+      "python",
+      "py",
+      "java",
+      "csharp",
+      "cs",
+      "cpp",
+      "c++",
+      "c",
+      "go",
+      "rust",
+      "php",
+      "ruby",
+      "swift",
+      "kotlin",
+      "scala",
+      "sql",
+      "bash",
+      "shell",
+      "powershell",
+      "yaml",
+      "yml",
+      "json",
+      "xml",
+      "html",
+      "css",
+      "markdown",
+      "md"
+    ]);
+    COMMON_ABBREVIATION_EXPANSIONS = {
+      AI: "Artificial Intelligence",
+      API: "Application Programming Interface",
+      HTTP: "Hypertext Transfer Protocol",
+      HTTPS: "Hypertext Transfer Protocol Secure",
+      URL: "Uniform Resource Locator",
+      URI: "Uniform Resource Identifier",
+      JSON: "JavaScript Object Notation",
+      XML: "eXtensible Markup Language",
+      CSS: "Cascading Style Sheets",
+      HTML: "Hypertext Markup Language",
+      JS: "JavaScript",
+      TS: "TypeScript",
+      SQL: "Structured Query Language",
+      DB: "Database",
+      UI: "User Interface",
+      UX: "User Experience",
+      SEO: "Search Engine Optimization",
+      SDK: "Software Development Kit",
+      CLI: "Command Line Interface",
+      IDE: "Integrated Development Environment",
+      JWT: "JSON Web Token",
+      OAuth: "Open Authorization",
+      REST: "Representational State Transfer",
+      CRUD: "Create Read Update Delete",
+      MVC: "Model View Controller",
+      SPA: "Single Page Application",
+      SSR: "Server Side Rendering",
+      CSR: "Client Side Rendering",
+      PWA: "Progressive Web App",
+      DOM: "Document Object Model",
+      BOM: "Browser Object Model",
+      CDN: "Content Delivery Network",
+      CMS: "Content Management System",
+      ERP: "Enterprise Resource Planning",
+      CRM: "Customer Relationship Management",
+      SaaS: "Software as a Service",
+      PaaS: "Platform as a Service",
+      IaaS: "Infrastructure as a Service",
+      VPN: "Virtual Private Network",
+      LAN: "Local Area Network",
+      WAN: "Wide Area Network",
+      TCP: "Transmission Control Protocol",
+      UDP: "User Datagram Protocol",
+      IP: "Internet Protocol",
+      DNS: "Domain Name System",
+      FTP: "File Transfer Protocol",
+      SMTP: "Simple Mail Transfer Protocol",
+      POP3: "Post Office Protocol version 3",
+      IMAP: "Internet Message Access Protocol"
+    };
+    COMMON_ABBREVIATION_BY_UPPERCASE = Object.fromEntries(
+      Object.keys(COMMON_ABBREVIATION_EXPANSIONS).map(
+        (abbreviation) => [abbreviation.toUpperCase(), abbreviation]
+      )
+    );
+    COMMON_ABBREVIATION_PATTERN = new RegExp(
+      `\\b(${Object.keys(COMMON_ABBREVIATION_EXPANSIONS).sort((a, b) => b.length - a.length).map(escapeRegExp).join("|")})(['\u2019]s|s)?\\b`,
+      "gi"
+    );
+    SPOKEN_AS_WORD = /* @__PURE__ */ new Set([
+      "JSON",
+      "OAuth",
+      "REST",
+      "CRUD",
+      "DOM",
+      "BOM",
+      "SaaS",
+      "PaaS",
+      "IaaS",
+      "LAN",
+      "WAN"
+    ]);
+    CASE_SENSITIVE_WORD_ACRONYMS = /* @__PURE__ */ new Set([
+      "REST",
+      "CRUD",
+      "SPA",
+      "DOM",
+      "BOM",
+      "LAN",
+      "WAN"
+    ]);
+    SPEECH_BLANK_WORD = "blank";
+  }
+});
+
+// src/voices/tts-config.ts
+function resolveVoiceId(userVoiceId, purpose) {
+  const v = (userVoiceId ?? "").trim();
+  if (v && v !== LEGACY_DEFAULT_VOICE_ID) return v;
+  return purpose === "reading" ? READING_VOICE_ID : ASSISTANT_VOICE_ID;
+}
+function resolveSpeed(userSpeed) {
+  if (typeof userSpeed === "number" && userSpeed >= TTS_SPEED_MIN && userSpeed <= TTS_SPEED_MAX) {
+    return userSpeed;
+  }
+  return TTS_DEFAULT_SPEED;
+}
+var TTS_MODEL_ID, CARTESIA_API_VERSION, READING_VOICE_ID, ASSISTANT_VOICE_ID, LEGACY_DEFAULT_VOICE_ID, TTS_SPEED_MIN, TTS_SPEED_MAX, TTS_DEFAULT_SPEED, TTS_DEFAULT_VOLUME, TTS_PLAYBACK_BUFFER_SEC;
+var init_tts_config = __esm({
+  "src/voices/tts-config.ts"() {
+    "use strict";
+    TTS_MODEL_ID = "sonic-3.5";
+    CARTESIA_API_VERSION = "2026-08-14";
+    READING_VOICE_ID = "db6b0ed5-d5d3-463d-ae85-518a07d3c2b4";
+    ASSISTANT_VOICE_ID = "47c38ca4-5f35-497b-b1a3-415245fb35e1";
+    LEGACY_DEFAULT_VOICE_ID = "156fb8d2-335b-4950-9cb3-a2d33befec77";
+    TTS_SPEED_MIN = 0.6;
+    TTS_SPEED_MAX = 1.5;
+    TTS_DEFAULT_SPEED = 1.2;
+    TTS_DEFAULT_VOLUME = 1;
+    TTS_PLAYBACK_BUFFER_SEC = 0.7;
+  }
+});
+
+// src/speech/cartesia-socket.ts
+function isCartesiaAuthError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return /\b(401|403)\b|unauthorized|forbidden|invalid.*token|expired.*token|authentication/i.test(message);
+}
+async function reportFailure(failure) {
+  const report = speechPorts().reportProviderFailure;
+  if (!report) return null;
+  try {
+    return await report(failure);
+  } catch {
+    return null;
+  }
+}
+function decodeBase64(value) {
+  const decoded = atob(value);
+  const bytes = new Uint8Array(decoded.length);
+  for (let index = 0; index < decoded.length; index += 1) {
+    bytes[index] = decoded.charCodeAt(index);
+  }
+  return bytes;
+}
+function toNativeVoice(voice) {
+  return { id: voice.id };
+}
+async function buildConnectedSocket(token, options) {
+  const client = new import_client.Cartesia({ token });
+  const native = await client.tts.websocket({
+    headers: { "Cartesia-Version": CARTESIA_API_VERSION }
+  });
+  await native.connect();
+  const closeListeners = /* @__PURE__ */ new Set();
+  native.socket.addEventListener("close", () => {
+    for (const listener of closeListeners) listener();
+  });
+  return {
+    ws: new CartesiaV4Socket(native, options),
+    ctx: {
+      on: (_event, listener) => {
+        closeListeners.add(listener);
+      }
+    }
+  };
+}
+async function connectCartesiaTts(options) {
+  const requested = { ...DEFAULTS, ...options };
+  if (requested.container !== "raw") {
+    throw new Error("Cartesia WebSocket playback requires the raw audio container.");
+  }
+  if (requested.encoding !== "pcm_f32le") {
+    throw new Error("Cartesia browser playback requires pcm_f32le audio.");
+  }
+  const sampleRates = [8e3, 16e3, 22050, 24e3, 44100, 48e3];
+  if (!sampleRates.includes(requested.sampleRate)) {
+    throw new Error(`Unsupported Cartesia sample rate: ${requested.sampleRate}`);
+  }
+  const resolved = requested;
+  const getToken = requirePort("getCartesiaToken");
+  const token = await getToken();
+  try {
+    try {
+      return await buildConnectedSocket(token, resolved);
+    } catch (error) {
+      if (!isCartesiaAuthError(error)) throw error;
+      speechPorts().invalidateCartesiaToken?.(token);
+      const refreshed = await getToken({ forceRefresh: true }).catch(
+        (mintError) => {
+          throw new BrokerMintFailure(mintError);
+        }
+      );
+      return await buildConnectedSocket(refreshed, resolved);
+    }
+  } catch (error) {
+    if (error instanceof BrokerMintFailure) throw error.cause;
+    throw await reportCartesiaConnectFailure(error);
+  }
+}
+async function reportCartesiaConnectFailure(error) {
+  const raw = error instanceof Error ? error.message : typeof error === "object" && error && "message" in error ? String(error.message) : "";
+  const status = /\b([45]\d\d)\b/.exec(raw)?.[1];
+  const failure = {
+    provider: "cartesia",
+    status_code: status ? Number(status) : null,
+    message: raw || "Cartesia WebSocket connection failed"
+  };
+  const verdict = await reportFailure(failure);
+  return new ProviderSessionError(
+    failure,
+    verdict,
+    raw || "Could not connect to the speech service.",
+    { cause: error }
+  );
+}
+var import_client, ProviderSessionError, CartesiaAudioSource, DEFAULTS, CartesiaV4Socket, BrokerMintFailure;
+var init_cartesia_socket = __esm({
+  "src/speech/cartesia-socket.ts"() {
+    "use strict";
+    import_client = require("@cartesia/cartesia-js/client");
+    init_tts_config();
+    init_configure();
+    ProviderSessionError = class extends Error {
+      name = "ProviderSessionError";
+      provider;
+      retryable;
+      errorType;
+      reported;
+      constructor(failure, verdict, fallbackMessage, options) {
+        super(verdict?.user_message || fallbackMessage, options);
+        this.provider = failure.provider;
+        this.retryable = verdict ? verdict.retryable : true;
+        this.errorType = verdict?.error_type ?? failure.error_type ?? null;
+        this.reported = verdict !== null;
+      }
+    };
+    CartesiaAudioSource = class {
+      sampleRate;
+      #chunks = [];
+      #done = false;
+      #waiter = null;
+      constructor(sampleRate) {
+        this.sampleRate = sampleRate;
+      }
+      durationToSampleCount(durationSecs) {
+        return Math.ceil(durationSecs * this.sampleRate);
+      }
+      push(bytes) {
+        const sampleCount = Math.floor(bytes.byteLength / Float32Array.BYTES_PER_ELEMENT);
+        const samples = new Float32Array(sampleCount);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        for (let index = 0; index < sampleCount; index += 1) {
+          samples[index] = view.getFloat32(index * Float32Array.BYTES_PER_ELEMENT, true);
+        }
+        this.#chunks.push(samples);
+        this.#wake();
+      }
+      finish() {
+        this.#done = true;
+        this.#wake();
+      }
+      async read(destination) {
+        let written = 0;
+        while (written < destination.length) {
+          while (this.#chunks.length === 0 && !this.#done) {
+            await new Promise((resolve) => {
+              this.#waiter = resolve;
+            });
+          }
+          if (this.#chunks.length === 0) break;
+          const chunk = this.#chunks[0];
+          const count = Math.min(chunk.length, destination.length - written);
+          destination.set(chunk.subarray(0, count), written);
+          written += count;
+          if (count === chunk.length) {
+            this.#chunks.shift();
+          } else {
+            this.#chunks[0] = chunk.subarray(count);
+          }
+        }
+        return written;
+      }
+      #wake() {
+        this.#waiter?.();
+        this.#waiter = null;
+      }
+    };
+    DEFAULTS = {
+      container: "raw",
+      encoding: "pcm_f32le",
+      sampleRate: 44100
+    };
+    CartesiaV4Socket = class {
+      #native;
+      #options;
+      #sources = /* @__PURE__ */ new Map();
+      #listeners = /* @__PURE__ */ new Map();
+      /** Set when the provider refused this account and reconnecting cannot help. */
+      #refused = null;
+      constructor(native, options) {
+        this.#native = native;
+        this.#options = options;
+        native.on("error", () => {
+        });
+        native.on("event", (event) => {
+          const contextId = "context_id" in event ? event.context_id : void 0;
+          if (event.type === "error") {
+            const listeners3 = contextId ? this.#listeners.get(contextId) : void 0;
+            if (contextId) {
+              this.#sources.get(contextId)?.finish();
+              this.#sources.delete(contextId);
+              this.#listeners.delete(contextId);
+            } else {
+              for (const source2 of this.#sources.values()) source2.finish();
+              this.#sources.clear();
+              this.#listeners.clear();
+            }
+            void this.#reportProviderError(event, listeners3);
+            return;
+          }
+          if (!contextId) return;
+          const source = this.#sources.get(contextId);
+          if (event.type === "chunk" && source) {
+            source.push(event.audio ?? decodeBase64(event.data));
+          } else if (event.type === "done") {
+            source?.finish();
+          }
+          const serialized = JSON.stringify(event);
+          for (const listener of this.#listeners.get(contextId) ?? []) {
+            listener(serialized);
+          }
+          if (event.type === "done") {
+            this.#sources.delete(contextId);
+            this.#listeners.delete(contextId);
+          }
+        });
+      }
+      /**
+       * Browser-held session: the server never sees this provider error unless we
+       * report it. Listeners get the event with `message` replaced by the server's
+       * sentence, and the person sees it as a toast.
+       */
+      async #reportProviderError(event, listeners3) {
+        const failure = {
+          provider: "cartesia",
+          status_code: event.status_code ?? null,
+          error_type: event.error_code ?? event.title ?? null,
+          message: event.message || event.title || "Cartesia TTS error"
+        };
+        const verdict = await reportFailure(failure);
+        const error = new ProviderSessionError(failure, verdict, failure.message);
+        if (!error.retryable) this.#refused = error;
+        const delivered = JSON.stringify({
+          ...event,
+          message: error.message,
+          retryable: error.retryable
+        });
+        for (const listener of listeners3 ?? []) listener(delivered);
+        speechPorts().notifyError?.("Speech stopped", error.message);
+      }
+      async send(request) {
+        if (this.#refused) throw this.#refused;
+        const contextId = request.contextId ?? crypto.randomUUID();
+        let source = this.#sources.get(contextId);
+        if (!source) {
+          source = new CartesiaAudioSource(this.#options.sampleRate);
+          this.#sources.set(contextId, source);
+        }
+        await this.#native.send({
+          context_id: contextId,
+          model_id: request.modelId,
+          transcript: request.transcript,
+          voice: toNativeVoice(request.voice),
+          output_format: {
+            container: this.#options.container,
+            encoding: this.#options.encoding,
+            sample_rate: this.#options.sampleRate
+          },
+          language: request.language,
+          continue: request.continue,
+          add_timestamps: request.addTimestamps,
+          add_phoneme_timestamps: request.addPhonemeTimestamps,
+          max_buffer_delay_ms: request.maxBufferDelayMs,
+          generation_config: request.generationConfig
+        });
+        return {
+          source,
+          on: (_event, listener) => {
+            const listeners3 = this.#listeners.get(contextId) ?? /* @__PURE__ */ new Set();
+            listeners3.add(listener);
+            this.#listeners.set(contextId, listeners3);
+          }
+        };
+      }
+      continue(request) {
+        return this.send(request);
+      }
+      disconnect() {
+        for (const source of this.#sources.values()) source.finish();
+        this.#sources.clear();
+        this.#listeners.clear();
+        this.#native.close();
+      }
+    };
+    BrokerMintFailure = class extends Error {
+      constructor(cause) {
+        super("broker mint failed");
+        this.cause = cause;
+      }
+      cause;
+    };
+  }
+});
+
+// src/speech/output-sink.ts
+function mediaElementSinkSupported() {
+  return typeof HTMLMediaElement !== "undefined" && "setSinkId" in HTMLMediaElement.prototype;
+}
+function audioContextSinkSupported() {
+  if (typeof window === "undefined") return false;
+  const Ctor = window.AudioContext || window.webkitAudioContext;
+  return !!Ctor && "setSinkId" in Ctor.prototype;
+}
+function outputSelectionSupported() {
+  return mediaElementSinkSupported() || audioContextSinkSupported();
+}
+function getPreferredOutputDeviceId() {
+  return state.deviceId;
+}
+function setPreferredOutputDeviceId(deviceId) {
+  if (state.deviceId === deviceId) return;
+  state.deviceId = deviceId;
+  for (const l of state.listeners) {
+    try {
+      l(deviceId);
+    } catch {
+    }
+  }
+}
+function subscribeOutputDevice(listener) {
+  state.listeners.add(listener);
+  return () => {
+    state.listeners.delete(listener);
+  };
+}
+async function applySinkToMediaElement(el) {
+  if (!el) return;
+  if (!mediaElementSinkSupported()) return;
+  const target = state.deviceId;
+  const elWithSink = el;
+  if (elWithSink.sinkId === target) return;
+  try {
+    await elWithSink.setSinkId?.(target);
+  } catch (err) {
+    console.error(
+      "[audioOutputSink] setSinkId on media element failed \u2014 falling back to the system default device. Requested device may be unavailable.",
+      { deviceId: target, error: err }
+    );
+  }
+}
+var state;
+var init_output_sink = __esm({
+  "src/speech/output-sink.ts"() {
+    "use strict";
+    state = {
+      deviceId: "",
+      listeners: /* @__PURE__ */ new Set()
+    };
+  }
+});
+
+// src/speech/sink-aware-player.ts
+function defaultCreateContext(sampleRate) {
+  return new AudioContext({ sampleRate });
+}
+var SinkAwarePlayer;
+var init_sink_aware_player = __esm({
+  "src/speech/sink-aware-player.ts"() {
+    "use strict";
+    init_output_sink();
+    init_unlock();
+    SinkAwarePlayer = class {
+      #context = null;
+      #startNextPlaybackAt = 0;
+      #bufferDuration;
+      #createContext;
+      #unsubscribeSink = null;
+      /**
+       * True when `#context` is the app's SHARED gesture-unlocked context
+       * (features/audio/unlock.ts) rather than a private per-utterance one.
+       * Shared mode exists for iOS/WebKit, where a context created outside a
+       * user gesture starts `suspended` forever — our audio starts from
+       * websocket callbacks, so per-utterance contexts were silent on iPhone.
+       * In shared mode the utterance plays through a per-utterance GainNode and
+       * `stop()` tears that down instead of closing the context.
+       */
+      #sharedMode = false;
+      #utteranceGain = null;
+      #liveSources = /* @__PURE__ */ new Set();
+      #stopped = false;
+      constructor({ bufferDuration, createContext }) {
+        this.#bufferDuration = bufferDuration;
+        this.#createContext = createContext ?? defaultCreateContext;
+      }
+      /**
+       * Play audio from a source. Resolves when the audio has finished playing.
+       *
+       * Prefers the app's shared gesture-unlocked context (required for sound on
+       * iOS/WebKit); otherwise builds a fresh AudioContext per call (matching the
+       * SDK). Either way the output is routed to the user's preferred device and
+       * re-routed live on device change. Web Audio resamples per-buffer, so the
+       * shared context's hardware rate plays 44.1k sources correctly.
+       */
+      async play(source) {
+        this.#startNextPlaybackAt = 0;
+        this.#stopped = false;
+        this.#detachSinkSubscription();
+        const shared = this.#createContext === defaultCreateContext ? getUnlockedAudioContext() : null;
+        const context = shared ?? this.#createContext(source.sampleRate);
+        this.#sharedMode = shared !== null;
+        this.#context = context;
+        if (this.#sharedMode) {
+          const ctx = shared;
+          this.#utteranceGain = ctx.createGain();
+          this.#utteranceGain.connect(ctx.destination);
+        } else {
+          this.#utteranceGain = null;
+        }
+        this.#attachSinkRouting(context);
+        if (context.state !== "running") {
+          try {
+            await context.resume();
+          } catch {
+          }
+          if (context.state !== "running") {
+            throw new Error(
+              "The browser blocked audio output \u2014 tap the play button to start sound."
+            );
+          }
+        }
+        try {
+          const buffer = new Float32Array(
+            source.durationToSampleCount(this.#bufferDuration)
+          );
+          const plays = [];
+          while (true) {
+            const read = await source.read(buffer);
+            const playableAudio = buffer.subarray(0, read);
+            plays.push(this.#playBuffer(playableAudio, source.sampleRate));
+            if (read < buffer.length) break;
+          }
+          await Promise.all(plays);
+        } finally {
+          this.#detachSinkSubscription();
+        }
+      }
+      /** Suspend playback. Throws before the first play (contract parity). */
+      async pause() {
+        const context = this.#requireContext();
+        if (this.#sharedMode && this.#stopped) return;
+        await context.suspend();
+      }
+      /** Resume suspended playback. Throws before the first play. */
+      async resume() {
+        const context = this.#requireContext();
+        if (this.#sharedMode && this.#stopped) return;
+        await context.resume();
+      }
+      /** Pause when running, resume otherwise. Throws before the first play. */
+      async toggle() {
+        if (this.#requireContext().state === "running") {
+          await this.pause();
+        } else {
+          await this.resume();
+        }
+      }
+      /**
+       * Stop playback. Throws before the first play (contract parity); a repeat
+       * stop is a silent no-op.
+       *
+       * Owned-context mode closes the context (the SDK contract). Shared mode
+       * NEVER closes the app-wide unlocked context — it stops this utterance's
+       * scheduled sources and tears down its GainNode, and resumes the context
+       * if this utterance had paused it (a suspended shared context would mute
+       * the NEXT utterance too).
+       */
+      async stop() {
+        const context = this.#requireContext();
+        this.#detachSinkSubscription();
+        if (this.#sharedMode) {
+          if (this.#stopped) return;
+          this.#stopped = true;
+          for (const node of this.#liveSources) {
+            try {
+              node.stop();
+            } catch {
+            }
+          }
+          this.#liveSources.clear();
+          try {
+            this.#utteranceGain?.disconnect();
+          } catch {
+          }
+          this.#utteranceGain = null;
+          if (context.state === "suspended") {
+            await context.resume().catch(() => {
+            });
+          }
+          return;
+        }
+        if (context.state === "closed") return;
+        await context.close();
+      }
+      #requireContext() {
+        if (!this.#context) {
+          throw new Error("AudioContext not initialized.");
+        }
+        return this.#context;
+      }
+      /**
+       * Route `context` to the current preferred output device and keep it
+       * routed while it lives. Feature-detected: on Firefox/Safari (no
+       * `AudioContext.setSinkId`) this is a clean no-op and audio plays on the
+       * system default device.
+       */
+      #attachSinkRouting(context) {
+        if (typeof context.setSinkId !== "function") return;
+        const applySink = (deviceId) => {
+          if (this.#context !== context || context.state === "closed") return;
+          context.setSinkId?.(deviceId).catch((err) => {
+            console.error(
+              "[SinkAwarePlayer] setSinkId failed \u2014 playback continues on the system default device. The requested device may be unavailable.",
+              { deviceId, error: err }
+            );
+          });
+        };
+        const initial = getPreferredOutputDeviceId();
+        if (initial) applySink(initial);
+        this.#unsubscribeSink = subscribeOutputDevice(applySink);
+      }
+      #detachSinkSubscription() {
+        this.#unsubscribeSink?.();
+        this.#unsubscribeSink = null;
+      }
+      async #playBuffer(buf, sampleRate) {
+        const context = this.#requireContext();
+        if (buf.length === 0) return;
+        if (this.#sharedMode && this.#stopped) return;
+        const startAt = this.#startNextPlaybackAt;
+        const duration = buf.length / sampleRate;
+        this.#startNextPlaybackAt = duration + Math.max(context.currentTime, this.#startNextPlaybackAt);
+        const sourceNode = context.createBufferSource();
+        const audioBuffer = context.createBuffer(1, buf.length, sampleRate);
+        audioBuffer.getChannelData(0).set(buf);
+        sourceNode.buffer = audioBuffer;
+        sourceNode.connect(this.#utteranceGain ?? context.destination);
+        sourceNode.start(startAt);
+        if (this.#sharedMode) this.#liveSources.add(sourceNode);
+        await new Promise((resolve) => {
+          sourceNode.onended = () => {
+            this.#liveSources.delete(sourceNode);
+            resolve();
+          };
+        });
+      }
+    };
+  }
+});
+
+// src/speech/cartesia-adapter.ts
+var cartesia_adapter_exports = {};
+__export(cartesia_adapter_exports, {
+  buildGenerationConfig: () => buildGenerationConfig,
+  cartesiaAdapter: () => cartesiaAdapter
+});
+function buildGenerationConfig(opts) {
+  const cfg = {
+    speed: resolveSpeed(opts?.speed),
+    volume: opts?.volume ?? TTS_DEFAULT_VOLUME
+  };
+  if (opts?.emotion) cfg.emotion = opts.emotion.toLowerCase();
+  return cfg;
+}
+async function resolveText(item) {
+  let pronunciations = [];
+  try {
+    pronunciations = await speechPorts().resolvePronunciations?.(item) ?? [];
+  } catch {
+    pronunciations = [];
+  }
+  const processMarkdown = item.processMarkdown ?? true;
+  return processMarkdown ? parseMarkdownToText(item.text, pronunciations.length ? { pronunciations } : void 0) : item.text;
+}
+var cartesiaAdapter;
+var init_cartesia_adapter = __esm({
+  "src/speech/cartesia-adapter.ts"() {
+    "use strict";
+    init_speech_text();
+    init_tts_config();
+    init_cartesia_socket();
+    init_configure();
+    init_sink_aware_player();
+    cartesiaAdapter = {
+      provider: "cartesia",
+      async start(item, cb) {
+        cb.onLoading();
+        const overrides = item.cartesia ?? {};
+        const settings = await requirePort("resolveVoiceSettings")();
+        const voice = {
+          voiceId: overrides.voiceId ?? resolveVoiceId(settings.voice, overrides.purpose ?? "assistant"),
+          language: overrides.language ?? settings.language,
+          speed: overrides.speed ?? settings.speed,
+          emotion: settings.emotion
+        };
+        const processed = (await resolveText(item)).trim();
+        if (!processed) {
+          throw new Error("Nothing to speak");
+        }
+        const { ws } = await connectCartesiaTts();
+        let stopped = false;
+        const player = new SinkAwarePlayer({
+          bufferDuration: TTS_PLAYBACK_BUFFER_SEC
+        });
+        const cleanup = () => {
+          try {
+            ws.disconnect();
+          } catch {
+          }
+        };
+        const response = await ws.send({
+          modelId: TTS_MODEL_ID,
+          voice: { mode: "id", id: voice.voiceId },
+          language: voice.language || "en",
+          transcript: processed,
+          generationConfig: buildGenerationConfig({ speed: voice.speed, emotion: voice.emotion ?? null })
+        });
+        if (stopped) {
+          cleanup();
+          throw new Error("Playback cancelled before it started");
+        }
+        cb.onPlaying();
+        player.play(response.source).then(() => {
+          if (stopped) return;
+          cleanup();
+          cb.onEnded();
+        }).catch((err) => {
+          if (stopped) return;
+          cleanup();
+          cb.onError(err instanceof Error ? err.message : "Playback failed");
+        });
+        return {
+          pause: () => player.pause().catch(() => {
+          }),
+          resume: () => player.resume().catch(() => {
+          }),
+          stop: async () => {
+            stopped = true;
+            try {
+              await player.stop();
+            } catch {
+            }
+            cleanup();
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/speech.ts
+var speech_exports = {};
+__export(speech_exports, {
+  CartesiaAudioSource: () => CartesiaAudioSource,
+  ProviderSessionError: () => ProviderSessionError,
+  SinkAwarePlayer: () => SinkAwarePlayer,
+  applySinkToMediaElement: () => applySinkToMediaElement,
+  audioContextSinkSupported: () => audioContextSinkSupported,
+  buildGenerationConfig: () => buildGenerationConfig,
+  cartesiaAdapter: () => cartesiaAdapter,
+  claimPlayback: () => claimPlayback,
+  clearPlayback: () => clearPlayback,
+  configureSpeech: () => configureSpeech,
+  connectCartesiaTts: () => connectCartesiaTts,
+  enqueuePlayback: () => enqueuePlayback,
+  getActivePlaybackHolderId: () => getActivePlaybackHolderId,
+  getPlaybackSnapshot: () => getPlaybackSnapshot,
+  getPreferredOutputDeviceId: () => getPreferredOutputDeviceId,
+  getPrimedMediaElement: () => getPrimedMediaElement,
+  getUnlockedAudioContext: () => getUnlockedAudioContext,
+  installAudioUnlockListeners: () => installAudioUnlockListeners,
+  isCartesiaAuthError: () => isCartesiaAuthError,
+  isPlaybackHeld: () => isPlaybackHeld,
+  mediaElementSinkSupported: () => mediaElementSinkSupported,
+  outputSelectionSupported: () => outputSelectionSupported,
+  pausePlayback: () => pausePlayback,
+  playPlaybackItem: () => playPlaybackItem,
+  primeAudioOutput: () => primeAudioOutput,
+  releasePlayback: () => releasePlayback,
+  removePlaybackItem: () => removePlaybackItem,
+  resetPlaybackForTests: () => resetPlaybackForTests,
+  resetSpeechPortsForTests: () => resetSpeechPortsForTests,
+  resolveSpeakEngine: () => resolveSpeakEngine,
+  resumePlayback: () => resumePlayback,
+  setPlaybackRate: () => setPlaybackRate,
+  setPreferredOutputDeviceId: () => setPreferredOutputDeviceId,
+  skipPlayback: () => skipPlayback,
+  speak: () => speak,
+  subscribeOutputDevice: () => subscribeOutputDevice,
+  subscribePlayback: () => subscribePlayback,
+  subscribePlaybackLock: () => subscribePlaybackLock
+});
+module.exports = __toCommonJS(speech_exports);
+init_configure();
+
+// src/speech/speak.ts
+init_configure();
+
+// src/speech/playback-queue.ts
+init_configure();
+init_unlock();
+
+// src/speech/playback-lock.ts
+var current = null;
+var listeners = /* @__PURE__ */ new Set();
+function notify(preempted) {
+  const event = { current, preempted };
+  for (const cb of listeners) {
+    try {
+      cb(event);
+    } catch (err) {
+      console.error("[playbackLock] listener threw:", err);
+    }
+  }
+}
+function claimPlayback(holder) {
+  if (current && current.id === holder.id) {
+    current = holder;
+    notify(null);
+    return;
+  }
+  let preempted = null;
+  if (current) {
+    preempted = current;
+    current = null;
+    try {
+      preempted.stop();
+    } catch (err) {
+      console.error(
+        `[playbackLock] previous holder "${preempted.id}" stop() threw during takeover:`,
+        err
+      );
+    }
+  }
+  current = holder;
+  notify(preempted);
+}
+function releasePlayback(id) {
+  if (current?.id === id) {
+    current = null;
+    notify(null);
+  }
+}
+function getActivePlaybackHolderId() {
+  return current?.id ?? null;
+}
+function isPlaybackHeld() {
+  return current !== null;
+}
+function subscribePlaybackLock(cb) {
+  listeners.add(cb);
+  return () => {
+    listeners.delete(cb);
+  };
+}
+
+// src/speech/playback-queue.ts
+var QUEUE_HOLDER_ID = "playback-queue";
+var adapterCache = /* @__PURE__ */ new Map();
+async function getAdapter(provider) {
+  const cached = adapterCache.get(provider);
+  if (cached) return cached;
+  let adapter;
+  const registered = speechPorts().adapters?.[provider];
+  if (registered) {
+    adapter = await registered();
+  } else if (provider === "cartesia") {
+    adapter = (await Promise.resolve().then(() => (init_cartesia_adapter(), cartesia_adapter_exports))).cartesiaAdapter;
+  } else {
+    throw new Error(`No speech engine "${provider}" is set up in this app.`);
+  }
+  adapterCache.set(provider, adapter);
+  return adapter;
+}
+var items = [];
+var currentId = null;
+var rate = 1;
+var active = null;
+var runToken = 0;
+var listeners2 = /* @__PURE__ */ new Set();
+var seq = 0;
+function nextId() {
+  seq += 1;
+  return `pb_${Date.now().toString(36)}_${seq}`;
+}
+function snapshot() {
+  return { items: items.map((i) => ({ ...i })), currentId, rate };
+}
+function notify2() {
+  const snap = snapshot();
+  listeners2.forEach((l) => {
+    try {
+      l(snap);
+    } catch (err) {
+      console.error("[playbackQueue] listener error", err);
+    }
+  });
+}
+function patch(id, changes) {
+  items = items.map((i) => i.id === id ? { ...i, ...changes } : i);
+}
+function isBusy() {
+  return active !== null || currentId !== null;
+}
+async function startItem(id) {
+  const item = items.find((i) => i.id === id);
+  if (!item) return;
+  claimPlayback({
+    id: QUEUE_HOLDER_ID,
+    label: "Playback queue",
+    stop: forcePreemptFromLock
+  });
+  if (active) {
+    const prev = active;
+    active = null;
+    try {
+      await prev.stop();
+    } catch {
+    }
+  }
+  const token = ++runToken;
+  currentId = id;
+  patch(id, { status: "loading", error: void 0 });
+  notify2();
+  const stale = () => token !== runToken;
+  const beforeStart = speechPorts().beforeStart;
+  if (beforeStart) {
+    try {
+      await beforeStart(item);
+    } catch (err) {
+      if (stale()) return;
+      patch(id, {
+        status: "error",
+        error: speechPorts().describeStartRefusal?.(err) ?? (err instanceof Error ? err.message : "Playback failed")
+      });
+      active = null;
+      void advance();
+      return;
+    }
+    if (stale()) return;
+  }
+  try {
+    const adapter = await getAdapter(item.provider);
+    if (stale()) return;
+    const handle = await adapter.start(
+      item,
+      {
+        onLoading: () => {
+          if (stale()) return;
+          patch(id, { status: "loading" });
+          notify2();
+        },
+        onPlaying: () => {
+          if (stale()) return;
+          patch(id, { status: "playing" });
+          notify2();
+        },
+        onEnded: () => {
+          if (stale()) return;
+          patch(id, { status: "done" });
+          active = null;
+          void advance();
+        },
+        onError: (message) => {
+          if (stale()) return;
+          patch(id, { status: "error", error: message });
+          active = null;
+          void advance();
+        }
+      },
+      rate
+    );
+    if (stale()) {
+      try {
+        await handle.stop();
+      } catch {
+      }
+      return;
+    }
+    active = handle;
+  } catch (err) {
+    if (stale()) return;
+    patch(id, {
+      status: "error",
+      error: err instanceof Error ? err.message : "Playback failed"
+    });
+    active = null;
+    void advance();
+  }
+}
+async function advance() {
+  const next = items.find((i) => i.status === "queued");
+  if (next) {
+    await startItem(next.id);
+  } else {
+    currentId = null;
+    releasePlayback(QUEUE_HOLDER_ID);
+    notify2();
+  }
+}
+function forcePreemptFromLock() {
+  runToken += 1;
+  if (active) {
+    const prev = active;
+    active = null;
+    try {
+      void prev.stop();
+    } catch {
+    }
+  }
+  items = [];
+  currentId = null;
+  notify2();
+}
+function enqueuePlayback(request) {
+  speechPorts().onEngage?.();
+  primeAudioOutput();
+  const id = nextId();
+  const item = {
+    ...request,
+    id,
+    status: "queued",
+    enqueuedAtMs: Date.now()
+  };
+  items = [...items, item];
+  notify2();
+  if (!isBusy()) {
+    void startItem(id);
+  }
+  return { id };
+}
+async function pausePlayback() {
+  if (!active || !currentId) return;
+  await active.pause();
+  patch(currentId, { status: "paused" });
+  notify2();
+}
+async function resumePlayback() {
+  speechPorts().onEngage?.();
+  primeAudioOutput();
+  if (!active || !currentId) return;
+  await active.resume();
+  patch(currentId, { status: "playing" });
+  notify2();
+}
+async function skipPlayback() {
+  if (currentId) patch(currentId, { status: "done" });
+  if (active) {
+    const prev = active;
+    active = null;
+    try {
+      await prev.stop();
+    } catch {
+    }
+  }
+  await advance();
+}
+async function playPlaybackItem(id) {
+  speechPorts().onEngage?.();
+  primeAudioOutput();
+  const item = items.find((i) => i.id === id);
+  if (!item) return;
+  if (item.status === "done" || item.status === "error") {
+    patch(id, { status: "queued", error: void 0 });
+  }
+  if (currentId && currentId !== id) {
+    patch(currentId, { status: "done" });
+  }
+  await startItem(id);
+}
+async function removePlaybackItem(id) {
+  if (id === currentId) {
+    await skipPlayback();
+    items = items.filter((i) => i.id !== id);
+    notify2();
+    return;
+  }
+  items = items.filter((i) => i.id !== id);
+  notify2();
+}
+async function clearPlayback() {
+  runToken += 1;
+  if (active) {
+    const prev = active;
+    active = null;
+    try {
+      await prev.stop();
+    } catch {
+    }
+  }
+  items = [];
+  currentId = null;
+  releasePlayback(QUEUE_HOLDER_ID);
+  notify2();
+}
+function setPlaybackRate(value) {
+  rate = Math.max(0.25, Math.min(4, value));
+  active?.setRate?.(rate);
+  notify2();
+}
+function getPlaybackSnapshot() {
+  return snapshot();
+}
+function resetPlaybackForTests() {
+  runToken += 1;
+  active = null;
+  items = [];
+  currentId = null;
+  rate = 1;
+  adapterCache.clear();
+  releasePlayback(QUEUE_HOLDER_ID);
+}
+function subscribePlayback(listener) {
+  listeners2.add(listener);
+  listener(snapshot());
+  return () => {
+    listeners2.delete(listener);
+  };
+}
+
+// src/speech/speak.ts
+function resolveSpeakEngine(requested) {
+  return requested ?? speechPorts().defaultEngine ?? "cartesia";
+}
+function speak(request) {
+  const complete = (r) => speechPorts().completeRequest?.(r) ?? r;
+  if (request.sample) {
+    const { id: id2 } = enqueuePlayback(
+      complete({
+        text: request.text,
+        processMarkdown: false,
+        label: request.label,
+        provider: "catalog",
+        catalog: { sample: request.sample }
+      })
+    );
+    return { id: id2, engine: "catalog" };
+  }
+  const engine = resolveSpeakEngine(request.engine);
+  const common = {
+    text: request.text,
+    processMarkdown: request.processMarkdown,
+    label: request.label,
+    dictionarySurfaceKey: request.dictionarySurfaceKey
+  };
+  if (engine === "cartesia") {
+    const { id: id2 } = enqueuePlayback(
+      complete({
+        ...common,
+        provider: "cartesia",
+        cartesia: {
+          voiceId: request.voice,
+          language: request.language,
+          speed: request.speed,
+          purpose: request.purpose ?? "assistant"
+        }
+      })
+    );
+    return { id: id2, engine };
+  }
+  const { id } = enqueuePlayback(complete({ ...common, provider: engine, catalog: { voice: request.voice } }));
+  return { id, engine };
+}
+
+// src/speech.ts
+init_unlock();
+init_output_sink();
+init_sink_aware_player();
+init_cartesia_socket();
+init_cartesia_adapter();
+//# sourceMappingURL=speech.cjs.map