1741 lines
86 KiB
JavaScript
1741 lines
86 KiB
JavaScript
// ── Book → multi-speaker audiobook ──────────────────────────────────────────
|
||
//
|
||
// Bridges the Read Aloud reader and the Script Rehearser: an LLM scans the
|
||
// document (in the current scope — selection / page range / whole book),
|
||
// attributes every segment to a speaker ("Narrator" or a character) with an
|
||
// emotion, then hands the result to the Script Rehearser as a cast-able script
|
||
// so each character gets its own voice. The rehearser is the editable preview:
|
||
// you fix any mis-attribution, cast voices, and synthesise there.
|
||
//
|
||
// Reuses: /api/attribute-dialogue (LLM), readerState + readerScopeIndices()
|
||
// (reader.js), parseScript / detectCharacters / rehState / rehDefaultLlmUrl
|
||
// (rehearser.js), splitTextIntoChunks (generation.js), $ / toast (utils.js).
|
||
|
||
const AUDIOBOOK_CHUNK_CHARS = 3000; // passage size per LLM attribution call
|
||
const AUDIOBOOK_WARMUP_TIMEOUT_MS = 240000;
|
||
// A chunk's max_tokens (routes/conversation.py) can reach ~4000 on slow local models
|
||
// (~15 tok/s on modest hardware), i.e. up to ~4.5 minutes of pure generation time —
|
||
// and large (100B+) models can take even longer just to produce a first token.
|
||
// 600s is also the server-side cap (_request_timeout_seconds in routes/conversation.py).
|
||
const AUDIOBOOK_ATTRIBUTION_TIMEOUT_MS = 600000;
|
||
const AUDIOBOOK_ATTRIBUTION_RETRY_TIMEOUT_MS = 300000;
|
||
const AUDIOBOOK_RECAST_TIMEOUT_MS = 240000;
|
||
const AUDIOBOOK_RECAST_CONTEXT_CHARS = 4200;
|
||
const AUDIOBOOK_RECAST_TARGETS_PER_CALL = 6;
|
||
const AUDIOBOOK_DRAFT_AUTOSAVE_MS = 5 * 60 * 1000;
|
||
const _audiobook = { running: false, cancel: false };
|
||
|
||
// Studio relocates this control out of the audiobook panel. That means a
|
||
// normal panel rebuild can leave an old copy visible even after the async cast
|
||
// has finished or failed. Always clear every live copy when the worker state
|
||
// reaches a terminal state.
|
||
function _abHideCastingControl() {
|
||
document.querySelectorAll('#ab-cv-cancel').forEach(btn => {
|
||
btn.hidden = true;
|
||
btn.disabled = false;
|
||
btn.innerHTML = '<span class="mdi mdi-close"></span> Cancel';
|
||
});
|
||
}
|
||
|
||
// The casting footer is physically moved into Studio and is also rebuilt by
|
||
// the live view. A listener attached only to the original panel can therefore
|
||
// disappear with a rebuilt footer. Keep one delegated listener on document so
|
||
// Stop Casting always reaches the current button.
|
||
if (!window._abDelegatedCancelHandler) {
|
||
window._abDelegatedCancelHandler = true;
|
||
document.addEventListener('click', event => {
|
||
const btn = event.target.closest?.('#ab-cv-cancel');
|
||
if (!btn || btn.hidden) return;
|
||
if (_audiobook.running) {
|
||
_audiobook.cancel = true;
|
||
btn.disabled = true;
|
||
btn.innerHTML = '<span class="mdi mdi-loading mdi-spin"></span> Stopping...';
|
||
if (typeof _audiobook.abort === 'function') _audiobook.abort();
|
||
} else {
|
||
_abHideCastingControl();
|
||
}
|
||
});
|
||
}
|
||
window._audiobook = _audiobook;
|
||
let _abDraftAutosaveTimer = null;
|
||
let _abLastServerDraftErrorAt = 0;
|
||
|
||
function audiobookDialogueKey(text) {
|
||
return String(text || '')
|
||
.normalize('NFKC')
|
||
.replace(/[»«„“”"‘’'`]+/g, '')
|
||
.replace(/\s+/g, ' ')
|
||
.trim()
|
||
.toLowerCase();
|
||
}
|
||
|
||
function audiobookSegmentText(seg) {
|
||
if (!seg) return '';
|
||
if (seg.type === 'narration' || !seg.speaker || /^Unknown|Unbekannt/i.test(seg.speaker)) return seg.text || '';
|
||
return `"${seg.text || ''}"`;
|
||
}
|
||
|
||
// Word-under-cursor for the casting feed WITHOUT wrapping every word in its
|
||
// own <span> — an earlier version did exactly that, and at book scale
|
||
// (1500+ segments × dozens of words) the ~100k extra DOM nodes with hover
|
||
// styles froze the page on every feed redraw. Instead this asks the browser
|
||
// which text position sits under the pointer (caretRangeFromPoint /
|
||
// caretPositionFromPoint — both native and cheap), then expands to word
|
||
// boundaries. Returns { word, range } or null; the Range provides the rect
|
||
// for the hover highlight overlay and popup anchoring.
|
||
function _abWordRangeAtPoint(x, y) {
|
||
let node = null, offset = 0;
|
||
if (document.caretRangeFromPoint) {
|
||
const r = document.caretRangeFromPoint(x, y);
|
||
if (!r) return null;
|
||
node = r.startContainer; offset = r.startOffset;
|
||
} else if (document.caretPositionFromPoint) {
|
||
const p = document.caretPositionFromPoint(x, y);
|
||
if (!p) return null;
|
||
node = p.offsetNode; offset = p.offset;
|
||
} else return null;
|
||
if (!node || node.nodeType !== 3) return null;
|
||
const text = node.nodeValue || '';
|
||
const isW = ch => ch != null && /[\p{L}\p{N}'’-]/u.test(ch);
|
||
if (offset >= text.length) offset = text.length - 1;
|
||
if (!isW(text[offset])) {
|
||
if (offset > 0 && isW(text[offset - 1])) offset--;
|
||
else return null;
|
||
}
|
||
let a = offset, b = offset;
|
||
while (a > 0 && isW(text[a - 1])) a--;
|
||
while (b + 1 < text.length && isW(text[b + 1])) b++;
|
||
const word = text.slice(a, b + 1).trim();
|
||
if (!word || word.length < 2) return null;
|
||
const range = document.createRange();
|
||
range.setStart(node, a);
|
||
range.setEnd(node, b + 1);
|
||
return { word, range };
|
||
}
|
||
|
||
function audiobookJoinSegmentText(a, b) {
|
||
const left = String(a || '');
|
||
const right = String(b || '');
|
||
if (!left) return right;
|
||
if (!right) return left;
|
||
if (/\s$/.test(left) || /^\s/.test(right)) return left + right;
|
||
if (/^[,.;:!?»«”"')\]]/.test(right)) return left + right;
|
||
if (/[([{„“"']$/.test(left)) return left + right;
|
||
return left + ' ' + right;
|
||
}
|
||
|
||
// ── Mislabeled-dialogue detector ────────────────────────────────────────────
|
||
// Spoken lines routinely come out of PDF extraction typed as `narration` —
|
||
// usually because the » « quote marks were lost. Those segments are invisible
|
||
// to "Identify unknown characters" (it only scans type === 'dialogue'), so no
|
||
// number of re-runs can ever fix them, and the only pass that could ("Verify
|
||
// all characters") re-sends every narration segment to the LLM: 1036 of them
|
||
// on a single novel, which is slow, GPU-hungry and risks disturbing lines that
|
||
// were already right. This scores narration segments for direct-speech
|
||
// signals instead, so only the genuinely suspicious ones get spent on an LLM
|
||
// call — measured on a real book: 36 candidates instead of 1036 (29x fewer),
|
||
// with the true positives ranked at the top.
|
||
const _AB_INQUIT_VERBS = '(?:sagte|rief|fragte|antwortete|erwiderte|murmelte|fl[üu]sterte|br[üu]llte|entgegnete|meinte|knurrte|zischte|stammelte|schrie|dr[äa]ngte|herrschte|seufzte|wisperte|grunzte|befahl|erkl[äa]rte|fuhr fort|setzte hinzu|f[üu]gte hinzu)';
|
||
function _abSuspectNarration(segs, minScore) {
|
||
// Threshold 2, not 3: measured against the hand-corrected book, 3 catches
|
||
// 28 of the 51 real "dialogue swallowed into narration" cases while 2
|
||
// catches 37, for only ~7 extra LLM calls. A false flag merely costs one
|
||
// call (the verification prompt still judges the line on its merits and
|
||
// usually leaves it alone), so erring generous is the cheap direction.
|
||
minScore = minScore || 2;
|
||
const norm = i => String(segs[i]?.text || '').replace(/\s+/g, ' ').trim();
|
||
const out = new Set();
|
||
for (let i = 0; i < segs.length; i++) {
|
||
if (segs[i]?.type !== 'narration') continue;
|
||
const t = norm(i), nxt = i + 1 < segs.length ? norm(i + 1) : '';
|
||
let score = 0;
|
||
// Strongest tell: the NEXT segment is a bare inquit ", drängte Marcian
|
||
// ungeduldig." — which means THIS segment was the quote it belongs to.
|
||
if (new RegExp('^[\\s,»«"\'\\-–]{0,4}(?:\\w+\\s+){0,2}' + _AB_INQUIT_VERBS + '\\b', 'i').test(nxt)) score += 5;
|
||
if (t.includes('»') || t.includes('«')) score += 4; // typed narration yet carries quote marks
|
||
// Count, don't just test: narration is 3rd-person past, so ONE stray "ich"
|
||
// can be free-indirect thought, but a passage sustaining first/second
|
||
// person is a speech that lost its quote marks. Long speeches used to
|
||
// score only 1 here (the <160-char bonus below can't apply to them), so
|
||
// they fell under any useful threshold — that was 24 of the 51 missed
|
||
// "dialogue swallowed into narration" cases in the measured book.
|
||
const p12n = (t.match(/\b(ich|du|wir|ihr|mich|dich|uns|euch|mein|dein|unser|euer)\b/gi) || []).length;
|
||
const p12 = p12n >= 1;
|
||
const excl = /[!?]\s*$/.test(t);
|
||
// Allow a leading discourse particle before the imperative — "Nun schafft
|
||
// diese Knochen fort" is every bit as much a command as "Schafft ...".
|
||
const imper = /^(?:(?:Nun|Jetzt|Dann|Also|Und|Aber|So|Doch|Hier|Da|Los)\s+)?(Bringt|Los|Mach|Macht|Kommt|Komm|Geht|Geh|Nehmt|Nimm|Haltet|Halt|Schafft|Schaff|T[öo]tet|Sieh|Seht|H[öo]rt|H[öo]r|Wartet|Warte|La[sß]|La[sß]t|Weist|Zeigt|Sagt|Sag|Gebt|Gib)\b/.test(t);
|
||
if (p12) score += 1;
|
||
if (p12n >= 3) score += 2;
|
||
if (excl) score += 1;
|
||
if (imper) score += 3;
|
||
if (p12 && excl) score += 1;
|
||
if (t.length < 160 && (p12 || excl || imper)) score += 1;
|
||
if (score >= minScore) out.add(i);
|
||
}
|
||
return out;
|
||
}
|
||
window._abSuspectNarration = _abSuspectNarration;
|
||
|
||
function audiobookRecastGroups(unknownIdxs, segs) {
|
||
const groups = [];
|
||
let cur = [];
|
||
for (const idx of unknownIdxs) {
|
||
const prev = cur.length ? cur[cur.length - 1] : -Infinity;
|
||
const shortGap = idx <= prev + 2
|
||
&& segs.slice(prev + 1, idx).every(s => !s || s.type === 'narration' || /^Unknown|Unbekannt/i.test(s.speaker || ''));
|
||
if (!cur.length || (shortGap && cur.length < AUDIOBOOK_RECAST_TARGETS_PER_CALL)) cur.push(idx);
|
||
else { groups.push(cur); cur = [idx]; }
|
||
}
|
||
if (cur.length) groups.push(cur);
|
||
return groups;
|
||
}
|
||
|
||
function audiobookRecastContext(segs, group) {
|
||
const targetStart = group[0];
|
||
const targetEnd = group[group.length - 1] + 1;
|
||
let start = Math.max(0, targetStart - 5);
|
||
let end = Math.min(segs.length, targetEnd + 4);
|
||
const render = () => segs.slice(start, end).map(audiobookSegmentText).join(' ').trim();
|
||
let text = render();
|
||
while (text.length > AUDIOBOOK_RECAST_CONTEXT_CHARS && (start < targetStart || end > targetEnd)) {
|
||
if (end > targetEnd) end--;
|
||
text = render();
|
||
if (text.length <= AUDIOBOOK_RECAST_CONTEXT_CHARS) break;
|
||
if (start < targetStart) start++;
|
||
text = render();
|
||
}
|
||
const recent = audiobookRecastRecent(segs, start, end);
|
||
return { text, start, end, recent };
|
||
}
|
||
|
||
function audiobookRecastRecent(segs, start, end) {
|
||
const lines = [];
|
||
for (let i = Math.max(0, start - 10); i < Math.min(segs.length, end + 8); i++) {
|
||
const s = segs[i];
|
||
if (!s || s.type !== 'dialogue' || !s.speaker || /^Unknown|Unbekannt/i.test(s.speaker)) continue;
|
||
lines.push(`${i < start ? 'before' : i >= end ? 'after' : 'near'}: ${s.speaker}: ${(s.text || '').slice(0, 100)}`);
|
||
}
|
||
return lines.slice(-12).join('\n');
|
||
}
|
||
|
||
function audiobookFindReturnedSegment(targetSeg, returned, used) {
|
||
const targetKey = audiobookDialogueKey(targetSeg?.text);
|
||
if (!targetKey) return null;
|
||
let loose = null;
|
||
for (let i = 0; i < returned.length; i++) {
|
||
if (used.has(i)) continue;
|
||
const cand = returned[i];
|
||
if (!cand) continue;
|
||
const candKey = audiobookDialogueKey(cand.text);
|
||
if (!candKey) continue;
|
||
if (candKey === targetKey) return { idx: i, seg: cand };
|
||
const minLen = Math.min(candKey.length, targetKey.length);
|
||
if (minLen >= 18 && (candKey.includes(targetKey) || targetKey.includes(candKey))) {
|
||
loose = loose || { idx: i, seg: cand };
|
||
}
|
||
}
|
||
return loose;
|
||
}
|
||
|
||
function audiobookFindReturnedSegmentSequence(targetSeg, returned, used) {
|
||
const targetKey = audiobookDialogueKey(targetSeg?.text);
|
||
if (!targetKey) return null;
|
||
for (let i = 0; i < returned.length; i++) {
|
||
if (used.has(i) || !returned[i]) continue;
|
||
let joined = '';
|
||
const idxs = [];
|
||
for (let j = i; j < returned.length; j++) {
|
||
if (used.has(j) || !returned[j]) break;
|
||
joined = audiobookJoinSegmentText(joined, returned[j].text || '');
|
||
idxs.push(j);
|
||
const key = audiobookDialogueKey(joined);
|
||
if (key === targetKey) return { idxs, segs: idxs.map(k => returned[k]) };
|
||
if (key.length > targetKey.length * 1.35 + 40) break;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// String coercer (mirrors library.js _libStr)
|
||
function _abStr(v) {
|
||
if (v == null) return '';
|
||
if (typeof v === 'string') return v;
|
||
if (Array.isArray(v)) return v.filter(Boolean).join(', ');
|
||
return String(v);
|
||
}
|
||
|
||
// ── Autosave / draft recovery ─────────────────────────────────────────────────
|
||
// Saves the accumulated segments to localStorage after every chunk so a page
|
||
// refresh or browser crash doesn't lose hours of casting work.
|
||
|
||
const _AB_DRAFT_KEY = 'ttsvc_ab_draft';
|
||
|
||
// The book this casting session belongs to. When a saved library book is open,
|
||
// the draft is keyed by its id so reopening the SAME book always restores its
|
||
// cast — independent of any drift in the extracted text fingerprint (the old
|
||
// text-only key silently lost the cast whenever PDF re-extraction differed even
|
||
// slightly). Falls back to the global key for unsaved/ad-hoc documents.
|
||
function _abBookId() {
|
||
return (window.readerState && readerState.savedId) || _audiobook.bookId || null;
|
||
}
|
||
function _abDraftKey(bookId) {
|
||
return bookId ? (_AB_DRAFT_KEY + '_' + bookId) : _AB_DRAFT_KEY;
|
||
}
|
||
|
||
function _abTextId(text) {
|
||
// Cheap fingerprint — no need for a full hash; length + first/last chars is enough
|
||
// to detect doc changes without storing the source text itself.
|
||
const s = (text.slice(0, 300) + text.slice(-300)).replace(/\s+/g, '');
|
||
let h = 5381;
|
||
for (let i = 0; i < s.length; i++) h = (((h << 5) + h) ^ s.charCodeAt(i)) >>> 0;
|
||
return h.toString(36) + '_' + text.length;
|
||
}
|
||
|
||
function _abSafeFilename(name, fallback = 'cast') {
|
||
const s = String(name || fallback || 'cast')
|
||
.replace(/[\\/:*?"<>|]+/g, '_')
|
||
.replace(/\s+/g, '_')
|
||
.replace(/^_+|_+$/g, '');
|
||
return (s || fallback || 'cast').slice(0, 120);
|
||
}
|
||
|
||
// Called after essentially every ~80-segment chunk during a full-book cast
|
||
// run — with the ENTIRE accumulated segments array re-stringified, written
|
||
// to localStorage, AND sent over the network EVERY time. Both the string
|
||
// size and the work involved grow with total segments cast so far, so this
|
||
// alone is an O(n) cost repeated dozens of times over a long book — an O(n²)
|
||
// total, confirmed live as a real contributor (alongside the feed's own
|
||
// per-batch full-DOM query) to a tab crash partway through a 235-page book.
|
||
// Always save on the FINAL call for a given run (so nothing real is lost on
|
||
// completion) but throttle the constant stream of intermediate autosaves —
|
||
// losing a few seconds of draft progress on an actual crash is a clear
|
||
// trade against causing that crash in the first place.
|
||
let _abLastDraftSaveAt = 0;
|
||
const AB_DRAFT_SAVE_THROTTLE_MS = 4000;
|
||
function _abSaveDraft(segs, roster, text, done, total) {
|
||
const isFinal = total > 0 && done >= total;
|
||
const now = Date.now();
|
||
if (!isFinal && now - _abLastDraftSaveAt < AB_DRAFT_SAVE_THROTTLE_MS) return;
|
||
_abLastDraftSaveAt = now;
|
||
const bookId = _abBookId();
|
||
const payload = {
|
||
bookId: bookId,
|
||
title: window.readerState?.title || '',
|
||
textId: _abTextId(text),
|
||
segments: segs,
|
||
roster: roster,
|
||
pageMarks: _audiobook.pageMarks || [],
|
||
rehId: _audiobook.rehId || null,
|
||
done: done,
|
||
total: total,
|
||
savedAt: Date.now()
|
||
};
|
||
try { localStorage.setItem(_abDraftKey(bookId), JSON.stringify(payload)); } catch (_) {}
|
||
// Mirror to server when a library book is open (fire-and-forget)
|
||
if (bookId) {
|
||
fetch(`/api/reader/docs/${encodeURIComponent(bookId)}/scripts/cast`, {
|
||
method: 'PUT',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(payload)
|
||
}).then(r => {
|
||
if (!r.ok) throw new Error(r.statusText || `HTTP ${r.status}`);
|
||
}).catch(err => {
|
||
console.warn('[audiobook] server draft autosave failed:', err);
|
||
const now = Date.now();
|
||
if (now - _abLastServerDraftErrorAt > 60000) {
|
||
_abLastServerDraftErrorAt = now;
|
||
if (typeof toast === 'function') toast('Server autosave failed. Browser draft is still saved.', 'error');
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
let _abExportBusy = false;
|
||
async function audiobookExportCastMd() {
|
||
// Re-entry guard: while the page is busy, a user's queued-up clicks can all
|
||
// fire at once when the main thread unblocks — without this, that meant a
|
||
// burst of identical downloads and one save-dialog per copy to cancel.
|
||
if (_abExportBusy) return;
|
||
_abExportBusy = true;
|
||
setTimeout(() => { _abExportBusy = false; }, 2000);
|
||
const segs = _audiobook.segments || [];
|
||
if (!segs.length) { toast('No cast to export', 'error'); return; }
|
||
const bookId = _abBookId();
|
||
if (_audiobook.lastText) {
|
||
_abSaveDraft(segs, _audiobook.roster || [], _audiobook.lastText, _audiobook.completedChunks || 0, _audiobook.completedTotal || 0);
|
||
}
|
||
const title = window.readerState?.title || _audiobook.title || 'audiobook';
|
||
if (bookId) {
|
||
try {
|
||
const r = await fetch(`/api/reader/docs/${encodeURIComponent(bookId)}/scripts/cast/export`);
|
||
if (!r.ok) throw new Error((await r.json().catch(() => ({}))).detail || r.statusText);
|
||
const blob = await r.blob();
|
||
const disp = r.headers.get('Content-Disposition') || '';
|
||
const match = disp.match(/filename="([^"]+)"/i);
|
||
const name = match?.[1] || `${_abSafeFilename(title)}_cast.zip`;
|
||
if (typeof readerDownload === 'function') readerDownload(blob, name);
|
||
else {
|
||
const a = document.createElement('a');
|
||
a.href = URL.createObjectURL(blob);
|
||
a.download = name;
|
||
a.click();
|
||
setTimeout(() => URL.revokeObjectURL(a.href), 500);
|
||
}
|
||
toast('Exported cast + character sheets (.zip)', 'success');
|
||
return;
|
||
} catch (err) {
|
||
toast('Server export failed, downloading local cast copy', 'error');
|
||
}
|
||
}
|
||
const payload = {
|
||
bookId,
|
||
title,
|
||
textId: _audiobook.lastText ? _abTextId(_audiobook.lastText) : '',
|
||
segments: segs,
|
||
roster: _audiobook.roster || [],
|
||
pageMarks: _audiobook.pageMarks || [],
|
||
rehId: _audiobook.rehId || null,
|
||
done: _audiobook.completedChunks || 0,
|
||
total: _audiobook.completedTotal || 0,
|
||
savedAt: Date.now(),
|
||
};
|
||
const blob = new Blob([_abCastMarkdown(payload)], { type: 'text/markdown;charset=utf-8' });
|
||
if (typeof readerDownload === 'function') readerDownload(blob, `${_abSafeFilename(title)}_cast.md`);
|
||
else {
|
||
const a = document.createElement('a');
|
||
a.href = URL.createObjectURL(blob);
|
||
a.download = `${_abSafeFilename(title)}_cast.md`;
|
||
a.click();
|
||
setTimeout(() => URL.revokeObjectURL(a.href), 500);
|
||
}
|
||
}
|
||
|
||
function _abStartDraftAutosave(saveNow) {
|
||
_abStopDraftAutosave();
|
||
if (typeof saveNow !== 'function') return;
|
||
_abDraftAutosaveTimer = setInterval(saveNow, AUDIOBOOK_DRAFT_AUTOSAVE_MS);
|
||
const saveOnLeave = () => saveNow();
|
||
_audiobook._draftSaveOnLeave = saveOnLeave;
|
||
window.addEventListener('pagehide', saveOnLeave);
|
||
window.addEventListener('beforeunload', saveOnLeave);
|
||
}
|
||
|
||
function _abStopDraftAutosave() {
|
||
if (_abDraftAutosaveTimer) clearInterval(_abDraftAutosaveTimer);
|
||
_abDraftAutosaveTimer = null;
|
||
if (_audiobook._draftSaveOnLeave) {
|
||
window.removeEventListener('pagehide', _audiobook._draftSaveOnLeave);
|
||
window.removeEventListener('beforeunload', _audiobook._draftSaveOnLeave);
|
||
_audiobook._draftSaveOnLeave = null;
|
||
}
|
||
}
|
||
|
||
async function _abEnsureLibraryBook() {
|
||
const rs = window.readerState;
|
||
if (!rs || rs.savedId || !rs.sentences?.length) return !!rs?.savedId;
|
||
if (rs.mode === 'pdf' && !rs.fileBlob) return false;
|
||
|
||
const meta = {
|
||
title: rs.title || 'Untitled',
|
||
kind: rs.mode,
|
||
idx: rs.idx,
|
||
voice: $('reader-voice-select')?.value || '',
|
||
backend: $('reader-backend-select')?.value || '',
|
||
speed: rs.speed,
|
||
instruct: $('reader-instruct')?.value.trim() || '',
|
||
chunkMode: rs.chunkMode,
|
||
seed: $('reader-seed')?.value.trim() || '',
|
||
temperature: $('reader-temp')?.value.trim() || '',
|
||
tts_speed: parseFloat($('reader-tts-speed')?.value) || 1,
|
||
normalize: rs.normalize,
|
||
sentenceCount: rs.sentences.length,
|
||
pageCount: rs.pages?.length || 0,
|
||
synthCount: 0,
|
||
updated: new Date().toISOString(),
|
||
};
|
||
|
||
try {
|
||
const r = await fetch('/api/reader/docs', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(meta),
|
||
});
|
||
if (!r.ok) throw new Error((await r.json().catch(() => ({}))).detail || r.statusText);
|
||
rs.savedId = (await r.json()).id;
|
||
_audiobook.bookId = rs.savedId;
|
||
|
||
const ext = rs.mode === 'pdf' ? 'pdf' : 'txt';
|
||
const body = rs.mode === 'pdf'
|
||
? rs.fileBlob
|
||
: new Blob([rs.docText || audiobookScopeText() || ''], { type: 'text/plain' });
|
||
const sr = await fetch(`/api/reader/docs/${encodeURIComponent(rs.savedId)}/source?ext=${ext}`, { method: 'PUT', body });
|
||
if (sr.ok) rs.sourceUploaded = true;
|
||
if (typeof readerRenderLibrary === 'function') readerRenderLibrary();
|
||
return true;
|
||
} catch (err) {
|
||
console.warn('[audiobook] could not create reader-library autosave target:', err);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
async function _abLoadDraftServer(bookId) {
|
||
if (!bookId) return null;
|
||
for (let attempt = 0; attempt < 2; attempt++) {
|
||
try {
|
||
const r = await fetch(`/api/reader/docs/${encodeURIComponent(bookId)}/scripts/cast`);
|
||
if (!r.ok) {
|
||
if (attempt === 0 && (r.status === 404 || r.status >= 500)) {
|
||
await new Promise(resolve => setTimeout(resolve, 650));
|
||
continue;
|
||
}
|
||
return null;
|
||
}
|
||
const d = await r.json();
|
||
if (d && Array.isArray(d.segments) && d.segments.length) return d;
|
||
return null;
|
||
} catch (_) {
|
||
if (attempt === 0) await new Promise(resolve => setTimeout(resolve, 650));
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function _abLoadDraft(text) {
|
||
const bookId = _abBookId();
|
||
const textId = _abTextId(text);
|
||
const title = String(window.readerState?.title || '').trim().toLowerCase();
|
||
try {
|
||
// 1. Per-book localStorage — fastest, no network
|
||
if (bookId) {
|
||
const raw = localStorage.getItem(_abDraftKey(bookId));
|
||
if (raw) {
|
||
const d = JSON.parse(raw);
|
||
if (d && Array.isArray(d.segments) && d.segments.length) return d;
|
||
}
|
||
}
|
||
// 2. Global draft (ad-hoc docs) — must match the text fingerprint
|
||
const raw = localStorage.getItem(_AB_DRAFT_KEY);
|
||
if (raw) {
|
||
const d = JSON.parse(raw);
|
||
if (d && Array.isArray(d.segments) && d.segments.length && d.textId === textId) return d;
|
||
}
|
||
|
||
// 3. Recovery fallback: the same saved book can receive a new id after an
|
||
// import/save cycle. Scan older per-book drafts with the same title so a good
|
||
// cast does not appear lost just because the storage key changed.
|
||
let best = null;
|
||
for (let i = 0; i < localStorage.length; i++) {
|
||
const key = localStorage.key(i);
|
||
if (!key || !key.startsWith(_AB_DRAFT_KEY + '_')) continue;
|
||
if (bookId && key === _abDraftKey(bookId)) continue;
|
||
try {
|
||
const cand = JSON.parse(localStorage.getItem(key) || 'null');
|
||
if (!cand || !Array.isArray(cand.segments) || !cand.segments.length) continue;
|
||
const candTitle = String(cand.title || '').trim().toLowerCase();
|
||
const exactText = cand.textId && cand.textId === textId;
|
||
const sameTitle = title && candTitle && candTitle === title;
|
||
if (!exactText && !sameTitle) continue;
|
||
const score = (exactText ? 1000000 : 0) + (sameTitle ? 100000 : 0) + cand.segments.length;
|
||
if (!best || score > best.score) best = { score, draft: cand };
|
||
} catch (_) {}
|
||
}
|
||
if (best?.draft) return best.draft;
|
||
} catch (_) { return null; }
|
||
return null;
|
||
}
|
||
|
||
function _abClearDraft() {
|
||
const bookId = _abBookId();
|
||
try { localStorage.removeItem(_abDraftKey(bookId)); } catch (_) {}
|
||
if (bookId) {
|
||
fetch(`/api/reader/docs/${encodeURIComponent(bookId)}/scripts/cast`, { method: 'DELETE' }).catch(() => {});
|
||
}
|
||
}
|
||
|
||
// Opening/closing quote glyphs across book conventions: English "..."/“...”,
|
||
// German »...«/„...“, French «»/curly single '...'/‘...’, CJK 「...」『...』,
|
||
// em-dash speech. Single guillemets ›...‹ are deliberately excluded — German
|
||
// prose uses ›...‹ as a narrator scare-quote/emphasis mark WITHIN narration
|
||
// (e.g. ein Zelt — ›Zelt‹ war eine schmeichelhafte Bezeichnung...), not as a
|
||
// dialogue delimiter; treating it as one split scare-quoted words out as
|
||
// speakerless "dialogue" fragments (confirmed live: "Zelt", "Skipperedikt",
|
||
// "Seulaslintan" etc.).
|
||
// Deterministic Unknown-resolution — the LLM keeps missing mechanical
|
||
// patterns no matter how explicitly the prompt spells them out (measured:
|
||
// ~44% Unknown on a full book WITH the rules in the prompt), so apply them
|
||
// in code where they cannot be ignored:
|
||
// A. Colon rule: the narration right before a quote ends with ":" → its
|
||
// last-mentioned character (roster name, whitelisted person noun, or the
|
||
// "Name … und sagte:" subject) speaks.
|
||
// B. Post-quote inquit: the narration right after a quote starts with a
|
||
// speech verb + Name, "Der X, der gesprochen hatte", or the impersonal
|
||
// "ertönte es … . Name …" formula → that character spoke.
|
||
// C. Two-person alternation: an Unknown whose two nearest preceding dialogue
|
||
// lines have two different known speakers gets the earlier of the two
|
||
// (strict turn-taking) — only when both neighbours are unambiguous.
|
||
// Only fills segments still Unknown; never overrides an LLM attribution.
|
||
function audiobookResolveUnknowns(segs, prevTail, roster) {
|
||
const isUnknown = s => s?.type === 'dialogue' && (!s.speaker || /^Unknown|Unbekannt/i.test(s.speaker));
|
||
const isNamed = s => s?.type === 'dialogue' && s.speaker && !/^Unknown|Unbekannt|Narrator$/i.test(s.speaker);
|
||
const names = (roster || []).filter(n => n && !/^(Narrator|Unknown|Unbekannt)/i.test(n)).sort((a, b) => b.length - a.length);
|
||
const lastNameIn = (text) => {
|
||
let best = null, bestAt = -1;
|
||
for (const n of names) {
|
||
const at = text.lastIndexOf(n);
|
||
if (at > bestAt) { bestAt = at; best = n; }
|
||
}
|
||
if (best) return best;
|
||
// "Marcian unterdrückte seinen Ärger und sagte:" — subject of the final
|
||
// speech clause, provided it isn't a sentence-opener adverb/article.
|
||
const clause = text.match(new RegExp(_AB_NAME + "[^.!?:]{0,80}\\b(?:und\\s+)?(?:" + AB_SPEECH_VERBS + ")[^:]{0,60}:\\s*$"));
|
||
if (clause && !AB_NOTNAME.has(clause[1]) && !AB_PERSON_NOUNS.has(clause[1])) return clause[1];
|
||
// whitelisted person nouns only — never arbitrary capitalized nouns
|
||
const m = [...text.matchAll(/\b(?:[Dd]er|[Dd]ie|[Dd]en|[Dd]em|[Ee]in|[Ee]ine)\s+([A-ZÄÖÜ][a-zäöüß]{2,})\b/g)]
|
||
.map(x => x[1]).filter(n => AB_PERSON_NOUNS.has(n));
|
||
return m.length ? m[m.length - 1] : null;
|
||
};
|
||
const all = [...(prevTail || []), ...segs];
|
||
const offset = (prevTail || []).length;
|
||
const resolved = [];
|
||
for (let i = offset; i < all.length; i++) {
|
||
const s = all[i];
|
||
if (!isUnknown(s)) continue;
|
||
const prev = all[i - 1], next = all[i + 1];
|
||
let who = null;
|
||
// Self-introduction: the line itself names its own speaker ("Man nennt
|
||
// mich Andra", "Ich bin X", "Mein Name ist X", "my name is X", "call me
|
||
// X") — the strongest possible signal, checked before anything context-
|
||
// dependent. Matched against the actual roster, never a bare capitalized
|
||
// word, so an unrelated proper noun right after the phrase can't misfire.
|
||
if (!who) {
|
||
const dt = String(s.text || '');
|
||
for (const n of names) {
|
||
const esc = n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||
if (new RegExp('\\b(?:man\\s+nennt\\s+mich|nennt\\s+mich|ich\\s+(?:bin|hei(?:ß|ss)e)|mein\\s+name\\s+ist|my\\s+name\\s+is|i\\s+am|call\\s+me|they\\s+call\\s+me)\\s+' + esc + '\\b', 'i').test(dt)) {
|
||
who = n; break;
|
||
}
|
||
}
|
||
}
|
||
if (!who && prev?.type === 'narration' && /:\s*$/.test(String(prev.text || '').trim())) {
|
||
who = lastNameIn(String(prev.text || ''));
|
||
}
|
||
// "Garbaz rief von unten herauf." / "...Ork legte den Kopf in den Nacken
|
||
// und schrie seinen Triumph zum Himmel." — a Name+speech-verb inquit
|
||
// ending the PRECEDING narration in a plain period (not the ":" the rule
|
||
// above requires) still reliably names who's about to speak, even with
|
||
// extra words (object/adverbial phrases) between the verb and the
|
||
// period. Matched against the actual roster (not a generic capitalized-
|
||
// word regex) so multi-word names/aliases match correctly, and anchored
|
||
// to end at the segment's literal end so an earlier, unrelated name
|
||
// mention in a longer paragraph can't win over the one right before the
|
||
// dialogue that follows it.
|
||
if (!who && prev?.type === 'narration') {
|
||
const pt = String(prev.text || '').trim();
|
||
for (const n of names) {
|
||
const esc = n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||
if (new RegExp('\\b' + esc + '\\b[^.!?:]{0,80}\\b(?:und\\s+)?(?:' + AB_SPEECH_VERBS + ')\\b[^.!?]{0,60}[.!?]\\s*$').test(pt)) {
|
||
who = n; break;
|
||
}
|
||
}
|
||
}
|
||
// Idiomatic "about to speak" narration that isn't a literal speech verb —
|
||
// "X fand als erster seine Stimme wieder" (found his voice first), "X
|
||
// brach das Schweigen" (broke the silence), "ihre ersten Worte waren"
|
||
// (her first words were) — confirmed live as a real gap: these read as
|
||
// an obvious cue to a human but the fixed AB_SPEECH_VERBS list above
|
||
// only matches literal verbs of speech, so this class of narration
|
||
// silently left the following line Unknown.
|
||
if (!who && prev?.type === 'narration') {
|
||
const pt = String(prev.text || '').trim();
|
||
for (const n of names) {
|
||
const esc = n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||
if (new RegExp('\\b' + esc + '\\b[^.!?]{0,60}\\b(?:fand|found)\\b[^.!?]{0,20}\\b(?:seine|ihre|his|her)\\s+(?:Stimme|voice)\\b[^.!?]{0,40}[.!?]\\s*$', 'i').test(pt)) { who = n; break; }
|
||
if (new RegExp('\\b' + esc + '\\b[^.!?]{0,60}\\bbrach\\b[^.!?]{0,20}\\b(?:das\\s+)?Schweigen\\b[^.!?]{0,40}[.!?]\\s*$', 'i').test(pt)) { who = n; break; }
|
||
}
|
||
// "Erst als Andra sich angekleidet hatte, ... und ihre ersten Worte
|
||
// waren ..." — the pronoun refers back to whoever was last named
|
||
// earlier in the SAME narration, not a name sitting next to the
|
||
// idiom itself, so resolve it the same way the colon-rule does.
|
||
if (!who && /\b(?:ihre|seine|his|her)\s+ersten\s+Worte\s+waren\b/i.test(pt)) who = lastNameIn(pt);
|
||
if (!who) {
|
||
const m2 = pt.match(new RegExp(_AB_NAME + "(?:'s)?\\s+first\\s+words\\s+were\\b", 'i'));
|
||
if (m2 && !AB_NOTNAME.has(m2[1])) who = m2[1];
|
||
}
|
||
}
|
||
// A segment that OPENS with a lower-case speech verb is an inquit by
|
||
// construction ("grunzte der Ork und hob den Dolch."), even when the caster
|
||
// mistyped it as dialogue — confirmed live: the quote before such a segment
|
||
// stayed Unknown purely because the inquit carried the wrong type. Accept
|
||
// either type here and repair the type while we are at it.
|
||
// A segment holding several turns separated by a blank line is TWO speakers
|
||
// fused into one ("...ausliefern und ...\n\nEr hat es nicht so gemeint" —
|
||
// Lysandra, then Perdia interrupting). A trailing inquit only names the LAST
|
||
// speaker, so applying it to the whole block silently mis-credits the earlier
|
||
// turn. Leaving it Unknown is the honest outcome: visibly unresolved beats
|
||
// confidently wrong, and the split can then be made by hand or by the LLM pass.
|
||
const _isFusedTurns = /\n\s*\n/.test(String(s.text || '').trim());
|
||
const _nextIsInquitText = !_isFusedTurns && next && new RegExp('^\\W{0,3}(?:' + AB_SPEECH_VERBS + ')\\b').test(String(next.text || '').trim());
|
||
if (!who && !_isFusedTurns && (next?.type === 'narration' || _nextIsInquitText)) {
|
||
const nt = String(next.text || '').trim();
|
||
// Split quote whose inquit uses a PRONOUN rather than a name:
|
||
// "»Ja, ungewöhnlich«" + ", antwortete er knapp." The rules below all
|
||
// require a literal name after the speech verb, so this whole class stayed
|
||
// Unknown even though the antecedent is unambiguous — resolve it the same
|
||
// way the colon rule does, to the last character named in the narration
|
||
// immediately before the quote.
|
||
if (new RegExp('^\\W{0,3}(?:' + AB_SPEECH_VERBS + ')\\s+(?:er|sie|es)\\b', 'i').test(nt)
|
||
&& prev?.type === 'narration') {
|
||
const byPronoun = lastNameIn(String(prev.text || ''));
|
||
if (byPronoun) who = byPronoun;
|
||
}
|
||
// "Darrags Stimme klang tonlos." / "Marcians Stimme war heiser." — a
|
||
// genitive name attached to Stimme in the narration right AFTER a quote
|
||
// names who just spoke. The existing voice-announcement rule only looked
|
||
// at the narration BEFORE the line, so this mirror image stayed Unknown.
|
||
if (!who) {
|
||
for (const n of names) {
|
||
const esc = n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||
if (new RegExp('^\\W{0,3}' + esc + "(?:s|'s)?\\s+Stimme\\b", 'i').test(nt)) { who = n; break; }
|
||
}
|
||
}
|
||
let m = who ? null : nt.match(new RegExp('^\\W{0,3}(?:' + AB_SPEECH_VERBS + ')\\s+(?:(?:der|die|das|den|dem)\\s+)?(?:[a-zäöüß]+e[nrms]?\\s+){0,2}' + _AB_NAME));
|
||
if (!m) m = nt.match(new RegExp('^(?:Der|Die)\\s+' + _AB_NAME + ',\\s+(?:der|die)\\s+gesprochen hatte'));
|
||
// "ertönte es plötzlich über ihm. Karyla hatte …" — impersonal formula,
|
||
// the next sentence's subject is the speaker.
|
||
if (!m) m = nt.match(new RegExp('^\\W{0,3}(?:ertönte|erklang|tönte|drang|kam)\\b[^.!?]{0,60}\\bes\\b[^.!?]{0,60}[.!?]\\s*' + _AB_NAME));
|
||
if (m && !AB_NOTNAME.has(m[1])) who = m[1];
|
||
}
|
||
const prevEndsColon = prev?.type === 'narration' && /:\s*$/.test(String(prev.text || '').trim());
|
||
if (!who && !prevEndsColon) {
|
||
// Two-person alternation, strictly: the two nearest preceding dialogue
|
||
// lines carry two DIFFERENT known names → this line belongs to the one
|
||
// who didn't just speak. Guards: never when the preceding narration
|
||
// ends with ":" (that colon introduces someone the rules above already
|
||
// failed to identify — alternation would be a guess, not a deduction),
|
||
// never across page boundaries, and only within a short window.
|
||
const prevDialogues = [];
|
||
for (let j = i - 1; j >= 0 && j >= i - 6 && prevDialogues.length < 2; j--) {
|
||
if (all[j]?.page != null && s.page != null && all[j].page !== s.page) break;
|
||
if (all[j]?.type !== 'dialogue') continue;
|
||
if (!isNamed(all[j])) { prevDialogues.length = 0; break; } // an unresolved line breaks the chain
|
||
prevDialogues.push(all[j].speaker);
|
||
}
|
||
if (prevDialogues.length === 2 && prevDialogues[0] !== prevDialogues[1]) who = prevDialogues[1];
|
||
}
|
||
if (who && _nextIsInquitText && next && next.type !== 'narration') {
|
||
next.type = 'narration'; next.speaker = 'Narrator'; next.emotion = '';
|
||
}
|
||
if (who && !/^(Narrator|Unknown|Unbekannt)$/i.test(who)) {
|
||
s.speaker = who;
|
||
resolved.push(who);
|
||
}
|
||
}
|
||
return resolved;
|
||
}
|
||
const _AB_TAG_NAME = "[A-ZÄÖÜ][A-Za-zäöüß'\\-]+";
|
||
const AB_SPEECH_TAG_ONLY_RE = new RegExp(
|
||
'^\\s*[,.;:!?–-]*\\s*(?:' +
|
||
'(?:' + AB_SPEECH_VERBS + ')\\b\\s+(?:er|sie|es|ich|du|wir|ihr|he|she|it|they|' + _AB_TAG_NAME + ')' +
|
||
'|' +
|
||
'(?:er|sie|es|ich|du|wir|ihr|he|she|it|they|' + _AB_TAG_NAME + ')\\s+(?:' + AB_SPEECH_VERBS + ')\\b' +
|
||
')' +
|
||
'(?:\\s+(?:mit|in|leise|laut|kalt|heiser|erstickt|ruhig|zornig|wütend|ängstlich|spöttisch|verächtlich|fragend|flüsternd|schrill|dumpf|slowly|coldly|quietly|softly|angrily|hoarsely)\\b[\\s\\S]*)?' +
|
||
'[.!?…]*\\s*$',
|
||
'i'
|
||
);
|
||
function audiobookIsSpeechTagOnly(text) {
|
||
const t = String(text || '').trim();
|
||
if (!t || t.length > 180) return false;
|
||
if (/[»«„“”"‟‚‘’『「]/.test(t)) return false;
|
||
return AB_SPEECH_TAG_ONLY_RE.test(t);
|
||
}
|
||
function audiobookGuessSpeaker(after, before) {
|
||
let m;
|
||
const ok = n => (n && !AB_NOTNAME.has(n)) ? n : null;
|
||
// NOTE: no 'i' flag — names must be genuinely capitalized; German speech verbs
|
||
// after a quote are lowercase, so this rejects pronouns like "sagte er".
|
||
// after the quote: ", sagte Riskan" / "sagte Riskan" (verb → name)
|
||
if ((m = new RegExp('^[\\s,;–-]*' + AB_SPEECH_VERBS + '\\s+(?:der|die|das|ein|eine)?\\s*' + _AB_NAME).exec(after || ''))) { const r = ok(m[1]); if (r) return r; }
|
||
// after the quote: ", Riskan sagte" (name → verb)
|
||
if ((m = new RegExp('^[\\s,;–-]*' + _AB_NAME + '\\s+' + AB_SPEECH_VERBS).exec(after || ''))) { const r = ok(m[1]); if (r) return r; }
|
||
// before the quote: "Riskan sagte:" / "Riskan fragte"
|
||
if ((m = new RegExp(_AB_NAME + '\\s+' + AB_SPEECH_VERBS + '[\\s:,–-]*$').exec(before || ''))) { const r = ok(m[1]); if (r) return r; }
|
||
return null;
|
||
}
|
||
|
||
// Deterministic fallback: split a passage into narration + dialogue by quotation
|
||
// spans and attribute speakers from the surrounding speech tags. Used when the LLM
|
||
// is unavailable so dialogue — and as many speakers as possible — are never lost.
|
||
// ›...‹ deliberately excluded — see AB_DIALOGUE_RE above.
|
||
const AB_QUOTE_PAIRS = {
|
||
'»': '«', '«': '»', '„': '“', '“': '”', '"': '"',
|
||
'「': '」', '『': '』', '‘': '’', '‚': '‘'
|
||
};
|
||
|
||
// Constant pattern — compiled once, not per sentence-ending character scanned.
|
||
const _AB_UNCLOSED_TAG_RE = new RegExp(
|
||
'^\\s*(?:[,;:–-]\\s*)?(?:' + AB_SPEECH_VERBS + '|(?:er|sie|es|ich|du|wir|ihr|he|she|it|they|I|we|you)\\s+' + AB_SPEECH_VERBS + ')\\b',
|
||
'i'
|
||
);
|
||
|
||
function _abUnclosedQuoteEnd(raw, closeIdx) {
|
||
const limit = closeIdx >= 0 ? closeIdx : raw.length;
|
||
for (let i = 0; i < limit; i++) {
|
||
if (!/[.!?]/.test(raw[i])) continue;
|
||
const quote = raw.slice(0, i + 1).trim();
|
||
if (quote.length < 2) continue;
|
||
const after = raw.slice(i + 1, Math.min(limit, i + 140));
|
||
if (_AB_UNCLOSED_TAG_RE.test(after)) return i + 1;
|
||
}
|
||
if (closeIdx < 0) {
|
||
const m = raw.match(/^([\s\S]{2,180}?[.!?])(?:\s|$)/);
|
||
if (m && raw.slice(m[1].length).trim().length > 40) return m[1].length;
|
||
}
|
||
return closeIdx >= 0 ? closeIdx : raw.length;
|
||
}
|
||
|
||
function _abOrphanClosingQuoteSpan(text, closeIdx, minStart) {
|
||
if (!'«”’‹」』'.includes(text[closeIdx])) return null;
|
||
const before = text.slice(minStart, closeIdx);
|
||
const prev = before.match(/\S(?=\s*$)/)?.[0] || '';
|
||
if (!/[.!?]/.test(prev)) return null;
|
||
const trimmedLen = before.trimEnd().length;
|
||
let localStart = 0;
|
||
const boundaryRe = /[\n\r]|[.!?:]\s+/g;
|
||
let m;
|
||
while ((m = boundaryRe.exec(before))) {
|
||
const next = m.index + m[0].length;
|
||
if (next < trimmedLen - 1) localStart = next;
|
||
}
|
||
const quote = before.slice(localStart).trim();
|
||
if (!/^[\s\S]{2,220}[.!?]$/.test(quote)) return null;
|
||
return { start: minStart + localStart, end: closeIdx + 1, quote };
|
||
}
|
||
|
||
// German typography opens a quote with » and closes it with « (the reverse
|
||
// of French) — this app's own casting prompt already spells that out
|
||
// ("»Nein«, sagte sie, »halt.«"). A dialogue turn's CLOSING « sometimes
|
||
// lands on the FRONT of the narration segment right after it instead of at
|
||
// the end of the dialogue turn itself (an off-by-one boundary slip in the
|
||
// LLM's own segmentation, not a policy question — the prompt already says
|
||
// to keep both marks). Symmetric case: an OPENING » can land on the END of
|
||
// a narration segment instead of the front of the dialogue turn that
|
||
// follows. Worst case, the whole narration "segment" is nothing but the
|
||
// stray mark on its own — an empty-looking NARRATOR row with nothing to
|
||
// read. Fixed mechanically instead of relying on the LLM to never mis-slice:
|
||
// move the mark to where it actually belongs, or leave it alone if there's
|
||
// no sensible home for it (safer than deleting a mark that might be
|
||
// legitimate narration content, e.g. narration quoting a title or saying).
|
||
const AB_QUOTE_OPENERS = '»„‚›';
|
||
const AB_QUOTE_CLOSERS = '«"\'‹';
|
||
function _audiobookFixOrphanedQuoteMarks(segments) {
|
||
const isQuoteChar = ch => ch && (AB_QUOTE_OPENERS + AB_QUOTE_CLOSERS).includes(ch);
|
||
for (let i = 0; i < segments.length; i++) {
|
||
const s = segments[i];
|
||
if (s.type !== 'narration') continue;
|
||
const trimmed = s.text.trim();
|
||
if (!trimmed) continue;
|
||
|
||
// A CLOSING mark stuck on the FRONT of narration belongs at the END of
|
||
// the dialogue turn right before it.
|
||
const lead = trimmed[0];
|
||
if (AB_QUOTE_CLOSERS.includes(lead)) {
|
||
const prev = segments[i - 1];
|
||
if (prev && prev.type === 'dialogue' && !isQuoteChar(prev.text.trim().slice(-1))) {
|
||
prev.text = prev.text.trimEnd() + lead;
|
||
s.text = trimmed.slice(1).trimStart();
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// An OPENING mark stuck on the END of narration belongs at the START of
|
||
// the dialogue turn right after it (mirror image of the case above).
|
||
const tail = trimmed[trimmed.length - 1];
|
||
if (AB_QUOTE_OPENERS.includes(tail)) {
|
||
const next = segments[i + 1];
|
||
if (next && next.type === 'dialogue' && !isQuoteChar(next.text.trim()[0])) {
|
||
next.text = tail + next.text.trimStart();
|
||
s.text = trimmed.slice(0, -1).trimEnd();
|
||
}
|
||
}
|
||
}
|
||
return segments.filter(s => s.text.trim());
|
||
}
|
||
|
||
// Removes a segment whose text is a near-duplicate of another segment within
|
||
// a nearby window — confirmed live: "Verify all characters" (audiobookRecastUnknown
|
||
// with includeNarrator:true) can re-splice a passage's already-correct text back
|
||
// into the array a second time when its context-window overlaps the neighbouring
|
||
// recast group (each group pads ±5/+4 segments of surrounding context so the LLM
|
||
// has continuity, and adjacent groups' windows can overlap by that much). The
|
||
// combined segment text is supposed to reconstruct the source exactly once — the
|
||
// source book only has each sentence once — so any repeat within a realistic
|
||
// overlap range is always wrong, regardless of which internal step produced it.
|
||
// Normalizes away stray leading/trailing quote marks before comparing, since the
|
||
// duplicate copy often carries one of those artifacts and an exact string
|
||
// comparison would miss it.
|
||
// German uses » « for quoted TERMS and titles as well as for speech — "Himgi war
|
||
// der Überzeugung, daß es sich dabei um »den gewundenen Weg der Krieger und
|
||
// Häuptlinge« handelte, von dem die Inschriften berichteten." The casting model
|
||
// reads those marks as a dialogue boundary and cuts the sentence into three
|
||
// pieces: a narration fragment ending mid-clause, the quoted phrase alone, and a
|
||
// fragment resuming in lower case. Nothing there is speech, so no attribution
|
||
// pass can repair it — the sentence simply has to be put back together. Only
|
||
// merges NARRATION neighbours, and only when the break is grammatically
|
||
// impossible (no sentence-ending punctuation before, lower-case continuation
|
||
// after), so a genuine narration→dialogue→narration sequence is never touched.
|
||
// ── Speaker identity consolidation ──────────────────────────────────────────
|
||
// The caster refers to one character by several labels across a book — a bare
|
||
// name and a full one ("Sharraz" / "Sharraz Garthai"), a title on its own
|
||
// ("Baronin" / "Baronin Ira von Seewiesen"), a stray fragment ("Von" /
|
||
// "Oberst Alrik von Blautann"). Each variant becomes its own cast entry and so
|
||
// gets its OWN VOICE, which is far more damaging in the finished audiobook than
|
||
// an unresolved line: the same person audibly changes voice mid-scene.
|
||
// Measured against a hand-corrected book, label fragmentation accounted for a
|
||
// large share of the disagreements — more than genuine misattributions.
|
||
// A variant is only folded into another when its words are a strict SUBSET of
|
||
// the other's after stripping articles and titles, so "Weber" and "Alter Weber"
|
||
// (equal after stripping) stay separate, and two unrelated names never merge.
|
||
// Speaker labels that are really fragments of a German noun phrase, not people:
|
||
// "in seinem Inneren" -> Inneren, "die Hand" -> Hand, "mein Geliebter" ->
|
||
// Geliebten, "der Wind" -> Wind. The caster emits these as characters, each then
|
||
// gets a cast entry and its own voice, and the real speaker's line is lost to a
|
||
// phantom — measured against a hand-corrected book, they were a large part of
|
||
// why a fresh cast produced 73 speakers where the human had 62. A line credited
|
||
// to one of these is better left Unknown: visibly unresolved, and still
|
||
// recoverable by the repair passes, instead of silently wrong.
|
||
// Grammatical words the caster mistakes for names because they open the sentence
|
||
// that introduces a quote: "Hinter ihm raunte Oberst von Blautann:" -> Hinter,
|
||
// "Keiner sagte mehr etwas." -> Keiner, a dangling "Von" from "von Blautann".
|
||
// Confirmed by a reader hand-correcting a whole book: every one of these was
|
||
// deleted as a bogus character.
|
||
window._audiobookDropPhantomSpeakers = _audiobookDropPhantomSpeakers;
|
||
window._audiobookConsolidateSpeakerAliases = _audiobookConsolidateSpeakerAliases;
|
||
|
||
// A bare one-word "dialogue" piece with no sentence-ending punctuation is
|
||
// essentially never a real spoken turn ("Nein!", "Halt." always carry
|
||
// punctuation) — it's the signature of »quoted title/name« text (German
|
||
// uses guillemets for emphasis and titles, not just speech) getting split
|
||
// as if each quoted word were its own line of dialogue (confirmed live: a
|
||
// dedication byline "»Lilo« and »Zerwas«" split into three one-word
|
||
// segments, two of them "dialogue" attributed to guessed speakers — both in
|
||
// the initial casting pass's own per-chunk output AND in a later
|
||
// verification-pass re-split of an existing line). Shared by both call
|
||
// sites rather than duplicated, since it's the same failure mode either way.
|
||
// If `text` begins with a repeat of `prefixText` (comparing only significant
|
||
// characters — quote marks and whitespace differ freely between the LLM's two
|
||
// renderings of the same words), return the index in `text` just past that
|
||
// duplicated content, else -1. Deliberately requires a reasonable length so
|
||
// two segments that merely start with the same short common word ("Und …")
|
||
// are never treated as duplicates.
|
||
function _abPrefixDupCut(text, prefixText) {
|
||
const INSIG = /[«»„“”"‟‚‘’›‹\s]/;
|
||
const d = String(prefixText || '').replace(/[«»„“”"‟‚‘’›‹\s]/g, '').toLowerCase();
|
||
if (d.length < 12) return -1;
|
||
const t = String(text || '');
|
||
let j = 0;
|
||
for (let i = 0; i < t.length; i++) {
|
||
const ch = t[i];
|
||
if (INSIG.test(ch)) continue;
|
||
if (ch.toLowerCase() !== d[j]) return -1;
|
||
j++;
|
||
if (j === d.length) return i + 1;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
// Resolve role/epithet speaker labels to the proper name they denote, using
|
||
// German appositive constructions found in the book's own text: "Darrag der
|
||
// Schmied" / "der Schmied Darrag", "Zerwas den Henker", "der Inquisitor
|
||
// Marcian". In both word orders the ROLE is the noun immediately after the
|
||
// article and the NAME is the other side, so the pair can be read off the
|
||
// grammar without knowing anything about a particular book.
|
||
//
|
||
// This is the "also known as" problem measured against the hand-corrected
|
||
// book: the caster routinely credits a line to what a character IS ("Schmied",
|
||
// "Henker", "Inquisitor") rather than who they ARE, and every such label
|
||
// becomes its own cast entry with its own voice. `Darrag -> Schmied` alone
|
||
// accounted for 27 wrong attributions.
|
||
//
|
||
// Deliberately conservative: a pair is only ever considered when BOTH sides
|
||
// are already speaker labels in this cast. A stray "die Männer der Garnison"
|
||
// can't invent a mapping, because "Garnison" never speaks.
|
||
function _audiobookResolveRoleAliases(segments, sourceText) {
|
||
const labels = new Map();
|
||
for (const s of segments) {
|
||
if (s?.type !== 'dialogue') continue;
|
||
const sp = String(s.speaker || '').trim();
|
||
if (!sp || /^(Narrator|Unknown|Unbekannt)$/i.test(sp)) continue;
|
||
labels.set(sp.toLowerCase(), sp);
|
||
}
|
||
if (labels.size < 2) return { merged: 0, moved: 0, pairs: [] };
|
||
|
||
const votes = new Map(); // roleLower -> Map(nameLower -> hits)
|
||
const vote = (role, name) => {
|
||
const r = String(role || '').toLowerCase(), n = String(name || '').toLowerCase();
|
||
if (!r || !n || r === n) return;
|
||
if (!labels.has(r) || !labels.has(n)) return;
|
||
if (!votes.has(r)) votes.set(r, new Map());
|
||
const m = votes.get(r);
|
||
m.set(n, (m.get(n) || 0) + 1);
|
||
};
|
||
const W = '([A-ZÄÖÜ][A-Za-zÄÖÜäöüß-]{2,})';
|
||
const ART = '(?:der|die|das|den|dem)';
|
||
const txt = String(sourceText || '');
|
||
let m;
|
||
const nameFirst = new RegExp('\\b' + W + ',?\\s+' + ART + '\\s+' + W + '\\b', 'g');
|
||
while ((m = nameFirst.exec(txt))) vote(m[2], m[1]); // "Darrag der Schmied"
|
||
const roleFirst = new RegExp('\\b' + ART + '\\s+' + W + '\\s+' + W + '\\b', 'g');
|
||
while ((m = roleFirst.exec(txt))) vote(m[1], m[2]); // "der Schmied Darrag"
|
||
|
||
// A single stray appositive is not evidence: German pairs capitalised nouns
|
||
// constantly ("die Männer der Garnison", "der Elfe Zerwas" in a passage
|
||
// where the elf is someone else), and one such accident is enough to bind a
|
||
// role to the wrong character for the whole book — measured live, allowing
|
||
// single hits produced Inquisitor→Lysandra and Vampir→Sartassa when the
|
||
// book's own repeated usage says Marcian and Zerwas. Require the pairing to
|
||
// recur, and to be an outright winner rather than tied with a rival.
|
||
const MIN_VOTES = 2;
|
||
const mapping = new Map();
|
||
for (const [role, names] of votes) {
|
||
let best = null, bestN = 0, runnerUp = 0;
|
||
for (const [n, c] of names) {
|
||
if (c > bestN) { runnerUp = bestN; best = n; bestN = c; }
|
||
else if (c > runnerUp) runnerUp = c;
|
||
}
|
||
if (best && bestN >= MIN_VOTES && bestN > runnerUp) mapping.set(role, labels.get(best));
|
||
}
|
||
// Never chain a rename (A->B while B->C) — collapse to the final target.
|
||
for (const [role, target] of mapping) {
|
||
let t = target, guard = 0;
|
||
while (mapping.has(t.toLowerCase()) && mapping.get(t.toLowerCase()) !== t && guard++ < 5) t = mapping.get(t.toLowerCase());
|
||
mapping.set(role, t);
|
||
}
|
||
let moved = 0;
|
||
const pairs = [];
|
||
for (const s of segments) {
|
||
if (s?.type !== 'dialogue') continue;
|
||
const to = mapping.get(String(s.speaker || '').trim().toLowerCase());
|
||
if (to && to !== s.speaker) {
|
||
pairs.push(`${s.speaker}→${to}`);
|
||
s.speaker = to;
|
||
moved++;
|
||
}
|
||
}
|
||
return { merged: mapping.size, moved, pairs: [...new Set(pairs)] };
|
||
}
|
||
|
||
// ── Attribution confidence ──────────────────────────────────────────────────
|
||
// 100% correct attribution is not reachable on a real novel, but knowing WHICH
|
||
// lines are doubtful is nearly as valuable: it lets a human skip the ones that
|
||
// are already right. Scored purely from local evidence (no extra LLM calls).
|
||
//
|
||
// Measured against the hand-corrected book, the score genuinely separates
|
||
// right from wrong — it is not decoration:
|
||
// >=80 (green) 45% of lines, 95.1% actually correct
|
||
// 50-79 (orange) 23% of lines, 77.3% actually correct
|
||
// <50 (red) 32% of lines, 53.7% actually correct
|
||
// Reviewing only orange+red means reading 55% of the book and still catching
|
||
// 90% of every real attribution error.
|
||
const _AB_GENERIC_ROLE_WORDS = new Set(('mann frau junge mädchen menge männer frauen krieger kriegerin ' +
|
||
'wache wachen reiter schreiber adepten elfe zwerg zauberer magier magierin ork orks vampir inquisitor ' +
|
||
'schmied oberst fremde fremder gestalt stimme sklave sklaven nachbar bote soldat soldaten ritter ' +
|
||
'ritterin unsicher alter junger bäckerstochter weber kutscher druide amazone henker').split(' '));
|
||
|
||
function _abIsGenericRoleLabel(name) {
|
||
const n = String(name || '').trim().toLowerCase().replace(/^(der|die|das|den|dem|ein|eine|alter|alte|junger|junge)\s+/, '');
|
||
const toks = n.match(/[\wäöüß]+/gu) || [];
|
||
return toks.length > 0 && toks.every(t => _AB_GENERIC_ROLE_WORDS.has(t));
|
||
}
|
||
|
||
function _abSegmentConfidence(segs, i) {
|
||
const s = segs[i] || {};
|
||
const t = String(s.text || '');
|
||
const sp = String(s.speaker || '').trim();
|
||
const why = [];
|
||
let score;
|
||
if (s.type === 'narration') {
|
||
score = 88; why.push('narration');
|
||
if (/[»«]/.test(t)) { score -= 25; why.push('carries quote marks'); }
|
||
const p12 = (t.match(/\b(ich|du|wir|ihr|mich|dich|uns|euch)\b/gi) || []).length;
|
||
if (p12 >= 3) { score -= 30; why.push('sustained 1st/2nd person — may be speech'); }
|
||
else if (p12 >= 1) { score -= 8; why.push('1st/2nd person present'); }
|
||
if (/[!?]\s*$/.test(t)) { score -= 8; why.push('ends with ! or ?'); }
|
||
return { score: Math.max(2, Math.min(99, score)), why };
|
||
}
|
||
if (!sp || /^(unknown|unbekannt)/i.test(sp)) return { score: 3, why: ['speaker unknown'] };
|
||
score = 60;
|
||
if (_abIsGenericRoleLabel(sp)) { score -= 28; why.push('speaker is a generic role label'); }
|
||
const nxt = i + 1 < segs.length ? String(segs[i + 1].text || '') : '';
|
||
const prv = i > 0 ? String(segs[i - 1].text || '') : '';
|
||
const first = (sp.split(/\s+/)[0] || '').replace(/[^\wäöüß]/gu, '');
|
||
const V = _AB_INQUIT_VERBS;
|
||
if (first && new RegExp(V + '\\W+' + first, 'i').test(nxt)) { score += 32; why.push('speech tag names this speaker'); }
|
||
else if (first && new RegExp(first + '\\W+\\w*\\s*' + V, 'i').test(nxt)) { score += 30; why.push('speaker + speech verb follows'); }
|
||
else if (first && new RegExp(first, 'i').test(prv)) { score += 12; why.push('speaker named just before'); }
|
||
else if (new RegExp('^\\s*[,»«]?\\s*' + V, 'i').test(nxt)) { score += 6; why.push('unnamed speech tag follows'); }
|
||
else { score -= 12; why.push('no nearby speech tag'); }
|
||
if (!/[»«]/.test(t)) { score -= 14; why.push('no quote marks'); }
|
||
if (/\n\s*\n/.test(t.trim())) { score -= 22; why.push('fused: several turns in one segment'); }
|
||
if (t.trim().length < 12) { score -= 10; why.push('very short line'); }
|
||
return { score: Math.max(2, Math.min(99, score)), why };
|
||
}
|
||
|
||
// The raw heuristic score is NOT a probability — measured against the
|
||
// hand-corrected book, raw 35-49 lines were right 69% of the time, not 42%.
|
||
// Showing the raw number would systematically understate how good the guess
|
||
// is. This maps each raw band onto the correctness actually observed for it,
|
||
// so the displayed percentage means "this is how often an attribution scoring
|
||
// like this turned out to be right".
|
||
//
|
||
// Wording is deliberately restrained: even the best band is wrong about 1 line
|
||
// in 25, so nothing is labelled "certain" or "definite" — a label the reviewer
|
||
// learns to distrust is worse than no label. Bands are coarse on purpose;
|
||
// six is as many reliability levels as this evidence can honestly separate.
|
||
const _AB_CONF_BANDS = [
|
||
{ max: 19, pct: 16, label: 'Guess' }, // 16.4% measured (n=55)
|
||
{ max: 34, pct: 47, label: 'Doubtful' }, // 47.1% measured (n=210)
|
||
{ max: 49, pct: 69, label: 'Probably' }, // 68.8% measured (n=240)
|
||
{ max: 64, pct: 75, label: 'Likely' }, // 75.4% measured (n=175)
|
||
{ max: 79, pct: 79, label: 'Likely' }, // 78.9% measured (n=175)
|
||
{ max: 100, pct: 96, label: 'Confident' }, // 95.6% measured (n=663)
|
||
];
|
||
|
||
function _abCalibrateConfidence(raw) {
|
||
for (const b of _AB_CONF_BANDS) if (raw <= b.max) return b;
|
||
return _AB_CONF_BANDS[_AB_CONF_BANDS.length - 1];
|
||
}
|
||
|
||
// A reviewer working through 1400 flagged lines needs to see what they have
|
||
// already dealt with — otherwise they lose their place and re-read the same
|
||
// lines. Marking a line checked is a human verdict that outranks the score:
|
||
// it turns the badge green and drops the line out of the review queue for
|
||
// good, whether the speaker was corrected or simply confirmed as fine.
|
||
function _abCheckBtnHtml(s) {
|
||
if (typeof s.conf !== 'number') return '';
|
||
const on = (s.confMark || (s.confChecked ? 'ok' : null)) === 'ok';
|
||
return `<button class="ab-cv-check${on ? ' is-checked' : ''}" type="button" title="${on
|
||
? 'Manually checked — click to un-check'
|
||
: 'Mark as manually checked (removes it from the review queue)'}"><span class="mdi mdi-${on ? 'check-circle' : 'check-circle-outline'}"></span></button>`;
|
||
}
|
||
|
||
function _abConfClass(conf) {
|
||
if (typeof conf !== 'number') return '';
|
||
return conf >= 80 ? 'ab-conf-green' : conf >= 50 ? 'ab-conf-orange' : 'ab-conf-red';
|
||
}
|
||
|
||
function _abConfBadgeHtml(s) {
|
||
if (typeof s.conf !== 'number') return '';
|
||
const cls = _abConfClass(s.conf);
|
||
const label = s.conf >= 80 ? 'Confident' : s.conf >= 50 ? 'Check this' : 'Likely wrong';
|
||
const why = s.confWhy ? ' — ' + s.confWhy : '';
|
||
// Integer, not a decimal: these are band averages over a few hundred lines
|
||
// each, so "95.4%" would imply a precision the measurement does not have.
|
||
const mark = s.confMark || (s.confChecked ? 'ok' : null);
|
||
if (mark === 'ok') return `<span class="ab-cv-conf ab-conf-checked" title="You confirmed this line (↑)">✓ Correct</span>`;
|
||
if (mark === 'wrong') return `<span class="ab-cv-conf ab-conf-wrong" title="You flagged this line as wrong (↓) — revisit it with the “Marked wrong” filter">✗ Wrong</span>`;
|
||
const word = s.confLabel || label;
|
||
return `<span class="ab-cv-conf ${cls}" title="${escHtml(word + ' — right about ' + s.conf + '% of the time' + why)}">${word} ${s.conf}%</span>`;
|
||
}
|
||
|
||
// Stamp every segment with its confidence so the UI can colour-code and the
|
||
// "next uncertain" navigation can skip what is already trustworthy.
|
||
function _abStampConfidence(segs) {
|
||
for (let i = 0; i < segs.length; i++) {
|
||
const { score, why } = _abSegmentConfidence(segs, i);
|
||
const band = _abCalibrateConfidence(score);
|
||
// Store the CALIBRATED percentage as `conf`, so every threshold in the UI
|
||
// (badge colour, "below 80%" review filter) is expressed in the same
|
||
// honest units the reviewer sees, rather than in raw heuristic points.
|
||
segs[i].conf = band.pct;
|
||
segs[i].confLabel = band.label;
|
||
segs[i].confRaw = score;
|
||
segs[i].confWhy = why.join('; ');
|
||
}
|
||
return segs;
|
||
}
|
||
|
||
function audiobookIsRouterModel(model) {
|
||
return /^auto[-_ ]?router/i.test(String(model || '').trim());
|
||
}
|
||
|
||
function audiobookSafeLlmModel(model) {
|
||
const m = String(model || '').trim();
|
||
const saved = String((typeof _appSettings !== 'undefined' && _appSettings && _appSettings.llm_model) || '').trim();
|
||
if (audiobookIsRouterModel(m) && saved && !audiobookIsRouterModel(saved)) return saved;
|
||
return m || saved;
|
||
}
|
||
|
||
function audiobookLlmUrl() { return $('reh-llm-url')?.value.trim() || (typeof _appSettings !== 'undefined' && _appSettings?.llm_url) || (typeof rehDefaultLlmUrl === 'function' ? rehDefaultLlmUrl() : ''); }
|
||
function audiobookLlmModel() { return audiobookSafeLlmModel($('reh-llm-model')?.value || ''); }
|
||
// Book language for the attribution LLM: the manual dropdown wins, otherwise
|
||
// detect it from the text itself (stop-word heuristic, utils.js detectLang) so
|
||
// the server's "keep names and wording in <language>" hint and grammar rules
|
||
// are applied even when nobody touched the dropdown.
|
||
function audiobookLang(text) {
|
||
const manual = $('reh-design-lang')?.value || '';
|
||
if (manual) return manual;
|
||
const sample = String(text || _audiobook.lastText || '').slice(0, 4000);
|
||
return (sample && typeof detectLang === 'function') ? (detectLang(sample) || '') : '';
|
||
}
|
||
|
||
function audiobookAttributeBody(fields, promptOverride = null) {
|
||
const prompt = typeof promptOverride === 'string' ? promptOverride.trim() : '';
|
||
return prompt ? { ...fields, audiobook_prompt: prompt } : fields;
|
||
}
|
||
|
||
function audiobookCurrentCastLlm(panel) {
|
||
const url = panel?.querySelector('#ab-cv-llm-url')?.value.trim() || audiobookLlmUrl();
|
||
const rawModel = panel?.querySelector('#ab-cv-llm-select')?.value || audiobookLlmModel();
|
||
return { url, model: audiobookSafeLlmModel(rawModel) };
|
||
}
|
||
|
||
function audiobookSaveLlmChoice(url, model) {
|
||
const cleanUrl = String(url || '').trim();
|
||
const cleanModel = audiobookSafeLlmModel(model);
|
||
if (typeof _appSettings !== 'undefined' && _appSettings) {
|
||
if (cleanUrl) _appSettings.llm_url = cleanUrl;
|
||
if (cleanModel) _appSettings.llm_model = cleanModel;
|
||
}
|
||
const patch = {};
|
||
if (cleanUrl) patch.llm_url = cleanUrl;
|
||
if (cleanModel) patch.llm_model = cleanModel;
|
||
if (Object.keys(patch).length) {
|
||
fetch('/api/settings', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(patch)
|
||
}).catch(() => {});
|
||
}
|
||
const rehModel = $('reh-llm-model');
|
||
if (rehModel && cleanModel && [...rehModel.options].some(o => o.value === cleanModel)) rehModel.value = cleanModel;
|
||
return { url: cleanUrl, model: cleanModel };
|
||
}
|
||
|
||
// Gather the plain text of the current reader scope (selection > page range > all).
|
||
// Also records PDF page boundaries as character offsets in the returned text
|
||
// (_audiobook.pageMarks) so saving to the Rehearser can reconstruct page breaks.
|
||
function audiobookScopeText() {
|
||
_audiobook.pageMarks = [];
|
||
if (typeof readerScopeIndices !== 'function' || !readerState?.sentences?.length) return '';
|
||
const idxs = readerScopeIndices();
|
||
const anchors = []; // {page, anchor} — first sentence of each new page
|
||
let lastPage = null;
|
||
for (const i of idxs) {
|
||
const u = readerState.sentences[i];
|
||
const pg = u?.words?.[0]?.page;
|
||
if (pg != null && pg !== lastPage) {
|
||
anchors.push({ page: pg, anchor: (u.text || '').trim().slice(0, 40) });
|
||
lastPage = pg;
|
||
}
|
||
}
|
||
// Join units with a blank line wherever one starts a real paragraph (per
|
||
// readerMarkParagraphBreaks/.paraStart) instead of unconditionally with a
|
||
// single space — otherwise chapter headings and every paragraph break in
|
||
// the book collapse into one run-on blob before the LLM ever sees the text.
|
||
let raw = '';
|
||
for (const i of idxs) {
|
||
const u = readerState.sentences[i];
|
||
if (!u?.text) continue;
|
||
raw += !raw ? u.text : (u.paraStart ? '\n\n' : ' ') + u.text;
|
||
}
|
||
// Collapse only horizontal whitespace runs and cap excessive blank lines —
|
||
// a plain /\s+/ collapse here would erase the \n\n paragraph markers just inserted.
|
||
raw = raw.replace(/[ \t]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
|
||
const text = audiobookDehyphenate(raw); // mend PDF line-break hyphenation for clean speech + tag matching
|
||
// Locate each page anchor in the final text → page-break offsets.
|
||
let from = 0;
|
||
for (const a of anchors) {
|
||
const probe = audiobookDehyphenate(a.anchor).slice(0, 24);
|
||
if (!probe) continue;
|
||
const pos = text.indexOf(probe, from);
|
||
if (pos >= 0) { _audiobook.pageMarks.push({ offset: pos, page: a.page }); from = pos + probe.length; }
|
||
}
|
||
return text;
|
||
}
|
||
|
||
// ── Progress overlay ─────────────────────────────────────────────────────────
|
||
|
||
function audiobookProgress(total) {
|
||
let ov = document.getElementById('audiobook-overlay');
|
||
if (!ov) {
|
||
ov = document.createElement('div');
|
||
ov.id = 'audiobook-overlay';
|
||
ov.className = 'audiobook-overlay';
|
||
ov.innerHTML = `<div class="audiobook-box">
|
||
<div class="audiobook-title"><span class="mdi mdi-drama-masks"></span> Casting audiobook</div>
|
||
<div class="audiobook-msg" id="audiobook-msg">Analysing…</div>
|
||
<div class="reader-synth-track"><div class="reader-synth-fill" id="audiobook-fill"></div></div>
|
||
<div class="audiobook-actions"><button class="btn-secondary btn-sm" id="audiobook-cancel">Cancel</button></div>
|
||
</div>`;
|
||
document.body.appendChild(ov);
|
||
ov.querySelector('#audiobook-cancel').addEventListener('click', () => { _audiobook.cancel = true; });
|
||
}
|
||
ov.hidden = false;
|
||
const fill = ov.querySelector('#audiobook-fill');
|
||
const msg = ov.querySelector('#audiobook-msg');
|
||
return {
|
||
update(done, label) { if (fill) fill.style.width = (done / total * 100) + '%'; if (msg && label) msg.textContent = label; },
|
||
done() { ov.hidden = true; },
|
||
};
|
||
}
|
||
|
||
// Delegates to the character library's canonical colour implementation
|
||
// (clNormalizeColor / clHslToHex / clNameHue in characters-library.js) so
|
||
// avatar colours can't drift between views; only the 'Narrator' default for a
|
||
// missing name lives here.
|
||
function _abNormalizeColor(color, fallbackName) {
|
||
return clNormalizeColor(color, fallbackName || 'Narrator');
|
||
}
|
||
|
||
function _abDefaultCharacterColor(name) {
|
||
if (/^Unknown|Unbekannt/i.test(name || '')) return '#a83232';
|
||
return _abNormalizeColor(null, name);
|
||
}
|
||
|
||
function _abRecordColor(rec, name) {
|
||
return _abNormalizeColor(rec?.color || rec?.sheet?.color, name || rec?.name);
|
||
}
|
||
|
||
// Escape a segment's text and underline any known character names. Module-level
|
||
// so the review/preview overlay (audiobookShowPreview) can use it too — the cast
|
||
// view (audiobookCastView) defines its own roster-coloured version that shadows
|
||
// this inside its closure. Names default to the current run's roster.
|
||
// Guillemets are the clearest visual cue for "this is spoken" — and in German
|
||
// prose narration is never quoted, so showing them makes a mislabeled line
|
||
// obvious at a glance. Extraction strips them from most segments, so they are
|
||
// rendered rather than stored: the saved text is left exactly as cast, and the
|
||
// marks are added for DISPLAY only on dialogue rows that lack them.
|
||
let _abShowQuotes = (() => { try { return localStorage.getItem('ab-show-quotes') !== '0'; } catch (_) { return true; } })();
|
||
function _abDisplayText(s) {
|
||
const t = String(s?.text || '');
|
||
if (s?.type !== 'dialogue' || !t.trim()) return t;
|
||
if (/^\s*[»„"']/.test(t)) return t; // already carries its own marks
|
||
return '»' + t.trim() + '«';
|
||
}
|
||
// Wrap guillemets in their own element AFTER escaping/highlighting, so hiding
|
||
// them is a pure CSS class flip on the container rather than a text rewrite and
|
||
// a full redraw of every row — CSS cannot target a character inside a text node,
|
||
// only an element. The marks stay in the DOM (and in the stored text, which is
|
||
// never touched); they are merely display:none when the toggle is off.
|
||
function _abMarkQuotes(html) {
|
||
return String(html || '').replace(/([»«„“”])/g, '<span class="ab-q">$1</span>');
|
||
}
|
||
function audiobookToggleQuotes(on) {
|
||
_abShowQuotes = (on === undefined) ? !_abShowQuotes : !!on;
|
||
try { localStorage.setItem('ab-show-quotes', _abShowQuotes ? '1' : '0'); } catch (_) {}
|
||
document.querySelectorAll('.ab-cv-quote-toggle').forEach(b => {
|
||
b.classList.toggle('is-on', _abShowQuotes);
|
||
b.title = _abShowQuotes ? 'Hide quotation marks' : 'Show quotation marks';
|
||
});
|
||
// One class on the root — instant, and cheap even with a couple of thousand rows.
|
||
document.body.classList.toggle('ab-hide-quotes', !_abShowQuotes);
|
||
return _abShowQuotes;
|
||
}
|
||
try { document.body.classList.toggle('ab-hide-quotes', !_abShowQuotes); } catch (_) {}
|
||
window.audiobookToggleQuotes = audiobookToggleQuotes;
|
||
|
||
function highlightText(text, names) {
|
||
if (!text) return '';
|
||
let html = escHtml(text);
|
||
const list = (names || (_audiobook && _audiobook.roster) || [])
|
||
.filter(n => n && n.toLowerCase() !== 'narrator' && !/^Unknown|Unbekannt/i.test(n))
|
||
.sort((a, b) => b.length - a.length);
|
||
list.forEach((name) => {
|
||
if (name.length < 2) return;
|
||
const safe = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||
const color = _abDefaultCharacterColor(name);
|
||
html = html.replace(new RegExp(`\\b(${safe})\\b`, 'gi'),
|
||
m => `<span style="border-bottom: 2px solid ${color}; font-weight: 600;">${m}</span>`);
|
||
});
|
||
return html;
|
||
}
|
||
|
||
// Small dropdown anchored to the "Character options" caret next to "View
|
||
// Characters", once a book's already been cast before — offers the existing
|
||
// full character-definition pass plus a targeted "define just these characters" flow.
|
||
// Lightweight "working on it" overlay for operations that block the main
|
||
// thread for a noticeable moment (e.g. rewriting + redrawing thousands of
|
||
// segments on a character merge) — without this, a long synchronous chunk
|
||
// of work just makes the page stop responding with no visible cause, which
|
||
// reads as a crash rather than "still working". Returns the overlay element;
|
||
// call .remove() on it when the work finishes.
|
||
function _abShowBusyOverlay(message, withProgress) {
|
||
const ov = document.createElement('div');
|
||
ov.className = 'audiobook-overlay ab-busy-overlay';
|
||
ov.innerHTML = `<div class="audiobook-box" style="text-align:center;">
|
||
<span class="mdi mdi-loading mdi-spin" style="font-size:28px; color:var(--accent);"></span>
|
||
<div class="audiobook-msg ab-busy-msg" style="margin:12px 0 0;">${escHtml(message)}</div>
|
||
${withProgress ? '<div class="reader-synth-track" style="margin-top:10px"><div class="reader-synth-fill ab-busy-fill" style="width:0%"></div></div>' : ''}
|
||
</div>`;
|
||
document.body.appendChild(ov);
|
||
ov.setProgress = (done, total) => {
|
||
const fill = ov.querySelector('.ab-busy-fill');
|
||
if (fill && total) fill.style.width = Math.round((done / total) * 100) + '%';
|
||
const msgEl = ov.querySelector('.ab-busy-msg');
|
||
if (msgEl) msgEl.textContent = `${message} (${done} / ${total})`;
|
||
};
|
||
return ov;
|
||
}
|
||
|
||
// Generic flyout menu for grouped toolbar/footer buttons — fixed-position,
|
||
// appended to <body>, anchored above its trigger via getBoundingClientRect
|
||
// (not nested inside a clipping/overflow:hidden ancestor). Earlier casting
|
||
// footer had a dropdown that opened in the wrong place because it wasn't
|
||
// positioned this way; this mirrors the alias popup's proven approach instead.
|
||
let _abFootMenuEl = null;
|
||
function _abCloseFootMenu() {
|
||
if (!_abFootMenuEl) return;
|
||
document.getElementById(_abFootMenuEl.dataset.forId)?.classList.remove('is-menu-open');
|
||
_abFootMenuEl.remove();
|
||
_abFootMenuEl = null;
|
||
document.removeEventListener('click', _abFootMenuOutside, true);
|
||
document.removeEventListener('keydown', _abFootMenuKey, true);
|
||
}
|
||
function _abFootMenuOutside(e) {
|
||
if (_abFootMenuEl && !_abFootMenuEl.contains(e.target) && !e.target.closest('.ab-foot-trigger')) _abCloseFootMenu();
|
||
}
|
||
function _abFootMenuKey(e) { if (e.key === 'Escape') _abCloseFootMenu(); }
|
||
function _abToggleFootMenu(triggerBtn, items) {
|
||
const reopening = _abFootMenuEl && _abFootMenuEl.dataset.forId === triggerBtn.id;
|
||
_abCloseFootMenu();
|
||
if (reopening) return;
|
||
const el = document.createElement('div');
|
||
el.className = 'ab-foot-menu';
|
||
el.dataset.forId = triggerBtn.id;
|
||
el.innerHTML = items.map((it, i) => it.divider
|
||
? '<div class="ab-foot-menu-sep"></div>'
|
||
: `<button type="button" class="ab-foot-menu-item${it.danger ? ' is-danger' : ''}" data-idx="${i}" ${it.disabled ? 'disabled' : ''} title="${escHtml(it.title || '')}"><span class="mdi ${it.icon}"></span><span class="ab-foot-menu-item-label">${escHtml(it.label)}</span></button>`
|
||
).join('');
|
||
document.body.appendChild(el);
|
||
const rect = triggerBtn.getBoundingClientRect();
|
||
el.style.left = Math.max(8, Math.min(rect.left, window.innerWidth - el.offsetWidth - 8)) + 'px';
|
||
// These buttons used to live only in the casting panel's footer at the bottom
|
||
// of the screen, so the menu was hard-anchored to open upwards. In Studio the
|
||
// same toolbar sits near the TOP of the page, where opening upwards pushed the
|
||
// menu off-screen and silently clipped its first entries (confirmed live: the
|
||
// first two items were unreachable). Pick the side with room, preferring down.
|
||
const menuH = el.offsetHeight;
|
||
const spaceBelow = window.innerHeight - rect.bottom;
|
||
const spaceAbove = rect.top;
|
||
if (spaceBelow >= menuH + 12 || spaceBelow >= spaceAbove) {
|
||
el.style.top = Math.min(rect.bottom + 6, Math.max(8, window.innerHeight - menuH - 8)) + 'px';
|
||
el.style.bottom = 'auto';
|
||
} else {
|
||
el.style.bottom = (window.innerHeight - rect.top + 6) + 'px';
|
||
el.style.top = 'auto';
|
||
}
|
||
el.querySelectorAll('.ab-foot-menu-item').forEach((btn) => {
|
||
btn.addEventListener('click', () => {
|
||
const it = items[Number(btn.dataset.idx)];
|
||
_abCloseFootMenu();
|
||
it?.onClick?.();
|
||
});
|
||
});
|
||
_abFootMenuEl = el;
|
||
triggerBtn.classList.add('is-menu-open');
|
||
setTimeout(() => {
|
||
document.addEventListener('click', _abFootMenuOutside, true);
|
||
document.addEventListener('keydown', _abFootMenuKey, true);
|
||
}, 0);
|
||
}
|
||
|
||
// Checkbox picker for the selected-character sheet generation flow.
|
||
// csForReaderSelective narrows extraction down to just the passages mentioning
|
||
// the picked character(s) (plus neighbouring context) instead of the whole book.
|
||
// The helper it calls is alias-aware, so selecting Darrag also catches evidence
|
||
// windows where the text uses one of his known alternate names.
|
||
function _abOpenRecastSelectPopup(existingChars) {
|
||
const ov = document.createElement('div');
|
||
ov.className = 'audiobook-overlay';
|
||
// Same avatar/name/line-count list style as the "Characters found" sidebar
|
||
// in the live casting view, instead of a bare alphabetical checkbox wall —
|
||
// picking a character to re-cast is much easier when you can see their
|
||
// portrait and how much dialogue they actually have. Selection state lives
|
||
// in `selected` (not just checkbox DOM state) so it survives re-render on
|
||
// search/sort.
|
||
const selected = new Set();
|
||
let sort = 'lines', filter = '';
|
||
try { sort = localStorage.getItem('ttsvc_ab_recast_sort') || 'lines'; } catch (_) {}
|
||
|
||
const rowHtml = (c) => {
|
||
const lineCount = c?.sheet?.line_count || 0;
|
||
const color = _abRecordColor(c, c.name);
|
||
const avatar = c?.image
|
||
? `<span class="ab-char-dot ab-char-dot-img" style="border-color:${color}"><img src="${escHtml(c.image)}" alt=""></span>`
|
||
: `<span class="ab-char-dot" style="background:${color}">${escHtml((c?.name || '?')[0].toUpperCase())}</span>`;
|
||
return `<label class="ab-char-item" data-name="${escHtml(c.name)}">
|
||
<input type="checkbox" class="ab-recast-cb" value="${escHtml(c.name)}"${selected.has(c.name) ? ' checked' : ''}>
|
||
${avatar}
|
||
<span class="ab-char-name">${escHtml(c.name)}</span>
|
||
<b class="ab-char-count">${lineCount}</b>
|
||
</label>`;
|
||
};
|
||
const render = () => {
|
||
const q = filter.trim().toLowerCase();
|
||
const items = existingChars
|
||
.filter(c => !q || (c.name || '').toLowerCase().includes(q))
|
||
.sort(sort === 'alpha'
|
||
? (a, b) => (a.name || '').localeCompare(b.name || '')
|
||
: (a, b) => (b.sheet?.line_count || 0) - (a.sheet?.line_count || 0));
|
||
const list = ov.querySelector('.ab-recast-select-list');
|
||
if (!list) return;
|
||
list.innerHTML = items.length ? items.map(rowHtml).join('') : '<div class="ab-cv-empty">No matches</div>';
|
||
list.querySelectorAll('.ab-recast-cb').forEach(cb => {
|
||
cb.addEventListener('change', () => { if (cb.checked) selected.add(cb.value); else selected.delete(cb.value); });
|
||
});
|
||
};
|
||
|
||
ov.innerHTML = '<div class="audiobook-box ab-recast-dialog">'
|
||
+ '<div class="audiobook-title"><span class="mdi mdi-account-details-outline"></span> Select characters to cast or recast roles</div>'
|
||
+ '<div class="audiobook-msg">Only re-reads the passages that mention the characters you pick below, including known aliases, plus a little surrounding context. Everyone else\'s sheet stays as-is.</div>'
|
||
+ '<div class="ab-cv-side-tools">'
|
||
+ '<input type="text" class="ab-cv-side-search" id="ab-recast-search" placeholder="Search characters..." autocomplete="off">'
|
||
+ '<select class="ab-cv-side-sort" id="ab-recast-sort" title="Sort">'
|
||
+ '<option value="lines">Lines</option>'
|
||
+ '<option value="alpha">A–Z</option>'
|
||
+ '</select>'
|
||
+ '</div>'
|
||
+ '<div class="ab-recast-select-list"></div>'
|
||
+ '<div class="audiobook-actions">'
|
||
+ '<button class="btn-secondary btn-sm" id="ab-recast-select-all">Select all</button>'
|
||
+ '<span style="flex:1"></span>'
|
||
+ '<button class="btn-secondary btn-sm" id="ab-recast-cancel">Cancel</button>'
|
||
+ '<button class="btn-primary btn-sm" id="ab-recast-confirm">Generate selected sheets</button>'
|
||
+ '</div>'
|
||
+ '</div>';
|
||
document.body.appendChild(ov);
|
||
render();
|
||
|
||
const sortSel = ov.querySelector('#ab-recast-sort');
|
||
sortSel.value = sort;
|
||
sortSel.addEventListener('change', () => {
|
||
sort = sortSel.value;
|
||
try { localStorage.setItem('ttsvc_ab_recast_sort', sort); } catch (_) {}
|
||
render();
|
||
});
|
||
let _searchT = null;
|
||
ov.querySelector('#ab-recast-search').addEventListener('input', (e) => {
|
||
clearTimeout(_searchT);
|
||
const v = e.target.value;
|
||
_searchT = setTimeout(() => { filter = v; render(); }, 120);
|
||
});
|
||
ov.querySelector('#ab-recast-cancel').addEventListener('click', () => ov.remove());
|
||
ov.querySelector('#ab-recast-select-all').addEventListener('click', (e) => {
|
||
const allSelected = existingChars.length > 0 && existingChars.every(c => selected.has(c.name));
|
||
if (allSelected) selected.clear();
|
||
else existingChars.forEach(c => selected.add(c.name));
|
||
e.currentTarget.textContent = allSelected ? 'Select all' : 'Select none';
|
||
render();
|
||
});
|
||
ov.querySelector('#ab-recast-confirm').addEventListener('click', async () => {
|
||
// The DOM checkboxes are the source of truth at confirmation time. The
|
||
// Set is only a render/search convenience and could become stale after a
|
||
// filtered list was rebuilt, which previously allowed a one-character
|
||
// selection to fall through as a full-roster recast.
|
||
const names = [...ov.querySelectorAll('.ab-recast-cb:checked')].map(cb => cb.value).filter(Boolean);
|
||
if (!names.length) { toast('Select at least one character', 'error'); return; }
|
||
ov.remove();
|
||
if (typeof window.audiobookRecastSelectedCharacters === 'function') await window.audiobookRecastSelectedCharacters(names);
|
||
else if (typeof window.csForReaderSelective === 'function') await window.csForReaderSelective(names);
|
||
});
|
||
}
|
||
|
||
async function audiobookRecastSelectedCharacters(selectedNames) {
|
||
if (typeof window.csForReaderSelective === 'function') return window.csForReaderSelective(selectedNames);
|
||
toast('Character-sheet recast is unavailable right now', 'error');
|
||
return null;
|
||
}
|
||
window.audiobookRecastSelectedCharacters = audiobookRecastSelectedCharacters;
|
||
window.TTVC = window.TTVC || {};
|
||
window.TTVC.audiobook = window.TTVC.audiobook || {};
|
||
window.TTVC.audiobook.recastSelectedCharacters = audiobookRecastSelectedCharacters;
|
||
|
||
// Live casting view: a scrolling feed of attributed lines + a character roster
|
||
// that fills up as speakers are discovered. Far clearer than a bare bar.
|
||
// content-visibility:auto on .ab-cv-page (added to keep a long book's DOM
|
||
// cheap to render) means every off-screen page's height is only an ESTIMATE
|
||
// (contain-intrinsic-size) until the browser actually measures it — so a
|
||
// single scrollIntoView() computed against a target many pages away lands
|
||
// wherever the SUM of all those estimation errors puts it, sometimes
|
||
// thousands of pixels off. Confirmed live: focusing a character's first
|
||
// line scrolled to `top: -4098px`, nowhere near the visible feed. A second,
|
||
// corrective call after the browser has had a chance to actually lay out
|
||
// whatever came into view during the first (rough) pass fixes this without
|
||
// giving up the performance win — RAF x2 reliably waits past style/layout.
|
||
function _abScrollIntoView(el, opts) {
|
||
if (!el) return;
|
||
el.scrollIntoView(Object.assign({ behavior: 'auto' }, opts));
|
||
requestAnimationFrame(() => requestAnimationFrame(() => {
|
||
el.scrollIntoView(Object.assign({ behavior: 'smooth' }, opts));
|
||
}));
|
||
}
|
||
|
||
|
||
// ── Wiring ───────────────────────────────────────────────────────────────────
|
||
|
||
$('reader-audiobook-btn')?.addEventListener('click', audiobookOpenCastView);
|
||
$('reh-tb-audiobook')?.addEventListener('click', audiobookExportDialog);
|
||
|
||
// Build a rehearsal record object from the current segments.
|
||
// If _audiobook.rehId is set, fetches the existing record so voice assignments
|
||
// made in Script Rehearser are preserved when we overwrite the script text.
|
||
async function _audiobookBuildRehRecord(segs) {
|
||
const { script, emotions } = audiobookBuildScript(segs);
|
||
const title = (typeof readerState !== 'undefined' && readerState.title) ? readerState.title : 'Audiobook';
|
||
const lines = (typeof parseScript === 'function') ? parseScript(script) : [];
|
||
|
||
// Map emotions onto lines so detectCharacters picks them up
|
||
if (emotions && emotions.length) {
|
||
let eIdx = 0;
|
||
lines.forEach(l => { if (l.type === 'dialog' && eIdx < emotions.length) { if (emotions[eIdx]) l.emotion = emotions[eIdx]; eIdx++; } });
|
||
}
|
||
|
||
// Build cast from detected speakers
|
||
const cast = {};
|
||
if (typeof detectCharacters === 'function') {
|
||
const detected = detectCharacters(lines);
|
||
Object.entries(detected).forEach(([sp, def]) => {
|
||
cast[sp] = { voice: def.voice, color: def.color, instruct: '', lang: '', gender: '', tags: '', soul: '', ignored: false, hidden: false, voiceData: null };
|
||
});
|
||
}
|
||
|
||
// Fetch the existing record and merge its cast so voice assignments survive an update
|
||
let existing = null;
|
||
if (_audiobook.rehId && typeof window.rehDbGetById === 'function') {
|
||
try { existing = await window.rehDbGetById(_audiobook.rehId); } catch (_) {}
|
||
}
|
||
if (existing && existing.cast) {
|
||
Object.entries(existing.cast).forEach(([sp, info]) => {
|
||
if (cast[sp]) cast[sp] = { ...cast[sp], ...info }; // overlay saved voice/instruct/etc.
|
||
else cast[sp] = info; // speaker was removed from segments but keep their info
|
||
});
|
||
}
|
||
|
||
const emotions_map = {};
|
||
lines.forEach((l, i) => { if (l.type === 'dialog' && l.emotion) emotions_map[i] = l.emotion; });
|
||
|
||
return {
|
||
title, script, cast,
|
||
emotions: emotions_map,
|
||
notes: existing ? (existing.notes || {}) : {},
|
||
ignored: existing ? (existing.ignored || {}) : {},
|
||
hidden: existing ? (existing.hidden || {}) : {},
|
||
backend: existing ? (existing.backend || '') : '',
|
||
narratorVoice: existing ? (existing.narratorVoice || '') : '',
|
||
lineIndex: existing ? (existing.lineIndex || 0) : 0,
|
||
clips: existing ? (existing.clips || []) : [],
|
||
created: existing ? existing.created : new Date(),
|
||
updated: new Date(),
|
||
};
|
||
}
|
||
|
||
let _abRehSaveTimer = null;
|
||
|
||
// Save segments to the Script Rehearser IndexedDB.
|
||
// { silent: true } suppresses the toast and draft-clear (used for auto-saves).
|
||
async function audiobookSaveAsRehearsal(opts) {
|
||
const silent = opts && opts.silent;
|
||
const segs = _audiobook.segments;
|
||
if (!segs || !segs.length) { if (!silent) toast('No segments to save', 'error'); return; }
|
||
if (typeof rehDbAdd !== 'function') { if (!silent) toast('Rehearser DB not available', 'error'); return; }
|
||
|
||
try {
|
||
const rec = await _audiobookBuildRehRecord(segs);
|
||
if (_audiobook.rehId) {
|
||
rec.id = _audiobook.rehId;
|
||
await rehDbPut(rec);
|
||
} else {
|
||
_audiobook.rehId = await rehDbAdd(rec);
|
||
}
|
||
if (typeof renderLibraryList === 'function') renderLibraryList();
|
||
if (!silent) {
|
||
_abClearDraft();
|
||
toast('Saved as Script Rehearsal', 'success');
|
||
}
|
||
} catch (e) {
|
||
if (!silent) toast('Failed to save rehearsal: ' + e.message, 'error');
|
||
else console.warn('[audiobook] auto-save failed:', e);
|
||
}
|
||
}
|
||
|
||
// Debounced silent save — called after each manual speaker correction
|
||
function _audiobookDebouncedSave() {
|
||
clearTimeout(_abRehSaveTimer);
|
||
_abRehSaveTimer = setTimeout(() => audiobookSaveAsRehearsal({ silent: true }), 1500);
|
||
}
|
||
|
||
function audiobookExportDialog() {
|
||
if (_audiobook.running) return;
|
||
if (!window.rehState || !(rehState.lines || []).length) { toast('Open a script in the rehearser first', 'error'); return; }
|
||
if (!rehState.backend) { toast('Select a TTS backend in the rehearser first', 'error'); return; }
|
||
|
||
const speakable = i => {
|
||
const l = rehState.lines[i];
|
||
if (!l || l.ignored || l.hidden) return false;
|
||
if (l.type === 'dialog') { const c = rehState.cast[l.speaker]; return !!(c && c.voice && c.voice !== 'me'); }
|
||
return !!(rehState.narratorVoice && (l.text || '').trim());
|
||
};
|
||
const buckets = [];
|
||
let cur = null;
|
||
rehState.lines.forEach((l, i) => {
|
||
if (audiobookIsChapter(l)) { cur = { title: (typeof stripMarkdown === 'function' ? stripMarkdown(l.text) : l.text).trim().slice(0, 50), idx: [] }; buckets.push(cur); }
|
||
if (speakable(i)) { if (!cur) { cur = { title: '', idx: [] }; buckets.push(cur); } cur.idx.push(i); }
|
||
});
|
||
|
||
const listEl = document.getElementById('ab-export-chapter-list');
|
||
if (listEl) {
|
||
listEl.innerHTML = '';
|
||
const countEl = document.getElementById('ab-export-chapter-count');
|
||
if (countEl) countEl.textContent = buckets.length;
|
||
// Numbering here is display-only (see _abChapterLabels) — bucket
|
||
// *indices* (chk.value) are untouched so opts.selectedChapterIndices in
|
||
// the actual export still lines up.
|
||
const labels = _abChapterLabels(buckets);
|
||
buckets.forEach((b, i) => {
|
||
const lbl = document.createElement('label');
|
||
lbl.style.display = 'block';
|
||
lbl.style.marginBottom = '4px';
|
||
const chk = document.createElement('input');
|
||
chk.type = 'checkbox';
|
||
chk.checked = true;
|
||
chk.value = i;
|
||
chk.className = 'ab-export-chapter-cb';
|
||
lbl.appendChild(chk);
|
||
lbl.appendChild(document.createTextNode(' ' + labels[i]));
|
||
listEl.appendChild(lbl);
|
||
});
|
||
}
|
||
|
||
const warn = document.getElementById('reh-tone-warn');
|
||
const slot = document.getElementById('ab-export-tone-warn-slot');
|
||
if (warn && slot) {
|
||
warn.hidden = false;
|
||
slot.appendChild(warn);
|
||
}
|
||
|
||
if (typeof _abInitPauseUI === 'function') _abInitPauseUI();
|
||
|
||
const modal = document.getElementById('audiobook-export-modal');
|
||
if (modal) {
|
||
if (modal.parentElement !== document.body) {
|
||
document.body.appendChild(modal);
|
||
// Bind event listeners once when the modal is first moved
|
||
document.getElementById('ab-export-modal-close')?.addEventListener('click', () => modal.style.display = 'none');
|
||
document.getElementById('ab-export-modal-cancel')?.addEventListener('click', () => modal.style.display = 'none');
|
||
document.getElementById('ab-export-modal-start')?.addEventListener('click', () => {
|
||
modal.style.display = 'none';
|
||
const formatEl = document.querySelector('input[name="ab_export_format"]:checked');
|
||
const format = formatEl ? formatEl.value : 'chapter';
|
||
const folderEl = document.getElementById('ab-export-server-folder');
|
||
const folder = folderEl ? folderEl.value : '';
|
||
const checkboxes = Array.from(document.querySelectorAll('.ab-export-chapter-cb'));
|
||
const selectedChapterIndices = checkboxes.filter(cb => cb.checked).map(cb => parseInt(cb.value, 10));
|
||
audiobookExport({ format, selectedChapterIndices, folder });
|
||
});
|
||
}
|
||
modal.style.display = 'flex';
|
||
}
|
||
}
|