@torrent-tv/proxy 2.89.16 → 2.89.18

package/test/drain-threat.test.js

@@ -1,65 +0,0 @@
-/**
- * @file When a move to a smaller output is prepared for a viewer, and when it is
- * not (roadmap item 98), and which way their buffer is going.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { drainThreat } from "../services/encode/quality/drain-threat.js";
-import { bufferTrend } from "../services/viewer/buffer-trend.js";
-
-test("a buffer that falls but lasts past the new piece's readiness moves nothing", () => {
-  // 60 s held, draining at 0.5 s/s: empty in 120 s. The new output would have
-  // the piece in 8 s, and the next report comes in 10 s.
-  const answer = drainThreat({ bufferedSec: 60, slope: -0.5, reportGapSec: 10, secondsToReady: 8 });
-  assert.equal(answer.threat, false);
-  assert.equal(answer.secondsToEmpty, 120);
-});
-
-test("a buffer that would end before the new piece is ready starts the move", () => {
-  // 6 s held, draining at 0.5 s/s: empty in 12 s — sooner than 8 s of making
-  // plus the 10 s until this viewer is heard from again.
-  assert.equal(drainThreat({ bufferedSec: 6, slope: -0.5, reportGapSec: 10, secondsToReady: 8 }).threat, true);
-});
-
-test("the wait for the next report is part of the reckoning", () => {
-  const without = drainThreat({ bufferedSec: 10, slope: -1, reportGapSec: 0, secondsToReady: 8 });
-  const withGap = drainThreat({ bufferedSec: 10, slope: -1, reportGapSec: 3, secondsToReady: 8 });
-  assert.equal(without.threat, false, "10 s left against 8 s of making");
-  assert.equal(withGap.threat, true, "but the next chance to act is 3 s away, too late");
-});
-
-test("a buffer that holds or grows is no threat, and neither is one with no trend yet", () => {
-  assert.equal(drainThreat({ bufferedSec: 1, slope: 0, reportGapSec: 10, secondsToReady: 30 }).threat, false);
-  assert.equal(drainThreat({ bufferedSec: 1, slope: 0.4, reportGapSec: 10, secondsToReady: 30 }).threat, false);
-  assert.equal(drainThreat({ bufferedSec: 1, slope: null, reportGapSec: 10, secondsToReady: 30 }).threat, false);
-});
-
-test("a readiness nobody can state is not assumed to be quick", () => {
-  assert.equal(drainThreat({ bufferedSec: 600, slope: -0.1, reportGapSec: 10, secondsToReady: null }).threat, true);
-});
-
-test("the trend is read over one segment's period, not from two readings", () => {
-  // A sawtooth over a flat line: a 4 s segment arrives, then 4 s play out.
-  const at = (seconds) => seconds * 1000;
-  const flat = [
-    { at: at(0), seconds: 20 },
-    { at: at(2), seconds: 18 },
-    { at: at(4), seconds: 20 },
-    { at: at(6), seconds: 18 },
-    { at: at(8), seconds: 20 }
-  ];
-  const trend = bufferTrend(flat, 4);
-  assert.ok(Math.abs(trend.slope) < 0.5, `the last two readings alone say +1 s/s; the period says ${trend.slope}`);
-  assert.equal(trend.reportGapSec, 2);
-});
-
-test("readings that do not yet span one segment say nothing", () => {
-  assert.equal(bufferTrend([{ at: 0, seconds: 10 }, { at: 1000, seconds: 9 }], 4), null);
-  assert.equal(bufferTrend([{ at: 0, seconds: 10 }], 4), null);
-});
-
-test("a steady drain reads as the rate it drains at", () => {
-  const readings = [0, 5, 10].map((second) => ({ at: second * 1000, seconds: 30 - second }));
-  assert.equal(bufferTrend(readings, 4).slope, -1);
-});

package/test/duplicate-add.test.js

@@ -1,48 +0,0 @@
-/**
- * @file One infohash, two sources: what happens when the second add is refused.
- *
- * The same film arrives as a magnet and as a `.torrent`. WebTorrent refuses the
- * second add — one infohash, one torrent — and the pool then has to decide what
- * to hand back. Adopting the one already there is right when it is ready, and
- * wrong when it is not: a magnet whose swarm has not answered has no file list,
- * so everything bound to it is answered 404.
- *
- * Measured 2026-08-15 on the addon host: a magnet with no reachable trackers
- * was added first and never became ready; the same film's own `.torrent`, which
- * carries the file list, the piece hashes and the trackers, then joined that
- * empty torrent instead of replacing it. `/stream` answered 404, the encoder
- * died on its first read, and the film stayed unplayable until the proxy was
- * restarted — one bad magnet poisoning every later attempt at that infohash.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { duplicateAddDecision } from "../services/torrent/torrent-pool.js";
-
-test("a ready torrent is adopted, whatever the new source carries", () => {
-  assert.equal(
-    duplicateAddDecision({ existingIsReady: true, incomingHasMetadata: true }),
-    "adopt",
-    "one swarm per infohash: a second copy would download the same pieces twice"
-  );
-  assert.equal(
-    duplicateAddDecision({ existingIsReady: true, incomingHasMetadata: false }),
-    "adopt"
-  );
-});
-
-test("an unready torrent is replaced when this add brings the metadata", () => {
-  assert.equal(
-    duplicateAddDecision({ existingIsReady: false, incomingHasMetadata: true }),
-    "replace",
-    "the .torrent holds what the swarm was being asked for; waiting for it is waiting for nothing"
-  );
-});
-
-test("two magnets wait, because neither has anything the other lacks", () => {
-  assert.equal(
-    duplicateAddDecision({ existingIsReady: false, incomingHasMetadata: false }),
-    "wait",
-    "replacing here would only restart the same search, and the caller's own bound answers"
-  );
-});

package/test/encode-admission.test.js

@@ -1,170 +0,0 @@
-/**
- * @file Whether the whole machine has a place for one more encoder (roadmap
- * item 97, step 13).
- *
- * What is pinned here:
- *
- * 1. a place is held by an OUTPUT: two preparations onto one output take one
- *    place, and the second is admitted without arithmetic;
- * 2. two preparations onto two DIFFERENT outputs with room for one: the first
- *    is admitted, the second refused, because it is asked after the first is
- *    recorded;
- * 3. one of two viewers giving up a preparation of one output does not free
- *    its place;
- * 4. the cost is what an encoder costs, not a count of processes: a picture
- *    and its soundtrack fit where two pictures do not — the addon host's own
- *    figures, 1080p alone at 1.96x;
- * 5. an admitted encoder is never taken away: the machine's answer is never
- *    below what already runs, nor below one for an output a preparation holds;
- * 6. a new output on a full machine is given no encoder.
- *
- * The records of who is being prepared are stood in for by a set the check
- * writes to, which is what the viewers' records are read as.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EncodeAdmission } from "../services/encode/EncodeAdmission.js";
-
-// 1080p re-encoded on the addon host: 1.96x alone.
-const PICTURE_1080 = 1 / 1.96;
-// A re-encoded soundtrack: a small fraction of a picture.
-const SOUNDTRACK = 0.02;
-
-/**
- * A machine with the outputs named, their costs, what runs and who is being
- * prepared onto what.
- *
- * @param {{ costs: Record<string, number | null>, running?: Record<string, number>, share?: number | null }} how
- */
-function machine(how) {
-  const running = new Map(Object.entries(how.running ?? {}));
-  /** Output address to the viewers being prepared onto it. @type {Map<string, Set<string>>} */
-  const preparing = new Map();
-  const admission = new EncodeAdmission({
-    liveRunsByAddress: () => new Map([...running].filter(([, count]) => count > 0)),
-    preparedAddresses: () => new Set([...preparing].filter(([, viewers]) => viewers.size > 0).map(([address]) => address)),
-    loadOf: (address) => (address in how.costs ? { costSec: how.costs[address], fileKey: "", fileCostSec: 0 } : null),
-    availability: () => (how.share === undefined || how.share === null ? null : { share: how.share, known: true })
-  });
-  return {
-    admission,
-    running,
-    /** A viewer's preparation recorded, as `Viewer` records it. */
-    prepare: (address, viewer) => {
-      const viewers = preparing.get(address) ?? new Set();
-      viewers.add(viewer);
-      preparing.set(address, viewers);
-    },
-    /** A viewer's preparation ended, on whichever path. */
-    giveUp: (address, viewer) => preparing.get(address)?.delete(viewer)
-  };
-}
-
-test("two preparations onto one output take one place", () => {
-  const { admission, prepare } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 } });
-  assert.equal(admission.admitsPreparation("a").admitted, true);
-  prepare("a", "viewer-1");
-  const second = admission.admitsPreparation("a");
-  assert.equal(second.admitted, true, "the second viewer shares the place");
-  assert.match(second.reason, /already holds a place/);
-});
-
-test("two preparations onto two different outputs with room for one: the second is refused", () => {
-  const { admission, prepare } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 } });
-  // The first is asked and recorded in one stretch, as the preparation does it.
-  assert.equal(admission.admitsPreparation("a").admitted, true);
-  prepare("a", "viewer-1");
-  const second = admission.admitsPreparation("b");
-  assert.equal(second.admitted, false, "both together would make 0.98x of each");
-  assert.ok(second.speedX < 1);
-});
-
-test("one of two viewers giving up a preparation of one output does not free its place", () => {
-  const { admission, prepare, giveUp } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 } });
-  prepare("a", "viewer-1");
-  prepare("a", "viewer-2");
-  giveUp("a", "viewer-1");
-  assert.equal(admission.admitsPreparation("b").admitted, false, "viewer-2 still holds the place on a");
-  assert.equal(admission.placesFor("a", 0).runs, 1, "and a keeps its encoder's place");
-  giveUp("a", "viewer-2");
-  assert.equal(admission.admitsPreparation("b").admitted, true, "the place ends with the last record");
-});
-
-test("a picture and its soundtrack fit where two pictures do not", () => {
-  const { admission } = machine({
-    costs: { picture: PICTURE_1080, sound: SOUNDTRACK, other: PICTURE_1080 },
-    running: { picture: 1 }
-  });
-  assert.equal(admission.admitsPreparation("sound").admitted, true, "0.53 s/s makes 1.89x");
-  assert.equal(admission.placesFor("sound", 0).runs >= 1, true);
-  assert.equal(admission.admitsPreparation("other").admitted, false, "1.02 s/s makes 0.98x");
-});
-
-test("an admitted encoder is never taken away, and a held place is kept", () => {
-  const { admission } = machine({
-    costs: { a: PICTURE_1080, b: PICTURE_1080 },
-    running: { a: 1, b: 1 }
-  });
-  assert.equal(admission.placesFor("a", 1).runs, 1, "both running: each keeps its one");
-  assert.equal(admission.placesFor("b", 1).runs, 1);
-  const { admission: held, prepare: prepareHeld } = machine({
-    costs: { a: PICTURE_1080, b: PICTURE_1080 },
-    running: { b: 1 }
-  });
-  prepareHeld("a", "viewer-1");
-  assert.equal(held.placesFor("a", 0).runs, 1, "a place promised to a preparation is not withdrawn");
-});
-
-test("a new output on a full machine is given no encoder", () => {
-  const { admission } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 }, running: { a: 1 } });
-  assert.equal(admission.placesFor("b", 0).runs, 0);
-});
-
-test("the share of the machine nobody has priced is taken off what there is", () => {
-  // 0.6 s/s alone makes 1.67x; with a third of the machine taken by work
-  // nobody priced it makes 1.11x, and a soundtrack beside it still fits.
-  const quiet = machine({ costs: { a: 0.6, b: 0.4 }, share: 1 });
-  assert.equal(quiet.admission.admitsPreparation("a").admitted, true);
-  const busy = machine({ costs: { a: 0.6, b: 0.4 }, running: { a: 1 }, share: 0.6 });
-  assert.equal(busy.admission.admitsPreparation("b").admitted, false, "1.0 s/s at 0.6 of the machine makes 0.6x");
-});
-
-test("an output with no measured cost is not admitted", () => {
-  const { admission } = machine({ costs: { a: PICTURE_1080, b: null }, running: { a: 1 } });
-  const answer = admission.admitsPreparation("b");
-  assert.equal(answer.admitted, false);
-  assert.match(answer.reason, /no measured encoding cost/);
-});
-
-test("unpriced occupied work is neither spare pool headroom nor capacity for another output", () => {
-  const { admission } = machine({ costs: { a: null, b: PICTURE_1080 }, running: { a: 1 } });
-  assert.equal(admission.headroom().encodeSpeedX, 0, "the pool sees no confirmed room");
-  const answer = admission.admitsPreparation("b");
-  assert.equal(answer.admitted, false);
-  assert.match(answer.reason, /capacity is unknown/);
-});
-
-test("a near-free output is answered at once, whatever its price", () => {
-  // Field 2026-10-04: a soundtrack priced at 5.4e-14 s per film second kept
-  // the main thread counting encoders one at a time for minutes.
-  const { admission } = machine({ costs: { sound: 5.36680075607109e-14 }, share: 0.6 });
-  const started = Date.now();
-  const { runs } = admission.placesFor("sound", 0);
-  assert.ok(Date.now() - started < 1_000, "answered without counting one at a time");
-  assert.ok(runs > 1e12 && Number.isFinite(runs), `as many as fit: ${runs}`);
-});
-
-test("the count is the largest that keeps every output at realtime", () => {
-  for (const cost of [0.5, 0.1, 0.03, 0.007, 0.0011]) {
-    for (const share of [null, 1, 0.37]) {
-      const { admission } = machine({ costs: { a: cost, b: PICTURE_1080 / 4 }, running: { b: 1 }, share });
-      const usable = share ?? 1;
-      let expected = 0;
-      while (usable / (PICTURE_1080 / 4 + (expected + 1) * cost) >= 1) {
-        expected += 1;
-      }
-      assert.equal(admission.placesFor("a", 0).runs, Math.max(expected, 0), `cost ${cost}, share ${share}`);
-    }
-  }
-});

package/test/encode-cost.test.js

@@ -1,275 +0,0 @@
-/**
- * @file What encoding costs this machine, asked of the object that owns it.
- *
- * The arithmetic itself is exercised end to end by `auto-quality-step` and
- * `quality-variants`, which go through the session manager. What is pinned here
- * is the seam the move created: this object is given the host's readings as a
- * QUESTION rather than a copy, and it holds what an encoder taught it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EncodeCost } from "../services/encode/quality/EncodeCost.js";
-import { measureSpeed, startRunOn } from "./helpers/encode-run.js";
-import { outputSpec } from "./helpers/output-spec.js";
-import { runStateOf } from "../services/encode/encode-run-state.js";
-import { qualityStateOf } from "../services/encode/quality/OutputQualityState.js";
-
-/**
- * @param {object} [readings]
- * @returns {{ cost: EncodeCost, asked: () => number, host: { share: number } }}
- */
-function costOn(readings = {}) {
-  let asked = 0;
-  const host = { share: 1 };
-  const cost = new EncodeCost({
-    outputs: {
-      familyOf: (session) => readings.familyOf?.(session) ?? [],
-      variantHeightOf: () => 0
-    },
-    host: () => {
-      asked += 1;
-      return {
-        benchmark: readings.benchmark ?? null,
-        decodeModel: null,
-        contentionPenalties: null,
-        availability: { known: true, share: host.share }
-      };
-    },
-    runningEncoders: () => readings.runningEncoders?.() ?? 0,
-    encodersRunningNow: () => 0,
-    torrentCostSecFor: () => 0,
-    runsFor: (session) => [...(session.runs ?? [])],
-    stateFor: (session) => runStateOf(session.runs)
-  });
-  return { cost, asked: () => asked, host };
-}
-
-/**
- * A session with one run going, of the kind this file measures.
- *
- * @param {{ audioOnly?: boolean, transcodeVideo?: boolean, audioSourceTrackIndex?: number, key?: string }} [what]
- * @returns {object}
- */
-function sessionProducing(what = {}) {
-  const session = {
-    id: "1111111122223333",
-    state: "ready",
-    spec: outputSpec({
-      audioOnly: what.audioOnly === true,
-      transcodeVideo: what.transcodeVideo === true,
-      audioSourceTrackIndex: what.audioSourceTrackIndex ?? 0
-    }),
-    file: { key: what.key ?? "torrent:abc:0", name: "film.mkv" },
-    output: { encodeWidth: 0, encodeHeight: 0, outputFps: 25, softwarePreset: null },
-    clock: { at: 1000 },
-    runs: new Set()
-  };
-  startRunOn(session, { from: 0, clock: session.clock });
-  return session;
-}
-
-/**
- * The session's run measures its speed, and is learned from as the product
- * learns: once the run has a reading.
- *
- * @param {EncodeCost} cost
- * @param {object} session
- * @param {number} speedX - Seconds of film produced per second of the run's own work.
- * @param {number} [waitedMs] - How long the run's input waits for the swarm
- *   between two closed pieces.
- * @returns {Promise<void>}
- */
-async function watchItRun(cost, session, speedX, waitedMs = 0) {
-  const run = [...session.runs][0];
-  measureSpeed(run, speedX, session.clock, waitedMs);
-  await cost.learnFrom(session, run);
-}
-
-test("the host is asked at the moment of the question, not when this was built", () => {
-  // The share of the machine that is free is re-read every few seconds. Copied
-  // into this object when it was made, every later rung would be priced against
-  // a machine that has gone.
-  const { cost, asked, host } = costOn();
-  assert.equal(asked(), 0, "nothing is read until something is asked");
-
-  cost.sustainableHeights({ heights: [1080], sourceWidth: 1920, sourceHeight: 1080, fps: 24, source: null, transcodeVideo: true, ownHeight: 0 });
-  const first = asked();
-  assert.ok(first > 0);
-
-  host.share = 0.1;
-  cost.sustainableHeights({ heights: [1080], sourceWidth: 1920, sourceHeight: 1080, fps: 24, source: null, transcodeVideo: true, ownHeight: 0 });
-  assert.ok(asked() > first, "and read again on the next question");
-});
-
-test("with no benchmark to judge by, every height offered is kept", () => {
-  // Nothing measured is not the same as nothing possible. Refusing here would
-  // hide the whole ladder on a host whose startup measurement failed.
-  const { cost } = costOn({ benchmark: null });
-  const kept = cost.sustainableHeights({
-    heights: [1080, 720, 480],
-    sourceWidth: 1920,
-    sourceHeight: 1080,
-    fps: 24,
-    source: null,
-    transcodeVideo: true,
-    ownHeight: 0
-  });
-  assert.deepEqual(kept, [1080, 720, 480]);
-});
-
-test("a rung measured below realtime is withdrawn, and a copied source height is not", () => {
-  const { cost } = costOn({ benchmark: null });
-  const kept = cost.sustainableHeights({
-    heights: [1080, 480],
-    sourceWidth: 1920,
-    sourceHeight: 1080,
-    fps: 24,
-    source: null,
-    // The base copies its picture, so the source height costs no encoder.
-    transcodeVideo: false,
-    ownHeight: 1080,
-    measuredHeights: new Map([[480, 0.4]])
-  });
-  assert.deepEqual(kept, [1080], "the copy stays; the rung seen failing does not");
-});
-
-test("what an encoder taught this host is learned here, and held here", () => {
-  // The three that learn were methods of the session manager, writing into maps
-  // this object owned — one keeper, a different author, and the maps public for
-  // it. Nothing outside can write a price now, and nothing outside needs to.
-  const { cost } = costOn();
-
-  assert.equal(typeof cost.learnFrom, "function");
-  assert.equal(cost.copyCost, undefined, "the store is not the surface");
-  assert.equal(cost.decodeCostFor("torrent:abc:0"), null, "and nothing is known until an encoder says so");
-});
-
-test("a copy is priced from what it was seen doing", async () => {
-  const { cost } = costOn();
-  const session = sessionProducing({ transcodeVideo: false });
-
-  await watchItRun(cost, session, 8);
-
-  assert.equal(cost.copyVersionFor("torrent:abc:0"), 1, "the price is published, so every offer recomputes");
-  assert.equal(
-    qualityStateOf(session).lastAloneSpeed.toFixed(2),
-    "8.00",
-    "and what it did with the machine to itself is on the session, which withdraws a step seen failing"
-  );
-});
-
-test("the time a run's input waited for the swarm is not in the price of this host", async () => {
-  // Field 2026-10-01: a copy waited 32.93 s and 43.91 s for two pieces and read
-  // 0.21x over the clock. Over its own working time it is the machine's speed.
-  const { cost } = costOn();
-  const session = sessionProducing({ transcodeVideo: false });
-
-  await watchItRun(cost, session, 8, 9_000);
-
-  assert.equal(qualityStateOf(session).lastAloneSpeed, 8, "the speed is the run's own, not the swarm's");
-  assert.equal(cost.copyVersionFor("torrent:abc:0"), 1, "and it is filed as what copying costs here");
-});
-
-test("a picture's reading taken beside another encoder is not filed", async () => {
-  // It contains that other encoder's work, and the budget ADDS the same work
-  // again when it predicts — so the price is counted twice and grows with every
-  // reading. Measured in the field 2026-08-15: copying, whose truth is 7.9x, was
-  // learned as 2.03x, and the quality menu collapsed to one height.
-  const { cost } = costOn({ runningEncoders: () => 2 });
-  const session = sessionProducing({ transcodeVideo: false });
-
-  await watchItRun(cost, session, 8);
-
-  assert.equal(cost.copyVersionFor("torrent:abc:0"), 0);
-});
-
-test("a run that has measured nothing teaches nothing", async () => {
-  const { cost } = costOn();
-  const session = sessionProducing({ transcodeVideo: false });
-  const run = [...session.runs][0];
-
-  await cost.learnFrom(session, run);
-
-  assert.equal(run.speedReading, null, "a speed needs two closed pieces of one run");
-  assert.equal(cost.copyVersionFor("torrent:abc:0"), 0);
-});
-
-test("a restarted run starts its own reckoning, so a seek is never read as speed", async () => {
-  // Twenty minutes of film against five seconds of work is a seek, and filed as
-  // a price it admits every step there is. The reading belongs to the run that
-  // made it, so a new run at another place has none until its own pieces close.
-  const { cost } = costOn();
-  const session = sessionProducing({ transcodeVideo: false });
-  session.runs = new Set();
-  const moved = startRunOn(session, { from: 300, clock: session.clock });
-
-  await cost.learnFrom(session, moved);
-
-  assert.equal(cost.copyVersionFor("torrent:abc:0"), 0);
-});
-
-test("two soundtracks of one file are priced apart", async () => {
-  // The key names the TRACK, not the file. A dub and the original run at
-  // different speeds — different codecs, different channel counts — and one key
-  // for both files each over the other's readings.
-  const { cost } = costOn();
-  const first = sessionProducing({ audioOnly: true });
-  const second = sessionProducing({ audioOnly: true, audioSourceTrackIndex: 1 });
-
-  await watchItRun(cost, first, 40);
-
-  assert.equal(cost.audioVersionFor(first), 1);
-  assert.equal(cost.audioVersionFor(second), 0, "the other track has been told nothing about itself");
-});
-
-test("a soundtrack's own share is what is left after everything else running is paid for", async () => {
-  // A rendition runs for exactly as long as the picture it accompanies, so
-  // "alone" is a state it is never in and the price stayed unmeasured for ever.
-  // Its share is recovered by subtracting what the machine is already known to
-  // be spending — which is only possible once that other work HAS a price.
-  const picture = sessionProducing({ transcodeVideo: false });
-  const sound = sessionProducing({ audioOnly: true });
-  let running = 1;
-  const { cost } = costOn({
-    runningEncoders: () => running,
-    familyOf: () => [picture, sound]
-  });
-
-  // The picture alone first, so copying has a price: 8x, i.e. 0.125 s/s.
-  await watchItRun(cost, picture, 8);
-  assert.equal(cost.copyVersionFor("torrent:abc:0"), 1);
-
-  // Now the pair. The reading off the soundtrack contains both, at 4x — 0.25 s/s
-  // together — so the sound's own share is 0.25 − 0.125 = 0.125 s/s.
-  running = 2;
-  await watchItRun(cost, sound, 4);
-
-  assert.equal(cost.audioVersionFor(sound), 1, "the soundtrack has a price at last");
-  // What was filed, read back the way the product reads it: the sum of what
-  // everything OTHER than the picture is costing. Charged the whole reading
-  // instead of its own share, a soundtrack is priced at twice the truth and
-  // refuses quality steps the host could hold.
-  running = 1;
-  assert.equal(
-    cost.pricedConcurrentCost(picture).toFixed(3),
-    "0.125",
-    "0.25 s/s together, less the 0.125 s/s the copy was already known to cost"
-  );
-});
-
-test("nothing is attributed to a soundtrack while something running has no price", async () => {
-  const picture = sessionProducing({ transcodeVideo: true });
-  const sound = sessionProducing({ audioOnly: true });
-  const { cost } = costOn({
-    runningEncoders: () => 2,
-    // A re-encoded picture with no benchmark to price it by and no speed of its
-    // own: unpriced work, which would otherwise land in the soundtrack's account
-    // and refuse quality steps on it.
-    familyOf: () => [picture, sound]
-  });
-
-  await watchItRun(cost, sound, 4);
-
-  assert.equal(cost.audioVersionFor(sound), 0);
-});

package/test/encode-exit.test.js

@@ -1,111 +0,0 @@
-/**
- * @file The four things an ffmpeg exit can mean, by their field cases.
- *
- * Each test names the release the classification cost. None of them needs a
- * process: what went wrong in every case was the reading of the exit, not the
- * handling of it.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { ENCODE_EXIT, classifyEncodeExit } from "../services/encode/encode-exit.js";
-
-test("the predecessor a seek kills says nothing about the session", () => {
-  // The handler decides "is this exit mine" by comparing against the session's
-  // current process — and during a restart that field still names the process
-  // being killed, because the replacement is spawned afterwards. So a SIGKILLed
-  // predecessor passed the check and was read as the session's own run dying:
-  // a spurious "failed" that a segment request landing in that window is
-  // answered 500 for, and on a hardware host a permanent downgrade to libx264.
-  assert.equal(
-    classifyEncodeExit({ superseded: true, code: null, inputUnavailable: false }),
-    ENCODE_EXIT.IGNORED
-  );
-  // Including when it looks like a clean finish.
-  assert.equal(classifyEncodeExit({ superseded: true, code: 0 }), ENCODE_EXIT.IGNORED);
-});
-
-test("exit 0 short of the last segment is a failure, not a finished file", () => {
-  // 2.9.104. A run that had made 188 segments of 624 reported itself complete,
-  // the player consumed what was on disk and froze on the first segment nobody
-  // was making.
-  assert.equal(
-    classifyEncodeExit({ code: 0, producedThrough: 188, lastSegmentIndex: 623 }),
-    ENCODE_EXIT.SHORT
-  );
-  assert.equal(
-    classifyEncodeExit({ code: 0, producedThrough: 623, lastSegmentIndex: 623 }),
-    ENCODE_EXIT.COMPLETE
-  );
-});
-
-test("exit 0 is complete when there is nothing to check it against", () => {
-  // No published last segment, or nothing readable on disk: the claim cannot be
-  // contradicted, so it stands. Guessing "short" here would fail every session
-  // whose directory could not be read.
-  assert.equal(classifyEncodeExit({ code: 0, producedThrough: null, lastSegmentIndex: 623 }), ENCODE_EXIT.COMPLETE);
-  assert.equal(classifyEncodeExit({ code: 0, producedThrough: 12, lastSegmentIndex: null }), ENCODE_EXIT.COMPLETE);
-});
-
-test("data that went away is recoverable, and is not an encoder fault", () => {
-  // Field 2026-08-06: a torrent evicted mid-seek took the film with it, the run
-  // died on `File 0 not found`, and the session answered 500 from then on while
-  // the swarm was there and the data would have come back in seconds.
-  assert.equal(
-    classifyEncodeExit({ code: 1, inputUnavailable: true }),
-    ENCODE_EXIT.INPUT_LOST
-  );
-  // And the distinction is what keeps a working hardware encoder: the caller
-  // downgrades to software on FAILED, so an input that vanished must not
-  // arrive there.
-  assert.notEqual(classifyEncodeExit({ code: 1, inputUnavailable: true }), ENCODE_EXIT.FAILED);
-});
-
-test("anything else is a failure of this target", () => {
-  assert.equal(classifyEncodeExit({ code: 1, inputUnavailable: false }), ENCODE_EXIT.FAILED);
-  assert.equal(classifyEncodeExit({ code: null, inputUnavailable: false }), ENCODE_EXIT.FAILED);
-});
-
-test("every combination answers, and no input produces undefined", () => {
-  for (const superseded of [true, false]) {
-    for (const code of [0, 1, null]) {
-      for (const producedThrough of [null, 0, 10]) {
-        for (const lastSegmentIndex of [null, 0, 10]) {
-          for (const inputUnavailable of [true, false]) {
-            const answer = classifyEncodeExit({
-              superseded,
-              code,
-              producedThrough,
-              lastSegmentIndex,
-              inputUnavailable
-            });
-            assert.ok(
-              Object.values(ENCODE_EXIT).includes(answer),
-              `answered ${String(answer)} for ${JSON.stringify({ superseded, code, producedThrough, lastSegmentIndex, inputUnavailable })}`
-            );
-          }
-        }
-      }
-    }
-  }
-  assert.ok(Object.values(ENCODE_EXIT).includes(classifyEncodeExit()));
-});
-
-test("a run that made nothing has not finished, whatever its exit code", () => {
-  // Field 2026-09-11: a run given #541..#541 was handed a start later than its
-  // own end, wrote 190 bytes that are not a fragment, and exited zero. Making
-  // no segment and being unable to read the directory were the same `null`, and
-  // the second reading — "cannot be contradicted, so it stands" — was applied
-  // to the first.
-  assert.equal(
-    classifyEncodeExit({ code: 0, producedThrough: null, producedCount: 0, lastSegmentIndex: 541 }),
-    ENCODE_EXIT.SHORT
-  );
-  // And the case that reading was written for still stands: nothing readable on
-  // disk is not a claim that nothing was made.
-  assert.equal(
-    classifyEncodeExit({ code: 0, producedThrough: null, producedCount: null, lastSegmentIndex: 623 }),
-    ENCODE_EXIT.COMPLETE
-  );
-});