nixamp 0.17.0 → 0.18.0

package/src/compression/cli.ts

@@ -16,11 +16,14 @@
  * `nixamp admin` finds its target. JSON goes to stdout and only JSON;
  * progress and complaints go to stderr; a failure is a nonzero exit.
  */
-import { createWriteStream } from "node:fs";
+import { createWriteStream, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { resolveTarget } from "../admin.ts";
 import { detectTools } from "../audio.ts";
+import { version as nixampVersion } from "../meta.ts";
 import { KEY_HEADER } from "../share.ts";
 import type { Analysis } from "./analyze.ts";
+import { exactnessFailures, fileCorpus, reportMarkdown, reportPasses, runBenchmark, type Sample, syntheticCorpus } from "./benchmark.ts";
 import { RelayError } from "./envelope.ts";
 import type { Job } from "./jobs.ts";
 import { receiveRelay, RelayRefused } from "./receiver.ts";
@@ -36,6 +39,8 @@ const USAGE = `nixamp compression — lossless relay compression: measure it, se
   nixamp compression off | on          the whole server's switch
   nixamp compression pull --channel ID --from URL [--from-key KEY] [--name NAME]
   nixamp compression fetch URL --out FILE [--key KEY]
+  nixamp compression benchmark [--corpus DIR] [--out DIR] [--levels 1,3,9]
+                   prove the envelope on a corpus and write a report; no server or ffmpeg needed
 
   --url U --key K  a server other than the local daemon, as for \`nixamp admin\`
   --format json    JSON on stdout (the default when stdout is not a terminal)
@@ -309,6 +314,53 @@ async function fetchRelay(flags: Flags): Promise<number> {
   }
 }
 
+/**
+ * Run the OpenStream benchmark and write a report. Anyone can run it: the
+ * default corpus is bytes we generate, no server and no ffmpeg. `--corpus DIR`
+ * benchmarks a directory of real files instead; `--out DIR` writes
+ * `openstream-report.json` and `.md` there for publishing.
+ */
+async function bench(flags: Flags): Promise<number> {
+  const dir = flags.named.get("corpus");
+  let corpus: Sample[];
+  try {
+    corpus = dir ? fileCorpus(dir) : syntheticCorpus();
+  } catch (error) {
+    console.error(`nixamp: cannot read corpus ${dir}: ${(error as Error).message}`);
+    return 1;
+  }
+  if (corpus.length === 0) {
+    console.error(`nixamp: no samples${dir ? ` in ${dir}` : ""}`);
+    return 1;
+  }
+  console.error(`  Benchmarking ${corpus.length} sample${corpus.length === 1 ? "" : "s"}${dir ? ` from ${dir}` : " (synthetic)"}…`);
+  const levels = flags.named.get("levels");
+  const report = await runBenchmark(corpus, {
+    implementationVersion: nixampVersion(),
+    ...(levels ? { zstdLevels: levels.split(",").map((n) => Number(n)).filter((n) => Number.isInteger(n)) } : {}),
+  });
+  const out = flags.named.get("out");
+  if (out) {
+    try {
+      mkdirSync(out, { recursive: true });
+      writeFileSync(join(out, "openstream-report.json"), JSON.stringify(report, null, 2));
+      writeFileSync(join(out, "openstream-report.md"), reportMarkdown(report));
+      console.error(`  Wrote openstream-report.json and .md to ${out}`);
+    } catch (error) {
+      console.error(`nixamp: cannot write to ${out}: ${(error as Error).message}`);
+      return 1;
+    }
+  }
+  if (wantsJson(flags)) console.log(JSON.stringify(report, null, 2));
+  else console.log(reportMarkdown(report));
+  if (!reportPasses(report)) {
+    const bad = exactnessFailures(report).map((f) => `${f.sample}/${f.mode}${f.level ? `L${f.level}` : ""}`).join(", ");
+    console.error(`nixamp: these did not restore byte-for-byte, this build must not ship: ${bad}`);
+    return 1;
+  }
+  return 0;
+}
+
 export async function compression(argv: string[]): Promise<number> {
   const flags = parse(argv);
   const verb = flags.positional[0];
@@ -329,6 +381,9 @@ export async function compression(argv: string[]): Promise<number> {
         return await pull(flags);
       case "fetch":
         return await fetchRelay(flags);
+      case "benchmark":
+      case "bench":
+        return await bench(flags);
       default:
         console.error(USAGE);
         return verb === undefined || verb === "help" || flags.named.has("help") ? 0 : 2;

package/src/compression/receiver.ts

@@ -10,13 +10,78 @@
  * which is surfaced as an error naming the reason, never as a stream of
  * something else.
  */
-import { MEDIA_TYPE, type Mode, RelayError, type StreamHeader } from "./envelope.ts";
+import { type Boundary, MEDIA_TYPE, type Mode, RelayError, type StreamHeader } from "./envelope.ts";
 import { RelayDecoder } from "./relay.ts";
 
 export const CODECS_HEADER = "x-nixamp-stream-codecs";
 export const KIND_HEADER = "x-nixamp-kind";
+export const BOUNDARY_HEADER = "x-nixamp-boundary";
+/** What the media inside is, as JSON: video, audio, container, duration. */
+export const MEDIA_HEADER = "x-nixamp-codecs";
 export const KEY_HEADER = "x-nixamp-key";
 
+export interface Media {
+  video: string;
+  audio: string;
+  container: string;
+  duration?: number;
+}
+
+/** What a server said it would send, read off its response headers. */
+export interface Accepted {
+  codecs: string;
+  kind: "audio" | "video" | "";
+  boundary: Boundary | "";
+  media: Media | null;
+}
+
+function acceptedFrom(headers: Headers): Accepted {
+  const kindSaid = headers.get(KIND_HEADER);
+  const boundarySaid = headers.get(BOUNDARY_HEADER);
+  let media: Media | null = null;
+  try {
+    const raw = JSON.parse(headers.get(MEDIA_HEADER) ?? "null") as Partial<Media> | null;
+    if (raw && typeof raw.video === "string" && typeof raw.audio === "string" && typeof raw.container === "string") {
+      media = { video: raw.video, audio: raw.audio, container: raw.container };
+      if (typeof raw.duration === "number") media.duration = raw.duration;
+    }
+  } catch {
+    // Not JSON: no media description, which the receiver copes with.
+  }
+  return {
+    codecs: headers.get(CODECS_HEADER) ?? "",
+    kind: kindSaid === "audio" || kindSaid === "video" ? kindSaid : "",
+    boundary: boundarySaid === "source" || boundarySaid === "channel" ? boundarySaid : "",
+    media,
+  };
+}
+
+/**
+ * Ask a relay what it would send, without taking it: the negotiation
+ * headers come back on the response and the body is cancelled at once.
+ * Costs one short connection; a receiver needs to know the boundary and
+ * the media before it can decide how to carry the stream.
+ */
+export async function probeRelay(url: string, key: string | null, fetchImpl?: typeof fetch): Promise<Accepted> {
+  const headers: Record<string, string> = { accept: MEDIA_TYPE, [CODECS_HEADER]: "stored,zstd,ts-zstd" };
+  if (key) headers[KEY_HEADER] = key;
+  const response = await (fetchImpl ?? fetch)(url, { headers });
+  const type = response.headers.get("content-type") ?? "";
+  if (response.status !== 200 || !type.startsWith(MEDIA_TYPE)) {
+    let reason = `${response.status}`;
+    try {
+      const body = (await response.json()) as { error?: string };
+      if (typeof body.error === "string") reason = body.error;
+    } catch {
+      // Not JSON; the status is the message.
+    }
+    throw new RelayRefused(response.status, reason);
+  }
+  const accepted = acceptedFrom(response.headers);
+  await response.body?.cancel().catch(() => undefined);
+  return accepted;
+}
+
 export interface ReceiveOptions {
   url: string;
   key: string | null;
@@ -24,7 +89,7 @@ export interface ReceiveOptions {
   modes?: Mode[];
   maxFrameBytes?: number;
   /** The server said yes: what it will compress with, and what the channel carries. Before any byte. */
-  onStart?: (accepted: { codecs: string; kind: "audio" | "video" | "" }) => void;
+  onStart?: (accepted: Accepted) => void;
   /** The stream header arrived: the generation this is. */
   onHeader?: (header: StreamHeader) => void;
   onBytes: (bytes: Buffer) => void | Promise<void>;
@@ -74,11 +139,7 @@ export async function receiveRelay(options: ReceiveOptions): Promise<ReceiveResu
     throw new RelayRefused(response.status, reason);
   }
   if (!response.body) throw new RelayRefused(response.status, "no body");
-  const kindSaid = response.headers.get(KIND_HEADER);
-  options.onStart?.({
-    codecs: response.headers.get(CODECS_HEADER) ?? "",
-    kind: kindSaid === "audio" || kindSaid === "video" ? kindSaid : "",
-  });
+  options.onStart?.(acceptedFrom(response.headers));
   const decoder = new RelayDecoder({
     modes,
     ...(options.maxFrameBytes !== undefined ? { maxFrameBytes: options.maxFrameBytes } : {}),

package/src/compression/routes.ts

@@ -12,7 +12,7 @@
 import { createReadStream } from "node:fs";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { MEDIA_TYPE, parseModes } from "./envelope.ts";
-import { CODECS_HEADER, KIND_HEADER } from "./receiver.ts";
+import { BOUNDARY_HEADER, CODECS_HEADER, KIND_HEADER, MEDIA_HEADER } from "./receiver.ts";
 import type { CompressionService } from "./service.ts";
 
 export interface RouteContext {
@@ -140,6 +140,11 @@ export async function handleChannelCompression(
         "content-encoding": "identity",
         [CODECS_HEADER]: answer.codecs.join(","),
         [KIND_HEADER]: answer.kind,
+        // Which bytes these are, and what is inside them: a receiver of the
+        // source boundary hands them to its own ffmpeg and needs to know
+        // what ffmpeg will find, without a probe of its own.
+        [BOUNDARY_HEADER]: answer.boundary,
+        ...(answer.media ? { [MEDIA_HEADER]: JSON.stringify(answer.media) } : {}),
         "x-nixamp-generation": String(answer.generation),
       });
       const leave = (): void => answer.session.leave();
@@ -160,7 +165,7 @@ export async function handleChannelCompression(
       }
       const key = typeof body?.["key"] === "string" ? body["key"] : null;
       const name = typeof body?.["name"] === "string" ? body["name"] : id;
-      const started = service.pull(id, from, key, name);
+      const started = await service.pull(id, from, key, name);
       if (!started.ok) {
         json(response, started.status, { error: started.error });
         return true;

package/src/compression/service.ts

@@ -8,16 +8,17 @@
  * translates flags into the routes. There is no second copy of the rules.
  */
 import { statSync } from "node:fs";
-import { codecsOf } from "../audio.ts";
-import { type Channel, type Channels, GIVE_UP, REDIAL } from "../channels.ts";
+import { codecsOf, videoArgs } from "../audio.ts";
+import { type Channel, type ChannelInfo, type Channels, GIVE_UP, type PullThrough, REDIAL } from "../channels.ts";
 import { type Analysis, analyzeSample, SAMPLE_MAX_BYTES, SAMPLE_MAX_SECONDS } from "./analyze.ts";
 import { Pool } from "./codec.ts";
-import { type Mode, RelayError } from "./envelope.ts";
+import { type Boundary, type Mode, RelayError } from "./envelope.ts";
 import { AnalysisJobs, type Job } from "./jobs.ts";
 import { ChannelMetrics, type ChannelMetricsSnapshot } from "./metrics.ts";
 import { type ChannelPolicy, type LosslessPolicy, variantOf } from "./policy.ts";
-import { receiveRelay, RelayRefused } from "./receiver.ts";
+import { type Accepted, probeRelay, receiveRelay, RelayRefused } from "./receiver.ts";
 import { RelayEncoder, type RelayListener, type RelaySession } from "./relay.ts";
+import { relayThrough, sourceThrough, unreadable } from "./source.ts";
 import { type GlobalSettings, PolicyStore } from "./store.ts";
 import { type Prepared, StaticCache } from "./static.ts";
 
@@ -101,7 +102,16 @@ export interface ChannelStatus {
 }
 
 export type RelayAnswer =
-  | { ok: true; session: RelaySession; codecs: Mode[]; generation: number; kind: "audio" | "video" | "" }
+  | {
+      ok: true;
+      session: RelaySession;
+      codecs: Mode[];
+      generation: number;
+      kind: "audio" | "video" | "";
+      /** Which bytes the stream carries, and what is inside them. */
+      boundary: Boundary;
+      media: ChannelInfo["codecs"] | null;
+    }
   | { ok: false; status: 404 | 406 | 409 | 503; code: string; error: string };
 
 interface Running {
@@ -110,7 +120,17 @@ interface Running {
   variant: string;
 }
 
-/** An incoming relay: this server as the receiver, dialling again when it drops. */
+/**
+ * An incoming relay: this server as the receiver.
+ *
+ * Two shapes, decided by what the sender says it carries. A channel-boundary
+ * relay is the sender's finished output, so it is fed straight into a
+ * channel here and dialled again by this class when it drops. A
+ * source-boundary relay is the original transport stream, so it is handed
+ * to a channel's own ffmpeg as a source read through us -- which plays it
+ * exactly as the sender would have, lets it be relayed on again, and puts
+ * the redialling in the channel where it already lives.
+ */
 class Incoming {
   generation = 0;
   reconnects = 0;
@@ -223,8 +243,24 @@ export class CompressionService {
     this.statics = options.cacheDir
       ? new StaticCache(options.cacheDir, { pool: this.pool, ...(options.maxCacheBytes !== undefined ? { maxBytes: options.maxCacheBytes } : {}) })
       : null;
+    // Whether a pulled source is read here rather than by ffmpeg, decided at
+    // every dial: only when the channel's policy asks for the source boundary
+    // and the source is one we can read exactly (a plain transport stream).
+    // A channel we brought in from another nixamp's source-boundary relay is
+    // itself read through us, so it can be relayed on.
+    this.channels.setThrough((info, from, input, audio) => {
+      const relayed = this.relaySource.get(info.id);
+      if (relayed) return relayThrough(relayed.from, relayed.key);
+      const policy = this.store.get(info.id).losslessCompression;
+      if (policy.mode === "off" || policy.boundary !== "source") return null;
+      if (unreadable(info, from, input, audio) !== null) return null;
+      return sourceThrough(info.source ?? "");
+    });
   }
 
+  /** Incoming source-boundary relays, so their channel is read through us. */
+  private readonly relaySource = new Map<string, { from: string; key: string | null }>();
+
   private get channels(): Channels {
     return this.options.channels;
   }
@@ -239,8 +275,15 @@ export class CompressionService {
       lossless.mode = "off";
       reason = "compression is off for the whole server";
     } else if (lossless.mode !== "off" && lossless.boundary === "source") {
-      lossless.mode = "off";
-      reason = "original source bytes are unavailable: this server's sources are read by ffmpeg, and only the channel boundary can be relayed";
+      // The source boundary is available only for a source we can read here.
+      // A live channel that is not read through us cannot offer it; a channel
+      // that is not on yet is given the benefit of the doubt until it is.
+      const info = this.channels.info(id);
+      const why = info ? unreadable(info, 0, [], "") : null;
+      if (why !== null) {
+        lossless.mode = "off";
+        reason = `original source bytes are unavailable: ${why}`;
+      }
     }
     return {
       losslessCompression: lossless,
@@ -333,7 +376,9 @@ export class CompressionService {
     }
     // A receiver that cannot undo the transform gets a variant without it.
     const variantPolicy: LosslessPolicy = { ...policy, tsAware: policy.tsAware && codecs.includes("ts-zstd") };
-    const variant = variantOf(variantPolicy);
+    // The boundary is part of the variant: a source relay and a channel
+    // relay are two different streams, and two different compressors.
+    const variant = `${policy.boundary}:${variantOf(variantPolicy)}`;
     let running = this.running.get(id);
     if (running && running.variant !== variant) {
       // One compressor per channel. A second variant would be a second
@@ -341,17 +386,32 @@ export class CompressionService {
       return { ok: false, status: 409, code: "VARIANT_IN_USE", error: "this channel is already being relayed under a different codec set; try again when that relay ends" };
     }
     if (!running) {
-      const started = this.startEncoder(id, variantPolicy, variant);
-      if (!started) return { ok: false, status: 503, code: "CHANNEL_GONE", error: "the channel ended before the relay could start" };
+      const started = this.startEncoder(id, variantPolicy, variant, policy.boundary);
+      if (!started) {
+        return started === null
+          ? { ok: false, status: 503, code: "CHANNEL_GONE", error: "the channel ended before the relay could start" }
+          : { ok: false, status: 409, code: "SOURCE_BOUNDARY_UNAVAILABLE", error: "the source is not being read through this server, so its original bytes are not available to relay" };
+      }
       running = started;
     }
-    // The opening bytes and the join point, in the same tick.
-    const preface = this.channels.opening(id);
+    // For the channel boundary, the opening bytes are the preface. The source
+    // boundary has none: a joining demuxer re-syncs on the next PAT and
+    // keyframe, exactly as it does when a live source is joined.
+    const preface = policy.boundary === "source" ? [] : this.channels.opening(id);
     const session = running.encoder.join(listener, preface);
-    return { ok: true, session, codecs, generation: running.encoder.generation, kind: this.channels.kindOf(id) ?? "" };
+    return {
+      ok: true,
+      session,
+      codecs,
+      generation: running.encoder.generation,
+      kind: this.channels.kindOf(id) ?? "",
+      boundary: policy.boundary,
+      media: this.channels.info(id)?.codecs ?? null,
+    };
   }
 
-  private startEncoder(id: string, policy: LosslessPolicy, variant: string): Running | null {
+  /** Null: the channel ended. False: the source boundary was asked for but is not being read through us. */
+  private startEncoder(id: string, policy: LosslessPolicy, variant: string, boundary: Boundary): Running | null | false {
     this.generation = (this.generation + 1) % 0xffff_ffff;
     const metrics = this.metrics.get(id) ?? new ChannelMetrics();
     this.metrics.set(id, metrics);
@@ -361,7 +421,7 @@ export class CompressionService {
       policy,
       pool: this.pool,
       metrics,
-      boundary: "channel",
+      boundary,
       onAbort: () => {
         if (record && this.running.get(id) === record) {
           this.running.delete(id);
@@ -378,22 +438,58 @@ export class CompressionService {
         }
       },
     });
-    const detach = this.channels.listen(id, {
-      write: (chunk) => encoder.write(chunk),
-      end: () => encoder.end(),
-      pending: () => metrics.queueBytes,
-    });
-    if (detach === null) return null;
+    const face = {
+      write: (chunk: Buffer): boolean => encoder.write(chunk),
+      end: (): void => encoder.end(),
+      pending: (): number => metrics.queueBytes,
+    };
+    // The source boundary taps the source's own bytes; the channel boundary
+    // is one more ordinary listener on the channel's output.
+    const detach = boundary === "source" ? this.channels.tapSource(id, face) : this.channels.listen(id, face);
+    if (detach === null) return boundary === "source" ? false : null;
     encoder.attach();
     record = { encoder, detach, variant };
     this.running.set(id, record);
     return record;
   }
 
-  /** Start listening to another nixamp's channel as one of ours. */
-  pull(id: string, from: string, key: string | null, name: string): { ok: true } | { ok: false; status: 409 | 400; error: string } {
+  /**
+   * Start listening to another nixamp's channel as one of ours. Probes the
+   * relay first to learn its boundary: a channel-boundary relay is decoded
+   * and its bytes are the channel's output directly; a source-boundary relay
+   * is the original transport stream, so it is read through ffmpeg here
+   * exactly as a pulled source would be, and can be relayed on again.
+   */
+  async pull(id: string, from: string, key: string | null, name: string): Promise<{ ok: true } | { ok: false; status: 409 | 400 | 502; error: string }> {
     if (!/^https?:\/\//i.test(from)) return { ok: false, status: 400, error: "the relay address must be http or https" };
     if (this.channels.has(id) || this.incoming.has(id)) return { ok: false, status: 409, error: `channel "${id}" is already on` };
+    let accepted: Accepted;
+    try {
+      accepted = await probeRelay(from, key);
+    } catch (error) {
+      const message = error instanceof RelayRefused ? `the relay refused: ${error.message}` : (error as Error).message;
+      return { ok: false, status: 502, error: message };
+    }
+    if (accepted.boundary === "source") {
+      // The upstream sends the original transport stream. Read it through
+      // ffmpeg here: the through-provider sees this registration and hands
+      // ffmpeg the decoded bytes. It can then be relayed on at either
+      // boundary, since its source now passes through this process.
+      const media = accepted.media;
+      const kind: "audio" | "video" = accepted.kind === "audio" ? "audio" : "video";
+      const encode = kind === "video"
+        ? videoArgs(media ?? { video: "h264", audio: "aac", container: "mpegts" })
+        : ["-vn", "-c:a", "libmp3lame", "-b:a", "192k", "-f", "mp3"];
+      this.relaySource.set(id, { from, key });
+      // A placeholder source string: the through-provider supplies the bytes,
+      // so this is only what a listener would never see and a restart reads.
+      const channel = this.channels.pull(id, name, from, encode, kind, true, undefined, [], "", { live: true, position: 0 }, media ?? undefined);
+      if (!channel) {
+        this.relaySource.delete(id);
+        return { ok: false, status: 409, error: `channel "${id}" is already on` };
+      }
+      return { ok: true };
+    }
     const inbound = new Incoming(id, from, key, name, this.channels, this.options.onEvent ?? (() => undefined), (gone) => this.incoming.delete(gone));
     this.incoming.set(id, inbound);
     inbound.start();
@@ -402,6 +498,7 @@ export class CompressionService {
 
   /** Stop an incoming relay, and the channel it feeds. */
   stopPull(id: string): boolean {
+    if (this.relaySource.delete(id)) return this.channels.stop(id);
     const inbound = this.incoming.get(id);
     if (!inbound) return false;
     inbound.stop();

package/src/compression/source.ts

@@ -0,0 +1,130 @@
+/**
+ * Reading a source ourselves, so its bytes exist here to be relayed.
+ *
+ * ffmpeg normally dials a channel's source and the original bytes never
+ * pass through this process. For a source-boundary relay they have to.
+ * This is the narrow set of sources that can be read here and piped to
+ * ffmpeg without changing how they play: a transport stream from a plain
+ * http(s) URL or a file, from its beginning, with no special request
+ * headers and no separate sound file. Anything else is left to ffmpeg,
+ * and a relay that asks for its source boundary is told why not.
+ *
+ * The second half is the receiving end of a source-boundary relay: the
+ * decoded original bytes, made into a source ffmpeg can be handed the
+ * same way, so a relayed transport stream plays here exactly as the
+ * original would have, and can be relayed on again.
+ */
+import { createReadStream, statSync } from "node:fs";
+import type { ChannelInfo, PullThrough } from "../channels.ts";
+import { receiveRelay } from "./receiver.ts";
+
+/**
+ * ffmpeg input flags that carry per-request authentication a plain fetch
+ * would not send: a user agent, a referer, cookies, arbitrary headers. A
+ * source that needs any of these is ffmpeg's to dial. Transport demux
+ * tuning (`-probesize`, `-analyzeduration`, `-fflags`) is not on this list:
+ * it applies to a piped read too and is no reason to refuse the tee.
+ */
+const HEADER_FLAGS = new Set(["-headers", "-user_agent", "-user-agent", "-referer", "-cookies", "-icy", "-http_proxy", "-http_persistent"]);
+
+/** The reason a source cannot be read here, or null when it can. */
+export function unreadable(info: ChannelInfo, from: number, input: string[], audio: string): string | null {
+  const source = info.source ?? "";
+  if (info.via !== "pull" || source === "") return "only a source this server pulls can be read here";
+  const container = info.codecs?.container ?? "";
+  if (!container.split(",").includes("mpegts")) return `the source is ${container || "of unknown container"}, not a transport stream`;
+  if (input.some((arg) => HEADER_FLAGS.has(arg))) return "the source needs request headers ffmpeg sends and nixamp does not";
+  if (audio !== "") return "the source keeps its sound in a second file";
+  if (from > 0) return "a film picked up mid-way cannot be read from its start";
+  if (/^https?:\/\//i.test(source)) return null;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(source)) return "only http(s) URLs and files can be read here";
+  try {
+    if (!statSync(source).isFile()) return "the source is not a file";
+  } catch {
+    return "the source file cannot be read";
+  }
+  return null;
+}
+
+/** Open a plain URL or a file as a stream of bytes, pulled shut by the signal. */
+export async function openSource(source: string, signal: AbortSignal): Promise<AsyncIterable<Uint8Array>> {
+  if (/^https?:\/\//i.test(source)) {
+    const response = await fetch(source, { signal, redirect: "follow", headers: { "user-agent": "nixamp" } });
+    if (!response.ok || !response.body) throw new Error(`the source answered ${response.status}`);
+    return response.body as unknown as AsyncIterable<Uint8Array>;
+  }
+  const stream = createReadStream(source, { highWaterMark: 256 * 1024 });
+  signal.addEventListener("abort", () => stream.destroy(), { once: true });
+  return stream;
+}
+
+/** A transport-stream source read by us, for `Channels.setThrough`. */
+export function sourceThrough(source: string): PullThrough {
+  return { format: "mpegts", open: (signal) => openSource(source, signal) };
+}
+
+/** How many decoded bytes may wait for ffmpeg before the relay is asked to pause. */
+const RELAY_QUEUE = 8 * 1024 * 1024;
+
+/**
+ * A relay's decoded bytes as an async iterable, at the pace ffmpeg takes
+ * them. The decoder is asked to wait when too much is queued, which holds
+ * the socket read, which is backpressure all the way to the sender's
+ * per-listener queue. A clean end ends the iterable; a broken stream
+ * throws, and the channel's own redial dials again.
+ */
+export async function* relayBytes(url: string, key: string | null, signal: AbortSignal): AsyncGenerator<Buffer> {
+  const queue: Buffer[] = [];
+  let queued = 0;
+  let wake: (() => void) | null = null;
+  let room: (() => void) | null = null;
+  let done = false;
+  let failure: Error | null = null;
+  void receiveRelay({
+    url,
+    key,
+    signal,
+    onBytes: async (bytes) => {
+      queue.push(bytes);
+      queued += bytes.length;
+      wake?.();
+      wake = null;
+      if (queued > RELAY_QUEUE) await new Promise<void>((resume) => { room = resume; });
+    },
+  }).then(
+    () => {
+      done = true;
+      wake?.();
+    },
+    (error: Error) => {
+      failure = error;
+      done = true;
+      wake?.();
+    },
+  );
+  for (;;) {
+    const next = queue.shift();
+    if (next) {
+      queued -= next.length;
+      // Captured into a local: `room` is only ever assigned inside a callback,
+      // which the compiler cannot see, so it would narrow the field to null.
+      const resume = room as (() => void) | null;
+      if (resume && queued <= RELAY_QUEUE / 2) {
+        resume();
+        room = null;
+      }
+      yield next;
+      continue;
+    }
+    if (done) {
+      if (failure) throw failure;
+      return;
+    }
+    await new Promise<void>((resume) => { wake = resume; });
+  }
+}
+
+/** A source-boundary relay from another nixamp, as a source ffmpeg reads through us. */
+export function relayThrough(url: string, key: string | null): PullThrough {
+  return { format: "mpegts", open: async (signal) => relayBytes(url, key, signal) };
+}

package/src/links.ts

@@ -177,6 +177,13 @@ export function parseResolved(json: unknown, page: string): ResolvedLink | null
     }
   }
   if (media === "") return null;
+  // A link that was the media all along -- an IPTV feed at /channel/906,
+  // with no extension to say so -- is answered by yt-dlp's generic
+  // extractor with wherever the feed redirected to, which for a panel is a
+  // second host and a token minted for that one request. ffmpeg follows a
+  // redirect itself, so the link is kept as pasted and every redial gets a
+  // fresh token instead of a 403 an hour in.
+  if (record["direct"] === true && parts.length === 0 && /^https?:\/\//i.test(page)) media = page;
   const title = typeof record["title"] === "string" && record["title"].trim() !== ""
     ? record["title"].trim().slice(0, 200)
     : fileNameOf(page);
@@ -306,9 +313,11 @@ export async function resolveLink(
   options: { cookies?: string; timeoutMs?: number; format?: string } = {},
 ): Promise<ResolvedLink | { error: string }> {
   if (isDirectMedia(url)) return directLink(url);
-  if (!ytdlp || ytdlp.length === 0) {
-    return { error: "this server has no yt-dlp, so it can only play a direct link to a file or a stream" };
-  }
+  // Without yt-dlp, a link is taken as the media it may well be: an IPTV
+  // feed has no extension and no page behind it, and ffprobe -- asked next,
+  // before anything goes on the air -- tells a stream from a web page in a
+  // second. A page it cannot read is refused there, by name.
+  if (!ytdlp || ytdlp.length === 0) return directLink(url);
   const [command, ...prefix] = ytdlp as [string, ...string[]];
   return new Promise((done) => {
     let out = "";

package/src/live-api.ts

@@ -628,6 +628,7 @@ export async function handleLiveApi(
       json(response, error.status, { error: error.message });
       return true;
     }
+    console.error(`live api ${request.method} ${path}:`, error instanceof Error ? error.message : error);
     json(response, 500, { error: "the live event service failed" });
     return true;
   }

package/src/live-events.ts

@@ -173,19 +173,22 @@ const EVENT_SCHEMA = `
     ON live_events (visibility, status, starts_at, updated_at DESC);
   CREATE INDEX IF NOT EXISTS live_events_owner
     ON live_events (owner_id, updated_at DESC);
-  CREATE INDEX IF NOT EXISTS live_events_kind
-    ON live_events (kind, status, starts_at);
 
   -- The repo has no migration runner, so a table that already exists is
   -- brought forward here. Every statement is idempotent, and the CHECKs are
   -- replaced by name rather than added twice: the originals were unnamed, so
   -- the ones carrying the old status list are found by what they say.
+  -- The columns come before any index on them: nixamp.com had live_events
+  -- from before 0.17.0, and an index on kind ahead of ADD COLUMN kind failed
+  -- there while every fresh database (tests, CI) sailed through.
   ALTER TABLE live_events ADD COLUMN IF NOT EXISTS kind               TEXT    NOT NULL DEFAULT 'talk';
   ALTER TABLE live_events ADD COLUMN IF NOT EXISTS doors_open_at      TIMESTAMPTZ;
   ALTER TABLE live_events ADD COLUMN IF NOT EXISTS ticket_price_cents INTEGER NOT NULL DEFAULT 0;
   ALTER TABLE live_events ADD COLUMN IF NOT EXISTS ticket_currency    TEXT    NOT NULL DEFAULT 'USD';
   ALTER TABLE live_events ADD COLUMN IF NOT EXISTS ticket_minutes     INTEGER NOT NULL DEFAULT 1440;
   ALTER TABLE live_events ADD COLUMN IF NOT EXISTS pay_to             TEXT;
+  CREATE INDEX IF NOT EXISTS live_events_kind
+    ON live_events (kind, status, starts_at);
 
   DO $$
   DECLARE stale record;
@@ -511,7 +514,15 @@ export class LiveEvents {
   constructor(private readonly db: Queryable) {}
 
   private async ensure(): Promise<void> {
-    this.ready ??= this.db.query(EVENT_SCHEMA).then(() => undefined);
+    // A failed schema run is not remembered: the next request tries again
+    // rather than answering 500 until the process restarts.
+    this.ready ??= this.db.query(EVENT_SCHEMA).then(
+      () => undefined,
+      (error: unknown) => {
+        this.ready = null;
+        throw error;
+      },
+    );
     await this.ready;
   }