dsh-vidi 0.1.0 → 0.2.0

package/lib/index.mjs

@@ -1088,6 +1088,504 @@ function findOriginal(dir) {
 	const f = readdirSync(dir).find((n) => /^original\.(mp4|mkv|webm|m4a|mp3)$/.test(n));
 	return f ? join(dir, f) : void 0;
 }
+// src/restream.ts
+/** Platforms people push to; only a label on our side — the address and key come from the platform's own streaming tool. */
+const PLATFORMS = [
+	"bilibili",
+	"douyin",
+	"kuaishou",
+	"wechat",
+	"douyu",
+	"huya",
+	"yy",
+	"cc",
+	"youtube",
+	"twitch",
+	"custom"
+];
+const mask$1 = (k) => !k ? "" : k.length > 10 ? `${k.slice(0, 3)}…${k.slice(-4)}` : "••••";
+/** The full push address: the server plus the key, unless the server already ends with it. */
+function pushUrl(t) {
+	const server = t.server.trim();
+	const key = t.key.trim();
+	if (!key || server.endsWith(key)) return server;
+	return server.endsWith("/") ? server + key : `${server}/${key}`;
+}
+var Targets = class {
+	file;
+	constructor(file) {
+		this.file = file;
+	}
+	list() {
+		if (!existsSync(this.file)) return [];
+		try {
+			return JSON.parse(readFileSync(this.file, "utf8")).filter((t) => t && t.id && t.server);
+		} catch {
+			return [];
+		}
+	}
+	view() {
+		return this.list().map((t) => ({
+			id: t.id,
+			platform: t.platform,
+			server: t.server,
+			key: mask$1(t.key)
+		}));
+	}
+	/** Add or change one (an empty key keeps the saved one); returns the saved list. */
+	save(input) {
+		const all = this.list();
+		const platform = PLATFORMS.includes(String(input.platform)) ? input.platform : "custom";
+		const server = String(input.server ?? "").trim();
+		if (!/^(rtmps?|srt):\/\//i.test(server)) throw new Error("the server address should start with rtmp://, rtmps:// or srt://");
+		const old = input.id ? all.find((t) => t.id === input.id) : void 0;
+		const key = String(input.key ?? "").trim() || old?.key || "";
+		const next = {
+			id: old?.id ?? Math.random().toString(36).slice(2, 10),
+			platform,
+			server,
+			key
+		};
+		this.write(old ? all.map((t) => t.id === old.id ? next : t) : [...all, next]);
+		return this.view();
+	}
+	remove(id) {
+		this.write(this.list().filter((t) => t.id !== id));
+		return this.view();
+	}
+	write(list) {
+		writeFileSync(this.file, JSON.stringify(list, null, 2), { mode: 384 });
+		try {
+			chmodSync(this.file, 384);
+		} catch {}
+	}
+};
+let canvasLib;
+/** The canvas library is loaded on first use (it is a native module; restreaming still works without subtitles if it fails). */
+const loadCanvas = () => canvasLib ??= import("@napi-rs/canvas").then((m) => m, () => void 0);
+const FONT = "\"PingFang SC\", \"Hiragino Sans GB\", \"Microsoft YaHei\", \"Noto Sans CJK SC\", \"Noto Sans SC\", \"Source Han Sans SC\", \"Helvetica Neue\", Arial, sans-serif";
+/**
+* Draws the subtitle lines for one moment as a transparent PNG the size of
+* the output picture, matching the player: the main line large and bold,
+* the rest smaller, each on a rounded dark box, wrapped to 92% of the width.
+*/
+async function drawSubtitles(rows, style, w, h) {
+	const lib = await loadCanvas();
+	if (!lib) return void 0;
+	const c = lib.createCanvas(w, h);
+	const g = c.getContext("2d");
+	const maxW = w * .92;
+	const blocks = rows.map((r) => {
+		const px = Math.round(r.size / 100 * w);
+		g.font = `${r.main ? 600 : 500} ${px}px ${FONT}`;
+		const lines = [];
+		let cur = "";
+		for (const ch of Array.from(r.text)) {
+			const next = cur + ch;
+			if (cur && g.measureText(next).width > maxW - px * .9) {
+				const sp = cur.lastIndexOf(" ");
+				if (sp > cur.length * .5 && /[A-Za-z]/.test(ch)) {
+					lines.push(cur.slice(0, sp));
+					cur = cur.slice(sp + 1) + ch;
+				} else {
+					lines.push(cur);
+					cur = ch.trimStart();
+				}
+			} else cur = next;
+		}
+		if (cur.trim()) lines.push(cur);
+		return {
+			px,
+			main: r.main,
+			lines
+		};
+	});
+	const lineH = (px) => px * 1.55;
+	const gap = (px) => px * .18;
+	const total = blocks.reduce((n, b) => n + b.lines.length * lineH(b.px) + gap(b.px), 0);
+	let y = style.position === "top" ? style.offset / 100 * h : h - style.offset / 100 * h - total;
+	for (const b of blocks) {
+		g.font = `${b.main ? 600 : 500} ${b.px}px ${FONT}`;
+		g.textAlign = "center";
+		g.textBaseline = "middle";
+		for (const line of b.lines) {
+			const tw = g.measureText(line).width;
+			const padX = b.px * .45, boxH = b.px * 1.4;
+			const cy = y + lineH(b.px) / 2;
+			if (style.bg > .02) {
+				g.fillStyle = `rgba(0,0,0,${style.bg})`;
+				roundRect(g, w / 2 - tw / 2 - padX, cy - boxH / 2, tw + padX * 2, boxH, b.px * .22);
+				g.fill();
+			} else {
+				g.shadowColor = "rgba(0,0,0,.85)";
+				g.shadowBlur = b.px * .18;
+				g.shadowOffsetY = b.px * .04;
+			}
+			g.fillStyle = b.main ? "#ffffff" : "#e8e8e8";
+			g.fillText(line, w / 2, cy);
+			g.shadowColor = "transparent";
+			g.shadowBlur = 0;
+			g.shadowOffsetY = 0;
+			y += lineH(b.px);
+		}
+		y += gap(b.px);
+	}
+	return c.toBuffer("image/png");
+}
+function roundRect(g, x, y, w, h, r) {
+	g.beginPath();
+	g.moveTo(x + r, y);
+	g.arcTo(x + w, y, x + w, y + h, r);
+	g.arcTo(x + w, y + h, x, y + h, r);
+	g.arcTo(x, y + h, x, y, r);
+	g.arcTo(x, y, x + w, y, r);
+	g.closePath();
+}
+const FPS_SUBS = 5;
+const RETRY_MS = [
+	2e3,
+	5e3,
+	1e4,
+	2e4,
+	3e4
+];
+/**
+* Restreaming: one ffmpeg reads the recording in real time from `from`,
+* overlays the subtitle pictures (drawn here, a few per second, for the
+* exact media time of each one) and encodes once to MPEG-TS; every
+* destination gets its own small ffmpeg that copies that stream to the
+* platform as FLV. A platform that drops or refuses only retries itself.
+*/
+var Restream = class extends EventEmitter {
+	source;
+	opts;
+	log;
+	encoder;
+	pushes = /* @__PURE__ */ new Map();
+	status;
+	stopped = false;
+	sentFrames = 0;
+	outTime = 0;
+	subsTimer;
+	lastKey = "";
+	lastPng;
+	blank;
+	startAt = 0;
+	spawnedAt = 0;
+	constructor(source, opts, targets, log) {
+		super();
+		this.source = source;
+		this.opts = opts;
+		this.log = log;
+		this.status = {
+			running: true,
+			at: opts.from,
+			startedAt: Date.now(),
+			burn: opts.burn,
+			height: opts.height,
+			targets: []
+		};
+		for (const t of targets) this.pushes.set(t.id, {
+			target: t,
+			tries: 0,
+			status: {
+				id: t.id,
+				platform: t.platform,
+				server: t.server,
+				state: "connecting",
+				since: Date.now()
+			}
+		});
+	}
+	get summary() {
+		return {
+			...this.status,
+			targets: [...this.pushes.values()].map((p) => ({ ...p.status }))
+		};
+	}
+	changed() {
+		this.emit("status", this.summary);
+	}
+	async start() {
+		const h = this.opts.height, w = Math.round(h * 16 / 9);
+		const { args: input, at } = this.source.input(this.opts.from);
+		this.startAt = at;
+		this.status.at = at;
+		const burn = this.opts.burn && !!await loadCanvas();
+		if (this.opts.burn && !burn) this.status.message = "no-burn";
+		this.status.burn = burn;
+		if (burn) this.blank = await drawSubtitles([], this.opts.style, w, h);
+		const video = `[0:v]scale=${w}:${h}:force_original_aspect_ratio=decrease,pad=${w}:${h}:(ow-iw)/2:(oh-ih)/2,setsar=1,fps=25,setpts=PTS-STARTPTS`;
+		const filter = burn ? `${video}[v];[1:v]format=rgba,setpts=PTS-STARTPTS[s];[v][s]overlay=0:0:eof_action=repeat:shortest=1,format=yuv420p[o]` : `${video},format=yuv420p[o]`;
+		const b = this.opts.bitrateK;
+		const args = [
+			"-hide_banner",
+			"-loglevel",
+			"error",
+			"-re",
+			...input,
+			...burn ? [
+				"-probesize",
+				"65536",
+				"-analyzeduration",
+				"0",
+				"-f",
+				"image2pipe",
+				"-framerate",
+				String(FPS_SUBS),
+				"-c:v",
+				"png",
+				"-i",
+				"pipe:0"
+			] : [],
+			"-filter_complex",
+			filter,
+			"-map",
+			"[o]",
+			"-map",
+			"0:a:0?",
+			"-c:v",
+			"libx264",
+			"-preset",
+			"veryfast",
+			"-tune",
+			"zerolatency",
+			"-profile:v",
+			"high",
+			"-b:v",
+			`${b}k`,
+			"-maxrate",
+			`${b}k`,
+			"-bufsize",
+			`${b * 2}k`,
+			"-g",
+			"50",
+			"-keyint_min",
+			"50",
+			"-sc_threshold",
+			"0",
+			"-c:a",
+			"aac",
+			"-b:a",
+			"128k",
+			"-ar",
+			"44100",
+			"-ac",
+			"2",
+			"-progress",
+			"pipe:3",
+			"-f",
+			"mpegts",
+			"pipe:1"
+		];
+		const enc = spawn("ffmpeg", args, { stdio: [
+			"pipe",
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		this.encoder = enc;
+		this.spawnedAt = Date.now();
+		process.once("exit", this.killAll);
+		let errTail = "";
+		enc.stderr.on("data", (d) => {
+			errTail = (errTail + d.toString()).slice(-600);
+		});
+		enc.stdio[3].on("data", (d) => {
+			const m = /out_time_us=(\d+)/g;
+			let last, hit = null;
+			while (last = m.exec(d.toString())) hit = last;
+			if (hit) {
+				this.outTime = Number(hit[1]) / 1e6;
+				this.status.at = this.startAt + this.outTime;
+			}
+		});
+		enc.stdin.on("error", () => {});
+		enc.stdout.on("data", (chunk) => {
+			for (const p of this.pushes.values()) {
+				const sin = p.proc?.stdin;
+				if (sin && !sin.destroyed && sin.writableLength < 8 << 20) sin.write(chunk);
+			}
+		});
+		enc.on("exit", (code) => {
+			if (this.stopped) return;
+			const reason = code === 0 ? "ended" : errTail.trim().split("\n").pop() || `encoder exited (${code})`;
+			this.log(`restream: ${reason}`);
+			this.stop(reason);
+		});
+		if (burn) this.feedSubtitles(w, h);
+		for (const p of this.pushes.values()) this.connect(p.target.id);
+		this.changed();
+	}
+	/** Subtitle pictures for media times from the start on, kept about a second ahead of the encoder. */
+	feedSubtitles(w, h) {
+		const sin = this.encoder.stdin;
+		const tick = async () => {
+			if (this.stopped) return;
+			const ahead = Math.max(4, (Date.now() - this.spawnedAt) / 1e3 + 2.5);
+			while (!this.stopped && this.sentFrames / FPS_SUBS <= ahead && sin.writableLength < 4 << 20) {
+				const t = this.startAt + this.sentFrames / FPS_SUBS;
+				const rows = this.source.rowsAt(t);
+				const key = JSON.stringify(rows);
+				if (key !== this.lastKey) {
+					this.lastKey = key;
+					try {
+						this.lastPng = rows.length ? await drawSubtitles(rows, this.opts.style, w, h) ?? this.blank : this.blank;
+					} catch (err) {
+						this.log(`restream: subtitle drawing failed (${err.message})`);
+						this.lastPng = this.blank;
+					}
+				}
+				if (this.lastPng) sin.write(this.lastPng);
+				this.sentFrames++;
+			}
+		};
+		let busy = false;
+		this.subsTimer = setInterval(() => {
+			if (busy) return;
+			busy = true;
+			tick().catch((err) => this.log(`restream: subtitles: ${err.message}`)).finally(() => {
+				busy = false;
+			});
+		}, 100);
+	}
+	/** Start (or restart) one destination. */
+	connect(id) {
+		const p = this.pushes.get(id);
+		if (!p || this.stopped) return;
+		const url = pushUrl(p.target);
+		const proc = spawn("ffmpeg", [
+			"-hide_banner",
+			"-nostats",
+			"-loglevel",
+			"info",
+			"-f",
+			"mpegts",
+			"-i",
+			"pipe:0",
+			"-c",
+			"copy",
+			"-f",
+			"flv",
+			"-flvflags",
+			"no_duration_filesize",
+			url
+		], { stdio: [
+			"pipe",
+			"ignore",
+			"pipe"
+		] });
+		p.proc = proc;
+		p.status = {
+			...p.status,
+			state: p.tries ? "retrying" : "connecting",
+			since: Date.now(),
+			message: void 0
+		};
+		let errTail = "";
+		let opened = false;
+		proc.stderr.on("data", (d) => {
+			const text = d.toString();
+			errTail = (errTail + text).slice(-600);
+			if (!opened && /Output #0/.test(errTail) && p.proc === proc) {
+				opened = true;
+				p.tries = 0;
+				p.status = {
+					...p.status,
+					state: "live",
+					message: void 0,
+					since: Date.now()
+				};
+				this.changed();
+			}
+		});
+		proc.stdin.on("error", () => {});
+		proc.on("exit", () => {
+			if (p.proc !== proc || this.stopped) return;
+			p.proc = void 0;
+			const reason = errTail.split("\n").map((l) => l.replace(/^\[[^\]]*\]\s*/, "").trim()).filter(Boolean).reverse().find((l) => /error|fail|refused|denied|invalid|timed out|not found|unauthor|forbidden|reset|broken/i.test(l)) || "the platform closed the connection";
+			if (p.tries >= RETRY_MS.length) {
+				p.status = {
+					...p.status,
+					state: "error",
+					message: reason,
+					since: Date.now()
+				};
+				this.changed();
+				return;
+			}
+			p.status = {
+				...p.status,
+				state: "retrying",
+				message: reason,
+				since: Date.now()
+			};
+			p.timer = setTimeout(() => this.connect(id), RETRY_MS[p.tries++]);
+			this.changed();
+		});
+		this.changed();
+	}
+	/** Add a destination while running (no interruption for the others). */
+	add(t) {
+		if (this.pushes.has(t.id) || this.stopped) return;
+		this.pushes.set(t.id, {
+			target: t,
+			tries: 0,
+			status: {
+				id: t.id,
+				platform: t.platform,
+				server: t.server,
+				state: "connecting",
+				since: Date.now()
+			}
+		});
+		this.connect(t.id);
+	}
+	/** Stop one destination; the rest keep going. Returns true when none are left. */
+	drop(id) {
+		const p = this.pushes.get(id);
+		if (p) {
+			clearTimeout(p.timer);
+			const proc = p.proc;
+			p.proc = void 0;
+			proc?.stdin?.end();
+			proc?.kill("SIGTERM");
+			this.pushes.delete(id);
+			this.changed();
+		}
+		return this.pushes.size === 0;
+	}
+	killAll = () => {
+		this.encoder?.kill("SIGKILL");
+		for (const p of this.pushes.values()) p.proc?.kill("SIGKILL");
+	};
+	async stop(message) {
+		if (this.stopped) return;
+		this.stopped = true;
+		process.off("exit", this.killAll);
+		clearInterval(this.subsTimer);
+		for (const p of this.pushes.values()) {
+			clearTimeout(p.timer);
+			const proc = p.proc;
+			proc?.stdin?.end();
+			if (proc) setTimeout(() => {
+				if (proc.exitCode === null) proc.kill("SIGTERM");
+			}, 3e3);
+			p.status = {
+				...p.status,
+				state: "stopped",
+				since: Date.now()
+			};
+		}
+		this.encoder?.kill("SIGTERM");
+		this.status = {
+			...this.status,
+			running: false,
+			message: message ?? this.status.message
+		};
+		this.changed();
+	}
+};
 // src/job.ts
 const run$1 = promisify(execFile);
 /** URLs ffmpeg can open directly (no yt-dlp resolution). */
@@ -1199,6 +1697,7 @@ var LiveJob = class LiveJob extends EventEmitter {
 			hls: this.hlsName,
 			height: this.height,
 			heights: this.heights,
+			restream: this.restream,
 			subs: { ...this.subs },
 			usage: this.deps.usage.summary(),
 			site: this.siteTracks,
@@ -1559,7 +2058,7 @@ var LiveJob = class LiveJob extends EventEmitter {
 			"pipe"
 		] });
 		this.ffmpeg = ff;
-		if (this.message) {
+		if (this.opts.source === "push") {
 			const wait = setInterval(() => {
 				if (this.ffmpeg !== ff) {
 					clearInterval(wait);
@@ -1621,12 +2120,7 @@ var LiveJob = class LiveJob extends EventEmitter {
 		let at = Math.max(0, from ?? this.subs.at);
 		const finished = readFileSync(this.m3u8, "utf8").includes("#EXT-X-ENDLIST");
 		let input;
-		if (finished) input = [
-			"-ss",
-			String(at),
-			"-i",
-			this.m3u8
-		];
+		if (finished) input = this.seekable(at);
 		else {
 			const i = Math.max(0, segs.findLastIndex((sg) => sg.start <= at));
 			at = segs[i].start;
@@ -1900,9 +2394,96 @@ var LiveJob = class LiveJob extends EventEmitter {
 	}
 	/** Stop everything (closing the job): recording and subtitles. */
 	async close(reason = "closed") {
+		await this.restreamer?.stop();
 		await this.stop(reason);
 		await this.pauseSubs();
 	}
+	restreamer;
+	get restream() {
+		return this.restreamer?.summary;
+	}
+	/** Push this video (from media time `from`, subtitles drawn in) to the chosen destinations. */
+	async startRestream(targets, opts) {
+		if (this.restreamer?.summary.running) {
+			for (const t of targets) this.restreamer.add(t);
+			return;
+		}
+		if (!this.segments().length) throw new Error("nothing recorded yet");
+		const r = new Restream({
+			input: (from) => this.restreamInput(from),
+			rowsAt: (t) => this.rowsAt(t, opts.style)
+		}, {
+			...opts,
+			bitrateK: opts.height === 1080 ? 4500 : 2500
+		}, targets, (m) => this.deps.log(`[${this.id}] ${m}`));
+		this.restreamer = r;
+		r.on("status", () => this.emit("state", this.summary()));
+		await r.start();
+	}
+	async stopRestream(targetId) {
+		if (!this.restreamer) return;
+		if (targetId && !this.restreamer.drop(targetId)) return;
+		await this.restreamer.stop();
+	}
+	/**
+	* Input arguments for a finished recording from media time `from`. Seeking
+	* an HLS playlist to 0 skips its whole first segment when the stream's
+	* timestamps don't start at 0, so: no seek from the start, and the single
+	* recording file (exact seeking) once it exists.
+	*/
+	seekable(from) {
+		const file = this.captureDone && existsSync(join(this.deps.dir, "recording.mp4")) ? join(this.deps.dir, "recording.mp4") : this.m3u8;
+		return from > .05 ? [
+			"-ss",
+			String(from),
+			"-i",
+			file
+		] : ["-i", file];
+	}
+	/** The recording from `from` on, for an ffmpeg that reads it in real time. */
+	restreamInput(from) {
+		const segs = this.segments();
+		if (readFileSync(this.m3u8, "utf8").includes("#EXT-X-ENDLIST")) return {
+			args: this.seekable(from),
+			at: Math.max(0, from)
+		};
+		const i = Math.max(0, segs.findLastIndex((sg) => sg.start <= from));
+		return {
+			args: [
+				"-live_start_index",
+				String(i),
+				"-max_reload",
+				"100000",
+				"-i",
+				this.m3u8
+			],
+			at: segs[i]?.start ?? 0
+		};
+	}
+	/** What the player would show at media time t, line by line (the same rules: no repeats, line-end marks dropped). */
+	rowsAt(t, style) {
+		const cue = this.cues.find((c) => c.final && c.start <= t && t < Math.max(c.end, c.start + 1.2));
+		const text = (key) => {
+			if (key.startsWith("site:")) return this.siteCues.get(key)?.find((c) => c.start <= t && t < c.end)?.text;
+			if (!cue) return void 0;
+			if (key === "src") return cue.src;
+			const tr = cue.tr?.[key];
+			return tr && tr.trim() !== cue.src.trim() ? tr : cue.lang?.split("-")[0] === key.split("-")[0] ? cue.src : void 0;
+		};
+		const seen = /* @__PURE__ */ new Set();
+		const rows = [];
+		for (const l of style.lines) {
+			const x = l.show ? text(l.key)?.trim() : void 0;
+			if (!x || seen.has(x)) continue;
+			seen.add(x);
+			rows.push({
+				text: subtitleText(x),
+				size: l.size,
+				main: rows.length === 0
+			});
+		}
+		return rows;
+	}
 	/** Write the default subtitle and transcript set (source, each target, multilingual). */
 	save() {
 		for (const { name, langs, formats } of defaultExports(this.opts.tgtLangs)) for (const f of formats) {
@@ -2380,6 +2961,10 @@ var KeyStore = class {
 	settings;
 	cache = /* @__PURE__ */ new Map();
 	creds;
+	/** Model providers configured in DSH (their key names and addresses), read fresh on each refresh. */
+	discover;
+	/** Addresses from DSH's provider setup, per service (e.g. SiliconFlow's international endpoint). */
+	bases = /* @__PURE__ */ new Map();
 	constructor(file, settings) {
 		this.file = file;
 		this.settings = settings;
@@ -2395,17 +2980,33 @@ var KeyStore = class {
 	async refresh() {
 		const file = this.readFile();
 		const next = /* @__PURE__ */ new Map();
+		const found = (() => {
+			try {
+				return this.discover?.() ?? [];
+			} catch {
+				return [];
+			}
+		})();
+		this.bases = new Map(found.filter((p) => p.base).map((p) => [p.service, p.base]));
 		for (const name of KEY_NAMES) {
 			let hit;
-			for (const ref of KEY_REFS[name]) {
+			const refs = [...found.filter((p) => p.service === name && p.ref).map((p) => ({
+				ref: p.ref,
+				provider: p.name
+			})), ...KEY_REFS[name].map((ref) => ({
+				ref,
+				provider: void 0
+			}))];
+			for (const { ref, provider } of refs) {
 				const r = await this.creds?.resolve(ref).catch(() => void 0);
 				if (r?.value.trim()) {
 					hit = {
 						key: r.value.trim(),
 						info: {
 							set: true,
-							source: r.source === "file" ? "dsh" : "env",
-							ref
+							source: r.source === "file" || provider ? "dsh" : "env",
+							ref,
+							provider
 						}
 					};
 					break;
@@ -3142,6 +3743,21 @@ const SERVICES = [
 	}
 ];
 const service = (id) => SERVICES.find((s) => s.id === id);
+/** Which speech service a DSH model provider also is, by its address (or its id when it has none). */
+function speechServiceOf(id, baseURL) {
+	const k = `${(() => {
+		try {
+			return baseURL ? new URL(baseURL).host : "";
+		} catch {
+			return "";
+		}
+	})()} ${id}`.toLowerCase();
+	if (/generativelanguage\.googleapis\.com|^ (google|gemini)$/.test(k)) return "gemini";
+	if (/api\.openai\.com|^ openai$/.test(k)) return "openai";
+	if (/api\.groq\.com|^ groq$/.test(k)) return "groq";
+	if (/siliconflow/.test(k)) return "siliconflow";
+	if (/bigmodel\.cn|(^|\.)z\.ai|^ (glm|zhipu|zhipuai|zai)$/.test(k)) return "glm";
+}
 const TIMEOUT = 3e4;
 async function fail(r) {
 	const body = await r.text().catch(() => "");
@@ -3802,7 +4418,30 @@ function apply(ctx, config) {
 		}, "dsh-vidi: translator model");
 	});
 	const translator = new Translator(() => llm);
+	const restreamTargets = new Targets(join(config.dataDir, "restream.json"));
 	const keys = new KeyStore(join(config.dataDir, "keys.json"), () => ({ openai: config.openaiApiKey }));
+	keys.discover = () => {
+		const loader = ctx.get?.("loader") ?? ctx.loader;
+		if (!loader?.entries) return [];
+		const val = (x) => x && typeof x.get === "function" ? x.get() : x;
+		const out = [];
+		for (const row of loader.entries()) {
+			if (!/llm-pi-ai$/.test(String(row.options?.name ?? ""))) continue;
+			const providers = val((row.fiber?.effectiveConfig ?? row.options?.config ?? {}).providers) ?? {};
+			for (const [id, raw] of Object.entries(providers)) {
+				const p = val(raw) ?? {};
+				const base = typeof val(p.baseURL) === "string" ? String(val(p.baseURL)).replace(/\/+$/, "") : void 0;
+				const service = speechServiceOf(id, base);
+				if (service) out.push({
+					service,
+					ref: val(p.apiKeyEnv),
+					base: service === "gemini" || service === "openai" ? void 0 : base,
+					name: String(val(p.displayName) ?? id)
+				});
+			}
+		}
+		return out;
+	};
 	keys.refresh();
 	ctx.inject(["credentials"], (c) => {
 		c.effect(() => {
@@ -3874,7 +4513,10 @@ function apply(ctx, config) {
 			});
 			const key = () => keys.get(svc.id);
 			return new LocalProvider({
-				engine: svc.kind === "gemini" ? geminiEngine(config.geminiModel, key, (model, u) => usage.add("gemini", model, u), log) : whisperApiEngine(svc, svc.model, key),
+				engine: svc.kind === "gemini" ? geminiEngine(config.geminiModel, key, (model, u) => usage.add("gemini", model, u), log) : whisperApiEngine({
+					...svc,
+					base: keys.bases.get(svc.id) ?? svc.base
+				}, svc.model, key),
 				lang: opts.srcLang === "auto" ? "auto" : opts.srcLang,
 				minSec: 3,
 				maxSec: 10,
@@ -4195,6 +4837,41 @@ function apply(ctx, config) {
 					conversationId: String(b.conversationId ?? "default")
 				}));
 			}
+			if (route === "restream/targets") {
+				if (req.method === "POST") {
+					const b = await readJson(req);
+					try {
+						if (typeof b.remove === "string") return send(res, 200, { targets: restreamTargets.remove(b.remove) });
+						return send(res, 200, { targets: restreamTargets.save(b.target ?? {}) });
+					} catch (err) {
+						return send(res, 400, { error: err.message });
+					}
+				}
+				return send(res, 200, { targets: restreamTargets.view() });
+			}
+			if (route === "restream" && req.method === "POST") {
+				const b = await readJson(req);
+				const job = jobs.get(String(b.jobId));
+				if (!job) return send(res, 404, { error: "no such job" });
+				if (b.action === "stop") {
+					await job.stopRestream(typeof b.targetId === "string" ? b.targetId : void 0);
+					return send(res, 200, job.summary());
+				}
+				const ids = Array.isArray(b.targets) ? b.targets.map(String) : [];
+				const chosen = restreamTargets.list().filter((t) => ids.includes(t.id));
+				if (!chosen.length) return send(res, 400, { error: "choose where to stream first" });
+				try {
+					await job.startRestream(chosen, {
+						from: typeof b.from === "number" ? b.from : 0,
+						burn: b.burn !== false,
+						style: b.style,
+						height: b.height === 1080 ? 1080 : 720
+					});
+				} catch (err) {
+					return send(res, 400, { error: err.message });
+				}
+				return send(res, 200, job.summary());
+			}
 			if (route === "models") {
 				const out = [];
 				for (const p of llmService?.listProviders?.() ?? []) {