@torrent-tv/proxy 2.56.0 → 2.57.1

package/services/subtitle-defaults.js

@@ -95,7 +95,20 @@ export function mergeContainerSubtitleFlags(bannerTracks, declared) {
   const banner = Array.isArray(bannerTracks) ? bannerTracks : [];
   const container = Array.isArray(declared) ? declared : [];
   const undecided = () => ({
-    tracks: banner.map((track) => ({ ...track, declaresDefault: false }))
+    // The container reading could not be lined up, so nothing of it is used —
+    // including the flags, which would otherwise be attributed to the wrong
+    // track.
+    tracks: banner.map((track) => ({
+      ...track,
+      declaresDefault: false,
+      isForced: false,
+      isHearingImpaired: false,
+      // Not "the container says this track is unusable" — nothing of the
+      // container is being used here. A track is offered unless it was read to
+      // say otherwise.
+      isEnabled: true,
+      languageBcp47: ""
+    }))
   });
   if (container.length === 0) {
     return { ...undecided(), aligned: false, reason: "the container declares no subtitle track" };
@@ -123,7 +136,20 @@ export function mergeContainerSubtitleFlags(bannerTracks, declared) {
     tracks: banner.map((track, order) => ({
       ...track,
       isDefault: container[order].isDefault === true,
-      declaresDefault: container[order].declaresDefault === true
+      declaresDefault: container[order].declaresDefault === true,
+      // Read from the file rather than guessed from the track's name. Both are
+      // stated by the container itself (RFC 9559 §5.1.4.1) and neither reaches
+      // ffmpeg's `-i` banner, which is where every other field here comes from.
+      isForced: container[order].isForced === true,
+      isHearingImpaired: container[order].isHearingImpaired === true,
+      // FlagEnabled, so the browser can leave an unusable track out of the
+      // menu. It stays in this list and keeps its number: ffmpeg creates a
+      // stream for it either way.
+      isEnabled: container[order].isEnabled !== false,
+      // The RFC 5646 tag, where the file writes one. Kept beside the code
+      // rather than replacing it: what this list is aligned against is ffmpeg's
+      // banner, which prints the three-letter form.
+      languageBcp47: typeof container[order].languageBcp47 === "string" ? container[order].languageBcp47 : ""
     })),
     aligned: true,
     reason: ""

package/test/delivery-probe.test.js

@@ -1,78 +1,158 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { readProbeState, MISSES_FOR_VERDICT, UNRELIABLE_LABEL } from "../services/delivery-probe.js";
-
-const ORDERED = ["proxy", "proxy-control"];
-const ALL = [...ORDERED, UNRELIABLE_LABEL];
-
-/**
- * @param {Record<string, number>} seen
- * @param {object} [overrides]
- */
-function state(seen, overrides = {}) {
-  return {
-    seq: 100,
-    seen,
-    labels: ALL,
-    echoes: 5,
-    echoAgeMs: 400,
-    ...overrides
-  };
-}
-
-test("every channel current reads as flowing", () => {
-  const { verdict } = readProbeState(state({ proxy: 100, "proxy-control": 99, "proxy-fast": 100 }));
-  assert.equal(verdict, "flowing");
-});
-
-test("a lag shorter than the verdict window is still flowing", () => {
-  const behind = 100 - (MISSES_FOR_VERDICT - 1);
-  const { verdict } = readProbeState(
-    state({ proxy: behind, "proxy-control": behind, "proxy-fast": 100 })
-  );
-  assert.equal(verdict, "flowing");
-});
-
-test("ordered channels behind while the unordered one keeps up names a stuck stream", () => {
-  const { verdict, detail } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 100 })
-  );
-  assert.equal(verdict, "stream-stuck");
-  // The numbers that produced the verdict must be in the line beside it.
-  assert.match(detail, /proxy=40\(gap 60\)/);
-});
-
-test("every channel behind names the association", () => {
-  const { verdict } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 42 })
-  );
-  assert.equal(verdict, "association-stopped");
-});
-
-test("without the unordered channel the verdict says it cannot compare", () => {
-  const { verdict } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41 }, { labels: ORDERED })
-  );
-  assert.equal(verdict, "ordered-behind-no-comparison");
-});
-
-test("a stale echo means the reverse direction went too", () => {
-  const { verdict } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 42 }, { echoAgeMs: 30_000 })
-  );
-  assert.equal(verdict, "reverse-direction-gone");
-});
-
-test("before the first echo nothing is claimed", () => {
-  const { verdict } = readProbeState(state({}, { echoes: 0, echoAgeMs: null }));
-  assert.equal(verdict, "no-echo-yet");
-});
-
-test("a channel that has never reported counts as behind, not as unknown", () => {
-  const { verdict, detail } = readProbeState(
-    state({ "proxy-fast": 100 })
-  );
-  assert.equal(verdict, "stream-stuck");
-  assert.match(detail, /proxy=\?\(gap \?\)/);
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { allowedGap, readProbeState, PROBE_INTERVAL_MS, UNRELIABLE_LABEL } from "../services/delivery-probe.js";
+
+const ORDERED = ["proxy", "proxy-control"];
+const ALL = [...ORDERED, UNRELIABLE_LABEL];
+
+/**
+ * @param {Record<string, number>} seen
+ * @param {object} [overrides]
+ */
+function state(seen, overrides = {}) {
+  const allowed = {};
+  for (const label of overrides.labels ?? ALL) {
+    allowed[label] = 3;
+  }
+  return {
+    seq: 100,
+    seen,
+    labels: ALL,
+    echoes: 5,
+    echoAgeMs: 400,
+    allowed,
+    ...overrides
+  };
+}
+
+test("every channel current reads as flowing", () => {
+  const { verdict } = readProbeState(state({ proxy: 100, "proxy-control": 99, "proxy-fast": 100 }));
+  assert.equal(verdict, "flowing");
+});
+
+test("a lag shorter than the verdict window is still flowing", () => {
+  const behind = 100 - 3;
+  const { verdict } = readProbeState(
+    state({ proxy: behind, "proxy-control": behind, "proxy-fast": 100 })
+  );
+  assert.equal(verdict, "flowing");
+});
+
+test("ordered channels behind while the unordered one keeps up names a stuck stream", () => {
+  const { verdict, detail } = readProbeState(
+    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 100 })
+  );
+  assert.equal(verdict, "stream-stuck");
+  // The numbers that produced the verdict must be in the line beside it.
+  assert.match(detail, /proxy=40\(gap 60 of 3\)/);
+});
+
+test("every channel behind names the association", () => {
+  const { verdict } = readProbeState(
+    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 42 })
+  );
+  assert.equal(verdict, "association-stopped");
+});
+
+test("without the unordered channel the verdict says it cannot compare", () => {
+  const { verdict } = readProbeState(
+    state({ proxy: 40, "proxy-control": 41 }, { labels: ORDERED })
+  );
+  assert.equal(verdict, "ordered-behind-no-comparison");
+});
+
+test("a stale echo means the reverse direction went too", () => {
+  const { verdict } = readProbeState(
+    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 42 }, { echoAgeMs: 30_000 })
+  );
+  assert.equal(verdict, "reverse-direction-gone");
+});
+
+test("before the first echo nothing is claimed", () => {
+  const { verdict } = readProbeState(state({}, { echoes: 0, echoAgeMs: null }));
+  assert.equal(verdict, "no-echo-yet");
+});
+
+test("a channel that has never reported counts as behind, not as unknown", () => {
+  const { verdict, detail } = readProbeState(
+    state({ "proxy-fast": 100 })
+  );
+  assert.equal(verdict, "stream-stuck");
+  assert.match(detail, /proxy=\?\(gap \? of 3\)/);
+});
+
+test("the allowance is the queue's own drain time, not a chosen number", () => {
+  // 8 MB queued at 8 MB/s is one second of draining; probes go twice a second,
+  // so two of them may legitimately be outstanding, plus the round trip.
+  assert.equal(
+    allowedGap({ queuedBytes: 8 * 1024 * 1024, bytesPerSecond: 8 * 1024 * 1024, rttMs: 0 }),
+    Math.ceil(1000 / PROBE_INTERVAL_MS)
+  );
+  // An empty queue still allows the one probe that is always in flight.
+  assert.equal(allowedGap({ queuedBytes: 0, bytesPerSecond: 8 * 1024 * 1024, rttMs: 0 }), 1);
+  // The round trip counts: the echo has to come back too.
+  assert.ok(
+    allowedGap({ queuedBytes: 0, bytesPerSecond: 1024, rttMs: 2000 }) >
+      allowedGap({ queuedBytes: 0, bytesPerSecond: 1024, rttMs: 0 })
+  );
+});
+
+test("with no rate measured nothing is claimed", () => {
+  assert.equal(allowedGap({ queuedBytes: 1024, bytesPerSecond: 0, rttMs: 10 }), null);
+  const { verdict } = readProbeState(
+    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 42 }, { allowed: {} })
+  );
+  assert.equal(verdict, "no-rate-yet");
+});
+
+test("a burst big enough to explain the lag is not called a stopped association", () => {
+  // The 2026-08-26 false positive: all three channels at gap 7 while 150 Mbps
+  // crossed the association. 64 MB queued at 18 MB/s is three and a half
+  // seconds of draining, which is seven probe intervals.
+  const allowance = allowedGap({
+    queuedBytes: 64 * 1024 * 1024,
+    bytesPerSecond: 18 * 1024 * 1024,
+    rttMs: 16
+  });
+  assert.ok(allowance >= 7);
+  const allowed = Object.fromEntries(ALL.map((label) => [label, allowance]));
+  const { verdict } = readProbeState(
+    state({ proxy: 93, "proxy-control": 93, "proxy-fast": 93 }, { allowed })
+  );
+  assert.equal(verdict, "flowing");
+});
+
+test("the peer's own answering cadence counts toward the allowance", () => {
+  // Field case 2026-08-27: queues empty, 3.4 MB/s crossing, tab hidden so the
+  // browser echoed about once a second. Without the peer's cadence the
+  // allowance is one probe and every other line read `association-stopped`.
+  const withoutCadence = allowedGap({
+    queuedBytes: 0,
+    bytesPerSecond: 3.4 * 1024 * 1024,
+    rttMs: 9
+  });
+  assert.equal(withoutCadence, 1);
+  const withCadence = allowedGap({
+    queuedBytes: 0,
+    bytesPerSecond: 3.4 * 1024 * 1024,
+    rttMs: 9,
+    echoIntervalMs: 1000
+  });
+  assert.ok(withCadence >= 3, `a second of cadence must allow more than ${withCadence}`);
+  const allowed = Object.fromEntries(ALL.map((label) => [label, withCadence]));
+  const { verdict } = readProbeState(
+    state({ proxy: 98, "proxy-control": 98, "proxy-fast": 98 }, { allowed, echoAgeMs: 977 })
+  );
+  assert.equal(verdict, "flowing");
+});
+
+test("a stale echo is judged against the peer's cadence, not a fixed half second", () => {
+  // The same numbers with the cadence unknown must still be able to say the
+  // reverse direction is gone — the bound rises with the cadence, it does not
+  // disappear.
+  const { verdict } = readProbeState(
+    state({ proxy: 99, "proxy-control": 99, "proxy-fast": 99 }, { echoAgeMs: 60_000, echoStaleMs: 2000 })
+  );
+  assert.equal(verdict, "reverse-direction-gone");
+});

package/test/packet-witness-ring.test.js

@@ -0,0 +1,236 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  adoptOrphanRingFiles,
+  createPacketWitness,
+  WITNESS_RING_BASENAME
+} from "../services/packet-witness.js";
+
+/**
+ * A stand-in for a spawned tcpdump: it records how it was called and stays
+ * "running" until something kills it.
+ */
+class FakeChild extends EventEmitter {
+  constructor(command, args) {
+    super();
+    this.command = command;
+    this.args = args;
+    this.killed = false;
+    this.signals = [];
+  }
+
+  kill(signal) {
+    this.signals.push(signal);
+    if (!this.killed) {
+      this.killed = true;
+      // A real child exits asynchronously, which is what the code must wait for.
+      setImmediate(() => this.emit("close", 0, signal));
+    }
+    return true;
+  }
+}
+
+/**
+ * @returns {{ spawnProcess: Function, children: FakeChild[], rings: FakeChild[] }}
+ */
+function makeSpawn() {
+  const children = [];
+  const spawnProcess = (command, args) => {
+    const child = new FakeChild(command, args);
+    children.push(child);
+    if (args.includes("--version")) {
+      // The availability probe: answer at once, like a present tcpdump.
+      setImmediate(() => child.emit("spawn"));
+    }
+    return child;
+  };
+  return {
+    spawnProcess,
+    children,
+    get rings() {
+      return children.filter((child) => !child.args.includes("--version"));
+    }
+  };
+}
+
+/**
+ * Wait until `check` holds, rather than for a chosen interval.
+ *
+ * A fixed sleep passes alone and fails in a full run — the defect roadmap item
+ * 51 names — and the work here is several awaits deep (probe, stop, readdir,
+ * copy, restart), so its duration is whatever the machine is busy with.
+ *
+ * @param {() => boolean | Promise<boolean>} check
+ * @param {string} what
+ * @returns {Promise<void>}
+ */
+async function waitFor(check, what) {
+  const deadline = Date.now() + 10_000;
+  for (;;) {
+    if (await check()) {
+      return;
+    }
+    if (Date.now() > deadline) {
+      throw new Error(`timed out waiting for ${what}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}
+
+/** Let every already-queued microtask and immediate run. */
+const settle = () => new Promise((resolve) => setTimeout(resolve, 20));
+
+async function withDir(run) {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "witness-ring-"));
+  try {
+    await run(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+test("the ring runs while a channel is open and stops with the last one", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const witness = createPacketWitness({
+      log: () => {},
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+
+    witness.holdRing();
+    witness.holdRing();
+    await waitFor(() => spawn.rings.length === 1, "the ring to start");
+    assert.equal(spawn.rings.length, 1, "a second channel must not start a second ring");
+    assert.equal(spawn.rings[0].killed, false);
+
+    witness.releaseRing();
+    await settle();
+    assert.equal(spawn.rings[0].killed, false, "one channel left still wants the ring");
+
+    witness.releaseRing();
+    await waitFor(() => spawn.rings[0].killed, "the ring to stop");
+  });
+});
+
+test("a channel that opens and closes while the ring is starting leaves nothing running", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const witness = createPacketWitness({
+      log: () => {},
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+    // Release before the availability probe has resolved — the start is still
+    // in flight. Without the second look after the await this leaves a tcpdump
+    // nobody holds and nobody will ever stop.
+    witness.holdRing();
+    witness.releaseRing();
+    await waitFor(
+      () => spawn.rings.every((child) => child.killed),
+      "any ring started mid-flight to be stopped"
+    );
+    const alive = spawn.rings.filter((child) => !child.killed);
+    assert.deepEqual(alive, [], "no ring may outlive the channels that wanted it");
+  });
+});
+
+test("the ring's files are removed once nobody is being served", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const witness = createPacketWitness({
+      log: () => {},
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+    witness.holdRing();
+    await waitFor(() => spawn.rings.length === 1, "the ring to start");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "pcap");
+    witness.releaseRing();
+    await waitFor(async () => (await readdir(dir)).length === 0, "the ring files to be removed");
+  });
+});
+
+test("a wedge keeps the ring's history, and the ring keeps recording afterwards", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const lines = [];
+    const witness = createPacketWitness({
+      log: (message) => lines.push(message),
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+    witness.holdRing();
+    await waitFor(() => spawn.rings.length === 1, "the ring to start");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "before-the-freeze");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}1`), "also-before");
+
+    const started = witness.maybeCapture({
+      sessionId: "68296f7d-0000-0000-0000-000000000000",
+      tag: "68296f7d",
+      label: "proxy",
+      remote: { address: "2001:db8::1", port: 61649 },
+      queuedBytes: 67_372_267,
+      stuckForMs: 4000
+    });
+    assert.equal(started, true);
+    await waitFor(
+      async () => (await readdir(dir)).filter((name) => name.includes(".before")).length === 2,
+      "both ring files to be copied aside"
+    );
+
+    const kept = (await readdir(dir)).filter((name) => name.includes(".before"));
+    assert.equal(kept.length, 2, "both ring files must be kept, not just the finished one");
+    assert.ok(kept.every((name) => name.startsWith("packet-witness.68296f7d.")));
+    // Stopped to flush, then started again: two ring processes over the episode.
+    await waitFor(() => spawn.rings.length >= 2, "the ring to resume after the copy");
+    assert.equal(spawn.rings.at(-1).killed, false);
+    assert.ok(lines.some((line) => line.includes("kept 2 ring file(s)")));
+
+    // End the tail capture: it would otherwise sit out its whole window, and
+    // its timer would hold this process open.
+    for (const child of spawn.children) {
+      child.kill("SIGTERM");
+    }
+    await settle();
+  });
+});
+
+test("dispose stops the ring and clears its files", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const witness = createPacketWitness({
+      log: () => {},
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+    witness.holdRing();
+    await waitFor(() => spawn.rings.length === 1, "the ring to start");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "pcap");
+    await witness.dispose();
+    assert.equal(spawn.rings.at(-1).killed, true);
+    assert.deepEqual(await readdir(dir), []);
+  });
+});
+
+test("ring files left by a killed process are kept, not deleted by the next one", async () => {
+  await withDir(async (dir) => {
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "the seconds before the crash");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}2`), "and these");
+    const adopted = await adoptOrphanRingFiles(dir);
+    assert.equal(adopted.length, 2);
+    const left = await readdir(dir);
+    assert.equal(left.filter((name) => name.startsWith(WITNESS_RING_BASENAME)).length, 0);
+    assert.ok(left.every((name) => name.startsWith("packet-witness.orphan.")));
+  });
+});