// ── Script Rehearser ──────────────────────────────────────────────────────

// ── Constants ─────────────────────────────────────────────────────────────
const SPEAKER_COLORS = ['#89b4fa','#a6e3a1','#f38ba8','#fab387','#f9e2af','#cba6f7','#89dceb','#74c7ec'];

const REH_EMOTIONS = [
  { value: '',                                        emoji: '😐', label: 'Neutral'    },
  { value: 'happy, cheerful and upbeat',              emoji: '😊', label: 'Happy'      },
  { value: 'sad, melancholy, somber',                 emoji: '😢', label: 'Sad'        },
  { value: 'angry, forceful, aggressive',             emoji: '😠', label: 'Angry'      },
  { value: 'whisper, hushed and intimate',            emoji: '🤫', label: 'Whisper'    },
  { value: 'excited, enthusiastic, energetic',        emoji: '🤩', label: 'Excited'    },
  { value: 'scared, nervous, trembling voice',        emoji: '😨', label: 'Scared'     },
  { value: 'sarcastic, dry, ironic delivery',         emoji: '😏', label: 'Sarcastic'  },
  { value: 'dramatic, theatrical, intense',           emoji: '🎭', label: 'Dramatic'   },
  { value: 'gentle, warm, tender',                    emoji: '🥰', label: 'Gentle'     },
  { value: 'confused, uncertain, hesitant',           emoji: '😕', label: 'Confused'   },
  { value: 'bored, flat, disinterested',              emoji: '😑', label: 'Bored'      },
  { value: 'surprised, shocked, astonished',          emoji: '😲', label: 'Surprised'  },
  { value: 'confident, authoritative, bold',          emoji: '💪', label: 'Confident'  },
  { value: 'mysterious, dark, ominous',               emoji: '🌑', label: 'Mysterious' },
  { value: 'romantic, loving, passionate',            emoji: '❤️',  label: 'Romantic'   },
  { value: 'playful, teasing, mischievous',           emoji: '😈', label: 'Playful'    },
  { value: 'calm, composed, measured',                emoji: '🧘', label: 'Calm'       },
  { value: 'commanding, authoritative, military',     emoji: '⚔️',  label: 'Commanding' },
  { value: 'grieving, tearful, broken',               emoji: '😭', label: 'Grieving'   },
];

// Exposed so the emotion quick-pickers in tts-preview.js / reader.js can read this
// list. They run in the same bundle scope but BEFORE this file, so they must go
// through window (and defer to a macrotask) rather than touch the const directly.
window.REH_EMOTIONS = REH_EMOTIONS;

// Load custom emotions from localStorage
let rehCustomEmotions = [];
try { rehCustomEmotions = JSON.parse(localStorage.getItem('reh-custom-emotions') || '[]'); } catch(_) {}

function getEmotionInfo(value) {
  if (!value) return { emoji: '', label: 'Pick tone' };
  const all = [...REH_EMOTIONS, ...rehCustomEmotions];
  const found = all.find(e => e.value === value);
  if (found) return { emoji: found.emoji, label: found.label };
  return { emoji: '✨', label: value.length > 14 ? value.slice(0, 13) + '…' : value };
}

// ── Markdown helpers ───────────────────────────────────────────────────────

function renderMarkdownInline(text) {
  // Escape HTML first, then apply inline markdown
  let s = escHtml(text);
  s = s.replace(/\*\*([^*\n]+?)\*\*/g,  '<strong>$1</strong>');
  s = s.replace(/\*([^*\n]+?)\*/g,       '<em>$1</em>');
  s = s.replace(/__([^_\n]+?)__/g,       '<u>$1</u>');
  s = s.replace(/~~([^~\n]+?)~~/g,       '<del>$1</del>');
  s = s.replace(/==([^=\n]+?)==/g,       '<mark class="reh-hl">$1</mark>');
  return s;
}

function stripMarkdown(text) {
  return text
    .replace(/\*\*([^*\n]+?)\*\*/g, '$1')
    .replace(/\*([^*\n]+?)\*/g,      '$1')
    .replace(/__([^_\n]+?)__/g,      '$1')
    .replace(/~~([^~\n]+?)~~/g,      '$1')
    .replace(/==([^=\n]+?)==/g,      '$1');
}

// ── State ─────────────────────────────────────────────────────────────────
const rehState = {
  lines:    [],
  cast:     {},
  lineIndex: 0,
  clips:    [],
  voices:   [],
  backend:  '',
  playing:  false,
  repeat:   false,
  savedId:  null,
  synthCache: new Map(),
  staleLines: new Set(),   // lines that were cached but had their tone changed
  synthCancelled: false,
  synthRunning: false,
  skipDescriptions: false,
  narratorVoice: '',
  practiceStart: null,
  practiceEnd:   null,
  bulkMode:   false,        // bulk-edit (line selection) mode on/off
  bulkSel:    new Set(),    // indices of currently selected lines
  bulkAnchor: null,         // last clicked index for Shift+click range selection
  showHidden: false,        // reveal hidden lines (so they can be restored)
  recStream: null, recAudioCtx: null, recAnalyser: null,
  recSourceNode: null, recGainNode: null, recDestStream: null,
  recMeterRaf: null, recWaveRing: null, mediaRec: null,
  recChunks: [], recTimer: null, recSecs: 0, lastRecBlob: null,
};
window.rehState = rehState;

// ── Library — SQLite via /api/rehearsals ──────────────────────────────────

async function rehDbGetAll() {
  const r = await fetch('/api/rehearsals');
  if (!r.ok) throw new Error('rehDbGetAll failed: ' + r.status);
  const d = await r.json();
  return d.rehearsals || [];
}

async function rehDbGetById(id) {
  const r = await fetch('/api/rehearsals/' + id);
  if (r.status === 404) return undefined;
  if (!r.ok) throw new Error('rehDbGetById failed: ' + r.status);
  return r.json();
}

async function rehDbAdd(record) {
  const r = await fetch('/api/rehearsals', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(_rehSanitize(record)),
  });
  if (!r.ok) throw new Error('rehDbAdd failed: ' + r.status);
  const d = await r.json();
  return d.id;
}

async function rehDbPut(record) {
  if (!record.id) { return rehDbAdd(record); }
  const r = await fetch('/api/rehearsals/' + record.id, {
    method: 'PUT',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(_rehSanitize(record)),
  });
  if (!r.ok) throw new Error('rehDbPut failed: ' + r.status);
}

async function rehDbDelete(id) {
  const r = await fetch('/api/rehearsals/' + id, { method: 'DELETE' });
  if (!r.ok) throw new Error('rehDbDelete failed: ' + r.status);
}

// Strip binary clip blobs before sending — blobs can't be JSON-serialised and
// are session-only anyway (they live in rehState.clips, not the library record).
function _rehSanitize(rec) {
  const out = { ...rec };
  if (out.clips) out.clips = (out.clips || []).map(c => ({ lineIndex: c.lineIndex, speaker: c.speaker, type: c.type }));
  return out;
}

// One-time IndexedDB → SQLite migration. Runs silently on page load.
(async function _rehMigrateIfNeeded() {
  try {
    const serverRecs = await rehDbGetAll();
    if (serverRecs.length > 0) return;
    const idbRecs = await _rehIdbGetAll().catch(() => []);
    if (!idbRecs.length) return;
    const r = await fetch('/api/rehearsals/migrate', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(idbRecs.map(_rehSanitize)),
    });
    if (r.ok) {
      const d = await r.json();
      console.log(`[rehearser] migrated ${d.imported} records from IndexedDB → SQLite`);
    }
  } catch (e) {
    console.warn('[rehearser] migration skipped:', e);
  }
})();

function _rehIdbGetAll() {
  return new Promise((resolve) => {
    const req = indexedDB.open('reh-library', 1);
    req.onerror = () => resolve([]);
    req.onsuccess = e => {
      const db = e.target.result;
      if (!db.objectStoreNames.contains('rehearsals')) { db.close(); resolve([]); return; }
      const all = db.transaction('rehearsals', 'readonly').objectStore('rehearsals').getAll();
      all.onsuccess = ev => { db.close(); resolve(ev.target.result || []); };
      all.onerror   = () => { db.close(); resolve([]); };
    };
  });
}

window.rehDbGetById  = rehDbGetById;
window.rehLoadRecord = loadRecord;  // expose so audiobook.js can open a record directly

// ── Serialization ─────────────────────────────────────────────────────────

async function clipsToJson(clips) {
  return Promise.all(clips.map(async c => {
    if (!c.blob) return { lineIndex: c.lineIndex, speaker: c.speaker, type: c.type };
    const ab  = await c.blob.arrayBuffer();
    const u8  = new Uint8Array(ab);
    let bin   = '';
    const CHUNK = 8192;
    for (let i = 0; i < u8.length; i += CHUNK)
      bin += String.fromCharCode(...u8.subarray(i, i + CHUNK));
    return { lineIndex: c.lineIndex, speaker: c.speaker, type: c.type, mime: c.blob.type, b64: btoa(bin) };
  }));
}

function clipsFromJson(clips) {
  return clips.map(c => {
    if (!c.b64) return c;
    const bin = atob(c.b64);
    const u8  = new Uint8Array(bin.length);
    for (let i = 0; i < bin.length; i++) u8[i] = bin.charCodeAt(i);
    return { ...c, blob: new Blob([u8], { type: c.mime || 'audio/webm' }), b64: undefined, mime: undefined };
  });
}

function rehCurrentRecord() {
  const cast = {};
  Object.entries(rehState.cast).forEach(([sp, c]) => {
    cast[sp] = {
      voice: c.voice, color: c.color, instruct: c.instruct || '',
      lang: c.lang || '', gender: c.gender || '', tags: c.tags || '', soul: c.soul || '',
      ignored: !!c.ignored, hidden: !!c.hidden,
    };
  });
  const emotions = {};
  const notes    = {};
  const ignored  = {};
  const hidden   = {};
  rehState.lines.forEach((l, i) => {
    if (l.type === 'dialog' && l.emotion) emotions[i] = l.emotion;
    if (l.type === 'dialog' && l.note)    notes[i]    = l.note;
    if (l.ignored) ignored[i] = true;
    if (l.hidden)  hidden[i]  = true;
  });
  return {
    title:         $('reh-script-title')?.value.trim() || $('reh-page-title')?.textContent || 'Untitled',
    // Reconstruct from parsed lines so structural edits (deletes) persist; fall back to the
    // raw textarea before the script has been parsed into lines.
    script:        rehState.lines.length ? linesToScriptText() : ($('reh-script-text')?.value.trim() || ''),
    cast, emotions, notes, ignored, hidden,
    backend:       rehState.backend,
    narratorVoice: rehState.narratorVoice,
    lineIndex:     rehState.lineIndex,
    clips:         rehState.clips.map(c => ({ lineIndex: c.lineIndex, speaker: c.speaker, type: c.type, blob: c.blob || null })),
    updated:       new Date(),
  };
}

// Reconstruct script text from current parsed lines (preserves inline edits)
function linesToScriptText() {
  return rehState.lines.map(line => {
    switch (line.type) {
      case 'act':
      case 'transition':  return '\n' + line.text + '\n';
      case 'scene':       return '\n' + line.text + '\n';
      case 'action':      return '\n' + line.text + '\n';
      case 'dialog':      return '\n' + line.speaker + '\n' + line.text + '\n';
      case 'direction':
        return line.speaker ? line.text + '\n' : '\n' + line.text + '\n';
      case 'pagebreak':   return line.page ? `\n\f${line.page}\n` : '\n\f\n';
      default:            return '';
    }
  }).join('').trim();
}

async function saveToLibrary() {
  const rec = rehCurrentRecord();
  if (rehState.savedId) {
    rec.id = rehState.savedId;
    if (!rec.created) rec.created = new Date();
    await rehDbPut(rec);
  } else {
    rec.created = new Date();
    const newId = await rehDbAdd(rec);
    rehState.savedId = newId;
  }
  toast('Saved to library', 'success');
  rehState._keepSavedIdOnce = true;
  // Sync cast voice choices into the shared character roster (existing chars only)
  if (typeof castWriteBack === 'function') { try { await castWriteBack(rec.title, rehState.cast); } catch (_) {} }
  await renderLibraryList();
}

// Auto-save a freshly imported/pasted script as its own library entry so it shows up
// in the Library and can be reopened. Returns the new id (or null on failure).
async function rehAutoSaveImport(title) {
  const text = ($('reh-script-text')?.value || '').trim();
  if (!text) return null;
  if (title && $('reh-script-title') && !$('reh-script-title').value.trim()) $('reh-script-title').value = title;
  const rec = {
    title:   $('reh-script-title')?.value.trim() || title || 'Untitled',
    script:  text,
    cast: {}, emotions: {}, notes: {}, ignored: {}, hidden: {},
    backend: rehState.backend || '', narratorVoice: rehState.narratorVoice || '',
    lineIndex: 0, clips: [], created: new Date(), updated: new Date(),
  };
  try {
    const id = await rehDbAdd(rec);
    rehState.savedId = id;
    rehState._keepSavedIdOnce = true; // keep this entry through the next Parse & cast
    await renderLibraryList();
    return id;
  } catch (e) { return null; }
}

async function exportToFile() {
  const rec   = rehCurrentRecord();
  rec.version = 1;
  rec.created = rec.created || new Date();
  rec.clips   = await clipsToJson(rec.clips);
  const json  = JSON.stringify(rec, null, 2);
  const blob  = new Blob([json], { type: 'application/json' });
  const a     = document.createElement('a');
  const title = (rec.title || 'rehearsal').replace(/[^a-z0-9_\- ]/gi, '_').slice(0, 40);
  a.href = URL.createObjectURL(blob);
  a.download = title + '.reh';
  a.click();
}

function exportFountain() {
  const title = $('reh-script-title')?.value.trim() || $('reh-page-title')?.textContent || 'Untitled';
  let out = `Title: ${title}\n\n`;
  rehState.lines.forEach(line => {
    const t = stripMarkdown(line.text);
    switch (line.type) {
      case 'act':        out += '\n' + t + '\n'; break;
      case 'scene':      out += '\n' + t + '\n'; break;
      case 'action':     out += '\n' + t + '\n'; break;
      case 'transition': out += '\n' + t + '\n'; break;
      case 'dialog':     out += '\n' + line.speaker + '\n' + t + '\n'; break;
      case 'direction':
        out += (line.speaker ? '' : '\n') + t + '\n'; break;
    }
  });
  const blob = new Blob([out.trim()], { type: 'text/plain' });
  const a = document.createElement('a');
  a.href = URL.createObjectURL(blob);
  a.download = (title.replace(/[^a-z0-9_\- ]/gi, '_') || 'script') + '.fountain';
  a.click();
  toast('Exported as .fountain', 'success');
}

// ── FDX (Final Draft XML) ──────────────────────────────────────────────────

function exportFDX() {
  const title = $('reh-script-title')?.value.trim() || 'Untitled';
  const x = s => (s||'').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
  let xml = `<?xml version="1.0" encoding="UTF-8" standalone="no" ?>\n`;
  xml += `<FinalDraft DocumentType="Script" Template="No" Version="1">\n<Content>\n`;
  rehState.lines.forEach(line => {
    const t = x(stripMarkdown(line.text));
    switch (line.type) {
      case 'act':
      case 'scene':      xml += `  <Paragraph Type="Scene Heading"><Text>${t}</Text></Paragraph>\n`; break;
      case 'action':     xml += `  <Paragraph Type="Action"><Text>${t}</Text></Paragraph>\n`; break;
      case 'transition': xml += `  <Paragraph Type="Transition"><Text>${t}</Text></Paragraph>\n`; break;
      case 'direction':  xml += `  <Paragraph Type="Parenthetical"><Text>${t}</Text></Paragraph>\n`; break;
      case 'dialog':
        xml += `  <Paragraph Type="Character"><Text>${x(line.speaker)}</Text></Paragraph>\n`;
        xml += `  <Paragraph Type="Dialogue"><Text>${t}</Text></Paragraph>\n`;
        break;
    }
  });
  xml += `</Content>\n</FinalDraft>`;
  const blob = new Blob([xml], { type: 'text/xml' });
  const a = document.createElement('a');
  a.href = URL.createObjectURL(blob);
  a.download = (title.replace(/[^a-z0-9_\- ]/gi, '_') || 'script') + '.fdx';
  a.click();
  toast('Exported as .fdx (Final Draft XML)', 'success');
}

async function importFDX(file) {
  const text = await file.text();
  const parser = new DOMParser();
  const doc = parser.parseFromString(text, 'text/xml');
  const paras = doc.querySelectorAll('Paragraph');
  let result = '';
  paras.forEach(para => {
    const type = para.getAttribute('Type') || '';
    const t = [...para.querySelectorAll('Text')].map(el => el.textContent).join('');
    if (!t.trim()) return;
    switch (type) {
      case 'Scene Heading': result += '\n' + t + '\n'; break;
      case 'Action':        result += '\n' + t + '\n'; break;
      case 'Character':     result += '\n' + t + '\n'; break;
      case 'Dialogue':      result += t + '\n'; break;
      case 'Parenthetical': result += t + '\n'; break;
      case 'Transition':    result += '\n' + t + '\n'; break;
    }
  });
  return result.trim();
}

// OSF (Open Screenplay Format — application-agnostic XML)
function exportOSF() {
  const title = $('reh-script-title')?.value.trim() || 'Untitled';
  const x = s => (s||'').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
  let xml = `<?xml version="1.0" encoding="UTF-8"?>\n<osf:script xmlns:osf="http://www.openscreenplayformat.org/ns/1.0">\n`;
  xml += `  <osf:title>${x(title)}</osf:title>\n<osf:content>\n`;
  rehState.lines.forEach(line => {
    const t = x(stripMarkdown(line.text));
    switch (line.type) {
      case 'act':
      case 'scene':      xml += `    <osf:scene-heading>${t}</osf:scene-heading>\n`; break;
      case 'action':     xml += `    <osf:action>${t}</osf:action>\n`; break;
      case 'transition': xml += `    <osf:transition>${t}</osf:transition>\n`; break;
      case 'direction':  xml += `    <osf:parenthetical speaker="${x(line.speaker)}">${t}</osf:parenthetical>\n`; break;
      case 'dialog':
        xml += `    <osf:dialogue>\n      <osf:character>${x(line.speaker)}</osf:character>\n      <osf:text>${t}</osf:text>\n    </osf:dialogue>\n`;
        break;
    }
  });
  xml += `</osf:content>\n</osf:script>`;
  const blob = new Blob([xml], { type: 'text/xml' });
  const a = document.createElement('a');
  a.href = URL.createObjectURL(blob);
  a.download = (title.replace(/[^a-z0-9_\- ]/gi, '_') || 'script') + '.osf';
  a.click();
  toast('Exported as .osf (Open Screenplay Format)', 'success');
}

// ── PDF import (via pdf.js from CDN) ──────────────────────────────────────

async function loadPdfJs() {
  if (window.pdfjsLib) return;
  await new Promise((resolve, reject) => {
    const s = document.createElement('script');
    s.src = '/static/js/pdf/pdf.min.js';
    s.onload = resolve; s.onerror = reject;
    document.head.appendChild(s);
  });
  pdfjsLib.GlobalWorkerOptions.workerSrc = '/static/js/pdf/pdf.worker.min.js';
}

// Extract a screenplay from a PDF, reconstructing element types from the
// horizontal indentation that screenplays use (the layout *is* the meaning):
//   action/scene  ~ left margin            character  ~ deeply indented (caps)
//   dialogue      ~ medium indent          parenthetical ~ indented "(...)"
//   transition    ~ right-aligned
async function importPDFScript(file) {
  toast('Loading PDF reader…', 'success');
  await loadPdfJs();

  const ab  = await file.arrayBuffer();
  const pdf = await pdfjsLib.getDocument({ data: ab }).promise;

  // First pass: collect every line {x, right, text} per page
  const allLinesByPage = [];
  const allLines = [];  // flat list for margin/width detection
  for (let p = 1; p <= pdf.numPages; p++) {
    const page     = await pdf.getPage(p);
    const content  = await page.getTextContent();
    const viewport = page.getViewport({ scale: 1 });
    const pageW    = viewport.width;

    // Group items into visual rows by Y (PDF Y is bottom-up)
    const rows = new Map();
    content.items.forEach(item => {
      if (!item.str) return;
      const y = Math.round(item.transform[5] / 3) * 3;
      if (!rows.has(y)) rows.set(y, []);
      rows.get(y).push({ x: item.transform[4], w: item.width || 0, str: item.str });
    });

    const pageLines = [];
    [...rows.entries()].sort((a, b) => b[0] - a[0]).forEach(([, items]) => {
      items.sort((a, b) => a.x - b.x);
      const text = items.map(i => i.str).join('').replace(/\s+/g, ' ').trim();
      if (!text) return;
      const x     = items[0].x;
      const last  = items[items.length - 1];
      const right = last.x + (last.w || 0);
      pageLines.push({ x, right, pageW, text });
      allLines.push({ x, right, pageW, text });
    });
    allLinesByPage.push(pageLines);
  }
  if (!allLines.length) return '';

  // Detect the left margin (the most common / smallest x of body lines)
  const leftMargin = Math.min(...allLines.map(l => l.x));
  const pageW = allLines[0].pageW || 612;

  // Noise filter: lone page numbers, scene numbers, "CONTINUED", revision marks
  const isNoise = t => {
    const s = t.trim();
    if (/^\d{1,4}\.?$/.test(s)) return true;                 // bare page/scene number
    if (/^\(?CONTINUED\)?:?$/i.test(s)) return true;
    if (/^\d+\.$/.test(s)) return true;
    if (/^(rev\.|revised|draft)\b/i.test(s) && s.length < 24) return true;
    return false;
  };

  const out = [];
  let prevBlank = true;
  let prevWasAction = false; // track consecutive action lines so we don't split paragraphs
  const push = (line, blankBefore) => {
    if (blankBefore && !prevBlank) { out.push(''); }
    out.push(line);
    prevBlank = false;
  };
  const blank = () => { if (!prevBlank) { out.push(''); prevBlank = true; } };
  const nonAction = () => { prevWasAction = false; };

  for (let pageIdx = 0; pageIdx < pdf.numPages; pageIdx++) {
    // Emit a page-break marker between PDF pages so the rehearser can paginate exactly
    if (pageIdx > 0) { blank(); out.push(`\f${pageIdx + 1}`); blank(); }

    const pageLns = allLinesByPage[pageIdx] || [];
    for (const ln of pageLns) {
    const t = ln.text.trim();
    if (!t || isNoise(t)) continue;

    const indent = (ln.x - leftMargin) / pageW;       // fraction of page width
    const rightFrac = ln.right / pageW;
    const isCaps = t === t.toUpperCase() && /[A-Z]/.test(t);
    const wordCount = t.split(/\s+/).length;

    // Scene heading (slug line)
    if (/^(INT|EXT|INT\.\/EXT|EXT\.\/INT|I\/E)[\. ]/i.test(t)) {
      blank(); push(t.toUpperCase().replace(/\s+\d+[A-Z]?\.?$/, '')); blank(); nonAction();
      continue;
    }
    // Act / scene number headings (theatre)
    if (/^(ACT|SCENE)\s+(\d+|[IVXLC]+|ONE|TWO|THREE|FOUR|FIVE)\b/i.test(t)) {
      blank(); push(t.toUpperCase()); blank(); nonAction();
      continue;
    }
    // Transition (right-aligned, caps, ends with TO: / IN / OUT)
    if (isCaps && (rightFrac > 0.72 || indent > 0.45) &&
        /(TO:|CUT|FADE|DISSOLVE|SMASH|MATCH|WIPE|BLACKOUT|INTERMISSION)\b/.test(t)) {
      blank(); push(t); blank(); nonAction();
      continue;
    }
    // Parenthetical
    if (/^\(.*\)?$/.test(t) || (indent > 0.18 && indent < 0.30 && /^\(/.test(t))) {
      push(t.startsWith('(') ? t : '(' + t + ')', false); nonAction();
      continue;
    }
    // Character cue: deeply indented + caps + short (often has (CONT'D)/(V.O.))
    const nameCore = t.replace(/\s*\([^)]*\)\s*$/, '').trim();
    if (indent > 0.22 && isCaps && wordCount <= 6 && nameCore.length <= 40 &&
        /^[A-Z0-9 .'#\-]+$/.test(nameCore)) {
      blank(); push(t.toUpperCase()); prevBlank = false; nonAction();    // name; dialog follows next line
      continue;
    }
    // Dialogue: medium indent (under a character)
    if (indent > 0.10 && indent < 0.34) {
      push(t, false); nonAction();
      continue;
    }
    // Default: action / description at the left margin.
    // Consecutive action lines join into one paragraph (no blank between them);
    // only start a new paragraph when coming from a non-action line.
    if (prevWasAction) {
      out.push(t); // continue same paragraph
    } else {
      blank(); push(t); // new paragraph
    }
    prevWasAction = true;
    } // end per-page line loop
  } // end page loop

  return out.join('\n').replace(/\n{3,}/g, '\n\n').trim();
}

async function importFromFile(file) {
  try {
    const text = await file.text();
    const data = JSON.parse(text);
    data.clips   = clipsFromJson(data.clips || []);
    data.created = data.created ? new Date(data.created) : new Date();
    data.updated = new Date();
    delete data.id;
    const newId = await rehDbAdd(data);
    toast('Imported: ' + (data.title || 'Untitled'), 'success');
    await renderLibraryList();
    loadRecord({ ...data, id: newId });
  } catch(e) { toast('Import failed: ' + e.message, 'error'); }
}

function loadRecord(rec) {
  // Opening a record from the Library (s-library) must bring the Rehearser
  // section into view — without this, showPhase(2) below just swaps a phase
  // div inside #s-rehearser while that whole section stays display:none,
  // so nothing visibly happens and the click looks like it did nothing.
  if (typeof navTo === 'function') navTo('s-rehearser');
  if ($('reh-script-text'))  $('reh-script-text').value  = rec.script || '';
  if ($('reh-script-title')) $('reh-script-title').value = rec.title  || '';
  rehState.savedId       = rec.id || null;
  rehState._keepSavedIdOnce = true; // re-parsing a loaded entry keeps updating it
  rehState.backend       = rec.backend || '';
  rehState.lineIndex     = rec.lineIndex || 0;
  rehState.clips         = (rec.clips || []).map(c => ({ ...c }));
  rehState.synthCache.clear(); rehDecodedBuffers.clear();
  rehState.narratorVoice = rec.narratorVoice || '';
  const lines = parseScript(rec.script || '');
  if (rec.emotions) {
    lines.forEach((l, i) => { if (l.type === 'dialog' && rec.emotions[i]) l.emotion = rec.emotions[i]; });
  }
  if (rec.notes) {
    lines.forEach((l, i) => { if (l.type === 'dialog' && rec.notes[i]) l.note = rec.notes[i]; });
  }
  if (rec.ignored) lines.forEach((l, i) => { if (rec.ignored[i]) l.ignored = true; });
  if (rec.hidden)  lines.forEach((l, i) => { if (rec.hidden[i])  l.hidden  = true; });
  rehState.lines = lines;
  rehState.cast  = {};
  const detected = detectCharacters(lines);
  Object.entries(detected).forEach(([sp, def]) => {
    const saved = rec.cast?.[sp];
    rehState.cast[sp] = {
      voice:    saved?.voice ?? def.voice,
      color:    saved?.color ?? def.color,
      instruct: saved?.instruct || '',
      lang:     saved?.lang || '', gender: saved?.gender || '',
      tags:     saved?.tags || '', soul: saved?.soul || '',
      ignored:  !!saved?.ignored, hidden: !!saved?.hidden,
      voiceData: saved?.voice && saved.voice !== 'me' ? getVoiceData(saved.voice) : null,
    };
  });
  renderCastList();
  rehApplySharedCast(rec.title);
  refreshRehBackends().then(() => {
    if (rec.backend && $('reh-backend-select')) $('reh-backend-select').value = rec.backend;
    if (rec.narratorVoice && $('reh-narrator-voice')) $('reh-narrator-voice').value = rec.narratorVoice;
  });
  showPhase(2);
}

// Fill any empty cast slots from the production's shared character roster
// (character library, matched by book OR tag). Only blanks are filled — an
// explicit voice/soul already on the rehearsal always wins. Re-renders if it
// changed anything.
async function rehApplySharedCast(title) {
  if (typeof castForProduction !== 'function' || !title) return;
  let roster;
  try { roster = await castForProduction(title); } catch (_) { return; }
  if (!roster) return;
  let changed = false;
  Object.keys(rehState.cast || {}).forEach(sp => {
    // Narrator can now have a real, persisted Library record too (Assign
    // Voices synthesizes one per production) — pull its voice the same way
    // as any other shared cast entry instead of skipping it, so a voice
    // picked there actually reaches the Rehearser/synthesis. The narrator's
    // cast key is the emoji-prefixed REH_NARRATOR_KEY sentinel, not its
    // plain "Narrator" library name, so the roster lookup below needs the
    // same translation renderCastStrip() already uses elsewhere — without
    // it, `roster["📖narrator"]` always misses and this silently never
    // fires for narrator at all (confirmed live: synthAll() then skips
    // every narration line since it reads rehState.narratorVoice directly,
    // which this function is also the only place expected to set from a
    // shared/library voice).
    const lookupName = sp === REH_NARRATOR_KEY ? 'narrator' : String(sp).toLowerCase();
    const shared = roster[lookupName];
    if (!shared) return;
    const slot = rehState.cast[sp];
    if (shared.voice && !slot.voice) {
      slot.voice = shared.voice;
      slot.voiceData = (shared.voice !== 'me' && typeof getVoiceData === 'function') ? getVoiceData(shared.voice) : null;
      changed = true;
      if (sp === REH_NARRATOR_KEY) rehState.narratorVoice = shared.voice;
    }
    if (shared.gender && !slot.gender) { slot.gender = shared.gender; changed = true; }
    if (shared.soul && !slot.soul) { slot.soul = shared.soul; changed = true; }
  });
  if (changed) renderCastList();
}

// ── Library UI ─────────────────────────────────────────────────────────────

// Deterministic cover gradient from the title string
function bookCover(title) {
  let h = 0;
  for (let i = 0; i < title.length; i++) h = (h * 31 + title.charCodeAt(i)) % 360;
  const h2 = (h + 40) % 360;
  return { c1: `hsl(${h}, 55%, 42%)`, c2: `hsl(${h2}, 58%, 30%)` };
}

let rehLibView = localStorage.getItem('reh-lib-view') || 'shelf';

function rehTitleKey(title) {
  return String(title || '').replace(/\s+/g, ' ').trim().toLowerCase();
}

function rehUniqueLibraryRecords(records) {
  const byTitle = new Map();
  const ordered = [...records].sort((a, b) => {
    const at = new Date(a.updated || 0).getTime();
    const bt = new Date(b.updated || 0).getTime();
    if (at !== bt) return bt - at;
    return (b.id || 0) - (a.id || 0);
  });
  for (const rec of ordered) {
    const key = rehTitleKey(rec.title);
    const bucketKey = key || `__reh__${rec.id}`;
    if (!byTitle.has(bucketKey)) byTitle.set(bucketKey, rec);
  }
  return [...byTitle.values()].sort((a, b) => {
    const at = new Date(a.updated || 0).getTime();
    const bt = new Date(b.updated || 0).getTime();
    if (at !== bt) return bt - at;
    return (b.id || 0) - (a.id || 0);
  });
}

async function renderLibraryList() {
  const list = $('reh-library-list'); if (!list) return;
  let all;
  try { all = await rehDbGetAll(); } catch(e) { all = []; }
  all = rehUniqueLibraryRecords(all);

  list.classList.toggle('list-view', rehLibView === 'list');
  const vt = $('reh-lib-view-toggle');
  if (vt) vt.innerHTML = `<span class="mdi mdi-${rehLibView === 'list' ? 'view-grid' : 'view-list'}"></span>`;

  if (!all.length) {
    list.innerHTML = '<div class="reh-lib-empty"><span class="mdi mdi-book-open-outline"></span><p>No saved rehearsals yet.<br>Parse a script below or drop a file to start.</p></div>';
    return;
  }

  list.innerHTML = all.map(rec => {
    const speakers  = Object.keys(rec.cast || {});
    const meCount   = speakers.filter(sp => rec.cast[sp]?.voice === 'me').length;
    const clipCount = (rec.clips || []).filter(c => c.type === 'me' && c.blob).length;
    const total     = parseScript(rec.script || '').filter(l => l.type === 'dialog').length;
    const pct       = total ? Math.round(((rec.lineIndex || 0) / total) * 100) : 0;
    const date      = rec.updated ? new Date(rec.updated).toLocaleDateString() : '—';
    const isCurrent = rec.id === rehState.savedId;
    const title     = rec.title || 'Untitled';
    const { c1, c2 } = bookCover(title);
    const avatars   = speakers.slice(0, 5).map(sp => {
      const c = rec.cast[sp];
      return `<span style="background:${c.color}">${sp[0].toUpperCase()}</span>`;
    }).join('');
    return `<div class="reh-book" data-id="${rec.id}" style="--bk1:${c1};--bk2:${c2}" title="${escHtml(title)}">
      ${isCurrent ? '<span class="reh-book-active-tag">active</span>' : ''}
      <div class="reh-book-actions">
        <button class="reh-book-act reh-lib-export" data-id="${rec.id}" title="Export .reh"><span class="mdi mdi-export"></span></button>
        <button class="reh-book-act reh-lib-delete" data-id="${rec.id}" title="Delete"><span class="mdi mdi-delete-outline"></span></button>
      </div>
      <div class="reh-book-title">${escHtml(title)}</div>
      <div class="reh-book-meta">
        <div class="reh-book-avatars">${avatars}</div>
        ${total} lines · ${speakers.length} cast${meCount ? ' · ' + meCount + ' me' : ''}${clipCount ? ' · ' + clipCount + '🎤' : ''}
        <div class="reh-book-progress"><div style="width:${pct}%"></div></div>
        <div style="margin-top:4px;opacity:.8">${pct}% · ${date}</div>
      </div>
    </div>`;
  }).join('');

  // Click book → open
  list.querySelectorAll('.reh-book').forEach(book => book.addEventListener('click', async e => {
    if (e.target.closest('.reh-book-act')) return;
    const id = parseInt(book.dataset.id);
    // rehDbOpen()/REH_STORE were the pre-migration raw-IndexedDB API and no
    // longer exist — rehearsals are server-backed now (rehDbGetById).
    const rec = await rehDbGetById(id);
    if (rec) loadRecord(rec);
    else toast('Rehearsal not found', 'error');
  }));

  list.querySelectorAll('.reh-lib-export').forEach(btn => btn.addEventListener('click', async e => {
    e.stopPropagation();
    const id = parseInt(btn.dataset.id);
    const rec = await rehDbGetById(id);
    if (!rec) { toast('Rehearsal not found', 'error'); return; }
    rec.version = 1;
    rec.clips = await clipsToJson(rec.clips || []);
    const json = JSON.stringify(rec, null, 2);
    const a = document.createElement('a');
    const t = (rec.title || 'rehearsal').replace(/[^a-z0-9_\- ]/gi, '_').slice(0, 40);
    a.href = URL.createObjectURL(new Blob([json], { type: 'application/json' }));
    a.download = t + '.reh';
    a.click();
  }));

  list.querySelectorAll('.reh-lib-delete').forEach(btn => btn.addEventListener('click', async e => {
    e.stopPropagation();
    
    const bookEl = btn.closest('.reh-book');
    if (bookEl.querySelector('.reh-book-del-confirm')) return;
    
    const confirmOverlay = document.createElement('div');
    confirmOverlay.className = 'reh-book-del-confirm';
    confirmOverlay.style.cssText = 'position:absolute; inset:0; background:rgba(0,0,0,0.85); color:#fff; display:flex; flex-direction:column; justify-content:center; align-items:center; border-radius:inherit; z-index:10; padding:12px; text-align:center; box-sizing:border-box;';
    confirmOverlay.innerHTML = `
      <div style="font-weight:600; margin-bottom:8px; font-size:14px;">Delete Rehearsal?</div>
      <div style="font-size:11px; opacity:0.8; margin-bottom:12px; line-height:1.4;">This cannot be undone.</div>
      <div style="display:flex; gap:8px;">
        <button class="btn-secondary btn-sm" id="btn-cancel-del" style="background:rgba(255,255,255,0.15); border:none; color:#fff; padding:6px 12px;">Cancel</button>
        <button class="btn-primary btn-sm" id="btn-confirm-del" style="background:var(--red,#ef4444); border:none; color:#fff; padding:6px 12px;">Delete</button>
      </div>
    `;
    
    confirmOverlay.addEventListener('click', ce => ce.stopPropagation());
    
    confirmOverlay.querySelector('#btn-cancel-del').addEventListener('click', ce => {
      ce.stopPropagation();
      confirmOverlay.remove();
    });
    
    confirmOverlay.querySelector('#btn-confirm-del').addEventListener('click', async ce => {
      ce.stopPropagation();
      await rehDbDelete(parseInt(btn.dataset.id));
      if (rehState.savedId === parseInt(btn.dataset.id)) rehState.savedId = null;
      renderLibraryList();
    });
    
    bookEl.appendChild(confirmOverlay);
  }));
}

$('reh-lib-view-toggle')?.addEventListener('click', () => {
  rehLibView = rehLibView === 'shelf' ? 'list' : 'shelf';
  localStorage.setItem('reh-lib-view', rehLibView);
  renderLibraryList();
});

// ── Helpers ────────────────────────────────────────────────────────────────

function getVoiceData(voiceId) {
  return (window._voices || []).find(v => v.id === voiceId) || null;
}

function _rehVoiceVisibleId(voiceId, include = '') {
  if (!voiceId) return false;
  if (include && voiceId === include) return true;
  const v = getVoiceData(voiceId);
  return !v || v.enabled !== false;
}

function voiceAvatarHtml(voiceId, color, size = 32) {
  const v = getVoiceData(voiceId);
  const s = size + 'px';
  const radius = Math.round(size / 2);
  if (v?.has_picture) {
    return `<img src="/api/voice/picture/${encodeURIComponent(voiceId)}" class="reh-char-img" style="width:${s};height:${s};border-radius:${radius}px;object-fit:cover;flex-shrink:0" alt="${escHtml(voiceId)}">`;
  }
  const ic = (v?.avatar && window.VOICE_AVATAR_ICONS) ? window.VOICE_AVATAR_ICONS[v.avatar] : null;
  if (ic) {
    return `<span class="reh-char-img" style="width:${s};height:${s};border-radius:${radius}px;background:${color};color:#fff;display:inline-flex;align-items:center;justify-content:center;flex-shrink:0"><span class="mdi ${ic}" style="font-size:${Math.round(size * 0.56)}px"></span></span>`;
  }
  const initial = (voiceId || '?')[0].toUpperCase();
  return `<span class="reh-char-img" style="width:${s};height:${s};border-radius:${radius}px;background:${color};color:#fff;font-weight:700;font-size:${Math.round(size * 0.45)}px;display:inline-flex;align-items:center;justify-content:center;flex-shrink:0">${initial}</span>`;
}

// Stage line rows used a generic voice icon/initial for the play-avatar
// button — a plain "?" for any speaker whose assigned voice has no picture
// of its own, even when the CHARACTER already has a real portrait in the
// Library (same one shown everywhere else: Cast Audiobook, Assign Voices,
// the Cast sidebar strip right next to this same line). Prefer that.
function _rehCharAvatarHtml(speaker, voiceId, color, size = 32) {
  const rec = (_rehLibCharsCache || []).find(r => String(r.name || '').trim().toLowerCase() === String(speaker || '').trim().toLowerCase());
  if (rec && rec.image) {
    const s = size + 'px'; const radius = Math.round(size / 2);
    // Reference the image by URL, never inline the raw data: URL here — this
    // renders once PER DIALOGUE LINE, and a character can speak hundreds of
    // lines; embedding a multi-KB/MB base64 blob that many times ballooned a
    // real 1968-line script's HTML to hundreds of megabytes and silently
    // failed to render at all (confirmed live). The browser fetches/caches
    // the URL once regardless of how many lines reference it.
    return `<img src="/api/characters/${encodeURIComponent(rec.id)}/image" class="reh-char-img" style="width:${s};height:${s};border-radius:${radius}px;object-fit:cover;flex-shrink:0" alt="${escHtml(speaker)}">`;
  }
  return voiceAvatarHtml(voiceId, color, size);
}

// ── Script parser + detectCharacters → moved to rehearser-parse.js (loaded first) ──

// ── Phase navigation ───────────────────────────────────────────────────────

function showPhase(n) {
  // Hide the import/export panel when switching to a numbered phase
  const impex = $('reh-impex-panel'); if (impex) impex.hidden = true;
  for (let i = 1; i <= 4; i++) { const el = $('reh-phase-' + i); if (el) el.hidden = i !== n; }
  syncPhaseTabs(n);
  if (typeof window.onRehearserPhaseChange === 'function') window.onRehearserPhaseChange(n);
}

window.showRehImpEx = function () {
  stopPlay(); stopRehMic();
  for (let i = 1; i <= 4; i++) { const el = $('reh-phase-' + i); if (el) el.hidden = true; }
  const panel = $('reh-impex-panel'); if (panel) panel.hidden = false;
  // Show export note based on state
  const note = $('reh-impex-export-note');
  if (note) note.textContent = rehState.lines.length
    ? `Current session: "${$('reh-script-title')?.value || 'Untitled'}" · ${rehState.lines.filter(l=>l.type==='dialog').length} lines`
    : 'No active session — load a script first to export.';
};

// Keep the sub-tab bar in sync: highlight current, enable reachable phases
function syncPhaseTabs(n) {
  const hasScript = rehState.lines.length > 0;
  const hasClips  = rehState.clips.length > 0;
  document.querySelectorAll('.reh-subtab').forEach(tab => {
    const p = parseInt(tab.dataset.phase);
    tab.classList.toggle('active', p === n);
    // Library always reachable; Cast/Stage need a parsed script; Summary needs clips (or being on it)
    let enabled = p === 1
      || (p === 2 && hasScript)
      || (p === 3 && hasScript)
      || (p === 4 && (hasClips || n === 4));
    tab.disabled = !enabled;
  });
}

document.querySelectorAll('.reh-subtab').forEach(tab => {
  tab.addEventListener('click', () => {
    if (tab.disabled) return;
    const p = parseInt(tab.dataset.phase);
    // Leaving the stage: stop playback/mic so audio doesn't keep running
    if (p !== 3) { stopPlay(); stopRehMic(); hideRecOverlay(); }
    if (p === 1) renderLibraryList();
    if (p === 3) {
      // (Re)build the stage if we have a cast/script
      if (rehState.lines.length) { buildScriptPage(); showPhase(3); highlightCurrentLine(); return; }
    }
    if (p === 4) { renderSummary(); }
    showPhase(p);
  });
});

// ── Phase 1 ────────────────────────────────────────────────────────────────

$('reh-file-input')?.addEventListener('change', function () {
  const f = this.files?.[0]; if (!f) return;
  const guess = f.name.replace(/\.[^.]+$/, '').replace(/[-_]+/g, ' ').trim();
  const r = new FileReader();
  r.onload = async e => {
    $('reh-script-text').value = e.target.result;
    await rehAutoSaveImport(guess);
    toast('Script loaded & saved to your library — click Parse & cast', 'success');
  };
  r.readAsText(f); this.value = '';
});

$('reh-pdf-input')?.addEventListener('change', async function () {
  const f = this.files?.[0]; if (!f) return;
  this.value = '';
  try {
    const text = await importPDFScript(f);
    if ($('reh-script-text')) $('reh-script-text').value = text;
    const guess = f.name.replace(/\.pdf$/i, '').replace(/[-_]+/g, ' ').trim();
    await rehAutoSaveImport(guess);
    toast('PDF imported & saved to your library — check formatting, then click Parse & cast', 'success');
  } catch(e) { toast('PDF import failed: ' + e.message, 'error'); }
});

$('reh-fdx-input')?.addEventListener('change', async function () {
  const f = this.files?.[0]; if (!f) return;
  this.value = '';
  try {
    const text = await importFDX(f);
    if ($('reh-script-text')) $('reh-script-text').value = text;
    if (!$('reh-script-title')?.value.trim()) {
      const guess = f.name.replace(/\.fdx$/i, '').replace(/[-_]+/g, ' ').trim();
      if ($('reh-script-title')) $('reh-script-title').value = guess;
    }
    toast('FDX imported — click Parse & cast', 'success');
  } catch(e) { toast('FDX import failed: ' + e.message, 'error'); }
});

// ── Unified import router (used by file pickers + drag & drop) ──────────────
async function rehImportAnyFile(f) {
  if (!f) return;
  const name = f.name.toLowerCase();
  const setTitle = strip => {
    if (!$('reh-script-title')?.value.trim()) {
      const guess = f.name.replace(strip, '').replace(/[-_]+/g, ' ').trim();
      if ($('reh-script-title')) $('reh-script-title').value = guess;
    }
  };
  try {
    if (name.endsWith('.reh') || name.endsWith('.json')) {
      await importFromFile(f);                       // full session → loads & jumps to cast
      return;
    }
    if (name.endsWith('.pdf')) {
      toast('Reading PDF…', 'success');
      const text = await importPDFScript(f);
      if ($('reh-script-text')) $('reh-script-text').value = text;
      setTitle(/\.pdf$/i);
      await rehAutoSaveImport();
      toast('PDF imported & saved to your library — check formatting, then Parse & cast', 'success');
      return;
    }
    if (name.endsWith('.fdx') || name.endsWith('.osf') || name.endsWith('.xml')) {
      const text = await importFDX(f);
      if ($('reh-script-text')) $('reh-script-text').value = text;
      setTitle(/\.(fdx|osf|xml)$/i);
      await rehAutoSaveImport();
      toast('Script imported & saved to your library — click Parse & cast', 'success');
      return;
    }
    // .txt / .md / .fountain / anything else → plain text
    const text = await f.text();
    if ($('reh-script-text')) $('reh-script-text').value = text;
    setTitle(/\.(txt|md|fountain)$/i);
    await rehAutoSaveImport();
    toast('Script loaded & saved to your library — click Parse & cast', 'success');
  } catch(e) { toast('Import failed: ' + e.message, 'error'); }
}

// Drag & drop over the dropzone AND the whole Phase-1 panel
(function setupRehDropzone() {
  const dz    = $('reh-dropzone');
  const phase = $('reh-phase-1');
  if (!dz || !phase) return;
  let depth = 0;

  const isFileDrag = e => e.dataTransfer && [...(e.dataTransfer.types || [])].includes('Files');

  phase.addEventListener('dragenter', e => {
    if (!isFileDrag(e)) return;
    e.preventDefault(); depth++; dz.classList.add('dragover');
    dz.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
  });
  phase.addEventListener('dragover', e => { if (isFileDrag(e)) e.preventDefault(); });
  phase.addEventListener('dragleave', e => {
    if (!isFileDrag(e)) return;
    depth = Math.max(0, depth - 1);
    if (depth === 0) dz.classList.remove('dragover');
  });
  phase.addEventListener('drop', async e => {
    if (!isFileDrag(e)) return;
    e.preventDefault(); depth = 0; dz.classList.remove('dragover');
    const f = e.dataTransfer.files?.[0];
    await rehImportAnyFile(f);
  });
})();

$('reh-parse-btn')?.addEventListener('click', () => {
  const text = $('reh-script-text')?.value.trim();
  if (!text) { toast('Paste or upload a script first', 'error'); return; }
  rehState.lines = parseScript(text);
  if (!rehState.lines.filter(l => l.type === 'dialog').length) {
    toast('No dialog found. Use screenplay format (CAPS name + dialog) or CHAR: text.', 'error'); return;
  }
  // Preserve cast for returning characters
  const detected = detectCharacters(rehState.lines);
  Object.entries(detected).forEach(([sp]) => {
    if (rehState.cast[sp]) detected[sp] = { ...detected[sp], ...rehState.cast[sp] };
  });
  rehState.cast      = detected;
  // Keep the imported/loaded library entry on the first parse so casting updates it
  // instead of orphaning it; otherwise start a fresh entry.
  if (rehState._keepSavedIdOnce) rehState._keepSavedIdOnce = false;
  else rehState.savedId = null;
  rehState.clips     = [];
  rehState.lineIndex = 0;
  rehState.synthCache.clear(); rehDecodedBuffers.clear();
  renderCastList();
  showPhase(2);
  refreshRehBackends();
});

// ── Phase 2 ────────────────────────────────────────────────────────────────

function castAvatarHtml(sp) {
  const c = rehState.cast[sp]; if (!c) return '';
  if (c.voice && c.voice !== 'me') {
    const vd = getVoiceData(c.voice);
    if (vd?.has_picture) return `<img src="/api/voice/picture/${encodeURIComponent(c.voice)}" style="width:36px;height:36px;border-radius:50%;object-fit:cover;border:2px solid ${c.color}" alt="">`;
    const ic = (vd?.avatar && window.VOICE_AVATAR_ICONS) ? window.VOICE_AVATAR_ICONS[vd.avatar] : null;
    if (ic) return `<span style="width:36px;height:36px;border-radius:50%;background:${c.color};color:#fff;display:inline-flex;align-items:center;justify-content:center;border:2px solid ${c.color}"><span class="mdi ${ic}" style="font-size:20px"></span></span>`;
  }
  const initial = sp[0].toUpperCase();
  return `<span style="width:36px;height:36px;border-radius:50%;background:${c.color};color:#fff;font-weight:700;font-size:16px;display:inline-flex;align-items:center;justify-content:center;border:2px solid ${c.color}">${initial}</span>`;
}

// ── Online voice picker: audition a sample, browse alternatives, agree/switch ──
let _rehAudEl = null, _rehAudBtn = null;
function _rehStopAudition() {
  if (_rehAudEl) { try { _rehAudEl.pause(); } catch (_) {} }
  if (_rehAudBtn) { _rehAudBtn.classList.remove('playing'); const i = _rehAudBtn.querySelector('.mdi'); if (i) i.className = 'mdi mdi-play'; }
  _rehAudBtn = null;
}
function _rehAudition(url, btn) {
  if (!url) { toast('No preview audio for this voice', 'error'); return; }
  if (_rehAudBtn === btn && _rehAudEl && !_rehAudEl.paused) { _rehStopAudition(); return; }
  _rehStopAudition();
  if (!_rehAudEl) { _rehAudEl = new Audio(); _rehAudEl.addEventListener('ended', _rehStopAudition); }
  _rehAudEl.src = url;
  _rehAudEl.play().then(() => {
    _rehAudBtn = btn; btn.classList.add('playing');
    const i = btn.querySelector('.mdi'); if (i) i.className = 'mdi mdi-stop';
  }).catch(() => toast('Could not play preview', 'error'));
}

const _REH_PREVIEW_TEXT = 'Hello — this is how this voice sounds.';
const _rehSearchCache = {}; // sp -> last fish.audio search results (simplified candidates)

// One row of the voice picker. Plays via sample URL (online) or TTS (local library voice).
function _rehVoiceRow({ name, meta, playUrl, playVoice, isCurrent, useAttrs }) {
  const play = `<button type="button" class="reh-vo-play"${playUrl ? ` data-url="${escHtml(playUrl)}"` : ''}${playVoice ? ` data-voice="${escHtml(playVoice)}"` : ''} title="Preview voice"><span class="mdi mdi-play"></span></button>`;
  const right = isCurrent
    ? `<span class="reh-vo-badge"><span class="mdi mdi-check-circle"></span> Selected</span>`
    : `<button type="button" class="btn-secondary btn-sm reh-vo-use"${useAttrs || ''}>Use this</button>`;
  return `<div class="reh-vo-row${isCurrent ? ' current' : ''}">${play}
    <div class="reh-vo-info"><span class="reh-vo-name">${escHtml(name)}</span><span class="reh-vo-meta">${escHtml(meta)}</span></div>
    ${right}</div>`;
}

// Render the "matched from fish.audio" picker: current voice + alternatives + change tools
function castOnlinePanelHtml(sp, c) {
  const o = c.online;
  if (!o || !Array.isArray(o.candidates) || c.voice === 'me') return '';

  // Current assigned voice — an online candidate (has a sample) or a plain library voice
  const curCand = o.candidates.find(x => x.voice_id && x.voice_id === c.voice);
  let curRow;
  if (curCand) {
    curRow = _rehVoiceRow({ name: curCand.title || c.voice, meta: [curCand.gender, curCand.language].filter(Boolean).join(' · ') || 'fish.audio', playUrl: curCand.sample_audio, isCurrent: true });
  } else if (c.voice) {
    const vd = getVoiceData(c.voice);
    curRow = _rehVoiceRow({ name: vd?.name || c.voice, meta: vd?.group || vd?.tag || 'library voice', playVoice: c.voice, isCurrent: true });
  } else {
    curRow = `<div class="reh-vo-row"><div class="reh-vo-info"><span class="reh-vo-name">No voice assigned</span><span class="reh-vo-meta">pick one below</span></div></div>`;
  }

  // Alternatives = the other matched candidates (not the current one)
  const alts = o.candidates.map((cand, i) => ({ cand, i })).filter(({ cand }) => cand.voice_id !== c.voice || !cand.voice_id);
  const altRows = alts.map(({ cand, i }) => _rehVoiceRow({
    name: cand.title || 'Voice', meta: [cand.gender, cand.language].filter(Boolean).join(' · ') || 'fish.audio',
    playUrl: cand.sample_audio, useAttrs: ` data-act="alt" data-idx="${i}"`,
  })).join('');

  return `<div class="reh-cc-online">
    <div class="reh-cc-online-head"><span class="mdi mdi-earth"></span> Voice — try &amp; change
      ${alts.length ? `<button type="button" class="reh-vo-toggle">${alts.length} match${alts.length !== 1 ? 'es' : ''} ▾</button>` : ''}</div>
    <div class="reh-vo-list">${curRow}</div>
    ${alts.length ? `<div class="reh-vo-list reh-vo-alts" hidden>${altRows}</div>` : ''}
    <div class="reh-vo-tools">
      <button type="button" class="reh-vo-tool" data-tool="local"><span class="mdi mdi-bookshelf"></span> From library</button>
      <button type="button" class="reh-vo-tool" data-tool="search"><span class="mdi mdi-magnify"></span> Search online</button>
    </div>
    <div class="reh-vo-tool-panel reh-vo-local-panel" hidden>
      <input type="search" class="reh-vo-local-input" placeholder="Filter your library voices…" autocomplete="off">
      <div class="reh-vo-results reh-vo-local-results"></div>
    </div>
    <div class="reh-vo-tool-panel reh-vo-search-panel" hidden>
      <div class="reh-vo-search-row"><input type="search" class="reh-vo-search-input" placeholder="Search fish.audio (name, style, language)…" autocomplete="off"><button type="button" class="btn-secondary btn-sm reh-vo-search-go">Search</button></div>
      <div class="reh-vo-results reh-vo-search-results"><div class="reh-vo-hint">Type a query and hit Search to browse fish.audio voices.</div></div>
    </div>
  </div>`;
}

// Preview a local library voice by synthesizing a short sample with the chosen backend
async function _rehPreviewLocal(voiceId, btn) {
  const backend = $('reh-backend-select')?.value;
  if (!backend) { toast('Select a TTS backend first', 'error'); return; }
  if (_rehAudBtn === btn && _rehAudEl && !_rehAudEl.paused) { _rehStopAudition(); return; }
  _rehStopAudition();
  const icon = btn.querySelector('.mdi');
  btn.classList.add('loading'); if (icon) icon.className = 'mdi mdi-loading';
  try {
    const blob = await fetchTtsPreviewBlob(voiceId, _REH_PREVIEW_TEXT, 'wav', '', backend);
    if (!_rehAudEl) { _rehAudEl = new Audio(); _rehAudEl.addEventListener('ended', _rehStopAudition); }
    _rehAudEl.src = URL.createObjectURL(blob);
    await _rehAudEl.play();
    btn.classList.remove('loading'); _rehAudBtn = btn; btn.classList.add('playing');
    if (icon) icon.className = 'mdi mdi-stop';
  } catch (e) {
    btn.classList.remove('loading'); if (icon) icon.className = 'mdi mdi-play';
    toast('Preview failed: ' + (e.message || e), 'error');
  }
}

// Pick a representative short line from a character's own dialogue (narrator: from
// the action/scene lines it narrates). Prefers a self-contained ~20–110 char sentence.
function _rehPickOneLiner(sp) {
  const isNarr = sp === REH_NARRATOR_KEY;
  const pool = rehState.lines
    .filter(l => isNarr ? (l.type !== 'dialog' && l.type !== 'pagebreak' && !l.ignored) : (l.type === 'dialog' && l.speaker === sp))
    .map(l => ({ text: stripMarkdown(l.text || '').trim(), emotion: l.emotion || '' }))
    .filter(l => l.text.length >= 4);
  if (!pool.length) return null;
  const scored = pool.map(l => {
    const len = l.text.length;
    let score = (len >= 20 && len <= 110) ? 3 : (len < 20 ? 1 : 0);
    if (/[.!?]["']?$/.test(l.text)) score += 1;          // complete sentence
    score -= Math.abs(len - 60) / 120;                    // prefer ~60 chars
    return { l, score };
  }).sort((a, b) => b.score - a.score);
  const best = scored[0].l;
  return { text: best.text.slice(0, 220), emotion: best.emotion };
}

// Synthesize and play a one-liner from this character's lines, in their assigned voice.
async function _rehPreviewCastLine(sp, btn) {
  const c = rehState.cast[sp];
  if (!c || !c.voice || c.voice === 'me') { toast('Assign a voice first', 'error'); return; }
  const backend = $('reh-backend-select')?.value;
  if (!backend) { toast('Select a TTS backend first', 'error'); return; }
  if (_rehAudBtn === btn && _rehAudEl && !_rehAudEl.paused) { _rehStopAudition(); return; }
  _rehStopAudition();
  const pick = _rehPickOneLiner(sp);
  if (!pick) { toast('No lines to preview yet', 'error'); return; }
  const icon = btn.querySelector('.mdi');
  btn.classList.add('loading'); if (icon) icon.className = 'mdi mdi-loading';
  try {
    const blob = await fetchTtsPreviewBlob(c.voice, _rehInlineTone(pick.text, pick.emotion), 'wav', _buildInstruct(c.instruct, pick.emotion, c.voice), backend);
    if (!_rehAudEl) { _rehAudEl = new Audio(); _rehAudEl.addEventListener('ended', _rehStopAudition); }
    _rehAudEl.src = URL.createObjectURL(blob);
    await _rehAudEl.play();
    btn.classList.remove('loading'); _rehAudBtn = btn; btn.classList.add('playing');
    if (icon) icon.className = 'mdi mdi-stop';
  } catch (e) {
    btn.classList.remove('loading'); if (icon) icon.className = 'mdi mdi-play';
    toast('Preview failed: ' + (e.message || e), 'error');
  }
}

// Assign an existing library voice to a character (keeps the picker open)
function _rehAssignLocal(sp, voiceId) {
  const c = rehState.cast[sp]; if (!c) return;
  _rehStopAudition();
  c.voice = voiceId; c.voiceData = getVoiceData(voiceId);
  if (c.online) c.online.picked = c.online.candidates.findIndex(x => x.voice_id === voiceId);
  renderCastList(); if (typeof populateNarratorSelect === 'function') populateNarratorSelect();
}

// Render filtered library voices inside a card's "From library" panel
function _rehRenderLocalResults(card, sp, q) {
  const box = card.querySelector('.reh-vo-local-results'); if (!box) return;
  const cur = rehState.cast[sp]?.voice;
  const ql = (q || '').trim().toLowerCase();
  const matches = rehState.voices.filter(v => {
    if (!_rehVoiceVisibleId(v, cur)) return false;
    if (v === cur) return false;
    if (!ql) return true;
    const vd = getVoiceData(v);
    return v.toLowerCase().includes(ql) || (vd?.name || '').toLowerCase().includes(ql) || (vd?.group || '').toLowerCase().includes(ql);
  }).slice(0, 40);
  if (!matches.length) { box.innerHTML = `<div class="reh-vo-hint">No library voices match.</div>`; return; }
  box.innerHTML = matches.map(v => {
    const vd = getVoiceData(v);
    return _rehVoiceRow({ name: vd?.name || v, meta: vd?.group || vd?.tag || 'library voice', playVoice: v, useAttrs: ` data-act="local" data-voice="${escHtml(v)}"` });
  }).join('');
}

// Search fish.audio and render results inside a card's "Search online" panel
async function _rehSearchOnline(card, sp, q) {
  const box = card.querySelector('.reh-vo-search-results'); if (!box) return;
  q = (q || '').trim();
  if (!q) { box.innerHTML = `<div class="reh-vo-hint">Enter a search term first.</div>`; return; }
  box.innerHTML = `<div class="reh-vo-hint"><span class="reh-imsdb-spinner"></span> Searching fish.audio…</div>`;
  const lang = REH_FISH_LANG[$('reh-design-lang')?.value || 'English'] ?? 'en';
  let items = [];
  try {
    const qs = [`search=${encodeURIComponent(q)}`, `language=${lang}`, 'page_size=10', 'sort_by=score'];
    items = (await fetch('/api/fishaudio/voices?' + qs.join('&')).then(r => r.json())).items || [];
  } catch (_) {}
  const cands = items.filter(v => v.sample_audio).slice(0, 10).map(v => ({
    title: v.title, sample_audio: v.sample_audio, image: v.image || '', gender: v.gender || '',
    language: v.language || lang || '', description: v.description || '', sample_text: v.sample_text || v.default_text || '',
  }));
  _rehSearchCache[sp] = cands;
  if (!cands.length) { box.innerHTML = `<div class="reh-vo-hint">No playable voices found for “${escHtml(q)}”.</div>`; return; }
  box.innerHTML = cands.map((cand, i) => _rehVoiceRow({
    name: cand.title || 'Voice', meta: [cand.gender, cand.language].filter(Boolean).join(' · ') || 'fish.audio',
    playUrl: cand.sample_audio, useAttrs: ` data-act="search" data-idx="${i}"`,
  })).join('');
}

// Import a freshly searched fish.audio result, assign it, and fold it into candidates
async function _rehUseSearchResult(sp, idx, btn) {
  const c = rehState.cast[sp]; if (!c) return;
  const cand = (_rehSearchCache[sp] || [])[idx]; if (!cand) return;
  _rehStopAudition();
  const orig = btn.innerHTML; btn.disabled = true; btn.innerHTML = '<span class="reh-imsdb-spinner"></span>';
  try {
    const vid = await _rehImportFishCandidate(sp, cand);
    cand.voice_id = vid; c.voice = vid; c.voiceData = getVoiceData(vid);
    if (!c.online) c.online = { candidates: [], picked: 0 };
    c.online.candidates.push(cand);
    c.online.picked = c.online.candidates.length - 1;
    if (typeof loadVoiceLibrary === 'function') await loadVoiceLibrary().catch(() => {});
    renderCastList(); if (typeof populateNarratorSelect === 'function') populateNarratorSelect();
    toast(`Switched ${sp} to ${cand.title || 'voice'}`, 'success');
  } catch (err) {
    btn.disabled = false; btn.innerHTML = orig;
    toast('Import failed: ' + err.message, 'error');
  }
}

// Remember fish imports this session so the same voice isn't downloaded twice
const _rehFishImported = {};

// Import one fish.audio candidate into the library and return its voice_id.
// Reuses an already-imported voice (this session OR already in the library) so the
// same fish.audio voice doesn't pile up as Mortal_Kombat, Mortal_Kombat_2, …
async function _rehImportFishCandidate(sp, cand) {
  const key = (cand.sample_audio || cand.title || '').toLowerCase();
  if (key && _rehFishImported[key]) {
    const id = _rehFishImported[key];
    if (!rehState.voices.includes(id)) rehState.voices.push(id);
    return id;
  }
  const title = (cand.title || '').toLowerCase().trim();
  const existing = title && (window._voices || []).find(v =>
    (v.group === 'fish-audio' || v.tag === 'fish-audio') && (v.name || '').toLowerCase().trim() === title);
  if (existing) {
    if (key) _rehFishImported[key] = existing.id;
    if (!rehState.voices.includes(existing.id)) rehState.voices.push(existing.id);
    return existing.id;
  }
  const lang2 = (cand.language || 'EN').slice(0, 2).toUpperCase();
  const vid = `${lang2}_${(typeof _umlautSafe === 'function' ? _umlautSafe(cand.title || sp) : (cand.title || sp)).replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 36) || 'Voice'}`;
  const d = await fetch('/api/quick-import-voice', {
    method: 'POST', headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ voice_id: vid, audio_url: cand.sample_audio, transcript: cand.sample_text || '' }),
  }).then(r => r.json());
  if (!d.voice_id) throw new Error('import returned no id');
  if (typeof saveMeta === 'function') await saveMeta(d.voice_id, { name: cand.title || sp, tag: 'fish-audio', group: 'fish-audio', origin: 'cloned', gender: (cand.gender || '').charAt(0).toUpperCase(), note: (cand.description || '').slice(0, 180) }).catch(e => logErr('fish saveMeta', e));
  if (cand.image) await fetch('/api/voice/picture-url', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ voice_id: d.voice_id, image_url: cand.image }) }).catch(e => logErr('fish picture', e));
  if (!rehState.voices.includes(d.voice_id)) rehState.voices.push(d.voice_id);
  if (key) _rehFishImported[key] = d.voice_id;
  return d.voice_id;
}

// "Disagree" → switch this character to one of the presented alternatives
async function _rehUseCandidate(sp, idx, btn) {
  const c = rehState.cast[sp]; const o = c && c.online; if (!o) return;
  const cand = o.candidates[idx]; if (!cand) return;
  _rehStopAudition();
  if (cand.voice_id) { // already imported earlier — just reassign
    c.voice = cand.voice_id; c.voiceData = getVoiceData(cand.voice_id); o.picked = idx;
    renderCastList(); if (typeof populateNarratorSelect === 'function') populateNarratorSelect();
    return;
  }
  const orig = btn.innerHTML; btn.disabled = true; btn.innerHTML = '<span class="reh-imsdb-spinner"></span>';
  try {
    const vid = await _rehImportFishCandidate(sp, cand);
    cand.voice_id = vid; c.voice = vid; c.voiceData = getVoiceData(vid); o.picked = idx;
    if (typeof loadVoiceLibrary === 'function') await loadVoiceLibrary().catch(() => {});
    renderCastList(); if (typeof populateNarratorSelect === 'function') populateNarratorSelect();
    toast(`Switched ${sp} to ${cand.title || 'voice'}`, 'success');
  } catch (err) {
    btn.disabled = false; btn.innerHTML = orig;
    toast('Import failed: ' + err.message, 'error');
  }
}

const REH_NARRATOR_KEY = '\u{1F4D6}NARRATOR'; // unique sentinel kept out of real speaker names

function _ensureNarrator() {
  if (!rehState.cast[REH_NARRATOR_KEY]) {
    rehState.cast[REH_NARRATOR_KEY] = {
      voice: rehState.narratorVoice || '',
      color: '#6b7280',
      instruct: '',
      voiceData: rehState.narratorVoice ? getVoiceData(rehState.narratorVoice) : null,
      _isNarrator: true,
    };
  }
  // Bidirectional sync between the narrator cast row and the global narratorVoice.
  // The cast row is the source of truth (auto-design assigns the voice there), but
  // playback/synth read rehState.narratorVoice — keep them aligned both ways.
  const n = rehState.cast[REH_NARRATOR_KEY];
  if (n.voice) {
    rehState.narratorVoice = n.voice;
    if (!n.voiceData) n.voiceData = getVoiceData(n.voice);
  } else if (rehState.narratorVoice) {
    n.voice = rehState.narratorVoice;
    n.voiceData = getVoiceData(rehState.narratorVoice);
  }
}

const REH_CAST_LANGS = ['English', 'German', 'Auto', 'French', 'Spanish', 'Italian', 'Portuguese', 'Dutch', 'Polish'];
const REH_CAST_GENDERS = [['', '—'], ['F', '♀ Female'], ['M', '♂ Male'], ['N', '⚥ Diverse']];

// Apply a mutation to every dialog line spoken by a character
function _castApplyToLines(sp, fn) {
  rehState.lines.forEach((l, i) => { if (l.speaker === sp && l.type === 'dialog') fn(l, i); });
}

function _safeDomId(value) {
  let out = '';
  const s = String(value || 'voice');
  for (let i = 0; i < s.length; i++) out += s.charCodeAt(i).toString(36) + '-';
  return out || 'voice';
}

// Cross-referencing the Character Library gives the cast cards a real
// portrait, tier badge, and occupation/archetype instead of just a colored
// initial — pulled from whatever book/script this cast shares a title with.
// Fetched once per script title (not per render) and cached. Two separate
// renderers share this one cache — renderCastList (the "Who's playing which
// character?" mecast panel) and renderCastStrip (the Stage sidebar's own
// character list, see below) — but only ONE fetch is ever kicked off per
// script title, guarded by _rehLibCharsCacheBook. Whichever renderer's guard
// check happens to run first "claims" that fetch; the other one sees the
// book already marked as fetched and skips starting its own — so BOTH must
// be re-run once the shared fetch resolves, not just whichever one started
// it. Confirmed live as a real bug: entering Perform & Export borrows both
// panels at once, renderCastList's guard usually wins the race, and its own
// old single-target callback left the Stage sidebar stuck on plain
// colored-letter dots forever (never re-rendered with portraits) even
// though the cache had genuinely finished loading with images moments
// later — only calling renderCastStrip() by hand fixed it.
let _rehLibCharsCache = null;
let _rehLibCharsCacheBook = null;
function _rehEnsureLibCharsCache(scriptTitle) {
  if (!scriptTitle || _rehLibCharsCacheBook === scriptTitle || typeof clGetAllByTagOrBook !== 'function') return;
  _rehLibCharsCacheBook = scriptTitle;
  clGetAllByTagOrBook(scriptTitle).then(recs => {
    _rehLibCharsCache = recs || [];
    renderCastList();
    if (typeof renderCastStrip === 'function') renderCastStrip();
    // Stage's per-line portraits (_rehCharAvatarHtml) also read this cache
    // directly, not just the sidebar row — re-run the full script page too
    // so lines that rendered before the cache arrived pick up portraits.
    if (typeof buildScriptPage === 'function') buildScriptPage();
  }).catch(() => {});
}

function renderCastList() {
  const list = $('reh-cast-list'); if (!list) return;
  // Make sure the voice library is loaded so every picker (incl. the narrator) has
  // voices to choose from even when the Rehearser was opened directly.
  if (!(window._voices || []).length && typeof loadVoiceLibrary === 'function' && !rehState._castLibFetch) {
    rehState._castLibFetch = true;
    loadVoiceLibrary().then(() => renderCastList()).catch(() => {});
  }
  _ensureNarrator();
  const narr = REH_NARRATOR_KEY;
  const lineCount  = sp => rehState.lines.filter(l => l.speaker === sp && l.type === 'dialog').length;
  const allOthers  = Object.keys(rehState.cast).filter(s => s !== narr);
  const others     = _castSortFilter(allOthers, lineCount);   // narrator always stays pinned on top
  const speakers   = [narr, ...others];
  const scriptTitle = $('reh-script-title')?.value.trim() || '';

  _rehEnsureLibCharsCache(scriptTitle);
  const libRecByName = new Map((_rehLibCharsCache || []).map(r => [String(r.name || '').trim().toLowerCase(), r]));
  const emotionsFor = sp => {
    const seen = new Map();
    rehState.lines.forEach(l => {
      if (l.speaker === sp && l.type === 'dialog' && l.emotion && !seen.has(l.emotion)) {
        seen.set(l.emotion, getEmotionInfo(l.emotion));
      }
    });
    return [...seen.values()];
  };

  list.innerHTML = speakers.map(sp => {
    const c = rehState.cast[sp];
    const isNarr = sp === narr;
    const isMe   = c.voice === 'me';
    const label  = isNarr ? 'Narrator' : sp;
    const n = lineCount(sp);
    const sub = isNarr ? 'scene headings &amp; descriptions' : `${n} line${n!==1?'s':''}${scriptTitle ? ` · ${escHtml(scriptTitle)}` : ''}`;
    const cardCls = 'reh-cast-card' + (isNarr ? ' reh-cast-narrator' : '') + (c.ignored ? ' reh-cast-ignored' : '') + (c.hidden ? ' reh-cast-hidden-c' : '');
    const langSel = REH_CAST_LANGS.map(l => `<option${(c.lang||'')===l?' selected':''}>${l}</option>`).join('');
    const genSel  = REH_CAST_GENDERS.map(([v,t]) => `<option value="${v}"${(c.gender||'')===v?' selected':''}>${t}</option>`).join('');
    const pickerId = 'reh-voice-sel-' + _safeDomId(sp);
    const voiceSel = `<select id="${pickerId}" class="reh-voice-sel" data-speaker="${escHtml(sp)}"${isMe?' style="display:none"':''}>
        <option value="">— ${isNarr ? 'none (skip descriptions)' : 'assign a voice'} —</option>
        ${_rehAllVoiceIds(c.voice).map(v=>`<option value="${escHtml(v)}"${v===c.voice?' selected':''}>${escHtml(v)}</option>`).join('')}
      </select>`;

    const voiceName = !isMe && c.voice ? (getVoiceData(c.voice)?.name || c.voice) : (isMe ? 'Your mic' : '');

    // Library cross-reference — same book/script, matched by name. When a
    // real character record exists, the card IS the exact Library card
    // (_charCardHtml) — same colorful portrait/tier/occupation/alignment
    // design already used in Library → Cast, not a separate look-alike —
    // and voice assignment happens by clicking into the full profile (or
    // the bulk match tools above) rather than a dropdown on the card.
    // Narrator/unmatched speakers (no Library record to point at) keep the
    // simple fallback header with an inline voice dropdown, since there's
    // no profile page for them to assign a voice from.
    const libRec = !isNarr ? libRecByName.get(String(sp).trim().toLowerCase()) : null;
    if (libRec) {
      const libVoice = typeof libRec.voice === 'object' ? (libRec.voice?.id || '') : (libRec.voice || '');
      if (libVoice) c.voice = libVoice;
    }
    const emotions = isNarr ? [] : emotionsFor(sp);
    const emotionsHtml = emotions.length
      ? `<div class="reh-cc-emotions">${emotions.map(info => `<span class="reh-cc-emo-chip">${info.emoji} ${escHtml(info.label)}</span>`).join('')}</div>`
      : '';
    const controlsHtml = `<div class="reh-cc-controls">
        <label class="reh-cc-me-row" title="Record this character with your own mic instead of a TTS voice"><input type="checkbox" class="reh-me-check" data-speaker="${escHtml(sp)}" ${isMe?'checked':''}><span><span class="mdi mdi-microphone"></span> I play this</span></label>
        ${(!isMe && c.voice) ? `<button type="button" class="reh-cc-sample-btn" data-speaker="${escHtml(sp)}" title="Hear a sample line in this voice" aria-label="Hear a sample line in this voice"><span class="mdi mdi-play"></span> Hear a line</button>` : ''}
        <span class="reh-cc-actions-spacer"></span>
        <button class="reh-cc-iconbtn${c.ignored?' active':''}" data-act="ignore" title="Ignore — grey out &amp; skip this character’s lines" aria-label="Ignore this character’s lines"><span class="mdi mdi-eye-off-outline"></span></button>
        <button class="reh-cc-iconbtn${c.hidden?' active':''}" data-act="hide" title="Hide this character’s lines from the script" aria-label="Hide this character’s lines"><span class="mdi mdi-minus-circle-outline"></span></button>
        <button class="reh-cc-iconbtn reh-cc-del" data-act="delete" title="Delete this character &amp; all their lines" aria-label="Delete this character"><span class="mdi mdi-trash-can-outline"></span></button>
      </div>
      ${emotionsHtml}`;

    if (libRec) {
      return `<div class="${cardCls} reh-cast-card-libcard" data-speaker="${escHtml(sp)}" data-char-id="${escHtml(libRec.id)}" style="--cc-color:${c.color}">
        ${(typeof _charCardHtml === 'function') ? _charCardHtml(libRec, _rehLibCharsCache || []) : ''}
        <div class="reh-cc-body">${controlsHtml}</div>
      </div>`;
    }

    return `<div class="${cardCls}" data-speaker="${escHtml(sp)}" style="--cc-color:${c.color}">
      <div class="reh-cc-head">
        <div class="reh-cc-avatar">${castAvatarHtml(sp)}</div>
        <div class="reh-cc-titles">
          <div class="reh-cc-name" style="color:${c.color}">${isNarr ? '<span class="mdi mdi-book-open-page-variant"></span> ' : ''}${escHtml(label)}</div>
          <div class="reh-cc-sub">${sub}</div>
          <div class="reh-cc-voicechip${(!isMe && !c.voice) ? ' empty' : ''}"><span class="mdi mdi-${isMe ? 'microphone' : 'account-music-outline'}"></span> ${escHtml(voiceName || 'No voice assigned')}</div>
        </div>
      </div>
      <div class="reh-cc-body"${isMe?' style="display:none"':''}>
        <div class="reh-cc-field reh-cc-voice"><label>Voice</label>${voiceSel}</div>
        ${controlsHtml}
        <details class="reh-cc-more">
          <summary><span class="mdi mdi-tune-variant"></span> More options</summary>
          <div class="reh-cc-extra">
            ${!isNarr ? castOnlinePanelHtml(sp, c) : ''}
            ${!isNarr ? `<div class="reh-cc-grid">
              <div class="reh-cc-field"><label>Language</label><select class="reh-cc-lang">${langSel}</select></div>
              <div class="reh-cc-field"><label>Gender</label><select class="reh-cc-gender">${genSel}</select></div>
              <div class="reh-cc-field"><label>Tags</label><input type="text" class="reh-cc-tags" value="${escHtml(c.tags||'')}" placeholder="e.g. villain, raspy"></div>
            </div>` : ''}
            <div class="reh-cc-field"><label>Speaking style · voice-design prompt</label>
              <input type="text" class="reh-cast-instruct" value="${escHtml(c.instruct||'')}" placeholder="${isNarr ? 'Narrator style: calm, measured, cinematic storyteller…' : 'British accent, commanding baritone, quietly menacing…'}"></div>
            ${!isNarr ? `<details class="reh-cc-soul"${c.soul?' open':''}>
              <summary><span class="mdi mdi-script-text-outline"></span> Character soul · LLM brief
                <button class="btn-secondary btn-sm reh-cc-develop" type="button" title="Let the LLM read the script &amp; flesh out this character"><span class="mdi mdi-auto-fix"></span> Develop</button>
              </summary>
              <textarea class="reh-cc-soul-text" placeholder="Backstory, motivation, vocal manner… (used as the LLM brief when designing this voice)">${escHtml(c.soul||'')}</textarea>
            </details>` : ''}
          </div>
        </details>
      </div>
    </div>`;
  }).join('');

  // Cast count (reflects active filter) + keep the chosen view (card / list)
  const countEl = $('reh-cast-count');
  if (countEl) {
    const shown = others.length, total = allOthers.length;
    countEl.textContent = shown === total
      ? `${total} ${total === 1 ? 'character' : 'characters'} + narrator`
      : `${shown} of ${total} characters`;
  }
  // Wire the reused Library cards (portrait upload, export, click → full
  // profile) exactly like the Library grid does — the profile page opens
  // in place of this list and "back" re-renders the cast list, same pattern
  // used for the post-recast results grid on the Read Aloud page.
  if (typeof _wireCharCards === 'function' && (_rehLibCharsCache || []).length) {
    const recsById = new Map(_rehLibCharsCache.map(r => [r.id, r]));
    _wireCharCards(list, recsById, _rehLibCharsCache, renderCastList, { container: list, onBack: renderCastList });
  }
  _wireCastControls();
  applyCastView();

  // ── Wiring ────────────────────────────────────────────────────────────────
  const card = el => el.closest('.reh-cast-card');
  const spOf = el => card(el).dataset.speaker;

  if (window.VoicePicker) {
    list.querySelectorAll('.reh-voice-sel[id]').forEach(sel => {
      const cur = sel.value;
      VoicePicker.upgrade(sel.id);
      if (cur) VoicePicker.setValue(sel.id, cur);
    });
  }

  list.querySelectorAll('.reh-me-check').forEach(cb => cb.addEventListener('change', function () {
    const sp = spOf(this);
    rehState.cast[sp].voice = this.checked ? 'me' : (card(this).querySelector('.reh-voice-sel')?.value || '');
    rehState.cast[sp].voiceData = this.checked ? null : getVoiceData(rehState.cast[sp].voice);
    renderCastList();
  }));
  list.querySelectorAll('.reh-voice-sel').forEach(sel => sel.addEventListener('change', function () {
    const sp = this.dataset.speaker;
    rehState.cast[sp].voice = this.value;
    rehState.cast[sp].voiceData = getVoiceData(this.value);
    delete rehState.cast[sp].online; // manual override → drop the online-match picker context
    if (sp === REH_NARRATOR_KEY) rehState.narratorVoice = this.value;
    renderCastList();
  }));
  list.querySelectorAll('.reh-cast-instruct').forEach(inp => inp.addEventListener('input', function () {
    rehState.cast[spOf(this)].instruct = this.value;
  }));
  list.querySelectorAll('.reh-cc-lang').forEach(s => s.addEventListener('change', function () { rehState.cast[spOf(this)].lang = this.value; }));
  list.querySelectorAll('.reh-cc-gender').forEach(s => s.addEventListener('change', function () { rehState.cast[spOf(this)].gender = this.value; }));
  list.querySelectorAll('.reh-cc-tags').forEach(i => i.addEventListener('input', function () { rehState.cast[spOf(this)].tags = this.value; }));
  list.querySelectorAll('.reh-cc-soul-text').forEach(t => t.addEventListener('input', function () { rehState.cast[spOf(this)].soul = this.value; }));
  list.querySelectorAll('.reh-cc-develop').forEach(b => b.addEventListener('click', function (e) { e.preventDefault(); _castDevelop(spOf(this), this); }));
  list.querySelectorAll('.reh-cc-iconbtn').forEach(b => b.addEventListener('click', function () {
    const sp = spOf(this), act = this.dataset.act, c = rehState.cast[sp];
    if (act === 'ignore') { c.ignored = !c.ignored; _castApplyToLines(sp, l => l.ignored = c.ignored); renderCastList(); }
    else if (act === 'hide') { c.hidden = !c.hidden; _castApplyToLines(sp, l => l.hidden = c.hidden); renderCastList(); }
    else if (act === 'delete') { _castDeleteCharacter(sp); }
  }));

  // Online voice picker — delegated so dynamically-injected result rows work too.
  // `list` persists across re-renders, so attach these handlers only once.
  if (!list._voDelegated) {
   list._voDelegated = true;
   list.addEventListener('click', e => {
    const sampleBtn = e.target.closest('.reh-cc-sample-btn');
    if (sampleBtn) { e.preventDefault(); _rehPreviewCastLine(sampleBtn.dataset.speaker, sampleBtn); return; }

    const playBtn = e.target.closest('.reh-vo-play');
    if (playBtn) { e.preventDefault(); if (playBtn.dataset.voice) _rehPreviewLocal(playBtn.dataset.voice, playBtn); else _rehAudition(playBtn.dataset.url, playBtn); return; }

    const toggle = e.target.closest('.reh-vo-toggle');
    if (toggle) {
      e.preventDefault();
      const alts = toggle.closest('.reh-cc-online')?.querySelector('.reh-vo-alts');
      if (alts) { alts.hidden = !alts.hidden; toggle.textContent = toggle.textContent.replace(/[▾▴]\s*$/, '') + (alts.hidden ? '▾' : '▴'); }
      return;
    }

    const tool = e.target.closest('.reh-vo-tool');
    if (tool) {
      e.preventDefault();
      const panel = tool.closest('.reh-cc-online');
      const want = tool.dataset.tool;
      const localP = panel.querySelector('.reh-vo-local-panel');
      const searchP = panel.querySelector('.reh-vo-search-panel');
      const showLocal = want === 'local' && (localP?.hidden ?? true);
      const showSearch = want === 'search' && (searchP?.hidden ?? true);
      if (localP) localP.hidden = !showLocal;
      if (searchP) searchP.hidden = !showSearch;
      panel.querySelectorAll('.reh-vo-tool').forEach(t => t.classList.toggle('active', (t.dataset.tool === 'local' && showLocal) || (t.dataset.tool === 'search' && showSearch)));
      if (showLocal) { const card = e.target.closest('.reh-cast-card'); _rehRenderLocalResults(card, spOf(tool), ''); card.querySelector('.reh-vo-local-input')?.focus(); }
      if (showSearch) panel.querySelector('.reh-vo-search-input')?.focus();
      return;
    }

    const goBtn = e.target.closest('.reh-vo-search-go');
    if (goBtn) { e.preventDefault(); const card = e.target.closest('.reh-cast-card'); _rehSearchOnline(card, spOf(goBtn), card.querySelector('.reh-vo-search-input')?.value); return; }

    const use = e.target.closest('.reh-vo-use');
    if (use) {
      e.preventDefault();
      const sp = spOf(use), act = use.dataset.act;
      if (act === 'local') _rehAssignLocal(sp, use.dataset.voice);
      else if (act === 'search') _rehUseSearchResult(sp, parseInt(use.dataset.idx, 10), use);
      else _rehUseCandidate(sp, parseInt(use.dataset.idx, 10), use); // 'alt'
    }
  });
  list.addEventListener('input', e => {
    const li = e.target.closest('.reh-vo-local-input');
    if (li) _rehRenderLocalResults(e.target.closest('.reh-cast-card'), spOf(li), li.value);
  });
  list.addEventListener('keydown', e => {
    const si = e.target.closest('.reh-vo-search-input');
    if (si && e.key === 'Enter') { e.preventDefault(); _rehSearchOnline(e.target.closest('.reh-cast-card'), spOf(si), si.value); }
   });
  }
}

// Cast card / list view toggle
function applyCastView() {
  const list = $('reh-cast-list'); if (!list) return;
  const view = rehState.castView === 'list' ? 'list' : 'card';
  list.classList.toggle('reh-cast-view-card', view === 'card');
  list.classList.toggle('reh-cast-view-list', view === 'list');
  document.querySelectorAll('#reh-cast-view-toggle .reh-view-btn').forEach(b => b.classList.toggle('active', b.dataset.view === view));
}
try { rehState.castView = localStorage.getItem('reh-cast-view') || 'card'; } catch (_) { rehState.castView = 'card'; }

// Cast sort + filter state (narrator excluded — it's pinned on top by renderCastList)
rehState.castFilter = { search: '', gender: '', lang: '' };
try { rehState.castSort = JSON.parse(localStorage.getItem('reh-cast-sort')) || { by: 'name', dir: 'asc' }; }
catch (_) { rehState.castSort = { by: 'name', dir: 'asc' }; }

// Wire the cast toolbar (view toggle + sort/filter). Called from renderCastList so it
// always binds once the section is mounted; guarded to attach only once.
function _wireCastControls() {
  const toggle = $('reh-cast-view-toggle');
  if (!toggle || toggle._wired) return;
  toggle._wired = true;
  toggle.querySelectorAll('.reh-view-btn').forEach(b => b.addEventListener('click', () => {
    rehState.castView = b.dataset.view;
    try { localStorage.setItem('reh-cast-view', b.dataset.view); } catch (_) {}
    applyCastView();
  }));
  const search = $('reh-cast-search'), fg = $('reh-cast-filter-gender'), fl = $('reh-cast-filter-lang');
  const sortSel = $('reh-cast-sort'), dirBtn = $('reh-cast-sort-dir');
  const setDirIcon = () => { if (dirBtn) { dirBtn.dataset.dir = rehState.castSort.dir; dirBtn.querySelector('.mdi').className = 'mdi mdi-sort-' + (rehState.castSort.dir === 'desc' ? 'descending' : 'ascending'); } };
  const persist = () => { try { localStorage.setItem('reh-cast-sort', JSON.stringify(rehState.castSort)); } catch (_) {} };
  if (sortSel) sortSel.value = rehState.castSort.by;
  setDirIcon();
  search?.addEventListener('input', () => { rehState.castFilter.search = search.value.trim(); renderCastList(); search.focus(); });
  fg?.addEventListener('change', () => { rehState.castFilter.gender = fg.value; renderCastList(); });
  fl?.addEventListener('change', () => { rehState.castFilter.lang = fl.value; renderCastList(); });
  sortSel?.addEventListener('change', () => {
    rehState.castSort.by = sortSel.value;
    rehState.castSort.dir = sortSel.value === 'lines' ? 'desc' : 'asc';   // lines → most first
    setDirIcon(); persist(); renderCastList();
  });
  dirBtn?.addEventListener('click', () => {
    rehState.castSort.dir = rehState.castSort.dir === 'desc' ? 'asc' : 'desc';
    setDirIcon(); persist(); renderCastList();
  });
}

function _castSortFilter(speakers, lineCount) {
  const f = rehState.castFilter || {}, s = rehState.castSort || { by: 'name', dir: 'asc' };
  const out = speakers.filter(sp => {
    const c = rehState.cast[sp] || {};
    if (f.search) { const q = f.search.toLowerCase(); if (!sp.toLowerCase().includes(q) && !(c.tags || '').toLowerCase().includes(q)) return false; }
    if (f.gender && (c.gender || '') !== f.gender) return false;
    if (f.lang && (c.lang || '') !== f.lang) return false;
    return true;
  });
  const byName = (a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' });
  const cmp = {
    name:   byName,
    gender: (a, b) => (rehState.cast[a].gender || '~').localeCompare(rehState.cast[b].gender || '~') || byName(a, b),
    lang:   (a, b) => (rehState.cast[a].lang || '~').localeCompare(rehState.cast[b].lang || '~') || byName(a, b),
    lines:  (a, b) => (lineCount(a) - lineCount(b)) || byName(a, b),
    tag:    (a, b) => (rehState.cast[a].tags || '~').localeCompare(rehState.cast[b].tags || '~') || byName(a, b),
  }[s.by] || byName;
  out.sort(cmp);
  if (s.dir === 'desc') out.reverse();
  return out;
}

// Remove a character and all of their dialog lines (with index-state remap)
function _castDeleteCharacter(sp) {
  const n = rehState.lines.filter(l => l.speaker === sp && l.type === 'dialog').length;
  if (!confirm(`Delete “${sp}” and their ${n} line${n!==1?'s':''}? This cannot be undone.`)) return;
  for (let i = rehState.lines.length - 1; i >= 0; i--) {
    if (rehState.lines[i].speaker === sp && rehState.lines[i].type === 'dialog') {
      rehState.lines.splice(i, 1);
      _reindexLineState(i);
    }
  }
  delete rehState.cast[sp];
  renderCastList();
  if (rehState.lines.length) buildScriptPage();
  toast(`Removed ${sp}`, 'success');
}

// Ask the LLM to flesh out one character → fills the soul brief + design prompt
async function _castDevelop(sp, btn) {
  const script = $('reh-script-text')?.value.trim() || linesToScriptText();
  if (!script) { toast('Load a script first', 'error'); return; }
  const c = rehState.cast[sp];
  const orig = btn.innerHTML;
  btn.disabled = true; btn.innerHTML = '<span class="reh-imsdb-spinner"></span> Developing…';
  try {
    const r = await fetch('/api/analyze-characters', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        script, names: [sp],
        llm_url: $('reh-llm-url')?.value.trim() || rehDefaultLlmUrl(),
        model: $('reh-llm-model')?.value || '',
        language: c.lang || $('reh-design-lang')?.value || 'English',
      }),
    });
    if (!r.ok) { const e = await r.json().catch(()=>({})); throw new Error(e.detail || r.statusText); }
    const info = (await r.json()).characters?.[0] || {};
    if (info.gender) c.gender = String(info.gender).toUpperCase().charAt(0).replace(/[^MFN]/, 'N');
    if (info.description) { c.soul = info.description; c.instruct = c.instruct || info.description; }
    renderCastList();
    toast(`Developed ${sp}`, 'success');
  } catch (e) {
    btn.disabled = false; btn.innerHTML = orig;
    toast('Develop failed: ' + e.message, 'error');
  }
}

async function refreshRehBackends() {
  rehInitLlmField();
  const sel = $('reh-backend-select'); if (!sel) return;
  let backends = typeof availableTtsBackends === 'function' ? availableTtsBackends() : [];
  // If the global list hasn't been probed yet, trigger the probe now
  if (!backends.length && typeof refreshTtsBackendAvailability === 'function') {
    await refreshTtsBackendAvailability().catch(() => {});
    backends = typeof availableTtsBackends === 'function' ? availableTtsBackends() : [];
  }
  // Last resort: show all known backends (even unavailable ones) so the user can try
  if (!backends.length && typeof _ttsBackends !== 'undefined' && Array.isArray(_ttsBackends)) {
    backends = _ttsBackends;
  }
  const prev = sel.value || rehState.backend;
  sel.innerHTML = backends.length
    ? backends.map(b => `<option value="${escHtml(b.id)}">${escHtml(b.label)}</option>`).join('')
    : '<option value="">No backend available</option>';
  if (prev && [...sel.options].some(o => o.value === prev)) {
    // Restore a previously chosen backend
    sel.value = prev;
  } else {
    // Default backend preference. fishspeech is best — it clones each voice's saved WAV
    // (consistent identity) AND honours per-line emotion markers (tone), so a character
    // sounds the same across the rehearsal while still reacting to tone. voice_clone is the
    // fallback for consistency (weak tone); voice_design gives tone but drifts each line.
    const preferred = ['fishspeech', 'voice_clone', 'customvoice', 'voice_design'];
    const pick = preferred.find(id => [...sel.options].some(o => o.value === id));
    if (pick) sel.value = pick;
  }
  rehState.backend = sel.value || '';   // keep state in sync with the (possibly auto-picked) value
  _checkToneStyleSupport();
}

// Keep the rehearser select in sync whenever the global backend list refreshes
(window._ttsRefreshHooks = window._ttsRefreshHooks || []).push(() => {
  const sel = $('reh-backend-select'); if (!sel) return;
  const backends = typeof availableTtsBackends === 'function' ? availableTtsBackends() : [];
  if (!backends.length) return;
  const prev = sel.value || rehState.backend;
  sel.innerHTML = backends.map(b => `<option value="${escHtml(b.id)}">${escHtml(b.label)}</option>`).join('');
  if (prev && [...sel.options].some(o => o.value === prev)) sel.value = prev;
  else if (sel.options.length) sel.value = sel.options[0].value;
  rehState.backend = sel.value || '';
});

// All voice IDs offered in the cast/narrator pickers — backend voices PLUS everything
// in the library, so any saved/cloned/imported voice (incl. for the narrator) is pickable.
function _rehAllVoiceIds(include) {
  const ids = new Set((rehState.voices || []).filter(id => _rehVoiceVisibleId(id, include)));
  (window._voices || []).forEach(v => { if (v && v.id && (v.enabled !== false || v.id === include)) ids.add(v.id); });
  if (include) ids.add(include);
  return [...ids].sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
}

function populateNarratorSelect() {
  const sel = $('reh-narrator-voice'); if (!sel) return;
  const cur = rehState.narratorVoice || sel.value;
  sel.innerHTML = '<option value="">— none (skip or pause) —</option>' +
    _rehAllVoiceIds(cur).map(v => `<option value="${escHtml(v)}"${v===cur?' selected':''}>${escHtml(v)}</option>`).join('');
}

$('reh-fetch-voices-btn')?.addEventListener('click', async () => {
  const backend = $('reh-backend-select')?.value;
  if (!backend) { toast('Select a backend first', 'error'); return; }
  $('reh-fetch-voices-btn').disabled = true;
  try {
    if ((!window._voices || !window._voices.length) && typeof loadVoiceLibrary === 'function') {
      await loadVoiceLibrary().catch(() => {});
    }
    const raw = await fetch('/api/tts-voices?backend=' + encodeURIComponent(backend)).then(r => r.json());
    rehState.voices = (Array.isArray(raw) ? raw.map(v => typeof v === 'string' ? v : (v.id || String(v))) : [])
      .filter(id => _rehVoiceVisibleId(id));
    renderCastList();
    populateNarratorSelect();
    toast('Fetched ' + rehState.voices.length + ' voices', 'success');
  } catch(e) { toast('Fetch failed: ' + e.message, 'error'); }
  finally { $('reh-fetch-voices-btn').disabled = false; }
});

$('reh-narrator-voice')?.addEventListener('change', function () { rehState.narratorVoice = this.value; });
$('reh-back-1-btn')?.addEventListener('click', () => showPhase(1));

// ── TTS instruct builder — emotion goes first as a directive ─────────────────
// voice_clone backends treat instruct as an IDENTITY description; putting the
// emotion first and using directive language ("Speak in a … manner") makes the
// model prioritise it over the static voice description, which otherwise wins.
// Casting tags emotions in the BOOK's own language (this app runs heavily
// with German books, so `emotion` here is usually a German word like
// "fordernd" or "entschlossen") — but the instruct sentence wrapping it was
// always hardcoded English ("Speak in a fordernd manner."), dropping a
// German adjective into an English carrier sentence. Confirmed as the
// likely reason emotion barely registered for designed voices even though
// isolated English-only test instructs ("speak in an extremely angry
// manner") clearly changed the output — a mixed-language instruct is a much
// weaker signal than a natural sentence in one language. `voiceId`'s own
// language-code prefix (DE_/EN_/...) picks the matching template.
const _BUILD_INSTRUCT_TEMPLATES = {
  DE: e => `Sprich in einem ${e} Tonfall.`,
  EN: e => `Speak in a ${e} manner.`,
};
// Same wording _buildVoicePrompt uses for the one-time design call — that
// clause was NEVER being resent on ongoing lines: the per-line instruct
// only ever carried the character's saved voice_design_prompt (a plain
// voice-quality description with no accent guidance in it at all), because
// the accent clause was built fresh at design time and never written back
// into that saved profile. Since each synthesis call is stateless — the
// engine has no memory of the original design call — omitting it here meant
// every ONGOING line got zero accent reinforcement, only the one-off
// creation call ever did. Confirmed as a real, separate cause of designed
// voices drifting back toward an American accent during actual narration.
const _BUILD_INSTRUCT_LANG_NAMES = { DE: 'German', FR: 'French', ES: 'Spanish', IT: 'Italian', PT: 'Portuguese', NL: 'Dutch', PL: 'Polish' };
function _buildAccentClause(langCode) {
  const langName = _BUILD_INSTRUCT_LANG_NAMES[langCode];
  if (langName) return `Speak with an authentic native ${langName} accent — not American-accented, not an English speaker doing ${langName}.`;
  if (langCode === 'EN') return 'English with a neutral British or international accent, explicitly not American/US-accented.';
  return '';
}
function _buildInstruct(voiceProfile, emotion, voiceId) {
  const p = (voiceProfile || '').trim();
  const e = (emotion     || '').trim();
  const langCode = String(voiceId || '').split('_')[0].toUpperCase();
  const accent = _buildAccentClause(langCode);
  if (!e && !p && !accent) return '';
  // The emotion clause is now ALWAYS built in English, regardless of the voice's
  // own language — confirmed via controlled A/B testing (same line, same voice,
  // varying only instruct language) that Qwen3-TTS's emotional differentiation is
  // dramatically stronger in English than German: sad/angry/shocked/happy formed a
  // clean, coherent pitch gradient (274Hz -> 398Hz) in English, but stayed muddled
  // together in German even with the exact same wording translated. The spoken
  // TEXT and the accent clause below stay fully native-language — only the
  // emotion instruction itself changes language. The raw per-line emotion is
  // LLM-generated in the book's own language (see the casting prompt's "1-2
  // deutsche Wörter"), so translate it before building the clause.
  const emotionEn = e && langCode !== 'EN' && typeof _rehEmotionEnglishTag === 'function' ? _rehEmotionEnglishTag(e) : '';
  const effectiveEmotion = emotionEn || e;
  const emotionTmpl = _BUILD_INSTRUCT_TEMPLATES.EN;
  // Emotion leads, accent trails — Qwen3-TTS's own prompting guidance warns
  // it "does not follow instructions correctly when dealing with
  // conflicting attributes... favoring one over the other." Putting the
  // accent clause first (as the previous version did) made it the most
  // prominent instruction on every single line, which lines up with the
  // reported regression right after that fix landed: mood stopped coming
  // through. Emotion is the one thing that MUST vary per line; accent is a
  // constant reminder the voice's own identity should mostly already carry,
  // so it goes last, not first.
  // ...and when an emotion IS present, the accent clause is dropped entirely rather
  // than merely demoted. Measured on the deterministic voice_clone backend (identical
  // input reproduces bit-identical audio, so these differences are real, not sampling
  // noise): with an emotion-only instruct the tones separate cleanly and in the right
  // order — whisper 206Hz, sad 170Hz, neutral 225Hz, happy 234Hz, angry 233Hz, scared
  // 239Hz, with sad also slower and quieter. Appending "Speak with an authentic native
  // German accent." to those same instructs collapsed the whole range to 222-250Hz and
  // erased sad almost completely. Two style directives in one instruct compete, and the
  // trailing one wins — which is exactly the failure Qwen3-TTS's own prompting guidance
  // warns about for conflicting attributes. A cloned voice already carries its accent
  // from the reference WAV, so accent reinforcement is the cheaper of the two to lose;
  // lines with no emotion still get it.
  const parts = e
    ? [emotionTmpl(effectiveEmotion), p].filter(Boolean)
    : [p, accent].filter(Boolean);
  return parts.join(' ');
}

// Fish-Speech / OpenAudio S2 reads inline [tag] emotion markers straight from the
// input text (the OpenAI-style `instruct` field is ignored). For fish backends we
// therefore prepend the tone as a [tag] so per-line tones actually take effect.
function _rehBackendIsFish() {
  let id = '';
  try { id = (typeof backendById === 'function' && backendById(rehState.backend)?.id) || rehState.backend || ''; }
  catch (_) { id = rehState.backend || ''; }
  return /fish/i.test(id);
}
// Fish-Speech's docs are explicit: "Use English emotion tags in square brackets
// regardless of the spoken language." Per-line auto emotions are LLM-generated in the
// book's own language (the casting prompt literally asks for "1-2 deutsche Wörter"),
// which is what _buildInstruct's native-language sentence needs for Qwen3-TTS — but
// that same raw word is useless as a Fish [tag] untranslated. Confirmed live: German
// tags were silently ignored, producing flat/emotionless Fish-Speech output even
// though the audio itself was fine. This table only needs to cover common tone/mood
// adjectives, not a full dictionary — unrecognized words fall through to no tag at
// all (line 8 below), which is a NOP for Fish, safer than sending a foreign-language
// word it will just ignore anyway.
const _REH_EMOTION_DE_EN = {
  'wütend':'angry','zornig':'angry','erzürnt':'angry','verärgert':'annoyed','gereizt':'irritated',
  'traurig':'sad','melancholisch':'melancholic','betrübt':'sad','niedergeschlagen':'dejected',
  'ängstlich':'scared','furchtsam':'fearful','verängstigt':'frightened','panisch':'panicked','nervös':'nervous',
  'fröhlich':'happy','glücklich':'happy','freudig':'joyful','heiter':'cheerful','vergnügt':'delighted',
  'flüsternd':'whispering','leise':'quiet','gedämpft':'hushed',
  'aufgeregt':'excited','begeistert':'enthusiastic','euphorisch':'euphoric',
  'überrascht':'surprised','erstaunt':'astonished','verblüfft':'amazed',
  'genervt':'annoyed','frustriert':'frustrated',
  'verzweifelt':'desperate','hoffnungslos':'hopeless','resigniert':'resigned',
  'entschlossen':'determined','entschieden':'decisive',
  'selbstbewusst':'confident','stolz':'proud','arrogant':'arrogant',
  'schüchtern':'shy','verlegen':'embarrassed','unsicher':'uncertain',
  'ironisch':'sarcastic','sarkastisch':'sarcastic','spöttisch':'mocking','höhnisch':'scornful','verächtlich':'contemptuous',
  'ernst':'serious','streng':'stern','autoritär':'authoritative','befehlend':'commanding',
  'sanft':'gentle','zärtlich':'tender','liebevoll':'loving','warm':'warm',
  'kalt':'cold','distanziert':'distant','gleichgültig':'indifferent','gelangweilt':'bored',
  'geheimnisvoll':'mysterious','unheimlich':'eerie','düster':'ominous','bedrohlich':'threatening',
  'dramatisch':'dramatic','theatralisch':'theatrical','pathetisch':'melodramatic',
  'ruhig':'calm','gelassen':'composed','besonnen':'measured',
  'schockiert':'shocked','entsetzt':'horrified','fassungslos':'stunned',
  'zögernd':'hesitant','verwirrt':'confused','ratlos':'bewildered','unschlüssig':'undecided',
  'weinend':'tearful','schluchzend':'sobbing','trauernd':'grieving','gebrochen':'broken',
  'schroff':'curt','barsch':'gruff','grob':'rough','abweisend':'dismissive',
  'freundlich':'friendly','herzlich':'warm','einladend':'welcoming',
  'spielerisch':'playful','neckend':'teasing','frech':'cheeky','schelmisch':'mischievous',
  'romantisch':'romantic','sehnsüchtig':'longing','verliebt':'infatuated',
  'triumphierend':'triumphant','siegessicher':'victorious',
  'erleichtert':'relieved','beruhigt':'reassured',
  'schuldbewusst':'guilty','reumütig':'remorseful',
  'neugierig':'curious','interessiert':'interested',
  'müde':'weary','erschöpft':'exhausted',
  'wehmütig':'wistful','nostalgisch':'nostalgic',
  'bemerkend':'remarking','feststellend':'noting','sachlich':'matter-of-fact','nüchtern':'plain',
  'flehend':'pleading','bittend':'imploring',
  'warnend':'warning','mahnend':'admonishing',
  'trotzig':'defiant','rebellisch':'rebellious',
  'erschrocken':'startled','verstört':'disturbed',
};
function _rehEmotionEnglishTag(emotion) {
  const raw = (emotion || '').trim();
  if (!raw) return '';
  // Preset emotions (REH_EMOTIONS / custom) are already English descriptive phrases —
  // the first, most tag-like word is what Fish actually needs.
  const firstWord = raw.split(/[,;]\s*/)[0].trim();
  const lower = firstWord.toLowerCase();
  // Check the DE→EN table BEFORE assuming "looks ASCII" means "is English" — most
  // German emotion adjectives (e.g. "bedrohlich") are pure a-z too, so charset alone
  // can't distinguish them from English; the dict must win first.
  if (_REH_EMOTION_DE_EN[lower]) return _REH_EMOTION_DE_EN[lower];
  // Try stripping a common German adjective ending (declined forms LLMs sometimes
  // produce, e.g. "ängstliche" instead of "ängstlich") and match on the stem.
  const stem = lower.replace(/(e|er|es|en|em)$/, '');
  if (stem.length >= 4) {
    for (const key in _REH_EMOTION_DE_EN) {
      if (key.startsWith(stem)) return _REH_EMOTION_DE_EN[key];
    }
  }
  if (/^[a-z\- ]+$/.test(lower)) return lower; // not in the table, but looks English (e.g. REH_EMOTIONS presets)
  return ''; // no reliable English tag — omit rather than send a word Fish will ignore
}
function _rehInlineTone(text, emotion) {
  if (!_rehBackendIsFish()) return text;
  if (/^\s*\[/.test(text)) return text;          // already carries an inline [tag]
  const tag = _rehEmotionEnglishTag(emotion);
  return tag ? `[${tag}] ${text}` : text;
}

// ── Auto-design voices with LLM + Design a Voice ────────────────────────────

const REH_LANG_CODE = { English:'EN', German:'DE', French:'FR', Spanish:'ES', Italian:'IT', Auto:'EN' };

function rehDefaultLlmUrl() {
  try {
    if (typeof _appSettings !== 'undefined' && _appSettings && _appSettings.llm_url)
      return _appSettings.llm_url;
  } catch(_) {}
  return 'http://localhost:11434/v1';
}

// Collect all LLM endpoints visible in the Language Models section
function rehCollectLlmEndpoints() {
  const seen = new Set();
  const results = [];
  const add = (url, label) => {
    if (!url) return;
    url = url.trim();
    if (!url || seen.has(url)) return;
    seen.add(url);
    results.push({ url, label: label || url });
  };
  // 1. Active LLM from settings
  add(rehDefaultLlmUrl(), 'Active LLM');
  // 2. All URL inputs in the Language Models section (llm-local-url-inp)
  document.querySelectorAll('.llm-local-url-inp, [data-llm-local-key]').forEach(inp => {
    const v = inp.value?.trim();
    const def = inp.dataset.llmLocalDefault;
    const key = inp.dataset.llmLocalKey || inp.dataset.dcUrlKey || '';
    const card = inp.closest('[class*="llm-local-card"], [class*="llm-local"]');
    const name = card?.querySelector('.llm-local-name')?.textContent?.trim() || key;
    add(v || def, name);
  });
  // 3. The dc-url-inp fields with LLM role
  document.querySelectorAll('.dc-url-inp').forEach(inp => {
    const card = inp.closest('[class*="llm-local-card"]');
    if (!card) return;
    const name = card.querySelector('.llm-local-name')?.textContent?.trim() || '';
    add(inp.value?.trim() || inp.dataset.dcDefault, name);
  });
  // 4. Always include common defaults as suggestions
  const DEFAULTS = [
    ['http://localhost:11434/v1', 'Ollama'],
    ['http://localhost:8000/v1',  'vLLM'],
    ['http://localhost:1234/v1',  'LM Studio'],
    ['http://localhost:28080/v1', 'llama-swap'],
    ['http://localhost:14000/v1', 'LiteLLM'],
  ];
  DEFAULTS.forEach(([u, l]) => add(u, l));
  return results;
}

// Prefill LLM URL + datalist when Phase 2 first shows voices
function rehInitLlmField() {
  const u = $('reh-llm-url');
  if (!u) return;
  if (!u.value) u.value = rehDefaultLlmUrl();
  // Populate datalist with all known LLM endpoints
  const dl = $('reh-llm-url-list');
  if (dl) {
    dl.innerHTML = rehCollectLlmEndpoints()
      .map(e => `<option value="${e.url.replace(/"/g, '&quot;')}">${e.label}</option>`)
      .join('');
  }
}

$('reh-llm-refresh')?.addEventListener('click', async () => {
  const url = $('reh-llm-url')?.value.trim() || rehDefaultLlmUrl();
  const sel = $('reh-llm-model'); if (!sel) return;
  sel.innerHTML = '<option value="">Loading…</option>';
  try {
    const r = await fetch('/api/conversation/llm-models?url=' + encodeURIComponent(url));
    const d = await r.json();
    const models = d.models || [];
    sel.innerHTML = '<option value="">— default —</option>' +
      models.map(m => `<option value="${escHtml(m)}">${escHtml(m)}</option>`).join('');
    // Default to the global Active LLM model when available (still overridable here)
    const want = (typeof _appSettings !== 'undefined' && _appSettings) ? _appSettings.llm_model : '';
    if (want && models.includes(want)) sel.value = want;
    toast(models.length ? `Found ${models.length} models` : 'No models found', models.length ? 'success' : 'error');
  } catch(e) {
    sel.innerHTML = '<option value="">— default —</option>';
    toast('Could not list models: ' + e.message, 'error');
  }
});

// Avatar icon keys for designed voices — male / female / neutral / robot / animal.
// Picked from the LLM description (robot/animal cues) then gender.
const REH_AVATAR_ICONS = {
  male:    'mdi-face-man',
  female:  'mdi-face-woman',
  neutral: 'mdi-account',
  robot:   'mdi-robot-outline',
  animal:  'mdi-paw',
};
function _pickVoiceAvatar(gender, desc, speaker) {
  const d = ((desc || '') + ' ' + (speaker || '')).toLowerCase();
  if (/\b(robot|android|synthetic|artificial|computer|machine|cyborg|a\.?i\.?|operating system|\bos\b|digital|hologram|drone)\b/.test(d)) return 'robot';
  if (/\b(animal|creature|beast|dragon|monster|cat|dog|wolf|lion|bird|horse|dino|dinosaur|alien)\b/.test(d)) return 'animal';
  if (gender === 'M') return 'male';
  if (gender === 'F') return 'female';
  return 'neutral';
}

let rehDesignCancelled = false;

$('reh-autodesign-cancel')?.addEventListener('click', () => { rehDesignCancelled = true; });

$('reh-autodesign-btn')?.addEventListener('click', async () => {
  const backend = $('reh-backend-select')?.value;
  if (!backend) { toast('Select a TTS backend first', 'error'); return; }

  const speakers = Object.keys(rehState.cast);
  if (!speakers.length) { toast('No characters to design for', 'error'); return; }

  const script  = $('reh-script-text')?.value.trim() || linesToScriptText();
  const llmUrl  = $('reh-llm-url')?.value.trim() || rehDefaultLlmUrl();
  const llmModel= $('reh-llm-model')?.value || '';
  const language= $('reh-design-lang')?.value || 'English';
  const langCode= REH_LANG_CODE[language] || 'EN';
  const scriptTitle = $('reh-script-title')?.value.trim() || 'Script';
  const tag = (typeof _umlautSafe === 'function' ? _umlautSafe(scriptTitle) : scriptTitle).replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 24) || 'Script';

  const btn = $('reh-autodesign-btn');
  const prog = $('reh-autodesign-progress');
  const fill = $('reh-autodesign-fill');
  const label= $('reh-autodesign-label');
  btn.disabled = true;
  rehDesignCancelled = false;
  if (prog) prog.hidden = false;
  const setProg = (d, t, msg) => {
    if (fill)  fill.style.width = (t ? (d/t)*100 : 0) + '%';
    if (label) label.textContent = msg || `${d} / ${t}`;
  };
  setProg(0, speakers.length, 'Analyzing script with LLM…');

  // 1) Ask the LLM to describe each character
  let characters;
  try {
    const r = await fetch('/api/analyze-characters', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ script, names: speakers, llm_url: llmUrl, model: llmModel, language }),
    });
    if (!r.ok) { const e = await r.json().catch(()=>({})); throw new Error(e.detail || r.statusText); }
    const d = await r.json();
    characters = d.characters || [];
  } catch(e) {
    toast('Character analysis failed: ' + e.message, 'error');
    btn.disabled = false; if (prog) prog.hidden = true;
    return;
  }

  // Map analysis back to speakers (case-insensitive match)
  const byName = {};
  characters.forEach(c => { if (c.name) byName[String(c.name).toUpperCase().trim()] = c; });

  // 2) For each character, design + save a voice
  let done = 0;
  // rehState.cast[sp] used to be assumed always present since `speakers` came
  // from Object.keys(rehState.cast) moments earlier — but the analyze-characters
  // await above can take many seconds for a large cast, and if anything
  // removes/replaces a cast entry while that request is in flight, the plain
  // `rehState.cast[sp].voice` access below threw a TypeError with nothing
  // catching it (this whole loop sits outside the try/catch above), silently
  // killing the click with no toast and no further requests — exactly the
  // "clicked Design all and nothing happens" symptom, confirmed by server
  // logs showing analyze-characters succeeding but voice-design never once
  // being called. Guard it and keep going instead of crashing the whole run.
  // The outer try/finally below is the same idea one level up: ANY unexpected
  // exception here used to vanish into the console with the button stuck
  // disabled — now it surfaces as a toast and always resets the UI.
  try {
  const designOnly = speakers.filter(sp => rehState.cast[sp]?.voice !== 'me');
  for (const sp of designOnly) {
    if (rehDesignCancelled) { toast('Cancelled', 'error'); break; }
    if (!rehState.cast[sp]) { done++; continue; }
    const info = byName[sp.toUpperCase().trim()] || {};
    const gender = (info.gender || 'N').toUpperCase().charAt(0).replace(/[^MFN]/, 'N') || 'N';
    const desc = info.description ||
      `A ${info.age || 'adult'} ${gender === 'M' ? 'male' : gender === 'F' ? 'female' : ''} character named ${sp}, natural expressive voice.`;
    const sampleLine = rehState.lines.find(l => l.type === 'dialog' && l.speaker === sp)?.text || `Hello, I am ${sp}.`;

    const safeName = (typeof _umlautSafe === 'function' ? _umlautSafe(sp) : sp).replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 24) || 'Char';
    const voiceId  = `${langCode}_${gender}_${safeName}_${tag}`.slice(0, 90);
    rehMarkCastDesigning(sp, 'designing', null, {
      gender, language, voiceId, desc,
      age: info.age || '',
      step: 'Generating voice audio…',
    });
    setProg(done, designOnly.length, `Designing ${sp}… (${done + 1}/${designOnly.length})`);

    try {
      // Generate the voice audio
      const dr = await fetch('/api/voice-design', {
        method: 'POST', headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ instruct: desc, sample_text: stripMarkdown(sampleLine).slice(0, 300), language, gender, dialogue: false }),
      });
      if (!dr.ok) { const e = await dr.json().catch(()=>({})); throw new Error(e.detail || dr.statusText); }
      const dd = await dr.json();

      // Save it to the voice library, tagged with script name + Rehearser
      const sr = await fetch('/api/save', {
        method: 'POST', headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ id: dd.id, voice_id: voiceId, transcript: stripMarkdown(sampleLine).slice(0, 300) }),
      });
      if (!sr.ok) { const e = await sr.json().catch(()=>({})); throw new Error(e.detail || sr.statusText); }
      const saved = await sr.json();

      // Tag metadata — display name = character, script as a tag, origin 'designed',
      // grouped by play title, plus an auto-picked gender/type avatar icon.
      const charName = (sp === REH_NARRATOR_KEY) ? 'Narrator' : sp;
      if (typeof saveMeta === 'function') {
        await saveMeta(saved.voice_id, {
          gender,
          name:   charName,
          avatar: _pickVoiceAvatar(gender, desc, sp),
          origin: 'designed',
          group:  `Rehearser: ${scriptTitle}`,
          note: `Rehearser · ${scriptTitle} · ${charName} — ${desc.slice(0, 180)}`,
          transcript: stripMarkdown(sampleLine).slice(0, 300),
          tag: scriptTitle,
        }).catch(()=>{});
      }

      // Assign to cast + remember the LLM's research as the style note & character soul
      rehState.cast[sp].voice    = saved.voice_id;
      rehState.cast[sp].instruct = rehState.cast[sp].instruct || desc;
      rehState.cast[sp].soul     = rehState.cast[sp].soul || [info.age ? `Age: ${info.age}` : '', desc].filter(Boolean).join(' · ');
      rehState.cast[sp].voiceData = null;
      if (!rehState.voices.includes(saved.voice_id)) rehState.voices.push(saved.voice_id);
      rehMarkCastDesigning(sp, 'done');
    } catch(e) {
      rehMarkCastDesigning(sp, 'err', e.message);
    }
    done++;
    setProg(done, designOnly.length);
  }

  // Refresh the broader voice library so avatars/pictures resolve
  if (typeof loadVoiceLibrary === 'function') await loadVoiceLibrary().catch(()=>{});

  if (!rehDesignCancelled) toast(`Designed ${done} voice${done!==1?'s':''} — tagged "${tag}" + Rehearser`, 'success');
  } catch (e) {
    toast('Design all failed: ' + (e?.message || e), 'error');
  } finally {
    renderCastList();
    populateNarratorSelect();
    if (prog) prog.hidden = true;
    btn.disabled = false;
  }
});

// ── Match from library — LLM picks the best EXISTING voice for each character ──
// ── Character research → per-character note ──────────────────────────────────
// Store the LLM's reading of the play as each character's "soul" note (+ gender / style).
function rehWriteCharacterNote(sp, info) {
  const c = rehState.cast[sp]; if (!c || !info) return;
  if (info.gender && !c.gender) c.gender = String(info.gender).toUpperCase().charAt(0).replace(/[^MFN]/, 'N');
  const bits = [];
  if (info.age) bits.push(`Age: ${info.age}`);
  if (info.description) bits.push(info.description);
  const note = bits.join(' · ');
  if (note && !c.soul) c.soul = note;                       // fills the Character-soul / LLM-brief note
  if (info.description && !c.instruct) c.instruct = info.description;
}

// Ask the LLM to read the script + cast, then annotate every character with a note.
// Returns a name→info map (used by the online/design flows that need gender too).
async function rehResearchCast(speakers) {
  const names = speakers.filter(sp => sp !== REH_NARRATOR_KEY);
  if (!names.length) return {};
  let chars = [];
  try {
    const r = await fetch('/api/analyze-characters', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        script: $('reh-script-text')?.value.trim() || linesToScriptText(), names,
        llm_url: $('reh-llm-url')?.value.trim() || rehDefaultLlmUrl(),
        model: $('reh-llm-model')?.value || '', language: $('reh-design-lang')?.value || 'English',
      }),
    });
    if (r.ok) chars = (await r.json()).characters || [];
  } catch (_) {}
  const byName = {};
  chars.forEach(c => { if (c.name) byName[String(c.name).toUpperCase().trim()] = c; });
  speakers.forEach(sp => rehWriteCharacterNote(sp, byName[sp.toUpperCase().trim()]));
  return byName;
}

$('reh-matchlib-btn')?.addEventListener('click', async () => {
  const btn = $('reh-matchlib-btn');
  const speakers = Object.keys(rehState.cast).filter(sp => rehState.cast[sp].voice !== 'me');
  if (!speakers.length) { toast('No characters to match', 'error'); return; }
  let lib = (window._voices || []).filter(v => v.enabled !== false);
  if (!lib.length) {
    // Library metadata isn't loaded yet (opened the Rehearser directly) — fetch it now.
    try { lib = (await fetch('/api/voices').then(r => r.json())).filter(v => v.enabled !== false); } catch (_) {}
  }
  if (!lib.length) { toast('Your voice library is empty — clone, design or import some voices first', 'error'); return; }

  const candidates = lib.map(v => ({
    id: v.id, gender: v.gender || '', language: v.lang || '',
    tags: v.tag || '', description: (v.note || v.name || '').slice(0, 140),
  }));
  const nameFor = sp => (sp === REH_NARRATOR_KEY ? 'Narrator' : sp);
  const byDisplay = {};
  speakers.forEach(sp => { byDisplay[nameFor(sp).toUpperCase().trim()] = sp; });

  const orig = btn.innerHTML;
  btn.disabled = true; btn.innerHTML = '<span class="reh-imsdb-spinner"></span> Matching…';
  try {
    const r = await fetch('/api/match-characters-voices', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        script: $('reh-script-text')?.value.trim() || linesToScriptText(),
        names: speakers.map(nameFor),
        voices: candidates,
        llm_url: $('reh-llm-url')?.value.trim() || rehDefaultLlmUrl(),
        model: $('reh-llm-model')?.value || '',
        language: $('reh-design-lang')?.value || 'English',
      }),
    });
    if (!r.ok) { const e = await r.json().catch(() => ({})); throw new Error(e.detail || r.statusText); }
    const assignments = (await r.json()).assignments || [];
    const validIds = new Set(candidates.map(c => c.id));
    let n = 0;
    assignments.forEach(a => {
      const sp = byDisplay[String(a.name || '').toUpperCase().trim()];
      if (sp && a.voice_id && validIds.has(a.voice_id)) {
        rehState.cast[sp].voice = a.voice_id;
        rehState.cast[sp].voiceData = getVoiceData(a.voice_id);
        if (!rehState.voices.includes(a.voice_id)) rehState.voices.push(a.voice_id);
        if (sp === REH_NARRATOR_KEY) rehState.narratorVoice = a.voice_id;
        n++;
      }
    });
    // Research the play + cast and drop a note on each character
    btn.innerHTML = '<span class="reh-imsdb-spinner"></span> Researching characters…';
    await rehResearchCast(speakers);
    renderCastList();
    populateNarratorSelect();
    toast(n ? `Matched ${n} character${n !== 1 ? 's' : ''} & added notes` : 'No good matches — try “Design all voices” instead', n ? 'success' : 'error');
  } catch (e) {
    toast('Match failed: ' + e.message, 'error');
  } finally {
    btn.disabled = false; btn.innerHTML = orig;
  }
});

// ── Match from online — search fish.audio per character, import & assign ──────
const REH_FISH_LANG = { English: 'en', German: 'de', French: 'fr', Spanish: 'es', Italian: 'it', Portuguese: 'pt', Dutch: 'nl', Auto: '' };
$('reh-matchonline-btn')?.addEventListener('click', async () => {
  const btn = $('reh-matchonline-btn');
  const speakers = Object.keys(rehState.cast).filter(sp => rehState.cast[sp].voice !== 'me' && sp !== REH_NARRATOR_KEY);
  if (!speakers.length) { toast('No characters to match', 'error'); return; }
  const lang = REH_FISH_LANG[$('reh-design-lang')?.value || 'English'] ?? 'en';
  const prog = $('reh-autodesign-progress'), fill = $('reh-autodesign-fill'), label = $('reh-autodesign-label');
  const setProg = (d, t, msg) => { if (fill) fill.style.width = (t ? (d / t) * 100 : 0) + '%'; if (label) label.textContent = msg || `${d} / ${t}`; };

  const orig = btn.innerHTML;
  btn.disabled = true; btn.innerHTML = '<span class="reh-imsdb-spinner"></span> Analyzing…';
  if (prog) prog.hidden = false;
  rehDesignCancelled = false;
  try {
    // 1) Ask the LLM for each character's gender (drives the online search)
    let chars = [];
    try {
      const ar = await fetch('/api/analyze-characters', {
        method: 'POST', headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ script: $('reh-script-text')?.value.trim() || linesToScriptText(), names: speakers,
          llm_url: $('reh-llm-url')?.value.trim() || rehDefaultLlmUrl(), model: $('reh-llm-model')?.value || '',
          language: $('reh-design-lang')?.value || 'English' }),
      });
      if (ar.ok) chars = (await ar.json()).characters || [];
    } catch (_) {}
    const byName = {}; chars.forEach(c => { if (c.name) byName[String(c.name).toUpperCase().trim()] = c; });
    const G = { M: 'male', F: 'female', N: 'neutral' };

    let done = 0, n = 0;
    for (let i = 0; i < speakers.length; i++) {
      if (rehDesignCancelled) { toast('Cancelled', 'error'); break; }
      const sp = speakers[i];
      setProg(done, speakers.length, `Matching ${sp}… (${done + 1}/${speakers.length})`);
      const info = byName[sp.toUpperCase().trim()] || {};
      rehWriteCharacterNote(sp, info);   // drop the LLM's character research into a note
      const gender = G[(info.gender || '').toUpperCase().charAt(0)] || '';
      // Search fish.audio: by character name first (catches known/celebrity names), then gender+lang
      const qs = [`search=${encodeURIComponent(sp)}`, `language=${lang}`, 'page_size=8', 'sort_by=score'];
      let items = [];
      try { items = (await fetch('/api/fishaudio/voices?' + qs.join('&')).then(r => r.json())).items || []; } catch (_) {}
      let pick = items.find(v => v.sample_audio);
      let nameHit = !!pick;   // got a result by searching the character's actual name
      if (!pick) {  // fallback: best by gender+language, offset per character to diversify
        const fb = [`language=${lang}`, gender ? `gender=${gender}` : '', 'page_size=12', 'sort_by=score', `page=${(i % 4) + 1}`].filter(Boolean);
        try { items = (await fetch('/api/fishaudio/voices?' + fb.join('&')).then(r => r.json())).items || []; } catch (_) {}
        pick = items.find(v => v.sample_audio);
      }
      // Keep the top few playable results so the user can audition & swap them later
      let cands = items.filter(v => v.sample_audio).slice(0, 6).map(v => ({
        title: v.title, sample_audio: v.sample_audio, image: v.image || '', gender: v.gender || '',
        language: v.language || lang || '', description: v.description || '', sample_text: v.sample_text || v.default_text || '',
      }));
      // When the name didn't match, the fallback returns the same popular voices for
      // everyone — rotate the pick per character so they don't all sound identical,
      // and skip voices already taken by earlier characters this run.
      if (!nameHit && cands.length > 1) {
        const taken = new Set(Object.values(rehState.cast).map(c => (c.online?.candidates?.[c.online.picked]?.sample_audio)).filter(Boolean));
        const rotated = [...cands.slice(i % cands.length), ...cands.slice(0, i % cands.length)];
        cands = rotated.sort((a, b) => (taken.has(a.sample_audio) ? 1 : 0) - (taken.has(b.sample_audio) ? 1 : 0));
      }
      if (cands.length) {
        try {
          const vid = await _rehImportFishCandidate(sp, cands[0]);
          cands[0].voice_id = vid;
          rehState.cast[sp].voice = vid;
          rehState.cast[sp].voiceData = getVoiceData(vid);
          rehState.cast[sp].online = { candidates: cands, picked: 0 };
          n++;
        } catch (e) { logErr('match-online import ' + sp, e); }
      }
      done++; setProg(done, speakers.length);
    }
    if (typeof loadVoiceLibrary === 'function') await loadVoiceLibrary().catch(() => {});
    renderCastList();
    populateNarratorSelect();
    toast(n ? `Imported & matched ${n} online voice${n !== 1 ? 's' : ''}` : 'No online matches found', n ? 'success' : 'error');
  } catch (e) {
    toast('Online match failed: ' + e.message, 'error');
  } finally {
    btn.disabled = false; btn.innerHTML = orig;
    if (prog) prog.hidden = true;
  }
});

// Show per-character design progress card beneath the cast row
function rehMarkCastDesigning(sp, state, msg, info) {
  const row = document.querySelector(`.reh-cast-row[data-speaker="${CSS.escape(sp)}"]`);
  if (!row) return;

  // Inline badge in the cast row header
  let badge = row.querySelector('.reh-cast-design-badge');
  if (!badge) {
    badge = document.createElement('span');
    badge.className = 'reh-cast-design-badge';
    row.querySelector('strong')?.after(badge);
  }
  badge.className = 'reh-cast-design-badge' + (state === 'done' ? ' done' : state === 'err' ? ' err' : '');
  badge.textContent = state === 'designing' ? '✨ designing…' : state === 'done' ? '✓ designed' : '✗ failed';
  if (msg) badge.title = msg;
  row.classList.toggle('reh-cast-designing', state === 'designing');

  // Expanded detail panel beneath the instruct row
  const wrap = row.closest('div');
  let panel = wrap?.querySelector('.reh-cast-design-panel');

  if (state === 'designing' && info) {
    if (!panel) {
      panel = document.createElement('div');
      panel.className = 'reh-cast-design-panel';
      wrap.appendChild(panel);
    }
    const genderIcon = info.gender === 'M' ? '♂' : info.gender === 'F' ? '♀' : '⚧';
    const genderLabel = info.gender === 'M' ? 'Male' : info.gender === 'F' ? 'Female' : 'Neutral';
    panel.innerHTML = `
      <div class="reh-cdp-meta">
        <span class="reh-cdp-chip reh-cdp-gender">${genderIcon} ${escHtml(genderLabel)}</span>
        <span class="reh-cdp-chip reh-cdp-lang"><span class="mdi mdi-translate"></span> ${escHtml(info.language || 'EN')}</span>
        <span class="reh-cdp-chip reh-cdp-name"><span class="mdi mdi-account-outline"></span> ${escHtml(info.voiceId || sp)}</span>
        ${info.age ? `<span class="reh-cdp-chip">${escHtml(info.age)}</span>` : ''}
      </div>
      <div class="reh-cdp-desc">${escHtml(info.desc || '')}</div>
      <div class="reh-cdp-step"><span class="reh-imsdb-spinner"></span> <span class="reh-cdp-step-txt">${escHtml(info.step || 'Designing voice…')}</span></div>`;
  } else if (state === 'done' && panel) {
    // Collapse to a summary line
    const descEl = panel.querySelector('.reh-cdp-desc');
    const metaEl = panel.querySelector('.reh-cdp-meta');
    const stepEl = panel.querySelector('.reh-cdp-step');
    if (stepEl) stepEl.remove();
    if (descEl) {
      // Truncate
      const t = descEl.textContent;
      if (t.length > 160) descEl.textContent = t.slice(0, 157) + '…';
    }
    panel.classList.add('done');
  } else if (state === 'err') {
    if (panel) panel.remove();
  }
}

$('reh-start-btn')?.addEventListener('click', () => {
  const backend = $('reh-backend-select')?.value;
  if (!backend) { toast('Select a backend first', 'error'); return; }
  rehState.backend       = backend;
  rehState.narratorVoice = $('reh-narrator-voice')?.value || '';
  rehState.lineIndex     = 0;
  rehState.clips         = [];
  rehState.playing       = false;
  rehState.synthCache.clear(); rehDecodedBuffers.clear();
  rehState.practiceStart = null;
  rehState.practiceEnd   = null;
  buildScriptPage();
  showPhase(3);
  highlightCurrentLine();
});

// ── Stage display controls (font size + collapsible cast) ───────────────────

const REH_STAGE_FONT_KEY = 'ttsvc_reh_stage_scale';
const REH_CAST_COLLAPSED_KEY = 'ttsvc_reh_cast_collapsed';

function rehStageScale() {
  const v = parseFloat(localStorage.getItem(REH_STAGE_FONT_KEY) || '1');
  return isNaN(v) ? 1 : Math.max(0.7, Math.min(2, v));
}
function rehApplyStageFont() {
  // Set on the page wrapper so the scale inherits to BOTH the single A4 page
  // (#reh-a4-page) and the paginated `.reh-paper` pages built by page-mode.
  const scale = String(rehStageScale());
  const wrap = document.querySelector('.reh-page-wrap');
  if (wrap) wrap.style.setProperty('--reh-stage-scale', scale);
  const page = $('reh-a4-page');
  if (page) page.style.setProperty('--reh-stage-scale', scale);
}
function rehStageFontStep(delta) {
  const next = Math.max(0.7, Math.min(2, Math.round((rehStageScale() + delta) * 100) / 100));
  localStorage.setItem(REH_STAGE_FONT_KEY, String(next));
  rehApplyStageFont();
}

function rehApplyCastCollapsed() {
  // Same collapse pattern as Read Aloud's Casting sidebar (.ab-cv-side.is-collapsed
  // shrinks to just the avatar dots); the stage area's grid column narrows to match.
  const row = $('reh-cast-row');
  const stage = $('reh-stage-area');
  if (!row) return;
  const collapsed = localStorage.getItem(REH_CAST_COLLAPSED_KEY) === '1';
  row.classList.toggle('is-collapsed', collapsed);
  if (stage) stage.classList.toggle('side-collapsed', collapsed);
  const btn = $('reh-cast-toggle');
  if (btn) {
    btn.setAttribute('aria-expanded', String(!collapsed));
    btn.title = collapsed ? 'Expand character list' : 'Collapse to avatars';
    const icon = btn.querySelector('.mdi');
    if (icon) icon.className = 'mdi ' + (collapsed ? 'mdi-chevron-right' : 'mdi-chevron-left');
  }
}
function rehToggleCast() {
  const collapsed = localStorage.getItem(REH_CAST_COLLAPSED_KEY) === '1';
  localStorage.setItem(REH_CAST_COLLAPSED_KEY, collapsed ? '0' : '1');
  rehApplyCastCollapsed();
}

$('reh-font-inc')?.addEventListener('click', () => rehStageFontStep(0.1));
$('reh-font-dec')?.addEventListener('click', () => rehStageFontStep(-0.1));
$('reh-cast-toggle')?.addEventListener('click', rehToggleCast);

// ── A4 Script page ─────────────────────────────────────────────────────────

// Cast sidebar — same look (.ab-char-item rows) as Read Aloud's Casting
// sidebar, but with real portraits (cross-referenced from the Library, same
// cache the Cast tab already builds) instead of plain colored-letter dots,
// plus search and sort. Split out from buildScriptPage so typing in the
// search box doesn't re-render the whole (potentially 1000+ line) script
// page on every keystroke — just this strip.
function renderCastStrip() {
  const castStrip = $('reh-cast-strip');
  if (!castStrip) return;
  const scriptTitle = $('reh-script-title')?.value.trim() || '';
  _rehEnsureLibCharsCache(scriptTitle);
  const names = Object.keys(rehState.cast);
  const lineCountFor = sp => rehState.lines.filter(l => l.speaker === sp && l.type === 'dialog').length;
  const libRecByNameStage = new Map((_rehLibCharsCache || []).map(r => [String(r.name || '').trim().toLowerCase(), r]));
  const sortMode = $('reh-cast-side-sort')?.value || localStorage.getItem('reh_cast_side_sort') || 'lines';
  const query = ($('reh-cast-side-search')?.value || '').trim().toLowerCase();

  let rows = names.map(sp => {
    const displayName = (sp === REH_NARRATOR_KEY) ? 'Narrator' : sp;
    const libRec = sp === REH_NARRATOR_KEY ? null : libRecByNameStage.get(String(sp).trim().toLowerCase());
    // `sp` is the raw speaker key straight out of script parsing, which
    // follows screenplay convention (ALL CAPS speaker tags) — rendering it
    // verbatim meant every name in this sidebar showed shouting-case
    // regardless of how it's actually spelled anywhere else in the app.
    // Prefer the Library's own properly-cased name when there's a match;
    // a plain per-word title-case is still better than shouting-case for
    // the rarer speaker key with no Library record to match against.
    const fallbackName = displayName === 'Narrator' ? displayName
      : displayName.replace(/\w\S*/g, w => w[0].toUpperCase() + w.slice(1).toLowerCase());
    return { sp, displayName: libRec?.name || fallbackName, n: lineCountFor(sp), libRec };
  });
  if (query) rows = rows.filter(r => r.displayName.toLowerCase().includes(query));
  rows.sort((a, b) => sortMode === 'name'
    ? a.displayName.localeCompare(b.displayName)
    : (b.n - a.n) || a.displayName.localeCompare(b.displayName));

  castStrip.innerHTML = rows.map(({ sp, displayName, n, libRec }) => {
    const c = rehState.cast[sp], isMe = c.voice === 'me';
    const avatarHtml = libRec?.image
      ? `<span class="ab-char-dot ab-char-dot-img" style="border-color:${c.color}"><img src="${libRec.image}" alt=""></span>`
      : `<span class="ab-char-dot" style="background:${c.color}">${escHtml((displayName||'?')[0].toUpperCase())}</span>`;
    return `<div class="ab-char-item" data-speaker="${escHtml(sp)}" title="${escHtml(displayName)} — ${isMe?'me':(c.voice||'no voice')}">
      ${avatarHtml}
      <span class="ab-char-name">${escHtml(displayName)}</span>
      ${isMe?'<span class="mdi mdi-microphone" style="font-size:11px;color:var(--subtext)"></span>':''}
      <b class="ab-char-count">${n}</b>
    </div>`;
  }).join('');
  castStrip.querySelectorAll('.ab-char-item').forEach(item => {
    item.addEventListener('click', () => {
      const line = document.querySelector(`.reh-block[data-speaker="${CSS.escape(item.dataset.speaker)}"]`);
      if (line) line.scrollIntoView({ behavior: 'smooth', block: 'center' });
    });
  });
  const lbl = $('reh-cast-toggle-label');
  if (lbl) lbl.textContent = `Characters (${names.length})`;

  const searchInp = $('reh-cast-side-search');
  const sortSel = $('reh-cast-side-sort');
  if (searchInp && !searchInp.dataset.wired) {
    searchInp.dataset.wired = '1';
    searchInp.addEventListener('input', () => renderCastStrip());
  }
  if (sortSel && !sortSel.dataset.wired) {
    sortSel.dataset.wired = '1';
    sortSel.value = sortMode;
    sortSel.addEventListener('change', () => { localStorage.setItem('reh_cast_side_sort', sortSel.value); renderCastStrip(); });
  }
}

function buildScriptPage() {
  const titleEl = $('reh-page-title');
  if (titleEl) titleEl.textContent = $('reh-script-title')?.value.trim() || 'Script';

  renderCastStrip();
  rehApplyStageFont();
  rehApplyCastCollapsed();

  // Fire-and-forget, guarded against re-running for the same script — see
  // _lineAudioSyncDots for why this exists (green dots otherwise look reset
  // after every reload even when the audio is safely cached on disk).
  if (typeof _lineAudioSyncDots === 'function') _lineAudioSyncDots().catch(() => {});

  const linesEl = $('reh-script-lines'); if (!linesEl) return;

  linesEl.innerHTML = rehState.lines.map((line, i) => {
    const isCached = rehState.synthCache.has(i);
    const isStale  = rehState.staleLines.has(i);
    const dotCls   = isStale ? 'reh-synth-dot stale' : 'reh-synth-dot';
    const dotTitle = isStale ? 'Tone changed — needs re-synthesis' : 'Pre-synthesized';
    const synthDot = `<span class="${dotCls}" id="reh-syd-${i}" style="${(isCached||isStale)?'':'display:none'}" title="${dotTitle}"></span>`;
    const reSynthBtn = `<button class="reh-resynth-btn" id="reh-rsb-${i}" title="Re-synthesize this line" ${isStale?'':'hidden'}><span class="mdi mdi-refresh"></span></button>`;
    const editBtn  = `<button class="reh-edit-btn" data-index="${i}" title="Edit text (or double-click)"><span class="mdi mdi-pencil-outline"></span></button>`;
    const note     = rehState.lines[i].note || '';
    // noteArea includes the edit button so both icons live in the right gutter
    const noteArea = `<div class="reh-note-area" data-index="${i}">
      ${editBtn}
      <button class="reh-note-btn${note?' has-note':''}" title="${note?'Edit note':'Add note'}"><span class="mdi mdi-note-edit-outline"></span></button>
      <textarea class="reh-note-ta" placeholder="Personal note (not spoken)…" spellcheck="false">${escHtml(note)}</textarea>
    </div>`;

    // Bulk-edit: hidden lines drop out of the view entirely, unless we're revealing
    // them inside bulk mode so they can be selected and restored.
    if (line.hidden && !(rehState.bulkMode && rehState.showHidden)) return '';
    const _bSel = rehState.bulkSel.has(i);
    const bulkCheck = rehState.bulkMode
      ? `<span class="reh-bulk-check${_bSel ? ' checked' : ''}" data-bulk="${i}" title="Select line"><span class="mdi ${_bSel ? 'mdi-checkbox-marked' : 'mdi-checkbox-blank-outline'}"></span></span>`
      : '';
    const lineFlags = (line.ignored ? ' reh-line-ignored' : '') + (line.hidden ? ' reh-line-hidden' : '') + (_bSel ? ' reh-selected' : '');

    // Same detection audiobookExport() uses to decide chapter/file boundaries
    // (audiobook.js) — surfaced here too so a chapter is visible in the script
    // itself, not just audible as a pause in the finished export. Runs before
    // the normal type switch so a chapter heading (however it was tagged
    // during parsing — 'act', 'scene', or plain 'action' text recovered via
    // heading OCR) always gets this treatment instead of its usual rendering.
    if (typeof audiobookIsChapter === 'function' && audiobookIsChapter(line)) {
      const label = (typeof stripMarkdown === 'function' ? stripMarkdown(line.text || '') : (line.text || '')).trim();
      return `<div class="reh-chapter-marker${lineFlags}" data-index="${i}">
        ${bulkCheck}
        <span class="reh-chapter-marker-line"></span>
        <span class="reh-chapter-marker-label">${label ? escHtml(label) : 'Chapter'}</span>
        <span class="reh-chapter-marker-line"></span>
        ${editBtn} ${synthDot}
      </div>`;
    }

    switch (line.type) {
      case 'act':
        return `<div class="reh-act${lineFlags}" data-index="${i}" style="position:relative">${bulkCheck}${escHtml(line.text)} ${editBtn} ${synthDot}</div>`;

      case 'scene':
        return `<div class="reh-scene${lineFlags}" data-index="${i}">
          ${bulkCheck}<span class="mdi mdi-film" style="flex-shrink:0"></span>
          <span style="flex:1">${escHtml(line.text)}</span>
          ${editBtn} ${synthDot}
        </div>`;

      case 'action': {
        // Narrator paragraphs get a play button too now, but deliberately
        // NOT wrapped in .reh-block's boxed/indented dialogue treatment
        // (avatar circle, name row, highlighted card) — just a small inline
        // icon before the text, same weight as the edit button, so plain
        // narration keeps reading like plain narration.
        const narrPlayBtn = `<button type="button" class="reh-line-play-avatar reh-action-play-btn" data-index="${i}" title="Play or pause this line" aria-label="Play or pause this line"><span class="mdi mdi-play"></span></button>`;
        return `<div class="reh-action-block${lineFlags}" data-index="${i}">
          ${bulkCheck}${narrPlayBtn}<span class="reh-action-text">${renderMarkdownInline(line.text)}</span>
          ${editBtn} ${synthDot}
        </div>`;
      }

      case 'pagebreak': {
        const pbLabel = line.page ? `— Page ${line.page} —` : '— Page break —';
        return `<div class="reh-block-pagebreak${lineFlags}" data-index="${i}">${bulkCheck}<span class="reh-pagebreak-label">${pbLabel}</span></div>`;
      }

      case 'transition':
        return `<div class="reh-transition${lineFlags}" data-index="${i}">${bulkCheck}${escHtml(line.text)}</div>`;

      case 'direction': {
        const indent = line.speaker ? 'text-align:center;' : '';
        return `<div class="reh-direction${lineFlags}" data-index="${i}" style="${indent}">${bulkCheck}<em>${escHtml(line.text)}</em></div>`;
      }

      case 'dialog': {
        const c     = rehState.cast[line.speaker] || { voice:'', color:'#89b4fa' };
        const isMe  = c.voice === 'me';
        const emoInfo = getEmotionInfo(line.emotion || '');
        return `<div class="reh-block${lineFlags}${rehState.practiceEnd===i?' reh-range-end':''}${rehState.practiceStart===i?' reh-range-start':''}${isPracticeRange(i)?' reh-in-range':''}" data-index="${i}" data-speaker="${escHtml(line.speaker)}" style="cursor:pointer">
          ${bulkCheck}<button class="reh-gutter-btn" data-index="${i}" title="Click: play from here · Shift+click: set end marker">${rehState.practiceStart===i?'▶':rehState.practiceEnd===i?'■':''}</button>
          <div class="reh-block-inner">
            <div class="reh-block-head">
              <button type="button" class="reh-line-play-avatar" data-index="${i}" title="Play or pause this line" aria-label="Play or pause this line">${_rehCharAvatarHtml(line.speaker, isMe?'':c.voice, c.color, 32)}</button>
              <span class="reh-block-name" style="color:${c.color}">${escHtml(line.speaker)}</span>
              <span class="reh-block-head-spacer"></span>
              ${isMe
                ? '<span class="reh-block-badge reh-badge-me"><span class="mdi mdi-microphone"></span> Me</span>'
                : '<span class="reh-block-badge reh-badge-tts"><span class="mdi mdi-speaker-outline"></span> TTS</span>'
              }
              ${!isMe
                ? `<button class="reh-emo-btn${line.emotion?' has-emotion':''}" data-index="${i}" title="Set speaking tone">
                    ${emoInfo.emoji ? emoInfo.emoji + ' ' : ''}<span class="reh-emo-label">${escHtml(emoInfo.label)}</span>
                    <span class="mdi mdi-chevron-down" style="font-size:9px;opacity:.6"></span>
                  </button>`
                : ''
              }
              ${synthDot}
              ${reSynthBtn}
            </div>
            <div class="reh-block-dialog" id="reh-diag-${i}">${renderMarkdownInline(line.text)}</div>
          </div>
          ${noteArea}
        </div>`;
      }

      default: return '';
    }
  }).join('');

  // Emotion picker buttons
  linesEl.querySelectorAll('.reh-emo-btn').forEach(btn => {
    btn.addEventListener('click', e => { e.stopPropagation(); openEmoPicker(parseInt(btn.dataset.index), btn); });
  });

  // Edit buttons
  linesEl.querySelectorAll('.reh-edit-btn').forEach(btn => {
    btn.addEventListener('click', e => { e.stopPropagation(); startInlineEdit(parseInt(btn.dataset.index)); });
  });

  // Double-click on dialog / action text to edit
  linesEl.querySelectorAll('.reh-block-dialog').forEach(el => {
    el.addEventListener('dblclick', e => { e.stopPropagation(); startInlineEdit(parseInt(el.closest('[data-index]').dataset.index)); });
  });
  linesEl.querySelectorAll('.reh-action-text').forEach(el => {
    el.addEventListener('dblclick', e => { e.stopPropagation(); startInlineEdit(parseInt(el.closest('[data-index]').dataset.index)); });
  });

  // Avatar button: play/pause a single character line
  linesEl.querySelectorAll('.reh-line-play-avatar').forEach(btn => {
    btn.addEventListener('click', e => {
      e.stopPropagation();
      const idx = parseInt(btn.dataset.index);
      if (rehState.playing && rehState.lineIndex === idx) { pausePlay(); return; }
      stopPlay();
      hideRecOverlay();
      rehState.lineIndex = idx;
      highlightCurrentLine();
      startPlay();
    });
  });

  // Gutter button: play from here / set end
  linesEl.querySelectorAll('.reh-gutter-btn').forEach(btn => {
    btn.addEventListener('click', e => {
      e.stopPropagation();
      const idx = parseInt(btn.dataset.index);
      if (e.shiftKey) {
        // Set / clear practice end
        rehState.practiceEnd = rehState.practiceEnd === idx ? null : idx;
      } else {
        // Jump to this line and start playing
        stopPlay();
        hideRecOverlay();
        rehState.lineIndex = idx;
        highlightCurrentLine();
        startPlay();
      }
      updatePracticeRange();
    });
  });

  // Click block to jump; in Select mode, click toggles selection and Shift+click selects a range.
  linesEl.querySelectorAll('[data-index]').forEach(el => {
    el.addEventListener('click', e => {
      if (e.target.closest('.reh-emo-btn, .reh-edit-btn, .reh-gutter-btn, .reh-note-btn, .reh-resynth-btn, .reh-line-play-avatar, textarea, select, .vp-root')) return;
      const idx = parseInt(el.dataset.index);
      if (rehState.bulkMode) {
        _toggleBulkSel(idx, e.shiftKey);
        return;
      }
      stopPlay();
      hideRecOverlay();
      rehState.lineIndex = idx;
      highlightCurrentLine();
    });
  });

  // Re-synth buttons (per line)
  linesEl.querySelectorAll('.reh-resynth-btn').forEach(btn => {
    btn.addEventListener('click', e => {
      e.stopPropagation();
      synthOneLine(parseInt(btn.id.replace('reh-rsb-', '')));
    });
  });

  // Note area: toggle textarea visibility on button click, save on change
  linesEl.querySelectorAll('.reh-note-area').forEach(area => {
    const idx = parseInt(area.dataset.index);
    const btn = area.querySelector('.reh-note-btn');
    const ta  = area.querySelector('.reh-note-ta');
    if (!btn || !ta) return;
    // Show if note has content
    if (ta.value.trim()) ta.classList.add('open');
    btn.addEventListener('click', e => {
      e.stopPropagation();
      ta.classList.toggle('open');
      if (ta.classList.contains('open')) ta.focus();
    });
    ta.addEventListener('input', () => {
      rehState.lines[idx].note = ta.value;
      btn.classList.toggle('has-note', !!ta.value.trim());
    });
    ta.addEventListener('click', e => e.stopPropagation());
  });

  // Bulk-edit: leading checkboxes toggle line selection. The page wrapper also
  // gets the mode class because A4/PDF modes move blocks out of #reh-script-lines.
  linesEl.classList.toggle('reh-bulk-mode', rehState.bulkMode);
  document.querySelector('.reh-page-wrap')?.classList.toggle('reh-bulk-mode', rehState.bulkMode);
  if (rehState.bulkMode) {
    linesEl.querySelectorAll('.reh-bulk-check').forEach(cb => {
      cb.addEventListener('click', e => {
        e.stopPropagation();
        _toggleBulkSel(parseInt(cb.dataset.bulk), e.shiftKey);
      });
    });
  }

  // Apply current pagination mode
  applyPageMode();

  // Warn if backend doesn't support tone/style changes
  _checkToneStyleSupport();
}

// ── Bulk-edit (line selection: ignore / hide / delete) ──────────────────────

function _toggleBulkSel(i, range = false) {
  if (!Number.isFinite(i)) return;
  if (range && rehState.bulkAnchor !== null && Number.isFinite(rehState.bulkAnchor)) {
    const a = Math.min(rehState.bulkAnchor, i);
    const b = Math.max(rehState.bulkAnchor, i);
    const indices = [];
    for (let n = a; n <= b; n++) if (rehState.lines[n] && !rehState.lines[n].hidden) indices.push(n);
    const deselect = indices.length && indices.every(n => rehState.bulkSel.has(n));
    indices.forEach(n => {
      if (deselect) rehState.bulkSel.delete(n);
      else rehState.bulkSel.add(n);
      _refreshBulkLine(n);
    });
    rehState.bulkAnchor = i;
  } else {
    if (rehState.bulkSel.has(i)) rehState.bulkSel.delete(i);
    else rehState.bulkSel.add(i);
    rehState.bulkAnchor = i;
    _refreshBulkLine(i);
  }
  _updateBulkCount();
}

function _refreshBulkLine(i) {
  const sel = rehState.bulkSel.has(i);
  document.querySelectorAll(`.reh-bulk-check[data-bulk="${i}"]`).forEach(cb => {
    cb.classList.toggle('checked', sel);
    const icon = cb.querySelector('.mdi');
    if (icon) icon.className = 'mdi ' + (sel ? 'mdi-checkbox-marked' : 'mdi-checkbox-blank-outline');
  });
  document.querySelectorAll(`[data-index="${i}"]`).forEach(el => el.classList.toggle('reh-selected', sel));
}

function _updateBulkCount() {
  const el = $('reh-bulk-count');
  if (el) el.textContent = `${rehState.bulkSel.size} selected`;
}

function setBulkMode(on) {
  rehState.bulkMode = on;
  if (!on) { rehState.bulkSel.clear(); rehState.bulkAnchor = null; }
  const bar = $('reh-bulk-bar'); if (bar) bar.hidden = !on;
  const btn = $('reh-bulk-toggle'); if (btn) btn.classList.toggle('active', on);
  _updateBulkCount();
  if (rehState.lines.length) buildScriptPage();
}

// Apply a mutation to all selected lines, then re-render.
function _bulkApply(fn, { keepSelection = false } = {}) {
  if (!rehState.bulkSel.size) { toast('No lines selected', 'error'); return; }
  [...rehState.bulkSel].forEach(i => { const l = rehState.lines[i]; if (l) fn(l, i); });
  if (!keepSelection) rehState.bulkSel.clear();
  _updateBulkCount();
  buildScriptPage();
}

function _bulkDelete() {
  if (!rehState.bulkSel.size) { toast('No lines selected', 'error'); return; }
  const victims = [...rehState.bulkSel].sort((a, b) => b - a);  // high → low so indices stay valid
  victims.forEach(i => {
    rehState.lines.splice(i, 1);
    _reindexLineState(i);
  });
  rehState.bulkSel.clear();
  // Keep the cursor in range
  if (rehState.lineIndex >= rehState.lines.length) rehState.lineIndex = Math.max(0, rehState.lines.length - 1);
  _updateBulkCount();
  buildScriptPage();
  highlightCurrentLine();
  toast(`Deleted ${victims.length} line${victims.length !== 1 ? 's' : ''}`, 'success');
}

// After deleting line `d`, shift every index-keyed bit of state above it down by one.
function _reindexLineState(d) {
  const shift = (collection, isMap) => {
    const out = isMap ? new Map() : new Set();
    for (const entry of collection) {
      const k = isMap ? entry[0] : entry;
      if (k === d) continue;            // dropped line
      const nk = k > d ? k - 1 : k;
      if (isMap) out.set(nk, entry[1]); else out.add(nk);
    }
    return out;
  };
  rehState.synthCache = shift(rehState.synthCache, true);
  rehState.staleLines = shift(rehState.staleLines, false);
  const sel = shift(rehState.bulkSel, false);
  rehState.bulkSel.clear(); sel.forEach(v => rehState.bulkSel.add(v));
  if (rehState.practiceStart != null && rehState.practiceStart > d) rehState.practiceStart--;
  if (rehState.practiceEnd   != null && rehState.practiceEnd   > d) rehState.practiceEnd--;
  if (rehState.lineIndex > d) rehState.lineIndex--;
}

// ── Page mode (endless scroll | auto-pages | pdf-pages) ─────────────────────
const PAGE_MODES = ['auto', 'scroll', 'pdf'];
// 'pdf' (break at the document's own real page marks) is the default now
// that parseScript's page-break detection actually works (see rehearser-parse.js) —
// 'auto' (break purely by content height, ignoring the source document's own
// pages entirely) was never really what most people mean by "pages".
let _pageMode = localStorage.getItem('reh-page-mode') || 'pdf';

function applyPageMode() {
  const wrap = document.querySelector('.reh-page-wrap');
  const a4   = $('reh-a4-page');
  if (!wrap) return;

  if (_pageMode === 'scroll') {
    // Endless scroll — put all blocks back into the a4 div, no paper pages
    wrap.querySelectorAll('.reh-paper').forEach(p => {
      [...p.children].forEach(c => { if (!c.classList.contains('reh-paper-num')) a4?.appendChild(c); });
      p.remove();
    });
    wrap.classList.remove('paginated');
    if (a4) a4.style.display = '';
    // Hide pagebreak visual dividers in scroll mode
    document.querySelectorAll('.reh-block-pagebreak').forEach(el => el.style.display = 'none');
  } else if (_pageMode === 'pdf') {
    // PDF pages — paginate at pagebreak markers
    paginateScript({ respectBreaks: true });
  } else {
    // Auto — paginate by content height
    paginateScript({ respectBreaks: false });
  }
  _syncPageModeBtn();
}

function _syncPageModeBtn() {
  const btn = $('reh-page-mode-btn');
  if (!btn) return;
  const icons  = { auto: 'mdi-file-document-outline', scroll: 'mdi-format-align-justify', pdf: 'mdi-book-open-page-variant' };
  const labels = { auto: 'A4 pages', scroll: 'Scroll', pdf: 'PDF pages' };
  // Labeling this with the CURRENT mode made it look like a passive status
  // indicator rather than a button — confirmed live as genuine confusion:
  // stuck in "Scroll" (one continuous page, no page breaks) with no visible
  // cue that clicking the very button saying "Scroll" is what would change
  // it. Show what clicking it switches TO instead, the normal convention
  // for a cycle/toggle button.
  const nextMode = PAGE_MODES[(PAGE_MODES.indexOf(_pageMode) + 1) % PAGE_MODES.length];
  btn.innerHTML = `<span class="mdi ${icons[nextMode] || icons.auto}"></span> ${labels[nextMode] || labels.auto}`;
  btn.title = `Currently: ${labels[_pageMode]} — click to switch to ${labels[nextMode]}`;
}

function cyclePageMode() {
  const idx = PAGE_MODES.indexOf(_pageMode);
  _pageMode = PAGE_MODES[(idx + 1) % PAGE_MODES.length];
  localStorage.setItem('reh-page-mode', _pageMode);
  applyPageMode();
  // Rebuild script page to apply cleanly
  if (rehState.lines.length) buildScriptPage();
}

// ── Pagination: split the continuous script into A4 paper pages ─────────────
function paginateScript({ respectBreaks = false } = {}) {
  const wrap    = document.querySelector('.reh-page-wrap');
  const linesEl = $('reh-script-lines');
  const titleEl = $('reh-page-title');
  if (!wrap || !linesEl) return;

  // Collect the already-wired block elements (moving them keeps listeners)
  const blocks = [...linesEl.children];
  if (!blocks.length) return;

  wrap.classList.add('paginated');
  const a4 = $('reh-a4-page');
  if (a4) a4.style.display = 'none';
  wrap.querySelectorAll('.reh-paper').forEach(p => p.remove());

  // Printable content height inside a page (A4 minus vertical padding)
  const PAGE_CONTENT = 1027;     // 1123 − 56 − 40
  const TITLE_SPACE  = 64;       // page-1 title block allowance

  let pageNum = 0, page = null, used = 0;
  const newPage = () => {
    pageNum++;
    page = document.createElement('div');
    page.className = 'reh-paper';
    const num = document.createElement('div');
    num.className = 'reh-paper-num';
    num.textContent = pageNum + '.';
    page.appendChild(num);
    used = 0;
    if (pageNum === 1 && titleEl) {
      const t = titleEl.cloneNode(true);
      t.style.display = '';
      page.appendChild(t);
      used += TITLE_SPACE;
    }
    wrap.appendChild(page);
  };
  newPage();

  for (const block of blocks) {
    // PDF page-break marker: always start a new page here
    if (respectBreaks && block.classList.contains('reh-block-pagebreak')) {
      newPage();
      continue; // don't move the marker div into the page
    }

    // Measure block height (must be in DOM to measure → append then check)
    page.appendChild(block);
    const cs = getComputedStyle(block);
    const h  = block.offsetHeight + (parseFloat(cs.marginTop) || 0) + (parseFloat(cs.marginBottom) || 0);

    // If adding this block overflows the page (and page already has content), move to a new page
    if (!respectBreaks && used + h > PAGE_CONTENT && used > (pageNum === 1 ? TITLE_SPACE : 0)) {
      newPage();
      page.appendChild(block);
    }
    used += h;
  }
}

function isPracticeRange(idx) {
  const s = rehState.practiceStart, e = rehState.practiceEnd;
  if (s === null) return false;
  return idx >= s && (e === null || idx <= e);
}

// ── Inline editing ──────────────────────────────────────────────────────────

function startInlineEdit(idx) {
  const line = rehState.lines[idx]; if (!line) return;
  const dialogEl = document.getElementById('reh-diag-' + idx);
  const actionEl = document.querySelector(`[data-index="${idx}"] .reh-action-text`);
  const sceneEl  = document.querySelector(`.reh-scene[data-index="${idx}"] span[style*="flex:1"]`);
  const targetEl = dialogEl || actionEl || sceneEl;
  if (!targetEl || targetEl.tagName === 'TEXTAREA') return;

  const orig = line.text;
  const ta   = document.createElement('textarea');
  ta.value   = orig;
  ta.style.cssText = 'width:100%;min-height:54px;font-size:14px;line-height:1.6;padding:5px 8px;border:1px solid var(--accent);border-top:none;border-radius:0 0 3px 3px;resize:vertical;background:#fffff8;font-family:inherit;display:block;box-sizing:border-box;outline:none;';

  // Formatting toolbar
  const toolbar = document.createElement('div');
  toolbar.className = 'reh-fmt-toolbar';
  toolbar.innerHTML = `
    <button class="reh-fmt-btn" data-b="**" title="Bold"><b>B</b></button>
    <button class="reh-fmt-btn" data-b="*" title="Italic"><i>I</i></button>
    <button class="reh-fmt-btn" data-b="__" title="Underline"><u>U</u></button>
    <button class="reh-fmt-btn" data-b="~~" title="Strikethrough"><del>S</del></button>
    <button class="reh-fmt-btn" data-b="==" title="Highlight" style="background:#fef3c7">H</button>
    <kbd class="reh-fmt-hint">Ctrl+Enter save · Esc cancel</kbd>
  `;
  toolbar.querySelectorAll('.reh-fmt-btn').forEach(btn => {
    btn.addEventListener('mousedown', e => {
      e.preventDefault();
      const wrap = btn.dataset.b;
      const s = ta.selectionStart, end = ta.selectionEnd;
      const sel = ta.value.slice(s, end) || 'text';
      ta.value = ta.value.slice(0, s) + wrap + sel + wrap + ta.value.slice(end);
      ta.setSelectionRange(s + wrap.length, s + wrap.length + sel.length);
      ta.focus();
    });
  });

  targetEl.style.display = 'none';
  targetEl.before(toolbar);
  toolbar.after(ta);
  ta.focus(); ta.select();

  const save = () => {
    const newText = ta.value.trim() || orig;
    line.text = newText;
    targetEl.innerHTML = renderMarkdownInline(newText);
    targetEl.style.display = '';
    toolbar.remove(); ta.remove();
    rehState.synthCache.delete(idx);
    const dot = document.getElementById('reh-syd-' + idx);
    if (dot) dot.style.display = 'none';
  };

  ta.addEventListener('keydown', e => {
    if (e.key === 'Escape')                      { ta.value = orig; save(); }
    if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) { e.preventDefault(); save(); }
  });
  ta.addEventListener('blur', save);
}

// ── Script editor modal ─────────────────────────────────────────────────────

function openScriptEditorModal() {
  const currentTitle  = $('reh-page-title')?.textContent || $('reh-script-title')?.value || 'Script';
  const currentScript = linesToScriptText() || $('reh-script-text')?.value || '';

  const modal = document.createElement('div');
  modal.className = 'reh-modal-overlay';
  modal.innerHTML = `
    <div class="reh-modal-box" style="max-width:720px;width:95vw;height:80vh">
      <div class="reh-modal-head">
        <h3 style="margin:0;font-size:15px"><span class="mdi mdi-script-text-outline"></span> Edit Script</h3>
        <button class="btn-secondary btn-sm" id="_reh-mc">✕ Close</button>
      </div>
      <div style="padding:10px 14px;border-bottom:1px solid var(--border);display:flex;gap:10px;align-items:center">
        <label style="font-size:12px;font-weight:600;flex-shrink:0">Title</label>
        <input type="text" id="_reh-mt" value="${escHtml(currentTitle)}" style="flex:1;padding:5px 8px;border:1px solid var(--border);border-radius:4px;font-size:13px;background:var(--surface);color:var(--text)">
      </div>
      <textarea id="_reh-ms" style="flex:1;padding:14px;font-family:'Courier New',monospace;font-size:12.5px;border:none;outline:none;resize:none;background:var(--surface);color:var(--text);height:calc(80vh - 140px);width:100%;box-sizing:border-box;" spellcheck="false">${escHtml(currentScript)}</textarea>
      <div style="padding:10px 14px;display:flex;gap:8px;justify-content:flex-end;border-top:1px solid var(--border)">
        <button class="btn-secondary" id="_reh-mcan">Cancel</button>
        <button class="btn-primary" id="_reh-mapp"><span class="mdi mdi-auto-fix"></span> Apply changes</button>
      </div>
    </div>
  `;
  document.body.appendChild(modal);

  const close = () => modal.remove();
  modal.querySelector('#_reh-mc').onclick   = close;
  modal.querySelector('#_reh-mcan').onclick = close;
  modal.addEventListener('click', e => { if (e.target === modal) close(); });

  modal.querySelector('#_reh-mapp').onclick = () => {
    const newTitle  = modal.querySelector('#_reh-mt').value.trim() || 'Script';
    const newScript = modal.querySelector('#_reh-ms').value;

    const newLines = parseScript(newScript);
    if (!newLines.filter(l => l.type === 'dialog').length) {
      toast('No dialog found in the edited script', 'error'); return;
    }

    // Merge emotions for unchanged lines
    newLines.forEach(nl => {
      if (nl.type !== 'dialog') return;
      const old = rehState.lines.find(ol => ol.type==='dialog' && ol.speaker===nl.speaker && ol.text===nl.text);
      if (old) nl.emotion = old.emotion;
    });

    // Keep cast for matching characters
    const detected = detectCharacters(newLines);
    Object.entries(detected).forEach(([sp]) => {
      if (rehState.cast[sp]) detected[sp] = { ...detected[sp], ...rehState.cast[sp] };
    });

    // Update state
    rehState.lines    = newLines;
    rehState.cast     = detected;
    rehState.lineIndex = Math.min(rehState.lineIndex, newLines.length - 1);
    rehState.synthCache.clear(); rehDecodedBuffers.clear();
    rehState.practiceStart = null;
    rehState.practiceEnd   = null;

    if ($('reh-script-title')) $('reh-script-title').value = newTitle;
    if ($('reh-page-title'))   $('reh-page-title').textContent = newTitle;

    buildScriptPage();
    highlightCurrentLine();
    close();
    toast('Script updated', 'success');
  };
}

// ── Practice range ──────────────────────────────────────────────────────────

function updatePracticeRange() {
  const start = rehState.practiceStart;
  const end   = rehState.practiceEnd;

  document.querySelectorAll('.reh-block').forEach(el => {
    const idx = parseInt(el.dataset.index);
    el.classList.toggle('reh-in-range',    start !== null && idx >= start && (end === null || idx <= end));
    el.classList.toggle('reh-range-start', start !== null && idx === start);
    el.classList.toggle('reh-range-end',   end   !== null && idx === end);
    const gb = el.querySelector('.reh-gutter-btn');
    if (gb) gb.textContent = idx === start ? '▶' : idx === end ? '■' : '';
  });

  const info = $('reh-practice-info');
  if (info) {
    const show = end !== null;
    info.classList.toggle('visible', show);
    info.hidden = !show;
    if (show) {
      const f = $('reh-practice-from'), t = $('reh-practice-to');
      if (f) f.textContent = (start !== null ? start : 0) + 1;
      if (t) t.textContent = end + 1;
    }
  }
}

function clearPracticeRange() {
  rehState.practiceStart = null;
  rehState.practiceEnd   = null;
  updatePracticeRange();
}

function setPracticeRangeFromSelection() {
  const picked = [...rehState.bulkSel].sort((a, b) => a - b);
  if (!picked.length) { toast('Select the lines you want to rehearse first', 'error'); return; }
  rehState.practiceStart = picked[0];
  rehState.practiceEnd = picked[picked.length - 1];
  rehState.lineIndex = rehState.practiceStart;
  setBulkMode(false);
  updatePracticeRange();
  highlightCurrentLine();
  toast(`Practice range set: lines ${rehState.practiceStart + 1}–${rehState.practiceEnd + 1}`, 'success');
}

$('reh-practice-clear')?.addEventListener('click', clearPracticeRange);
$('reh-bulk-range')?.addEventListener('click', setPracticeRangeFromSelection);

// ── Emotion picker popover ──────────────────────────────────────────────────

let rehEmoPicker = null;

function openEmoPicker(idx, anchorBtn) {
  closeEmoPicker();
  const line     = rehState.lines[idx];
  const allEmos  = [...REH_EMOTIONS, ...rehCustomEmotions];
  const rect     = anchorBtn.getBoundingClientRect();
  const left     = Math.min(rect.left, window.innerWidth - 265);
  const topBelow = rect.bottom + 4;
  const topAbove = rect.top - 4;
  const spaceBelow = window.innerHeight - topBelow;
  const top = spaceBelow >= 240 ? topBelow : (topAbove - 260);

  const pop = document.createElement('div');
  pop.className = 'reh-emo-popover';
  pop.style.cssText = `position:fixed;z-index:1000;top:${top}px;left:${left}px;width:258px;`;
  pop.innerHTML = `<div class="reh-emo-pop-inner">
    <input class="reh-emo-search" placeholder="Search or type custom tone…" autocomplete="off">
    <div class="reh-emo-list"></div>
    <div class="reh-emo-custom-row">
      <button class="btn-secondary btn-sm" id="_emo-custom-apply" style="width:100%;font-size:11px">
        <span class="mdi mdi-plus"></span> Use as custom tone
      </button>
    </div>
  </div>`;
  document.body.appendChild(pop);
  rehEmoPicker = pop;

  const searchEl = pop.querySelector('.reh-emo-search');
  const listEl   = pop.querySelector('.reh-emo-list');
  const applyBtn = pop.querySelector('#_emo-custom-apply');

  function renderList(q = '') {
    const lq = q.toLowerCase();
    const filtered = allEmos.filter(e => !q || e.label.toLowerCase().includes(lq) || e.value.toLowerCase().includes(lq));
    listEl.innerHTML = filtered.map(e =>
      `<div class="reh-emo-item${line.emotion===e.value?' selected':''}" data-value="${escHtml(e.value)}">
        <span class="reh-emo-item-emoji">${e.emoji}</span>
        <span class="reh-emo-item-label">${escHtml(e.label)}</span>
        ${line.emotion===e.value?'<span class="mdi mdi-check" style="margin-left:auto;font-size:13px;color:var(--accent)"></span>':''}
      </div>`
    ).join('');
    listEl.querySelectorAll('.reh-emo-item').forEach(item => {
      item.addEventListener('mousedown', e => {
        e.preventDefault();
        selectEmotion(idx, item.dataset.value, anchorBtn);
        closeEmoPicker();
      });
    });
  }

  searchEl.addEventListener('input', () => renderList(searchEl.value));
  searchEl.addEventListener('keydown', e => {
    if (e.key === 'Escape') closeEmoPicker();
    if (e.key === 'Enter') {
      const val = searchEl.value.trim();
      if (val) { selectEmotion(idx, val, anchorBtn); closeEmoPicker(); }
    }
  });

  applyBtn.addEventListener('mousedown', e => {
    e.preventDefault();
    const val = searchEl.value.trim(); if (!val) return;
    const exists = [...REH_EMOTIONS, ...rehCustomEmotions].find(e => e.value === val);
    if (!exists) {
      rehCustomEmotions.push({ emoji: '✨', label: val, value: val, custom: true });
      try { localStorage.setItem('reh-custom-emotions', JSON.stringify(rehCustomEmotions)); } catch(_) {}
    }
    selectEmotion(idx, val, anchorBtn);
    closeEmoPicker();
  });

  renderList();
  searchEl.focus();

  setTimeout(() => document.addEventListener('mousedown', _closePickerOnOutside), 50);
}

function _closePickerOnOutside(e) {
  if (rehEmoPicker && !rehEmoPicker.contains(e.target)) closeEmoPicker();
}

function closeEmoPicker() {
  if (rehEmoPicker) { rehEmoPicker.remove(); rehEmoPicker = null; }
  document.removeEventListener('mousedown', _closePickerOnOutside);
}

function _markSynthDot(idx, state) {
  const dot = document.getElementById('reh-syd-' + idx);
  if (!dot) return;
  dot.className = 'reh-synth-dot'
    + (state === 'stale'       ? ' stale'       : '')
    + (state === 'synthesizing' ? ' synthesizing' : '');
  dot.style.display = state ? '' : 'none';
  dot.title = state === 'stale'        ? 'Tone changed — needs re-synthesis'
            : state === 'synthesizing' ? 'Synthesizing…'
            : 'Pre-synthesized';
  // Also highlight the block row itself while synthesizing
  const block = dot.closest('[data-index]');
  if (block) block.classList.toggle('reh-line-synthesizing', state === 'synthesizing');
}

function _showReSynthBtn(idx, show) {
  const btn = document.getElementById('reh-rsb-' + idx);
  if (btn) btn.hidden = !show;
}

// A voice reassigned in the Library/Studio Voices tab (clPut calls this
// after every character save) used to never reach an already-open
// rehearsal of the same book: rehState.cast[sp].voice is loaded once from
// the saved rehearsal record, and an explicit prior value always wins over
// a fresher one from the shared roster (see the `saved?.voice ?? def.voice`
// load above) — so the Stage/export kept reading, and kept the cached
// audio for, the OLD voice indefinitely. Confirmed live as the cause of an
// audiobook export that finished suspiciously fast right after changing a
// voice: the reassigned character's lines were still "cached" under the
// old voice and never got marked stale. Only acts when a rehearsal for the
// SAME book is actually open right now and the name matches a real speaker.
function _rehSyncCastVoiceFromLibrary(rec) {
  if (!window.rehState || !rehState.lines || !rehState.lines.length) return;
  if (!rec || !rec.name || !rec.voice) return;
  const openBook = (typeof _lineAudioBookName === 'function') ? _lineAudioBookName() : '';
  if (!openBook || String(rec.book || '').trim().toLowerCase() !== openBook.trim().toLowerCase()) return;
  const target = String(rec.name).toUpperCase().trim();
  const sp = Object.keys(rehState.cast).find(k => String(k).toUpperCase().trim() === target);
  if (!sp) return;
  const c = rehState.cast[sp];
  if (!c || c.voice === rec.voice) return;
  c.voice = rec.voice;
  c.voiceData = getVoiceData(rec.voice);
  rehState.lines.forEach((line, idx) => {
    if (line.type === 'dialog' && line.speaker === sp && rehState.synthCache.has(idx)) {
      rehState.synthCache.delete(idx);
      rehState.staleLines.add(idx);
      if (typeof _markSynthDot === 'function') _markSynthDot(idx, 'stale');
    }
  });
  if (typeof _updateStaleBatchBtn === 'function') _updateStaleBatchBtn();
  if (typeof renderCastList === 'function') renderCastList();
}
window._rehSyncCastVoiceFromLibrary = _rehSyncCastVoiceFromLibrary;

async function synthOneLine(idx) {
  const line = rehState.lines[idx];
  if (!line || line.type !== 'dialog') return;
  const c = rehState.cast[line.speaker];
  if (!c || !c.voice || c.voice === 'me') return;
  const instruct = _buildInstruct(c.instruct, line.emotion, c.voice);
  _showReSynthBtn(idx, false);
  _markSynthDot(idx, 'synthesizing');
  try {
    const blob = await fetchTtsPreviewBlob(c.voice, _rehInlineTone(stripMarkdown(line.text), line.emotion), 'wav', instruct, _ttsBackendForVoice(c.voice, rehState.backend));
    rehState.synthCache.set(idx, blob);
    rehState.staleLines.delete(idx);
    preDecodeBlob(idx, blob);
    _markSynthDot(idx, 'ok');
    toast('Re-synthesized line ' + (idx + 1), 'success');
  } catch(e) {
    _markSynthDot(idx, null);
    _showReSynthBtn(idx, true);
    toast('Synthesis failed: ' + e.message, 'error');
  }
}

function selectEmotion(idx, value, anchorBtn) {
  rehState.lines[idx].emotion = value;
  if (rehState.synthCache.has(idx)) {
    rehState.synthCache.delete(idx);
    rehState.staleLines.add(idx);
    _markSynthDot(idx, 'stale');
    _updateStaleBatchBtn();
  }
  _showReSynthBtn(idx, true);
  // Update button
  const info = getEmotionInfo(value);
  anchorBtn.className = 'reh-emo-btn' + (value ? ' has-emotion' : '');
  anchorBtn.innerHTML = `${info.emoji ? info.emoji + ' ' : ''}<span class="reh-emo-label">${escHtml(info.label)}</span> <span class="mdi mdi-chevron-down" style="font-size:9px;opacity:.6"></span>`;
  // Show warning if the active backend doesn't reliably support style
  if (value) _checkToneStyleSupport();
}

// One row of the tone/identity comparison table.
function _rehToneCmpRow(backend, isCurrent) {
  const check = (ok) => ok
    ? '<span class="reh-tone-cmp-yes"><span class="mdi mdi-check"></span></span>'
    : '<span class="reh-tone-cmp-no"><span class="mdi mdi-close"></span></span>';
  const action = isCurrent
    ? '<span class="reh-tone-cmp-current-tag">current</span>'
    : `<button type="button" class="btn-secondary btn-sm reh-tone-switch-btn" data-backend-id="${escHtml(backend.id)}">Switch</button>`;
  return `<tr${isCurrent ? ' class="reh-tone-cmp-current"' : ''}>
    <td>${escHtml(backend.label)}</td>
    <td>${check(backend.style_aware)}</td>
    <td>${check(backend.uses_wav)}</td>
    <td>${action}</td>
  </tr>`;
}

function _checkToneStyleSupport() {
  const warn = $('reh-tone-warn'); if (!warn) return;
  const txtEl = $('reh-tone-warn-txt');
  const b = (typeof backendById === 'function') ? backendById(rehState.backend) : null;
  if (!b) { warn.hidden = true; return; }
  const all = (typeof availableTtsBackends === 'function') ? availableTtsBackends() : [];
  const hasTone = rehState.lines.some(l => l.type === 'dialog' && l.emotion);

  // Two opposite engine trade-offs, surfaced so the user can choose knowingly:
  //  • clone backends  → consistent character identity, but weak tone control
  //  • design backends → strong tone, but a fresh persona each call (voices drift)
  // Originally a single run-on sentence with a button awkwardly wedged into
  // the middle of it (confirmed live: read badly, wrapped worse). A table
  // says the same two facts as two columns instead of two clauses.
  if (_rehBackendIsFish()) {
    // Fish-Speech / OpenAudio S2 honours inline [tag] tones (15 000+ tags) injected per line
    if (txtEl) txtEl.innerHTML = `<strong>${escHtml(b.label)}</strong> keeps each character’s voice consistent <em>and</em> applies tone. Per-line tones are sent as inline <code>[tags]</code> (e.g. <code>[whisper]</code>, <code>[excited]</code>, <code>[laughing]</code>). You can also type a custom tone like <code>[professional broadcast tone]</code> — S2 supports free-form descriptions. <a href="https://huggingface.co/fishaudio/s2-pro" target="_blank" rel="noopener">Fish-Speech S2 ↗</a>`;
    warn.hidden = false;
  } else if (!b.style_aware && hasTone) {
    // Prefer a backend that fixes BOTH weaknesses at once (tone-aware AND
    // clones from a reference WAV, e.g. Fish-Speech) over one that only
    // fixes this one (tone-aware but re-rolls the voice each line, e.g.
    // Voice Design) — confirmed live: with both available, `.find()` was
    // silently suggesting whichever happened to come first in the backend
    // list, which was never Fish-Speech despite it being the strictly
    // better option whenever it's actually running.
    const styleAware = all.find(x => x.style_aware && x.uses_wav) || all.find(x => x.style_aware);
    if (txtEl) {
      txtEl.innerHTML = styleAware
        ? `<table class="reh-tone-cmp"><thead><tr><th></th><th>Tone control</th><th>Voice stays identical</th><th></th></tr></thead><tbody>${_rehToneCmpRow(b, true)}${_rehToneCmpRow(styleAware, false)}</tbody></table>`
        : `<strong>${escHtml(b.label)}</strong> keeps each character’s voice consistent but has weak tone control — tone picks may have little effect.`;
    }
    warn.hidden = false;
  } else if (b.style_aware && !b.uses_wav) {
    // Same preference as above, mirrored: a wav-cloning backend that's ALSO
    // tone-aware (Fish-Speech) beats one that drops tone control entirely
    // (Voice Clone) as the suggested alternative.
    const wavBackend = all.find(x => x.uses_wav && x.style_aware) || all.find(x => x.uses_wav);
    const qwenHint = /qwen|voice design|custom/i.test((b.id || '') + ' ' + (b.label || '')) ? '<p class="reh-tone-cmp-note">Qwen3TTS tone is sent as the per-line style/instruct text, so this is the right path for directed delivery.</p>' : '';
    if (txtEl) {
      txtEl.innerHTML = wavBackend
        ? `<table class="reh-tone-cmp"><thead><tr><th></th><th>Tone control</th><th>Voice stays identical</th><th></th></tr></thead><tbody>${_rehToneCmpRow(b, true)}${_rehToneCmpRow(wavBackend, false)}</tbody></table>${qwenHint}`
        : `<strong>${escHtml(b.label)}</strong> gives strong tone but re-generates a fresh voice each line, so a character won’t sound the same throughout.${qwenHint}`;
    }
    warn.hidden = false;
  } else {
    warn.hidden = true;
  }
}

$('reh-tone-warn-close')?.addEventListener('click', () => { const w = $('reh-tone-warn'); if (w) w.hidden = true; });

// The suggestion buttons above get rebuilt (via innerHTML) every time
// _checkToneStyleSupport() re-runs, so a delegated listener on the
// container — bound once — is the only reliable way to catch clicks on them.
$('reh-tone-warn')?.addEventListener('click', (e) => {
  const btn = e.target.closest('.reh-tone-switch-btn');
  if (!btn) return;
  const id = btn.dataset.backendId;
  const sel = $('reh-backend-select');
  if (sel && [...sel.options].some(o => o.value === id)) sel.value = id;
  rehState.backend = id;
  _checkToneStyleSupport();
  const b = (typeof backendById === 'function') ? backendById(id) : null;
  toast('Switched to ' + (b ? b.label : id), 'success');
});

// ── Transport controls ──────────────────────────────────────────────────────

$('reh-tb-play')?.addEventListener('click', () => {
  if (rehState.playing) pausePlay(); else startPlay();
});

$('reh-tb-stop')?.addEventListener('click', () => {
  stopPlay();
  rehState.lineIndex = rehState.practiceStart ?? 0;
  highlightCurrentLine();
  hideRecOverlay();
});

$('reh-tb-prev')?.addEventListener('click', () => {
  stopPlay();
  rehState.lineIndex = Math.max(0, rehState.lineIndex - 1);
  highlightCurrentLine();
  hideRecOverlay();
});

$('reh-tb-next')?.addEventListener('click', () => {
  stopPlay();
  rehState.lineIndex = Math.min(rehState.lines.length - 1, rehState.lineIndex + 1);
  highlightCurrentLine();
  hideRecOverlay();
});

$('reh-tb-repeat')?.addEventListener('click', () => {
  rehState.repeat = !rehState.repeat;
  $('reh-tb-repeat')?.classList.toggle('reh-btn-active', rehState.repeat);
});

$('reh-skip-desc-toggle')?.addEventListener('change', function () { rehState.skipDescriptions = this.checked; });

$('reh-edit-script-btn')?.addEventListener('click', openScriptEditorModal);
$('reh-fountain-btn')?.addEventListener('click', exportFountain);
$('reh-fountain-export-p4')?.addEventListener('click', exportFountain);
$('reh-fdx-export-btn')?.addEventListener('click', exportFDX);
$('reh-osf-export-btn')?.addEventListener('click', exportOSF);

$('reh-exit-btn')?.addEventListener('click', () => {
  stopPlay(); stopRehMic();
  if (rehState.clips.length) { renderSummary(); showPhase(4); }
  else showPhase(2);
});

// ── Page title inline editing ───────────────────────────────────────────────

$('reh-page-title')?.addEventListener('dblclick', function () {
  this.contentEditable = 'true';
  this.style.outline = '2px solid var(--accent)';
  this.style.borderRadius = '3px';
  this.focus();
  const range = document.createRange();
  range.selectNodeContents(this);
  window.getSelection().removeAllRanges();
  window.getSelection().addRange(range);
});

$('reh-page-title')?.addEventListener('blur', function () {
  if (this.contentEditable === 'true') {
    this.contentEditable = 'false';
    this.style.outline = '';
    const v = this.textContent.trim() || 'Script';
    this.textContent = v;
    if ($('reh-script-title')) $('reh-script-title').value = v;
  }
});

$('reh-page-title')?.addEventListener('keydown', function (e) {
  if (e.key === 'Enter') { e.preventDefault(); this.blur(); }
  if (e.key === 'Escape') { this.textContent = $('reh-script-title')?.value || 'Script'; this.blur(); }
});

// ── WebAudio pre-decode (eliminates 2-3s silence between lines) ─────────────

let _rehPlayCtx   = null;
const rehDecodedBuffers = new Map(); // lineIndex → AudioBuffer (pre-decoded PCM)
let rehCurrentSource  = null;        // active AudioBufferSourceNode
let rehWordHighlightRaf = null;

function rehPlayCtx() {
  if (!_rehPlayCtx) _rehPlayCtx = new (window.AudioContext || window.webkitAudioContext)();
  if (_rehPlayCtx.state === 'suspended') _rehPlayCtx.resume().catch(() => {});
  return _rehPlayCtx;
}

// Decoded PCM (Float32) is the heaviest cache and is re-derivable from the cached
// blob, so keep only a sliding window around the playhead. Without this, a long
// script holds every line's raw PCM in memory at once and crashes mobile Safari.
const REH_DECODE_WINDOW = 8;
function _rehEvictDecoded(keepIdx) {
  if (rehDecodedBuffers.size <= REH_DECODE_WINDOW * 2 + 4) return;
  const lo = keepIdx - REH_DECODE_WINDOW, hi = keepIdx + REH_DECODE_WINDOW;
  for (const k of rehDecodedBuffers.keys()) {
    if (k < lo || k > hi) rehDecodedBuffers.delete(k);
  }
}

async function preDecodeBlob(lineIdx, blob) {
  if (rehDecodedBuffers.has(lineIdx)) return;
  try {
    const ab  = await blob.arrayBuffer();
    const buf = await rehPlayCtx().decodeAudioData(ab);
    rehDecodedBuffers.set(lineIdx, buf);
    _rehEvictDecoded(lineIdx);
  } catch(_) {}
}

function computeWordTimings(text, durationSec) {
  const words = stripMarkdown(text).split(/\s+/).filter(Boolean);
  if (words.length < 2) return [];
  // Distribute proportionally by character length (longer words = more time)
  const totalChars = words.reduce((s, w) => s + w.length, 0) || 1;
  let t = 0;
  return words.map(w => {
    const start = t;
    t += (w.length / totalChars) * durationSec;
    return { word: w, start, end: t };
  });
}

function stopAudioSource() {
  if (rehCurrentSource) {
    try { rehCurrentSource.stop(0); } catch(_) {}
    rehCurrentSource = null;
  }
  if (rehWordHighlightRaf) { cancelAnimationFrame(rehWordHighlightRaf); rehWordHighlightRaf = null; }
}

// Instant playback from pre-decoded buffer + word-level highlight
async function playPreDecoded(lineIdx, blob, text) {
  if (!rehDecodedBuffers.has(lineIdx)) await preDecodeBlob(lineIdx, blob);
  _rehEvictDecoded(lineIdx);   // keep the window centred on the playhead
  const buf = rehDecodedBuffers.get(lineIdx);
  if (!buf) { await playAudioBlobFallback(blob); return; }

  const timings = computeWordTimings(text, buf.duration);
  const dialogEl = document.getElementById('reh-diag-' + lineIdx);

  if (dialogEl && timings.length >= 2) {
    dialogEl.innerHTML = timings.map((t, i) =>
      `<span class="reh-word" data-wi="${i}">${escHtml(t.word)}</span>`
    ).join(' ');
  }

  return new Promise(resolve => {
    stopAudioSource();
    const ctx = rehPlayCtx();
    const src = ctx.createBufferSource();
    src.buffer = buf;
    src.connect(ctx.destination);
    rehCurrentSource = src;
    const t0 = ctx.currentTime;

    src.onended = () => {
      rehCurrentSource = null;
      if (rehWordHighlightRaf) { cancelAnimationFrame(rehWordHighlightRaf); rehWordHighlightRaf = null; }
      if (dialogEl && timings.length >= 2) dialogEl.innerHTML = renderMarkdownInline(text);
      resolve();
    };

    src.start(0);

    // Pre-decode the line AFTER this one while this is playing
    const nextI = findNextCachedLine(lineIdx + 1);
    if (nextI >= 0) preDecodeBlob(nextI, rehState.synthCache.get(nextI));

    if (dialogEl && timings.length >= 2) {
      const tick = () => {
        if (rehCurrentSource !== src) return;
        const elapsed = ctx.currentTime - t0;
        let active = 0;
        for (let i = timings.length - 1; i >= 0; i--) {
          if (elapsed >= timings[i].start) { active = i; break; }
        }
        dialogEl.querySelectorAll('.reh-word').forEach((span, i) => {
          span.classList.toggle('reh-word-active', i === active);
        });
        rehWordHighlightRaf = requestAnimationFrame(tick);
      };
      rehWordHighlightRaf = requestAnimationFrame(tick);
    }
  });
}

function findNextCachedLine(fromIdx) {
  for (let i = fromIdx; i < rehState.lines.length; i++) {
    if (rehState.lines[i].type === 'dialog' && rehState.synthCache.has(i)) return i;
  }
  return -1;
}

// Fallback when AudioContext decode fails
async function playAudioBlobFallback(blob) {
  const url   = URL.createObjectURL(blob);
  const audio = $('reh-tts-audio'); if (!audio) return;
  audio.src = url; audio.style.display = '';
  await new Promise(r => { audio.addEventListener('canplay', r, { once: true }); setTimeout(r, 3000); });
  await audio.play().catch(() => {});
  await waitForAudioEnd(audio);
}

// ── Auto-play sequence ──────────────────────────────────────────────────────

function startPlay() {
  rehPlayCtx(); // warm up AudioContext on user gesture
  _ensureNarrator();  // make sure rehState.narratorVoice reflects the narrator cast row
  rehState.playing = true;
  updatePlayBtn();
  playNextLine();
}

// Resets the narrator play button's icon back to "play" — separate from
// highlightCurrentLine() (which also moves the active-line highlight and
// scrolls) since pausing/stopping shouldn't jump the page around, just
// stop claiming a line is still playing.
function _rehResetActionPlayIcons() {
  document.querySelectorAll('.reh-action-play-btn').forEach(btn => {
    const icon = btn.querySelector('.mdi');
    if (icon) icon.className = 'mdi mdi-play';
    btn.title = 'Play or pause this line';
  });
}

function pausePlay() {
  rehState.playing = false;
  updatePlayBtn();
  stopAudioSource();
  const audio = $('reh-tts-audio');
  if (audio && !audio.paused) audio.pause();
  hideStatusBar();
  _rehResetActionPlayIcons();
}

function stopPlay() {
  rehState.playing = false;
  updatePlayBtn();
  stopAudioSource();
  const audio = $('reh-tts-audio');
  if (audio) { audio.pause(); audio.src = ''; }
  hideStatusBar();
  _rehResetActionPlayIcons();
}

function hideStatusBar() { const bar = $('reh-tts-status-bar'); if (bar) bar.hidden = true; }

async function playNextLine() {
  if (!rehState.playing) return;

  // Check practice end boundary
  if (rehState.practiceEnd !== null && rehState.lineIndex > rehState.practiceEnd) {
    rehState.playing = false;
    updatePlayBtn();
    if (rehState.repeat) {
      rehState.lineIndex = rehState.practiceStart ?? 0;
      startPlay();
    } else {
      rehState.lineIndex = rehState.practiceStart ?? 0;
      highlightCurrentLine();
    }
    return;
  }

  // Always skip pagebreak markers
  if (rehState.lines[rehState.lineIndex]?.type === 'pagebreak') {
    rehState.lineIndex++;
    return playNextLine();
  }

  // Skip lines the user marked ignore / hide during bulk edit
  const _cur = rehState.lines[rehState.lineIndex];
  if (_cur && (_cur.ignored || _cur.hidden)) {
    rehState.lineIndex++;
    return playNextLine();
  }

  // Skip non-dialog lines whenever skip mode is on, full stop — regardless of
  // whether a narrator voice happens to be assigned. This used to also require
  // !rehState.narratorVoice, on the theory that skipping was only meaningful
  // when there was nothing to skip TO — but the individual-line branch below
  // never re-checked skipDescriptions at all, so once ANY narrator voice was
  // configured (the common case once a book is actually set up), narration
  // played regardless of this toggle. Confirmed live: Studio's "Rehearse ⇄
  // Audiobook" toggle (which just flips this same flag) had zero observable
  // effect once a narrator voice existed — exactly the reported "doesn't
  // read the narrator" / toggle-does-nothing behavior, just inverted from
  // what it looked like (narration was stuck ON, not stuck OFF).
  if (rehState.skipDescriptions) {
    while (
      rehState.lineIndex < rehState.lines.length &&
      rehState.lines[rehState.lineIndex].type !== 'dialog' &&
      rehState.lines[rehState.lineIndex].type !== 'pagebreak' &&
      !(rehState.practiceEnd !== null && rehState.lineIndex > rehState.practiceEnd)
    ) { rehState.lineIndex++; }
  }

  if (rehState.lineIndex >= rehState.lines.length) {
    rehState.playing = false;
    updatePlayBtn();
    if (rehState.repeat) { rehState.lineIndex = 0; startPlay(); return; }
    toast('Script finished', 'success');
    return;
  }

  // Captured up front so a later `await` (waiting on a fresh TTS synthesis)
  // can tell whether the user has since clicked a DIFFERENT line's play
  // button — `rehState.lineIndex` itself gets overwritten by that click, so
  // re-reading it after the await always looks "current" even when it
  // isn't. Checking only `rehState.playing` (a bare boolean, flipped false
  // then true again by the new click's own stopPlay()/startPlay() pair
  // before this await ever resumes) let this stale continuation slip
  // through and actually play — confirmed live as the reported bug: click
  // a line while a previous, not-yet-synthesized line is still loading, and
  // once that first synthesis finally finishes it cuts in and starts
  // playing anyway, on top of (or right over) the line the user actually
  // asked for, with no way to stop just that stray one.
  const myLineIndex = rehState.lineIndex;
  const stillCurrent = () => rehState.playing && rehState.lineIndex === myLineIndex;
  const line = rehState.lines[rehState.lineIndex];
  highlightCurrentLine();

  // Non-dialog lines
  if (line.type !== 'dialog') {
    // Any line with text can be narrated — direction/transition/scene/act/action all included
    const hasText = !!(line.text || '').trim();
    if (rehState.narratorVoice && hasText && !rehState.skipDescriptions) {
      showStatusBar('Narrator: ' + line.text.slice(0, 50) + (line.text.length > 50 ? '…' : ''));
      const cached = rehState.synthCache.get(rehState.lineIndex);
      if (cached) {
        await playPreDecoded(rehState.lineIndex, cached, line.text);
      } else {
        try {
          const book = _lineAudioBookName();
          const cleanNarr = stripMarkdown(line.text);
          const cacheKey = await _lineAudioCacheKey(cleanNarr, rehState.narratorVoice, '');
          if (!stillCurrent()) return;
          let blob = await _lineAudioCacheGet(book, cacheKey);
          if (!stillCurrent()) return;
          if (!blob) {
            blob = await fetchTtsPreviewBlob(rehState.narratorVoice, cleanNarr, 'wav', '', _ttsBackendForVoice(rehState.narratorVoice, rehState.backend));
            if (!stillCurrent()) return;
            _lineAudioCachePut(book, cacheKey, blob);
          }
          rehState.synthCache.set(myLineIndex, blob);
          _markSynthDot(myLineIndex, 'ok');
          await playPreDecoded(myLineIndex, blob, line.text);
        } catch(_) { await new Promise(r => setTimeout(r, 200)); }
      }
    } else if (!rehState.skipDescriptions) {
      await new Promise(r => setTimeout(r, line.type === 'direction' ? 150 : 250));
    }
    if (!stillCurrent()) return;
    rehState.lineIndex++;
    playNextLine();
    return;
  }

  // Dialog line
  const cast = rehState.cast[line.speaker] || { voice: '' };

  if (cast.voice === 'me') {
    rehState.playing = false; updatePlayBtn();
    showRecOverlay(line);
    return;
  }

  if (!cast.voice) {
    showStatusBar(line.speaker + ' has no voice — skipping…');
    await new Promise(r => setTimeout(r, 350));
    if (!stillCurrent()) return;
    rehState.lineIndex++; playNextLine(); return;
  }

  const profile  = (cast.instruct || '').trim();
  const instruct = _buildInstruct(profile, line.emotion, cast.voice);
  const cleanTxt = stripMarkdown(line.text);

  const cached = rehState.synthCache.get(rehState.lineIndex);
  if (cached) {
    showStatusBar(line.speaker + ' is speaking…');
    await playPreDecoded(rehState.lineIndex, cached, line.text);  // ← instant: pre-decoded PCM
    rehState.clips.push({ lineIndex: rehState.lineIndex, speaker: line.speaker, type: 'tts', blob: cached });
  } else {
    showStatusBar('Synthesizing…');
    try {
      const toneText = _rehInlineTone(cleanTxt, line.emotion);
      const book = _lineAudioBookName();
      const cacheKey = await _lineAudioCacheKey(toneText, cast.voice, instruct);
      if (!stillCurrent()) return;
      let blob = await _lineAudioCacheGet(book, cacheKey);
      if (!stillCurrent()) return;
      if (!blob) {
        blob = await fetchTtsPreviewBlob(cast.voice, toneText, 'wav', instruct, _ttsBackendForVoice(cast.voice, rehState.backend));
        if (!stillCurrent()) return;
        _lineAudioCachePut(book, cacheKey, blob);
      }
      rehState.synthCache.set(myLineIndex, blob);
      showStatusBar(line.speaker + ' is speaking…');
      await playPreDecoded(myLineIndex, blob, line.text);  // also decodes + pre-fetches next
      rehState.clips.push({ lineIndex: myLineIndex, speaker: line.speaker, type: 'tts', blob });
    } catch(e) {
      showStatusBar('TTS failed: ' + e.message);
      await new Promise(r => setTimeout(r, 1000));
    }
  }

  if (!stillCurrent()) return;
  rehState.lineIndex++;
  playNextLine();
}

function waitForAudioEnd(audio) {
  return new Promise(resolve => {
    if (!audio || audio.paused || audio.ended) { resolve(); return; }
    audio.addEventListener('ended', resolve, { once: true });
    audio.addEventListener('pause',  resolve, { once: true });
    audio.addEventListener('error',  resolve, { once: true });
  });
}

function showStatusBar(msg) {
  const bar = $('reh-tts-status-bar'); if (!bar) return;
  bar.hidden = false;
  const txt = $('reh-tts-status-txt'); if (txt) txt.textContent = msg;
}

function highlightCurrentLine() {
  const i = rehState.lineIndex, total = rehState.lines.length;
  const prog = $('reh-tb-progress');
  if (prog) prog.style.width = (total ? (i / total) * 100 : 0) + '%';
  const lbl = $('reh-tb-label');
  if (lbl) lbl.textContent = `${i + 1} / ${total}`;

  document.querySelectorAll('[data-index]').forEach(el => {
    el.classList.toggle('reh-line-active', parseInt(el.dataset.index) === i);
  });

  // Dialogue's own play button shows play/pause via a pure-CSS badge
  // overlay on the avatar (.reh-line-active .reh-line-play-avatar::after),
  // but the plain narrator play button (.reh-action-play-btn, no avatar to
  // overlay onto) never got the same treatment — its icon just stayed a
  // static play triangle even while that exact line was the one actively
  // playing, with nothing to show that clicking it again would stop it.
  // Confirmed live as the reported "no way to stop it" complaint.
  document.querySelectorAll('.reh-action-play-btn').forEach(btn => {
    const icon = btn.querySelector('.mdi');
    if (!icon) return;
    const isActive = rehState.playing && parseInt(btn.dataset.index) === i;
    icon.className = isActive ? 'mdi mdi-stop' : 'mdi mdi-play';
    btn.title = isActive ? 'Stop' : 'Play or pause this line';
  });

  const active = document.querySelector(`[data-index="${i}"]`);
  if (active) active.scrollIntoView({ behavior: 'smooth', block: 'center' });
  updatePlayBtn();
}

function updatePlayBtn() {
  const btn = $('reh-tb-play'); if (!btn) return;
  btn.innerHTML = rehState.playing ? '<span class="mdi mdi-pause"></span>' : '<span class="mdi mdi-play"></span>';
  btn.title     = rehState.playing ? 'Pause' : 'Play all';
}

// ── Persistent per-paragraph audio cache ────────────────────────────────────
//
// rehState.synthCache only ever lived in the browser tab's memory — closing
// the tab, reloading, or a crash threw away everything "Synth all" had
// already paid GPU time for, forcing a full re-synthesis (and the pause
// between paragraphs that comes with it) the next time regardless. This
// persists each line's audio to disk, keyed by a hash of exactly what
// determines its sound (text + voice + tone/instruct) rather than its
// position in the script. An untouched paragraph's key never changes, so it
// keeps reusing the same cached file indefinitely; an edited paragraph's
// key changes the instant the text (or voice/tone) does, so it simply never
// matches a cached file again and gets synthesized fresh next time — no
// separate "delete the old file" step needed, the old file just becomes
// unreachable dead weight rather than ever being served again.
async function _lineAudioCacheKey(text, voice, instruct) {
  const enc = new TextEncoder().encode(`${text}${voice}${instruct || ''}`);
  const digest = await crypto.subtle.digest('SHA-256', enc);
  return [...new Uint8Array(digest)].map(b => b.toString(16).padStart(2, '0')).join('').slice(0, 32);
}
function _lineAudioBookName() {
  return $('reh-script-title')?.value.trim() || 'Untitled';
}
async function _lineAudioCacheGet(book, key) {
  try {
    const r = await fetch(`/api/line-audio/${encodeURIComponent(book)}/${key}`);
    if (!r.ok) return null;
    return await r.blob();
  } catch (_) { return null; }
}
function _lineAudioCachePut(book, key, blob) {
  // Fire-and-forget — a failed save just means this line resynthesizes next
  // time too, no worse than before this cache existed at all.
  fetch(`/api/line-audio/${encodeURIComponent(book)}/${key}`, { method: 'POST', body: blob }).catch(() => {});
}

// Every line's "pre-synthesized" green dot only ever reflected
// rehState.synthCache — this browser tab's own memory, empty on every fresh
// page load — so a script that was fully "Synth all"-ed and safely
// persisted to disk in an EARLIER session still looked completely
// unsynthesized after a reload, with no way to tell the cached audio was
// actually right there. This asks the server, in one batch request, which
// of the current script's lines already have a matching file, and lights
// up their dots — without downloading any actual audio (that still only
// happens lazily, right when a line is about to play).
let _lineAudioSyncedFor = null; // `${book}::${lineCount}` — avoid re-running the same scan on every small re-render
async function _lineAudioSyncDots() {
  const book = _lineAudioBookName();
  const scanId = `${book}::${rehState.lines.length}`;
  if (_lineAudioSyncedFor === scanId) return;
  _lineAudioSyncedFor = scanId;
  _ensureNarrator();
  const idxToKey = new Map();
  for (let i = 0; i < rehState.lines.length; i++) {
    const line = rehState.lines[i];
    if (line.ignored || line.hidden) continue;
    if (rehState.synthCache.has(i)) continue; // already known-good this session
    let voice, instruct, text;
    if (line.type === 'dialog') {
      const c = rehState.cast[line.speaker];
      if (!c || !c.voice || c.voice === 'me') continue;
      voice = c.voice;
      instruct = _buildInstruct(c.instruct, line.emotion, c.voice);
      text = _rehInlineTone(stripMarkdown(line.text), line.emotion);
    } else {
      if (!rehState.narratorVoice || !(line.text || '').trim()) continue;
      voice = rehState.narratorVoice; instruct = '';
      text = stripMarkdown(line.text);
    }
    idxToKey.set(i, await _lineAudioCacheKey(text, voice, instruct));
  }
  if (!idxToKey.size) return;
  const keyToIdx = new Map([...idxToKey].map(([i, k]) => [k, i]));
  try {
    const r = await fetch(`/api/line-audio/${encodeURIComponent(book)}/check`, {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ keys: [...idxToKey.values()] }),
    });
    if (!r.ok) return;
    const { existing } = await r.json();
    (existing || []).forEach(key => {
      const idx = keyToIdx.get(key);
      if (idx == null) return;
      rehState.staleLines.delete(idx);
      _markSynthDot(idx, 'ok');
    });
  } catch (_) { /* dots just stay as-is; playback still checks the disk cache lazily either way */ }
}

// ── Synthesize All ─────────────────────────────────────────────────────────

async function synthAll() {
  if (rehState.synthRunning) return;
  if (!rehState.backend) { toast('Select a TTS backend first', 'error'); return; }
  _ensureNarrator();  // sync narrator voice from its cast row before synthesizing

  const ttsLines = rehState.lines.map((l, i) => ({ line:l, idx:i })).filter(({ line }) => {
    if (line.ignored || line.hidden) return false;  // bulk-edit: never synth ignored/hidden lines
    if (line.type === 'dialog') {
      const c = rehState.cast[line.speaker];
      return c && c.voice && c.voice !== 'me';
    }
    // All non-dialog lines with text are narrated when a narrator voice is set
    return !!(rehState.narratorVoice && (line.text || '').trim());
  });

  if (!ttsLines.length) { toast('No TTS lines to synthesize', 'error'); return; }

  rehState.synthRunning = true; rehState.synthCancelled = false;
  const synthBar = $('reh-synth-bar'), fill = $('reh-synth-fill'), label = $('reh-synth-label');
  if (synthBar) synthBar.hidden = false;

  const prog = (d, t) => {
    if (fill)  fill.style.width   = (t ? (d/t)*100 : 0) + '%';
    if (label) label.textContent  = `${d} / ${t} synthesized`;
  };
  prog(0, ttsLines.length);

  let done = 0;
  const book = _lineAudioBookName();
  // Wrapped in try/finally so a thrown error (e.g. the speaker's cast entry
  // got deleted mid-run — see the `!c` guard below) can never leave
  // synthRunning stuck true forever, which would silently no-op every future
  // "Synthesize All" / "Re-synthesize stale" click with no error shown, same
  // failure shape as the character-sheets generation-lock bug fixed earlier.
  try {
    for (const { line, idx } of ttsLines) {
      if (rehState.synthCancelled) break;
      let voice, instruct;
      if (line.type === 'dialog') {
        const c = rehState.cast[line.speaker];
        if (!c || !c.voice || c.voice === 'me') { _markSynthDot(idx, null); prog(++done, ttsLines.length); continue; }
        voice    = c.voice;
        instruct = _buildInstruct(c.instruct, line.emotion, c.voice);
      } else {
        voice = rehState.narratorVoice; instruct = '';
      }
      _markSynthDot(idx, 'synthesizing');
      document.getElementById('reh-syd-' + idx)?.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
      const toneText = _rehInlineTone(stripMarkdown(line.text), line.emotion);
      try {
        const cacheKey = await _lineAudioCacheKey(toneText, voice, instruct);
        let blob = await _lineAudioCacheGet(book, cacheKey);
        if (!blob) {
          blob = await fetchTtsPreviewBlob(voice, toneText, 'wav', instruct, _ttsBackendForVoice(voice, rehState.backend));
          _lineAudioCachePut(book, cacheKey, blob);
        }
        rehState.synthCache.set(idx, blob);
        rehState.staleLines.delete(idx);
        _markSynthDot(idx, 'ok');
        _showReSynthBtn(idx, false);
        preDecodeBlob(idx, blob);  // decode to PCM immediately → zero-latency playback
      } catch(_) { _markSynthDot(idx, null); }
      prog(++done, ttsLines.length);
    }
  } finally {
    if (synthBar) synthBar.hidden = true;
    rehState.synthRunning = false;
  }
  if (!rehState.synthCancelled) toast(`Pre-synthesized ${done} of ${ttsLines.length} lines — ready for instant playback`, 'success');
}

function _updateStaleBatchBtn() {
  const btn = $('reh-tb-resynth-stale');
  if (btn) btn.hidden = rehState.staleLines.size === 0;
}

$('reh-tb-synth-all')?.addEventListener('click', () => synthAll());
$('reh-tb-resynth-stale')?.addEventListener('click', async () => {
  if (rehState.synthRunning) return;
  const stale = [...rehState.staleLines];
  if (!stale.length) return;
  rehState.synthRunning = true; rehState.synthCancelled = false;
  const synthBar = $('reh-synth-bar'), fill = $('reh-synth-fill'), label = $('reh-synth-label');
  if (synthBar) synthBar.hidden = false;
  let done = 0;
  const book = _lineAudioBookName();
  try {
    for (const idx of stale) {
      if (rehState.synthCancelled) break;
      const line = rehState.lines[idx];
      if (!line || line.type !== 'dialog') { rehState.staleLines.delete(idx); continue; }
      const c = rehState.cast[line.speaker];
      if (!c || !c.voice || c.voice === 'me') { rehState.staleLines.delete(idx); continue; }
      const instruct = [c.instruct||'', line.emotion||''].filter(Boolean).join('. ');
      _markSynthDot(idx, 'synthesizing');
      const toneText = _rehInlineTone(stripMarkdown(line.text), line.emotion);
      try {
        const cacheKey = await _lineAudioCacheKey(toneText, c.voice, instruct);
        let blob = await _lineAudioCacheGet(book, cacheKey);
        if (!blob) {
          blob = await fetchTtsPreviewBlob(c.voice, toneText, 'wav', instruct, _ttsBackendForVoice(c.voice, rehState.backend));
          _lineAudioCachePut(book, cacheKey, blob);
        }
        rehState.synthCache.set(idx, blob);
        rehState.staleLines.delete(idx);
        preDecodeBlob(idx, blob);
        _markSynthDot(idx, 'ok');
        _showReSynthBtn(idx, false);
      } catch(_) { _markSynthDot(idx, 'stale'); }
      if (fill)  fill.style.width  = ((++done / stale.length) * 100) + '%';
      if (label) label.textContent = `${done} / ${stale.length} synthesized`;
    }
  } finally {
    if (synthBar) synthBar.hidden = true;
    rehState.synthRunning = false;
    _updateStaleBatchBtn();
  }
  if (!rehState.synthCancelled) toast(`Re-synthesized ${done} stale line${done !== 1 ? 's' : ''}`, 'success');
});
$('reh-synth-cancel')?.addEventListener('click', () => { rehState.synthCancelled = true; rehState.synthRunning = false; });

// Editing a paragraph doesn't delete its OLD cached audio file — the write
// path only ever knows the NEW content's hash, not whatever the line used
// to hash to before the edit, so the stale file just sits there unreferenced
// forever. This computes every key the CURRENT script would actually use
// and asks the server to delete anything else on disk for this book.
$('reh-tb-clean-cache')?.addEventListener('click', async () => {
  const btn = $('reh-tb-clean-cache');
  if (btn) { btn.disabled = true; btn.innerHTML = '<span class="mdi mdi-loading mdi-spin"></span> Scanning…'; }
  try {
    _ensureNarrator();
    const keep = [];
    for (const line of rehState.lines) {
      if (line.ignored || line.hidden) continue;
      let voice, instruct, text;
      if (line.type === 'dialog') {
        const c = rehState.cast[line.speaker];
        if (!c || !c.voice || c.voice === 'me') continue;
        voice = c.voice;
        instruct = _buildInstruct(c.instruct, line.emotion, c.voice);
        text = _rehInlineTone(stripMarkdown(line.text), line.emotion);
      } else {
        if (!rehState.narratorVoice || !(line.text || '').trim()) continue;
        voice = rehState.narratorVoice; instruct = '';
        text = stripMarkdown(line.text);
      }
      keep.push(await _lineAudioCacheKey(text, voice, instruct));
    }
    const book = _lineAudioBookName();
    const r = await fetch(`/api/line-audio/${encodeURIComponent(book)}/prune`, {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ keep }),
    });
    if (!r.ok) throw new Error((await r.json().catch(() => ({}))).detail || r.statusText);
    const d = await r.json();
    toast(d.deleted ? `Cleaned up ${d.deleted} unused cached audio file${d.deleted !== 1 ? 's' : ''}` : 'Nothing to clean up — every cached file is still in use', 'success');
  } catch (e) {
    toast('Cache cleanup failed: ' + (e.message || e), 'error');
  } finally {
    if (btn) { btn.disabled = false; btn.innerHTML = '<span class="mdi mdi-broom"></span> Clean cache'; }
  }
});

// ── Recording overlay ───────────────────────────────────────────────────────

function showRecOverlay(line) {
  const overlay = $('reh-rec-overlay'); if (!overlay) return;
  overlay.hidden = false;
  const cue = $('reh-rec-cue'), c = rehState.cast[line.speaker] || { color: '#89b4fa' };
  if (cue) cue.innerHTML = `<span class="reh-rec-cue-name" style="color:${c.color}">${escHtml(line.speaker)}</span> — your line:<div class="reh-rec-cue-text">${escHtml(stripMarkdown(line.text))}</div>`;
  if ($('reh-rec-preview'))     { $('reh-rec-preview').style.display='none'; $('reh-rec-preview').src=''; }
  if ($('reh-rec-confirm-row')) $('reh-rec-confirm-row').hidden = true;
  if ($('reh-rec-start'))       $('reh-rec-start').disabled = false;
  if ($('reh-rec-stop'))        $('reh-rec-stop').disabled  = true;
  if ($('reh-rec-time'))        $('reh-rec-time').textContent = '0:00';
  rehState.lastRecBlob = null;
}

function hideRecOverlay() {
  const overlay = $('reh-rec-overlay'); if (overlay) overlay.hidden = true;
  stopRehMic();
}

// ── Mic recording ───────────────────────────────────────────────────────────

function rehRenderMeter(level=0, db=-Infinity, clipped=false) {
  const meter = $('reh-mic-meter'); if (!meter) return;
  if (!meter.children.length) for (let i=0;i<18;i++){const b=document.createElement('div');b.className='bar';meter.appendChild(b);}
  const active = Math.round(Math.max(0,Math.min(1,level))*meter.children.length);
  [...meter.children].forEach((bar,i)=>{
    bar.className='bar'; bar.style.height=(7+Math.min(i,active)*1.55)+'px';
    if(i<active){bar.classList.add('on');if(db>-12&&i>11)bar.classList.add('hot');if(clipped&&i>14)bar.classList.add('clip');}
  });
  const el=$('reh-db-readout');if(el)el.textContent=Number.isFinite(db)?db.toFixed(1)+' dB':'-∞ dB';
}

function rehStartMeter() {
  if (!rehState.recAnalyser) return;
  if (rehState.recMeterRaf) cancelAnimationFrame(rehState.recMeterRaf);
  const data=new Float32Array(rehState.recAnalyser.fftSize), canvas=$('reh-live-wave'), RING=300, ADD=10;
  rehState.recWaveRing = new Float32Array(RING);
  const tick=()=>{
    rehState.recAnalyser.getFloatTimeDomainData(data);
    let sum=0,peak=0; for(const s of data){sum+=s*s;peak=Math.max(peak,Math.abs(s));}
    const rms=Math.sqrt(sum/data.length), db=rms>0?20*Math.log10(rms):-Infinity;
    rehRenderMeter((db+60)/60,db,peak>0.98);
    if(canvas&&rehState.recWaveRing){
      const ring=rehState.recWaveRing; ring.copyWithin(0,ADD);
      for(let i=0;i<ADD;i++) ring[RING-ADD+i]=data[Math.floor(i*data.length/ADD)];
      const ctx=canvas.getContext('2d'),w=canvas.width,h=canvas.height;
      ctx.clearRect(0,0,w,h); ctx.beginPath();
      ctx.strokeStyle=peak>0.98?'#f38ba8':db>-12?'#f9e2af':'#a6e3a1'; ctx.lineWidth=1.5;
      const mid=h/2;
      for(let i=0;i<RING;i++){const x=(i/RING)*w,y=mid-ring[i]*mid*0.85;i===0?ctx.moveTo(x,y):ctx.lineTo(x,y);}
      ctx.stroke();
    }
    rehState.recMeterRaf=requestAnimationFrame(tick);
  };
  tick();
}

async function startRehMic() {
  if (rehState.recDestStream) return;
  const AudioCtx = window.AudioContext || window.webkitAudioContext;
  rehState.recStream = await requestMicrophoneStream({ raw: true });
  if (AudioCtx) {
    rehState.recAudioCtx   = new AudioCtx();
    rehState.recSourceNode = rehState.recAudioCtx.createMediaStreamSource(rehState.recStream);
    rehState.recGainNode   = rehState.recAudioCtx.createGain();
    rehState.recAnalyser   = rehState.recAudioCtx.createAnalyser();
    rehState.recAnalyser.fftSize = 1024;
    const dest = rehState.recAudioCtx.createMediaStreamDestination();
    rehState.recSourceNode.connect(rehState.recGainNode);
    rehState.recGainNode.connect(rehState.recAnalyser);
    rehState.recGainNode.connect(dest);
    rehState.recDestStream = dest.stream;
    rehStartMeter();
  } else { rehState.recDestStream = rehState.recStream; }
}

function stopRehMic() {
  if (rehState.recMeterRaf) cancelAnimationFrame(rehState.recMeterRaf);
  rehState.recMeterRaf = null;
  [rehState.recSourceNode,rehState.recGainNode,rehState.recAnalyser].forEach(n=>{try{if(n)n.disconnect();}catch(_){}});
  if (rehState.recStream)     rehState.recStream.getTracks().forEach(t=>t.stop());
  if (rehState.recDestStream) rehState.recDestStream.getTracks().forEach(t=>t.stop());
  if (rehState.recAudioCtx)   rehState.recAudioCtx.close().catch(()=>{});
  Object.assign(rehState,{recStream:null,recDestStream:null,recSourceNode:null,recGainNode:null,recAnalyser:null,recAudioCtx:null,recWaveRing:null});
  rehRenderMeter();
  const wc=$('reh-live-wave');if(wc)wc.getContext('2d').clearRect(0,0,wc.width,wc.height);
}

$('reh-rec-start')?.addEventListener('click', async () => {
  try {
    await startRehMic();
    rehState.recChunks=[]; rehState.recSecs=0;
    if($('reh-rec-time'))$('reh-rec-time').textContent='0:00';
    if($('reh-rec-start'))$('reh-rec-start').disabled=true;
    if($('reh-rec-stop'))$('reh-rec-stop').disabled=false;
    if($('reh-rec-confirm-row'))$('reh-rec-confirm-row').hidden=true;
    rehState.recTimer=setInterval(()=>{
      rehState.recSecs++;
      if($('reh-rec-time'))$('reh-rec-time').textContent=Math.floor(rehState.recSecs/60)+':'+String(rehState.recSecs%60).padStart(2,'0');
    },1000);
    rehState.mediaRec=new MediaRecorder(rehState.recDestStream||rehState.recStream,{audioBitsPerSecond:256000});
    rehState.mediaRec.ondataavailable=e=>{if(e.data.size)rehState.recChunks.push(e.data);};
    rehState.mediaRec.onstop=()=>{
      clearInterval(rehState.recTimer);
      if($('reh-rec-start'))$('reh-rec-start').disabled=false;
      if($('reh-rec-stop'))$('reh-rec-stop').disabled=true;
      const blob=new Blob(rehState.recChunks,{type:rehState.mediaRec.mimeType||'audio/webm'});
      const url=URL.createObjectURL(blob);
      const p=$('reh-rec-preview');if(p){p.src=url;p.style.display='';}
      if($('reh-rec-confirm-row'))$('reh-rec-confirm-row').hidden=false;
      rehState.lastRecBlob=blob;
    };
    rehState.mediaRec.start(100);
  } catch(e){stopRehMic();toast(await microphoneErrorMessage(e),'error');}
});

$('reh-rec-stop')?.addEventListener('click', () => { if(rehState.mediaRec?.state!=='inactive')rehState.mediaRec.stop(); });

$('reh-rec-keep')?.addEventListener('click', () => {
  if (rehState.lastRecBlob)
    rehState.clips.push({lineIndex:rehState.lineIndex, speaker:rehState.lines[rehState.lineIndex]?.speaker, type:'me', blob:rehState.lastRecBlob});
  stopRehMic(); hideRecOverlay();
  rehState.lineIndex++;
  startPlay();
});

$('reh-rec-redo')?.addEventListener('click', () => { stopRehMic(); const l=rehState.lines[rehState.lineIndex]; if(l)showRecOverlay(l); });

$('reh-skip-line')?.addEventListener('click', () => {
  rehState.clips.push({lineIndex:rehState.lineIndex, speaker:rehState.lines[rehState.lineIndex]?.speaker, type:'skip'});
  stopRehMic(); hideRecOverlay();
  rehState.lineIndex++;
  startPlay();
});

// ── Phase 4: Summary ────────────────────────────────────────────────────────

function renderSummary() {
  const list = $('reh-summary-list'); if (!list) return;
  if (!rehState.clips.length) { list.innerHTML='<p class="note">No clips in this session.</p>'; return; }
  list.innerHTML = rehState.clips.map((clip,idx)=>{
    const line=rehState.lines[clip.lineIndex]||{text:'—',speaker:clip.speaker};
    const c=rehState.cast[clip.speaker]||{color:'#89b4fa'};
    const typeLabel=clip.type==='me'?'🎤 Recorded':clip.type==='tts'?'🔊 Synthesized':'⏭ Skipped';
    const audioHtml=clip.blob?`<audio controls src="${URL.createObjectURL(clip.blob)}" style="width:100%;max-width:320px;margin-top:4px"></audio>`:'';
    const dlHtml=clip.blob?`<a class="btn-secondary" style="text-decoration:none;flex-shrink:0" download="line_${idx+1}_${clip.speaker}.webm" href="${URL.createObjectURL(clip.blob)}"><span class="mdi mdi-download"></span></a>`:'';
    return `<div class="reh-summary-row">
      <span style="width:10px;height:10px;border-radius:50%;background:${c.color};flex-shrink:0;margin-top:4px"></span>
      <div style="flex:1;min-width:0">
        <div style="font-weight:600;font-size:13px;color:${c.color}">${escHtml(clip.speaker||'—')} <span style="font-weight:400;color:var(--subtext)">${typeLabel}</span></div>
        <div style="font-size:13px;line-height:1.4;margin-top:2px">${escHtml(stripMarkdown(line.text))}</div>
        ${audioHtml}
      </div>
      ${dlHtml}
    </div>`;
  }).join('');
}

$('reh-new-session-btn')?.addEventListener('click', () => {
  stopPlay(); stopRehMic();
  rehState.lines=[]; rehState.cast={}; rehState.clips=[]; rehState.lineIndex=0;
  rehState.savedId=null; rehState.synthCache.clear(); rehDecodedBuffers.clear(); rehState.narratorVoice='';
  rehState.practiceStart=null; rehState.practiceEnd=null;
  if($('reh-script-text'))$('reh-script-text').value='';
  if($('reh-script-title'))$('reh-script-title').value='';
  renderLibraryList(); showPhase(1);
});

$('reh-resume-btn')?.addEventListener('click', ()=>{showPhase(3);highlightCurrentLine();});
$('reh-save-session-btn')?.addEventListener('click',  saveToLibrary);
$('reh-cast-save-btn')?.addEventListener('click',     saveToLibrary);
$('reh-export-session-btn')?.addEventListener('click', exportToFile);
$('reh-tb-save')?.addEventListener('click',            saveToLibrary);
$('reh-tb-export')?.addEventListener('click',           exportToFile);

$('reh-lib-import-file')?.addEventListener('change', async function(){
  const f=this.files?.[0]; if(!f)return;
  await importFromFile(f); this.value='';
});

// ── Import/Export panel wiring ─────────────────────────────────────────────
document.querySelectorAll('.reh-impex-file').forEach(inp => {
  inp.addEventListener('change', async function () {
    const f = this.files?.[0]; if (!f) return;
    await importFromFile(f);
    this.value = '';
    // After import, return to Library
    navRehearserPhase(1);
  });
});
$('reh-impex-reh-btn')?.addEventListener('click',     exportToFile);
$('reh-impex-fountain-btn')?.addEventListener('click', () => { $('reh-fountain-btn')?.click(); });
$('reh-impex-fdx-btn')?.addEventListener('click',     () => { $('reh-fdx-export-btn')?.click(); });
$('reh-impex-osf-btn')?.addEventListener('click',     () => { $('reh-osf-export-btn')?.click(); });

// ── Plain-text + Markdown export ───────────────────────────────────────────
function _downloadText(content, filename) {
  const a = document.createElement('a');
  a.href = URL.createObjectURL(new Blob([content], { type: 'text/plain;charset=utf-8' }));
  a.download = filename; a.click(); setTimeout(() => URL.revokeObjectURL(a.href), 3000);
}

function exportAsTxt() {
  const title = $('reh-script-title')?.value.trim() || $('reh-page-title')?.textContent || 'script';
  _downloadText(linesToScriptText(), title.replace(/[^a-z0-9]/gi, '_') + '.txt');
}

function exportAsMd() {
  const title = $('reh-script-title')?.value.trim() || 'Script';
  const lines = rehState.lines.map(l => {
    switch (l.type) {
      case 'act':        return `\n# ${l.text}\n`;
      case 'scene':      return `\n## ${l.text}\n`;
      case 'transition': return `\n*${l.text}*\n`;
      case 'direction':  return `*(${l.text})*`;
      case 'action':     return `\n${l.text}\n`;
      case 'dialog':     return `\n**${l.speaker}**\n${l.text}\n`;
      default: return '';
    }
  }).join('\n');
  _downloadText(`# ${title}\n\n${lines.trim()}\n`, title.replace(/[^a-z0-9]/gi, '_') + '.md');
}

$('reh-impex-txt-btn')?.addEventListener('click', exportAsTxt);
$('reh-impex-md-btn')?.addEventListener('click',  exportAsMd);

// ── IMSDb / URL import ─────────────────────────────────────────────────────
(function initUrlImport() {
  const inp    = $('reh-impex-url');
  const btn    = $('reh-impex-url-btn');
  const status = $('reh-impex-url-status');
  if (!inp || !btn) return;

  async function fetchUrl() {
    const url = inp.value.trim();
    if (!url) { toast('Paste a URL first', 'error'); return; }
    btn.disabled = true;
    if (status) { status.textContent = 'Fetching…'; status.style.color = ''; }
    try {
      const r = await fetch('/api/fetch-web-script', {
        method: 'POST', headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ url }),
      });
      if (!r.ok) { const e = await r.json().catch(()=>({})); throw new Error(e.detail || r.statusText); }
      const d = await r.json();
      // Put script into the textarea and set title
      const ta = $('reh-script-text');
      if (ta) ta.value = d.text;
      const titleInp = $('reh-script-title');
      if (titleInp && d.title) titleInp.value = d.title.replace(/-/g,' ').replace(/\b\w/g,c=>c.toUpperCase());
      if (status) {
        status.textContent = `✓ Fetched ${(d.chars/1000).toFixed(0)} K chars — scroll down to Parse & cast`;
        status.style.color = 'var(--green)';
      }
      // Navigate to Library phase so user sees the script text area
      navRehearserPhase(1);
      // Scroll the script textarea into view
      setTimeout(() => ta?.scrollIntoView({ behavior:'smooth', block:'nearest' }), 300);
      toast(`Fetched "${d.title}" — click "Parse & cast" to continue`, 'success');
    } catch(e) {
      if (status) { status.textContent = '✗ ' + e.message; status.style.color = 'var(--red)'; }
      toast('Fetch failed: ' + e.message, 'error');
    } finally { btn.disabled = false; }
  }

  btn.addEventListener('click', fetchUrl);
  inp.addEventListener('keydown', e => { if (e.key === 'Enter') fetchUrl(); });
})();

// ── IMSDb library browser (poster grid) ────────────────────────────────────
(function initImsdbBrowser() {
  const modal    = $('reh-imsdb-modal');
  const grid     = $('reh-imsdb-grid');
  const search   = $('reh-imsdb-search');
  const countEl  = $('reh-imsdb-count');
  const closeBtn = $('reh-imsdb-close');
  const coverBtn = $('reh-imsdb-cover-btn');
  const listBtn  = $('reh-imsdb-list-btn');
  const urlInp   = $('reh-imsdb-url');
  const urlBtn   = $('reh-imsdb-url-fetch');
  if (!modal || !grid) return;

  const CACHE_KEY = 'reh-imsdb-cat-v1';
  const CACHE_TTL = 6 * 3600 * 1000;

  let _catalogue = null;
  let _posterObserver = null;
  let _view = localStorage.getItem('reh-imsdb-view') || 'list'; // 'cover' | 'list'

  function _applyView() {
    grid.classList.toggle('list-view', _view === 'list');
    if (coverBtn) coverBtn.classList.toggle('active', _view === 'cover');
    if (listBtn)  listBtn.classList.toggle('active', _view === 'list');
  }

  function _ensurePosterObserver() {
    if (_posterObserver) return _posterObserver;
    _posterObserver = new IntersectionObserver((entries) => {
      entries.forEach(async (ent) => {
        if (!ent.isIntersecting) return;
        const card = ent.target;
        _posterObserver.unobserve(card);
        const title = card.dataset.title;
        try {
          const d = await fetch('/api/movie-poster?title=' + encodeURIComponent(title)).then(r => r.json());
          if (d.poster) {
            const img = document.createElement('img');
            img.className = 'reh-imsdb-poster';
            img.loading = 'lazy'; img.src = d.poster; img.alt = title;
            img.onload = () => {
              const wrap = card.querySelector('.reh-imsdb-poster-wrap');
              if (wrap) {
                wrap.querySelector('.reh-imsdb-fallback')?.remove();
                wrap.appendChild(img);
              }
            };
          }
          if (d.year) {
            card.querySelectorAll('.reh-imsdb-year').forEach(y => { y.textContent = d.year; });
          }
        } catch(_) {}
      });
    }, { root: grid, rootMargin: '300px' });
    return _posterObserver;
  }

  function _bookColor(title) {
    let h = 0; for (let i = 0; i < title.length; i++) h = (h * 31 + title.charCodeAt(i)) >>> 0;
    return `hsl(${h % 360}, 45%, 42%)`;
  }

  function renderGrid(items) {
    const obs = _ensurePosterObserver();
    grid.innerHTML = '';
    if (!items.length) { grid.innerHTML = '<div class="reh-imsdb-loading">No matches.</div>'; return; }
    const frag = document.createDocumentFragment();
    items.slice(0, 400).forEach(it => {
      const card = document.createElement('div');
      card.className = 'reh-imsdb-card';
      card.dataset.title = it.title;
      card.dataset.url = it.fetch_url;
      const color1 = _bookColor(it.title);
      const color2 = _bookColor(it.title + '_');
      card.innerHTML = `
        <div class="reh-imsdb-poster-wrap">
          <div class="reh-imsdb-fallback" style="background:linear-gradient(160deg, ${color1}, ${color2})">
            <span class="mdi mdi-movie-roll"></span>
            <span class="reh-imsdb-fallback-title">${escHtml(it.title)}</span>
          </div>
        </div>
        <div class="reh-imsdb-meta">
          <span class="reh-imsdb-title">${escHtml(it.title)}</span>
          <span class="reh-imsdb-year"></span>
        </div>`;
      card.addEventListener('click', () => importImsdb(it));
      frag.appendChild(card);
      obs.observe(card);
    });
    grid.appendChild(frag);
    if (countEl) countEl.textContent = `${items.length} script${items.length!==1?'s':''}${items.length>400?' (showing 400)':''}`;
    _applyView();
  }

  async function importAnyWebUrl(url, label = 'script') {
    url = String(url || '').trim();
    if (!url) { toast('Paste a script URL first', 'error'); return; }
    if (!/^https?:\/\//i.test(url)) { toast('URL must start with http:// or https://', 'error'); return; }
    if (urlBtn) urlBtn.disabled = true;
    grid.innerHTML = `<div class="reh-imsdb-loading"><span class="reh-imsdb-spinner"></span> Fetching ${escHtml(label)}…</div>`;
    try {
      const r = await fetch('/api/fetch-web-script', {
        method: 'POST', headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ url }),
      });
      if (!r.ok) { const e = await r.json().catch(()=>({})); throw new Error(e.detail || r.statusText); }
      const d = await r.json();
      const ta = $('reh-script-text'); if (ta) ta.value = d.text;
      const ti = $('reh-script-title'); if (ti) ti.value = d.title || label;
      closeModal();
      navRehearserPhase(1);
      setTimeout(() => ta?.scrollIntoView({ behavior:'smooth', block:'center' }), 250);
      toast(`Loaded "${d.title || label}" (${(d.chars/1000).toFixed(0)} K) — click "Parse & cast"`, 'success');
    } catch(e) {
      grid.innerHTML = `<div class="reh-imsdb-load-error">Fetch failed: ${escHtml(e.message)}</div>`;
      if (_catalogue) renderGrid(_searchFilter(_catalogue));
      toast('Script fetch failed: ' + e.message, 'error');
    } finally {
      if (urlBtn) urlBtn.disabled = false;
    }
  }

  async function importImsdb(it) {
    await importAnyWebUrl(it.fetch_url, it.title || 'IMSDb script');
  }

  async function _loadCatalogue() {
    // Try localStorage cache first
    try {
      const raw = localStorage.getItem(CACHE_KEY);
      if (raw) {
        const cached = JSON.parse(raw);
        if (Date.now() - cached.ts < CACHE_TTL && Array.isArray(cached.items) && cached.items.length) {
          _catalogue = cached.items;
          return;
        }
      }
    } catch(_) {}
    // Fetch from server
    const d = await fetch('/api/imsdb/list').then(r => r.json());
    _catalogue = d.items || [];
    try {
      localStorage.setItem(CACHE_KEY, JSON.stringify({ ts: Date.now(), items: _catalogue }));
    } catch(_) {}
  }

  async function openModal() {
    modal.hidden = false;
    if (urlInp) urlInp.value = '';
    _applyView();
    if (!_catalogue) {
      grid.innerHTML = '<div class="reh-imsdb-loading"><span class="reh-imsdb-spinner"></span> Loading catalogue…</div>';
      try {
        await _loadCatalogue();
      } catch(e) {
        grid.innerHTML = `<div class="reh-imsdb-loading">Failed to load: ${escHtml(e.message)}</div>`;
        return;
      }
    }
    renderGrid(_searchFilter(_catalogue));
    search?.focus();
  }

  function closeModal() { modal.hidden = true; }

  function _searchFilter(items) {
    const q = search?.value.trim().toLowerCase() || '';
    return q ? items.filter(it => it.title.toLowerCase().includes(q)) : items;
  }

  let _searchTimer = null;
  search?.addEventListener('input', () => {
    clearTimeout(_searchTimer);
    _searchTimer = setTimeout(() => {
      if (!_catalogue) return;
      renderGrid(_searchFilter(_catalogue));
    }, 150);
  });
  search?.addEventListener('keydown', e => {
    if (e.key === 'Enter' && /^https?:\/\//i.test(search.value.trim())) {
      e.preventDefault();
      importAnyWebUrl(search.value.trim(), 'pasted URL');
    }
  });
  urlBtn?.addEventListener('click', () => importAnyWebUrl(urlInp?.value || '', 'pasted URL'));
  urlInp?.addEventListener('keydown', e => { if (e.key === 'Enter') { e.preventDefault(); importAnyWebUrl(urlInp.value, 'pasted URL'); } });

  coverBtn?.addEventListener('click', () => {
    _view = 'cover'; localStorage.setItem('reh-imsdb-view', _view); _applyView();
  });
  listBtn?.addEventListener('click', () => {
    _view = 'list'; localStorage.setItem('reh-imsdb-view', _view); _applyView();
  });

  // Wire all open buttons (Library tab + Import/Export tab)
  [$('reh-browse-imsdb-btn'), $('reh-browse-imsdb-btn-impex')].forEach(btn => {
    btn?.addEventListener('click', openModal);
  });
  closeBtn?.addEventListener('click', closeModal);
  modal.addEventListener('click', e => { if (e.target === modal) closeModal(); });
})();

// ── Train Mode ────────────────────────────────────────────────────────────
// State machine: idle → playing_cue → ready → recording → transcribing → done
// Each "turn" = one set of cue lines + one "me" line the user must speak.

const trainState = {
  seq:      [],       // [{cueLines:[{index,speaker,text,voice,instruct}], myLine:{index,speaker,text}}]
  turn:     0,        // current turn index
  phase:    'idle',   // idle | playing_cue | ready | recording | transcribing | done
  cueSource: null,    // AudioBufferSourceNode currently playing
  mediaRec:  null,    // MediaRecorder for train recording
  recChunks: [],
  recRaf:    null,    // rAF id for meter
  recStream: null,    // MediaStream
  recCtx:    null,    // AudioContext for meter
  recAnalyser: null,
  recTimer:  null,
  recSecs:   0,
};

function _trainNormWords(str) {
  return (str || '').toLowerCase().replace(/[^a-zäöüàáâãèéêëìíîïòóôõùúûüýÿæœßа-яёА-ЯЁ0-9\s]/g, '').trim().split(/\s+/).filter(Boolean);
}

function _trainLcs(a, b) {
  const R = a.length, C = b.length;
  const dp = Array.from({length: R + 1}, () => new Int16Array(C + 1));
  for (let i = 1; i <= R; i++) for (let j = 1; j <= C; j++)
    dp[i][j] = a[i-1] === b[j-1] ? dp[i-1][j-1] + 1 : Math.max(dp[i-1][j], dp[i][j-1]);
  let i = R, j = C; const seq = [];
  while (i > 0 && j > 0) {
    if (a[i-1] === b[j-1]) { seq.unshift([i-1, j-1]); i--; j--; }
    else if (dp[i-1][j] >= dp[i][j-1]) i--;
    else j--;
  }
  return seq;
}

function _trainCompare(expected, actual) {
  const ew = _trainNormWords(expected), aw = _trainNormWords(actual);
  if (!ew.length) return { html_exp: '', html_act: '', score: 1 };
  const pairs = _trainLcs(ew, aw);
  const matchedE = new Set(pairs.map(p => p[0]));
  const matchedA = new Set(pairs.map(p => p[1]));
  const expHtml = ew.map((w, i) => matchedE.has(i)
    ? `<span class="tw-ok">${escHtml(w)}</span>`
    : `<span class="tw-miss">${escHtml(w)}</span>`).join(' ');
  const actHtml = aw.map((w, i) => matchedA.has(i)
    ? `<span class="tw-ok">${escHtml(w)}</span>`
    : `<span class="tw-extra">${escHtml(w)}</span>`).join(' ');
  const score = ew.length ? Math.round((matchedE.size / ew.length) * 100) : 100;
  return { html_exp: expHtml, html_act: actHtml, score };
}

function buildTrainSeq() {
  const seq = [];
  const lines = rehState.lines;
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    if (line.type !== 'dialog') continue;
    const cast = rehState.cast[line.speaker];
    if (!cast || cast.voice !== 'me') continue;
    // Gather preceding cue lines (last up to 3 TTS dialog lines going backwards)
    const cueLines = [];
    for (let j = i - 1; j >= 0 && cueLines.length < 3; j--) {
      const prev = lines[j];
      if (prev.type === 'scene' || prev.type === 'act') break;
      if (prev.type !== 'dialog') continue;
      const pc = rehState.cast[prev.speaker];
      if (!pc || pc.voice === 'me') break;
      cueLines.unshift({ index: j, speaker: prev.speaker, text: prev.text, emotion: prev.emotion || '',
        voice: pc.voice, color: pc.color, instruct: _buildInstruct(pc.instruct, prev.emotion, pc.voice),
        voiceData: pc.voiceData });
    }
    seq.push({ cueLines, myLine: { index: i, speaker: line.speaker, text: line.text, color: cast.color } });
  }
  return seq;
}

function _trainSetState(phase) {
  trainState.phase = phase;
  const stateEl = $('reh-train-rec-state');
  const playBtn   = $('reh-train-play');
  const recBtn    = $('reh-train-record');
  const stopBtn   = $('reh-train-stop-rec');
  const cueState  = $('reh-train-cue-state');
  const map = {
    idle:         { state:'Read the cue above · press ▶ to hear it', play:true,  rec:false, stop:false },
    playing_cue:  { state:'Playing cue…',                            play:false, rec:false, stop:false },
    ready:        { state:'Press 🎤 to record your line',            play:false, rec:true,  stop:false },
    recording:    { state:'Recording…',                              play:false, rec:false, stop:true  },
    transcribing: { state:'Transcribing…',                           play:false, rec:false, stop:false },
    done:         { state:'Done — press ▶ to replay or ⏭ for next', play:true,  rec:true,  stop:false },
  };
  const m = map[phase] || map.idle;
  if (stateEl) stateEl.textContent = m.state;
  if (cueState && phase === 'playing_cue') { cueState.innerHTML = '<span class="mdi mdi-volume-high" style="color:var(--accent)"></span>'; }
  else if (cueState) cueState.innerHTML = '';
  if (playBtn) playBtn.disabled = !m.play;
  if (recBtn)  { recBtn.disabled = !m.rec; recBtn.hidden = !!m.stop; }
  if (stopBtn) { stopBtn.disabled = !m.stop; stopBtn.hidden = !m.stop; }
  const timerEl = $('reh-train-rec-timer');
  const metersEl = $('reh-train-meters');
  if (phase === 'recording') {
    if (timerEl) timerEl.hidden = false;
    if (metersEl) metersEl.hidden = false;
  } else if (phase !== 'done') {
    if (timerEl) timerEl.hidden = true;
    if (metersEl) metersEl.hidden = true;
  }
}

async function _trainPlayCueLines(cueLines) {
  _trainSetState('playing_cue');
  for (const cue of cueLines) {
    if (trainState.phase !== 'playing_cue') break;
    let blob = rehState.synthCache.get(cue.index);
    if (!blob) {
      try { blob = await fetchTtsPreviewBlob(cue.voice, _rehInlineTone(stripMarkdown(cue.text), cue.emotion), 'wav', cue.instruct, _ttsBackendForVoice(cue.voice, rehState.backend)); }
      catch(e) { toast('Cue TTS failed: ' + e.message, 'error'); break; }
    }
    if (trainState.phase !== 'playing_cue') break;
    await new Promise(resolve => {
      const url = URL.createObjectURL(blob);
      const audio = new Audio(url);
      audio.onended = () => { URL.revokeObjectURL(url); resolve(); };
      audio.onerror = () => { URL.revokeObjectURL(url); resolve(); };
      trainState.cueAudio = audio;
      audio.play().catch(resolve);
    });
  }
  if (trainState.phase === 'playing_cue') _trainSetState('ready');
}

async function _trainTranscribe(blob) {
  _trainSetState('transcribing');
  try {
    const fd = new FormData();
    fd.append('file', blob, 'train_rec.webm');
    fd.append('backend', _appSettings?.stt_preferred_backend || 'configured');
    const r = await fetch('/api/transcribe-bytes', { method:'POST', body:fd });
    if (!r.ok) throw new Error(r.statusText);
    const d = await r.json();
    return (d.text || '').trim();
  } catch(e) {
    toast('Transcription failed: ' + e.message, 'error');
    return '';
  }
}

async function trainGoTo(idx) {
  // Stop any in-progress recording or playback
  if (trainState.cueAudio) { trainState.cueAudio.pause(); trainState.cueAudio = null; }
  _trainStopMic();

  trainState.turn = Math.max(0, Math.min(idx, trainState.seq.length - 1));
  const turn = trainState.seq[trainState.turn];
  if (!turn) return;

  // Update progress
  const progEl = $('reh-train-progress');
  if (progEl) progEl.textContent = `Turn ${trainState.turn + 1} / ${trainState.seq.length}`;

  // Render cue card — show ALL cue lines so user can read the full context
  const cueCard    = $('reh-train-cue');
  const cueAvEl    = $('reh-train-cue-avatar');
  const cueSpeaker = $('reh-train-cue-speaker');
  const cueText    = $('reh-train-cue-text');
  if (turn.cueLines.length) {
    const lastCue = turn.cueLines[turn.cueLines.length - 1];
    if (cueAvEl) cueAvEl.innerHTML = voiceAvatarHtml(lastCue.voice, lastCue.color, 32);
    if (cueSpeaker) cueSpeaker.textContent = lastCue.speaker;
    // Show all cue lines as a readable block
    if (cueText) {
      cueText.innerHTML = turn.cueLines.map(c =>
        `<div class="reh-train-cue-block">
          <span class="reh-train-cue-who" style="color:${c.color}">${escHtml(c.speaker)}</span>
          <span class="reh-train-cue-line">${escHtml(c.text)}</span>
        </div>`
      ).join('');
    }
    cueCard?.classList.remove('no-cue');
  } else {
    if (cueAvEl) cueAvEl.innerHTML = '<span class="mdi mdi-information-outline" style="font-size:24px;color:var(--subtext)"></span>';
    if (cueSpeaker) cueSpeaker.textContent = 'No preceding cue';
    if (cueText) cueText.textContent = 'This is the first line — speak when ready.';
    cueCard?.classList.add('no-cue');
  }

  // Render my line card
  const mySpeaker = $('reh-train-my-speaker');
  const myText    = $('reh-train-my-text');
  if (mySpeaker) mySpeaker.textContent = turn.myLine.speaker;
  if (myText) myText.textContent = turn.myLine.text;

  // Hide result from previous turn
  const resultEl = $('reh-train-result');
  if (resultEl) resultEl.hidden = true;

  // Reset audio preview
  const prevAudio = $('reh-train-audio-preview');
  if (prevAudio) { prevAudio.src = ''; prevAudio.style.display = 'none'; }

  // Show the script text immediately — user reads first, then clicks ▶ to hear the cue
  _trainSetState(turn.cueLines.length ? 'idle' : 'ready');
}

function _trainStartMeter() {
  const meterEl  = $('reh-train-meter');
  const dbEl     = $('reh-train-db');
  const waveEl   = $('reh-train-wave');
  if (!trainState.recAnalyser || !meterEl) return;
  const analyser = trainState.recAnalyser;
  const fft = new Uint8Array(analyser.frequencyBinCount);
  const wCtx = waveEl?.getContext('2d');
  const W = waveEl?.width || 300, H = waveEl?.height || 36;
  const BARS = 18;

  function tick() {
    analyser.getByteFrequencyData(fft);
    const rms = fft.reduce((s, v) => s + v * v, 0) / fft.length;
    const db  = rms > 0 ? 20 * Math.log10(Math.sqrt(rms) / 128) : -Infinity;
    if (dbEl) dbEl.textContent = isFinite(db) ? db.toFixed(1) + ' dB' : '-∞ dB';
    const slots = Array.from({length: BARS}, (_, i) => {
      const s = Math.floor(i / BARS * fft.length), e = Math.floor((i+1) / BARS * fft.length);
      return fft.slice(s, e).reduce((a, b) => a + b, 0) / (e - s) / 255;
    });
    meterEl.innerHTML = slots.map(v => {
      const h = Math.max(2, Math.round(v * 28));
      const col = v > 0.85 ? 'var(--red)' : v > 0.6 ? '#f59e0b' : 'var(--green)';
      return `<span style="height:${h}px;background:${col};width:4px;border-radius:2px;display:inline-block;vertical-align:bottom;margin:0 1px"></span>`;
    }).join('');
    if (wCtx) {
      analyser.getByteTimeDomainData(fft);
      wCtx.clearRect(0, 0, W, H);
      wCtx.beginPath(); wCtx.strokeStyle = 'var(--accent)'; wCtx.lineWidth = 1.5;
      fft.forEach((v, i) => { const x = (i / fft.length) * W, y = (v / 255) * H; i ? wCtx.lineTo(x, y) : wCtx.moveTo(x, y); });
      wCtx.stroke();
    }
    trainState.recRaf = requestAnimationFrame(tick);
  }
  trainState.recRaf = requestAnimationFrame(tick);
}

function _trainStopMic() {
  if (trainState.recRaf) { cancelAnimationFrame(trainState.recRaf); trainState.recRaf = null; }
  if (trainState.recTimer) { clearInterval(trainState.recTimer); trainState.recTimer = null; }
  if (trainState.mediaRec && trainState.mediaRec.state !== 'inactive') {
    try { trainState.mediaRec.stop(); } catch(_) {}
  }
  trainState.mediaRec = null;
  if (trainState.recCtx) { try { trainState.recCtx.close(); } catch(_) {} trainState.recCtx = null; }
  if (trainState.recStream) { trainState.recStream.getTracks().forEach(t => t.stop()); trainState.recStream = null; }
  trainState.recAnalyser = null;
  trainState.recChunks = [];
  const timerEl = $('reh-train-rec-timer');
  if (timerEl) { timerEl.hidden = true; timerEl.textContent = '0:00'; }
  const metersEl = $('reh-train-meters');
  if (metersEl) metersEl.hidden = true;
}

async function _trainStartRecording() {
  if (trainState.phase !== 'ready') return;
  try {
    const stream = await requestMicrophoneStream({ raw: true });
    trainState.recStream = stream;
    const ctx = new AudioContext();
    trainState.recCtx = ctx;
    const src = ctx.createMediaStreamSource(stream);
    const analyser = ctx.createAnalyser(); analyser.fftSize = 256;
    trainState.recAnalyser = analyser;
    const dst = ctx.createMediaStreamDestination();
    src.connect(analyser); analyser.connect(dst);
    _trainSetState('recording');
    _trainStartMeter();

    const timerEl = $('reh-train-rec-timer');
    if (timerEl) timerEl.hidden = false;
    trainState.recSecs = 0;
    trainState.recTimer = setInterval(() => {
      trainState.recSecs++;
      const m = Math.floor(trainState.recSecs / 60), s = trainState.recSecs % 60;
      if (timerEl) timerEl.textContent = `${m}:${String(s).padStart(2,'0')}`;
    }, 1000);

    trainState.recChunks = [];
    const mr = new MediaRecorder(dst.stream, { audioBitsPerSecond: 128000 });
    trainState.mediaRec = mr;
    mr.ondataavailable = e => { if (e.data.size > 0) trainState.recChunks.push(e.data); };
    mr.onstop = async () => {
      _trainStopMic();
      const blob = new Blob(trainState.recChunks, { type: 'audio/webm' });
      trainState.recChunks = [];
      const url = URL.createObjectURL(blob);
      const prevAudio = $('reh-train-audio-preview');
      if (prevAudio) { prevAudio.src = url; prevAudio.style.display = ''; }

      // Transcribe
      const transcript = await _trainTranscribe(blob);
      const turn = trainState.seq[trainState.turn];
      const { html_exp, html_act, score } = _trainCompare(turn?.myLine?.text || '', transcript);

      const resultEl = $('reh-train-result');
      const expEl    = $('reh-train-expected-text');
      const actEl    = $('reh-train-actual-text');
      const scoreEl  = $('reh-train-score');
      if (expEl)   expEl.innerHTML   = html_exp;
      if (actEl)   actEl.innerHTML   = html_act || '<em style="color:var(--subtext)">Nothing detected</em>';
      if (scoreEl) {
        const col = score >= 90 ? 'var(--green)' : score >= 60 ? '#f59e0b' : 'var(--red)';
        scoreEl.innerHTML = `<span style="color:${col};font-weight:700">${score}%</span>`;
      }
      if (resultEl) resultEl.hidden = false;
      _trainSetState('done');
    };
    mr.start();
  } catch(e) {
    toast('Microphone error: ' + e.message, 'error');
    _trainSetState('ready');
  }
}

function _trainStopRecording() {
  if (trainState.mediaRec && trainState.mediaRec.state === 'recording') {
    trainState.mediaRec.stop();
  }
}

function _trainHideStage(hide) {
  // Show/hide the script content area and auxiliary bars — transport bar stays visible always
  const els = ['.reh-stage-area', '#reh-tts-status-bar', '#reh-rec-overlay', '#reh-synth-bar'];
  els.forEach(sel => {
    const el = document.querySelector(sel) || document.getElementById(sel.replace('#',''));
    if (el) el.style.display = hide ? 'none' : '';
  });
}

function enterTrainMode() {
  const seq = buildTrainSeq();
  if (!seq.length) {
    toast('No "I play this" lines found — check "I play this" on at least one character in the Cast tab.', 'error');
    return;
  }
  trainState.seq = seq;
  trainState.turn = 0;
  trainState.phase = 'idle';

  _trainHideStage(true);
  const panel = $('reh-train-panel');
  if (panel) panel.hidden = false;

  trainGoTo(0);
}

function exitTrainMode() {
  if (trainState.cueAudio) { trainState.cueAudio.pause(); trainState.cueAudio = null; }
  _trainStopMic();
  trainState.phase = 'idle';
  trainState.seq = [];

  _trainHideStage(false);
  const panel = $('reh-train-panel');
  if (panel) panel.hidden = true;
}

// ── Bulk-edit button wiring ─────────────────────────────────────────────────
$('reh-bulk-toggle')?.addEventListener('click', () => setBulkMode(!rehState.bulkMode));
$('reh-bulk-done')?.addEventListener('click', () => setBulkMode(false));
$('reh-bulk-all')?.addEventListener('click', () => {
  // Select every line currently visible in the stage
  document.querySelectorAll('#reh-script-lines .reh-bulk-check').forEach(cb => rehState.bulkSel.add(parseInt(cb.dataset.bulk)));
  rehState.bulkAnchor = rehState.bulkSel.size ? Math.min(...rehState.bulkSel) : null;
  document.querySelectorAll('#reh-script-lines .reh-bulk-check').forEach(cb => _refreshBulkLine(parseInt(cb.dataset.bulk)));
  _updateBulkCount();
});
$('reh-bulk-none')?.addEventListener('click', () => {
  const had = [...rehState.bulkSel];
  rehState.bulkSel.clear();
  rehState.bulkAnchor = null;
  had.forEach(_refreshBulkLine);
  _updateBulkCount();
});
$('reh-bulk-ignore')?.addEventListener('click', () => _bulkApply(l => { l.ignored = true; }));
$('reh-bulk-unignore')?.addEventListener('click', () => _bulkApply(l => { l.ignored = false; }));
$('reh-bulk-hide')?.addEventListener('click', () => _bulkApply(l => { l.hidden = true; }));
$('reh-bulk-delete')?.addEventListener('click', _bulkDelete);
$('reh-bulk-show-hidden')?.addEventListener('change', e => {
  rehState.showHidden = e.target.checked;
  buildScriptPage();
});

// ── Train button wiring ─────────────────────────────────────────────────────
$('reh-page-mode-btn')?.addEventListener('click', cyclePageMode);
$('reh-train-open-btn')?.addEventListener('click', enterTrainMode);
$('reh-train-exit-btn')?.addEventListener('click', exitTrainMode);

$('reh-train-play')?.addEventListener('click', () => {
  const turn = trainState.seq[trainState.turn];
  if (!turn) return;
  if (trainState.phase === 'playing_cue') return;
  if (trainState.cueAudio) { trainState.cueAudio.pause(); trainState.cueAudio = null; }
  if (turn.cueLines.length) _trainPlayCueLines(turn.cueLines);
  else _trainSetState('ready');
});

$('reh-train-record')?.addEventListener('click', () => {
  if (trainState.phase === 'ready' || trainState.phase === 'done') _trainStartRecording();
});

$('reh-train-stop-rec')?.addEventListener('click', _trainStopRecording);

$('reh-train-prev')?.addEventListener('click', () => {
  if (trainState.turn > 0) trainGoTo(trainState.turn - 1);
});

$('reh-train-next')?.addEventListener('click', () => {
  if (trainState.turn < trainState.seq.length - 1) trainGoTo(trainState.turn + 1);
});

$('reh-train-repeat')?.addEventListener('click', () => {
  if (trainState.cueAudio) { trainState.cueAudio.pause(); trainState.cueAudio = null; }
  _trainStopMic();
  const turn = trainState.seq[trainState.turn];
  if (!turn) return;
  const resultEl = $('reh-train-result');
  if (resultEl) resultEl.hidden = true;
  if (turn.cueLines.length) _trainPlayCueLines(turn.cueLines);
  else _trainSetState('ready');
});

// ── Init ───────────────────────────────────────────────────────────────────
rehRenderMeter();
_syncPageModeBtn();
renderLibraryList().catch(()=>{});
if($('reh-skip-desc-toggle'))$('reh-skip-desc-toggle').checked=rehState.skipDescriptions;
if (window._rehearserStartImpEx) {
  delete window._rehearserStartImpEx;
  showRehImpEx();
} else {
  const _initPhase = window._rehearserStartPhase || 1;
  delete window._rehearserStartPhase;
  showPhase(_initPhase);
}