@fayz-ai/plugin-scribe 0.10.0

package/dist/index.js

@@ -0,0 +1,2910 @@
+import * as React6 from 'react';
+import React6__default from 'react';
+import { getActiveTenantId, getSupabaseClientOptional, registerTranslations } from '@fayz-ai/core';
+import { create } from 'zustand';
+import { createPortal } from 'react-dom';
+import { useAgentSurface, useAuth, resolveFayzAgentConnection } from '@fayz-ai/admin';
+import { Button, toast, Badge, Tabs, TabsList, TabsTrigger, TabsContent, Card, CardContent, MarkdownEditor, Modal, ModalContent, ModalHeader, ModalTitle, ModalBody, Checkbox, ModalFooter } from '@fayz-ai/ui/primitives';
+import { Mic, Loader2, FileText, Sparkles, AlertTriangle, RefreshCw, Trash2, Check, Pause, Play, Square, ShieldCheck } from 'lucide-react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { SubpageHeader } from '@fayz-ai/ui/layout';
+
+// src/index.ts
+
+// src/locales/en.ts
+var en = {
+  "scribe.nav.sessions": "Sessions",
+  "scribe.settings.title": "Session recording",
+  "scribe.action.start": "Start session",
+  "scribe.action.pause": "Pause",
+  "scribe.action.resume": "Resume",
+  "scribe.action.finish": "Finish",
+  "scribe.action.discard": "Discard",
+  "scribe.action.generate": "Generate document",
+  "scribe.transcript": "Transcript",
+  "scribe.recovery.title": "Recording interrupted",
+  "scribe.consent.title": "Start recording"
+};
+
+// src/locales/pt-BR.ts
+var ptBR = {
+  "scribe.nav.sessions": "Atendimentos",
+  "scribe.settings.title": "Grava\xE7\xE3o de atendimentos",
+  "scribe.action.start": "Iniciar atendimento",
+  "scribe.action.pause": "Pausar",
+  "scribe.action.resume": "Retomar",
+  "scribe.action.finish": "Finalizar",
+  "scribe.action.discard": "Descartar",
+  "scribe.action.generate": "Gerar documento",
+  "scribe.transcript": "Transcri\xE7\xE3o",
+  "scribe.recovery.title": "Grava\xE7\xE3o interrompida",
+  "scribe.consent.title": "Iniciar grava\xE7\xE3o"
+};
+
+// src/locales/index.ts
+var scribeLocales = {
+  en,
+  "pt-BR": ptBR
+};
+
+// src/runtime/idb.ts
+var DB_NAME = "fayz.scribe";
+var DB_VERSION = 1;
+var STORE_SESSIONS = "sessions";
+var STORE_PIECES = "pieces";
+var STORE_SEGMENTS = "segments";
+var STORE_TRANSCRIPT = "transcript";
+var IDX_SEGMENT_UPLOAD = "by_upload";
+var dbPromise = null;
+function isIdbAvailable() {
+  return typeof indexedDB !== "undefined";
+}
+function openScribeDb() {
+  if (dbPromise) return dbPromise;
+  dbPromise = new Promise((resolve, reject) => {
+    if (!isIdbAvailable()) {
+      reject(new Error("IndexedDB indispon\xEDvel neste navegador"));
+      return;
+    }
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE_SESSIONS)) {
+        db.createObjectStore(STORE_SESSIONS, { keyPath: "id" });
+      }
+      if (!db.objectStoreNames.contains(STORE_PIECES)) {
+        db.createObjectStore(STORE_PIECES, { keyPath: ["sessionId", "segIndex", "pieceIndex"] });
+      }
+      if (!db.objectStoreNames.contains(STORE_SEGMENTS)) {
+        const store = db.createObjectStore(STORE_SEGMENTS, { keyPath: ["sessionId", "segIndex"] });
+        store.createIndex(IDX_SEGMENT_UPLOAD, ["uploadState", "nextAttemptAt"]);
+      }
+      if (!db.objectStoreNames.contains(STORE_TRANSCRIPT)) {
+        db.createObjectStore(STORE_TRANSCRIPT, { keyPath: ["sessionId", "segIndex"] });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error ?? new Error("falha ao abrir o IndexedDB"));
+    req.onblocked = () => reject(new Error("IndexedDB bloqueado por outra aba"));
+  });
+  return dbPromise;
+}
+function promisify(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error ?? new Error("falha na opera\xE7\xE3o do IndexedDB"));
+  });
+}
+async function withStore(name, mode, fn) {
+  const db = await openScribeDb();
+  const tx = db.transaction(name, mode);
+  const store = tx.objectStore(name);
+  const out = fn(store);
+  const value = out instanceof Promise ? await out : await promisify(out);
+  await new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error ?? new Error("transa\xE7\xE3o abortada"));
+    tx.onabort = () => reject(tx.error ?? new Error("transa\xE7\xE3o abortada"));
+  });
+  return value;
+}
+function putSession(session) {
+  return withStore(STORE_SESSIONS, "readwrite", (s) => s.put(session));
+}
+function getSession(id) {
+  return withStore(STORE_SESSIONS, "readonly", (s) => s.get(id));
+}
+function getAllSessions() {
+  return withStore(STORE_SESSIONS, "readonly", (s) => s.getAll());
+}
+async function findOrphanSessions(staleAfterMs = 15e3) {
+  const now = Date.now();
+  const all = await getAllSessions();
+  return all.filter(
+    (s) => (s.state === "recording" || s.state === "paused" || s.state === "interrupted") && now - s.lastTickEpochMs > staleAfterMs
+  );
+}
+function putPiece(piece) {
+  return withStore(STORE_PIECES, "readwrite", (s) => s.put(piece));
+}
+function getPieces(sessionId, segIndex) {
+  const range = IDBKeyRange.bound(
+    [sessionId, segIndex, -Infinity],
+    [sessionId, segIndex, Infinity]
+  );
+  return withStore(STORE_PIECES, "readonly", (s) => s.getAll(range));
+}
+function deletePieces(sessionId, segIndex) {
+  const range = IDBKeyRange.bound(
+    [sessionId, segIndex, -Infinity],
+    [sessionId, segIndex, Infinity]
+  );
+  return withStore(STORE_PIECES, "readwrite", (s) => promisify(s.delete(range)).then(() => void 0));
+}
+function putSegment(segment) {
+  return withStore(STORE_SEGMENTS, "readwrite", (s) => s.put(segment));
+}
+function getSegment(sessionId, segIndex) {
+  return withStore(
+    STORE_SEGMENTS,
+    "readonly",
+    (s) => s.get([sessionId, segIndex])
+  );
+}
+async function claimUploadable(limit) {
+  const now = Date.now();
+  const out = [];
+  for (const state of ["pending", "failed"]) {
+    if (out.length >= limit) break;
+    const range = IDBKeyRange.bound([state, -Infinity], [state, now]);
+    const rows = await withStore(
+      STORE_SEGMENTS,
+      "readonly",
+      (s) => s.index(IDX_SEGMENT_UPLOAD).getAll(range, limit - out.length)
+    );
+    out.push(...rows);
+  }
+  return out.sort(
+    (a, b) => a.sessionId === b.sessionId ? a.segIndex - b.segIndex : a.sessionId.localeCompare(b.sessionId)
+  );
+}
+async function reclaimStuckUploads() {
+  const range = IDBKeyRange.bound(["uploading", -Infinity], ["uploading", Infinity]);
+  const stuck = await withStore(
+    STORE_SEGMENTS,
+    "readonly",
+    (s) => s.index(IDX_SEGMENT_UPLOAD).getAll(range)
+  );
+  for (const seg of stuck) {
+    await putSegment({ ...seg, uploadState: "pending", nextAttemptAt: 0 });
+  }
+  return stuck.length;
+}
+var MIN_FREE_BYTES = 50 * 1024 * 1024;
+async function checkStorageHealth() {
+  if (!isIdbAvailable()) {
+    return { ok: false, persisted: false, freeBytes: null, reason: "IndexedDB indispon\xEDvel" };
+  }
+  let persisted = false;
+  try {
+    if (navigator.storage?.persist) persisted = await navigator.storage.persist();
+  } catch {
+  }
+  try {
+    if (!navigator.storage?.estimate) return { ok: true, persisted, freeBytes: null };
+    const { quota = 0, usage = 0 } = await navigator.storage.estimate();
+    const free = quota - usage;
+    if (free < MIN_FREE_BYTES) {
+      return {
+        ok: false,
+        persisted,
+        freeBytes: free,
+        reason: `Espa\xE7o insuficiente no navegador (${Math.round(free / 1024 / 1024)} MB livres, m\xEDnimo ${MIN_FREE_BYTES / 1024 / 1024} MB)`
+      };
+    }
+    return { ok: true, persisted, freeBytes: free };
+  } catch {
+    return { ok: true, persisted, freeBytes: null };
+  }
+}
+
+// src/runtime/capture.ts
+var PIECE_MS = 5e3;
+var SEGMENT_MS = 3e4;
+var HEARTBEAT_MS = 2e3;
+var MIME_CANDIDATES = [
+  "audio/webm;codecs=opus",
+  "audio/ogg;codecs=opus",
+  "audio/mp4",
+  "audio/webm"
+];
+function pickMimeType() {
+  if (typeof MediaRecorder === "undefined") return null;
+  for (const mime of MIME_CANDIDATES) {
+    try {
+      if (MediaRecorder.isTypeSupported(mime)) return mime;
+    } catch {
+    }
+  }
+  return null;
+}
+function isCaptureSupported() {
+  return typeof navigator !== "undefined" && !!navigator.mediaDevices?.getUserMedia && typeof MediaRecorder !== "undefined" && pickMimeType() !== null;
+}
+var live = null;
+var listeners = /* @__PURE__ */ new Set();
+var lastError;
+function getSnapshot() {
+  if (!live) return { state: "idle", sessionId: null, elapsedMs: 0, segIndex: 0, error: lastError };
+  return {
+    state: live.session.state,
+    sessionId: live.session.id,
+    subjectId: live.session.subjectId,
+    subjectName: live.session.subjectName,
+    elapsedMs: elapsedMs(live.session),
+    segIndex: live.session.segIndex,
+    error: lastError
+  };
+}
+function emit() {
+  const snap = getSnapshot();
+  for (const fn of listeners) {
+    try {
+      fn(snap);
+    } catch {
+    }
+  }
+}
+function subscribeCapture(fn) {
+  listeners.add(fn);
+  fn(getSnapshot());
+  return () => listeners.delete(fn);
+}
+function elapsedMs(session) {
+  const running2 = session.state === "recording" && session.resumedAtEpochMs !== null;
+  return session.accumulatedMs + (running2 ? Date.now() - session.resumedAtEpochMs : 0);
+}
+async function closeSegment(cap, partial) {
+  const { session, buffer, segStartOffsetMs } = cap;
+  if (buffer.length === 0) return;
+  const segIndex = session.segIndex;
+  const blob = new Blob(buffer, { type: session.mimeType });
+  const nominalDurationMs = buffer.length * PIECE_MS;
+  await putSegment({
+    sessionId: session.id,
+    segIndex,
+    blob,
+    bytes: blob.size,
+    startOffsetMs: segStartOffsetMs,
+    nominalDurationMs,
+    partial,
+    gap: false,
+    uploadState: "pending",
+    attempts: 0,
+    nextAttemptAt: 0,
+    storagePath: null
+  });
+  await deletePieces(session.id, segIndex);
+  cap.buffer = [];
+  cap.pieceIndex = 0;
+  cap.segStartOffsetMs = segStartOffsetMs + nominalDurationMs;
+  session.segIndex = segIndex + 1;
+  await putSession(session);
+}
+async function writeGapSegment(cap, durationMs) {
+  const { session } = cap;
+  const segIndex = session.segIndex;
+  await putSegment({
+    sessionId: session.id,
+    segIndex,
+    blob: null,
+    bytes: 0,
+    startOffsetMs: cap.segStartOffsetMs,
+    nominalDurationMs: durationMs,
+    partial: false,
+    gap: true,
+    uploadState: "pending",
+    attempts: 0,
+    nextAttemptAt: 0,
+    storagePath: null
+  });
+  cap.segStartOffsetMs += durationMs;
+  session.segIndex = segIndex + 1;
+  await putSession(session);
+}
+function startRecorder(cap) {
+  const recorder = new MediaRecorder(cap.stream, {
+    mimeType: cap.session.mimeType,
+    // 24 kbps mono é transparente para fala e mantém 40 min em ~7 MB — o número
+    // que torna toda a história de durabilidade barata.
+    audioBitsPerSecond: 24e3
+  });
+  recorder.ondataavailable = (ev) => {
+    if (!ev.data || ev.data.size === 0) return;
+    cap.buffer.push(ev.data);
+    const pieceIndex = cap.pieceIndex++;
+    void putPiece({
+      sessionId: cap.session.id,
+      segIndex: cap.session.segIndex,
+      pieceIndex,
+      blob: ev.data,
+      bytes: ev.data.size,
+      createdAt: Date.now()
+    }).catch(() => {
+    });
+  };
+  recorder.onstop = () => {
+    const wasRotating = cap.rotating;
+    cap.rotating = false;
+    void (async () => {
+      await closeSegment(cap, !wasRotating);
+      if (wasRotating && cap.session.state === "recording") {
+        startRecorder(cap);
+        armRotation(cap);
+      }
+      emit();
+    })();
+  };
+  recorder.onerror = () => {
+    void handleInterruption("erro do gravador");
+  };
+  cap.recorder = recorder;
+  recorder.start(PIECE_MS);
+}
+function armRotation(cap) {
+  if (cap.rotateTimer) clearTimeout(cap.rotateTimer);
+  cap.rotateTimer = setTimeout(() => {
+    if (!cap.recorder || cap.recorder.state !== "recording") return;
+    cap.rotating = true;
+    cap.recorder.stop();
+  }, SEGMENT_MS);
+}
+async function acquireWakeLock(cap) {
+  try {
+    if (!("wakeLock" in navigator)) return;
+    cap.wakeLock = await navigator.wakeLock.request("screen");
+  } catch {
+  }
+}
+async function releaseWakeLock(cap) {
+  try {
+    await cap.wakeLock?.release();
+  } catch {
+  }
+  cap.wakeLock = null;
+}
+function onBeforeUnload(ev) {
+  if (!live || live.session.state !== "recording") return;
+  ev.preventDefault();
+  ev.returnValue = "";
+}
+function onVisibilityChange() {
+  if (!live) return;
+  if (document.visibilityState === "visible" && live.session.state === "recording" && !live.wakeLock) {
+    void acquireWakeLock(live);
+  }
+  emit();
+}
+function onFreeze() {
+  if (!live) return;
+  live.interruptedAtMs = Date.now();
+  live.session.lastTickEpochMs = Date.now();
+  void putSession(live.session);
+}
+function onResume() {
+  if (!live) return;
+  const track = live.stream.getAudioTracks()[0];
+  if (!track || track.readyState === "ended") {
+    void handleInterruption("microfone perdido enquanto a aba estava suspensa");
+  }
+}
+function attachLifecycle() {
+  window.addEventListener("beforeunload", onBeforeUnload);
+  document.addEventListener("visibilitychange", onVisibilityChange);
+  document.addEventListener("freeze", onFreeze);
+  document.addEventListener("resume", onResume);
+}
+function detachLifecycle() {
+  window.removeEventListener("beforeunload", onBeforeUnload);
+  document.removeEventListener("visibilitychange", onVisibilityChange);
+  document.removeEventListener("freeze", onFreeze);
+  document.removeEventListener("resume", onResume);
+}
+function watchTrack(cap) {
+  const track = cap.stream.getAudioTracks()[0];
+  if (!track) return;
+  track.onended = () => void handleInterruption("microfone desconectado");
+  track.onmute = () => void handleInterruption("microfone silenciado pelo sistema");
+}
+async function handleInterruption(reason) {
+  if (!live || live.session.state !== "recording") return;
+  const cap = live;
+  cap.interruptedAtMs = Date.now();
+  cap.session.state = "interrupted";
+  cap.session.accumulatedMs = elapsedMs(cap.session);
+  cap.session.resumedAtEpochMs = null;
+  lastError = reason;
+  if (cap.rotateTimer) clearTimeout(cap.rotateTimer);
+  try {
+    if (cap.recorder?.state === "recording") cap.recorder.stop();
+    else await closeSegment(cap, true);
+  } catch {
+    await closeSegment(cap, true);
+  }
+  await releaseWakeLock(cap);
+  await putSession(cap.session);
+  emit();
+}
+async function startCapture(opts) {
+  if (live) return { ok: false, reason: "j\xE1 existe uma grava\xE7\xE3o em andamento" };
+  if (!isCaptureSupported()) return { ok: false, reason: "este navegador n\xE3o suporta grava\xE7\xE3o de \xE1udio" };
+  const health = await checkStorageHealth();
+  if (!health.ok) return { ok: false, reason: health.reason ?? "armazenamento local indispon\xEDvel" };
+  const mimeType = pickMimeType();
+  let stream;
+  try {
+    stream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        channelCount: 1,
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true,
+        sampleRate: 16e3
+      }
+    });
+  } catch (err) {
+    const name = err?.name;
+    return {
+      ok: false,
+      reason: name === "NotAllowedError" ? "permiss\xE3o de microfone negada" : name === "NotFoundError" ? "nenhum microfone encontrado" : "n\xE3o foi poss\xEDvel acessar o microfone"
+    };
+  }
+  const now = Date.now();
+  const session = {
+    id: crypto.randomUUID(),
+    tenantId: opts.tenantId,
+    subjectId: opts.subjectId,
+    subjectName: opts.subjectName,
+    appointmentId: opts.appointmentId,
+    userId: opts.userId,
+    mimeType,
+    locale: opts.locale ?? "pt-BR",
+    startedAtEpochMs: now,
+    resumedAtEpochMs: now,
+    accumulatedMs: 0,
+    lastTickEpochMs: now,
+    state: "recording",
+    segIndex: 0,
+    templateKeys: opts.templateKeys ?? []
+  };
+  await putSession(session);
+  const cap = {
+    session,
+    stream,
+    recorder: null,
+    buffer: [],
+    pieceIndex: 0,
+    segStartOffsetMs: 0,
+    wakeLock: null,
+    heartbeat: null,
+    rotateTimer: null,
+    rotating: false,
+    interruptedAtMs: null
+  };
+  live = cap;
+  lastError = void 0;
+  startRecorder(cap);
+  armRotation(cap);
+  watchTrack(cap);
+  attachLifecycle();
+  void acquireWakeLock(cap);
+  cap.heartbeat = setInterval(() => {
+    if (!live) return;
+    live.session.lastTickEpochMs = Date.now();
+    void putSession(live.session);
+    emit();
+  }, HEARTBEAT_MS);
+  try {
+    await opts.onSessionCreated?.(session, opts.consentMode);
+  } catch {
+  }
+  emit();
+  return { ok: true, sessionId: session.id };
+}
+async function pauseCapture() {
+  if (!live || live.session.state !== "recording") return;
+  const cap = live;
+  cap.session.accumulatedMs = elapsedMs(cap.session);
+  cap.session.resumedAtEpochMs = null;
+  cap.session.state = "paused";
+  if (cap.rotateTimer) clearTimeout(cap.rotateTimer);
+  if (cap.recorder?.state === "recording") {
+    cap.rotating = false;
+    cap.recorder.stop();
+  }
+  await releaseWakeLock(cap);
+  await putSession(cap.session);
+  emit();
+}
+async function resumeCapture() {
+  if (!live || live.session.state !== "paused" && live.session.state !== "interrupted") return;
+  const cap = live;
+  if (cap.session.state === "interrupted" && cap.interruptedAtMs) {
+    await writeGapSegment(cap, Date.now() - cap.interruptedAtMs);
+  }
+  cap.interruptedAtMs = null;
+  const track = cap.stream.getAudioTracks()[0];
+  if (!track || track.readyState === "ended") {
+    try {
+      cap.stream = await navigator.mediaDevices.getUserMedia({
+        audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true, autoGainControl: true }
+      });
+      watchTrack(cap);
+    } catch {
+      lastError = "n\xE3o foi poss\xEDvel reabrir o microfone";
+      emit();
+      return;
+    }
+  }
+  cap.session.state = "recording";
+  cap.session.resumedAtEpochMs = Date.now();
+  lastError = void 0;
+  await putSession(cap.session);
+  startRecorder(cap);
+  armRotation(cap);
+  void acquireWakeLock(cap);
+  emit();
+}
+async function stopCapture() {
+  if (!live) return null;
+  const cap = live;
+  const sessionId = cap.session.id;
+  cap.session.accumulatedMs = elapsedMs(cap.session);
+  cap.session.resumedAtEpochMs = null;
+  cap.session.state = "stopping";
+  await putSession(cap.session);
+  emit();
+  if (cap.rotateTimer) clearTimeout(cap.rotateTimer);
+  if (cap.heartbeat) clearInterval(cap.heartbeat);
+  if (cap.recorder?.state === "recording") {
+    cap.rotating = false;
+    await new Promise((resolve) => {
+      const rec = cap.recorder;
+      const prev = rec.onstop;
+      rec.onstop = (ev) => {
+        if (typeof prev === "function") prev.call(rec, ev);
+        setTimeout(resolve, 0);
+      };
+      rec.stop();
+    });
+  } else {
+    await closeSegment(cap, true);
+  }
+  for (const track of cap.stream.getTracks()) track.stop();
+  await releaseWakeLock(cap);
+  detachLifecycle();
+  const finished = await getSession(sessionId);
+  if (finished) {
+    finished.state = "idle";
+    await putSession(finished);
+  }
+  live = null;
+  emit();
+  return sessionId;
+}
+async function adoptOrphan(session) {
+  if (live) return;
+  const pieces = await getPieces(session.id, session.segIndex);
+  live = {
+    session: { ...session, state: "interrupted" },
+    stream: new MediaStream(),
+    recorder: null,
+    buffer: pieces.map((p) => p.blob),
+    pieceIndex: pieces.length,
+    segStartOffsetMs: 0,
+    wakeLock: null,
+    heartbeat: null,
+    rotateTimer: null,
+    rotating: false,
+    interruptedAtMs: session.lastTickEpochMs
+  };
+  if (pieces.length > 0) await closeSegment(live, true);
+  live.session.state = "interrupted";
+  await putSession(live.session);
+  lastError = "grava\xE7\xE3o interrompida";
+  emit();
+}
+async function releaseCapture() {
+  if (!live) return;
+  if (live.rotateTimer) clearTimeout(live.rotateTimer);
+  if (live.heartbeat) clearInterval(live.heartbeat);
+  for (const track of live.stream.getTracks()) track.stop();
+  await releaseWakeLock(live);
+  detachLifecycle();
+  live = null;
+  lastError = void 0;
+  emit();
+}
+function getLiveSessionId() {
+  return live?.session.id ?? null;
+}
+
+// src/data/tables.ts
+var T = {
+  sessions: "plg_scribe_sessions",
+  segments: "plg_scribe_segments",
+  generations: "plg_scribe_generations"
+};
+var AUDIO_BUCKET = "scribe-audio";
+function storagePath(args) {
+  const yyyy = String(args.startedAt.getUTCFullYear());
+  const mm = String(args.startedAt.getUTCMonth() + 1).padStart(2, "0");
+  const seg = String(args.segIndex).padStart(5, "0");
+  return `${args.tenantId}/${yyyy}/${mm}/${args.sessionId}/${seg}.${args.ext}`;
+}
+function sessionPrefix(args) {
+  const yyyy = String(args.startedAt.getUTCFullYear());
+  const mm = String(args.startedAt.getUTCMonth() + 1).padStart(2, "0");
+  return `${args.tenantId}/${yyyy}/${mm}/${args.sessionId}`;
+}
+function extForMime(mimeType) {
+  if (mimeType.includes("ogg")) return "ogg";
+  if (mimeType.includes("mp4")) return "m4a";
+  if (mimeType.includes("mpeg")) return "mp3";
+  return "webm";
+}
+
+// src/runtime/pump.ts
+var CONCURRENCY = 2;
+var IDLE_POLL_MS = 3e3;
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_CEILING_MS = 3e4;
+var CHANNEL_NAME = "fayz.scribe";
+var running = false;
+var timer = null;
+var channel = null;
+var tabId = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : String(Math.random());
+var isLeader = true;
+var peerIds = /* @__PURE__ */ new Set();
+function setupChannel() {
+  if (typeof BroadcastChannel === "undefined" || channel) return;
+  channel = new BroadcastChannel(CHANNEL_NAME);
+  channel.onmessage = (ev) => {
+    const msg = ev.data;
+    if (msg?.type === "hello" && msg.tabId) {
+      peerIds.add(msg.tabId);
+      channel?.postMessage({ type: "ack", tabId });
+      recomputeLeader();
+    } else if (msg?.type === "ack" && msg.tabId) {
+      peerIds.add(msg.tabId);
+      recomputeLeader();
+    } else if (msg?.type === "bye" && msg.tabId) {
+      peerIds.delete(msg.tabId);
+      recomputeLeader();
+    }
+  };
+  channel.postMessage({ type: "hello", tabId });
+  window.addEventListener("pagehide", () => channel?.postMessage({ type: "bye", tabId }));
+}
+function recomputeLeader() {
+  const all = [tabId, ...peerIds].sort();
+  isLeader = all[0] === tabId;
+}
+function isDuplicateError(err) {
+  const e = err;
+  const status = Number(e?.statusCode ?? e?.status);
+  if (status === 409) return true;
+  const text = `${e?.message ?? ""} ${e?.error ?? ""}`.toLowerCase();
+  return text.includes("duplicate") || text.includes("already exists") || text.includes("resource already");
+}
+function nextBackoff(attempts) {
+  const base = Math.min(BACKOFF_CEILING_MS, BACKOFF_BASE_MS * 2 ** attempts);
+  return Date.now() + base + Math.floor(Math.random() * 500);
+}
+async function uploadOne(segment) {
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) return;
+  const session = await getSession(segment.sessionId);
+  if (!session) {
+    await putSegment({ ...segment, uploadState: "failed", nextAttemptAt: nextBackoff(segment.attempts + 1), attempts: segment.attempts + 1 });
+    return;
+  }
+  await putSegment({ ...segment, uploadState: "uploading" });
+  if (segment.gap || !segment.blob) {
+    await recordSegment(supabase, session.id, segment, null);
+    await putSegment({ ...segment, blob: null, uploadState: "uploaded", storagePath: null });
+    return;
+  }
+  const path = storagePath({
+    tenantId: session.tenantId,
+    sessionId: session.id,
+    segIndex: segment.segIndex,
+    startedAt: new Date(session.startedAtEpochMs),
+    ext: extForMime(session.mimeType)
+  });
+  try {
+    const { error } = await supabase.storage.from(AUDIO_BUCKET).upload(path, segment.blob, {
+      contentType: session.mimeType,
+      // Sem upsert de propósito: combina com a ausência de policy de UPDATE no
+      // bucket. Um caminho gravado nunca é trocado por outro conteúdo.
+      upsert: false
+    });
+    if (error && !isDuplicateError(error)) throw error;
+    await recordSegment(supabase, session.id, segment, path);
+    await putSegment({ ...segment, blob: null, uploadState: "uploaded", storagePath: path });
+  } catch (err) {
+    const attempts = segment.attempts + 1;
+    await putSegment({
+      ...segment,
+      uploadState: "failed",
+      attempts,
+      nextAttemptAt: nextBackoff(attempts)
+    });
+  }
+}
+async function recordSegment(supabase, sessionId, segment, path) {
+  const { error } = await supabase.rpc("scribe_record_segment", {
+    p_payload: {
+      session_id: sessionId,
+      seg_index: segment.segIndex,
+      storage_path: path,
+      bytes: segment.bytes,
+      start_offset_ms: segment.startOffsetMs,
+      // Duração NOMINAL. O servidor sobrescreve com a medida do STT quando ela
+      // chega — o cliente conta tempo, o STT conta amostras.
+      duration_ms: segment.nominalDurationMs,
+      partial: segment.partial,
+      gap: segment.gap
+    }
+  });
+  if (error) throw error;
+}
+async function tick() {
+  if (!running) return;
+  try {
+    if (typeof navigator !== "undefined" && navigator.onLine === false) return;
+    if (!isLeader) return;
+    if (!getSupabaseClientOptional()) return;
+    const batch = await claimUploadable(CONCURRENCY);
+    if (batch.length === 0) return;
+    await Promise.all(
+      batch.map(async (seg) => {
+        const fresh = await getSegment(seg.sessionId, seg.segIndex);
+        if (!fresh || fresh.uploadState === "uploaded") return;
+        await uploadOne(fresh);
+      })
+    );
+  } catch {
+  } finally {
+    if (running) timer = setTimeout(() => void tick(), IDLE_POLL_MS);
+  }
+}
+function onOnline() {
+  if (!running) return;
+  if (timer) clearTimeout(timer);
+  void tick();
+}
+function kickPump() {
+  if (!running) return;
+  if (timer) clearTimeout(timer);
+  timer = setTimeout(() => void tick(), 0);
+}
+function startPump() {
+  if (running) return;
+  running = true;
+  setupChannel();
+  if (typeof window !== "undefined") window.addEventListener("online", onOnline);
+  void reclaimStuckUploads().finally(() => void tick());
+}
+async function finalizeSession(sessionId, wallDurationMs) {
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) return;
+  const local = await getSession(sessionId);
+  await supabase.from("plg_scribe_sessions").update({
+    status: "uploading",
+    ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+    wall_duration_ms: wallDurationMs,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).eq("id", sessionId);
+  if (local) {
+    local.state = "idle";
+    await putSession(local);
+  }
+}
+
+// src/runtime/index.ts
+var initialized = false;
+var retention = {
+  audioDays: 90,
+  requireConsent: true,
+  defaultConsentMode: "verbal"
+};
+var orphans = [];
+var orphanListeners = /* @__PURE__ */ new Set();
+function subscribeOrphans(fn) {
+  orphanListeners.add(fn);
+  fn(orphans);
+  return () => orphanListeners.delete(fn);
+}
+function emitOrphans() {
+  for (const fn of orphanListeners) {
+    try {
+      fn(orphans);
+    } catch {
+    }
+  }
+}
+function initScribeRuntime(options) {
+  if (initialized) return;
+  if (typeof window === "undefined" || !isIdbAvailable()) return;
+  initialized = true;
+  retention = { ...retention, ...options?.retention };
+  startPump();
+  void (async () => {
+    try {
+      orphans = await findOrphanSessions();
+      if (orphans.length > 0) {
+        const latest = orphans.reduce((a, b) => a.lastTickEpochMs > b.lastTickEpochMs ? a : b);
+        await adoptOrphan(latest);
+        kickPump();
+      }
+      emitOrphans();
+    } catch {
+    }
+  })();
+}
+async function beginSession(args) {
+  const tenantId = getActiveTenantId();
+  if (!tenantId) return { ok: false, reason: "nenhum tenant ativo" };
+  const opts = {
+    tenantId,
+    userId: args.userId,
+    subjectId: args.subjectId,
+    subjectName: args.subjectName,
+    appointmentId: args.appointmentId,
+    locale: args.locale,
+    templateKeys: args.templateKeys,
+    consentMode: args.consentMode ?? retention.defaultConsentMode,
+    onSessionCreated: async (session, consentMode) => {
+      const supabase = getSupabaseClientOptional();
+      if (!supabase) return;
+      const retentionUntil = new Date(Date.now() + retention.audioDays * 864e5);
+      await supabase.from("plg_scribe_sessions").insert({
+        id: session.id,
+        tenant_id: session.tenantId,
+        subject_id: session.subjectId ?? null,
+        appointment_id: session.appointmentId ?? null,
+        context_kind: session.appointmentId ? "appointment" : session.subjectId ? "person" : "standalone",
+        owner_user_id: session.userId,
+        status: "recording",
+        locale: session.locale,
+        mime_type: session.mimeType,
+        started_at: new Date(session.startedAtEpochMs).toISOString(),
+        // O consentimento é carimbado no INSERT, não depois: a linha nunca
+        // existe sem a base legal do que ela guarda.
+        consent_at: retention.requireConsent ? (/* @__PURE__ */ new Date()).toISOString() : null,
+        consent_mode: retention.requireConsent ? consentMode ?? retention.defaultConsentMode : null,
+        retention_until: retentionUntil.toISOString().slice(0, 10)
+      });
+    }
+  };
+  const result = await startCapture(opts);
+  if (result.ok) kickPump();
+  return result;
+}
+async function pauseSession() {
+  await pauseCapture();
+  const id = getLiveSessionId();
+  if (!id) return;
+  kickPump();
+  await patchStatus(id, "paused");
+}
+async function resumeSession() {
+  await resumeCapture();
+  const id = getLiveSessionId();
+  if (id) await patchStatus(id, "recording");
+}
+async function endSession() {
+  const snapshot = getSnapshot();
+  const wall = snapshot.elapsedMs;
+  const id = await stopCapture();
+  if (!id) return null;
+  kickPump();
+  await finalizeSession(id, wall);
+  orphans = orphans.filter((o) => o.id !== id);
+  emitOrphans();
+  return id;
+}
+async function discardSession(sessionId) {
+  const id = sessionId ?? getLiveSessionId();
+  if (!id) return;
+  await releaseCapture();
+  await patchStatus(id, "abandoned");
+  const local = await getSession(id);
+  if (local) {
+    local.state = "idle";
+    await putSession(local);
+  }
+  orphans = orphans.filter((o) => o.id !== id);
+  emitOrphans();
+}
+function dismissOrphan(sessionId) {
+  orphans = orphans.filter((o) => o.id !== sessionId);
+  emitOrphans();
+}
+async function patchStatus(sessionId, status) {
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) return;
+  try {
+    await supabase.from("plg_scribe_sessions").update({ status, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", sessionId);
+  } catch {
+  }
+}
+var useScribeStore = create((set) => ({
+  ...getSnapshot(),
+  orphans: [],
+  viewingSessionId: null,
+  setViewing: (id) => set({ viewingSessionId: id })
+}));
+var wired = false;
+function wireScribeStore() {
+  if (wired) return;
+  wired = true;
+  subscribeCapture((snap) => {
+    useScribeStore.setState({
+      state: snap.state,
+      sessionId: snap.sessionId,
+      subjectId: snap.subjectId,
+      subjectName: snap.subjectName,
+      elapsedMs: snap.elapsedMs,
+      segIndex: snap.segIndex,
+      error: snap.error
+    });
+  });
+  subscribeOrphans((orphans2) => useScribeStore.setState({ orphans: orphans2 }));
+}
+function formatElapsed(ms) {
+  const total = Math.max(0, Math.floor(ms / 1e3));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const mm = String(m).padStart(2, "0");
+  const ss = String(s).padStart(2, "0");
+  return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`;
+}
+var MOBILE_BREAKPOINT = 768;
+function useIsMobile() {
+  const [isMobile, setIsMobile] = React6.useState(
+    () => typeof window !== "undefined" && window.innerWidth < MOBILE_BREAKPOINT
+  );
+  React6.useEffect(() => {
+    const mq = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+    const onChange = (e) => setIsMobile(e.matches);
+    setIsMobile(mq.matches);
+    mq.addEventListener("change", onChange);
+    return () => mq.removeEventListener("change", onChange);
+  }, []);
+  return isMobile;
+}
+function useTicker(active) {
+  const [, force] = React6.useReducer((n) => n + 1, 0);
+  React6.useEffect(() => {
+    if (!active) return;
+    let raf = 0;
+    let last = 0;
+    const loop = (t) => {
+      if (t - last >= 250) {
+        last = t;
+        if (document.visibilityState === "visible") force();
+      }
+      raf = requestAnimationFrame(loop);
+    };
+    raf = requestAnimationFrame(loop);
+    const onVis = () => force();
+    document.addEventListener("visibilitychange", onVis);
+    return () => {
+      cancelAnimationFrame(raf);
+      document.removeEventListener("visibilitychange", onVis);
+    };
+  }, [active]);
+  return 0;
+}
+function ScribeRecordingPill({ labels, onOpenSession }) {
+  const state = useScribeStore((s) => s.state);
+  const sessionId = useScribeStore((s) => s.sessionId);
+  const subjectName = useScribeStore((s) => s.subjectName);
+  const isMobile = useIsMobile();
+  const [busy, setBusy] = React6.useState(false);
+  const active = state === "recording" || state === "paused" || state === "interrupted";
+  useTicker(state === "recording");
+  const elapsedMs2 = active ? useScribeStore.getState().elapsedMs : 0;
+  const handleToggle = React6.useCallback(async () => {
+    setBusy(true);
+    try {
+      if (state === "recording") await pauseSession();
+      else await resumeSession();
+    } finally {
+      setBusy(false);
+    }
+  }, [state]);
+  const handleStop = React6.useCallback(async () => {
+    setBusy(true);
+    try {
+      const id = await endSession();
+      if (id) onOpenSession?.(id);
+    } finally {
+      setBusy(false);
+    }
+  }, [onOpenSession]);
+  if (!active || !sessionId) return null;
+  const tone = state === "recording" ? "bg-destructive/10 text-destructive border-destructive/30" : state === "interrupted" ? "bg-amber-500/10 text-amber-700 border-amber-500/30 dark:text-amber-400" : "bg-muted text-muted-foreground border-border";
+  const content = /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `flex items-center gap-2 rounded-full border px-2.5 py-1 ${tone}`,
+      role: "status",
+      "aria-live": "polite",
+      "aria-label": `${labels.sessionSingular}: ${formatElapsed(elapsedMs2)}`,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => onOpenSession?.(sessionId),
+            className: "flex items-center gap-1.5 text-sm font-medium tabular-nums",
+            title: subjectName ?? labels.sessionSingular,
+            children: [
+              /* @__PURE__ */ jsxs("span", { className: "relative flex h-2 w-2 shrink-0", children: [
+                state === "recording" && /* @__PURE__ */ jsx("span", { className: "absolute inline-flex h-full w-full animate-ping rounded-full bg-current opacity-60" }),
+                /* @__PURE__ */ jsx("span", { className: "relative inline-flex h-2 w-2 rounded-full bg-current" })
+              ] }),
+              formatElapsed(elapsedMs2),
+              subjectName && /* @__PURE__ */ jsxs("span", { className: "hidden max-w-[12ch] truncate sm:inline", children: [
+                "\xB7 ",
+                subjectName
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "h-6 w-6 p-0",
+            disabled: busy,
+            onClick: handleToggle,
+            title: state === "recording" ? labels.pause : labels.resume,
+            "aria-label": state === "recording" ? labels.pause : labels.resume,
+            children: state === "recording" ? /* @__PURE__ */ jsx(Pause, { className: "h-3.5 w-3.5" }) : /* @__PURE__ */ jsx(Play, { className: "h-3.5 w-3.5" })
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "h-6 w-6 p-0",
+            disabled: busy,
+            onClick: handleStop,
+            title: labels.finish,
+            "aria-label": labels.finish,
+            children: /* @__PURE__ */ jsx(Square, { className: "h-3.5 w-3.5" })
+          }
+        )
+      ]
+    }
+  );
+  if (isMobile && typeof document !== "undefined") {
+    return createPortal(
+      /* @__PURE__ */ jsx("div", { className: "fixed inset-x-0 top-0 z-50 flex justify-center bg-background/80 p-1.5 backdrop-blur md:hidden", children: content }),
+      document.body
+    );
+  }
+  return content;
+}
+function ScribeStartButton({ labels, disabled, onStart, variant = "default", size = "sm" }) {
+  const state = useScribeStore((s) => s.state);
+  const busy = state === "recording" || state === "paused" || state === "interrupted" || state === "requesting";
+  return /* @__PURE__ */ jsxs(Button, { variant, size, disabled: disabled || busy, onClick: onStart, title: labels.start, children: [
+    /* @__PURE__ */ jsx(Mic, { className: "mr-1.5 h-4 w-4" }),
+    labels.start
+  ] });
+}
+var RESUMABLE_WINDOW_MS = 30 * 60 * 1e3;
+function ScribeRecoveryBanner({ labels, onOpenSession }) {
+  const orphans2 = useScribeStore((s) => s.orphans);
+  const [busy, setBusy] = React6.useState(null);
+  if (orphans2.length === 0) return null;
+  const session = orphans2[0];
+  const interruptedAgoMs = Date.now() - session.lastTickEpochMs;
+  const canResume = interruptedAgoMs < RESUMABLE_WINDOW_MS;
+  const durationLabel = formatElapsed(session.accumulatedMs);
+  const run = async (fn) => {
+    setBusy(session.id);
+    try {
+      await fn();
+    } finally {
+      setBusy(null);
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "mx-3 mb-3 flex flex-col gap-2 rounded-lg border border-amber-500/40 bg-amber-500/10 p-3 md:mx-6 md:flex-row md:items-center md:justify-between", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-2", children: [
+      /* @__PURE__ */ jsx(AlertTriangle, { className: "mt-0.5 h-4 w-4 shrink-0 text-amber-600 dark:text-amber-400" }),
+      /* @__PURE__ */ jsxs("div", { className: "text-sm", children: [
+        /* @__PURE__ */ jsxs("p", { className: "font-medium", children: [
+          labels.sessionSingular,
+          " de ",
+          durationLabel,
+          " foi interrompido",
+          session.subjectName ? ` \u2014 ${session.subjectName}` : "",
+          "."
+        ] }),
+        /* @__PURE__ */ jsx("p", { className: "text-muted-foreground", children: "O \xE1udio j\xE1 gravado est\xE1 seguro e continua sendo enviado." })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex shrink-0 flex-wrap gap-1.5", children: [
+      canResume && /* @__PURE__ */ jsx(Button, { size: "sm", disabled: busy === session.id, onClick: () => void run(resumeSession), children: labels.resume }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          size: "sm",
+          variant: "outline",
+          disabled: busy === session.id,
+          onClick: () => void run(async () => {
+            const id = await endSession();
+            dismissOrphan(session.id);
+            if (id) onOpenSession?.(id);
+          }),
+          children: labels.finish
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          size: "sm",
+          variant: "ghost",
+          disabled: busy === session.id,
+          onClick: () => void run(() => discardSession(session.id)),
+          children: labels.discard
+        }
+      )
+    ] })
+  ] });
+}
+function ScribeConsentDialog({
+  open,
+  labels,
+  subjectName,
+  defaultConsentMode,
+  onCancel,
+  onConfirm
+}) {
+  const [acknowledged, setAcknowledged] = React6.useState(false);
+  React6.useEffect(() => {
+    if (open) setAcknowledged(false);
+  }, [open]);
+  return /* @__PURE__ */ jsx(Modal, { open, onOpenChange: (next) => !next && onCancel(), children: /* @__PURE__ */ jsxs(ModalContent, { size: "sm", children: [
+    /* @__PURE__ */ jsx(ModalHeader, { children: /* @__PURE__ */ jsxs(ModalTitle, { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx(Mic, { className: "h-4 w-4" }),
+      "Iniciar grava\xE7\xE3o"
+    ] }) }),
+    /* @__PURE__ */ jsxs(ModalBody, { className: "space-y-3 text-sm", children: [
+      /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground", children: [
+        "O \xE1udio ",
+        subjectName ? `de ${subjectName}` : `deste ${labels.sessionSingular.toLowerCase()}`,
+        " ser\xE1 gravado e transcrito para gerar um documento. A grava\xE7\xE3o fica vis\xEDvel na barra superior enquanto durar."
+      ] }),
+      /* @__PURE__ */ jsxs("label", { className: "flex cursor-pointer items-start gap-2 rounded-md border p-3", children: [
+        /* @__PURE__ */ jsx(Checkbox, { checked: acknowledged, onChange: setAcknowledged, className: "mt-0.5" }),
+        /* @__PURE__ */ jsxs("span", { children: [
+          "Informei ",
+          subjectName ?? "o titular",
+          " de que este atendimento ser\xE1 gravado e obtive o consentimento."
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("p", { className: "flex items-start gap-2 text-xs text-muted-foreground", children: [
+        /* @__PURE__ */ jsx(ShieldCheck, { className: "mt-0.5 h-3.5 w-3.5 shrink-0" }),
+        "O \xE1udio \xE9 armazenado de forma privada e pode ser apagado a qualquer momento \u2014 a transcri\xE7\xE3o e o documento assinado permanecem."
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(ModalFooter, { children: [
+      /* @__PURE__ */ jsx(Button, { variant: "outline", size: "sm", onClick: onCancel, children: "Cancelar" }),
+      /* @__PURE__ */ jsx(Button, { size: "sm", disabled: !acknowledged, onClick: () => onConfirm(defaultConsentMode), children: labels.start })
+    ] })
+  ] }) });
+}
+var SCRIBE_START_EVENT = "scribe:start";
+function ScribeShellMount({ labels, retention: retention2, locale, onOpenSession }) {
+  const { user } = useAuth();
+  const [pending, setPending] = React6.useState(null);
+  React6.useEffect(() => {
+    wireScribeStore();
+  }, []);
+  React6.useEffect(() => {
+    const onStart = (ev) => {
+      const detail = ev.detail ?? {};
+      if (retention2.requireConsent) setPending(detail);
+      else void start(detail, retention2.defaultConsentMode);
+    };
+    window.addEventListener(SCRIBE_START_EVENT, onStart);
+    return () => window.removeEventListener(SCRIBE_START_EVENT, onStart);
+  }, [retention2.requireConsent, retention2.defaultConsentMode, user?.id, locale]);
+  const start = React6.useCallback(
+    async (detail, consentMode) => {
+      if (!user?.id) {
+        toast.error("Fa\xE7a login para gravar um atendimento");
+        return;
+      }
+      const result = await beginSession({
+        userId: user.id,
+        subjectId: detail.subjectId,
+        subjectName: detail.subjectName,
+        appointmentId: detail.appointmentId,
+        templateKeys: detail.templateKeys,
+        locale,
+        consentMode
+      });
+      if (!result.ok) {
+        toast.error(`N\xE3o foi poss\xEDvel iniciar: ${result.reason}`);
+        return;
+      }
+      toast.success(`${labels.sessionSingular} iniciado`);
+    },
+    [user?.id, locale, labels.sessionSingular]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(ScribeRecordingPill, { labels, onOpenSession }),
+    /* @__PURE__ */ jsx(
+      ScribeConsentDialog,
+      {
+        open: pending !== null,
+        labels,
+        subjectName: pending?.subjectName,
+        defaultConsentMode: retention2.defaultConsentMode,
+        onCancel: () => setPending(null),
+        onConfirm: (mode) => {
+          const detail = pending;
+          setPending(null);
+          if (detail) void start(detail, mode);
+        }
+      }
+    ),
+    typeof document !== "undefined" && createPortal(
+      /* @__PURE__ */ jsx("div", { className: "pointer-events-auto fixed inset-x-0 top-14 z-40", children: /* @__PURE__ */ jsx(ScribeRecoveryBanner, { labels, onOpenSession }) }),
+      document.body
+    )
+  ] });
+}
+function requestScribeStart(detail) {
+  window.dispatchEvent(new CustomEvent(SCRIBE_START_EVENT, { detail }));
+}
+
+// src/lib/prompt.ts
+var PROMPT_VERSION = "scribe/narrative@1";
+function formatOffset(ms) {
+  const total = Math.floor(ms / 1e3);
+  const mm = String(Math.floor(total / 60)).padStart(2, "0");
+  const ss = String(total % 60).padStart(2, "0");
+  return `${mm}:${ss}`;
+}
+function renderTranscript(lines) {
+  return lines.filter((l) => l.gap || l.text?.trim()).map((l) => {
+    const at = formatOffset(l.startOffsetMs);
+    if (l.gap) return `[${at}] (((TRECHO AUSENTE \u2014 a grava\xE7\xE3o foi interrompida aqui)))`;
+    const who = l.speaker !== void 0 ? `Falante ${l.speaker + 1}: ` : "";
+    return `[${at}] ${who}${l.text.trim()}`;
+  }).join("\n");
+}
+function shapeInstruction(section) {
+  switch (section.shape) {
+    case "bullets":
+      return "Formato: lista com h\xEDfen. Itens curtos, um fato por item.";
+    case "keyvalue":
+      return "Formato: lista com h\xEDfen no padr\xE3o `- **R\xF3tulo:** valor`. Um par por linha.";
+    default:
+      return "Formato: prosa corrida, sem listas.";
+  }
+}
+function buildSystemPrompt(schema) {
+  const parts = [];
+  parts.push(
+    "Voc\xEA redige documentos a partir da transcri\xE7\xE3o de um atendimento gravado.",
+    "Escreva SOMENTE o que a transcri\xE7\xE3o sustenta. Voc\xEA n\xE3o \xE9 um assistente conversacional: sua sa\xEDda \xE9 o documento, nada mais."
+  );
+  if (schema.style) parts.push(`Estilo: ${schema.style}`);
+  if (schema.outputLocale) parts.push(`Escreva o documento em ${schema.outputLocale}, mesmo que a transcri\xE7\xE3o esteja em outro idioma.`);
+  parts.push(
+    "",
+    "REGRAS INEGOCI\xC1VEIS:",
+    "- Nunca invente fato, n\xFAmero, data, nome ou medida que n\xE3o esteja na transcri\xE7\xE3o.",
+    '- Quando a transcri\xE7\xE3o n\xE3o cobre algo que a se\xE7\xE3o pede, escreva "n\xE3o informado". N\xE3o deduza a partir do contexto.',
+    "- Onde a transcri\xE7\xE3o indicar `(((TRECHO AUSENTE)))`, N\xC3O costure os dois lados como se fossem cont\xEDnuos. Se aquilo afeta o que a se\xE7\xE3o diz, registre a lacuna.",
+    "- N\xE3o dirija a palavra ao leitor, n\xE3o comente o pr\xF3prio trabalho, n\xE3o pe\xE7a confirma\xE7\xE3o."
+  );
+  if (schema.neverInfer?.length) {
+    parts.push(
+      `- Estes itens NUNCA podem ser inferidos, apenas transcritos quando ditos explicitamente: ${schema.neverInfer.join(", ")}.`
+    );
+  }
+  parts.push(
+    "",
+    "FORMATO DA SA\xCDDA (markdown restrito):",
+    "- Cada se\xE7\xE3o come\xE7a com `## ` seguido exatamente do t\xEDtulo fornecido.",
+    "- Use no m\xE1ximo `###` para subt\xEDtulo. Nunca `####` ou mais fundo.",
+    "- PROIBIDO: tabela, link, imagem, bloco de c\xF3digo cercado por crases, HTML.",
+    "- Permitido: par\xE1grafo, lista com h\xEDfen, lista numerada, **negrito**, *it\xE1lico*.",
+    "- N\xE3o escreva pre\xE2mbulo nem fecho. A primeira linha da resposta \xE9 o primeiro `## `."
+  );
+  return parts.join("\n");
+}
+function buildUserPrompt(args) {
+  const { schema, transcript, context } = args;
+  const parts = [];
+  const ctx = Object.entries(context ?? {}).filter(([, v]) => v);
+  if (ctx.length > 0) {
+    parts.push("DADOS DO ATENDIMENTO (refer\xEAncia; n\xE3o repita como se\xE7\xE3o):");
+    for (const [k, v] of ctx) parts.push(`- ${k}: ${v}`);
+    parts.push("");
+  }
+  parts.push("TRANSCRI\xC7\xC3O:", '"""', transcript, '"""', "");
+  parts.push("SE\xC7\xD5ES A ESCREVER, nesta ordem:");
+  schema.sections.forEach((section, i) => {
+    parts.push("");
+    parts.push(`${i + 1}. ## ${section.heading}`);
+    parts.push(`   O que entra: ${section.guidance}`);
+    parts.push(`   ${shapeInstruction(section)}`);
+    if (section.maxWords) parts.push(`   Limite: cerca de ${section.maxWords} palavras.`);
+    if (section.required) parts.push('   Obrigat\xF3ria: escreva-a mesmo que s\xF3 para registrar "n\xE3o informado".');
+    else if (section.omitWhenEmpty) parts.push("   Se a transcri\xE7\xE3o n\xE3o disser nada sobre isto, OMITA a se\xE7\xE3o inteira, t\xEDtulo incluso.");
+  });
+  return parts.join("\n");
+}
+function parseSections(markdown, schema) {
+  const out = {};
+  if (!markdown) return out;
+  const norm = (s) => s.trim().toLowerCase().replace(/\s+/g, " ").replace(/[:.]+$/, "");
+  const byHeading = new Map(schema.sections.map((s) => [norm(s.heading), s.id]));
+  const lines = markdown.split("\n");
+  let currentId = null;
+  let buffer = [];
+  const flush = () => {
+    if (currentId) out[currentId] = buffer.join("\n").trim();
+    buffer = [];
+  };
+  for (const line of lines) {
+    const match = /^##\s+(.+?)\s*$/.exec(line);
+    if (match && !line.startsWith("###")) {
+      flush();
+      currentId = byHeading.get(norm(match[1])) ?? null;
+      continue;
+    }
+    if (currentId) buffer.push(line);
+  }
+  flush();
+  return out;
+}
+function deriveTitle(markdown, fallback, maxLen = 80) {
+  const firstBody = markdown.split("\n").find((l) => l.trim() && !l.startsWith("#") && !l.startsWith("-") && !l.startsWith(">"));
+  if (!firstBody) return fallback;
+  const clean = firstBody.replace(/[*_`]/g, "").trim();
+  return clean.length > maxLen ? `${clean.slice(0, maxLen - 1)}\u2026` : clean;
+}
+function TranscriptPanel({ segments, pending, emptyLabel }) {
+  const visible = segments.filter((s) => s.gap || s.text?.trim());
+  if (visible.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: "flex flex-col items-center justify-center gap-2 py-12 text-center text-sm text-muted-foreground", children: pending ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Loader2, { className: "h-5 w-5 animate-spin" }),
+      /* @__PURE__ */ jsx("p", { children: "Transcrevendo\u2026" }),
+      /* @__PURE__ */ jsx("p", { className: "text-xs", children: "O texto aparece conforme os trechos s\xE3o processados." })
+    ] }) : /* @__PURE__ */ jsx("p", { children: emptyLabel ?? "Nenhuma transcri\xE7\xE3o ainda." }) });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+    visible.map((seg) => {
+      if (seg.gap) {
+        return /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "flex items-center gap-2 rounded-md border border-dashed border-amber-500/40 bg-amber-500/5 px-3 py-2 text-xs text-amber-700 dark:text-amber-400",
+            children: [
+              /* @__PURE__ */ jsx(AlertTriangle, { className: "h-3.5 w-3.5 shrink-0" }),
+              /* @__PURE__ */ jsx("span", { className: "font-mono", children: formatOffset(seg.startOffsetMs) }),
+              /* @__PURE__ */ jsxs("span", { children: [
+                "Grava\xE7\xE3o interrompida",
+                seg.durationMs ? ` por ${Math.round(seg.durationMs / 1e3)}s` : ""
+              ] })
+            ]
+          },
+          seg.segIndex
+        );
+      }
+      const speaker = seg.words?.[0]?.sp;
+      return /* @__PURE__ */ jsxs("div", { className: "flex gap-3", children: [
+        /* @__PURE__ */ jsx("span", { className: "w-12 shrink-0 pt-0.5 font-mono text-xs text-muted-foreground", children: formatOffset(seg.startOffsetMs) }),
+        /* @__PURE__ */ jsxs("div", { className: "min-w-0 flex-1", children: [
+          speaker !== void 0 && /* @__PURE__ */ jsxs(Badge, { variant: "secondary", className: "mb-1 text-[10px]", children: [
+            "Falante ",
+            speaker + 1
+          ] }),
+          /* @__PURE__ */ jsxs("p", { className: "text-sm leading-relaxed", children: [
+            seg.text,
+            seg.partial && /* @__PURE__ */ jsx("span", { className: "ml-1 text-xs text-muted-foreground", children: "(trecho parcial)" })
+          ] })
+        ] })
+      ] }, seg.segIndex);
+    }),
+    pending && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 pl-15 text-xs text-muted-foreground", children: [
+      /* @__PURE__ */ jsx(Loader2, { className: "h-3.5 w-3.5 animate-spin" }),
+      "Transcrevendo o restante\u2026"
+    ] })
+  ] });
+}
+function client() {
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) throw new Error("Supabase n\xE3o inicializado");
+  return supabase;
+}
+function mapSession(r) {
+  return {
+    id: r.id,
+    tenantId: r.tenant_id,
+    subjectId: r.subject_id ?? void 0,
+    contextKind: r.context_kind,
+    appointmentId: r.appointment_id ?? void 0,
+    ownerUserId: r.owner_user_id,
+    status: r.status,
+    locale: r.locale,
+    mimeType: r.mime_type ?? void 0,
+    startedAt: r.started_at,
+    endedAt: r.ended_at ?? void 0,
+    wallDurationMs: r.wall_duration_ms ?? 0,
+    audioDurationMs: r.audio_duration_ms ?? 0,
+    segmentCount: r.segment_count ?? 0,
+    uploadedSegmentCount: r.uploaded_segment_count ?? 0,
+    transcribedSegmentCount: r.transcribed_segment_count ?? 0,
+    transcriptChars: r.transcript_chars ?? 0,
+    consentAt: r.consent_at ?? void 0,
+    consentMode: r.consent_mode ?? void 0,
+    retentionUntil: r.retention_until ?? void 0,
+    audioDeletedAt: r.audio_deleted_at ?? void 0,
+    error: r.error ?? void 0,
+    metadata: r.metadata ?? {}
+  };
+}
+function mapSegment(r) {
+  return {
+    sessionId: r.session_id,
+    segIndex: r.seg_index,
+    tenantId: r.tenant_id,
+    storagePath: r.storage_path ?? void 0,
+    bytes: r.bytes ?? void 0,
+    startOffsetMs: r.start_offset_ms ?? 0,
+    durationMs: r.duration_ms ?? void 0,
+    partial: !!r.partial,
+    gap: !!r.gap,
+    uploadState: r.upload_state,
+    uploadedAt: r.uploaded_at ?? void 0,
+    sttState: r.stt_state,
+    sttProvider: r.stt_provider ?? void 0,
+    sttAttempts: r.stt_attempts ?? 0,
+    sttError: r.stt_error ?? void 0,
+    text: r.text ?? void 0,
+    words: r.words ?? void 0,
+    confidence: r.confidence ?? void 0
+  };
+}
+function mapGeneration(r) {
+  return {
+    id: r.id,
+    tenantId: r.tenant_id,
+    sessionId: r.session_id,
+    templateId: r.template_id ?? void 0,
+    templateKey: r.template_key ?? void 0,
+    tabOrder: r.tab_order ?? 0,
+    title: r.title ?? void 0,
+    status: r.status,
+    markdown: r.markdown ?? void 0,
+    markdownEdited: r.markdown_edited ?? void 0,
+    facts: r.facts ?? void 0,
+    model: r.model ?? void 0,
+    promptVersion: r.prompt_version ?? void 0,
+    inputTokens: r.input_tokens ?? void 0,
+    outputTokens: r.output_tokens ?? void 0,
+    error: r.error ?? void 0,
+    documentId: r.document_id ?? void 0,
+    createdBy: r.created_by ?? void 0,
+    createdAt: r.created_at
+  };
+}
+async function fetchSession(sessionId) {
+  const { data, error } = await client().from(T.sessions).select("*").eq("id", sessionId).maybeSingle();
+  if (error) throw error;
+  return data ? mapSession(data) : null;
+}
+async function fetchSegments(sessionId) {
+  const { data, error } = await client().from(T.segments).select("*").eq("session_id", sessionId).order("seg_index", { ascending: true });
+  if (error) throw error;
+  return (data ?? []).map(mapSegment);
+}
+async function fetchGenerations(sessionId) {
+  const { data, error } = await client().from(T.generations).select("*").eq("session_id", sessionId).neq("status", "discarded").order("tab_order", { ascending: true });
+  if (error) throw error;
+  return (data ?? []).map(mapGeneration);
+}
+async function fetchOpenSessions(userId) {
+  const { data, error } = await client().from(T.sessions).select("*").eq("owner_user_id", userId).in("status", ["recording", "paused", "interrupted", "uploading", "transcribing", "ready", "generating"]).order("started_at", { ascending: false }).limit(20);
+  if (error) throw error;
+  return (data ?? []).map(mapSession);
+}
+async function fetchSessionsForSubject(subjectId) {
+  const { data, error } = await client().from(T.sessions).select("*").eq("subject_id", subjectId).order("started_at", { ascending: false }).limit(50);
+  if (error) throw error;
+  return (data ?? []).map(mapSession);
+}
+async function saveDraft(generationId, markdownEdited) {
+  const { error } = await client().from(T.generations).update({ markdown_edited: markdownEdited, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", generationId);
+  if (error) throw error;
+}
+async function discardGeneration(generationId) {
+  const { error } = await client().from(T.generations).update({ status: "discarded", updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", generationId);
+  if (error) throw error;
+}
+async function commitGeneration(args) {
+  const supabase = client();
+  const { generation, session, markdown, title, sections, edited } = args;
+  const { data: doc, error: docErr } = await supabase.from("documents").insert({
+    tenant_id: session.tenantId,
+    kind: "form",
+    person_id: session.subjectId ?? null,
+    title,
+    status: "completed",
+    metadata: {
+      scribe: {
+        sessionId: session.id,
+        generationId: generation.id,
+        model: generation.model,
+        promptVersion: generation.promptVersion,
+        edited,
+        audioDurationMs: session.audioDurationMs
+      }
+    }
+  }).select("id").single();
+  if (docErr || !doc) throw docErr ?? new Error("falha ao criar o documento");
+  const { error: extErr } = await supabase.from("plg_forms_documents").insert({
+    document_id: doc.id,
+    tenant_id: session.tenantId,
+    template_id: generation.templateId ?? null,
+    data: {
+      markdown,
+      sections,
+      sourceSessionId: session.id,
+      generationId: generation.id
+    }
+  });
+  if (extErr) throw extErr;
+  const { error: genErr } = await supabase.from(T.generations).update({ status: "committed", document_id: doc.id, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", generation.id);
+  if (genErr) throw genErr;
+  await maybeCompleteSession(session.id);
+  return doc.id;
+}
+async function maybeCompleteSession(sessionId) {
+  const supabase = client();
+  const { data } = await supabase.from(T.generations).select("status").eq("session_id", sessionId);
+  if (!data || data.length === 0) return;
+  const open = data.filter((g) => !["committed", "discarded"].includes(g.status));
+  if (open.length > 0) return;
+  await supabase.from(T.sessions).update({ status: "completed", updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", sessionId);
+}
+async function deleteSessionAudio(session) {
+  const supabase = client();
+  const prefix = sessionPrefix({
+    tenantId: session.tenantId,
+    sessionId: session.id,
+    startedAt: new Date(session.startedAt)
+  });
+  const { data: files } = await supabase.storage.from(AUDIO_BUCKET).list(prefix);
+  const paths = (files ?? []).map((f) => `${prefix}/${f.name}`);
+  if (paths.length > 0) await supabase.storage.from(AUDIO_BUCKET).remove(paths);
+  await supabase.from(T.sessions).update({ audio_deleted_at: (/* @__PURE__ */ new Date()).toISOString(), updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", session.id);
+  await supabase.from(T.segments).update({ storage_path: null, upload_state: "missing" }).eq("session_id", session.id);
+  return paths.length;
+}
+async function invokeTranscribe(args) {
+  const { data, error } = await client().functions.invoke(args.endpoint, {
+    body: {
+      action: "drain",
+      sessionId: args.sessionId,
+      provider: args.provider,
+      model: args.model,
+      diarize: args.diarize
+    }
+  });
+  if (error) throw error;
+  if (data?.error) throw new Error(data.error);
+  return { transcribed: data?.transcribed ?? 0, failed: data?.failed ?? 0, remaining: data?.remaining ?? 0 };
+}
+async function invokeGenerate(args) {
+  const { data, error } = await client().functions.invoke(args.endpoint, {
+    body: {
+      sessionId: args.sessionId,
+      templateId: args.templateId,
+      templateKey: args.templateKey,
+      schema: args.schema,
+      tabOrder: args.tabOrder ?? 0
+    }
+  });
+  if (error) throw error;
+  if (data?.error) throw new Error(data.error);
+  return { generationId: data.generationId, markdown: data.markdown };
+}
+var AUTOSAVE_DEBOUNCE_MS = 2e3;
+function DraftPanel({
+  generation,
+  session,
+  schema,
+  templateName,
+  labels,
+  onRegenerate,
+  onCommitted,
+  onDiscarded
+}) {
+  const original = generation.markdown ?? "";
+  const [value, setValue] = React6.useState(generation.markdownEdited ?? original);
+  const [saving, setSaving] = React6.useState(false);
+  const [committing, setCommitting] = React6.useState(false);
+  const timer2 = React6.useRef(null);
+  React6.useEffect(() => {
+    setValue(generation.markdownEdited ?? generation.markdown ?? "");
+  }, [generation.id, generation.markdown, generation.markdownEdited]);
+  const edited = value.trim() !== original.trim();
+  const handleChange = React6.useCallback(
+    (next) => {
+      setValue(next);
+      if (timer2.current) clearTimeout(timer2.current);
+      timer2.current = setTimeout(() => {
+        setSaving(true);
+        saveDraft(generation.id, next).catch(() => toast.error("N\xE3o foi poss\xEDvel salvar o rascunho")).finally(() => setSaving(false));
+      }, AUTOSAVE_DEBOUNCE_MS);
+    },
+    [generation.id]
+  );
+  React6.useEffect(() => {
+    return () => {
+      if (timer2.current) {
+        clearTimeout(timer2.current);
+        void saveDraft(generation.id, value).catch(() => void 0);
+      }
+    };
+  }, [generation.id, value]);
+  const handleCommit = React6.useCallback(async () => {
+    setCommitting(true);
+    try {
+      if (timer2.current) clearTimeout(timer2.current);
+      await saveDraft(generation.id, value);
+      const documentId = await commitGeneration({
+        generation,
+        session,
+        markdown: value,
+        title: generation.title ?? deriveTitle(value, templateName),
+        sections: parseSections(value, schema),
+        edited
+      });
+      toast.success("Documento salvo na ficha");
+      onCommitted(documentId);
+    } catch (err) {
+      toast.error(`N\xE3o foi poss\xEDvel salvar: ${err?.message ?? err}`);
+    } finally {
+      setCommitting(false);
+    }
+  }, [generation, session, value, schema, templateName, edited, onCommitted]);
+  if (generation.status === "running" || generation.status === "pending") {
+    return /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center justify-center gap-2 py-16 text-sm text-muted-foreground", children: [
+      /* @__PURE__ */ jsx(Loader2, { className: "h-5 w-5 animate-spin" }),
+      /* @__PURE__ */ jsxs("p", { children: [
+        "Gerando ",
+        templateName.toLowerCase(),
+        "\u2026"
+      ] })
+    ] });
+  }
+  if (generation.status === "failed") {
+    return /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center justify-center gap-3 py-16 text-sm", children: [
+      /* @__PURE__ */ jsx("p", { className: "text-destructive", children: generation.error ?? "A gera\xE7\xE3o falhou." }),
+      /* @__PURE__ */ jsxs(Button, { size: "sm", variant: "outline", onClick: onRegenerate, children: [
+        /* @__PURE__ */ jsx(RefreshCw, { className: "mr-1.5 h-4 w-4" }),
+        "Tentar novamente"
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center justify-between gap-2", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-xs text-muted-foreground", children: [
+        edited ? /* @__PURE__ */ jsx(Badge, { variant: "secondary", children: "Editado" }) : /* @__PURE__ */ jsx(Badge, { variant: "outline", children: "Gerado por IA" }),
+        saving && /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-1", children: [
+          /* @__PURE__ */ jsx(Loader2, { className: "h-3 w-3 animate-spin" }),
+          "salvando\u2026"
+        ] }),
+        generation.model && /* @__PURE__ */ jsxs("span", { className: "hidden sm:inline", children: [
+          "\xB7 ",
+          generation.model
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "flex gap-1.5", children: [
+        /* @__PURE__ */ jsxs(Button, { size: "sm", variant: "ghost", onClick: onRegenerate, disabled: committing, children: [
+          /* @__PURE__ */ jsx(RefreshCw, { className: "mr-1.5 h-3.5 w-3.5" }),
+          "Regerar"
+        ] }),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            size: "sm",
+            variant: "ghost",
+            disabled: committing,
+            onClick: () => void discardGeneration(generation.id).then(onDiscarded).catch(() => toast.error("Falha ao descartar")),
+            children: [
+              /* @__PURE__ */ jsx(Trash2, { className: "mr-1.5 h-3.5 w-3.5" }),
+              labels.discard
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(Button, { size: "sm", onClick: () => void handleCommit(), disabled: committing || !value.trim(), children: [
+          committing ? /* @__PURE__ */ jsx(Loader2, { className: "mr-1.5 h-3.5 w-3.5 animate-spin" }) : /* @__PURE__ */ jsx(Check, { className: "mr-1.5 h-3.5 w-3.5" }),
+          "Salvar na ficha"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(
+      MarkdownEditor,
+      {
+        value,
+        onChange: handleChange,
+        minRows: 20,
+        defaultMode: "preview",
+        editLabel: "Editar",
+        previewLabel: "Visualizar"
+      }
+    ),
+    schema.disclaimer && /* @__PURE__ */ jsx("p", { className: "text-xs italic text-muted-foreground", children: schema.disclaimer })
+  ] });
+}
+
+// src/lib/config.ts
+function usesFayzTransport(stt) {
+  return (stt.transport ?? "fayz") === "fayz";
+}
+function assertSttConfig(stt) {
+  if (!stt) {
+    throw new Error("[plugin-scribe] a op\xE7\xE3o `stt` \xE9 obrigat\xF3ria.");
+  }
+  if (!usesFayzTransport(stt)) {
+    if (!stt.endpoint) {
+      throw new Error(
+        '[plugin-scribe] com transport: "edge" o stt.endpoint \xE9 obrigat\xF3rio. Sem um endpoint pr\xF3prio de transcri\xE7\xE3o o \xE1udio do atendimento sairia para um terceiro n\xE3o declarado \u2014 o plugin recusa a subir.'
+      );
+    }
+    return;
+  }
+  if (stt.provider !== "openai") {
+    throw new Error(
+      `[plugin-scribe] transport: "fayz" s\xF3 fala com provider: "openai" (recebido: "${stt.provider}"). Para Deepgram use transport: "edge" com uma edge function pr\xF3pria.`
+    );
+  }
+}
+
+// src/lib/transport.ts
+var KEY_HEADER = "x-fayz-agent-key";
+function createFayzTransport() {
+  const connection = resolveFayzAgentConnection();
+  if (!connection) return null;
+  const base = `${connection.apiBaseUrl.replace(/\/+$/, "")}/public/projects/${connection.projectId}/agents`;
+  async function readError(res) {
+    let detail = "";
+    try {
+      const body = await res.json();
+      detail = body?.error ?? "";
+    } catch {
+      detail = await res.text().catch(() => "");
+    }
+    throw new Error(`fayz ${res.status}${detail ? `: ${detail}` : ""}`);
+  }
+  return {
+    kind: "fayz",
+    async transcribeClip({ audio, mimeType, locale, model, context }) {
+      const form = new FormData();
+      form.append("file", audio, `clip.${extOf(mimeType)}`);
+      if (model) form.append("model", model);
+      form.append("language", locale);
+      if (context) form.append("prompt", context);
+      const res = await fetch(`${base}/transcribe`, {
+        method: "POST",
+        headers: { [KEY_HEADER]: connection.publishableKey },
+        body: form
+      });
+      if (!res.ok) await readError(res);
+      const json = await res.json();
+      return {
+        text: json.text ?? "",
+        words: json.words ?? [],
+        durationMs: json.durationMs ?? 0,
+        // The broker returns no aggregate confidence; 0 means "not reported",
+        // same as durationMs.
+        confidence: 0,
+        provider: json.provider ?? "fayz"
+      };
+    },
+    async complete({ system, user, model, temperature, maxTokens }) {
+      const res = await fetch(`${base}/complete`, {
+        method: "POST",
+        headers: { [KEY_HEADER]: connection.publishableKey, "Content-Type": "application/json" },
+        body: JSON.stringify({ system, user, model, temperature, maxTokens })
+      });
+      if (!res.ok) await readError(res);
+      const json = await res.json();
+      return {
+        content: json.content ?? "",
+        model: json.model ?? (model ?? "auto"),
+        tokensIn: json.tokensIn,
+        tokensOut: json.tokensOut
+      };
+    }
+  };
+}
+function extOf(mimeType) {
+  const type = mimeType.split(";")[0]?.trim().toLowerCase() ?? "";
+  if (type === "audio/ogg") return "ogg";
+  if (type === "audio/mp4" || type === "audio/mpeg") return "m4a";
+  if (type === "audio/mpga" || type === "audio/mp3") return "mp3";
+  if (type === "audio/wav" || type === "audio/x-wav") return "wav";
+  return "webm";
+}
+function resolveScribeTransport(stt) {
+  if (!usesFayzTransport(stt)) return null;
+  return createFayzTransport();
+}
+
+// src/lib/drain.ts
+var CONCURRENCY2 = 3;
+var MAX_ATTEMPTS = 4;
+function client2() {
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) throw new Error("Supabase not initialized");
+  return supabase;
+}
+async function drainSessionViaTransport(sessionId, stt) {
+  const transport = resolveScribeTransport(stt);
+  if (!transport) return null;
+  const supabase = client2();
+  const { data: session } = await supabase.from(T.sessions).select("id, locale, mime_type, status, ended_at").eq("id", sessionId).maybeSingle();
+  if (!session) throw new Error("session not found");
+  const { data: pending } = await supabase.from(T.segments).select("session_id, seg_index, storage_path, stt_attempts").eq("session_id", sessionId).eq("upload_state", "uploaded").in("stt_state", ["pending", "failed"]).lt("stt_attempts", MAX_ATTEMPTS).order("seg_index", { ascending: true });
+  if (!pending || pending.length === 0) {
+    await recomputeCounters(supabase, sessionId);
+    await maybeMarkReady(supabase, sessionId);
+    return { transcribed: 0, failed: 0, remaining: 0 };
+  }
+  let transcribed = 0;
+  let failed = 0;
+  for (let i = 0; i < pending.length; i += CONCURRENCY2) {
+    const batch = pending.slice(i, i + CONCURRENCY2);
+    const results = await Promise.all(
+      batch.map(
+        (seg) => transcribeOne(supabase, transport, seg, {
+          locale: session.locale ?? stt.locale ?? "pt-BR",
+          mimeType: session.mime_type ?? "audio/webm",
+          model: stt.model
+        })
+      )
+    );
+    transcribed += results.filter(Boolean).length;
+    failed += results.filter((ok) => !ok).length;
+  }
+  await recomputeCounters(supabase, sessionId);
+  await maybeMarkReady(supabase, sessionId);
+  const { count } = await supabase.from(T.segments).select("seg_index", { count: "exact", head: true }).eq("session_id", sessionId).eq("upload_state", "uploaded").in("stt_state", ["pending", "failed"]).lt("stt_attempts", MAX_ATTEMPTS);
+  return { transcribed, failed, remaining: count ?? 0 };
+}
+async function transcribeOne(supabase, transport, seg, opts) {
+  if (!seg.storage_path) return false;
+  const where = (q) => q.eq("session_id", seg.session_id).eq("seg_index", seg.seg_index);
+  try {
+    await where(
+      supabase.from(T.segments).update({
+        stt_state: "running",
+        stt_attempts: (seg.stt_attempts ?? 0) + 1,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    const { data: file, error: dlErr } = await supabase.storage.from(AUDIO_BUCKET).download(seg.storage_path);
+    if (dlErr || !file) throw new Error(`download failed: ${dlErr?.message ?? "no body"}`);
+    const context = await previousTail(supabase, seg.session_id, seg.seg_index);
+    const result = await transport.transcribeClip({
+      audio: file,
+      mimeType: opts.mimeType,
+      locale: opts.locale,
+      model: opts.model,
+      context
+    });
+    await where(
+      supabase.from(T.segments).update({
+        stt_state: "done",
+        stt_provider: result.provider,
+        stt_error: null,
+        text: result.text,
+        words: result.words,
+        confidence: result.confidence,
+        // AUTHORITATIVE duration: measured in the audio, never counted in JS.
+        // A provider that does not report it returns 0, and 0 becomes NULL
+        // rather than a zero-minute session.
+        duration_ms: result.durationMs > 0 ? result.durationMs : null,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    return true;
+  } catch (err) {
+    await where(
+      supabase.from(T.segments).update({
+        stt_state: "failed",
+        stt_error: String(err?.message ?? err).slice(0, 500),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    return false;
+  }
+}
+async function previousTail(supabase, sessionId, segIndex) {
+  if (segIndex === 0) return void 0;
+  const { data } = await supabase.from(T.segments).select("text").eq("session_id", sessionId).eq("seg_index", segIndex - 1).maybeSingle();
+  const text = data?.text;
+  return text ? text.slice(-200) : void 0;
+}
+async function recomputeCounters(supabase, sessionId) {
+  const { data: segs } = await supabase.from(T.segments).select("stt_state, duration_ms, text, gap").eq("session_id", sessionId);
+  if (!segs) return;
+  await supabase.from(T.sessions).update({
+    transcribed_segment_count: segs.filter((s) => s.stt_state === "done").length,
+    audio_duration_ms: segs.filter((s) => !s.gap).reduce((acc, s) => acc + (s.duration_ms ?? 0), 0),
+    transcript_chars: segs.reduce((acc, s) => acc + (s.text?.length ?? 0), 0),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).eq("id", sessionId);
+}
+async function maybeMarkReady(supabase, sessionId) {
+  const { data: session } = await supabase.from(T.sessions).select("status, ended_at").eq("id", sessionId).maybeSingle();
+  if (!session?.ended_at) return;
+  if (!["uploading", "transcribing", "recording", "paused", "interrupted"].includes(session.status)) return;
+  const { data: segs } = await supabase.from(T.segments).select("stt_state, stt_attempts, upload_state").eq("session_id", sessionId);
+  if (!segs || segs.length === 0) return;
+  const outstanding = segs.filter(
+    (s) => s.upload_state === "uploaded" && ["pending", "running", "failed"].includes(s.stt_state) && (s.stt_attempts ?? 0) < MAX_ATTEMPTS
+  );
+  await supabase.from(T.sessions).update({
+    status: outstanding.length === 0 ? "ready" : "transcribing",
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).eq("id", sessionId);
+}
+var TEMPERATURE = 0.2;
+var MAX_TOKENS = 4e3;
+function client3() {
+  const supabase = getSupabaseClientOptional();
+  if (!supabase) throw new Error("Supabase n\xE3o inicializado");
+  return supabase;
+}
+async function generateViaTransport(args) {
+  const transport = resolveScribeTransport(args.stt);
+  if (!transport) return null;
+  const supabase = client3();
+  const { data: userData } = await supabase.auth.getUser();
+  const userId = userData?.user?.id;
+  if (!userId) throw new Error("n\xE3o autenticado");
+  const { data: session } = await supabase.from(T.sessions).select("id, tenant_id, subject_id, started_at, audio_duration_ms, locale").eq("id", args.sessionId).maybeSingle();
+  if (!session) throw new Error("sess\xE3o n\xE3o encontrada");
+  const lines = await loadTranscript(supabase, args.sessionId);
+  if (!lines.some((l) => !l.gap && l.text.trim())) {
+    throw new Error("n\xE3o h\xE1 transcri\xE7\xE3o para gerar o documento");
+  }
+  const { data: created, error: insErr } = await supabase.from(T.generations).insert({
+    tenant_id: session.tenant_id,
+    session_id: args.sessionId,
+    template_id: args.templateId ?? null,
+    template_key: args.templateKey ?? null,
+    tab_order: args.tabOrder ?? 0,
+    status: "running",
+    prompt_version: PROMPT_VERSION,
+    created_by: userId
+  }).select("id").single();
+  if (insErr || !created) throw new Error(`falha ao criar a gera\xE7\xE3o: ${insErr?.message}`);
+  const generationId = created.id;
+  try {
+    let subjectName;
+    if (session.subject_id) {
+      const { data: person } = await supabase.from("people").select("name").eq("id", session.subject_id).maybeSingle();
+      subjectName = person?.name;
+    }
+    const result = await transport.complete({
+      system: buildSystemPrompt(args.schema),
+      user: buildUserPrompt({
+        schema: args.schema,
+        transcript: renderTranscript(lines),
+        context: {
+          Titular: subjectName,
+          Data: new Date(session.started_at).toLocaleDateString(session.locale ?? "pt-BR"),
+          "Dura\xE7\xE3o (min)": String(Math.round((session.audio_duration_ms ?? 0) / 6e4))
+        }
+      }),
+      model: args.model,
+      temperature: TEMPERATURE,
+      maxTokens: MAX_TOKENS
+    });
+    const markdown = result.content.trim();
+    if (!markdown) throw new Error("o modelo devolveu um documento vazio");
+    await supabase.from(T.generations).update({
+      status: "ready",
+      markdown,
+      title: deriveTitle(markdown, args.templateName),
+      model: result.model,
+      input_tokens: result.tokensIn ?? null,
+      output_tokens: result.tokensOut ?? null,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("id", generationId);
+    await supabase.from(T.sessions).update({ status: "generating", updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", args.sessionId);
+    return { generationId, markdown, model: result.model };
+  } catch (err) {
+    const message = String(err?.message ?? err);
+    await supabase.from(T.generations).update({ status: "failed", error: message.slice(0, 500), updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", generationId);
+    throw err;
+  }
+}
+async function loadTranscript(supabase, sessionId) {
+  const { data } = await supabase.from(T.segments).select("seg_index, start_offset_ms, text, gap, words").eq("session_id", sessionId).order("seg_index", { ascending: true });
+  if (!data) return [];
+  return data.map((s) => ({
+    startOffsetMs: s.start_offset_ms ?? 0,
+    text: s.text ?? "",
+    gap: !!s.gap,
+    speaker: Array.isArray(s.words) && s.words.length > 0 ? s.words[0]?.sp : void 0
+  }));
+}
+var POLL_MS = 5e3;
+function ScribeSessionPage({
+  sessionId,
+  labels,
+  presets,
+  stt,
+  generateEndpoint,
+  onOpenDocument,
+  onBack
+}) {
+  const [session, setSession] = React6.useState(null);
+  const [segments, setSegments] = React6.useState([]);
+  const [generations, setGenerations] = React6.useState([]);
+  const [loading, setLoading] = React6.useState(true);
+  const [generating, setGenerating] = React6.useState(false);
+  const [tab, setTab] = React6.useState("transcript");
+  const draining = React6.useRef(false);
+  const refresh = React6.useCallback(async () => {
+    const [s, segs, gens] = await Promise.all([
+      fetchSession(sessionId),
+      fetchSegments(sessionId),
+      fetchGenerations(sessionId)
+    ]);
+    setSession(s);
+    setSegments(segs);
+    setGenerations(gens);
+    return { session: s, segments: segs };
+  }, [sessionId]);
+  React6.useEffect(() => {
+    setLoading(true);
+    void refresh().finally(() => setLoading(false));
+  }, [refresh]);
+  const pendingStt = React6.useMemo(
+    () => segments.filter((s) => s.uploadState === "uploaded" && ["pending", "failed"].includes(s.sttState) && s.sttAttempts < 4),
+    [segments]
+  );
+  const busy = pendingStt.length > 0 || segments.some((s) => s.sttState === "running");
+  React6.useEffect(() => {
+    if (!busy) return;
+    const id = setInterval(() => {
+      void (async () => {
+        if (draining.current) return;
+        draining.current = true;
+        try {
+          if (pendingStt.length > 0) {
+            const drained = await drainSessionViaTransport(sessionId, stt);
+            if (drained === null) {
+              await invokeTranscribe({
+                endpoint: stt.endpoint,
+                sessionId,
+                provider: stt.provider,
+                model: stt.model,
+                diarize: stt.diarize
+              });
+            }
+          }
+          await refresh();
+        } catch {
+        } finally {
+          draining.current = false;
+        }
+      })();
+    }, POLL_MS);
+    return () => clearInterval(id);
+  }, [busy, pendingStt.length, sessionId, stt, refresh]);
+  const hasTranscript = segments.some((s) => !s.gap && s.text?.trim());
+  const handleGenerate = React6.useCallback(
+    async (preset) => {
+      setGenerating(true);
+      try {
+        const viaTransport = await generateViaTransport({
+          sessionId,
+          schema: preset.schema,
+          templateName: typeof preset.name === "string" ? preset.name : "Documento",
+          templateKey: preset.key,
+          tabOrder: generations.length,
+          stt
+        });
+        const generationId = viaTransport?.generationId ?? (await invokeGenerate({
+          endpoint: generateEndpoint,
+          sessionId,
+          templateKey: preset.key,
+          schema: preset.schema,
+          tabOrder: generations.length
+        })).generationId;
+        await refresh();
+        setTab(generationId);
+      } catch (err) {
+        toast.error(`N\xE3o foi poss\xEDvel gerar: ${err?.message ?? err}`);
+      } finally {
+        setGenerating(false);
+      }
+    },
+    [generateEndpoint, sessionId, generations.length, refresh, stt]
+  );
+  const activeGeneration = generations.find((g) => g.id === tab);
+  useAgentSurface(
+    React6.useMemo(
+      () => ({
+        id: "scribe.session",
+        describe: () => ({
+          title: `${labels.sessionSingular} \u2014 ${session?.startedAt ? new Date(session.startedAt).toLocaleDateString() : ""}`,
+          state: {
+            durationMinutes: Math.round((session?.audioDurationMs ?? 0) / 6e4),
+            transcriptExcerpt: segments.filter((s) => s.text).map((s) => s.text).join(" ").slice(0, 4e3),
+            documentMarkdown: activeGeneration?.markdownEdited ?? activeGeneration?.markdown,
+            documentStatus: activeGeneration?.status
+          },
+          record: session?.subjectId ? { entity: "person", id: session.subjectId, label: labels.subject } : void 0
+        }),
+        instructions: [
+          `O usu\xE1rio est\xE1 revisando um ${labels.sessionSingular.toLowerCase()} gravado e transcrito.`,
+          'Responda "o que foi dito sobre X" citando o trecho da transcri\xE7\xE3o, sempre com o minuto.',
+          "Nunca afirme algo que a transcri\xE7\xE3o n\xE3o sustente \u2014 diga que n\xE3o foi mencionado."
+        ].join(" ")
+      }),
+      [session, segments, activeGeneration, labels]
+    )
+  );
+  if (loading) {
+    return /* @__PURE__ */ jsx("div", { className: "flex justify-center py-16", children: /* @__PURE__ */ jsx(Loader2, { className: "h-6 w-6 animate-spin text-muted-foreground" }) });
+  }
+  if (!session) {
+    return /* @__PURE__ */ jsx("p", { className: "py-16 text-center text-sm text-muted-foreground", children: "Sess\xE3o n\xE3o encontrada." });
+  }
+  const uploadPending = session.segmentCount - session.uploadedSegmentCount;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-4", children: [
+    /* @__PURE__ */ jsx(
+      SubpageHeader,
+      {
+        title: labels.sessionSingular,
+        parentLabel: onBack ? labels.sessionPlural : void 0,
+        onBack
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2 text-sm text-muted-foreground", children: [
+      /* @__PURE__ */ jsx(Badge, { variant: "outline", children: new Date(session.startedAt).toLocaleString() }),
+      /* @__PURE__ */ jsxs(Badge, { variant: "outline", children: [
+        formatElapsed(session.audioDurationMs),
+        " de \xE1udio"
+      ] }),
+      /* @__PURE__ */ jsx(Badge, { variant: session.status === "ready" || session.status === "completed" ? "secondary" : "outline", children: statusLabel(session.status) }),
+      uploadPending > 0 && /* @__PURE__ */ jsxs(Badge, { variant: "outline", className: "text-amber-600", children: [
+        uploadPending,
+        " trecho",
+        uploadPending > 1 ? "s" : "",
+        " enviando"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Tabs, { value: tab, onValueChange: setTab, children: [
+      /* @__PURE__ */ jsxs(TabsList, { className: "max-w-full justify-start overflow-x-auto scrollbar-none", children: [
+        /* @__PURE__ */ jsxs(TabsTrigger, { value: "transcript", className: "gap-1.5", children: [
+          /* @__PURE__ */ jsx(FileText, { className: "h-3.5 w-3.5" }),
+          labels.transcript
+        ] }),
+        generations.map((g) => /* @__PURE__ */ jsxs(TabsTrigger, { value: g.id, className: "gap-1.5", children: [
+          /* @__PURE__ */ jsx(Sparkles, { className: "h-3.5 w-3.5" }),
+          g.title ?? presets.find((p) => p.key === g.templateKey)?.name ?? "Documento"
+        ] }, g.id))
+      ] }),
+      /* @__PURE__ */ jsxs(TabsContent, { value: "transcript", className: "mt-4", children: [
+        /* @__PURE__ */ jsx(Card, { children: /* @__PURE__ */ jsx(CardContent, { className: "pt-6", children: /* @__PURE__ */ jsx(TranscriptPanel, { segments, pending: busy }) }) }),
+        hasTranscript && /* @__PURE__ */ jsx("div", { className: "mt-4 flex flex-wrap gap-2", children: presets.map((preset) => /* @__PURE__ */ jsxs(
+          Button,
+          {
+            size: "sm",
+            variant: generations.length === 0 ? "default" : "outline",
+            disabled: generating,
+            onClick: () => void handleGenerate(preset),
+            children: [
+              generating ? /* @__PURE__ */ jsx(Loader2, { className: "mr-1.5 h-4 w-4 animate-spin" }) : /* @__PURE__ */ jsx(Sparkles, { className: "mr-1.5 h-4 w-4" }),
+              labels.generate,
+              ": ",
+              preset.name
+            ]
+          },
+          preset.key
+        )) })
+      ] }),
+      generations.map((g) => {
+        const preset = presets.find((p) => p.key === g.templateKey);
+        if (!preset) return null;
+        return /* @__PURE__ */ jsx(TabsContent, { value: g.id, className: "mt-4", children: /* @__PURE__ */ jsx(
+          DraftPanel,
+          {
+            generation: g,
+            session,
+            schema: preset.schema,
+            templateName: preset.name,
+            labels,
+            onRegenerate: () => void handleGenerate(preset),
+            onCommitted: (documentId) => {
+              void refresh();
+              onOpenDocument?.(documentId);
+            },
+            onDiscarded: () => {
+              setTab("transcript");
+              void refresh();
+            }
+          }
+        ) }, g.id);
+      })
+    ] })
+  ] });
+}
+function statusLabel(status) {
+  const map = {
+    recording: "Gravando",
+    paused: "Pausado",
+    interrupted: "Interrompido",
+    uploading: "Enviando",
+    transcribing: "Transcrevendo",
+    ready: "Pronto",
+    generating: "Rascunho",
+    completed: "Conclu\xEDdo",
+    abandoned: "Descartado",
+    failed: "Falhou"
+  };
+  return map[status] ?? status;
+}
+
+// src/migrations/index.ts
+var MIGRATION_001_SCRIBE_BASE = `-- plugin-scribe 001: gravar um atendimento inteiro sem poder perd\xEA-lo.
+--
+-- O problema que este schema resolve n\xE3o \xE9 "guardar \xE1udio". \xC9 que o profissional
+-- aperta gravar, navega o app por 40 minutos, e QUALQUER coisa pode acontecer no
+-- meio: reload, aba morta, wifi caindo, tampa fechando. Perder a consulta \xE9 uma
+-- falha irrecuper\xE1vel \u2014 n\xE3o d\xE1 para pedir para o paciente repetir.
+--
+-- Por isso o desenho n\xE3o tem "o arquivo da sess\xE3o". Tem um MANIFESTO: a sess\xE3o
+-- \xE9 uma linha, e cada 30 segundos de \xE1udio \xE9 OUTRA linha que sobe sozinha e \xE9
+-- transcrita sozinha. O que chegou, chegou. O cliente pode morrer entre dois
+-- segmentos e o que j\xE1 subiu continua \xEDntegro e j\xE1 transcrito.
+--
+-- ---------------------------------------------------------------------------
+-- Duas dura\xE7\xF5es, e elas discordam de prop\xF3sito
+-- ---------------------------------------------------------------------------
+-- \`wall_duration_ms\` \xE9 o rel\xF3gio de parede que o browser reportou. Serve para o
+-- cron\xF4metro na tela e para mais nada.
+--
+-- \`audio_duration_ms\` \xE9 SUM(segments.duration_ms) \u2014 soma do \xE1udio que de fato
+-- existe, com a dura\xE7\xE3o vinda da resposta do STT, n\xE3o de um \`setInterval\`.
+--
+-- Elas divergem sempre que a aba congela: notebook dormindo por 10 minutos faz
+-- o rel\xF3gio de parede contar a soneca inteira enquanto o MediaRecorder n\xE3o
+-- emitiu um byte. Registro cl\xEDnico, medidor de cota e fatura usam a SEGUNDA.
+-- Confundir as duas \xE9 cobrar do cliente pelo cochilo do notebook.
+--
+-- ---------------------------------------------------------------------------
+-- O contador nunca \xE9 escrito pelo browser
+-- ---------------------------------------------------------------------------
+-- \`scribe_record_segment\` (se\xE7\xE3o 5) faz o upsert do segmento e RECALCULA os
+-- contadores da sess\xE3o a partir da tabela de segmentos. Um cliente que sobe o
+-- mesmo segmento duas vezes (replay depois de queda de rede) converge para o
+-- mesmo n\xFAmero em vez de somar duas vezes.
+
+-- ---------------------------------------------------------------------------
+-- 1. sessions \u2014 o encontro
+-- ---------------------------------------------------------------------------
+-- \`id\` N\xC3O tem DEFAULT gen_random_uuid(). \xC9 gerado no cliente, antes do primeiro
+-- byte, e usado como chave no IndexedDB e no caminho do Storage. Sem isso a
+-- grava\xE7\xE3o teria que esperar um round-trip para saber onde escrever \u2014 e uma
+-- grava\xE7\xE3o que depende da rede para COME\xC7AR j\xE1 nasce fr\xE1gil.
+CREATE TABLE IF NOT EXISTS public.plg_scribe_sessions (
+  id                uuid PRIMARY KEY,
+  tenant_id         uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+
+  -- O titular. SET NULL e n\xE3o CASCADE: apagar a pessoa n\xE3o pode apagar em
+  -- sil\xEAncio o registro do atendimento que aconteceu.
+  subject_id        uuid REFERENCES public.people(id) ON DELETE SET NULL,
+  context_kind      text NOT NULL DEFAULT 'person'
+    CHECK (context_kind IN ('person', 'appointment', 'standalone')),
+  appointment_id    uuid REFERENCES public.appointments(id) ON DELETE SET NULL,
+  owner_user_id     uuid NOT NULL,
+
+  status            text NOT NULL DEFAULT 'recording'
+    CHECK (status IN ('recording','paused','interrupted','uploading','transcribing',
+                      'ready','generating','completed','abandoned','failed')),
+  locale            text NOT NULL DEFAULT 'pt-BR',
+  mime_type         text,
+
+  started_at        timestamptz NOT NULL DEFAULT now(),
+  ended_at          timestamptz,
+  wall_duration_ms  integer NOT NULL DEFAULT 0,
+  audio_duration_ms integer NOT NULL DEFAULT 0,
+
+  segment_count             integer NOT NULL DEFAULT 0,
+  uploaded_segment_count    integer NOT NULL DEFAULT 0,
+  transcribed_segment_count integer NOT NULL DEFAULT 0,
+  transcript_chars          integer NOT NULL DEFAULT 0,
+
+  -- Base legal, carimbada antes do primeiro byte. "Quando" e "como" \xE9 o que se
+  -- prova depois; guardar isso na mesma linha da grava\xE7\xE3o \xE9 o que torna a prova
+  -- barata.
+  consent_at        timestamptz,
+  consent_mode      text CHECK (consent_mode IN ('verbal','written','implied_contract')),
+
+  -- Reten\xE7\xE3o: o \xE1udio some, a transcri\xE7\xE3o e o documento assinado ficam.
+  retention_until   date,
+  audio_deleted_at  timestamptz,
+
+  error             text,
+  metadata          jsonb NOT NULL DEFAULT '{}'::jsonb,
+  created_at        timestamptz NOT NULL DEFAULT now(),
+  updated_at        timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_scribe_sessions ENABLE ROW LEVEL SECURITY;
+
+CREATE INDEX IF NOT EXISTS idx_plg_scribe_sessions_tenant
+  ON public.plg_scribe_sessions(tenant_id);
+CREATE INDEX IF NOT EXISTS idx_plg_scribe_sessions_subject
+  ON public.plg_scribe_sessions(subject_id) WHERE subject_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_plg_scribe_sessions_appointment
+  ON public.plg_scribe_sessions(appointment_id) WHERE appointment_id IS NOT NULL;
+
+-- A consulta da recupera\xE7\xE3o: "este usu\xE1rio tem alguma sess\xE3o aberta?". Roda em
+-- todo boot do app, ent\xE3o \xE9 \xEDndice parcial e n\xE3o varredura.
+CREATE INDEX IF NOT EXISTS idx_plg_scribe_sessions_open
+  ON public.plg_scribe_sessions(tenant_id, owner_user_id, status)
+  WHERE status IN ('recording','paused','interrupted','uploading','transcribing','ready','generating');
+
+-- A consulta do job de reten\xE7\xE3o.
+CREATE INDEX IF NOT EXISTS idx_plg_scribe_sessions_retention
+  ON public.plg_scribe_sessions(retention_until)
+  WHERE audio_deleted_at IS NULL AND retention_until IS NOT NULL;
+
+-- ---------------------------------------------------------------------------
+-- 2. segments \u2014 o manifesto dos peda\xE7os
+-- ---------------------------------------------------------------------------
+-- A PK \xE9 (session_id, seg_index) e n\xE3o um uuid: o \xEDndice do segmento j\xE1 \xE9
+-- \xFAnico dentro da sess\xE3o, e usar isso como chave faz o re-upload do mesmo
+-- peda\xE7o ser um ON CONFLICT em vez de uma linha duplicada. Idempot\xEAncia de
+-- gra\xE7a, que \xE9 exatamente o que um pump com retry infinito precisa.
+CREATE TABLE IF NOT EXISTS public.plg_scribe_segments (
+  session_id      uuid NOT NULL REFERENCES public.plg_scribe_sessions(id) ON DELETE CASCADE,
+  seg_index       integer NOT NULL,
+  tenant_id       uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+
+  storage_path    text,
+  bytes           integer,
+  start_offset_ms integer NOT NULL,
+  -- Vem da resposta do STT. O rel\xF3gio do JS n\xE3o \xE9 testemunha confi\xE1vel de
+  -- quanto \xE1udio existe: ele conta tempo, n\xE3o amostras.
+  duration_ms     integer,
+
+  -- Montado a partir de pieces de um segmento cortado no meio (crash). Vale
+  -- transcrever mesmo assim: 22 segundos de consulta \xE9 melhor que zero.
+  partial         boolean NOT NULL DEFAULT false,
+
+  -- Linha SINT\xC9TICA: n\xE3o tem \xE1udio, marca um buraco (sono, mic perdido,
+  -- permiss\xE3o revogada). Existe para a transcri\xE7\xE3o ADMITIR o buraco em vez de
+  -- emendar dois momentos como se fossem cont\xEDnuos. Isso \xE9 requisito
+  -- m\xE9dico-legal: um registro que esconde a costura \xE9 pior que um com furo.
+  gap             boolean NOT NULL DEFAULT false,
+
+  upload_state    text NOT NULL DEFAULT 'pending'
+    CHECK (upload_state IN ('pending','uploaded','missing')),
+  uploaded_at     timestamptz,
+
+  stt_state       text NOT NULL DEFAULT 'pending'
+    CHECK (stt_state IN ('pending','running','done','failed','skipped')),
+  stt_provider    text,
+  stt_attempts    smallint NOT NULL DEFAULT 0,
+  stt_error       text,
+
+  text            text,
+  -- [{w,s,e,c,sp}] com offsets RELATIVOS a este segmento. Absoluto se calcula
+  -- somando start_offset_ms; guardar relativo \xE9 o que deixa reprocessar um
+  -- segmento sozinho sem reescrever os vizinhos.
+  words           jsonb,
+  confidence      real,
+
+  created_at      timestamptz NOT NULL DEFAULT now(),
+  updated_at      timestamptz NOT NULL DEFAULT now(),
+  PRIMARY KEY (session_id, seg_index)
+);
+ALTER TABLE public.plg_scribe_segments ENABLE ROW LEVEL SECURITY;
+
+CREATE INDEX IF NOT EXISTS idx_plg_scribe_segments_tenant
+  ON public.plg_scribe_segments(tenant_id);
+
+-- A fila do STT. Parcial porque s\xF3 interessa o que j\xE1 subiu e ainda n\xE3o foi
+-- transcrito \u2014 que \xE9 uma fra\xE7\xE3o min\xFAscula da tabela em regime permanente.
+CREATE INDEX IF NOT EXISTS idx_plg_scribe_segments_stt_queue
+  ON public.plg_scribe_segments(tenant_id, stt_state, created_at)
+  WHERE upload_state = 'uploaded' AND stt_state IN ('pending','failed');
+
+-- ---------------------------------------------------------------------------
+-- 3. generations \u2014 uma tentativa de documento
+-- ---------------------------------------------------------------------------
+-- DUAS colunas de markdown, e isso n\xE3o \xE9 redund\xE2ncia.
+--
+--   \`markdown\`        sa\xEDda do modelo, escrita uma vez, nunca mutada
+--   \`markdown_edited\` a c\xF3pia de trabalho do humano
+--
+-- A diferen\xE7a entre elas \xE9 a \xFAnica prova de que algu\xE9m revisou. Ela sustenta
+-- tr\xEAs coisas: o selo "revisado pelo profissional", o diff que diz se o prompt
+-- est\xE1 bom (documento muito editado = prompt ruim), e a cadeia de proveni\xEAncia
+-- que um registro m\xE9dico-legal precisa ter. Guardar s\xF3 o texto final apaga tudo
+-- isso para economizar uma coluna de texto.
+CREATE TABLE IF NOT EXISTS public.plg_scribe_generations (
+  id              uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id       uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  session_id      uuid NOT NULL REFERENCES public.plg_scribe_sessions(id) ON DELETE CASCADE,
+
+  -- Um dos dois. \`template_id\` quando o tenant forkou e tem linha pr\xF3pria;
+  -- \`template_key\` quando \xE9 preset de c\xF3digo (que de prop\xF3sito n\xE3o tem linha,
+  -- para n\xE3o consumir a cota de templates do plano).
+  template_id     uuid,
+  template_key    text,
+
+  tab_order       integer NOT NULL DEFAULT 0,
+  title           text,
+  status          text NOT NULL DEFAULT 'pending'
+    CHECK (status IN ('pending','running','ready','failed','committed','discarded')),
+
+  markdown        text,
+  markdown_edited text,
+
+  -- Extra\xE7\xE3o stage-1 do modo two-stage. A coluna entra agora, vazia, porque a
+  -- interface j\xE1 nasce com esse formato \u2014 quando as abas de multi-documento
+  -- chegarem, \xE9 preencher, n\xE3o migrar.
+  facts           jsonb,
+
+  model           text,
+  prompt_version  text,
+  input_tokens    integer,
+  output_tokens   integer,
+  error           text,
+
+  document_id     uuid,
+  created_by      uuid,
+  created_at      timestamptz NOT NULL DEFAULT now(),
+  updated_at      timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.plg_scribe_generations ENABLE ROW LEVEL SECURITY;
+
+CREATE INDEX IF NOT EXISTS idx_plg_scribe_generations_session
+  ON public.plg_scribe_generations(session_id, tab_order);
+CREATE INDEX IF NOT EXISTS idx_plg_scribe_generations_tenant
+  ON public.plg_scribe_generations(tenant_id);
+
+-- FKs para plugin-forms e para o arqu\xE9tipo de documentos s\xE3o condicionais: o
+-- scribe declara \`dependencies: ['custom_forms']\`, mas a ordem de aplica\xE7\xE3o
+-- entre plugins n\xE3o \xE9 garantida e um pool pode aplicar este arquivo antes.
+-- Guardado, o re-apply converge; sem guarda, quebraria o passo inteiro.
+DO $$
+BEGIN
+  IF to_regclass('public.plg_forms_templates') IS NOT NULL
+     AND NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'plg_scribe_generations_template_fk') THEN
+    ALTER TABLE public.plg_scribe_generations
+      ADD CONSTRAINT plg_scribe_generations_template_fk
+      FOREIGN KEY (template_id) REFERENCES public.plg_forms_templates(id) ON DELETE SET NULL;
+  END IF;
+
+  IF to_regclass('public.documents') IS NOT NULL
+     AND NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'plg_scribe_generations_document_fk') THEN
+    ALTER TABLE public.plg_scribe_generations
+      ADD CONSTRAINT plg_scribe_generations_document_fk
+      FOREIGN KEY (document_id) REFERENCES public.documents(id) ON DELETE SET NULL;
+  END IF;
+END $$;
+
+-- ---------------------------------------------------------------------------
+-- 4. RLS \u2014 a forma can\xF4nica deste repo, tr\xEAs tabelas x quatro verbos
+-- ---------------------------------------------------------------------------
+DROP POLICY IF EXISTS plg_scribe_sessions_select ON public.plg_scribe_sessions;
+CREATE POLICY plg_scribe_sessions_select ON public.plg_scribe_sessions FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+DROP POLICY IF EXISTS plg_scribe_sessions_insert ON public.plg_scribe_sessions;
+CREATE POLICY plg_scribe_sessions_insert ON public.plg_scribe_sessions FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+DROP POLICY IF EXISTS plg_scribe_sessions_update ON public.plg_scribe_sessions;
+CREATE POLICY plg_scribe_sessions_update ON public.plg_scribe_sessions FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+DROP POLICY IF EXISTS plg_scribe_sessions_delete ON public.plg_scribe_sessions;
+CREATE POLICY plg_scribe_sessions_delete ON public.plg_scribe_sessions FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.plg_scribe_sessions TO authenticated;
+
+DROP POLICY IF EXISTS plg_scribe_segments_select ON public.plg_scribe_segments;
+CREATE POLICY plg_scribe_segments_select ON public.plg_scribe_segments FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+DROP POLICY IF EXISTS plg_scribe_segments_insert ON public.plg_scribe_segments;
+CREATE POLICY plg_scribe_segments_insert ON public.plg_scribe_segments FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+DROP POLICY IF EXISTS plg_scribe_segments_update ON public.plg_scribe_segments;
+CREATE POLICY plg_scribe_segments_update ON public.plg_scribe_segments FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+DROP POLICY IF EXISTS plg_scribe_segments_delete ON public.plg_scribe_segments;
+CREATE POLICY plg_scribe_segments_delete ON public.plg_scribe_segments FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.plg_scribe_segments TO authenticated;
+
+DROP POLICY IF EXISTS plg_scribe_generations_select ON public.plg_scribe_generations;
+CREATE POLICY plg_scribe_generations_select ON public.plg_scribe_generations FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+DROP POLICY IF EXISTS plg_scribe_generations_insert ON public.plg_scribe_generations;
+CREATE POLICY plg_scribe_generations_insert ON public.plg_scribe_generations FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+DROP POLICY IF EXISTS plg_scribe_generations_update ON public.plg_scribe_generations;
+CREATE POLICY plg_scribe_generations_update ON public.plg_scribe_generations FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+DROP POLICY IF EXISTS plg_scribe_generations_delete ON public.plg_scribe_generations;
+CREATE POLICY plg_scribe_generations_delete ON public.plg_scribe_generations FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.plg_scribe_generations TO authenticated;
+
+-- ---------------------------------------------------------------------------
+-- 5. scribe_record_segment \u2014 o browser registra, o banco conta
+-- ---------------------------------------------------------------------------
+-- SECURITY INVOKER: a RLS acima j\xE1 amarra o tenant. N\xE3o h\xE1 nada aqui que
+-- precise de privil\xE9gio elevado, e uma fun\xE7\xE3o SECURITY DEFINER que n\xE3o precisa
+-- ser \xE9 s\xF3 superf\xEDcie de ataque a mais.
+--
+-- O ponto da fun\xE7\xE3o \xE9 a segunda metade: recalcular os contadores da sess\xE3o a
+-- partir de um SELECT sobre os segmentos, nunca de um \`+1\` vindo do cliente.
+-- Um pump com retry infinito vai reenviar o mesmo segmento, e um contador
+-- incremental transformaria isso em n\xFAmeros que crescem sem o \xE1udio crescer.
+CREATE OR REPLACE FUNCTION public.scribe_record_segment(p_payload jsonb)
+RETURNS jsonb
+LANGUAGE plpgsql
+SECURITY INVOKER
+SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_session_id uuid;
+  v_seg_index  integer;
+  v_tenant_id  uuid;
+  v_result     jsonb;
+BEGIN
+  v_session_id := (p_payload->>'session_id')::uuid;
+  v_seg_index  := (p_payload->>'seg_index')::integer;
+
+  IF v_session_id IS NULL OR v_seg_index IS NULL THEN
+    RAISE EXCEPTION 'session_id and seg_index are required';
+  END IF;
+
+  -- O tenant vem da SESS\xC3O, nunca do payload. Se o cliente pudesse informar o
+  -- tenant, ele escolheria em que pasta escrever.
+  SELECT s.tenant_id INTO v_tenant_id
+  FROM plg_scribe_sessions s WHERE s.id = v_session_id;
+
+  IF v_tenant_id IS NULL THEN
+    -- Sess\xE3o inexistente OU invis\xEDvel pela RLS: a mesma resposta nos dois
+    -- casos, de prop\xF3sito \u2014 n\xE3o vaza a exist\xEAncia de sess\xE3o de outro tenant.
+    RAISE EXCEPTION 'unknown session';
+  END IF;
+
+  INSERT INTO plg_scribe_segments (
+    session_id, seg_index, tenant_id, storage_path, bytes,
+    start_offset_ms, duration_ms, partial, gap, upload_state, uploaded_at, stt_state
+  ) VALUES (
+    v_session_id, v_seg_index, v_tenant_id,
+    p_payload->>'storage_path',
+    (p_payload->>'bytes')::integer,
+    COALESCE((p_payload->>'start_offset_ms')::integer, 0),
+    (p_payload->>'duration_ms')::integer,
+    COALESCE((p_payload->>'partial')::boolean, false),
+    COALESCE((p_payload->>'gap')::boolean, false),
+    CASE WHEN COALESCE((p_payload->>'gap')::boolean, false) THEN 'missing' ELSE 'uploaded' END,
+    now(),
+    -- Buraco n\xE3o vai para o STT: n\xE3o h\xE1 \xE1udio para transcrever, e mand\xE1-lo
+    -- queimaria uma chamada para receber string vazia.
+    CASE WHEN COALESCE((p_payload->>'gap')::boolean, false) THEN 'skipped' ELSE 'pending' END
+  )
+  ON CONFLICT (session_id, seg_index) DO UPDATE SET
+    storage_path = COALESCE(EXCLUDED.storage_path, plg_scribe_segments.storage_path),
+    bytes        = COALESCE(EXCLUDED.bytes, plg_scribe_segments.bytes),
+    duration_ms  = COALESCE(EXCLUDED.duration_ms, plg_scribe_segments.duration_ms),
+    partial      = EXCLUDED.partial,
+    upload_state = EXCLUDED.upload_state,
+    uploaded_at  = COALESCE(plg_scribe_segments.uploaded_at, EXCLUDED.uploaded_at),
+    updated_at   = now();
+
+  -- Contadores derivados. \`audio_duration_ms\` soma s\xF3 o que tem dura\xE7\xE3o medida,
+  -- ent\xE3o um segmento que ainda n\xE3o voltou do STT n\xE3o infla o total.
+  UPDATE plg_scribe_sessions s SET
+    segment_count             = agg.total,
+    uploaded_segment_count    = agg.uploaded,
+    transcribed_segment_count = agg.transcribed,
+    audio_duration_ms         = agg.audio_ms,
+    transcript_chars          = agg.chars,
+    updated_at                = now()
+  FROM (
+    SELECT
+      count(*)::int                                                  AS total,
+      count(*) FILTER (WHERE upload_state = 'uploaded')::int         AS uploaded,
+      count(*) FILTER (WHERE stt_state = 'done')::int                AS transcribed,
+      COALESCE(sum(duration_ms) FILTER (WHERE NOT gap), 0)::int      AS audio_ms,
+      COALESCE(sum(length(text)), 0)::int                            AS chars
+    FROM plg_scribe_segments WHERE session_id = v_session_id
+  ) agg
+  WHERE s.id = v_session_id;
+
+  SELECT to_jsonb(x) INTO v_result FROM (
+    SELECT s.segment_count, s.uploaded_segment_count,
+           s.transcribed_segment_count, s.audio_duration_ms, s.status
+    FROM plg_scribe_sessions s WHERE s.id = v_session_id
+  ) x;
+
+  RETURN v_result;
+END;
+$function$;
+
+COMMENT ON FUNCTION public.scribe_record_segment(jsonb) IS
+  'Idempotent upsert of one audio segment + recomputation of the parent session counters from the segments table. Called by the browser upload pump after each successful Storage write.';
+
+GRANT EXECUTE ON FUNCTION public.scribe_record_segment(jsonb) TO authenticated;
+
+-- ---------------------------------------------------------------------------
+-- 6. o bucket
+-- ---------------------------------------------------------------------------
+-- PRIVADO, sem discuss\xE3o: \xE9 a voz de uma pessoa falando da pr\xF3pria sa\xFAde. URL
+-- p\xFAblica seria um endere\xE7o eterno para isso. O backoffice l\xEA por URL assinada
+-- de curta dura\xE7\xE3o; a edge function de transcri\xE7\xE3o l\xEA com service key.
+--
+-- 5 MB por SEGMENTO \xE9 folgado por design: 30 s de Opus mono a 24 kbps d\xE1 ~90 KB.
+-- O limite existe para barrar um cliente com bug mandando um arquivo inteiro,
+-- n\xE3o para apertar o caso normal.
+INSERT INTO storage.buckets (id, name, public, file_size_limit, allowed_mime_types)
+VALUES (
+  'scribe-audio',
+  'scribe-audio',
+  false,
+  5242880,
+  ARRAY['audio/webm','audio/ogg','audio/mp4','audio/mpeg','audio/m4a','audio/x-m4a']
+)
+ON CONFLICT (id) DO UPDATE SET
+  public             = EXCLUDED.public,
+  file_size_limit    = EXCLUDED.file_size_limit,
+  allowed_mime_types = EXCLUDED.allowed_mime_types;
+
+-- ---------------------------------------------------------------------------
+-- 7. o caminho \xE9 v\xE1lido?
+-- ---------------------------------------------------------------------------
+-- Gram\xE1tica (o SDK constr\xF3i, o banco confere):
+--
+--   {tenant_id}/{yyyy}/{mm}/{session_id}/{seg_index:05d}.{ext}
+--        1         2     3        4              5
+--
+--   1 tenant_id   chave do isolamento \u2014 toda policy pendura aqui
+--   2,3 yyyy/mm   varredura de reten\xE7\xE3o por prefixo (LGPD), pasta list\xE1vel
+--   4 session_id  uuid do cliente: agrupa a sess\xE3o e \xE9 imprevis\xEDvel
+--   5 seg_index   zero-padded, ent\xE3o list() j\xE1 volta em ordem cronol\xF3gica
+--
+-- SECURITY DEFINER porque o EXISTS olha \`tenants\`, que tem RLS.
+CREATE OR REPLACE FUNCTION public.scribe_audio_path_ok(p_name text)
+RETURNS boolean
+LANGUAGE sql
+STABLE
+SECURITY DEFINER
+SET search_path TO 'public'
+AS $function$
+  SELECT
+    p_name IS NOT NULL
+    AND length(p_name) <= 200
+    AND p_name ~ ('^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
+               || '/[0-9]{4}/[0-9]{2}'
+               || '/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
+               || '/[0-9]{5}\\.(webm|ogg|m4a|mp3)$')
+    -- compara\xE7\xE3o em texto (nunca \`::uuid\`): entrada malformada devolve falso em
+    -- vez de derrubar a policy com erro de cast.
+    AND EXISTS (
+      SELECT 1 FROM public.tenants t WHERE t.id::text = split_part(p_name, '/', 1)
+    );
+$function$;
+
+COMMENT ON FUNCTION public.scribe_audio_path_ok(text) IS
+  'True when a storage object name follows the scribe-audio grammar {tenant}/{yyyy}/{mm}/{session}/{segIndex}.{ext} and segment 1 is a real tenant. Used by the INSERT policy on that bucket.';
+
+GRANT EXECUTE ON FUNCTION public.scribe_audio_path_ok(text) TO authenticated;
+
+-- ---------------------------------------------------------------------------
+-- 8. pol\xEDticas do bucket
+-- ---------------------------------------------------------------------------
+DROP POLICY IF EXISTS plg_scribe_audio_insert ON storage.objects;
+DROP POLICY IF EXISTS plg_scribe_audio_read ON storage.objects;
+DROP POLICY IF EXISTS plg_scribe_audio_delete ON storage.objects;
+
+-- Escrever: s\xF3 logado (diferente do bucket do CRM, que aceita visitante an\xF4nimo
+-- \u2014 aqui quem grava \xE9 sempre um profissional autenticado), dentro da gram\xE1tica
+-- e da pr\xF3pria pasta.
+--
+-- N\xC3O existe policy de UPDATE, e isso \xE9 a trava mais importante das tr\xEAs: sem
+-- ela o \`upsert\` falha, e um caminho j\xE1 gravado NUNCA pode ser trocado por
+-- outro conte\xFAdo. \xC9 o que torna o \xE1udio uma testemunha e n\xE3o um rascunho.
+CREATE POLICY plg_scribe_audio_insert ON storage.objects
+  FOR INSERT TO authenticated
+  WITH CHECK (
+    bucket_id = 'scribe-audio'
+    AND public.scribe_audio_path_ok(name)
+    AND (storage.foldername(name))[1] IN (SELECT public.user_tenant_ids()::text)
+  );
+
+CREATE POLICY plg_scribe_audio_read ON storage.objects
+  FOR SELECT TO authenticated
+  USING (
+    bucket_id = 'scribe-audio'
+    AND (storage.foldername(name))[1] IN (SELECT public.user_tenant_ids()::text)
+  );
+
+-- Apagar: mesma regra da leitura. \xC9 o que torna "apagar o \xE1udio desta sess\xE3o"
+-- execut\xE1vel por quem \xE9 dono dele \u2014 o direito de elimina\xE7\xE3o do art. 18 VI n\xE3o
+-- vale nada se ningu\xE9m no tenant consegue exerc\xEA-lo.
+CREATE POLICY plg_scribe_audio_delete ON storage.objects
+  FOR DELETE TO authenticated
+  USING (
+    bucket_id = 'scribe-audio'
+    AND (storage.foldername(name))[1] IN (SELECT public.user_tenant_ids()::text)
+  );
+`;
+
+// src/types.ts
+function isNarrativeSchema(schema) {
+  return !!schema && typeof schema === "object" && schema.kind === "narrative";
+}
+
+// src/index.ts
+var DEFAULT_LABELS = {
+  sessionSingular: "Atendimento",
+  sessionPlural: "Atendimentos",
+  start: "Iniciar atendimento",
+  pause: "Pausar",
+  resume: "Retomar",
+  finish: "Finalizar",
+  discard: "Descartar",
+  generate: "Gerar documento",
+  subject: "Cliente",
+  transcript: "Transcri\xE7\xE3o",
+  settingsTitle: "Grava\xE7\xE3o de atendimentos"
+};
+var DEFAULT_RETENTION = {
+  audioDays: 90,
+  requireConsent: true,
+  defaultConsentMode: "verbal"
+};
+function createScribePlugin(options) {
+  assertSttConfig(options?.stt);
+  const labels = { ...DEFAULT_LABELS, ...options.labels };
+  const retention2 = { ...DEFAULT_RETENTION, ...options.retention };
+  const presets = options.templatePresets ?? [];
+  const generateEndpoint = options.generateEndpoint ?? "scribe-generate";
+  const locale = options.stt.locale ?? "pt-BR";
+  registerTranslations(scribeLocales);
+  initScribeRuntime({ retention: retention2 });
+  wireScribeStore();
+  const openSession = (sessionId) => {
+    window.location.hash = `/scribe/${sessionId}`;
+  };
+  const ShellMount = () => React6__default.createElement(ScribeShellMount, { labels, retention: retention2, locale, onOpenSession: openSession });
+  ShellMount.displayName = "ScribeShellMount";
+  const SessionRoute = () => {
+    const hash = typeof window !== "undefined" ? window.location.hash : "";
+    const sessionId = hash.split("/scribe/")[1]?.split("/")[0] ?? "";
+    if (!sessionId) return null;
+    return React6__default.createElement(ScribeSessionPage, {
+      sessionId,
+      labels,
+      presets,
+      stt: options.stt,
+      generateEndpoint,
+      onBack: () => {
+        window.location.hash = "/clients";
+      },
+      onOpenDocument: () => {
+        window.location.hash = "/clients";
+      }
+    });
+  };
+  SessionRoute.displayName = "ScribeSessionRoute";
+  return {
+    id: "scribe",
+    name: labels.sessionPlural,
+    icon: "Mic",
+    version: "0.1.0",
+    scope: options.scope ?? "universal",
+    verticalId: options.verticalId,
+    defaultEnabled: false,
+    // O scribe EMITE documento mas não é dono do conceito. plugin-forms é a
+    // engine de documento; este é uma engine de aquisição. A dependência aponta
+    // nessa direção e não na inversa — senão todo app que só quer uma anamnese
+    // impressa passaria a depender de bucket, duas edge functions e chave de
+    // modelo.
+    dependencies: ["custom_forms"],
+    navigation: [],
+    routes: [
+      {
+        path: "/scribe/*",
+        component: SessionRoute
+      }
+    ],
+    widgets: [
+      {
+        id: "scribe-shell-mount",
+        // A única zona global verificadamente renderizada (AdminShell.tsx:979-980)
+        // e que fica FORA do switch de rota. Navegar não a desmonta.
+        zone: "shell.topbar.end",
+        component: ShellMount,
+        order: -10
+      }
+    ],
+    declaredFeatures: [
+      { id: "scribe", label: labels.settingsTitle, actions: ["read", "create", "edit", "delete"] }
+    ],
+    declaredLimits: [
+      // Cota entra no dia um, não depois: a 1000 atendimentos/mês o STT bruto
+      // já é a maior linha de custo variável do produto.
+      {
+        key: options.limits?.minutesMonth ?? "scribe_minutes_month",
+        label: "Minutos de grava\xE7\xE3o por m\xEAs",
+        table: "plg_scribe_sessions",
+        period: "month"
+      },
+      {
+        key: options.limits?.documentsMonth ?? "scribe_documents_month",
+        label: "Documentos gerados por m\xEAs",
+        table: "plg_scribe_generations",
+        period: "month"
+      }
+    ],
+    aiTools: [
+      {
+        id: "scribe.list-sessions",
+        name: "listScribeSessions",
+        description: `Lista ${labels.sessionPlural.toLowerCase()} gravados, com data, dura\xE7\xE3o e status.`,
+        icon: "Mic",
+        mode: "read",
+        category: labels.sessionPlural,
+        permission: { feature: "scribe", action: "read" },
+        parameters: {
+          type: "object",
+          properties: {
+            subjectId: { type: "string", description: "Filtra pelo id do titular" },
+            status: { type: "string", description: "Filtra pelo status da sess\xE3o" }
+          }
+        },
+        suggestions: [
+          { label: `Quais ${labels.sessionPlural.toLowerCase()} ainda n\xE3o viraram documento?` }
+        ]
+      }
+    ],
+    migrations: [
+      {
+        id: "scribe-001-base",
+        version: "0.1.0",
+        sql: MIGRATION_001_SCRIBE_BASE,
+        description: "Cria plg_scribe_sessions/_segments/_generations, o bucket privado scribe-audio com guard de caminho, e o RPC scribe_record_segment"
+      }
+    ],
+    locales: scribeLocales
+  };
+}
+
+export { PROMPT_VERSION, SCRIBE_START_EVENT, ScribeSessionPage, ScribeStartButton, beginSession, createScribePlugin, deleteSessionAudio, discardSession, endSession, fetchGenerations, fetchOpenSessions, fetchSegments, fetchSession, fetchSessionsForSubject, formatElapsed, formatOffset, isCaptureSupported, isNarrativeSchema, parseSections, pauseSession, renderTranscript, requestScribeStart, resumeSession, useScribeStore };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map