@mieweb/ui 0.11.0-dev.7 → 0.11.0-dev.9

package/dist/chunk-IZY4CMOO.js

@@ -0,0 +1,715 @@
+// src/components/AI/modelCache.ts
+var registered = /* @__PURE__ */ new Set();
+function registerModelServiceWorker(swUrl = "/ozwell-model-sw.js") {
+  if (typeof navigator === "undefined" || !("serviceWorker" in navigator))
+    return;
+  if (registered.has(swUrl)) return;
+  registered.add(swUrl);
+  navigator.serviceWorker.register(swUrl).then(
+    () => console.log("[modelCache] model service worker registered"),
+    (e) => {
+      registered.delete(swUrl);
+      console.warn(
+        "[modelCache] SW registration failed (models will still load, just not cached):",
+        e
+      );
+    }
+  );
+}
+
+// src/components/AI/ozwellChat.ts
+var DEFAULT_BASE = "https://api.ozwell.ai";
+var OLLAMA_BASE = "http://localhost:11434";
+var DEFAULTS = {
+  model: "gpt-4o-mini",
+  system: "You are Ozwell, a concise and helpful clinical assistant. Answer briefly and clearly.",
+  temperature: 0.7
+};
+function readWindowGlobal() {
+  if (typeof window === "undefined") return {};
+  const get = (w) => {
+    try {
+      return w?.__ozwell;
+    } catch {
+      return void 0;
+    }
+  };
+  return get(window) || get(window.parent) || get(window.top) || {};
+}
+function sanitizeConfig(o) {
+  if (!o || typeof o !== "object") return {};
+  const out = {};
+  for (const k of Object.keys(o)) {
+    if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
+    out[k] = o[k];
+  }
+  return out;
+}
+function readRaw() {
+  let stored = {};
+  try {
+    stored = sanitizeConfig(
+      JSON.parse(localStorage.getItem("ozwellConfig") || "{}")
+    );
+  } catch {
+  }
+  return { ...stored, ...sanitizeConfig(readWindowGlobal()) };
+}
+function getOzwellConfig() {
+  const c = readRaw();
+  const apiKey = c.apiKey || "";
+  const baseURL = c.baseURL || (apiKey === "ollama" ? OLLAMA_BASE : DEFAULT_BASE);
+  return {
+    baseURL,
+    apiKey,
+    model: c.model || DEFAULTS.model,
+    system: c.system ?? DEFAULTS.system,
+    // Coerce: temperature set via console/localStorage often arrives as a string; a string in the request
+    // body can be rejected by OpenAI-compatible servers. Fall back to the default if it's not a real number —
+    // and guard the empty/whitespace string explicitly, since Number('') is 0 (a valid-looking temperature)
+    // and would silently pin sampling to 0 instead of using the default.
+    temperature: c.temperature != null && String(c.temperature).trim() !== "" && Number.isFinite(Number(c.temperature)) ? Number(c.temperature) : DEFAULTS.temperature
+  };
+}
+function isOzwellConfigured() {
+  return !!getOzwellConfig().apiKey;
+}
+function toOzwellMessages(msgs) {
+  const out = [];
+  for (const m of msgs) {
+    if (m.role !== "user" && m.role !== "assistant") continue;
+    const text = (m.content || []).map((c) => c.text || "").join(" ").trim();
+    if (text) out.push({ role: m.role, content: text });
+  }
+  return out;
+}
+function withSystem(messages, system) {
+  if (!system || messages.some((m) => m.role === "system")) return messages;
+  return [{ role: "system", content: system }, ...messages];
+}
+function buildRequest(messages, cfg, stream) {
+  const msgs = typeof messages === "string" ? [{ role: "user", content: messages }] : messages;
+  return {
+    url: `${cfg.baseURL.replace(/\/$/, "")}/v1/chat/completions`,
+    headers: {
+      "Content-Type": "application/json",
+      // 'ollama' is a sentinel that points baseURL at the local Ollama server, not a real credential —
+      // don't send it as a Bearer token (some local OpenAI-compatible servers reject unexpected auth).
+      ...cfg.apiKey && cfg.apiKey !== "ollama" ? { Authorization: `Bearer ${cfg.apiKey}` } : {}
+    },
+    body: JSON.stringify({
+      model: cfg.model,
+      messages: withSystem(msgs, cfg.system),
+      temperature: cfg.temperature,
+      stream
+    })
+  };
+}
+function resolveConfig(opts) {
+  const cfg = { ...getOzwellConfig(), ...opts };
+  if (opts.apiKey && !opts.baseURL && !readRaw().baseURL) {
+    cfg.baseURL = cfg.apiKey === "ollama" ? OLLAMA_BASE : DEFAULT_BASE;
+  }
+  return cfg;
+}
+async function askOzwell(messages, opts = {}) {
+  const cfg = resolveConfig(opts);
+  const req = buildRequest(messages, cfg, false);
+  const res = await fetch(req.url, {
+    method: "POST",
+    headers: req.headers,
+    body: req.body,
+    signal: opts.signal
+  });
+  if (!res.ok) throw new Error(`Ozwell API ${res.status}: ${res.statusText}`);
+  const data = await res.json();
+  return (data?.choices?.[0]?.message?.content ?? "").trim();
+}
+async function askOzwellStream(messages, onToken, opts = {}) {
+  const cfg = resolveConfig(opts);
+  const req = buildRequest(messages, cfg, true);
+  const res = await fetch(req.url, {
+    method: "POST",
+    headers: req.headers,
+    body: req.body,
+    signal: opts.signal
+  });
+  if (!res.ok || !res.body)
+    throw new Error(`Ozwell API ${res.status}: ${res.statusText}`);
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let full = "";
+  const processEvent = (ev) => {
+    for (const line of ev.split(/\r?\n/)) {
+      if (!line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (payload === "[DONE]") return true;
+      try {
+        const json = JSON.parse(payload);
+        const delta = json?.choices?.[0]?.delta?.content || "";
+        if (delta) {
+          full += delta;
+          onToken(delta, full);
+        }
+      } catch {
+      }
+    }
+    return false;
+  };
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const events = buf.split(/\r?\n\r?\n/);
+      buf = events.pop() || "";
+      for (const ev of events) if (processEvent(ev)) return full;
+    }
+    buf += decoder.decode();
+    if (buf.trim()) processEvent(buf);
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    }
+  }
+  return full;
+}
+
+// src/components/AI/whisperTranscribe.ts
+var HF_HOST = "https://huggingface.co";
+var HF_PATH = "{model}/resolve/{revision}/";
+var R2_HOST = "https://pub-64db68afc2cb4e108ff06e7e583f09d1.r2.dev";
+function whisperHost() {
+  if (typeof window === "undefined") return R2_HOST;
+  const fromWin = (w) => {
+    try {
+      return w?.__ozwellWhisperHost;
+    } catch {
+      return void 0;
+    }
+  };
+  const win = fromWin(window) || fromWin(window.parent) || fromWin(window.top);
+  if (win) return win.replace(/\/$/, "");
+  try {
+    const h = JSON.parse(
+      localStorage.getItem("ozwellConfig") || "{}"
+    ).whisperHost;
+    if (h) return String(h).replace(/\/$/, "");
+  } catch {
+  }
+  return R2_HOST;
+}
+var SMALL_MODELS = {
+  tiny: "Xenova/whisper-tiny.en",
+  "tiny.en": "Xenova/whisper-tiny.en",
+  base: "Xenova/whisper-base.en",
+  "base.en": "Xenova/whisper-base.en",
+  small: "Xenova/whisper-small.en",
+  "small.en": "Xenova/whisper-small.en"
+};
+var GATE_MODEL = "Xenova/whisper-base.en";
+function whisperPref() {
+  if (typeof window === "undefined") return null;
+  const fromWin = (w) => {
+    try {
+      return w?.__ozwell?.whisper;
+    } catch {
+      return void 0;
+    }
+  };
+  const win = fromWin(window) || fromWin(window.parent) || fromWin(window.top);
+  if (win) return win;
+  try {
+    return JSON.parse(localStorage.getItem("ozwellConfig") || "{}").whisper || null;
+  } catch {
+    return null;
+  }
+}
+function whisperDevice() {
+  if (typeof window === "undefined") return null;
+  const fromWin = (w) => {
+    try {
+      return w?.__ozwell?.whisperDevice;
+    } catch {
+      return void 0;
+    }
+  };
+  const win = fromWin(window) || fromWin(window.parent) || fromWin(window.top);
+  if (win) return win;
+  try {
+    return JSON.parse(localStorage.getItem("ozwellConfig") || "{}").whisperDevice || null;
+  } catch {
+    return null;
+  }
+}
+function whisperDtype() {
+  if (typeof window === "undefined") return null;
+  const fromWin = (w) => {
+    try {
+      return w?.__ozwell?.whisperDtype;
+    } catch {
+      return void 0;
+    }
+  };
+  const win = fromWin(window) || fromWin(window.parent) || fromWin(window.top);
+  if (win) return win;
+  try {
+    return JSON.parse(localStorage.getItem("ozwellConfig") || "{}").whisperDtype || null;
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_TRANSFORMERS_URL = "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.8.1";
+function transformersUrl() {
+  try {
+    const w = window.__ozwellTransformersUrl;
+    if (w) return w;
+    const ls = localStorage.getItem("ozwellTransformersUrl");
+    if (ls) return ls;
+  } catch {
+  }
+  return DEFAULT_TRANSFORMERS_URL;
+}
+var dictationLoad = {
+  active: false,
+  progress: 0,
+  done: false
+};
+var loadListeners = /* @__PURE__ */ new Set();
+function setDictationLoad(patch) {
+  dictationLoad = { ...dictationLoad, ...patch };
+  loadListeners.forEach((l) => l());
+}
+function getDictationLoad() {
+  return dictationLoad;
+}
+function subscribeDictationLoad(cb) {
+  loadListeners.add(cb);
+  return () => {
+    loadListeners.delete(cb);
+  };
+}
+var WORKER_SRC = `
+let cfg = null, modP = null, pipeP = null, gateP = null, isMulti = false;
+let chain = Promise.resolve();
+const serialize = (fn) => { const r = chain.then(fn, fn); chain = r.then(() => {}, () => {}); return r; };
+
+function getMod() {
+  if (modP) return modP;
+  modP = (async () => {
+    const mod = await import(cfg.transformersUrl);
+    mod.env.allowLocalModels = false;
+    // transformers.js's OWN cache STREAMS the model straight to the Cache API (how whisper-web caches this
+    // 1.2GB turbo model). A hand-rolled SW that buffers the whole file chokes (QuotaExceeded).
+    mod.env.useBrowserCache = true;
+    mod.env.backends.onnx.wasm.numThreads = 1;
+    try { if (navigator.storage && navigator.storage.persist) await navigator.storage.persist(); } catch (e) {}
+    return mod;
+  })();
+  return modP;
+}
+
+function progressCb() {
+  const frac = {};
+  const report = () => {
+    const v = Object.values(frac);
+    self.postMessage({ type: 'progress', frac: v.length ? v.reduce((a, b) => a + b, 0) / v.length : 0 });
+  };
+  return (p) => {
+    if (!p || !p.file) return;
+    if (p.status === 'initiate') { frac[p.file] = frac[p.file] || 0; report(); }
+    else if (p.status === 'done') { frac[p.file] = 1; report(); }
+    else if (p.status === 'progress' && typeof p.progress === 'number') { frac[p.file] = p.progress / 100; report(); }
+  };
+}
+
+async function buildEnglish(modelId) {
+  const mod = await getMod();
+  mod.env.remoteHost = cfg.hfHost;
+  mod.env.remotePathTemplate = cfg.hfPath;
+  if ((cfg.whisperDevice || '').toLowerCase() !== 'wasm') {
+    try {
+      const gpuDtype = cfg.whisperDtype || 'q8';
+      const pipe = await mod.pipeline('automatic-speech-recognition', modelId, { device: 'webgpu', dtype: gpuDtype, progress_callback: progressCb() });
+      console.log('[whisper] ready (' + modelId + ' / WebGPU ' + gpuDtype + ', worker)');
+      return pipe;
+    } catch (e) { /* fall through to wasm */ }
+  }
+  const pipe = await mod.pipeline('automatic-speech-recognition', modelId, { dtype: 'q8', progress_callback: progressCb() });
+  console.log('[whisper] ready (' + modelId + ' / wasm, worker)');
+  return pipe;
+}
+
+async function buildTurbo() {
+  const mod = await getMod();
+  mod.env.remoteHost = cfg.whisperHost;
+  mod.env.remotePathTemplate = '{model}/';
+  const pipe = await mod.pipeline('automatic-speech-recognition', 'whisper-turbo', {
+    device: 'webgpu',
+    dtype: { encoder_model: 'fp16', decoder_model_merged: 'q4' },
+    progress_callback: progressCb(),
+  });
+  isMulti = true;
+  console.log('[whisper] ready (turbo / worker)');
+  return pipe;
+}
+
+function loadWhisper() {
+  if (pipeP) return pipeP;
+  self.postMessage({ type: 'loadState', patch: { active: true, progress: 0, done: false } });
+  pipeP = (async () => {
+    const pref = (cfg.whisperPref || '').toLowerCase();
+    if (pref && pref !== 'turbo' && cfg.smallModels[pref]) {
+      console.log('[whisper] loading ' + pref + ' (forced via ozwellConfig.whisper)\u2026');
+      return serialize(() => buildEnglish(cfg.smallModels[pref]));
+    }
+    console.log('[whisper] loading turbo\u2026');
+    try { return await serialize(() => buildTurbo()); }
+    catch (e) {
+      console.log('[whisper] turbo unavailable (' + (e && e.message ? e.message : e) + ') \u2192 base.en fallback');
+      return serialize(() => buildEnglish(cfg.gateModel));
+    }
+  })();
+  pipeP.then(
+    () => self.postMessage({ type: 'loadState', patch: { active: false, progress: 1, done: true } }),
+    () => { pipeP = null; self.postMessage({ type: 'loadState', patch: { active: false } }); }
+  );
+  return pipeP;
+}
+
+function loadGate() {
+  if (gateP) return gateP;
+  console.log('[whisper] loading stop-confirm gate (base.en)\u2026');
+  gateP = serialize(() => buildEnglish(cfg.gateModel));
+  gateP.catch(() => { gateP = null; });
+  return gateP;
+}
+
+self.onmessage = async (e) => {
+  const m = e.data;
+  if (!m) return;
+  if (m.type === 'init') { cfg = m.cfg; return; }
+  if (m.type === 'warm') { loadWhisper().catch(() => {}); return; }
+  if (m.type === 'warmGate') { loadGate().catch(() => {}); return; }
+  if (m.type === 'transcribe') {
+    try {
+      let pipe, opts;
+      if (m.want === 'gate') { pipe = await loadGate(); opts = { chunk_length_s: 30 }; }
+      else {
+        pipe = await loadWhisper();
+        if (m.want === 'segments' || m.want === 'words') opts = Object.assign({ chunk_length_s: 30, return_timestamps: m.want === 'words' ? 'word' : true }, isMulti ? { language: 'english', task: 'transcribe' } : {});
+        else opts = isMulti ? { chunk_length_s: 30, language: 'english', task: 'transcribe' } : { chunk_length_s: 30 };
+      }
+      const out = await pipe(m.samples, opts);
+      self.postMessage({ type: 'result', id: m.id, text: (out && out.text ? out.text : '').trim(), chunks: (out && out.chunks) || null });
+    } catch (err) {
+      self.postMessage({ type: 'error', id: m.id, message: err && err.message ? err.message : String(err) });
+    }
+  }
+};
+`;
+var worker = null;
+var reqId = 0;
+var pending = /* @__PURE__ */ new Map();
+function buildWorkerCfg() {
+  return {
+    transformersUrl: transformersUrl(),
+    whisperHost: whisperHost(),
+    whisperPref: whisperPref(),
+    whisperDevice: whisperDevice(),
+    whisperDtype: whisperDtype(),
+    hfHost: HF_HOST,
+    hfPath: HF_PATH,
+    smallModels: SMALL_MODELS,
+    gateModel: GATE_MODEL
+  };
+}
+function getWorker() {
+  if (worker) return worker;
+  registerModelServiceWorker();
+  const url = URL.createObjectURL(
+    new Blob([WORKER_SRC], { type: "application/javascript" })
+  );
+  const w = new Worker(url, { type: "module" });
+  w.onmessage = (e) => {
+    const m = e.data;
+    if (!m) return;
+    if (m.type === "loadState") {
+      setDictationLoad(m.patch);
+      return;
+    }
+    if (m.type === "progress") {
+      setDictationLoad({ progress: m.frac });
+      return;
+    }
+    if (m.type === "result") {
+      const p = pending.get(m.id);
+      if (p) {
+        pending.delete(m.id);
+        p.resolve({ text: m.text, chunks: m.chunks });
+      }
+      return;
+    }
+    if (m.type === "error") {
+      const p = pending.get(m.id);
+      if (p) {
+        pending.delete(m.id);
+        p.reject(new Error(m.message));
+      }
+      return;
+    }
+  };
+  w.onerror = (e) => {
+    const err = new Error(
+      `whisper worker error: ${e.message || "failed to load"}`
+    );
+    pending.forEach((p) => p.reject(err));
+    pending.clear();
+    setDictationLoad({ active: false });
+  };
+  w.postMessage({ type: "init", cfg: buildWorkerCfg() });
+  worker = w;
+  return worker;
+}
+function callWorker(want, samples) {
+  const w = getWorker();
+  const id = ++reqId;
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    w.postMessage({ type: "transcribe", id, want, samples }, [samples.buffer]);
+  });
+}
+function isWhisperLoaded() {
+  return getDictationLoad().done;
+}
+function resetWhisperWorker() {
+  if (!worker) return;
+  const err = new Error("whisper worker reset");
+  pending.forEach((p) => p.reject(err));
+  pending.clear();
+  worker.terminate();
+  worker = null;
+  setDictationLoad({ active: false, progress: 0, done: false });
+}
+function warmWhisper() {
+  getWorker().postMessage({ type: "warm" });
+}
+function warmStopGate() {
+  getWorker().postMessage({ type: "warmGate" });
+}
+function downmixToMono(audio) {
+  if (audio.numberOfChannels <= 1) return audio.getChannelData(0);
+  const n = audio.length;
+  const out = new Float32Array(n);
+  for (let ch = 0; ch < audio.numberOfChannels; ch++) {
+    const data = audio.getChannelData(ch);
+    for (let i = 0; i < n; i++) out[i] += data[i];
+  }
+  for (let i = 0; i < n; i++) out[i] /= audio.numberOfChannels;
+  return out;
+}
+function resampleTo16kMono(src, sampleRate) {
+  const ratio = 16e3 / sampleRate;
+  const n = Math.round(src.length * ratio);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const t = i / ratio;
+    const i0 = Math.floor(t);
+    const i1 = Math.min(i0 + 1, src.length - 1);
+    out[i] = src[i0] + (src[i1] - src[i0]) * (t - i0);
+  }
+  return out;
+}
+async function decodeTo16kMono(blob) {
+  const Ctx = window.AudioContext || window.webkitAudioContext;
+  const ctx = new Ctx();
+  try {
+    const audio = await ctx.decodeAudioData(await blob.arrayBuffer());
+    return resampleTo16kMono(downmixToMono(audio), audio.sampleRate);
+  } finally {
+    void ctx.close();
+  }
+}
+function encodeWav16kMono(samples) {
+  const sr = 16e3;
+  const buf = new ArrayBuffer(44 + samples.length * 2);
+  const view = new DataView(buf);
+  const str = (o2, s) => {
+    for (let i = 0; i < s.length; i++) view.setUint8(o2 + i, s.charCodeAt(i));
+  };
+  str(0, "RIFF");
+  view.setUint32(4, 36 + samples.length * 2, true);
+  str(8, "WAVE");
+  str(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, sr, true);
+  view.setUint32(28, sr * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  str(36, "data");
+  view.setUint32(40, samples.length * 2, true);
+  let o = 44;
+  for (let i = 0; i < samples.length; i++) {
+    const s = Math.max(-1, Math.min(1, samples[i]));
+    view.setInt16(o, s < 0 ? s * 32768 : s * 32767, true);
+    o += 2;
+  }
+  return new Blob([buf], { type: "audio/wav" });
+}
+async function trimTrailingStopPhrase(blob, phraseHintSec = 0) {
+  let samples;
+  try {
+    samples = await decodeTo16kMono(blob);
+  } catch {
+    return blob;
+  }
+  const SR = 16e3;
+  const n = samples.length;
+  if (n < SR * 0.8) return blob;
+  const fr = Math.round(SR * 0.03);
+  const nf = Math.ceil(n / fr);
+  const e = new Float32Array(nf);
+  let peak = 0;
+  for (let f = 0; f < nf; f++) {
+    const a = f * fr, b = Math.min(n, a + fr);
+    let s = 0;
+    for (let i = a; i < b; i++) s += samples[i] * samples[i];
+    e[f] = Math.sqrt(s / (b - a));
+    if (e[f] > peak) peak = e[f];
+  }
+  const sil = Math.max(8e-3, peak * 0.15);
+  const minGap = Math.max(1, Math.round(0.15 * SR / fr));
+  const maxTrimFrames = Math.round(2.2 * SR / fr);
+  const floor = Math.max(0, nf - maxTrimFrames);
+  let cutFrame;
+  if (phraseHintSec > 0.2) {
+    const anchor = Math.max(0, nf - Math.round(phraseHintSec * SR / fr));
+    const win = Math.round(0.35 * SR / fr);
+    let best = -1, bestDist = Infinity;
+    for (let f = Math.max(0, anchor - win); f <= Math.min(nf - 1, anchor + win); f++) {
+      if (e[f] < sil) {
+        const dist = Math.abs(f - anchor);
+        if (dist < bestDist) {
+          bestDist = dist;
+          best = f;
+        }
+      }
+    }
+    cutFrame = best >= 0 ? best : anchor;
+  } else {
+    let k = nf - 1;
+    while (k >= floor && e[k] < sil) k--;
+    cutFrame = -1;
+    while (k >= floor) {
+      if (e[k] < sil) {
+        let m = k;
+        while (m >= floor && e[m] < sil) m--;
+        if (k - m >= minGap) {
+          cutFrame = k + 1;
+          break;
+        }
+        k = m;
+      } else k--;
+    }
+    if (cutFrame < 0) cutFrame = Math.max(0, nf - Math.round(1.1 * SR / fr));
+  }
+  cutFrame = Math.max(cutFrame, floor);
+  const cutSample = Math.min(n, cutFrame * fr);
+  if (cutSample < SR * 0.2) return blob;
+  return encodeWav16kMono(samples.subarray(0, cutSample));
+}
+async function transcribeBlob(blob, trimEndSeconds = 0) {
+  let samples = await decodeTo16kMono(blob);
+  if (trimEndSeconds > 0) {
+    const cut = Math.round(trimEndSeconds * 16e3);
+    if (samples.length > cut + 16e3)
+      samples = samples.slice(0, samples.length - cut);
+  }
+  const out = await callWorker("text", samples);
+  return (out.text ?? "").trim();
+}
+async function transcribeSamples(samples, sampleRate) {
+  const out = await callWorker("text", resampleTo16kMono(samples, sampleRate));
+  return (out.text ?? "").trim();
+}
+function chunksToSegments(chunks) {
+  return (chunks ?? []).map((c) => ({
+    start: c.timestamp?.[0] ?? 0,
+    end: c.timestamp?.[1] ?? c.timestamp?.[0] ?? 0,
+    text: (c.text ?? "").trim()
+  })).filter((s) => s.text);
+}
+async function transcribeSegments(blob) {
+  const samples = await decodeTo16kMono(blob);
+  const out = await callWorker("segments", samples);
+  return chunksToSegments(out.chunks);
+}
+async function transcribeWords(blob) {
+  return transcribeWordsFromSamples(await decodeTo16kMono(blob));
+}
+async function transcribeWordsFromSamples(samples) {
+  const out = await callWorker("words", samples);
+  return chunksToSegments(out.chunks);
+}
+async function transcribeSegmentsFromSamples(samples) {
+  const out = await callWorker("segments", samples);
+  return chunksToSegments(out.chunks);
+}
+function serverAsrModel() {
+  try {
+    return JSON.parse(localStorage.getItem("ozwellConfig") || "{}").serverWhisper || "whisper-1";
+  } catch {
+    return "whisper-1";
+  }
+}
+async function transcribeServer(blob) {
+  const cfg = getOzwellConfig();
+  const form = new FormData();
+  form.append("file", blob, "audio.webm");
+  form.append("model", serverAsrModel());
+  const url = `${cfg.baseURL.replace(/\/$/, "")}/v1/audio/transcriptions`;
+  const headers = {};
+  if (cfg.apiKey && cfg.apiKey !== "ollama")
+    headers.Authorization = `Bearer ${cfg.apiKey}`;
+  const res = await fetch(url, { method: "POST", headers, body: form });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(
+      `Server ASR ${res.status}: ${res.statusText || body.slice(0, 200) || "request failed"}`
+    );
+  }
+  const data = await res.json();
+  return (typeof data?.text === "string" ? data.text : "").trim();
+}
+async function transcribeGate(samples, sampleRate) {
+  const out = await callWorker("gate", resampleTo16kMono(samples, sampleRate));
+  return (out.text ?? "").trim();
+}
+function stripStopPhrase(text) {
+  const tail = /(?:\b(?:oz\s{0,4}well|all(?:['’]?s|\s{1,4}was)?\s{0,4}well|as\s{0,4}well|also|oswald)\b[\s,]{0,6}i(?:['’]?m|\s{1,4}am)\s{1,4}done\b|\b(?:oz\s{0,4}well|all(?:['’]?s|\s{1,4}was)?\s{0,4}well|oswald)\b|\bi(?:['’]?m|\s{1,4}am)\s{1,4}done\b|\b(?:that\s{1,4}was\s{1,4}|was\s{1,4})?well\s{1,4}done\b|\bthat['’]?s?\s{1,4}(?:was\s{1,4})?all\b|\bthank(?:s|\s{1,4}you)(?:\s{1,4}for\s{1,4}watching)?\b|\bbye\b)[\s.,!?-]{0,24}$/i;
+  let prev = null;
+  let t = text;
+  while (t !== prev && t) {
+    prev = t;
+    t = trimTrailingPunct(t.replace(tail, ""));
+  }
+  return t.trim();
+}
+function trimTrailingPunct(s) {
+  let end = s.length;
+  while (end > 0 && /[\s.,!?-]/.test(s[end - 1])) end--;
+  return end === s.length ? s : s.slice(0, end);
+}
+function endsWithDone(text) {
+  return /\b(?:i(?:['’]?m|\s{1,4}am)\s{1,4}|all\s{1,4}|well\s{1,4})?done\b[\s.,!?-]{0,24}$/i.test(
+    text
+  );
+}
+
+export { askOzwell, askOzwellStream, decodeTo16kMono, endsWithDone, getDictationLoad, getOzwellConfig, isOzwellConfigured, isWhisperLoaded, registerModelServiceWorker, resetWhisperWorker, stripStopPhrase, subscribeDictationLoad, toOzwellMessages, transcribeBlob, transcribeGate, transcribeSamples, transcribeSegments, transcribeSegmentsFromSamples, transcribeServer, transcribeWords, transcribeWordsFromSamples, trimTrailingStopPhrase, warmStopGate, warmWhisper };
+//# sourceMappingURL=chunk-IZY4CMOO.js.map
+//# sourceMappingURL=chunk-IZY4CMOO.js.map