@torrent-tv/proxy 2.80.4 → 2.80.6

package/test/segment-demand.test.js

@@ -1,5 +1,15 @@
 /**
- * @file What viewers want of an output, stated once each and read as a union.
+ * @file What is wanted of one output, in its own segment numbers.
+ *
+ * The class held a window per viewer per band and merged them itself. That was
+ * the priority layer's work done a second time in the wrong place, and it
+ * carried the viewer's name as the key of a claim — against the rule that the
+ * encoding and the viewer are not connected at all. The behaviours those checks
+ * pinned (a viewer's own bands, two viewers as a union) are the priority map's
+ * and are checked there.
+ *
+ * What is left is a holder: one map per output, replaced whole, and an empty one
+ * meaning nobody is coming.
  */
 
 import test from "node:test";
@@ -7,76 +17,64 @@ import assert from "node:assert/strict";
 import { SegmentDemand } from "../services/encode/SegmentDemand.js";
 
 const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-const SOUND = "torrent:abc:fmt=fmp4:grid=kf@0:audio-only:a=0/1/copy";
+const SOUND = "torrent:abc:fmt=fmp4:grid=kf@0:audio-only:a=0/0/aac";
 
-test("a viewer restating a window replaces it rather than adding to it", () => {
-  // A player restates its window every few seconds. Accumulated, the demand
-  // would grow to the whole film within a minute.
+test("an output nothing has been said about wants nothing", () => {
   const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 10, statedAt: 1 });
-  demand.state({ claimant: "one", address: PICTURE, from: 30, to: 40, statedAt: 2 });
-  assert.deepEqual(demand.spanOn(PICTURE), { from: 30, to: 40 });
-  assert.equal(demand.stats().windows, 1);
+  assert.deepEqual(demand.mapOn(PICTURE), []);
+  assert.deepEqual(demand.addresses(), []);
 });
 
-test("one viewer states a window per output, and both stand", () => {
+test("a map replaces whatever was wanted before, rather than adding to it", () => {
+  // The map is a statement of what is wanted NOW, built fresh each time from
+  // where the viewers are. Accumulating them would keep serving people who have
+  // moved or gone.
   const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 10, statedAt: 1 });
-  demand.state({ claimant: "one", address: SOUND, from: 0, to: 10, statedAt: 1 });
-  assert.equal(demand.stats().windows, 2);
-  assert.deepEqual(demand.addresses().sort(), [SOUND, PICTURE].sort());
-});
-
-test("two viewers of one output are a union, not a sum", () => {
-  // Two viewers seconds apart want mostly the same segments; counted twice, a
-  // stretch would look twice as wanted as it is.
-  const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 10, to: 14, statedAt: 1 });
-  demand.state({ claimant: "two", address: PICTURE, from: 12, to: 16, statedAt: 1 });
-  assert.deepEqual(demand.wantedOn(PICTURE), [10, 11, 12, 13, 14, 15, 16]);
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.state(PICTURE, [{ from: 500, to: 530, priority: 32, withinSeconds: 0 }]);
+  assert.deepEqual(demand.mapOn(PICTURE), [{ from: 500, to: 530, priority: 32, withinSeconds: 0 }]);
 });
 
-test("two viewers far apart make a span that covers the ground between them", () => {
-  // Not so it is all made — so that a search for a gap considers all of it.
+test("an empty map is a statement, and it is kept as one", () => {
+  // It says nobody is coming anywhere in this output, which is what stops the
+  // encoders on it. Dropped instead of stored, the output would look like one
+  // nothing had ever been said about, and the last map with people in it would
+  // stand as current.
   const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 5, statedAt: 1 });
-  demand.state({ claimant: "two", address: PICTURE, from: 900, to: 905, statedAt: 1 });
-  assert.deepEqual(demand.spanOn(PICTURE), { from: 0, to: 905 });
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.state(PICTURE, []);
+  assert.deepEqual(demand.mapOn(PICTURE), []);
+  assert.deepEqual(demand.addresses(), [PICTURE], "the output is still one that has been spoken about");
 });
 
-test("a viewer who leaves takes every window they stated", () => {
+test("each output holds its own map", () => {
+  // Two outputs of one film are cut independently — 454 pieces against 401 on
+  // the field file — so the same second is a different number in each, and one
+  // map cannot serve both.
   const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 5, statedAt: 1 });
-  demand.state({ claimant: "one", address: SOUND, from: 0, to: 5, statedAt: 1 });
-  demand.state({ claimant: "two", address: PICTURE, from: 0, to: 5, statedAt: 1 });
-  assert.equal(demand.forget("one"), 2);
-  assert.equal(demand.stats().claimants, 1);
-  assert.equal(demand.addresses().length, 1);
-});
-
-test("expiry is carried out here and decided elsewhere", () => {
-  // The register has no clock on purpose: the rule that says how stale is too
-  // stale lives with whoever measures it, and this stays exercisable with
-  // numbers alone.
-  const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 5, statedAt: 1000 });
-  demand.state({ claimant: "two", address: PICTURE, from: 0, to: 5, statedAt: 9000 });
-  const dropped = demand.forgetStatedBefore(5000);
-  assert.equal(dropped.length, 1);
-  assert.equal(dropped[0].claimant, "one");
-  assert.equal(demand.stats().windows, 1);
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.state(SOUND, [{ from: 88, to: 115, priority: 32, withinSeconds: 0 }]);
+  assert.equal(demand.mapOn(PICTURE)[0].from, 100);
+  assert.equal(demand.mapOn(SOUND)[0].from, 88);
+  assert.deepEqual(demand.addresses().sort(), [SOUND, PICTURE].sort());
 });
 
-test("a window that is not a window is refused rather than stored", () => {
+test("an output can be forgotten entirely", () => {
   const demand = new SegmentDemand();
-  assert.equal(demand.state({ claimant: "one", address: PICTURE, from: 5, to: 1, statedAt: 1 }), null);
-  assert.equal(demand.state({ claimant: "", address: PICTURE, from: 0, to: 1, statedAt: 1 }), null);
-  assert.equal(demand.state({ claimant: "one", address: "", from: 0, to: 1, statedAt: 1 }), null);
-  assert.equal(demand.stats().windows, 0);
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.forget(PICTURE);
+  assert.deepEqual(demand.addresses(), []);
 });
 
-test("nothing wanted on an output answers null rather than an empty span", () => {
+test("nothing about a viewer can be stated, because nothing about one is held", () => {
+  // The check that the rule holds by construction: there is no name to pass and
+  // no way to ask about one.
   const demand = new SegmentDemand();
-  assert.equal(demand.spanOn(PICTURE), null);
-  assert.deepEqual(demand.wantedOn(PICTURE), []);
+  assert.equal(typeof (/** @type {any} */ (demand).want), "undefined");
+  assert.equal(typeof (/** @type {any} */ (demand).windowsOn), "undefined");
+  assert.equal(
+    demand.state.length,
+    2,
+    "an address and a map, and nothing else"
+  );
 });

package/test/wedge-certainty.test.js

@@ -65,14 +65,14 @@ test("a tiny queue still waits for one round of probes", () => {
   assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
 });
 
-test("nothing queued is not a wedge however long the counter has been still", () => {
+test("nothing queued is still a wedge when the counter has been flat long enough — the channel queue was 0 on the real wedge while usrsctp held 399 MB", () => {
   const verdict = wedgeIsCertain({
     queuedBytes: 0,
     bytesPerSecond: 16 * MEGABYTE,
     flatForMs: 600_000
   });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, null);
+  assert.equal(verdict.certain, true);
+  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
 });
 
 test("with no rate measured the answer is that nothing can be said", () => {

package/test/flushed-piece.test.js

@@ -1,108 +0,0 @@
-/**
- * @file The piece an encoder writes out on its way to being stopped.
- *
- * `-segment_list pipe:3` was taken as proof that a piece is whole: ffmpeg names
- * a file when it closes it, so a named file is closed. True of the FILE and
- * false of the SPAN. On SIGTERM ffmpeg writes out the piece it had open and
- * names it like any other, so the result is a valid, decodable piece holding
- * film only up to the instant of the stop — under a name whose playlist entry
- * promises the whole span.
- *
- * Field 2026-09-06, one session, both tracks: `segment-00010.mp4` held 3.92 s
- * of its declared 5.589 s (96 frames), and the picture jumped 1.5 s at 1:02;
- * the soundtrack's own stopped run left the same shape at 17.5 s, 2.8 s wide.
- * Judging such a file by whether it decodes answers yes, which is how both
- * reached the viewer.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile, readdir } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { discardOpenPiece } from "../services/encode/open-piece.js";
-
-const format = {
-  isSegmentFileName: (name) => /^segment-\d{5}\.mp4$/.test(name),
-  segmentIndexFromName: (name) => Number(name.slice(8, 13))
-};
-
-/** A run directory holding pieces 0..last, every one of them readable. */
-async function runDirectory(last) {
-  const dir = await mkdtemp(path.join(os.tmpdir(), "flushed-piece-"));
-  for (let index = 0; index <= last; index += 1) {
-    await writeFile(path.join(dir, `segment-${String(index).padStart(5, "0")}.mp4`), Buffer.alloc(64, 7));
-  }
-  return dir;
-}
-
-test("the piece named on the way out goes, though it reads perfectly", async () => {
-  const dir = await runDirectory(10);
-  try {
-    const removed = await discardOpenPiece(
-      dir,
-      format,
-      { from: 0, to: 535 },
-      // Everything decodes. This is the field case exactly: the short piece is
-      // a valid fMP4 and nothing about its contents betrays it.
-      () => true,
-      "segment-00010.mp4"
-    );
-    assert.equal(removed, 10, "the flushed piece was kept because it decodes");
-    const left = await readdir(dir);
-    assert.ok(!left.includes("segment-00010.mp4"));
-    assert.ok(left.includes("segment-00009.mp4"), "a piece closed before the stop was taken too");
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("a run that named nothing on the way out loses no readable piece", async () => {
-  // A run that reached the end of its stretch closed its last file properly.
-  // Removing it would mean encoding it a second time for nothing.
-  const dir = await runDirectory(10);
-  try {
-    const removed = await discardOpenPiece(dir, format, { from: 0, to: 535 }, () => true, null);
-    assert.equal(removed, null);
-    assert.ok((await readdir(dir)).includes("segment-00010.mp4"));
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("a piece that does not read still goes, named or not", async () => {
-  const dir = await runDirectory(10);
-  try {
-    const removed = await discardOpenPiece(dir, format, { from: 0, to: 535 }, () => false, null);
-    assert.equal(removed, 10, "an unreadable last piece survived");
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("only inside the stretch the ended run was given", async () => {
-  // Several runs write into one directory, kept apart by their intervals. The
-  // highest file overall may belong to a run that is still going.
-  const dir = await runDirectory(20);
-  try {
-    const removed = await discardOpenPiece(
-      dir, format, { from: 0, to: 10 }, () => true, "segment-00010.mp4"
-    );
-    assert.equal(removed, 10);
-    assert.ok((await readdir(dir)).includes("segment-00020.mp4"), "another run's piece was taken");
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("a name from another run's stretch takes nothing", async () => {
-  const dir = await runDirectory(20);
-  try {
-    const removed = await discardOpenPiece(
-      dir, format, { from: 0, to: 10 }, () => true, "segment-00020.mp4"
-    );
-    assert.equal(removed, null, "a name outside the stretch removed a piece anyway");
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});