@torrent-tv/proxy 2.86.0 → 2.87.0

package/test/decode-cost.test.js

@@ -23,12 +23,13 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { Timeline } from "../services/output/Timeline.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
-import { decodeCostOf, decodeFamilyOf } from "../services/decode-cost-fit.js";
-import { Output } from "../services/output/Output.js";
+import { decodeCostOf, decodeFamilyOf } from "../services/encode/decode-cost-fit.js";
+import { Output } from "../services/encode/output/Output.js";
+import { outputSpec } from "./helpers/output-spec.js";
 import os from "node:os";
 import path from "node:path";
 import {
@@ -36,11 +37,11 @@ import {
   decodeSpeedFor,
   predictedRealtimeSpeed,
   speedBar
-} from "../services/hwaccel.js";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { SourceFile, sourceDecodeCharacteristics } from "../services/source/SourceFile.js";
-import { parseFfmpegBitrateKbps, parseFfmpegVideoDimensions, parseFfmpegVideoFps } from "../services/ffmpeg-banner.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+} from "../services/encode/hwaccel.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { SourceFile, sourceDecodeCharacteristics } from "../services/media/SourceFile.js";
+import { parseFfmpegBitrateKbps, parseFfmpegVideoDimensions, parseFfmpegVideoFps } from "../services/media/ffmpeg-banner.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 
 const require = createRequire(import.meta.url);
 const ffmpegBin = require("ffmpeg-static");
@@ -187,15 +188,22 @@ test("an observation prices a host whose clips were never fitted", () => {
   assert.ok(priced.speed < 1, `priced ${priced.speed?.toFixed(2)}x`);
 });
 
-test("nothing measured means nothing refused", () => {
-  const verdict = canSustainOutput({
-    benchmark: [],
+test("not calibrated means nothing judged; calibrated with nothing qualified means refused", () => {
+  const uncalibrated = canSustainOutput({
+    benchmark: null,
     decodeModel: null,
     source: null,
     outputPixelsPerSec: 1920 * 1080 * 24
   });
+  assert.deepEqual(uncalibrated, { speed: null, sustainable: true });
 
-  assert.deepEqual(verdict, { speed: null, sustainable: true });
+  const nothingQualified = canSustainOutput({
+    benchmark: [],
+    decodeModel: null,
+    source: null,
+    outputPixelsPerSec: 1920 * 1080 * 24
+  });
+  assert.deepEqual(nothingQualified, { speed: null, sustainable: false });
 });
 
 test("a real ffmpeg banner reads into the figures the budget prices", async () => {
@@ -285,7 +293,7 @@ test("the source's decode figures come off the probe, or not at all", () => {
 
 test("the OFFER drops the rungs the host cannot hold, and the master keeps addressing them", async (t) => {
   const dirPath = await mkdtemp(path.join(os.tmpdir(), "decode-cost-"));
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -296,12 +304,13 @@ test("the OFFER drops the rungs the host cannot hold, and the master keeps addre
     decodeCostModel: ADDON_HOST_MODEL
   });
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
 
   const session = {
-    id: "cccccccc-dddd-eeee-ffff-000000000000",
+    id: "ccccccccddddeeee",
+    spec: outputSpec({ transcodeVideo: false, cutGrid: "keyframe" }),
     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.
@@ -348,10 +357,10 @@ test("the OFFER drops the rungs the host cannot hold, and the master keeps addre
     segmentCount: 100,
     progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
   };
-  manager.sessionsById.set(session.id, session);
+  manager.outputs.set(session.id, session);
 
   assert.deepEqual(
-    manager.offeredHeights(session),
+    manager.quality.offeredHeights(session),
     [1080],
     "every rung under the copy runs below realtime here, so there is nothing to switch to"
   );
@@ -360,7 +369,7 @@ test("the OFFER drops the rungs the host cannot hold, and the master keeps addre
   // session's life: the browser is handed its address at creation, and a live
   // figure that withdrew it left a session answering 404 to itself (field
   // 2026-08-18, "Moana (2016).mkv" — nothing played at all).
-  const weakMaster = manager.buildMasterPlaylist(session.id);
+  const weakMaster = manager.renditions.buildMasterPlaylist(session.id);
   assert.ok(weakMaster, "published once, whatever the host is managing this second");
   assert.deepEqual(
     [...weakMaster.matchAll(/^v\/(\d+)\/index\.m3u8$/gm)].map((match) => Number(match[1])),
@@ -371,14 +380,14 @@ test("the OFFER drops the rungs the host cannot hold, and the master keeps addre
   // A host with a little more encoder keeps the rungs it can actually hold. A
   // second session, because the answer is settled once per session.
   manager.softwarePresetBenchmark = [{ preset: "ultrafast", pixelsPerSec: 12e6 }];
-  const stronger = { ...session, id: "dddddddd-eeee-ffff-0000-111111111111", offeredHeightsCache: undefined };
-  manager.sessionsById.set(stronger.id, stronger);
+  const stronger = { ...session, id: "ddddddddeeeeffff", offeredHeightsCache: undefined };
+  manager.outputs.set(stronger.id, stronger);
   assert.deepEqual(
-    manager.offeredHeights(stronger),
+    manager.quality.offeredHeights(stronger),
     [1080, 360, 240],
     "nothing is known about this swarm, so the bar is realtime"
   );
-  const master = manager.buildMasterPlaylist(stronger.id);
+  const master = manager.renditions.buildMasterPlaylist(stronger.id);
   assert.ok(master, "1080p copied plus every rung that can be spliced beside it");
   assert.deepEqual(
     [...master.matchAll(/^v\/(\d+)\/index\.m3u8$/gm)].map((match) => Number(match[1])),
@@ -391,13 +400,13 @@ test("the OFFER drops the rungs the host cannot hold, and the master keeps addre
   // 1.67x of any step, and the rungs that only just cleared realtime go.
   const onAThinSwarm = {
     ...stronger,
-    id: "eeeeeeee-ffff-0000-1111-222222222222",
+    id: "eeeeeeeeffff0000",
     offeredHeightsCache: undefined,
     supplyFigures: { requiredSpeed: 1.67, worstWaitSec: 1.49, medianIntervalSec: 2.22, samples: 12 }
   };
-  manager.sessionsById.set(onAThinSwarm.id, onAThinSwarm);
+  manager.outputs.set(onAThinSwarm.id, onAThinSwarm);
   assert.deepEqual(
-    manager.offeredHeights(onAThinSwarm),
+    manager.quality.offeredHeights(onAThinSwarm),
     [1080],
     "the copied height costs no encoder and stays; nothing re-encoded survives that supply"
   );

package/test/delivery-probe.test.js

@@ -7,7 +7,7 @@ import {
   readProbeState,
   PROBE_INTERVAL_MS,
   UNRELIABLE_LABEL
-} from "../services/delivery-probe.js";
+} from "../services/transport/delivery-probe.js";
 
 const ORDERED = ["proxy", "proxy-control"];
 const ALL = [...ORDERED, UNRELIABLE_LABEL];

package/test/demand-register.test.js

@@ -9,15 +9,15 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { DemandRegister } from "../services/demand/DemandRegister.js";
-import { unionOf, Window } from "../services/demand/Window.js";
+import { DemandRegister } from "../services/torrent/demand/DemandRegister.js";
+import { unionOf, Window } from "../services/torrent/demand/Window.js";
 import {
   isConditional,
   mayDisplaceSlowPeer,
   selectionPriority,
   Urgency
-} from "../services/demand/Urgency.js";
-import { nearestFirst, piecesNeededFor, piecesOf, piecesWithin } from "../services/demand/pieces.js";
+} from "../services/torrent/demand/Urgency.js";
+import { nearestFirst, piecesNeededFor, piecesOf, piecesWithin } from "../services/torrent/demand/pieces.js";
 
 const MEGABYTE = 1024 * 1024;
 

package/test/dht-bootstrap.test.js

@@ -14,7 +14,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { dhtNodeCount, parseBootstrapEntry, resolveDhtBootstrap } from "../services/torrent-pool.js";
+import { dhtNodeCount, parseBootstrapEntry, resolveDhtBootstrap } from "../services/torrent/torrent-pool.js";
 
 test("a bootstrap entry is split into host and port", () => {
   assert.deepEqual(parseBootstrapEntry("dht.libtorrent.org:25401"), {

package/test/drain-threat.test.js

@@ -0,0 +1,65 @@
+/**
+ * @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

@@ -17,7 +17,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { duplicateAddDecision } from "../services/torrent-pool.js";
+import { duplicateAddDecision } from "../services/torrent/torrent-pool.js";
 
 test("a ready torrent is adopted, whatever the new source carries", () => {
   assert.equal(

package/test/encode-admission.test.js

@@ -0,0 +1,146 @@
+/**
+ * @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/);
+});

package/test/encode-cost.test.js

@@ -9,7 +9,11 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { EncodeCost } from "../services/quality/EncodeCost.js";
+import { EncodeCost } from "../services/encode/quality/EncodeCost.js";
+import { 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]
@@ -19,7 +23,10 @@ function costOn(readings = {}) {
   let asked = 0;
   const host = { share: 1 };
   const cost = new EncodeCost({
-    liveOutputs: { familyOf: () => [], variantHeightOf: () => 0 },
+    outputs: {
+      familyOf: (session) => readings.familyOf?.(session) ?? [],
+      variantHeightOf: () => 0
+    },
     host: () => {
       asked += 1;
       return {
@@ -29,14 +36,60 @@ function costOn(readings = {}) {
         availability: { known: true, share: host.share }
       };
     },
-    audioCostKey: () => "audio",
-    runningEncoders: () => 0,
+    runningEncoders: () => readings.runningEncoders?.() ?? 0,
     encodersRunningNow: () => 0,
-    torrentCostSecFor: () => 0
+    torrentCostSecFor: () => 0,
+    boundBy: async () => readings.boundBy ?? "cpu",
+    runsFor: (session) => [...(session.runs ?? [])],
+    stateFor: (session) => runStateOf(session.runs),
+    progressFor: (session) => session.progress ?? null
   });
   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 },
+    progress: { processedSeconds: 0 },
+    runs: new Set()
+  };
+  startRunOn(session, { from: 0, speedX: 1 });
+  return session;
+}
+
+/**
+ * Two readings of one run, far enough apart to be a speed.
+ *
+ * @param {EncodeCost} cost
+ * @param {object} session
+ * @param {number} speedX - Seconds of film produced per second of clock.
+ * @returns {Promise<void>}
+ */
+async function watchItRun(cost, session, speedX) {
+  session.progress.processedSeconds = 0;
+  await cost.learnFrom(session);
+  // The pair is a DELTA, and the first reading has nothing to be a delta from.
+  // Backdated rather than waited for: the window a speed may be read over is
+  // seconds, and a test that sleeps through it measures the clock.
+  qualityStateOf(session).learnSample.takenAt -= 10_000;
+  session.progress.processedSeconds = 10 * speedX;
+  await cost.learnFrom(session);
+}
+
 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
@@ -85,10 +138,146 @@ test("a rung measured below realtime is withdrawn, and a copied source height is
   assert.deepEqual(kept, [1080], "the copy stays; the rung seen failing does not");
 });
 
-test("what an encoder taught this host is held here, and nowhere else", () => {
+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();
-  cost.copyCost.set("torrent:abc:0", { costSec: 0.125, readings: [8], version: 1 });
-  assert.equal(cost.copyCost.get("torrent:abc:0").costSec, 0.125);
-  assert.equal(cost.audioCost.size, 0);
-  assert.equal(cost.decodeCost.size, 0);
+  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("a reading taken while the swarm is short is not filed as the price of this host", async () => {
+  // A run starved of torrent data reports a speed that measures the swarm. Filed
+  // as a price it reads as more work per second than the machine has, and every
+  // quality step is then refused on the download's account.
+  const { cost } = costOn({ boundBy: "download" });
+  const session = sessionProducing({ transcodeVideo: false });
+
+  await watchItRun(cost, session, 0.3);
+
+  assert.equal(cost.copyVersionFor("torrent:abc:0"), 0, "nothing was learned about the machine");
+  assert.equal(qualityStateOf(session).lastAloneSpeed, undefined, "and nothing claims this rung was seen failing");
+});
+
+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("one reading is not a speed", async () => {
+  const { cost } = costOn();
+  const session = sessionProducing({ transcodeVideo: false });
+  session.progress.processedSeconds = 40;
+
+  await cost.learnFrom(session);
+
+  assert.equal(cost.copyVersionFor("torrent:abc:0"), 0, "a delta needs two readings of one run");
+  assert.ok(qualityStateOf(session).learnSample, "and the first is kept to be the other half of the next");
+});
+
+test("a pair that straddles a restart measures the seek, not the host", async () => {
+  const { cost } = costOn();
+  const session = sessionProducing({ transcodeVideo: false });
+  await cost.learnFrom(session);
+  qualityStateOf(session).learnSample.takenAt -= 10_000;
+  // A new run, at another place in the film: twenty minutes of film against five
+  // seconds of clock is a seek, and filed as a price it admits every step there
+  // is.
+  session.runs = new Set();
+  startRunOn(session, { from: 300, speedX: 1 });
+  session.progress.processedSeconds = 1200;
+
+  await cost.learnFrom(session);
+
+  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);
 });