@torrent-tv/proxy 2.89.3 → 2.89.5

package/test/piece-completeness.test.js

@@ -0,0 +1,42 @@
+/**
+ * @file Whether a closed piece holds the whole of its stretch of film.
+ *
+ * Decided by the encoding from the cut table and the piece's own media; the
+ * segment store only keeps what it is given.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { cutOf, judgePiece } from "../services/encode/piece-completeness.js";
+import { SEGMENT_CUT_TIME_DELTA_SECONDS } from "../services/encode/output/index.js";
+
+/** Media ending where stated, in the shape a format's reading has. */
+const endingAt = (seconds) => ({ end: seconds });
+const format = { producedThroughSeconds: (ranges) => ranges?.end ?? null };
+
+/** Cuts every ten seconds, ten pieces. */
+const timeline = { segmentCount: 10, publishedStartOf: (index) => index * 10 };
+
+test("a piece must reach its next cut less the delta the muxer is given", () => {
+  assert.equal(cutOf(timeline, 3), 40 - SEGMENT_CUT_TIME_DELTA_SECONDS);
+});
+
+test("the final piece has no next cut", () => {
+  assert.equal(cutOf(timeline, 9), undefined);
+  assert.deepEqual(judgePiece(format, endingAt(95), cutOf(timeline, 9)), { whole: true, throughSeconds: 95 });
+});
+
+test("an audio piece ending within the delta of its cut is whole", () => {
+  // Field 2026-10-01: AAC frames end 4.7389 s into a piece cut at 4.755 s.
+  const cut = 4.755 - SEGMENT_CUT_TIME_DELTA_SECONDS;
+  assert.equal(judgePiece(format, endingAt(4.738913832199547), cut).whole, true);
+});
+
+test("a piece closed short of its cut is not whole", () => {
+  // A run killed mid-piece: 84 ms of film where ten seconds were cut.
+  assert.deepEqual(judgePiece(format, endingAt(456.084), 466), { whole: false, throughSeconds: 456.084 });
+});
+
+test("a piece with no playable media is not whole, whatever its cut", () => {
+  assert.deepEqual(judgePiece(format, null, undefined), { whole: false, throughSeconds: null });
+});

package/test/quality-offer.test.js

@@ -58,10 +58,8 @@ function offerOver(
     runningEncoders: () => 0,
     encodersRunningNow: () => 0,
     torrentCostSecFor: () => 0,
-    boundBy: async () => "cpu",
     runsFor: (session) => [...(session.runs ?? [])],
-    stateFor: (session) => runStateOf(session.runs),
-    progressFor: (session) => session.progress ?? null
+    stateFor: (session) => runStateOf(session.runs)
   });
   let computed = 0;
   const real = cost.sustainableHeights.bind(cost);

package/test/quality-variants.test.js

@@ -131,7 +131,7 @@ function fakeSession({
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     segmentCount: 100,
-    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
+    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0 }
   };
 }
 

package/test/run-progress.test.js

@@ -16,7 +16,7 @@ test("a run rebases ffmpeg's relative clock onto its own source position", () =>
   let now = 10;
   const progress = new RunProgress({ startSeconds: 600, totalSeconds: 1000, now: () => now });
   now = 20;
-  progress.note({ processedSeconds: 12.5, speed: "2.0x" });
+  progress.note({ processedSeconds: 12.5 });
 
   assert.deepEqual(progress.snapshot(), {
     processedSeconds: 612.5,
@@ -24,7 +24,6 @@ test("a run rebases ffmpeg's relative clock onto its own source position", () =>
     totalSeconds: 1000,
     percent: 3.125,
     remainingSeconds: 387.5,
-    speed: "2.0x",
     updatedAt: 20
   });
 });
@@ -33,7 +32,7 @@ test("two runs of one output retain separate clocks", () => {
   const made = orchestrator();
   const first = { from: 0, to: 49, isAlive: true, progress: new RunProgress({ startSeconds: 0 }) };
   const second = { from: 50, to: 99, isAlive: true, progress: new RunProgress({ startSeconds: 200 }) };
-  first.progress.note({ processedSeconds: 40, speed: "1.0x" });
+  first.progress.note({ processedSeconds: 40 });
   second.progress.note({ processedSeconds: 8, speed: "2.0x" });
   made.adopt("picture", first);
   made.adopt("picture", second);

package/test/same-height-switch.test.js

@@ -65,7 +65,6 @@ import { SourceFile } from "../services/media/SourceFile.js";
 import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 import { outputSpec } from "./helpers/output-spec.js";
 import { maxrateKbpsFor, nominalKbpsFor, softwareRateControlFor } from "../services/encode/args.js";
-import { LINK_SAFETY } from "../services/encode/quality/link-budget.js";
 
 const BASE_ID = "1111111122223333";
 const SEGMENT_SECONDS = 4;
@@ -86,7 +85,7 @@ const AUDIO_MBPS = 0.128;
  * @returns {number}
  */
 function linkJustFor(limit) {
-  return (maxrateKbpsFor(limit) / 1000 + AUDIO_MBPS + 0.01) / LINK_SAFETY;
+  return maxrateKbpsFor(limit) / 1000 + AUDIO_MBPS + 0.01;
 }
 
 /**

package/test/segment-closed-on-both-branches.test.js

@@ -1,96 +1,114 @@
-/**
- * @file A piece is closed by one of two writers, and both must say so.
- *
- * The `segment` muxer writes under a working name and reports the closure on a
- * channel of its own, which reaches `SegmentStore.publish`. The `hls` muxer
- * writes through a temporary name of its own (`+temp_file`) and reports
- * nothing: the file simply appears under the name it is served as. That branch
- * is taken by every re-encoded output cut on the even grid — an ordinary
- * quality step — and for it a wait could only end on its deadline, so a segment
- * lying finished on disk was answered 503 after the whole hold.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-
-const KEY = "torrent:abc:fmt=fmp4:grid=uniform@0:video-only:v=libx264/854x480";
-
-/** A deadline is the backstop of these waits, never what they measure. */
-const BACKSTOP_MS = 10_000;
-
-/**
- * @returns {{ store: SegmentStore, root: string }}
- */
-function storeInATempRoot() {
-  const root = mkdtempSync(path.join(os.tmpdir(), "segment-closed-"));
-  const store = new SegmentStore({ root, logger: { info: () => {}, warn: () => {} } });
-  store.useFormat(KEY, fmp4Format);
-  return { store, root };
-}
-
-test("a piece that simply appears ends the wait that began before it", async (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => {
-    store.dropAll("the test is over");
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  const dir = store.directoryFor(KEY);
-  // The wait begins on a segment nobody has written yet — the cold case, and
-  // the only one the deadline used to decide.
-  const waited = store.waitFor(KEY, 7, BACKSTOP_MS);
-
-  // What the `hls` muxer does: a temporary name of its own, renamed into place
-  // when the piece is whole. Nothing is told; the directory simply moves.
-  const temp = path.join(dir, "segment-00007.mp4.tmp");
-  writeFileSync(temp, Buffer.alloc(64));
-  renameSync(temp, path.join(dir, fmp4Format.segmentFileName(7)));
-
-  assert.equal(await waited, true, "the piece was on disk and the wait did not end");
-  assert.ok(store.pathOf(KEY, 7), "and the store must be able to hand it over");
-});
-
-test("clearing up after a run is not its pieces arriving", async (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => {
-    store.dropAll("the test is over");
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  const dir = store.directoryFor(KEY);
-  const unfinished = path.join(dir, fmp4Format.makingFileNameTemplate("3").replace("%05d", "00009"));
-  writeFileSync(unfinished, Buffer.alloc(64));
-
-  let ended = false;
-  // 200 ms is a grace before asserting that something did NOT happen, which can
-  // only ever pass too easily — never a measurement.
-  const waited = store.waitFor(KEY, 9, 200).then((value) => {
-    ended = value;
-    return value;
-  });
-  rmSync(unfinished, { force: true });
-
-  assert.equal(await waited, false, "a directory that moved because a file went holds nothing new");
-  assert.equal(ended, false);
-});
-
-test("the writer that does report a closure is unaffected", async (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => {
-    store.dropAll("the test is over");
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  const dir = store.directoryFor(KEY);
-  const making = fmp4Format.makingFileNameTemplate("4").replace("%05d", "00004");
-  writeFileSync(path.join(dir, making), Buffer.alloc(64));
-
-  const waited = store.waitFor(KEY, 4, BACKSTOP_MS);
-  assert.equal(store.publish(KEY, making, fmp4Format), fmp4Format.segmentFileName(4));
-  assert.equal(await waited, true);
-});
+/**
+ * @file A piece is closed by one of two writers, and both must say so.
+ *
+ * The `segment` muxer writes under a working name and reports the closure on a
+ * channel of its own, which reaches `SegmentStore.publish`. The `hls` muxer
+ * writes through a temporary name of its own (`+temp_file`) and reports
+ * nothing: the file simply appears under the name it is served as. That branch
+ * is taken by every re-encoded output cut on the even grid — an ordinary
+ * quality step — and for it a wait could only end on its deadline, so a segment
+ * lying finished on disk was answered 503 after the whole hold.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+
+const KEY = "torrent:abc:fmt=fmp4:grid=uniform@0:video-only:v=libx264/854x480";
+
+/** A deadline is the backstop of these waits, never what they measure. */
+const BACKSTOP_MS = 10_000;
+
+/**
+ * @returns {{ store: SegmentStore, root: string }}
+ */
+function storeInATempRoot() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "segment-closed-"));
+  const store = new SegmentStore({ root, logger: { info: () => {}, warn: () => {} } });
+  store.useFormat(KEY, fmp4Format);
+  return { store, root };
+}
+
+test("a piece that simply appears ends the wait that began before it", async (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => {
+    store.dropAll("the test is over");
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  const dir = store.directoryFor(KEY);
+  // The wait begins on a segment nobody has written yet — the cold case, and
+  // the only one the deadline used to decide.
+  const waited = store.waitFor(KEY, 7, BACKSTOP_MS);
+
+  // What the `hls` muxer does: a temporary name of its own, renamed into place
+  // when the piece is whole. Nothing is told; the directory simply moves.
+  const temp = path.join(dir, "segment-00007.mp4.tmp");
+  writeFileSync(temp, Buffer.alloc(64));
+  renameSync(temp, path.join(dir, fmp4Format.segmentFileName(7)));
+
+  assert.equal(await waited, true, "the piece was on disk and the wait did not end");
+  assert.ok(store.pathOf(KEY, 7), "and the store must be able to hand it over");
+});
+
+test("clearing up after a run is not its pieces arriving", async (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => {
+    store.dropAll("the test is over");
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  const dir = store.directoryFor(KEY);
+  const unfinished = path.join(dir, fmp4Format.makingFileNameTemplate("3").replace("%05d", "00009"));
+  writeFileSync(unfinished, Buffer.alloc(64));
+
+  let ended = false;
+  // 200 ms is a grace before asserting that something did NOT happen, which can
+  // only ever pass too easily — never a measurement.
+  const waited = store.waitFor(KEY, 9, 200).then((value) => {
+    ended = value;
+    return value;
+  });
+  rmSync(unfinished, { force: true });
+
+  assert.equal(await waited, false, "a directory that moved because a file went holds nothing new");
+  assert.equal(ended, false);
+});
+
+test("the writer that does report a closure is unaffected", async (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => {
+    store.dropAll("the test is over");
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  const dir = store.directoryFor(KEY);
+  const making = fmp4Format.makingFileNameTemplate("4").replace("%05d", "00004");
+  writeFileSync(path.join(dir, making), Buffer.alloc(64));
+
+  const waited = store.waitFor(KEY, 4, BACKSTOP_MS);
+  assert.equal(store.publish(KEY, making, fmp4Format), fmp4Format.segmentFileName(4));
+  assert.equal(await waited, true);
+});
+
+test("a directory removed from outside and made again is watched again", async (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => {
+    store.dropAll("the test is over");
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  // Removed by something other than the store, so its watch was not stopped
+  // first. The watch held on that path watches a directory that is gone.
+  rmSync(store.directoryFor(KEY), { recursive: true, force: true });
+  const dir = store.directoryFor(KEY);
+  const waited = store.waitFor(KEY, 3, BACKSTOP_MS);
+
+  writeFileSync(path.join(dir, fmp4Format.segmentFileName(3)), Buffer.alloc(64));
+
+  assert.equal(await waited, true, "the piece arrived in the new directory and the wait did not end");
+});

package/test/segment-store.test.js

@@ -10,7 +10,6 @@ import os from "node:os";
 import path from "node:path";
 import { directoryNameFor, SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
 import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { SEGMENT_CUT_TIME_DELTA_SECONDS } from "../services/encode/output/index.js";
 
 /**
  * @returns {{ store: SegmentStore, root: string, lines: string[] }}
@@ -36,32 +35,33 @@ function writeSegment(dir, index, bytes = 16) {
 
 const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
 
-test("a complete audio cut within the configured muxer delta remains usable", (t) => {
+test("a published piece keeps the media intervals the encoding read from it", (t) => {
+  // The store does not judge a piece; whether it is whole is the encoding's
+  // decision (`encode/piece-completeness.js`), taken before it is published.
   const { store, root } = storeInATempRoot();
   t.after(() => { store.dropAll("the check is over"); rmSync(root, { recursive: true, force: true }); });
-  const format = { ...fmp4Format, readMediaRanges: () => [{ start: 0, end: 4.738913832199547 }],
-    producedThroughSeconds: (ranges) => ranges.at(-1).end };
+  const format = { ...fmp4Format, readMediaRanges: () => assert.fail("the store does not read a piece it was handed") };
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, format);
-  const endSeconds = 4.755 - SEGMENT_CUT_TIME_DELTA_SECONDS;
-  writeFileSync(path.join(dir, "making-0-00000.mp4"), Buffer.alloc(16));
-  assert.equal(store.publish(KEY, "making-0-00000.mp4", format, { endSeconds }), "segment-00000.mp4");
-  assert.ok(store.mediaRangesOf(KEY, 0, { endSeconds }));
+  writeFileSync(path.join(dir, "making-0-00000.mp4"), Buffer.from("closed"));
+  assert.deepEqual(store.closedBytesOf(KEY, "making-0-00000.mp4"), Buffer.from("closed"));
+  const mediaRanges = { tracks: [] };
+  assert.equal(store.publish(KEY, "making-0-00000.mp4", format, { mediaRanges }), "segment-00000.mp4");
+  assert.equal(store.mediaRangesOf(KEY, 0), mediaRanges);
 });
 
-test("a closed but truncated non-final piece is not published or reused", (t) => {
-  const { store, root } = storeInATempRoot();
+test("a stored piece is taken off the disk at its owner's word", (t) => {
+  const { store, root, lines } = storeInATempRoot();
   t.after(() => { store.dropAll("the check is over"); rmSync(root, { recursive: true, force: true }); });
-  const format = { ...fmp4Format, readMediaRanges: () => [{ start: 456, end: 456.084 }],
-    producedThroughSeconds: (ranges) => ranges.at(-1).end };
+  const format = { ...fmp4Format, readMediaRanges: () => ({ tracks: [] }) };
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, format);
-  writeFileSync(path.join(dir, "making-0-00071.mp4"), Buffer.alloc(16));
-  assert.equal(store.publish(KEY, "making-0-00071.mp4", format, { endSeconds: 466 }), null);
   writeSegment(dir, 71);
   assert.ok(store.mediaRangesOf(KEY, 71));
-  assert.equal(store.mediaRangesOf(KEY, 71, { endSeconds: 466 }), undefined);
+  store.remove(KEY, 71, "short of its cut");
   assert.equal(store.pathOf(KEY, 71), null);
+  assert.equal(store.mediaRangesOf(KEY, 71), undefined);
+  assert.ok(lines.some((line) => line.includes("segment 71") && line.includes("short of its cut")));
 });
 
 test("two viewers of one output are given the same directory", (t) => {

package/test/stream-route.test.js

@@ -207,3 +207,31 @@ test("a file this proxy does not have whole still goes to the torrent", async ()
   await handleStreamGet(req, reply, deps);
   assert.equal(state.prioritized.length, 1, "the ordinary path was not taken");
 });
+
+test("every wait of an encoder's input read is marked for the run its URL names", async () => {
+  // The run's processing speed is read over its own working time; the time its
+  // input waits for the swarm is what this marks (RunClock).
+  const { req, reply, deps } = harness({ method: "GET", range: "bytes=0-5" });
+  const { files: [file] } = await deps.torrentPool.getTorrent();
+  const pieces = [Buffer.from("abc"), Buffer.from("def")];
+  file.createFragmentReader = () => ({
+    cancel() {},
+    async *[Symbol.asyncIterator]() {
+      for (const bytes of pieces) {
+        yield { bytes, release() {} };
+      }
+    }
+  });
+  reply.raw.write = (_bytes, done) => done();
+  reply.raw.writableEnded = false;
+  reply.raw.destroyed = false;
+  req.query.session = "output-1";
+  req.query.run = "7";
+  const marks = [];
+  deps.noteInputWaiting = (runToken, waiting) => marks.push([runToken, waiting]);
+
+  await handleStreamGet(req, reply, deps);
+
+  assert.deepEqual(marks, [[7, true], [7, false], [7, true], [7, false], [7, true], [7, false]],
+    "a wait before each fragment and one before the end, each closed");
+});

package/test/supply-margin.test.js

@@ -175,3 +175,16 @@ test("a term with nothing observed contributes nothing", () => {
   assert.equal(minimumBufferFrom({}), null, "without a segment duration nothing can be said");
   assert.equal(minimumBufferFrom({ segmentSeconds: 0 }), null);
 });
+
+test("a supply that delivered for a sliver of the time asks for what it measured, uncut", () => {
+  // Two stalls of 99.9 s with 0.1 s of delivery between them: the share lost is
+  // 0.999, and the speed asked for is a thousand times realtime. A cap at a
+  // chosen 0.99 used to report a hundred.
+  const answer = requiredSpeedFrom([
+    { waitedMs: 99_900, at: 99_900 },
+    { waitedMs: 99_900, at: 199_900 }
+  ]);
+  assert.ok(answer);
+  assert.ok(Math.abs(answer.lostShare - 0.999) < 1e-9, `got ${answer.lostShare}`);
+  assert.ok(Math.abs(answer.requiredSpeed - 1000) < 1e-6, `got ${answer.requiredSpeed}`);
+});

package/test/two-viewers-one-picture.test.js

@@ -132,7 +132,7 @@ function fakeSession({
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     segmentCount: 100,
-    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
+    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0 }
   };
 }
 

package/test/viewer-outputs.test.js

@@ -98,7 +98,7 @@ function fakeSession({ id, dirPath, file, encodeHeight = 0, audioOnly = false, i
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     segmentCount: 100,
-    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
+    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0 }
   };
 }