nixamp 0.28.44 → 0.29.1

package/src/publish-choice.ts

@@ -0,0 +1,35 @@
+/**
+ * Whether this server goes in the public directory.
+ *
+ * A listing is a phone code and a link anybody can open, so it is a thing
+ * somebody chose, not a thing that happens because a daemon had no terminal
+ * to ask on. The choice is asked once, or taken from a flag, and written into
+ * config.json beside the library, and every later start reads it back.
+ *
+ * Servers that were listed before the choice was written down keep being
+ * listed: a daemon without a terminal used to publish by itself, and quietly
+ * taking it off the directory on an update would be changing somebody's
+ * choice for them. A server new to this machine is not listed until asked.
+ */
+export type PublishFlag = "ask" | "yes" | "no";
+
+/**
+ * "yes" or "no" when the answer is already known, "ask" when there is a
+ * person at the terminal to ask.
+ */
+export function publishChoice(
+  flag: PublishFlag,
+  recorded: boolean | undefined,
+  interactive: boolean,
+  established: boolean,
+): "yes" | "no" | "ask" {
+  if (flag !== "ask") return flag;
+  if (recorded !== undefined) return recorded ? "yes" : "no";
+  if (interactive) return "ask";
+  return established ? "yes" : "no";
+}
+
+/** Whether to write the answer down: only a choice nobody had made yet. */
+export function shouldRecord(flag: PublishFlag, recorded: boolean | undefined): boolean {
+  return flag === "ask" && recorded === undefined;
+}

package/src/server.ts

@@ -9,7 +9,9 @@
  * a WebSocket because SSE is plain HTTP: no dependency, and it reconnects on
  * its own when the laptop running the remote goes to sleep.
  */
-import { createReadStream, statSync } from "node:fs";
+import { publishChoice, shouldRecord } from "./publish-choice.ts";
+import { protocolArgs } from "./decoder-policy.ts";
+import { createReadStream, existsSync, statSync } from "node:fs";
 import { createServer as createHttpServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
 import { randomBytes } from "node:crypto";
@@ -68,6 +70,7 @@ import { Directory, ENDED_TTL_MS, parseAnnouncement, type LineupEntry, type List
 import { ArtCache, coverArtOf, stillFrom } from "./art.ts";
 import { PartyLine, telnyxSms } from "./partyline.ts";
 import { HlsPackagers, segmentType, withKey } from "./hls.ts";
+import { refusedDestination } from "./destinations.ts";
 import { CompressionService } from "./compression/service.ts";
 import { handleChannelCompression, handleCompressionApi, handleStaticRelay, type RouteContext } from "./compression/routes.ts";
 import { DEFAULT_SITE as NICHEDB, Enricher, type EnrichKind, FIXTURE_TTL_MS } from "./enrich.ts";
@@ -86,7 +89,7 @@ import { Porkbun, isIPv4, isIPv6, type DnsZone } from "./dns.ts";
 import { NameError, Names } from "./names.ts";
 import { AcmeIssuer, Certs } from "./certs.ts";
 import { claimName, fetchCert, humanizeSource, labelFor, readCertFiles, writeCertFiles } from "./naming.ts";
-import { forbiddenLibrary, readLibrary } from "./library.ts";
+import { forbiddenLibrary, readConfig, readLibrary, writeConfig } from "./library.ts";
 import { createThrottle, presentedCredential, type Throttle } from "@profullstack/throttle";
 import { Durable } from "./durable.ts";
 import { notifyAll, resendEmail, webPush, type Notification } from "./notify.ts";
@@ -1976,7 +1979,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         json(response, 404, { error: "not found" });
         return;
       }
-      response.writeHead(302, { ...CORS, "set-cookie": keyCookie(offered), location: "/" });
+      response.writeHead(302, { ...CORS, "set-cookie": keyCookie(offered, (request.socket as { encrypted?: boolean }).encrypted === true || (options.secureCookies ?? false)), location: "/" });
       response.end();
       return;
     }
@@ -2563,6 +2566,10 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
     // port is open from another device before wondering whether the link is
     // wrong, and it says nothing about the library.
     const eventChannelRequest = Boolean(channelId && await eventForChannel());
+    // Whether this request holds only the listen key. A listener may browse
+    // and hear the library, but where it lives on this machine is the
+    // owner's business: the absolute path names the user account and the disk.
+    let listening = false;
     if (
       key !== null &&
       path !== "/api/health" &&
@@ -2571,6 +2578,8 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       !eventChannelRequest
     ) {
       let scope = scopeOf(keyFrom(request, url), key, listenKey);
+      // Kept for the routes below that answer a listener with less.
+      const settle = (): void => { listening = scope === "listen"; };
       // A key is how somebody who was invited proves it. It is not the only way
       // to be allowed in: the person who owns this server is allowed in whether
       // or not they still have the link, and their nixamp.com session says who
@@ -2596,6 +2605,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         });
         return;
       }
+      settle();
       if (scope === "listen" && !allowedForListening(path)) {
         json(response, 403, { error: "this link can listen, not drive" });
         return;
@@ -4631,11 +4641,32 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         json(response, 429, { error: `this server is already carrying ${MAX_ON_DEMAND} channels on demand; try again in a minute` });
         return;
       }
-      const resolved = known ?? await resolveLink(options.ytdlp ?? null, link, { cookies: options.cookies ?? "" });
+      // A member's link is fetched from inside the owner's network, so it has
+      // to lead somewhere public: the link, every hop of a playlist, and
+      // whatever yt-dlp says the media is. The owner's is theirs to aim.
+      const guard = liveBy && !known ? (one: string) => refusedDestination(one) : undefined;
+      if (guard) {
+        const refused = await guard(link);
+        if (refused) {
+          json(response, 403, { error: refused });
+          return;
+        }
+      }
+      const resolved = known ?? await resolveLink(options.ytdlp ?? null, link, { cookies: options.cookies ?? "", guard });
       if ("error" in resolved) {
-        json(response, 422, { error: resolved.error });
+        json(response, guard && resolved.error.includes("private network") ? 403 : 422, { error: resolved.error });
         return;
       }
+      if (guard) {
+        const reached = [resolved.media, resolved.audio, ...(resolved.playlist ?? [])].filter((one) => one && /^(https?|rtmps?):\/\//i.test(one));
+        for (const one of [...new Set(reached)].slice(0, 200)) {
+          const refused = await guard(one);
+          if (refused) {
+            json(response, 403, { error: refused });
+            return;
+          }
+        }
+      }
       links.set(link, resolved);
       // A channel already on -- put back by a restart, which forgets where
       // it came from -- learns its picture and its line from the link pasted
@@ -5494,7 +5525,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
     }
 
     if (path === "/api/state") {
-      json(response, 200, engine.snapshot());
+      json(response, 200, listening ? { ...engine.snapshot(), root: "" } : engine.snapshot());
       return;
     }
 
@@ -5562,7 +5593,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         "x-accel-buffering": "no",
       });
       const send = (snapshot: Snapshot): void => {
-        response.write(`data: ${JSON.stringify(snapshot)}\n\n`);
+        response.write(`data: ${JSON.stringify(listening ? { ...snapshot, root: "" } : snapshot)}\n\n`);
       };
       const unsubscribe = engine.subscribe(send);
       // A comment line keeps proxies from closing an idle stream.
@@ -6039,6 +6070,7 @@ async function liveAudio(
         // A live source has no beginning to seek from.
         ...(from > 1 && !isRemote(source) ? ["-ss", String(from)] : []),
         "-re",
+        ...protocolArgs(source),
         "-i", source,
         ...(asVideo
           // Copied where it can be, because a room full of viewers is a room
@@ -6157,6 +6189,7 @@ function pipeFfmpeg(
       // when they are handed to it for a file on disk.
       ...(isRemote(source) ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : []),
       ...inputArgs,
+      ...protocolArgs(source),
       "-i", source,
       ...outputArgs,
       "-",
@@ -6341,6 +6374,10 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   // still works after a restart -- and a server is restarted to pick up a new
   // version, which is to say often. `--new-key` mints a fresh pair and forgets
   // the old one, which is the way to revoke a link that got out.
+  // Whether this port had keys before this start: a server that has run
+  // here before, whose directory listing (see publishChoice) is kept.
+  const established = existsSync(join(stateDir(), "keys.json")) &&
+    (() => { try { return String(options.port) in (JSON.parse(readFileSync(join(stateDir(), "keys.json"), "utf8")) as object); } catch { return false; } })();
   const remembered = options.key ? rememberedKeys(stateDir(), options.port, options.newKey) : null;
   const key = remembered?.key ?? null;
   // Kept whether or not it is published, so `nixamp admin` and the operator
@@ -7475,10 +7512,20 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     // public at all.
     //
     // Still asked when a person is at the terminal to answer, because that is
-    // somebody who can say no.
-    const wanted = options.publish === "yes" || !process.stdin.isTTY
-      ? true
-      : await confirm(`\n  List this stream at ${DEFAULT_DIRECTORY}/directory so anyone can find it?\n  It publishes ${listen} — listen only, not the controls.`);
+    // somebody who can say no -- and since 0.29 the answer is kept, so a
+    // daemon started later does what the person said, not what it guesses.
+    const recorded = readConfig().publish;
+    const choice = publishChoice(options.publish, recorded, Boolean(process.stdin.isTTY), established);
+    const wanted = choice === "ask"
+      ? await confirm(`\n  List this stream at ${DEFAULT_DIRECTORY}/directory so anyone can find it?\n  It publishes ${listen} — listen only, not the controls.`)
+      : choice === "yes";
+    if (shouldRecord(options.publish, recorded)) {
+      try { writeConfig({ publish: wanted }); } catch { /* unwritable state: asked again next time */ }
+    }
+    if (!wanted && options.publish === "ask") {
+      console.log("");
+      console.log(`  Not listed at ${DEFAULT_DIRECTORY}/directory. Start with --publish to list it.`);
+    }
 
     if (wanted) {
       publisher = makePublisher();

package/src/share.ts

@@ -136,11 +136,12 @@ export function keyFrom(request: IncomingMessage, url: URL): string | null {
 }
 
 /** The Set-Cookie for a browser that just opened the link. */
-export function keyCookie(key: string): string {
+export function keyCookie(key: string, secure = false): string {
   // HttpOnly because nothing in the page reads it: the browser attaches it to
-  // every same-origin request by itself. No Secure, because the whole point is
-  // a plain-http address on your own network.
-  return `${KEY_COOKIE}=${encodeURIComponent(key)}; Path=/; Max-Age=31536000; SameSite=Lax; HttpOnly`;
+  // every same-origin request by itself. Secure only when the link was opened
+  // over https: a plain-http address on your own network is still a thing,
+  // and a Secure cookie there would never be sent back.
+  return `${KEY_COOKIE}=${encodeURIComponent(key)}; Path=/; Max-Age=31536000; SameSite=Lax; HttpOnly${secure ? "; Secure" : ""}`;
 }
 
 /**

package/src/shared-translation.ts

@@ -1,26 +1,8 @@
-/** One live source/language pipeline, paid access for every listening account.
- * Browsers receive the same PCM, never upload a replacement for a public feed. */
-import { transientAudioError } from "./live-recovery.ts";
-import { createHash, randomUUID } from "node:crypto";
-import { lookup } from "node:dns/promises";
-import { BlockList, isIP } from "node:net";
-import http from "node:http";
-import https from "node:https";
-import { spawn } from "node:child_process";
-import { Interpreter, type Caption } from "./live-interpreter.ts";
-import { LiveVoice, LIVE_VOICE_LANGUAGES } from "./live-voice.ts";
-import { SpeechError } from "./speech.ts";
-import type { Translator } from "./translate.ts";
-import type { TranslationMeter, TranslationUsage } from "./translation-passes.ts";
+/** Shared live translation, from @profullstack/live-translate, limited to nixamp channels. */
+import { SharedTranslations as Base, liveInput as baseLiveInput, SpeechError, type OpenLiveInput } from "@profullstack/live-translate";
+export { publicStreamAddress, type LiveInput, type OpenLiveInput, type SharedEvent } from "@profullstack/live-translate";
 
-const blocked = new BlockList();
-for (const [ip, bits] of [["0.0.0.0",8],["10.0.0.0",8],["100.64.0.0",10],["127.0.0.0",8],["169.254.0.0",16],["172.16.0.0",12],["192.0.0.0",24],["192.0.2.0",24],["192.168.0.0",16],["198.18.0.0",15],["198.51.100.0",24],["203.0.113.0",24],["224.0.0.0",4],["240.0.0.0",4]] as const) blocked.addSubnet(ip, bits, "ipv4");
-const v6global = new BlockList(); v6global.addSubnet("2000::", 3, "ipv6");
-blocked.addSubnet("2001:db8::", 32, "ipv6"); blocked.addSubnet("2002::", 16, "ipv6"); blocked.addSubnet("2001::", 32, "ipv6");
-export function publicStreamAddress(address: string): boolean {
-  const family = isIP(address);
-  return family === 4 ? !blocked.check(address, "ipv4") : family === 6 && v6global.check(address, "ipv6") && !blocked.check(address, "ipv6");
-}
+/** Only a live nixamp channel (`/api/channels/<id>`, optionally `?k=`). */
 export function sharedSource(raw: string): URL {
   let url: URL;
   try { url = new URL(raw); } catch { throw new SpeechError("Choose a live Nixamp channel.", 400); }
@@ -28,205 +10,8 @@ export function sharedSource(raw: string): URL {
   if (url.toString().length > 2048) throw new SpeechError("Invalid live source.", 400);
   url.searchParams.sort(); return url;
 }
-export interface LiveInput { stop(): void; }
-export type OpenLiveInput = (source: URL, pcm: (bytes: Buffer) => void, ended: () => void, signal: AbortSignal) => Promise<LiveInput>;
-
-/** Resolve once and pin that public address; no redirects or ffmpeg URL fetches. */
-export function liveInput(ffmpeg: string[] = ["ffmpeg"]): OpenLiveInput {
-  return async (source, pcm, ended, signal) => {
-    const hostname = source.hostname.replace(/^\[|\]$/g, "");
-    const addresses = await lookup(hostname, { all: true });
-    if (!addresses.length || addresses.some(one => !publicStreamAddress(one.address))) throw new SpeechError("This live source is not publicly reachable.", 400);
-    signal.throwIfAborted();
-    const selected = addresses[0]!;
-    const child = spawn(ffmpeg[0]!, [...ffmpeg.slice(1), "-v", "error", "-nostats", "-protocol_whitelist", "pipe", "-readrate", "1", "-analyzeduration", "500000", "-probesize", "262144", "-i", "pipe:0", "-vn", "-ac", "1", "-ar", "16000", "-f", "s16le", "pipe:1"], { stdio: ["pipe", "pipe", "ignore"] });
-    let stopped = false;
-    const request = (source.protocol === "https:" ? https : http).get(source, {
-      signal, headers: { "user-agent": "Nixamp shared translated audio", accept: "audio/*,video/*,application/octet-stream" },
-      lookup: (_name, options, callback) => { if (typeof options === "object" && options.all) callback(null, [selected]); else callback(null, selected.address, selected.family); },
-    });
-    const stop = (): void => { if (stopped) return; stopped = true; request.destroy(); child.stdin.destroy(); child.kill("SIGKILL"); signal.removeEventListener("abort", stop); };
-    const end = (): void => { if (!stopped) { stop(); ended(); } };
-    signal.addEventListener("abort", stop, { once: true });
-    child.stdout.on("data", pcm); child.on("error", end); child.on("close", end); child.stdin.on("error", end);
-    request.on("response", response => {
-      if (response.statusCode !== 200) { response.destroy(); end(); return; }
-      response.on("error", end); response.on("end", end); response.pipe(child.stdin);
-    });
-    request.on("error", end);
-    request.setTimeout(15_000, end);
-    return { stop };
-  };
-}
-
-export type SharedEvent = { type: "status"; listeners: number } | { type: "line"; id: string; line: Caption } | { type: "audio"; id: string; data: string } | { type: "end"; id: string } | { type: "error"; error: string; retryable?: boolean };
-type Member = { by: string; send: (event: SharedEvent) => void; close: () => void };
-interface Feed { id: string; source: URL; language: string; members: Set<Member>; controller: AbortController; input?: LiveInput; interpreter: Interpreter; meter: TranslationMeter; reservations: Map<string, string[]>; queue: Caption[]; speaking: boolean; voiceFailures: number; previous: Buffer; pending: Buffer; until: number; heartbeat?: ReturnType<typeof setInterval>; }
-
-export class SharedTranslations {
-  private readonly feeds = new Map<string, Feed>();
-  constructor(private readonly options: { voice: LiveVoice; translator: Pick<Translator, "translate">; billing?: TranslationMeter; open?: OpenLiveInput }) {}
-  get size(): number { return this.feeds.size; }
+export function liveInput(ffmpeg: string[] = ["ffmpeg"]): OpenLiveInput { return baseLiveInput(ffmpeg, "Nixamp shared translated audio"); }
 
-  async join(raw: string, language: string, by: string, send: Member["send"], close: () => void): Promise<() => void> {
-    if (!this.options.voice.available()) throw new SpeechError("Translated audio is unavailable.", 503);
-    const source = sharedSource(raw);
-    if (!LIVE_VOICE_LANGUAGES.has(language)) throw new SpeechError("Choose a supported audio language.", 400);
-    const id = `dub-${createHash("sha256").update(`${source}|${language}`).digest("hex").slice(0, 40)}`;
-    const capacity = (): void => {
-      const connections = [...this.feeds.values()].reduce((total, feed) => total + [...feed.members].filter(member => member.by === by).length, 0);
-      if (connections >= 2) throw new SpeechError("Translated audio is already open in two players for this account.", 429);
-      const feed = this.feeds.get(id);
-      if (!feed && this.feeds.size >= 4) throw new SpeechError("Live translation is busy. Try again shortly.", 429);
-      if (feed && feed.members.size >= 1000) throw new SpeechError("This translated stream is full. Try again shortly.", 429);
-    };
-    capacity();
-    if (this.options.billing?.begin) await this.options.billing.begin(by, id);
-    else await this.options.billing?.require(by, id);
-    capacity(); // Other joins can finish during the account/database check.
-    let feed = this.feeds.get(id);
-    if (!feed) {
-      feed = this.make(id, source, language); this.feeds.set(id, feed);
-      const current = feed;
-      current.heartbeat = setInterval(() => void this.checkMembers(current), 10_000); current.heartbeat.unref?.();
-    }
-    const member = { by, send, close }; feed.members.add(member);
-    this.broadcast(feed, { type: "status", listeners: feed.members.size });
-    if (feed.members.size === 1 && !feed.input) void this.start(feed);
-    const current = feed;
-    return () => this.leave(current, member);
-  }
-  private leave(feed: Feed, member: Member): void {
-    if (!feed.members.delete(member)) return;
-    if (!feed.members.size) {
-      if (feed.heartbeat) clearInterval(feed.heartbeat);
-      feed.controller.abort(); feed.input?.stop(); feed.interpreter.reset(); feed.queue = [];
-      this.feeds.delete(feed.id);
-    } else this.broadcast(feed, { type: "status", listeners: feed.members.size });
-  }
-  private async checkMembers(feed: Feed): Promise<void> {
-    const accounts = [...new Set([...feed.members].map(member => member.by))];
-    let funded = new Set(accounts), message = "This free session ended and audio credit is used up. Start a remaining free session or buy a pass.";
-    try {
-      if (this.options.billing?.eligible) funded = new Set(await this.options.billing.eligible(accounts, feed.id));
-      else if (this.options.billing) {
-        const results = await Promise.allSettled(accounts.map(by => this.options.billing!.require(by, feed.id)));
-        funded = new Set(accounts.filter((_by, index) => results[index]?.status === "fulfilled"));
-      }
-    } catch { funded.clear(); message = "Your translation access could not be checked. Try again shortly."; }
-    for (const member of [...feed.members]) if (accounts.includes(member.by) && !funded.has(member.by)) {
-      try { member.send({ type: "error", error: message }); } catch { /* disconnected */ }
-      finally { this.leave(feed, member); member.close(); }
-    }
-  }
-  private broadcast(feed: Feed, event: SharedEvent): void {
-    for (const member of [...feed.members]) {
-      try { member.send(event); } catch { this.leave(feed, member); member.close(); }
-    }
-  }
-  private stop(feed: Feed, error: string, retryable = false): void {
-    this.broadcast(feed, { type: "error", error, retryable });
-    for (const member of [...feed.members]) { this.leave(feed, member); member.close(); }
-  }
-  private make(id: string, source: URL, language: string): Feed {
-    const feed = { id, source, language, members: new Set<Member>(), controller: new AbortController(), reservations: new Map<string, string[]>(), queue: [], speaking: false, voiceFailures: 0, previous: Buffer.alloc(0), pending: Buffer.alloc(0), until: Date.now() } as unknown as Feed;
-    // Each account uses free access first, then the same published credit rate.
-    // Additional listeners do not trigger recognition or synthesis.
-    feed.meter = {
-      require: async () => { if (!feed.members.size) throw new SpeechError("No listeners.", 410); },
-      reserve: async (_by: string, kind: TranslationUsage, units: number) => {
-        const ids: string[] = [];
-        const accounts = [...new Set([...feed.members].map(member => member.by))];
-        const accepted = new Set<string>();
-        const billing = this.options.billing;
-        if (billing?.reserveMany) {
-          for (const charged of await billing.reserveMany(accounts, kind, units, feed.id)) { ids.push(charged.id); accepted.add(charged.by); }
-        } else {
-          const results = await Promise.allSettled(accounts.map(async account => ({ by: account, id: await billing?.reserve(account, kind, units, feed.id) })));
-          let failure: unknown;
-          for (const result of results) {
-            if (result.status === "fulfilled") { accepted.add(result.value.by); if (result.value.id) ids.push(result.value.id); }
-            else if (!(result.reason instanceof SpeechError) || result.reason.status !== 402) failure = result.reason;
-          }
-          if (failure) { await Promise.all(ids.map(id => billing!.refund(id))); throw failure; }
-        }
-        for (const member of [...feed.members]) if (accounts.includes(member.by) && !accepted.has(member.by)) {
-          try { member.send({ type: "error", error: "This free session ended and audio credit is used up. Start a remaining free session or buy a pass." }); }
-          catch { /* disconnected */ } finally { this.leave(feed, member); member.close(); }
-        }
-        if (!feed.members.size) { await Promise.all(ids.map(id => this.options.billing!.refund(id))); throw new SpeechError("No funded listeners.", 402); }
-        const reservation = randomUUID(); feed.reservations.set(reservation, ids); return reservation;
-      },
-      commit: async id => { const ids = feed.reservations.get(id) ?? []; if (this.options.billing?.commitMany) await this.options.billing.commitMany(ids); else await Promise.all(ids.map(id => this.options.billing!.commit(id))); feed.reservations.delete(id); },
-      refund: async id => { const ids = feed.reservations.get(id) ?? []; if (this.options.billing?.refundMany) await this.options.billing.refundMany(ids); else await Promise.all(ids.map(id => this.options.billing!.refund(id))); feed.reservations.delete(id); },
-    };
-    let voices: Awaited<ReturnType<LiveVoice["voices"]>> = [];
-    feed.interpreter = new Interpreter({
-      language: () => language, speakers: () => true, voices: () => voices, channel: () => id,
-      status: text => { if (!feed.controller.signal.aborted && !feed.members.size) this.stop(feed, text); },
-      failed: message => this.stop(feed, message),
-      lines: lines => {
-        feed.queue.push(...lines);
-        feed.queue = feed.queue.filter(line => Date.now() - line.until <= 12_000).slice(-24);
-        if (!feed.speaking) void this.speak(feed);
-      },
-      fetcher: (async (url, init) => {
-        feed.controller.signal.throwIfAborted();
-        const signal = AbortSignal.any([feed.controller.signal, ...(init?.signal ? [init.signal] : [])]);
-        if (String(url).includes("/speakers")) {
-          voices = await this.options.voice.voices();
-          return Response.json(await this.options.voice.hear(new Uint8Array(init?.body as Uint8Array), id, signal, feed.meter));
-        }
-        const body = JSON.parse(String(init?.body));
-        return Response.json(await this.options.translator.translate(body.texts, body.from, body.to, { by: id, deadline: Date.now() + 10_000 }));
-      }) as typeof fetch,
-    });
-    return feed;
-  }
-  private async start(feed: Feed): Promise<void> {
-    try {
-      const input = await (this.options.open ?? liveInput())(feed.source, bytes => {
-        if (feed.controller.signal.aborted) return;
-        feed.pending = Buffer.concat([feed.pending, bytes]);
-        while (feed.pending.length >= 64_000) {
-          const fresh = feed.pending.subarray(0, 64_000); feed.pending = feed.pending.subarray(64_000);
-          const pcm = Buffer.concat([feed.previous, fresh]); feed.previous = pcm.subarray(-128_000);
-          feed.until += 2000;
-          if (Math.abs(Date.now() - feed.until) > 2000) feed.until = Date.now();
-          const samples = new Float32Array(pcm.length / 2);
-          for (let index = 0; index < samples.length; index++) samples[index] = pcm.readInt16LE(index * 2) / 32768;
-          feed.interpreter.push({ samples, at: feed.until - samples.length / 16, until: feed.until, freshAt: feed.until - 2000 });
-        }
-      }, () => this.stop(feed, "The live source disconnected.", true), feed.controller.signal);
-      if (feed.controller.signal.aborted) input.stop(); else feed.input = input;
-    } catch (error) { this.stop(feed, error instanceof SpeechError ? error.message : "The live source could not be opened."); }
-  }
-  private async speak(feed: Feed): Promise<void> {
-    feed.speaking = true;
-    try {
-      while (feed.queue.length && !feed.controller.signal.aborted) {
-        const line = feed.queue.shift()!;
-        if (Date.now() - line.until > 12_000) continue;
-        try {
-          const response = await this.options.voice.stream({ text: line.text, language: feed.language, channel: feed.id, speaker: line.speaker, voice: feed.interpreter.tracker.speakers.get(line.speaker ?? "")?.voice }, feed.id, feed.controller.signal, feed.meter);
-          const id = randomUUID();
-          this.broadcast(feed, { type: "line", id, line });
-          const reader = response.body!.getReader();
-          try {
-            while (true) {
-              const { done, value } = await reader.read(); if (done) break;
-              for (let at = 0; at < value.length; at += 16_384) this.broadcast(feed, { type: "audio", id, data: Buffer.from(value.subarray(at, at + 16_384)).toString("base64") });
-            }
-          } finally { reader.releaseLock(); this.broadcast(feed, { type: "end", id }); }
-          feed.voiceFailures = 0;
-        } catch (error) {
-          if (feed.controller.signal.aborted) return;
-          if (!transientAudioError(error) || ++feed.voiceFailures >= 3) throw error;
-          // A provider failure skips this phrase; the source and other listeners
-          // remain connected. Never replay partial speech or retry a charge.
-        }
-      }
-    } catch (error) { if (!feed.controller.signal.aborted) this.stop(feed, error instanceof SpeechError ? error.message : "Translated audio was interrupted."); }
-    finally { feed.speaking = false; }
-  }
+export class SharedTranslations extends Base {
+  constructor(options: ConstructorParameters<typeof Base>[0]) { super({ parse: sharedSource, open: liveInput(), ...options }); }
 }

package/src/speaker-turns.ts

@@ -1,34 +1 @@
-/** Provider speaker IDs belong to a clip. Clients reconcile the overlapping
- * word timestamps before assigning a voice; these are not people's identities. */
-import { reliableText, type Wav } from "./speech.ts";
-import { voiceProfile, type VoiceProfile } from "./voice-profile.ts";
-
-export interface SpeakerTurn { start: number; end: number; text: string; speaker: string; profile: VoiceProfile; words: { text: string; start: number; end: number }[]; }
-export interface SpeakerTranscript { language: string; seconds: number; turns: SpeakerTurn[]; }
-export interface ScribeResult {
-  language_code?: string;
-  words?: { text: string; start: number; end: number; type: string; speaker_id?: string | null }[];
-}
-const ISO: Record<string, string> = Object.fromEntries("eng:en spa:es deu:de ger:de fra:fr fre:fr por:pt ita:it nld:nl dut:nl swe:sv dan:da fin:fi rus:ru ukr:uk ces:cs cze:cs hun:hu cmn:zh zho:zh ara:ar hin:hi vie:vi ind:id jpn:ja kor:ko pol:pl tur:tr ron:ro bul:bg ell:el nor:no nob:no nno:no".split(" ").map(pair => pair.split(":")));
-
-export function speakerTurns(body: ScribeResult, wav: Wav): SpeakerTranscript {
-  const seconds = wav.samples.length / wav.rate;
-  const language = ISO[body.language_code ?? ""] ?? body.language_code ?? "";
-  const turns: SpeakerTurn[] = [];
-  for (const word of (body.words ?? []).slice(0, 1500)) {
-    if (word.type !== "word" || typeof word.text !== "string" || !Number.isFinite(word.start) || !Number.isFinite(word.end) || word.start < 0 || word.end < word.start || word.end > seconds + 0.5) continue;
-    const speaker = typeof word.speaker_id === "string" && /^[\w-]{1,80}$/.test(word.speaker_id) ? word.speaker_id : "unknown";
-    const last = turns.at(-1);
-    if (last && last.speaker === speaker && word.start - last.end < 0.8 && last.text.length + word.text.length < 400) {
-      last.text += ` ${word.text}`; last.end = Math.max(last.end, word.end);
-      last.words.push({ text: word.text, start: word.start, end: word.end });
-    } else turns.push({ start: word.start, end: word.end, text: word.text, speaker, profile: "unknown", words: [{ text: word.text, start: word.start, end: word.end }] });
-  }
-  const pcm = Buffer.alloc(wav.samples.length * 2);
-  wav.samples.forEach((sample, i) => pcm.writeInt16LE(Math.round(Math.max(-1, Math.min(1, sample)) * 32767), i * 2));
-  for (const turn of turns) {
-    turn.text = reliableText(turn.text, Math.max(1, turn.end - turn.start));
-    turn.profile = voiceProfile(pcm.subarray(Math.floor(turn.start * 16000) * 2, Math.ceil(turn.end * 16000) * 2));
-  }
-  return { language, seconds, turns: turns.filter(turn => turn.text !== "") };
-}
+export { speakerTurns, type SpeakerTurn, type SpeakerTranscript, type ScribeResult } from "@profullstack/live-translate";

package/src/speech.ts

@@ -43,11 +43,10 @@ export const DEFAULT_MODEL = "onnx-community/whisper-base";
 /** Stored live lines from older recognition settings must be heard again. */
 export const NATIVE_REVISION = "native-v2";
 
-export class SpeechError extends Error {
-  constructor(message: string, readonly status: number) {
-    super(message);
-  }
-}
+/** The package's class, so an error thrown inside @profullstack/live-translate
+ * is still `instanceof SpeechError` to the server's handlers. */
+export { SpeechError } from "@profullstack/live-translate/core";
+import { SpeechError } from "@profullstack/live-translate/core";
 
 /** A stretch of the clip and what was said in it, seconds from the clip's start. */
 export interface Segment {