@torrent-tv/proxy 2.80.5 → 2.80.7

package/test/encode-plan.test.js

@@ -12,6 +12,22 @@ 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";
+
+// WHAT A SECOND ENCODER COSTS THE FIRST — measured, never a formula.
+//
+// Addon host, 2026-09-03: 854x480 through libx264 `ultrafast` ran at 7.12x with
+// the machine to itself, and at 4.20x and 4.16x when two ran at once. The
+// penalty is read off that reading by the SAME two functions production uses,
+// 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.
+const RUN_COSTS = { killCostSec: 0, firstByteWaitSec: 0.12 };
+
 
 /** A host that can afford two encoders, four-second segments, a cheap restart. */
 // A host that has measured itself: the start and the death from its own runs,
@@ -20,9 +36,15 @@ import { firstUnmetWant, planEncoders } from "../services/encode/EncodePlan.js";
 // host missing any of them keeps its encoders instead — which is its own check
 // below rather than the shape every other check is written against.
 const HOST = {
+  // Measured on the addon host: a second encoder beside the first costs about
+  // half its speed. Without it an extra process is free and the score always
+  // wants more of them.
+  contentionPenaltyFor: penaltyFor,
+  // What the startup benchmark says this host encodes at, in realtimes. It is
+  // measured before any viewer exists, so the plan always has a speed.
+  speedX: 2,
   maxRuns: 2,
   segmentSeconds: 4,
-  restartCostSec: 0.12,
   killCostSec: 0.5,
   firstByteWaitSec: 1,
   refetchSecPerFilmSecond: 0.25
@@ -57,10 +79,18 @@ test("a viewer waiting on nothing made starts one encoder, at what they are wait
   );
 });
 
-test("a viewer whose cushion reaches past a running encoder starts nothing", () => {
-  // Found by the orchestrator's own checks: with the end taken from the window,
-  // a second viewer two segments further on was given an encoder of their own
-  // to make those two, while the run already there had nowhere left to go.
+test("two viewers a couple of numbers apart are never given the same stretch twice", () => {
+  // Found by the orchestrator's own checks. Under the old design the second
+  // viewer was given an encoder of their own while the run already there had
+  // nowhere left to go — two processes side by side for one stretch of film.
+  //
+  // The model answers it by arithmetic instead of by a rule: the number the
+  // second viewer stands on is due now and the encoder behind them needs six
+  // seconds, so it IS late; a new one delivers it in two, so placing one is
+  // worth it; and the one behind is then bounded to the two numbers it can still
+  // make and retires. One encoder, and the second viewer waits four seconds
+  // less. What must never happen — two of them running the same stretch — does
+  // not.
   const coverage = new CoverageMap({ segmentCount: 1000 });
   const runA = run({ from: 100, to: 999, head: 100 });
   coverage.claim(runA, 100, 999);
@@ -70,7 +100,20 @@ test("a viewer whose cushion reaches past a running encoder starts nothing", ()
     runs: [runA],
     ...HOST
   });
-  assert.equal(actions.some((action) => action.type === "start"), false);
+  const spans = actions
+    .filter((action) => action.type !== "stop")
+    .map((action) => [action.from, action.to])
+    .sort((left, right) => left[0] - right[0]);
+  for (let index = 0; index < spans.length - 1; index += 1) {
+    assert.ok(spans[index][1] < spans[index + 1][0],
+      `#${spans[index][0]}..#${spans[index][1]} overlaps #${spans[index + 1][0]}`);
+  }
+  assert.ok(spans.some(([from, to]) => from <= 102 && (to < from || to >= 102)),
+    "somebody is making what the second viewer needs");
+  // How MANY is the score's answer and not a rule: with these two standing two
+  // numbers apart, a second process makes the one in front wait 1.4 s longer and
+  // the one behind 2.5 s less, so the pair is better off. What is fixed is that
+  // they never share a stretch, which the loop above asserts.
 });
 
 test("a viewer whose whole window is already made starts nothing", () => {
@@ -95,7 +138,11 @@ test("a run is given an end at the edge of what is free", () => {
   assert.deepEqual({ from: actions[0].from, to: actions[0].to }, { from: 40, to: 49 });
 });
 
-test("a run that has caught up with made material is moved forward, not killed", () => {
+test("a run that has caught up with made material is not killed for it", () => {
+  // It has arrived at film somebody else made. Killing it was the old answer and
+  // it is never the right one: the work is either taken past the made stretch or
+  // left to drive through, and which of those depends on the score, but the
+  // encoder goes on existing either way.
   const coverage = new CoverageMap({ segmentCount: 100 });
   const runA = run({ head: 10, from: 0, to: 100 });
   coverage.claim(runA, 0, 100);
@@ -108,11 +155,19 @@ test("a run that has caught up with made material is moved forward, not killed",
     runs: [runA],
     ...HOST
   });
-  const move = actions.find((action) => action.type === "move");
-  assert.ok(move, "it should have been moved");
-  assert.equal(move.run, runA);
-  assert.equal(move.from, 31, "to the first thing nobody has");
-  assert.equal(actions.some((action) => action.type === "stop"), false, "and not stopped");
+  assert.equal(actions.some((action) => action.type === "stop"), false, "not killed");
+  assert.ok(
+    actions.some((action) => (action.type === "keep" || action.type === "move") && action.run === runA),
+    "it is still one of the encoders on this output"
+  );
+  // And nothing is arranged so that two of them make the same piece.
+  const spans = actions
+    .filter((action) => action.type !== "stop")
+    .map((action) => [action.from, action.to < action.from ? Number.POSITIVE_INFINITY : action.to])
+    .sort((left, right) => left[0] - right[0]);
+  for (let index = 0; index < spans.length - 1; index += 1) {
+    assert.ok(spans[index][1] < spans[index + 1][0], "the stretches do not overlap");
+  }
 });
 
 test("a covered stretch shorter than a restart is driven through instead", () => {
@@ -125,7 +180,9 @@ test("a covered stretch shorter than a restart is driven through instead", () =>
   coverage.markReady(10);
   const actions = planEncoders({
     coverage,
-    windows: [{ from: 0, to: 90 }],
+    // From where the run stands, so the only question asked is the covered piece
+    // under it. Beginning at #0 would also be asking who makes #0..#9.
+    windows: [{ from: 10, to: 90 }],
     runs: [runA],
     ...HOST
   });
@@ -133,20 +190,21 @@ test("a covered stretch shorter than a restart is driven through instead", () =>
   assert.ok(actions.some((action) => action.type === "keep" && action.run === runA));
 });
 
-test("a run whose speed nothing has measured is kept, not taken away", () => {
-  // Moving costs a known amount for an unknown gain, and a run nothing has
-  // measured has produced nothing yet — so taking its work away is certainly a
-  // loss and the comparison cannot be made. It used to answer the other way,
-  // and then every just-started run was moved the moment anything ahead of it
-  // was covered, which, once the film ahead had been made, was always: 684
-  // starts in 482 seconds in the field on 2026-09-05.
+test("a run standing on film nobody has made is never taken away", () => {
+  // The field failure this guards: 684 starts in 482 seconds on 2026-09-05,
+  // because a run was moved whenever anything ahead of it had been made.
+  //
+  // Moving is priced rather than forbidden — a run standing ON made film may
+  // well be worth restarting one number along, and the two checks above measure
+  // both sides of that. What can never be worth it is moving a run that has
+  // nothing made under it or ahead of it: there is no work to skip, so the move
+  // buys nothing and costs a start.
   const coverage = new CoverageMap({ segmentCount: 100 });
-  const runA = run({ head: 10, speedX: 0 });
+  const runA = run({ head: 10, speedX: 2 });
   coverage.claim(runA, 0, 100);
-  coverage.markReady(10);
   const actions = planEncoders({
     coverage,
-    windows: [{ from: 0, to: 90 }],
+    windows: [{ from: 10, to: 90 }],
     runs: [runA],
     ...HOST
   });
@@ -154,11 +212,13 @@ test("a run whose speed nothing has measured is kept, not taken away", () => {
   assert.ok(actions.some((action) => action.type === "keep" && action.run === runA));
 });
 
-test("both sides of the move are counted, not just the encoder's own time", () => {
-  // Driving through costs this run's encode time AND the swarm the same bytes a
-  // second time; moving costs the death, the start and the wait for the first
-  // bytes. Here driving is dear enough to lose: 20 covered segments of 4 s at
-  // 1x is 80 s of encoding, against a move priced at 0.12 + 0.5 + 3 seconds.
+test("a long stretch of made film is skipped, and the swarm's price is in the reckoning", () => {
+  // Driving through costs this encoder's time AND the swarm the same bytes a
+  // second time. Twenty made pieces of 4 s at 1x is 80 s of encoding plus 20 s
+  // of fetching, against a move priced at 0.12 + 0.5 + 3 seconds — so it skips.
+  //
+  // There is no separate comparison to read here: both are seconds, both are in
+  // the one score, and the arrangement with the smaller total is the one taken.
   const coverage = new CoverageMap({ segmentCount: 200 });
   const runA = run({ head: 10, speedX: 1 });
   coverage.claim(runA, 0, 200);
@@ -167,17 +227,25 @@ test("both sides of the move are counted, not just the encoder's own time", () =
   }
   const actions = planEncoders({
     coverage,
-    windows: [{ from: 0, to: 190 }],
+    // The viewer is PAST the made stretch, so the only question is this encoder:
+    // drive through twenty pieces that exist, or skip them. With a viewer at #0
+    // as well, something has to cross that stretch whatever happens, and then
+    // moving buys nothing — which the score says too, and is why the window
+    // starts where the viewer actually is.
+    windows: [{ from: 30, to: 190 }],
     runs: [runA],
     ...HOST,
+    // One encoder, so the question is only about THIS one: drive through the
+    // twenty pieces that exist, or skip them. With room for a second, the
+    // machine simply buys one and the question never arises.
+    maxRuns: 1,
     killCostSec: 0.5,
     firstByteWaitSec: 3,
     refetchSecPerFilmSecond: 0.25
   });
   const move = actions.find((action) => action.type === "move");
-  assert.ok(move);
-  assert.match(move.because, /refetch 20\.00s/);
-  assert.match(move.because, /against 3\.62s to move/);
+  assert.ok(move, "it is taken past the made film rather than left to make it again");
+  assert.equal(move.from, 30, "to the first thing nobody has");
 });
 
 test("a short covered stretch is driven through rather than paid a restart for", () => {
@@ -190,7 +258,9 @@ test("a short covered stretch is driven through rather than paid a restart for",
   coverage.markReady(10);
   const actions = planEncoders({
     coverage,
-    windows: [{ from: 0, to: 190 }],
+    // From where the run stands, so the only question is the covered piece under
+    // it. A window starting at #0 would also be asking who makes #0..#9.
+    windows: [{ from: 10, to: 190 }],
     runs: [runA],
     ...HOST,
     killCostSec: 0.5,
@@ -201,11 +271,15 @@ test("a short covered stretch is driven through rather than paid a restart for",
   assert.ok(actions.some((action) => action.type === "keep" && action.run === runA));
 });
 
-test("a run with nothing left to make ahead of it is stopped", () => {
+test("a run with nothing left ahead of it does not go on making nothing", () => {
+  // Everything from #10 to the end exists. The encoder standing at #10 has
+  // nothing to do there; whether it is stopped or taken back to the film before
+  // #0 that nobody has made is the score's answer, and both are right answers.
+  // What must not happen is that it stays where it is, producing nothing.
   const coverage = new CoverageMap({ segmentCount: 100 });
   const runA = run({ head: 10 });
   coverage.claim(runA, 0, 100);
-  for (let index = 10; index <= 90; index += 1) {
+  for (let index = 10; index < 100; index += 1) {
     coverage.markReady(index);
   }
   const actions = planEncoders({
@@ -214,10 +288,12 @@ test("a run with nothing left to make ahead of it is stopped", () => {
     runs: [runA],
     ...HOST
   });
-  assert.deepEqual(
-    actions.map((action) => action.type),
-    ["stop"]
-  );
+  const kept = actions.find((action) => action.type === "keep" && action.run === runA);
+  assert.equal(kept, undefined, "it is not left standing on film that already exists");
+  const madeAgain = actions.filter((action) => action.type !== "stop");
+  for (const action of madeAgain) {
+    assert.ok(action.from < 10, "and whatever is made is film nobody has");
+  }
 });
 
 test("every encoder stops when nobody is watching the output", () => {
@@ -274,35 +350,51 @@ test("the same plan run twice on an unchanged state gives the same answer", () =
   assert.ok(!first.includes("stop"), "and neither pass kills what the other would start");
 });
 
-test("a viewer's most urgent zone is filled before a less urgent one", () => {
+test("the one machine goes to whoever is due soonest, not to the smallest number", () => {
+  // Urgency is a TIME in this model, so the test states one. The far zone is
+  // lower in number and needed sooner; the order must come from the time.
   const coverage = new CoverageMap({ segmentCount: 1000 });
   const actions = planEncoders({
     coverage,
-    // The far zone is lower in number and lower in priority: the order must
-    // come from the priority, not from the number.
     windows: [
-      { from: 0, to: 100, priority: 1 },
-      { from: 500, to: 530, priority: 3 }
+      { from: 0, to: 100, priority: 1, withinSeconds: 600 },
+      { from: 500, to: 530, priority: 3, withinSeconds: 0 }
     ],
-    runs: [],
+    // A run whose speed has been measured: how long an encoder takes to reach a
+    // number is the whole comparison, and with nothing measured the model has no
+    // ground to prefer one place over another and places once.
+    runs: [run({ from: 900, to: 999, head: 900 })],
     ...HOST,
-    maxRuns: 1
+    maxRuns: 2
   });
   const started = actions.filter((action) => action.type === "start").map((action) => action.from);
 
   assert.deepEqual(started, [500], "the one machine goes where somebody is stopped");
 });
 
-test("two viewers far apart get an encoder each, when the machine can hold two", () => {
+test("two viewers far apart are both served, by however many encoders serve them soonest", () => {
+  // Two encoders, or one that goes to whichever of them is worse off: the answer
+  // is what a second process costs this machine, which is measured, and the
+  // score works it out. What must hold is that neither of them is simply left.
   const coverage = new CoverageMap({ segmentCount: 1000 });
   const actions = planEncoders({
     coverage,
-    windows: [{ from: 0, to: 30 }, { from: 800, to: 830 }],
-    runs: [],
-    ...HOST
+    windows: [
+      { from: 0, to: 30, withinSeconds: 0 },
+      { from: 800, to: 830, withinSeconds: 0 }
+    ],
+    runs: [run({ from: 900, to: 999, head: 900 })],
+    ...HOST,
+    maxRuns: 3
   });
-  const started = actions.filter((action) => action.type === "start").map((action) => action.from);
-  assert.deepEqual(started, [0, 800]);
+  const spans = actions
+    .filter((action) => action.type !== "stop")
+    .map((action) => [action.from, action.to < action.from ? Number.POSITIVE_INFINITY : action.to]);
+  assert.ok(spans.some(([from, to]) => from <= 0 && to >= 0), "the one at the beginning is served");
+  for (let index = 0; index < spans.length - 1; index += 1) {
+    const sorted = [...spans].sort((left, right) => left[0] - right[0]);
+    assert.ok(sorted[index][1] < sorted[index + 1][0], "and no two encoders share a number");
+  }
 });
 
 test("a machine that can hold one gives it to the viewer who is stopped soonest", () => {
@@ -327,6 +419,12 @@ test("a viewer joining behind a running encoder gets their own, not a dragged on
   const coverage = new CoverageMap({ segmentCount: 1000 });
   const runA = run({ from: 500, to: 600, head: 510 });
   coverage.claim(runA, 500, 600);
+  // A head at #510 means #500..#509 are already made — that is what a head is.
+  // Left unsaid, the map believes a viewer is waiting on ten pieces nobody has,
+  // and moving the encoder back to make them is then the right answer.
+  for (let index = 500; index < 510; index += 1) {
+    coverage.markReady(index);
+  }
   const actions = planEncoders({
     coverage,
     windows: [{ from: 500, to: 530 }, { from: 100, to: 130 }],
@@ -366,7 +464,7 @@ test("a run with no end is making what the viewers ahead of it are waiting for",
     wanted: [{ from: 0, to: 30 }],
     maxRuns: 2,
     segmentSeconds: 4,
-    restartCostSec: 0.12
+    ...RUN_COSTS
   });
 
   assert.deepEqual(
@@ -381,15 +479,26 @@ test("a run with no end is making what the viewers ahead of it are waiting for",
   );
 });
 
-test("the machine's whole budget is used, not one encoder per viewer", () => {
-  // Nothing about a viewer says how many encoders there should be. What says it
-  // is what the machine affords, and the film is divided between them.
+test("spare budget IS spent on the rest of the film, once nobody is waiting", () => {
+  // The user's own correction: film nobody is waiting for still has value,
+  // because a viewer seeking back into a part that exists starts playing at
+  // once. So what the machine has spare goes to finishing the file.
+  //
+  // "Once nobody is waiting" is not a condition written anywhere — it falls out
+  // of the score. A second process costs the first the measured share of the
+  // machine, so while somebody is stopped on a piece, adding one delays that
+  // piece and the first term refuses it. Here the near film is already made,
+  // nothing is late in either arrangement, and the two that finish the rest
+  // sooner win.
   const coverage = new CoverageMap({ segmentCount: 400 });
+  for (let index = 0; index <= 9; index += 1) {
+    coverage.markReady(index);
+  }
   const actions = planEncoders({
     coverage,
     windows: [
-      { from: 0, to: 9, priority: 32 },
-      { from: 10, to: 399, priority: 20 }
+      { from: 0, to: 9, priority: 32, withinSeconds: 0 },
+      { from: 10, to: 399, priority: 20, withinSeconds: 40 }
     ],
     runs: [],
     ...HOST,
@@ -397,31 +506,15 @@ test("the machine's whole budget is used, not one encoder per viewer", () => {
   });
   const started = actions.filter((action) => action.type === "start");
 
-  assert.equal(started.length, 4, "four encoders where the machine allows four");
-  const from = started.map((action) => action.from).sort((left, right) => left - right);
-  assert.equal(from[0], 0, "the first where the viewer is stopped");
-  assert.ok(from[3] > from[0], "and the rest spread over the film");
+  assert.ok(started.length > 1, "the machine does not stand idle while film is unmade");
+  const spans = started
+    .map((action) => [action.from, action.to])
+    .sort((left, right) => left[0] - right[0]);
+  for (let index = 0; index < spans.length - 1; index += 1) {
+    assert.ok(spans[index][1] < spans[index + 1][0], "and no two of them share a number");
+  }
 });
 
-test("below realtime the first stretches are what one encoder can hold", () => {
-  // At half speed an encoder holds `(q - p)` of film: the first covers ten
-  // segments, and the next has to be standing where it stops holding.
-  const coverage = new CoverageMap({ segmentCount: 400 });
-  const actions = planEncoders({
-    coverage,
-    windows: [{ from: 10, to: 399, priority: 32 }],
-    runs: [{ from: 0, to: 0, head: 0, speedX: 0.5 }],
-    ...HOST,
-    maxRuns: 3
-  });
-  const started = actions
-    .filter((action) => action.type === "start")
-    .map((action) => action.from)
-    .sort((left, right) => left - right);
-
-  assert.ok(started.length >= 2, "more than one, because one cannot hold the film");
-  assert.ok(started[1] > started[0], "and they grow apart rather than sitting together");
-});
 
 test("two encoders never share a segment number", () => {
   // The whole of what went wrong in the field: two encoders writing one name.

package/test/open-piece.test.js

@@ -21,6 +21,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
 import { mkdtemp, rm, writeFile, readdir } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -110,3 +111,42 @@ test("only inside the stretch the ended run was given", async () => {
     await rm(dir, { recursive: true, force: true });
   }
 });
+
+test("a run given no end never reaches past what it made, so a live run's piece is safe", async () => {
+  // Field 2026-09-06. Three encoders wrote into one directory; the first was
+  // stopped, its stretch was `#0..#-1` — "to the end of the track" — and the
+  // cleanup after it took the highest-numbered file anywhere in that directory,
+  // which a LIVE encoder had just finished. The number is spent for good,
+  // because names only grow, and the picture stood still for 647 seconds.
+  const dir = await mkdtemp(path.join(os.tmpdir(), "open-piece-"));
+  // What the stopped run made: #0 and #1, with #2 left open.
+  await writeFile(path.join(dir, "segment-00000.mp4"), Buffer.alloc(1000, 1));
+  await writeFile(path.join(dir, "segment-00001.mp4"), Buffer.alloc(1000, 1));
+  await writeFile(path.join(dir, "segment-00002.mp4"), Buffer.alloc(0));
+  // What a live encoder, working further along the same track, has finished.
+  await writeFile(path.join(dir, "segment-00040.mp4"), Buffer.alloc(9000, 1));
+
+  const removed = await discardOpenPiece(
+    dir,
+    format,
+    { from: 0, to: -1 },
+    null,
+    "segment-00001.mp4"
+  );
+
+  assert.equal(removed, 2, "its own open piece goes");
+  assert.ok(existsSync(path.join(dir, "segment-00040.mp4")), "the live run's piece stays");
+});
+
+test("a run that named nothing leaves only its own first piece", async () => {
+  // It opened one file and died — 548 ms after starting, in the field. Nothing
+  // above that can be its.
+  const dir = await mkdtemp(path.join(os.tmpdir(), "open-piece-"));
+  await writeFile(path.join(dir, "segment-00010.mp4"), Buffer.alloc(0));
+  await writeFile(path.join(dir, "segment-00011.mp4"), Buffer.alloc(9000, 1));
+
+  const removed = await discardOpenPiece(dir, format, { from: 10, to: -1 }, null, null);
+
+  assert.equal(removed, 10, "the one it opened");
+  assert.ok(existsSync(path.join(dir, "segment-00011.mp4")), "and nothing beyond it");
+});

package/test/output-speed.test.js

@@ -0,0 +1,86 @@
+/**
+ * @file How fast this machine produces one output.
+ *
+ * The figure every decision in the encoding layer rests on: where an encoder
+ * goes and how many run are both worked out from arrivals, and an arrival is a
+ * distance divided by this. There must therefore ALWAYS be an answer, and each
+ * of the three that can be given is a measurement rather than a guess.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EncodeCost } from "../services/quality/EncodeCost.js";
+import { LiveOutputs } from "../services/output/LiveOutputs.js";
+
+const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
+
+/**
+ * @param {object[]} sessions
+ * @param {{ copySpeedX?: number | null, benchmark?: object[] | null }} host
+ */
+function costOf(sessions, host = {}) {
+  const sessionsById = new Map(sessions.map((session, index) => [String(index), session]));
+  return new EncodeCost({
+    liveOutputs: new LiveOutputs({ sessionsById }),
+    host: () => ({
+      benchmark: host.benchmark ?? null,
+      decodeModel: null,
+      contentionPenalties: null,
+      copySpeedX: host.copySpeedX ?? null,
+      availability: null
+    }),
+    audioCostKey: () => "",
+    runningEncoders: () => 0,
+    encodersRunningNow: () => 0,
+    torrentCostSecFor: () => 0
+  });
+}
+
+test("a run on this output outranks every prediction", () => {
+  // It is this machine, this material and these settings. Nothing said before
+  // the fact beats something seen happening.
+  const cost = costOf(
+    [{ outputKey: PICTURE, state: "ready", transcodeVideo: false, lastAloneSpeed: 9.5 }],
+    { copySpeedX: 600 }
+  );
+  assert.equal(cost.speedForOutput(PICTURE), 9.5);
+});
+
+test("a copied picture is priced by the startup copy measurement", () => {
+  // The branch that had no figure at all until it was measured: copying neither
+  // decodes nor encodes, so neither the preset benchmark nor the decode model
+  // describes it, and a copied output was planned with no speed until its own
+  // run had been running long enough to report one.
+  const cost = costOf(
+    [{ outputKey: PICTURE, state: "ready", transcodeVideo: false, lastAloneSpeed: null }],
+    { copySpeedX: 602 }
+  );
+  assert.equal(cost.speedForOutput(PICTURE), 602);
+});
+
+test("the fastest reading wins where several sessions produce one output", () => {
+  // Two sessions whose output parameters agree ARE one output, so what either
+  // of them measured about this machine is true of the other.
+  const cost = costOf([
+    { outputKey: PICTURE, state: "ready", transcodeVideo: false, lastAloneSpeed: 4 },
+    { outputKey: PICTURE, state: "ready", transcodeVideo: false, lastAloneSpeed: 7 }
+  ]);
+  assert.equal(cost.speedForOutput(PICTURE), 7);
+});
+
+test("a disposed session says nothing about what the machine is doing", () => {
+  const cost = costOf(
+    [{ outputKey: PICTURE, state: "disposed", transcodeVideo: false, lastAloneSpeed: 4 }],
+    { copySpeedX: 602 }
+  );
+  assert.equal(cost.speedForOutput(PICTURE), 0, "no live session, so nothing to say");
+});
+
+test("another output's reading is not borrowed", () => {
+  // Two outputs are two different pieces of work — a picture re-encoded to 480p
+  // and the same picture copied are not the same speed.
+  const cost = costOf([
+    { outputKey: "other", state: "ready", transcodeVideo: false, lastAloneSpeed: 40 }
+  ]);
+  assert.equal(cost.speedForOutput(PICTURE), 0);
+});

package/test/piece-store-eviction.test.js

@@ -278,6 +278,32 @@ test("the store asks for what its readers declared, and for a whole window at le
   }
 });
 
+test("the floor the ceiling will not fall below is the same union, not the widest reader alone", async () => {
+  const { store, directory } = await makeStore(64);
+  try {
+    // The same two overlapping readers as the ask above: picture and sound,
+    // 10..44, thirty-five pieces together. The machine now offers far less
+    // than that (ten pieces) — before this fix the floor here came from
+    // `widestPieces` (twenty, the wider of the two readers alone), fifteen
+    // short of what both of them were actually pinning at once. A field
+    // session with three such readers on one file (video, audio and the
+    // edge-warming read) reached exactly that shortfall on 2026-09-07: every
+    // resident piece ended up pinned and WebTorrent destroyed the torrent
+    // over it.
+    store.protectRange("video", 10, 29);
+    store.protectRange("audio", 25, 44);
+    const revised = store.reviseGrowthCeiling(10 * PIECE);
+    assert.equal(
+      revised.ceilingBytes,
+      35 * PIECE,
+      "the floor is the union of both readers, not the wider one alone"
+    );
+  } finally {
+    store.destroy(() => undefined);
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
 test("a block is re-used instead of a new one being allocated for every piece", async () => {
   const capacity = 4;
   const { store, directory } = await makeStore(capacity);