dsh-vidi 0.10.0 → 0.10.2

package/lib/client.js

@@ -40155,13 +40155,20 @@ body > .dshl-menu { z-index: 2147483002; }
 
 /* ── Outside the plugin view: sidebar entry and the composer's paste prompt (host tokens directly) ── */
 .dshl-sidebtn { position: relative; isolation: isolate; display: flex; align-items: center; gap: 8px; flex: 0 0 auto; overflow: hidden; border: 0; background: none; cursor: pointer;
-  color: var(--dsw-alias-label-primary, #1b1b19); font-family: inherit; font-size: 14px; line-height: 22px; box-sizing: border-box; }
-.dshl-sidebtn.wide { width: calc(100% + 4px); height: 42px; margin: 4px -2px 0; padding: 0 10px 0 8px; border-radius: 12px; }
-.dshl-sidebtn.rail { justify-content: center; width: 36px; height: 36px; margin: 8px 0 0; padding: 0; border-radius: 50%; }
-.dshl-sidebtn:hover { background: var(--dsw-alias-interactive-bg-hover, rgba(0,0,0,.05)); }
+  color: var(--dsw-alias-label-primary, #1b1b19); font-family: inherit; font-size: 14px; line-height: 22px; text-align: left; box-sizing: border-box; border-radius: var(--dsw-radius-md, 12px); }
+/* Lined up with the account row at the sidebar foot: the same 2px inset and 6px padding, the icon centred in a
+   24px slot like the avatar, so icon centre and label start match the row below. */
+.dshl-sidebtn.wide { width: calc(100% - 4px); height: 34px; margin: 4px 2px 0; padding: 6px; }
+/* The footer row holds every plugin's button: wide buttons take a line each, rail icons stack.
+   DSH wraps each slot entry in a display:contents element, so the row is the button's grandparent. */
+div:has(> .dshl-sidebtn.wide), div:has(> div > .dshl-sidebtn.wide) { flex-wrap: wrap; }
+div:has(> .dshl-sidebtn.rail), div:has(> div > .dshl-sidebtn.rail) { flex-direction: column; align-items: center; }
+.dshl-sidebtn.rail { justify-content: center; width: 36px; height: 36px; margin: 8px 0 0; padding: 0; }
+.dshl-sidebtn:hover { background-color: var(--dsw-alias-interactive-bg-hover, rgba(0,0,0,.05)); }
 .dshl-sidebtn svg { flex: none; }
-/* The mark is drawn at 18px; the host's sidebar icons are 16px. Same centre, same text start. */
-.dshl-sidebtn.wide svg { margin: 0 -1px; }
+/* The host's sidebar icons: 16px in the wide sidebar, 18px in the narrow one. */
+.dshl-sidebtn.wide svg { width: 16px; height: 16px; margin: 0 4px; }
+.dshl-sidebtn.rail svg { width: 18px; height: 18px; }
 .dshl-sidebtn .label { position: relative; overflow: hidden; white-space: nowrap; }
 .dshl-sidebtn .meta { margin-left: auto; color: var(--dsw-alias-label-secondary, #66655f); font-size: 12px; font-variant-numeric: tabular-nums; white-space: nowrap; }
 .dshl-sidebtn .bg { position: absolute; inset: 0; z-index: -1; background: var(--thumb) center / cover no-repeat; opacity: .38; filter: saturate(.85);

package/lib/index.mjs

@@ -360,6 +360,286 @@ var Glossary = class {
 		}
 	}
 };
+// src/align.ts
+/**
+* Does each translation sit on its own line? A model translating several lines at once sometimes
+* joins two and writes every later translation one line off. Numbers and Latin-script words
+* (names, products) survive translation as they are, so they tell which line a translation
+* belongs to.
+*/
+const CJK_NUM = /[〇零一二两三四五六七八九十百千万亿萬億]{2}/;
+const LATIN_STOP = /* @__PURE__ */ new Set([
+	"the",
+	"and",
+	"for",
+	"that",
+	"this",
+	"with",
+	"you",
+	"are",
+	"was",
+	"not",
+	"but",
+	"have",
+	"from",
+	"they",
+	"what",
+	"ok",
+	"okay"
+]);
+/** The numbers in a text ("1,200" = "1200"; "5.5" stays one number). */
+function numbers(text) {
+	return new Set((text.match(/\d+(?:[.,]\d+)*/g) ?? []).map((n) => n.replace(/,(?=\d{3}\b)/g, "").replace(/,/g, ".")));
+}
+/** Latin-script words of a text, lowercased (short and everyday ones left out). */
+function words(text) {
+	return new Set((text.toLowerCase().match(/[a-z][a-z'’-]*[a-z]/g) ?? []).filter((w) => w.length > 2 && !LATIN_STOP.has(w)));
+}
+const NON_LATIN = /* @__PURE__ */ new Set([
+	"zh",
+	"zh-Hant",
+	"ja",
+	"ko",
+	"ru",
+	"ar",
+	"hi",
+	"th"
+]);
+/** Is this translation of line `i` more likely a neighbour's? */
+function shifted(lines, i, lang) {
+	const me = lines[i], tr = me.tr?.[lang];
+	if (!tr) return false;
+	const near = [lines[i - 1], lines[i + 1]].filter((x) => !!x);
+	const srcN = numbers(me.src), trN = numbers(tr);
+	for (const n of trN) if (!srcN.has(n) && near.some((x) => numbers(x.src).has(n))) return true;
+	for (const n of srcN) if (!trN.has(n) && near.some((x) => !numbers(x.src).has(n) && numbers(x.tr?.[lang] ?? "").has(n))) return true;
+	if (srcN.size && !trN.size && !(NON_LATIN.has(lang) && CJK_NUM.test(tr)) && [...srcN].some((n) => n.length > 1)) return true;
+	if (NON_LATIN.has(lang)) {
+		const srcW = words(me.src);
+		for (const w of words(tr)) if (!srcW.has(w) && near.some((x) => words(x.src).has(w))) return true;
+	}
+	if (near.some((x) => x.tr?.[lang] === tr && x.src.trim() !== me.src.trim()) && tr.length > 4) return true;
+	return false;
+}
+/**
+* The lines whose translation cannot be trusted: missing, or looking like a neighbour's. A shift
+* runs on over the following lines, so everything between the first and the last sign of one
+* (and a line either side) is included.
+*/
+function suspects(lines, targets) {
+	const bad = /* @__PURE__ */ new Set();
+	let first = -1, last = -1;
+	lines.forEach((l, i) => {
+		if (targets.some((t) => !l.tr?.[t]?.trim())) {
+			bad.add(l.id);
+			return;
+		}
+		if (targets.some((t) => shifted(lines, i, t))) {
+			if (first < 0) first = i;
+			last = i;
+		}
+	});
+	if (first >= 0) for (let i = Math.max(0, first - 1); i <= Math.min(lines.length - 1, last + 1); i++) bad.add(lines[i].id);
+	return bad;
+}
+/** A reply's ids against the lines asked for: unknown, repeated or out of order means the numbering cannot be trusted. */
+function misnumbered(asked, got) {
+	let at = -1;
+	const seen = /* @__PURE__ */ new Set();
+	for (const id of got) {
+		const i = asked.indexOf(id);
+		if (i < 0 || seen.has(id) || i < at) return true;
+		seen.add(id);
+		at = i;
+	}
+	return false;
+}
+/** How alike two versions of a line are (0–1): shared words, or shared characters where there are no spaces. */
+function alike(a, b) {
+	const units = (s) => {
+		const w = s.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+		return new Set(w.length > 2 && !/[぀-鿿가-힯]/.test(s) ? w : [...s.replace(/[\s\p{P}]/gu, "")]);
+	};
+	const x = units(a), y = units(b);
+	if (!x.size || !y.size) return x.size === y.size ? 1 : 0;
+	let both = 0;
+	for (const u of x) if (y.has(u)) both++;
+	return both / Math.min(x.size, y.size);
+}
+// src/ask.ts
+/**
+* How long one request may take (ms). A request that sends nothing for `first` (before its first
+* piece) or `idle` (between pieces) hangs: it is given up and asked again. One that keeps sending
+* is alive (a model thinking at length), and only given up after `total`, or `perToken` for each
+* token of room it was given if that is longer.
+*/
+const LIMITS = {
+	first: 6e4,
+	idle: 4e4,
+	total: 18e4,
+	perToken: 40,
+	pause: 1500
+};
+/** The most a reply may be given, whatever the model. */
+const MAX_BUDGET = 32e3;
+/** Models seen thinking before they answer (their thinking counts against the reply's size). */
+const thinkers = /* @__PURE__ */ new Set();
+/** Models that refused a reply size: the largest they may be asked for. */
+const caps = /* @__PURE__ */ new Map();
+var AskError = class extends Error {
+	empty;
+	/** `empty`: the model answered, but with nothing usable (smaller pieces may do); otherwise it could not be reached. */
+	constructor(message, empty = false) {
+		super(message);
+		this.empty = empty;
+	}
+};
+/** Room for a reply: the answer, plus the thinking of a model that thinks first. */
+function budgetFor(key, answer, grown = 1) {
+	const want = (thinkers.has(key) ? answer * 2 + 6e3 : answer) * grown;
+	return Math.round(Math.min(want, caps.get(key) ?? MAX_BUDGET, MAX_BUDGET));
+}
+/**
+* One question to the subtitle model, answered as text. A request that hangs is cut off and asked
+* again; one that fails is asked again after a pause; an answer that came back empty or cut short
+* (a thinking model spent the room on its thoughts) is asked again with more room. Throws when no
+* try gave an answer, or at once when `signal` says to stop.
+*/
+async function ask(handle, o) {
+	const { provider, model } = handle.selection();
+	const key = `${provider}/${model}`;
+	const tries = o.tries ?? 3;
+	let grown = 1;
+	let last = "no answer", empty = false;
+	for (let n = 0; n < tries; n++) {
+		if (o.signal?.aborted) throw new AskError("stopped");
+		const maxTokens = budgetFor(key, o.maxTokens, grown);
+		let r;
+		try {
+			r = await once(handle, {
+				...o,
+				provider,
+				model,
+				maxTokens
+			});
+		} catch (err) {
+			if (o.signal?.aborted) throw new AskError("stopped");
+			last = err.message || String(err);
+			empty = false;
+			if (/max[_ ]?(completion[_ ])?tokens|maxTokens/i.test(last) && maxTokens > 1024) caps.set(key, Math.floor(maxTokens / 2));
+			else if (/^4\d\d\b/.test(last) && !/^4(08|09|25|29)\b/.test(last)) throw new AskError(last);
+			o.log?.(`${o.purpose}: ${last}${n + 1 < tries ? ", asking again" : ""}`);
+			if (n + 1 < tries) await sleep(LIMITS.pause * (n + 1), o.signal);
+			continue;
+		}
+		if (r.thought) thinkers.add(key);
+		if (r.text.trim() && !r.cut) return r.text;
+		if (r.cut || r.thought) thinkers.add(key);
+		last = r.cut ? `answer cut short at ${maxTokens} tokens` : "empty answer";
+		empty = true;
+		const more = budgetFor(key, o.maxTokens, grown * 2);
+		o.log?.(`${o.purpose}: ${last}${r.thought ? " (the model was thinking)" : ""}${n + 1 < tries ? `, asking again with room for ${more}` : ""}`);
+		if (more <= maxTokens && r.text.trim()) return r.text;
+		grown *= 2;
+	}
+	throw new AskError(last, empty);
+}
+async function once(handle, o) {
+	const ac = new AbortController();
+	const outer = () => ac.abort();
+	o.signal?.addEventListener("abort", outer, { once: true });
+	let giveUp;
+	const gaveUp = new Promise((_, reject) => {
+		giveUp = reject;
+	});
+	gaveUp.catch(() => {});
+	ac.signal.addEventListener("abort", () => giveUp(new AskError("stopped")), { once: true });
+	const started = Date.now();
+	const total = Math.max(LIMITS.total, o.maxTokens * LIMITS.perToken);
+	let timer;
+	const arm = (ms, what) => {
+		clearTimeout(timer);
+		const left = Math.min(ms, total - (Date.now() - started));
+		timer = setTimeout(() => {
+			giveUp(new AskError(left < ms ? `no complete answer in ${Math.round(total / 1e3)} s` : what));
+			ac.abort();
+		}, Math.max(0, left));
+	};
+	const it = handle.stream({
+		provider: o.provider,
+		model: o.model,
+		system: o.system,
+		maxTokens: o.maxTokens,
+		purpose: o.purpose,
+		signal: ac.signal,
+		messages: [createUserMessage({
+			content: [...o.image ? [o.image] : [], {
+				type: "text",
+				text: o.text
+			}],
+			source: {
+				kind: "plugin",
+				plugin: "dsh-vidi"
+			}
+		})]
+	})[Symbol.asyncIterator]();
+	const asm = new BlockAssembler();
+	let cut = false, thought = false;
+	try {
+		arm(LIMITS.first, `no answer in ${Math.round(LIMITS.first / 1e3)} s`);
+		for (;;) {
+			const step = await Promise.race([it.next(), gaveUp]);
+			if (step.done) break;
+			const c = step.value;
+			arm(LIMITS.idle, `answer stalled for ${Math.round(LIMITS.idle / 1e3)} s`);
+			if (c.type === "reasoning-delta") thought = true;
+			else if (c.type === "usage") {
+				if ((c.usage?.reasoningTokens ?? 0) > 0) thought = true;
+			} else if (c.type === "finish") {
+				const kind = c.reason?.kind;
+				if (kind === "max-tokens") cut = true;
+				else if (kind === "error" || kind === "aborted") throw new AskError(c.reason?.failure?.message || `request ${kind}`);
+				continue;
+			}
+			asm.push(c);
+		}
+	} finally {
+		clearTimeout(timer);
+		o.signal?.removeEventListener("abort", outer);
+		Promise.resolve(it.return?.()).catch(() => {});
+	}
+	const blocks = asm.blocks();
+	if (blocks.some((b) => b.type === "reasoning")) thought = true;
+	return {
+		text: blocks.filter((b) => b.type === "text").map((b) => b.text ?? "").join(""),
+		cut,
+		thought
+	};
+}
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		const t = setTimeout(done, ms);
+		function done() {
+			clearTimeout(t);
+			signal?.removeEventListener("abort", done);
+			resolve();
+		}
+		signal?.addEventListener("abort", done, { once: true });
+	});
+}
+/** The first complete JSON value of a kind in a reply (models wrap it in prose or code fences). */
+function jsonIn(out, open) {
+	const close = open === "{" ? "}" : "]";
+	for (let from = out.indexOf(open); from >= 0; from = out.indexOf(open, from + 1)) {
+		for (let to = out.lastIndexOf(close); to > from; to = out.lastIndexOf(close, to - 1)) {
+			try {
+				return JSON.parse(out.slice(from, to + 1));
+			} catch {}
+			if (out.length - to > 2e3) break;
+		}
+		if (from > 2e3) break;
+	}
+}
 // src/translate.ts
 /** Display names used in prompts (the model understands English names best). */
 const LANGS = {
@@ -398,54 +678,106 @@ var Translator = class {
 	get available() {
 		return this.llm() !== void 0;
 	}
-	async translate(targets, line, context, glossary = "", signal, reference = "") {
+	async translate(targets, line, context, glossary = "", signal, reference = "", log) {
 		const handle = this.llm();
-		if (!handle || !line.trim() || targets.length === 0) return void 0;
-		const system = [
-			`You translate live speech subtitles. Target languages: ${targets.map((t) => `"${t}" (${LANGS[t] ?? t})`).join(", ")}.`,
-			"Translate only the final line. Be faithful, natural and concise, like professional subtitles, with normal punctuation.",
-			"Follow the glossary when it covers a term. Otherwise keep brand, product and model names in their original form, and give well-known people, places and organisations their standard name in the target language.",
-			"If the line is a fragment, translate the fragment as-is; do not complete it.",
-			`Reply with one JSON object mapping each language code to its translation, e.g. {${targets.map((t) => `"${t}": "..."`).join(", ")}} — nothing else.`
-		].join(" ");
-		const ctx = context.slice(-6).map((c) => `- ${c.src}${c.tr ? `\n  => ${JSON.stringify(c.tr)}` : ""}`).join("\n");
+		if (!handle) return void 0;
+		return translateLine(handle, targets, line, context, glossary, reference, {
+			signal,
+			log
+		});
+	}
+};
+/**
+* One line translated on its own (the lines before only as context). A reply that is really the
+* line before it (its numbers or names, not this line's) is asked for again without the context.
+*/
+async function translateLine(handle, targets, line, context, glossary = "", reference = "", o = {}) {
+	if (!line.trim() || targets.length === 0) return void 0;
+	const system = [
+		`You translate live speech subtitles. Target languages: ${targets.map((t) => `"${t}" (${LANGS[t] ?? t})`).join(", ")}.`,
+		"Translate only the final line. Be faithful, natural and concise, like professional subtitles, with normal punctuation.",
+		"Follow the glossary when it covers a term. Otherwise keep brand, product and model names in their original form, and give well-known people, places and organisations their standard name in the target language.",
+		"If the line is a fragment, translate the fragment as-is; do not complete it.",
+		`Reply with one JSON object mapping each language code to its translation, e.g. {${targets.map((t) => `"${t}": "..."`).join(", ")}} — nothing else.`
+	].join(" ");
+	const once = async (ctxLines) => {
+		const ctx = ctxLines.slice(-6).map((c) => `- ${c.src}${c.tr ? `\n  => ${JSON.stringify(c.tr)}` : ""}`).join("\n");
 		const text = [
 			glossary ? `Glossary:\n${glossary}\n` : "",
-			ctx ? `Earlier lines (context, already translated):\n${ctx}\n` : "",
+			ctx ? `Earlier lines (context, already translated — do not translate these):\n${ctx}\n` : "",
 			reference ? `The video's own subtitles around this moment (from the site; may be inaccurate or misaligned — use them to fix names, terms and misheard words, not as the answer):\n${reference}\n` : "",
 			`Line to translate:\n${line}`
 		].join("\n");
-		const { provider, model } = handle.selection();
-		const assembler = new BlockAssembler();
-		for await (const chunk of handle.stream({
-			provider,
-			model,
+		return parseTranslations((await ask(handle, {
 			system,
+			text,
 			maxTokens: 300 + 300 * targets.length,
 			purpose: "live-subtitle-translate",
-			signal,
-			messages: [createUserMessage({
-				content: [{
-					type: "text",
-					text
-				}],
-				source: {
-					kind: "plugin",
-					plugin: "dsh-vidi"
-				}
-			})]
-		})) assembler.push(chunk);
-		return parseTranslations(assembler.blocks().filter((b) => b.type === "text").map((b) => b.text ?? "").join("").trim(), targets);
+			signal: o.signal,
+			log: o.log
+		})).trim(), targets);
+	};
+	const tr = await once(context);
+	const before = context.at(-1);
+	if (tr && before && targets.some((t) => borrowed(tr[t] ?? "", line, before.src))) {
+		o.log?.("translate: the answer belongs to the line before, asking again without context");
+		return await once([]) ?? tr;
 	}
-};
-/** Pull the JSON object out of the reply; fall back to plain text for a single target. */
+	return tr;
+}
+/** Does a translation carry a number or name that `other` has and its own line does not? */
+function borrowed(tr, own, other) {
+	const n = numbers(own), on = numbers(other);
+	for (const x of numbers(tr)) if (!n.has(x) && on.has(x)) return true;
+	if (/[^\x00-ɏ]/.test(tr)) {
+		const w = words(own), ow = words(other);
+		for (const x of words(tr)) if (!w.has(x) && ow.has(x)) return true;
+	}
+	return false;
+}
 /**
 * Translate many finished lines at once (adding a language to a video that
 * already has subtitles). Returns id → { lang: text }.
+*
+* Every line is checked against its id. A reply that cannot be read, or whose numbering is off, is
+* asked for again in two halves (then line by line); lines left out, or whose translation looks like a neighbour's,
+* are translated one at a time. A line no try could translate is simply absent from the result.
 */
-async function translateBatch(handle, targets, lines, glossary = "") {
+async function translateBatch(handle, targets, lines, glossary = "", o = {}, depth = 0) {
+	const res = /* @__PURE__ */ new Map();
+	if (!lines.length || !targets.length) return res;
+	const alone = async (l) => {
+		const i = lines.indexOf(l);
+		const context = lines.slice(Math.max(0, i - 3), i).map((c) => ({
+			src: c.src,
+			tr: res.get(c.id)
+		}));
+		try {
+			const tr = await translateLine(handle, targets, l.src, context, glossary, "", o);
+			if (tr) res.set(l.id, tr);
+			else res.delete(l.id);
+		} catch (err) {
+			if (o.signal?.aborted) throw err;
+			res.delete(l.id);
+			o.log?.(`translate: line ${l.id} failed (${err.message})`);
+		}
+	};
+	if (lines.length === 1) {
+		await alone(lines[0]);
+		return res;
+	}
+	const halves = async () => {
+		if (depth > 0) {
+			for (const l of lines) await alone(l);
+			return res;
+		}
+		const mid = Math.ceil(lines.length / 2);
+		for (const part of [lines.slice(0, mid), lines.slice(mid)]) for (const [id, tr] of await translateBatch(handle, targets, part, glossary, o, depth + 1)) res.set(id, tr);
+		return res;
+	};
 	const system = [
 		`You translate subtitles into: ${targets.map((t) => `"${t}" (${LANGS[t] ?? t})`).join(", ")}. Keep each line separate (same ids), faithful, natural and concise, with normal punctuation.`,
+		"One translation per id, in the same order: never join two lines into one or move part of a line to the next, even when a sentence runs across lines.",
 		"Use the earlier and later lines as context. Keep brand, product and model names as they are; follow the glossary.",
 		`Reply with JSON only: [{"id":1,${targets.map((t) => `"${t}":"…"`).join(",")}}]`
 	].join(" ");
@@ -457,47 +789,58 @@ async function translateBatch(handle, targets, lines, glossary = "") {
 			src: l.src
 		})))
 	].filter(Boolean).join("\n");
-	const { provider, model } = handle.selection();
-	const asm = new BlockAssembler();
-	for await (const chunk of handle.stream({
-		provider,
-		model,
-		system,
-		maxTokens: 400 + lines.length * 90 * targets.length,
-		purpose: "live-translate-batch",
-		messages: [createUserMessage({
-			content: [{
-				type: "text",
-				text
-			}],
-			source: {
-				kind: "plugin",
-				plugin: "dsh-vidi"
-			}
-		})]
-	})) asm.push(chunk);
-	const out = asm.blocks().filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
-	const res = /* @__PURE__ */ new Map();
-	const m = out.match(/\[[\s\S]*\]/);
-	if (!m) return res;
+	let out;
 	try {
-		for (const row of JSON.parse(m[0])) {
-			const id = Number(row.id);
-			const tr = {};
-			for (const t of targets) if (typeof row[t] === "string" && row[t].trim()) tr[t] = row[t].trim();
-			if (Object.keys(tr).length) res.set(id, tr);
-		}
-	} catch {}
+		out = await ask(handle, {
+			system,
+			text,
+			maxTokens: 400 + lines.length * 90 * targets.length,
+			purpose: "live-translate-batch",
+			signal: o.signal,
+			log: o.log
+		});
+	} catch (err) {
+		if (o.signal?.aborted) throw err;
+		if (!(err instanceof AskError && err.empty)) {
+			o.log?.(`translate: ${lines.length} lines failed (${err.message})`);
+			return res;
+		}
+		o.log?.(`translate: ${lines.length} lines failed (${err.message}), trying smaller`);
+		return halves();
+	}
+	const rows = jsonIn(out, "[");
+	if (!Array.isArray(rows)) {
+		o.log?.(`translate: unreadable answer for ${lines.length} lines (${out.slice(0, 80)}), trying smaller`);
+		return halves();
+	}
+	const ids = rows.map((r) => Number(r?.id));
+	if (misnumbered(lines.map((l) => l.id), ids)) {
+		o.log?.(`translate: answer numbered wrongly for ${lines.length} lines, trying smaller`);
+		return halves();
+	}
+	for (const row of rows) {
+		const tr = {};
+		for (const t of targets) if (typeof row[t] === "string" && row[t].trim()) tr[t] = row[t].trim();
+		if (Object.keys(tr).length) res.set(Number(row.id), tr);
+	}
+	const bad = suspects(lines.map((l) => ({
+		...l,
+		tr: res.get(l.id)
+	})), targets);
+	if (bad.size) {
+		o.log?.(`translate: ${bad.size} of ${lines.length} lines missing or on the wrong line (ids ${[...bad].join(", ")}), translating them one by one`);
+		for (const l of lines) if (bad.has(l.id)) await alone(l);
+	}
 	return res;
 }
+/** Pull the JSON object out of the reply; fall back to plain text for a single target. */
 function parseTranslations(out, targets) {
-	const m = out.match(/\{[\s\S]*\}/);
-	if (m) try {
-		const obj = JSON.parse(m[0]);
+	const obj = jsonIn(out, "{");
+	if (obj && typeof obj === "object") {
 		const res = {};
 		for (const t of targets) if (typeof obj[t] === "string" && obj[t]) res[t] = obj[t].trim();
 		if (Object.keys(res).length) return res;
-	} catch {}
+	}
 	if (targets.length === 1 && out && !out.startsWith("{")) return { [targets[0]]: out };
 }
 // src/polish.ts
@@ -529,7 +872,7 @@ var Polisher = class {
 		return this.pending.length;
 	}
 	add(cue) {
-		if (!cue.src.trim()) return;
+		if (!cue.src.trim() || this.deps.signal?.aborted) return;
 		this.pending.push(cue);
 		if (this.pending.length === 1) this.firstWaitAt = Date.now();
 		this.kick();
@@ -547,7 +890,7 @@ var Polisher = class {
 	}
 	/** Polish whatever is left (end of a run). */
 	async flush() {
-		while (this.busy || this.pending.length) if (this.busy) await this.busy;
+		while ((this.busy || this.pending.length) && !this.deps.signal?.aborted) if (this.busy) await this.busy;
 		else await this.runBatch();
 	}
 	runBatch() {
@@ -562,13 +905,19 @@ var Polisher = class {
 	async polish(batch) {
 		const handle = this.deps.llm();
 		if (!handle || !batch.length) return;
+		await this.part(handle, batch, 0);
+		this.done.push(...batch);
+		if (this.done.length > 40) this.done.splice(0, this.done.length - 40);
+	}
+	/** Polish some lines in one request; what comes back is checked line by line against its id. */
+	async part(handle, batch, depth) {
 		const targets = this.deps.targets();
 		const names = targets.map((t) => `"${t}" (${LANGS[t] ?? t})`).join(", ");
 		const system = [
 			"You polish live speech-recognition subtitles and maintain the glossary for this video.",
 			"A frame from the video in this stretch may be attached: use what is on screen (names, titles, slides, captions, products) to fix words and to confirm glossary entries.",
 			"Fix misheard words (names, terms, homophones) using the video background, the glossary, the site's own subtitles and the surrounding lines. Otherwise keep the speaker's words: do not rewrite, summarise, merge or split lines; keep every id.",
-			targets.length ? `Translate each fixed line into: ${names}, as natural, concise subtitles.` : "No translation is needed.",
+			targets.length ? `Translate each fixed line into: ${names}, as natural, concise subtitles. Each translation covers exactly the words of its own id: never join two lines into one translation or move part of a line to the next, even when a sentence runs across lines.` : "No translation is needed.",
 			"Speaker: say who says each line — a name when the background or context makes it clear (host, guest, a named person), otherwise \"Speaker 1\", \"Speaker 2\"… consistent with the earlier lines; if only one person talks, use the same label throughout.",
 			"Glossary: keep names and terms that must stay consistent — people, groups, places, products, titles, jargon, and words recognition keeps getting wrong. Merge spelling variants under one correct form and list the wrong forms as aliases. Only add what the text or background confirms; correct or remove earlier entries when new evidence shows they were wrong. Skip ordinary words, and skip entries whose translation equals the source unless they have aliases. Return only changes.",
 			`Reply with JSON only: {"lines":[{"id":1,"speaker":"…","src":"…"${targets.length ? `,"tr":{${targets.map((t) => `"${t}":"…"`).join(",")}}` : ""}}],"glossary":{"set":[{"src":"correct form","aliases":["misheard form"],"tr":{"<lang>":"…"},"note":"who/what, short"}],"remove":["src"]}}`
@@ -594,50 +943,93 @@ var Polisher = class {
 			this.deps.log("polish: no picture to show the model");
 		}
 		const image = jpeg ? await handle.image(jpeg).catch(() => void 0) : void 0;
-		const { provider, model } = handle.selection();
-		const asm = new BlockAssembler();
-		for await (const chunk of handle.stream({
-			provider,
-			model,
-			system,
-			maxTokens: 800 + batch.length * 120 * Math.max(1, targets.length + 1),
-			purpose: "live-polish",
-			messages: [createUserMessage({
-				content: [...image ? [image] : [], {
-					type: "text",
-					text
-				}],
-				source: {
-					kind: "plugin",
-					plugin: "dsh-vidi"
-				}
-			})]
-		})) asm.push(chunk);
-		const out = asm.blocks().filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
-		const m = out.match(/\{[\s\S]*\}/);
-		if (!m) {
-			this.deps.log(`polish: no JSON (${out.slice(0, 120)})`);
-			this.done.push(...batch);
-			return;
-		}
-		let res;
+		let out;
 		try {
-			res = JSON.parse(m[0]);
-		} catch {
-			this.deps.log("polish: bad JSON");
-			this.done.push(...batch);
+			out = await ask(handle, {
+				system,
+				text,
+				image,
+				maxTokens: 800 + batch.length * 120 * Math.max(1, targets.length + 1),
+				purpose: "live-polish",
+				signal: this.deps.signal,
+				log: this.deps.log
+			});
+		} catch (err) {
+			if (this.deps.signal?.aborted) return;
+			if (err instanceof AskError && err.empty) return this.smaller(handle, batch, depth, err.message);
+			this.deps.log(`polish: ${batch.length} lines not polished (${err.message})`);
 			return;
 		}
-		for (const line of res.lines ?? []) {
+		const res = jsonIn(out, "{");
+		if (!res || !Array.isArray(res.lines)) return this.smaller(handle, batch, depth, `unreadable answer (${out.slice(0, 80)})`);
+		if (misnumbered(batch.map((c) => c.id), res.lines.map((l) => Number(l?.id)))) return this.smaller(handle, batch, depth, "answer numbered wrongly");
+		const got = /* @__PURE__ */ new Map();
+		const strangers = /* @__PURE__ */ new Set();
+		for (const line of res.lines) {
 			const cue = batch.find((c) => c.id === line.id);
 			if (!cue || typeof line.src !== "string" || !line.src.trim()) continue;
+			const own = alike(line.src, cue.src) >= .4;
+			if (!own) strangers.add(cue.id);
 			const tr = {};
-			for (const t of targets) if (typeof line.tr?.[t] === "string") tr[t] = line.tr[t];
-			this.deps.onLine(cue, line.src.trim(), tr, typeof line.speaker === "string" && line.speaker.trim() ? line.speaker.trim().slice(0, 40) : void 0);
+			for (const t of targets) if (typeof line.tr?.[t] === "string" && line.tr[t].trim()) tr[t] = line.tr[t].trim();
+			got.set(cue.id, {
+				src: own ? line.src.trim() : cue.src,
+				tr,
+				speaker: typeof line.speaker === "string" && line.speaker.trim() ? line.speaker.trim().slice(0, 40) : void 0
+			});
+		}
+		const bad = targets.length ? suspects(batch.map((c) => ({
+			id: c.id,
+			src: got.get(c.id)?.src ?? c.src,
+			tr: got.get(c.id)?.tr
+		})), targets) : /* @__PURE__ */ new Set();
+		for (const id of strangers) bad.add(id);
+		if (bad.size) this.deps.log(`polish: ${bad.size} of ${batch.length} lines missing or on the wrong line (ids ${[...bad].join(", ")}), translating them one by one`);
+		for (const cue of batch) {
+			const g = got.get(cue.id);
+			if (g && !bad.has(cue.id)) {
+				this.deps.onLine(cue, g.src, g.tr, g.speaker);
+				continue;
+			}
+			if (!targets.length) continue;
+			const src = g?.src ?? cue.src;
+			const tr = await this.alone(handle, batch, cue, src);
+			if (tr || g) this.deps.onLine(cue, src, tr ?? {}, g?.speaker);
 		}
 		if (res.glossary) this.deps.glossary.apply(res.glossary);
-		this.done.push(...batch);
-		if (this.done.length > 40) this.done.splice(0, this.done.length - 40);
+	}
+	/** A request that gave nothing usable: once more in two halves, then each line translated on its own. */
+	async smaller(handle, batch, depth, why) {
+		if (batch.length > 1 && depth === 0) {
+			this.deps.log(`polish: ${why} for ${batch.length} lines, trying smaller`);
+			const mid = Math.ceil(batch.length / 2);
+			await this.part(handle, batch.slice(0, mid), 1);
+			await this.part(handle, batch.slice(mid), 1);
+			return;
+		}
+		this.deps.log(`polish: ${why} for ${batch.length} lines, translating them one by one`);
+		if (!this.deps.targets().length) return;
+		for (const cue of batch) {
+			const tr = await this.alone(handle, batch, cue, cue.src);
+			if (tr) this.deps.onLine(cue, cue.src, tr);
+		}
+	}
+	/** One line translated on its own, with the lines before it as context. */
+	async alone(handle, batch, cue, src) {
+		if (this.deps.signal?.aborted) return void 0;
+		const before = [...this.done.slice(-3), ...batch.slice(0, batch.indexOf(cue))].slice(-4);
+		try {
+			return await translateLine(handle, this.deps.targets(), src, before.map((c) => ({
+				src: c.src,
+				tr: c.tr
+			})), this.deps.glossary.forPrompt(), "", {
+				signal: this.deps.signal,
+				log: this.deps.log
+			});
+		} catch (err) {
+			if (!this.deps.signal?.aborted) this.deps.log(`polish: line ${cue.id} not translated (${err.message})`);
+			return;
+		}
 	}
 };
 // src/xiaoyuzhou.ts
@@ -2772,6 +3164,8 @@ const FILE_LIKE = /\.(mp4|m4v|mov|mkv|webm|mp3|m4a|aac|wav|flac|ogg)(\?|$)/i;
 /** Pace for subtitles: stop reading ahead once recognition or translation is this far behind (seconds / lines). */
 const AHEAD_MAX_SEC = 30;
 const AHEAD_MAX_LINES = 10;
+/** How long pausing waits for lines still being translated or polished before leaving them to finish behind it (ms). */
+const SETTLE = { wait: 3e3 };
 /**
 * One video or live stream, in two independent parts:
 *
@@ -2876,6 +3270,8 @@ var LiveJob = class LiveJob extends EventEmitter {
 	/** The video's language as the site states it (before any recognition). */
 	siteLang;
 	polisher;
+	/** Set off when the video is closed: model requests under way are given up. */
+	closing = new AbortController();
 	nextId = 1;
 	drafts = /* @__PURE__ */ new Map();
 	ingest;
@@ -2901,6 +3297,7 @@ var LiveJob = class LiveJob extends EventEmitter {
 			siteText: (a, b) => this.siteText(a, b),
 			targets: () => this.targets(),
 			still: (at) => this.still(at),
+			signal: this.closing.signal,
 			onLine: (cue, src, tr, speaker) => {
 				if (!this.cues.includes(cue) || cue.edited) return;
 				this.deps.glossary.notice(src);
@@ -3570,39 +3967,62 @@ var LiveJob = class LiveJob extends EventEmitter {
 		this.deps.glossary.setTargets(tgtLangs);
 		this.persist();
 		this.emit("state", this.summary());
+		await this.fill();
+	}
+	filling = false;
+	/**
+	* Give every finished line the translations it lacks (a language just added, or lines a failed
+	* request left behind), in batches. A line that cannot be translated is passed over, so the
+	* lines after it still get theirs; it stops only when the model gives nothing twice in a row.
+	*/
+	async fill() {
 		if (this.filling) return;
 		this.filling = true;
+		const log = (m) => this.deps.log(`[${this.id}] ${m}`);
+		const failed = /* @__PURE__ */ new Set();
+		let empty = 0, filled = 0;
 		try {
-			for (;;) {
+			while (!this.closing.signal.aborted) {
 				const targets = this.targets();
 				const handle = this.deps.llm();
 				if (!handle || !targets.length) break;
-				const todo = this.cues.filter((c) => c.final && c.src && targets.some((t) => !c.tr?.[t])).slice(0, 15);
+				const todo = this.cues.filter((c) => c.final && c.src.trim() && !failed.has(c.id) && targets.some((t) => !c.tr?.[t])).slice(0, 15);
 				if (!todo.length) break;
 				const got = await translateBatch(handle, targets.filter((t) => todo.some((c) => !c.tr?.[t])), todo.map((c) => ({
 					id: c.id,
 					src: c.src
-				})), this.deps.glossary.forPrompt());
-				if (!got.size) break;
+				})), this.deps.glossary.forPrompt(), {
+					signal: this.closing.signal,
+					log
+				});
 				for (const c of todo) {
 					const tr = got.get(c.id);
-					if (!tr) continue;
-					c.tr = {
-						...c.tr,
-						...tr
-					};
-					this.emit("cue", c);
-					this.record(c);
+					const add = Object.fromEntries(Object.entries(tr ?? {}).filter(([t]) => !c.tr?.[t]));
+					if (Object.keys(add).length) {
+						c.tr = {
+							...c.tr,
+							...add
+						};
+						filled++;
+						this.emit("cue", c);
+						this.record(c);
+					}
+					if (targets.some((t) => !c.tr?.[t])) failed.add(c.id);
+				}
+				empty = got.size ? 0 : empty + 1;
+				if (empty >= 2) {
+					log(`fill translations: the model gives nothing, stopping (${this.cues.filter((c) => c.final && c.src.trim() && targets.some((t) => !c.tr?.[t])).length} lines left)`);
+					break;
 				}
 			}
+			if (failed.size) log(`fill translations: ${failed.size} lines still without a translation (ids ${[...failed].slice(0, 20).join(", ")}${failed.size > 20 ? "…" : ""})`);
 		} catch (err) {
-			this.deps.log(`[${this.id}] fill translations: ${err.message}`);
+			if (!this.closing.signal.aborted) log(`fill translations: ${err.message}`);
 		} finally {
 			this.filling = false;
-			this.save();
+			if (filled) this.save();
 		}
 	}
-	filling = false;
 	/** Pause subtitles; the next start resumes from here. */
 	async pauseSubs() {
 		const rd = this.reader;
@@ -3621,11 +4041,15 @@ var LiveJob = class LiveJob extends EventEmitter {
 		};
 		this.persist();
 		this.emit("state", this.summary());
-		await this.translating;
-		await this.polisher.flush();
-		this.save();
-		this.persist();
-		this.emit("state", this.summary());
+		const settled = (async () => {
+			await this.translating;
+			await this.polisher.flush();
+			if (!this.reader) await this.fill();
+			this.save();
+			this.persist();
+			this.emit("state", this.summary());
+		})().catch((err) => this.deps.log(`[${this.id}] finishing subtitles: ${err.message}`));
+		await Promise.race([settled, new Promise((r) => setTimeout(r, SETTLE.wait))]);
 	}
 	/**
 	* How far the subtitles are complete (media s): audio read minus what the
@@ -3714,7 +4138,7 @@ var LiveJob = class LiveJob extends EventEmitter {
 		this.translating = this.translating.then(async () => {
 			try {
 				const ref = this.siteText(cue.start, cue.end).map((x) => `[${x.lang}${x.auto ? ", auto" : ""}] ${x.text}`).join("\n");
-				const tr = await this.deps.translator.translate(this.targets(), text, context, this.deps.glossary.forPrompt(), void 0, ref);
+				const tr = await this.deps.translator.translate(this.targets(), text, context, this.deps.glossary.forPrompt(), this.closing.signal, ref, (m) => this.deps.log(`[${this.id}] ${m}`));
 				if (tr) {
 					cue.tr = {
 						...cue.tr,
@@ -3723,7 +4147,7 @@ var LiveJob = class LiveJob extends EventEmitter {
 					this.emit("cue", cue);
 				}
 			} catch (err) {
-				this.deps.log(`[${this.id}] translate: ${err.message}`);
+				if (!this.closing.signal.aborted) this.deps.log(`[${this.id}] translate: ${err.message}`);
 			}
 			this.pendingTranslations--;
 			this.record(cue);
@@ -3867,6 +4291,7 @@ var LiveJob = class LiveJob extends EventEmitter {
 		await this.restreamer?.stop();
 		await this.stop(reason);
 		await this.pauseSubs();
+		this.closing.abort();
 	}
 	dubber;
 	/** The voiceover (made on first use; its clips stay in the video's folder). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vidi",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "A video tool for DeepSeek Harness: watch live streams, videos and podcasts with real-time subtitles in any language, then clip and download",
   "type": "module",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -37,7 +37,8 @@
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "check": "node --experimental-transform-types --no-warnings checks/subtitles.check.ts"
   },
   "dsh": {
     "bundle": {