@torrent-tv/proxy 2.89.7 → 2.89.8

package/test/split-a-stretch.test.js

@@ -1,139 +1,139 @@
-/**
- * @file Where a second encoder joins a stretch, and whether it is worth having.
- *
- * Both halves are arithmetic and neither was asked before. The stretch used to
- * be halved, unconditionally:
- *
- *     widestFrom = from + Math.floor(Math.min(room, to - from + 1) / 2)
- *
- * Halving IS the answer when both encoders are fresh and owe the same. It is not
- * when one of them is already partway through a piece, and it never asked the
- * other question at all — whether two encoders under this host's measured
- * contention beat one at full speed.
- *
- * The derivation. A stretch of unmade film runs from `from` to `to`; whoever is
- * already on it stands at `from` and owes `w` before the piece under it exists;
- * a fresh one placed at `x` owes `d` — its start and then a whole piece — and
- * both then work at the rate two encoders leave each other:
- *
- *     the one there closes [from, x-1]:  w + (x - 1 - from) / r   rises with x
- *     the fresh one closes [x, to]:      d + (to - x)     / r     falls with x
- *
- *     x* = (from + to + 1) / 2  +  (d - w) * r / 2
- *
- * The shift is `firstByteWait / (2 * perPiece)` pieces, so it depends on how
- * long a piece takes here: 0.24 of a piece at 4.45x on a 4.2 s grid, but 0.96 at
- * 8.9x and 2.14 at 20x — a whole segment and more on the copy branch, where a
- * piece is short and a start is not. Measuring only the re-encode rate
- * understated it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { planEncoders } from "../services/encode/EncodePlan.js";
-import { CoverageMap } from "../services/encode/CoverageMap.js";
-
-const SEGMENT_SECONDS = 4.2;
-const LAST = 199;
-
-/**
- * One encoder on a long stretch nobody has made, and room for more.
- *
- * @param {{ speedX: number, penalty: number, head?: number, ageMs?: number,
- *   maxRuns?: number }} params
- * @returns {{ actions: object[], run: object }}
- */
-function planFor({ speedX, penalty, head = 0, ageMs = 60_000, maxRuns = 3, runs = null }) {
-  const coverage = new CoverageMap({ segmentCount: LAST + 1 });
-  const run = { from: 0, to: -1, head, speedX, isAlive: true, startedAt: 1_000_000 };
-  const live = runs ?? [run];
-  for (const one of live) {
-    coverage.claim(one, one.from, one.to);
-  }
-  return {
-    run,
-    actions: planEncoders({
-      coverage,
-      // One zone over the whole film, due now, so nothing but the arithmetic of
-      // sharing it decides anything.
-      windows: [{ from: 0, to: LAST, priority: 100, withinSeconds: 0, behind: false }],
-      runs: live,
-      maxRuns,
-      segmentSeconds: SEGMENT_SECONDS,
-      speedX,
-      killCostSec: 0.04,
-      firstByteWaitSec: 0.9,
-      moveCostSec: 0.94,
-      refetchSecPerFilmSecond: 0,
-      // Measured on the addon host: 1.70 at 854x480, 1.98 at 1920x1080. Raised
-      // to the power of how many others there are, so a third costs again.
-      contentionPenaltyFor: (others) => (others <= 0 ? 1 : penalty ** others),
-      now: 1_000_000 + ageMs
-    })
-  };
-}
-
-test("one encoder that reaches everything in time is left to do it alone", () => {
-  // A zone whose deadline GROWS with distance — which is what the map states,
-  // one segment at a time — is comfortably served by one encoder at 4.45x: #199
-  // is due in 835 s and arrives in 189 s. So there is no position to fill and
-  // nothing to split, whatever the budget says.
-  //
-  // Measured rather than assumed: this is what the plan answers, and the test
-  // was written expecting two encoders before it was run.
-  const { actions } = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3 });
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["keep #0..#-1"],
-    "one encoder, its road to the end of the film"
-  );
-});
-
-test("a stretch nobody is on is split at the middle, and the halves bound each other", () => {
-  // Both encoders are fresh, so both owe the same and `d - w` is zero: the
-  // meeting point is the midpoint, which is what halving always said. What is
-  // new is that each one's road ENDS where the next begins, so neither writes
-  // into the other's names.
-  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 2, runs: [] }).actions;
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["start #0..#100", "start #101..#199"],
-    "0..199 halved at 100"
-  );
-});
-
-test("a third encoder halves the widest half that is left", () => {
-  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3, runs: [] }).actions;
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["start #0..#50", "start #51..#100", "start #101..#199"],
-    "the first half is halved again, greedily, widest first"
-  );
-});
-
-test("a stretch of one piece is not split at all", () => {
-  const coverage = new CoverageMap({ segmentCount: 2 });
-  const actions = planEncoders({
-    coverage,
-    windows: [{ from: 0, to: 0, priority: 100, withinSeconds: 0, behind: false }],
-    runs: [],
-    maxRuns: 3,
-    segmentSeconds: SEGMENT_SECONDS,
-    speedX: 8.9,
-    killCostSec: 0.04,
-    firstByteWaitSec: 0.9,
-    moveCostSec: 0.94,
-    refetchSecPerFilmSecond: 0,
-    contentionPenaltyFor: () => 1,
-    now: 1_000_000
-  });
-
-  assert.equal(
-    actions.filter((one) => one.type === "start").length,
-    1,
-    "there is nothing to share"
-  );
-});
+/**
+ * @file Where a second encoder joins a stretch, and whether it is worth having.
+ *
+ * Both halves are arithmetic and neither was asked before. The stretch used to
+ * be halved, unconditionally:
+ *
+ *     widestFrom = from + Math.floor(Math.min(room, to - from + 1) / 2)
+ *
+ * Halving IS the answer when both encoders are fresh and owe the same. It is not
+ * when one of them is already partway through a piece, and it never asked the
+ * other question at all — whether two encoders under this host's measured
+ * contention beat one at full speed.
+ *
+ * The derivation. A stretch of unmade film runs from `from` to `to`; whoever is
+ * already on it stands at `from` and owes `w` before the piece under it exists;
+ * a fresh one placed at `x` owes `d` — its start and then a whole piece — and
+ * both then work at the rate two encoders leave each other:
+ *
+ *     the one there closes [from, x-1]:  w + (x - 1 - from) / r   rises with x
+ *     the fresh one closes [x, to]:      d + (to - x)     / r     falls with x
+ *
+ *     x* = (from + to + 1) / 2  +  (d - w) * r / 2
+ *
+ * The shift is `firstByteWait / (2 * perPiece)` pieces, so it depends on how
+ * long a piece takes here: 0.24 of a piece at 4.45x on a 4.2 s grid, but 0.96 at
+ * 8.9x and 2.14 at 20x — a whole segment and more on the copy branch, where a
+ * piece is short and a start is not. Measuring only the re-encode rate
+ * understated it.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { planEncoders } from "../services/encode/EncodePlan.js";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+
+const SEGMENT_SECONDS = 4.2;
+const LAST = 199;
+
+/**
+ * One encoder on a long stretch nobody has made, and room for more.
+ *
+ * @param {{ speedX: number, penalty: number, head?: number, ageMs?: number,
+ *   maxRuns?: number }} params
+ * @returns {{ actions: object[], run: object }}
+ */
+function planFor({ speedX, penalty, head = 0, ageMs = 60_000, maxRuns = 3, runs = null }) {
+  const coverage = new CoverageMap({ segmentCount: LAST + 1 });
+  const run = { from: 0, to: -1, head, speedX, isAlive: true, startedAt: 1_000_000 };
+  const live = runs ?? [run];
+  for (const one of live) {
+    coverage.claim(one, one.from, one.to);
+  }
+  return {
+    run,
+    actions: planEncoders({
+      coverage,
+      // One zone over the whole film, due now, so nothing but the arithmetic of
+      // sharing it decides anything.
+      windows: [{ from: 0, to: LAST, priority: 100, withinSeconds: 0, behind: false }],
+      runs: live,
+      maxRuns,
+      segmentSeconds: SEGMENT_SECONDS,
+      speedX,
+      killCostSec: 0.04,
+      firstByteWaitSec: 0.9,
+      moveCostSec: 0.94,
+      refetchSecPerFilmSecond: 0,
+      // Measured on the addon host: 1.70 at 854x480, 1.98 at 1920x1080. Raised
+      // to the power of how many others there are, so a third costs again.
+      contentionPenaltyFor: (others) => (others <= 0 ? 1 : penalty ** others),
+      now: 1_000_000 + ageMs
+    })
+  };
+}
+
+test("one encoder that reaches everything in time is left to do it alone", () => {
+  // A zone whose deadline GROWS with distance — which is what the map states,
+  // one segment at a time — is comfortably served by one encoder at 4.45x: #199
+  // is due in 835 s and arrives in 189 s. So there is no position to fill and
+  // nothing to split, whatever the budget says.
+  //
+  // Measured rather than assumed: this is what the plan answers, and the test
+  // was written expecting two encoders before it was run.
+  const { actions } = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3 });
+
+  assert.deepEqual(
+    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
+    ["keep #0..#-1"],
+    "one encoder, its road to the end of the film"
+  );
+});
+
+test("a stretch nobody is on is split at the middle, and the halves bound each other", () => {
+  // Both encoders are fresh, so both owe the same and `d - w` is zero: the
+  // meeting point is the midpoint, which is what halving always said. What is
+  // new is that each one's road ENDS where the next begins, so neither writes
+  // into the other's names.
+  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 2, runs: [] }).actions;
+
+  assert.deepEqual(
+    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
+    ["start #0..#100", "start #101..#199"],
+    "0..199 halved at 100"
+  );
+});
+
+test("a third encoder halves the widest half that is left", () => {
+  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3, runs: [] }).actions;
+
+  assert.deepEqual(
+    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
+    ["start #0..#50", "start #51..#100", "start #101..#199"],
+    "the first half is halved again, greedily, widest first"
+  );
+});
+
+test("a stretch of one piece is not split at all", () => {
+  const coverage = new CoverageMap({ segmentCount: 2 });
+  const actions = planEncoders({
+    coverage,
+    windows: [{ from: 0, to: 0, priority: 100, withinSeconds: 0, behind: false }],
+    runs: [],
+    maxRuns: 3,
+    segmentSeconds: SEGMENT_SECONDS,
+    speedX: 8.9,
+    killCostSec: 0.04,
+    firstByteWaitSec: 0.9,
+    moveCostSec: 0.94,
+    refetchSecPerFilmSecond: 0,
+    contentionPenaltyFor: () => 1,
+    now: 1_000_000
+  });
+
+  assert.equal(
+    actions.filter((one) => one.type === "start").length,
+    1,
+    "there is nothing to share"
+  );
+});

package/test/stale-request-after-seek.test.js

@@ -1,158 +1,158 @@
-/**
- * @file A segment request steers nothing.
- *
- * Field 2026-08-17: the viewer seeked to 2083.4 s, both runs restarted at
- * segment #373, and a request for #371 — issued before the seek and reissued by
- * the player a second later — moved the encoder to #370. The viewer was at
- * #374 and waited for the encoder to come back to them.
- *
- * That was answered first by a guard: a request behind what the viewer had
- * REPORTED was refused, while the same traffic still moved the encoder when
- * nothing had been reported. The guard is gone with the thing it guarded. A
- * request for a file is not a statement about where anybody is, and nothing
- * about it belongs in the decision of where encoders go — that is read from the
- * priority map, which is built from where the viewers are and from nothing else.
- *
- * So the rule pinned here is now the whole rule, and it has no exception: a
- * request moves neither the encoder nor the viewer, whether or not the viewer
- * has said anything.
- */
-
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import test from "node:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-
-const SEGMENT_SECONDS = 4;
-const RUN_STARTS_AT = 373;
-const BEHIND_INDEX = 371;
-const SESSION_ID = "2222222233334444";
-
-/**
- * A live session whose run begins at #373 and whose directory is empty, so any
- * segment request is a request for something not yet produced.
- *
- * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
- */
-async function sessionWithRunAt373() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-request-"));
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const session = {
-    id: SESSION_ID,
-    dirPath,
-    timeline: new Timeline({
-      boundaries: Array.from({ length: 901 }, (_, index) => index * SEGMENT_SECONDS),
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    segmentFormat: fmp4Format,
-    segmentCount: 900,
-    startedAt: Date.now(),
-    lastAccessedAt: Date.now(),
-    runs: new Set(),
-    consumers: new Set(),
-    viewers: new Map(),
-    progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS },
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    lastError: "",
-    waitEpoch: 0
-  };
-  manager.outputs.set(SESSION_ID, session);
-  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true, speedX: 2 });
-  return { manager, session, dirPath };
-}
-
-/**
- * @param {object} manager
- * @param {object} session
- * @param {string} dirPath
- */
-async function tidy(manager, session, dirPath) {
-  if (session.seekSettleTimer) {
-    clearTimeout(session.seekSettleTimer);
-    session.seekSettleTimer = null;
-  }
-  manager.outputs.clear();
-  manager.stop?.();
-  await rm(dirPath, { recursive: true, force: true });
-}
-
-test("a request behind where the viewer said they are does not move the encoder", async (t) => {
-  const { manager, session, dirPath } = await sessionWithRunAt373();
-  t.after(async () => {
-    await tidy(manager, session, dirPath);
-  });
-
-  // The viewer stated their position: 2083.4 s, which is segment #520 here.
-  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
-
-  await manager.serving.getFileStream(
-    SESSION_ID,
-    fmp4Format.segmentFileName(BEHIND_INDEX)
-  );
-
-  // The field log's line was `seek settle → restart at segment #370`. Nothing
-  // aims an encoder from here at all now, so there is no destination for a
-  // stale request to become.
-  assert.equal(
-    session.seekTarget ?? null,
-    null,
-    "a request behind the viewer must not become the encoder's destination"
-  );
-  assert.equal(
-    session.seekSettleTimer ?? null,
-    null,
-    "and it must not arm a restart"
-  );
-});
-
-test("the same traffic moves nothing when the viewer has said nothing either", async (t) => {
-  const { manager, session, dirPath } = await sessionWithRunAt373();
-  t.after(async () => {
-    await tidy(manager, session, dirPath);
-  });
-
-  // THE CONTROL, INVERTED. It used to be that without a reported seek this very
-  // traffic DID move the encoder — the guard applied only to a viewer who had
-  // spoken. That exception is the thing that was removed: a request is evidence
-  // about what a player is reading, never about where a person is, and an
-  // encoder placed from it is placed from a number the player picked.
-  await manager.serving.getFileStream(
-    SESSION_ID,
-    fmp4Format.segmentFileName(BEHIND_INDEX)
-  );
-
-  assert.equal(session.seekTarget ?? null, null);
-  assert.equal(session.seekSettleTimer ?? null, null);
-});
-
-test("a request cannot move the viewer's position backwards", async (t) => {
-  const { manager, session, dirPath } = await sessionWithRunAt373();
-  t.after(async () => {
-    await tidy(manager, session, dirPath);
-  });
-
-  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
-  await manager.serving.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX));
-
-  assert.ok(
-    Math.abs((manager.viewers.get("viewer-1")?.positionSeconds() ?? -1) - 2083.4) < 1,
-    "a stale request must not rewrite what the viewer said about themselves"
-  );
-});
+/**
+ * @file A segment request steers nothing.
+ *
+ * Field 2026-08-17: the viewer seeked to 2083.4 s, both runs restarted at
+ * segment #373, and a request for #371 — issued before the seek and reissued by
+ * the player a second later — moved the encoder to #370. The viewer was at
+ * #374 and waited for the encoder to come back to them.
+ *
+ * That was answered first by a guard: a request behind what the viewer had
+ * REPORTED was refused, while the same traffic still moved the encoder when
+ * nothing had been reported. The guard is gone with the thing it guarded. A
+ * request for a file is not a statement about where anybody is, and nothing
+ * about it belongs in the decision of where encoders go — that is read from the
+ * priority map, which is built from where the viewers are and from nothing else.
+ *
+ * So the rule pinned here is now the whole rule, and it has no exception: a
+ * request moves neither the encoder nor the viewer, whether or not the viewer
+ * has said anything.
+ */
+
+import assert from "node:assert/strict";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import test from "node:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { startRunOn } from "./helpers/encode-run.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+
+const SEGMENT_SECONDS = 4;
+const RUN_STARTS_AT = 373;
+const BEHIND_INDEX = 371;
+const SESSION_ID = "2222222233334444";
+
+/**
+ * A live session whose run begins at #373 and whose directory is empty, so any
+ * segment request is a request for something not yet produced.
+ *
+ * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
+ */
+async function sessionWithRunAt373() {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-request-"));
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const session = {
+    id: SESSION_ID,
+    dirPath,
+    timeline: new Timeline({
+      boundaries: Array.from({ length: 901 }, (_, index) => index * SEGMENT_SECONDS),
+      cutGrid: "uniform"
+    }),
+    state: "ready",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
+    segmentFormat: fmp4Format,
+    segmentCount: 900,
+    startedAt: Date.now(),
+    lastAccessedAt: Date.now(),
+    runs: new Set(),
+    consumers: new Set(),
+    viewers: new Map(),
+    progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS },
+    useSyntheticPlaylist: true,
+    playlistText: "#EXTM3U\n",
+    lastError: "",
+    waitEpoch: 0
+  };
+  manager.outputs.set(SESSION_ID, session);
+  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true, speedX: 2 });
+  return { manager, session, dirPath };
+}
+
+/**
+ * @param {object} manager
+ * @param {object} session
+ * @param {string} dirPath
+ */
+async function tidy(manager, session, dirPath) {
+  if (session.seekSettleTimer) {
+    clearTimeout(session.seekSettleTimer);
+    session.seekSettleTimer = null;
+  }
+  manager.outputs.clear();
+  manager.stop?.();
+  await rm(dirPath, { recursive: true, force: true });
+}
+
+test("a request behind where the viewer said they are does not move the encoder", async (t) => {
+  const { manager, session, dirPath } = await sessionWithRunAt373();
+  t.after(async () => {
+    await tidy(manager, session, dirPath);
+  });
+
+  // The viewer stated their position: 2083.4 s, which is segment #520 here.
+  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
+
+  await manager.serving.getFileStream(
+    SESSION_ID,
+    fmp4Format.segmentFileName(BEHIND_INDEX)
+  );
+
+  // The field log's line was `seek settle → restart at segment #370`. Nothing
+  // aims an encoder from here at all now, so there is no destination for a
+  // stale request to become.
+  assert.equal(
+    session.seekTarget ?? null,
+    null,
+    "a request behind the viewer must not become the encoder's destination"
+  );
+  assert.equal(
+    session.seekSettleTimer ?? null,
+    null,
+    "and it must not arm a restart"
+  );
+});
+
+test("the same traffic moves nothing when the viewer has said nothing either", async (t) => {
+  const { manager, session, dirPath } = await sessionWithRunAt373();
+  t.after(async () => {
+    await tidy(manager, session, dirPath);
+  });
+
+  // THE CONTROL, INVERTED. It used to be that without a reported seek this very
+  // traffic DID move the encoder — the guard applied only to a viewer who had
+  // spoken. That exception is the thing that was removed: a request is evidence
+  // about what a player is reading, never about where a person is, and an
+  // encoder placed from it is placed from a number the player picked.
+  await manager.serving.getFileStream(
+    SESSION_ID,
+    fmp4Format.segmentFileName(BEHIND_INDEX)
+  );
+
+  assert.equal(session.seekTarget ?? null, null);
+  assert.equal(session.seekSettleTimer ?? null, null);
+});
+
+test("a request cannot move the viewer's position backwards", async (t) => {
+  const { manager, session, dirPath } = await sessionWithRunAt373();
+  t.after(async () => {
+    await tidy(manager, session, dirPath);
+  });
+
+  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
+  await manager.serving.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX));
+
+  assert.ok(
+    Math.abs((manager.viewers.get("viewer-1")?.positionSeconds() ?? -1) - 2083.4) < 1,
+    "a stale request must not rewrite what the viewer said about themselves"
+  );
+});