@torrent-tv/proxy 2.80.8 → 2.80.10

package/test/encode-plan-viewers.test.js

@@ -31,7 +31,7 @@ import { EncodeRun } from "../services/encode/EncodeRun.js";
 import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
 import { EncodeOrchestrator } from "../services/orchestrators/EncodeOrchestrator.js";
 import { mapForViewer, mergeMaps, runsOf } from "../services/priority/PriorityMap.js";
-import { contentionPenalty, penaltiesFrom } from "../services/contention.js";
+import { penaltiesFrom } from "../services/encode/contention.js";
 
 // WHAT A SECOND ENCODER COSTS THE FIRST — measured, never a formula.
 //
@@ -41,7 +41,6 @@ import { contentionPenalty, penaltiesFrom } from "../services/contention.js";
 // so nothing here invents a shape: beyond what was measured the reading is held
 // rather than extrapolated.
 const MEASURED_PENALTIES = penaltiesFrom(7.12, [{ others: 1, speed: 4.18 }]);
-const penaltyFor = (others) => contentionPenalty(others, MEASURED_PENALTIES).penalty;
 
 // What a start and a stop cost, measured on the same host: a spawn with its
 // input open is 0.12 s there.
@@ -195,7 +194,7 @@ function assertNoOverlap(made) {
 // ---------------------------------------------------------------- one viewer
 
 test("one viewer playing: one encoder, exactly where they are", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   assert.deepEqual(placements(made), [100], "at their own position, 400s / 4s");
@@ -206,7 +205,7 @@ test("one viewer playing: the encoder keeping up buys no second one", () => {
   // The peak moves forward on its own as they watch, and an encoder that stays
   // in front of it is never late. This is the case that must NOT spend a
   // process, and the one the old head-as-a-barrier rule got wrong.
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   const [run] = made.runsOn(PICTURE);
@@ -223,7 +222,7 @@ test("one viewer playing: the encoder keeping up buys no second one", () => {
 });
 
 test("one viewer seeking far ahead: an encoder is placed there", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(6);
@@ -241,7 +240,7 @@ test("one viewer paused: nothing is late, so no encoder is added", () => {
   // A paused viewer states the whole film at one undifferentiated rank and no
   // time by which any of it must exist. The encoder already working goes on
   // encoding the track; nothing justifies a second process.
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(1);
@@ -280,7 +279,7 @@ test("one viewer paused states no deadline anywhere", () => {
 test("two viewers close together share one encoder", () => {
   // Film both of them want is made once. This is what merging the map is for,
   // and it must survive the deadline being carried alongside the rank.
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 408 });
   made.reconcile();
@@ -293,7 +292,7 @@ test("two viewers close together share one encoder", () => {
 });
 
 test("two viewers far apart get an encoder each", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(6);
@@ -308,7 +307,7 @@ test("two viewers far apart get an encoder each", () => {
 });
 
 test("two viewers: one seeking does not take the other's encoder", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   // A speed has to be measured before a second encoder can be justified: how
@@ -338,7 +337,7 @@ test("two viewers: one seeking does not take the other's encoder", () => {
 });
 
 test("two viewers: one pausing leaves the other served", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 3000 });
   made.reconcile();
@@ -374,7 +373,7 @@ test("two viewers: the one who leaves takes nothing from the one who stays", ()
 // ------------------------------------------------------------- three viewers
 
 test("three viewers far apart get an encoder each when the machine affords it", () => {
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 2000 });
   watches("three", { atSeconds: 3600 });
@@ -397,7 +396,7 @@ test("three viewers, a machine that affords two: the budget binds, not the map",
   // machine can hold. Which two are served follows from the order the work is
   // taken in; what must not happen is a third process on a host that cannot
   // hold it, or two processes writing one number.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 2 });
+  const { made, watches } = orchestrator({ maxRuns: 2 });
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 2000 });
   watches("three", { atSeconds: 3600 });
@@ -413,7 +412,7 @@ test("three viewers, a machine that affords two: the budget binds, not the map",
 });
 
 test("three viewers: one seeks onto another, and the two of them share", () => {
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(6);
@@ -436,7 +435,7 @@ test("three viewers: one seeks onto another, and the two of them share", () => {
 });
 
 test("three viewers: all paused, and no encoder is added for any of them", () => {
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(1);
@@ -457,7 +456,7 @@ test("three viewers: all paused, and no encoder is added for any of them", () =>
 test("the plan is a function of the state: the same state twice gives the same answer", () => {
   // What stops a moving map from becoming a thrash: the decision is arithmetic
   // over the state, so a pass that finds nothing changed changes nothing.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 2000 });
   made.reconcile();
@@ -481,7 +480,7 @@ test("exactly realtime arrives exactly on time, and no second encoder is bought"
   // something quite different — `speed / (1 - speed)` divides by zero here and
   // claims the encoder stays ahead FOR EVER, which is the same answer arrived
   // at by nonsense.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(1);
@@ -525,7 +524,7 @@ test("two viewers arriving together on a cold output get one encoder, then are m
   // would take to reach the second viewer is not a known quantity. Buying a
   // process on that is buying it on no evidence, which is refused; one is placed
   // and the speed it reports is what justifies the next.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 3000 });
   made.reconcile();
@@ -540,7 +539,7 @@ test("two viewers arriving together on a cold output get one encoder, then are m
 });
 
 test("an encoder comfortably faster than realtime is left to do the whole stretch", () => {
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(6);
@@ -556,7 +555,7 @@ test("a swarm that feeds one encoder moves it to whoever is late, rather than se
   // the viewer left — so it is moved to the soonest number that IS due. Without
   // this the viewer who seeked was served by nobody at all: the run kept its
   // road because nothing covered what lay in front of IT.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   const [run] = made.runsOn(PICTURE);

package/test/encode-plan.test.js

@@ -12,7 +12,7 @@ import assert from "node:assert/strict";
 import { CoverageMap } from "../services/encode/CoverageMap.js";
 import { endOfRun } from "../services/encode/EncodeRun.js";
 import { firstUnmetWant, planEncoders } from "../services/encode/EncodePlan.js";
-import { contentionPenalty, penaltiesFrom } from "../services/contention.js";
+import { contentionPenalty, penaltiesFrom } from "../services/encode/contention.js";
 
 // WHAT A SECOND ENCODER COSTS THE FIRST — measured, never a formula.
 //
@@ -440,10 +440,9 @@ test("a viewer joining behind a running encoder gets their own, not a dragged on
 
 test("the lowest thing a viewer is waiting for is reported, so a stalled plan is visible", () => {
   const coverage = new CoverageMap({ segmentCount: 100 });
-  coverage.markReady(40);
-  coverage.markReady(41);
+  coverage.setReady([40, 41]);
   assert.equal(firstUnmetWant(coverage, [{ from: 40, to: 70 }]), 42);
-  coverage.markReadyAll([42, 43, 44]);
+  coverage.setReady([40, 41, 42, 43, 44]);
   assert.equal(firstUnmetWant(coverage, [{ from: 40, to: 44 }]), null);
 });
 

package/test/held-request-width.test.js

@@ -1,154 +1,155 @@
-/**
- * @file How far ahead of the viewer a held segment request may sit.
- *
- * A request is released when the viewer has moved away from it. "Moved away"
- * used to mean more than `MAX_LOOKAHEAD_SEGMENTS` — eight segments, which
- * happened to match a browser holding thirty seconds and would refuse three
- * quarters of the requests of one holding the whole cushion. The width is the
- * encoder's own look-ahead now, which is the same figure the browser sizes its
- * buffer from. Roadmap item 4, step 2.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Timeline } from "../services/output/Timeline.js";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
-
-const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
-const SEGMENT_SECONDS = 4;
-
-/**
- * @returns {Promise<{ manager: HlsSessionManager, dirPath: string }>}
- */
-async function managerWithSession() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "held-request-"));
-  const manager = new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  manager.sessionsById.set(SESSION_ID, {
-    id: SESSION_ID,
-    dirPath,
-    // Where this file is cut, held by the file. A fixture that stated it
-    // on the session was describing what production no longer does.
-    timeline: new Timeline({
-      boundaries: Array.from({ length: 201 }, (_, index) => index * SEGMENT_SECONDS),
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    segmentFormat: fmp4Format,
-    segmentCount: 200,
-    useSyntheticPlaylist: true,
-    // The viewer is at segment #25.
-    furthestViewerSeconds: 100
-  });
-  return { manager, dirPath };
-}
-
-/**
- * @param {number} index
- * @returns {string}
- */
-function segment(index) {
-  return `segment-${String(index).padStart(5, "0")}.mp4`;
-}
-
-test("the width is the encoder's own look-ahead, in segments", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  const width = Math.ceil(manager.lookaheadSeconds / manager.segmentDurationSec);
-  assert.equal(width, 30, "120 s of look-ahead over 4 s segments");
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25 + width)), true, "the far edge");
-  assert.equal(
-    manager.requestStillWanted(SESSION_ID, segment(25 + width + 1)),
-    false,
-    "past everything the encoder is allowed to have produced"
-  );
-});
-
-test("a request the old eight-segment width would have refused is kept", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  // #34 is nine segments ahead of the viewer — inside a 120 s cushion and
-  // outside the eight the width used to be. This is the request a browser
-  // holding the whole cushion makes constantly.
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(34)), true);
-});
-
-test("a segment behind the viewer is still released", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24)), false);
-});
-
-test("a seek by one viewer does not release the request held for another", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  const session = manager.sessionsById.get(SESSION_ID);
-
-  // Both are watching the same copied picture, so both are this one session.
-  // One is at segment #25, the other far ahead at #150 — inside the fixture's
-  // own 200-segment timeline, since a position past the end of the grid is
-  // clamped to it and would prove nothing about the width.
-  manager.requestSeek(SESSION_ID, 100, "behind");
-  manager.requestSeek(SESSION_ID, 600, "ahead");
-
-  // The shared field now holds the leader's position, which is what the
-  // encoder is steered by and what every earlier release judged BOTH of them
-  // against.
-  assert.equal(session.furthestViewerSeconds, 600);
-
-  assert.equal(
-    manager.requestStillWanted(SESSION_ID, segment(26), "behind"),
-    true,
-    "the segment the viewer behind is waiting for is still theirs to wait for"
-  );
-  assert.equal(
-    manager.requestStillWanted(SESSION_ID, segment(26), "ahead"),
-    false,
-    "and for the one in front it is a place they have left"
-  );
-});
-
-test("a viewer's own head moves with their seek", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  // Their last request was at #25; they jump to 600 s, which is #150. The
-  // segment at the target must be wanted — refusing it there is the freeze of
-  // 2026-08-18.
-  manager.requestSeek(SESSION_ID, 600, "viewer");
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(150), "viewer"), true);
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25), "viewer"), false);
-});
-
-test("a viewer nobody can name is judged against the one shared position", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  // A plain HTTP transport builds its own URLs and carries no id. The old
-  // behaviour is what remains, which for a single viewer is the same thing.
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(26), ""), true);
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24), ""), false);
-});
+/**
+ * @file How far ahead of the viewer a held segment request may sit.
+ *
+ * A request is released when the viewer has moved away from it. "Moved away"
+ * used to mean more than `MAX_LOOKAHEAD_SEGMENTS` — eight segments, which
+ * happened to match a browser holding thirty seconds and would refuse three
+ * quarters of the requests of one holding the whole cushion. The width is the
+ * encoder's own look-ahead now, which is the same figure the browser sizes its
+ * buffer from. Roadmap item 4, step 2.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Timeline } from "../services/output/Timeline.js";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { fmp4Format } from "../services/segment-formats/fmp4.js";
+
+const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const SEGMENT_SECONDS = 4;
+
+/**
+ * @returns {Promise<{ manager: HlsSessionManager, dirPath: string }>}
+ */
+async function managerWithSession() {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "held-request-"));
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  manager.sessionsById.set(SESSION_ID, {
+    id: SESSION_ID,
+    dirPath,
+    // Where this file is cut, held by the file. A fixture that stated it
+    // on the session was describing what production no longer does.
+    timeline: new Timeline({
+      boundaries: Array.from({ length: 201 }, (_, index) => index * SEGMENT_SECONDS),
+      cutGrid: "uniform"
+    }),
+    state: "ready",
+    segmentFormat: fmp4Format,
+    segmentCount: 200,
+    useSyntheticPlaylist: true,
+    // The viewer is at segment #25.
+    furthestViewerSeconds: 100
+  });
+  return { manager, dirPath };
+}
+
+/**
+ * @param {number} index
+ * @returns {string}
+ */
+function segment(index) {
+  return `segment-${String(index).padStart(5, "0")}.mp4`;
+}
+
+test("the width is the encoder's own look-ahead, in segments", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  const width = Math.ceil(manager.lookaheadSeconds / manager.segmentDurationSec);
+  assert.equal(width, 30, "120 s of look-ahead over 4 s segments");
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25 + width)), true, "the far edge");
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, segment(25 + width + 1)),
+    false,
+    "past everything the encoder is allowed to have produced"
+  );
+});
+
+test("a request the old eight-segment width would have refused is kept", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  // #34 is nine segments ahead of the viewer — inside a 120 s cushion and
+  // outside the eight the width used to be. This is the request a browser
+  // holding the whole cushion makes constantly.
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(34)), true);
+});
+
+test("a segment behind the viewer is still released", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24)), false);
+});
+
+test("a seek by one viewer does not release the request held for another", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // Both are watching the same copied picture, so both are this one session.
+  // One is at segment #25, the other far ahead at #150 — inside the fixture's
+  // own 200-segment timeline, since a position past the end of the grid is
+  // clamped to it and would prove nothing about the width.
+  manager.requestSeek(SESSION_ID, 100, "behind");
+  manager.requestSeek(SESSION_ID, 600, "ahead");
+
+  // A SEEK DOES ONE THING: it puts the viewer where they now are. It used to
+  // write that position into five places, this session's shared field among
+  // them, and every held request was then judged against whoever moved last —
+  // which is exactly what this test exists to refuse. Each viewer's own
+  // position is what decides, and the two below are asked separately.
+  assert.equal(manager.viewers.get("behind").positionSeconds(), 100);
+  assert.equal(manager.viewers.get("ahead").positionSeconds(), 600);
+
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, segment(26), "behind"),
+    true,
+    "the segment the viewer behind is waiting for is still theirs to wait for"
+  );
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, segment(26), "ahead"),
+    false,
+    "and for the one in front it is a place they have left"
+  );
+});
+
+test("a viewer's own head moves with their seek", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  // Their last request was at #25; they jump to 600 s, which is #150. The
+  // segment at the target must be wanted — refusing it there is the freeze of
+  // 2026-08-18.
+  manager.requestSeek(SESSION_ID, 600, "viewer");
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(150), "viewer"), true);
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25), "viewer"), false);
+});
+
+test("a viewer nobody can name is judged against the one shared position", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  // A plain HTTP transport builds its own URLs and carries no id. The old
+  // behaviour is what remains, which for a single viewer is the same thing.
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(26), ""), true);
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24), ""), false);
+});