@torrent-tv/proxy 2.76.3 → 2.76.5

package/test/encode-orchestrator.test.js

@@ -194,3 +194,34 @@ test("nothing wanted anywhere is said plainly", () => {
   const { made } = orchestrator();
   assert.match(made.describe(), /nothing wanted/);
 });
+
+test("a run adopted with no end holds the look-ahead, not the rest of the film", () => {
+  // A session's own encoder is handed to the plan rather than built by it, and
+  // it carries `to = -1` — no end. Claiming the film from there would leave a
+  // viewer further in with no encoder at all: they would wait for this run to
+  // encode its way to them, which on a long film is an hour. What bounds it is
+  // the look-ahead, because a run is suspended once it is that far in front of
+  // its viewer and produces nothing until somebody asks.
+  const { made } = orchestrator({ maxRuns: 2 });
+  made.lookaheadSegments = 30;
+  const adopted = {
+    from: 0,
+    to: -1,
+    head: 3,
+    isAlive: true,
+    isStopping: false,
+    speedX: 8,
+    stop() {
+      this.isAlive = false;
+    }
+  };
+  made.adopt(PICTURE, adopted);
+
+  made.want({ claimant: "far", address: PICTURE, from: 200, to: 230 });
+  made.reconcile();
+
+  const runs = made.runsOn(PICTURE);
+  assert.equal(runs.length, 2, "the viewer further in got an encoder of their own");
+  assert.ok(adopted.isAlive, "and the adopted run was not stopped to make room");
+  assert.equal(runs.some((run) => run.from === 200), true, "started where that viewer is waiting");
+});

package/test/encode-plan.test.js

@@ -10,6 +10,7 @@
 import test from "node:test";
 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";
 
 /** A host that can afford two encoders, four-second segments, a cheap restart. */
@@ -243,3 +244,35 @@ test("the lowest thing a viewer is waiting for is reported, so a stalled plan is
   coverage.markReadyAll([42, 43, 44]);
   assert.equal(firstUnmetWant(coverage, [{ from: 40, to: 44 }]), null);
 });
+
+test("a run with no end is making what the viewers ahead of it are waiting for", () => {
+  // Field, 2026-09-05: an encoder was started and killed every five seconds,
+  // each producing 0-2 segments, for as long as anybody watched. A run given no
+  // end carries `to = -1`, and two places read that as a number instead of as
+  // "no end": the overlap test called its work unwanted, and the claim it made
+  // in the coverage map was one segment long, so the plan saw the rest of the
+  // film as free and started another encoder there.
+  const coverage = new CoverageMap({ segmentCount: 570 });
+  const run = { from: 0, to: -1, head: 3, speedX: 8, isAlive: true };
+  coverage.claim(run, run.from, endOfRun(run));
+
+  const actions = planEncoders({
+    coverage,
+    live: [run],
+    wanted: [{ from: 0, to: 30 }],
+    maxRuns: 2,
+    segmentSeconds: 4,
+    restartCostSec: 0.12
+  });
+
+  assert.deepEqual(
+    actions.filter((action) => action.type === "stop"),
+    [],
+    "nothing is stopped: it is making exactly what is wanted"
+  );
+  assert.deepEqual(
+    actions.filter((action) => action.type === "start"),
+    [],
+    "and nothing new is started over ground it already holds"
+  );
+});