@torrent-tv/proxy 2.88.4 → 2.88.6

package/test/helpers/manager.js

@@ -1,57 +1,57 @@
-/**
- * @file A session manager for a test, with a store of its own.
- *
- * ONE MANAGER, ONE ROOT. In production that is true by construction: one
- * process holds one manager, and the store's root is a fixed path so that a
- * restart can find what the process before it finished (`SegmentStore.sweep`).
- * Under `node --test` it is false — the runner starts one PROCESS PER FILE and
- * runs them in parallel, so every manager built without a store of its own
- * shared the one default root with every other file running at that moment.
- *
- * What that cost, measured 2026-09-14: `disposeAll` removes the store's whole
- * root, and four files call it between them 40 times. Running the twenty-one
- * files that build a manager gave 2, 3 and 4 failures on consecutive runs and
- * zero with `--test-concurrency=1`; the victim was always
- * `segment-serve-wiring.test.js`, reporting a segment missing that it had
- * written itself a moment earlier, because another process had deleted the
- * directory under it. `npm test` is `node --test`, so this was the project's
- * own test command, and it is why a red result had become something to read
- * past rather than to act on.
- *
- * A test that fails by luck is worse than one that does not exist: it costs a
- * run every time, and it trains everyone to ignore red.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { wireOutputs } from "../../services/server/wire-outputs.js";
-import { SegmentStore } from "../../services/storage/segment-store/SegmentStore.js";
-
-/**
- * A manager whose produced segments live where nothing else can reach them.
- *
- * @param {object} [options] - Passed to the manager, over the defaults below.
- *   A `segmentStore` given here wins, for a test that wants to watch the store
- *   itself.
- * @returns {{ manager: object, store: SegmentStore, root: string,
- *   cleanup: () => void }} `cleanup` removes the root; call it from `t.after`.
- */
-export function managerWithOwnStore(options = {}) {
-  const root = mkdtempSync(path.join(os.tmpdir(), "ttv-store-"));
-  const store = options.segmentStore ?? new SegmentStore({ root });
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    ...options,
-    segmentStore: store
-  });
-  return {
-    manager,
-    store,
-    root,
-    cleanup: () => rmSync(root, { recursive: true, force: true })
-  };
-}
+/**
+ * @file A session manager for a test, with a store of its own.
+ *
+ * ONE MANAGER, ONE ROOT. In production that is true by construction: one
+ * process holds one manager, and the store's root is a fixed path so that a
+ * restart can find what the process before it finished (`SegmentStore.sweep`).
+ * Under `node --test` it is false — the runner starts one PROCESS PER FILE and
+ * runs them in parallel, so every manager built without a store of its own
+ * shared the one default root with every other file running at that moment.
+ *
+ * What that cost, measured 2026-09-14: `disposeAll` removes the store's whole
+ * root, and four files call it between them 40 times. Running the twenty-one
+ * files that build a manager gave 2, 3 and 4 failures on consecutive runs and
+ * zero with `--test-concurrency=1`; the victim was always
+ * `segment-serve-wiring.test.js`, reporting a segment missing that it had
+ * written itself a moment earlier, because another process had deleted the
+ * directory under it. `npm test` is `node --test`, so this was the project's
+ * own test command, and it is why a red result had become something to read
+ * past rather than to act on.
+ *
+ * A test that fails by luck is worse than one that does not exist: it costs a
+ * run every time, and it trains everyone to ignore red.
+ */
+
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { wireOutputs } from "../../services/server/wire-outputs.js";
+import { SegmentStore } from "../../services/storage/segment-store/SegmentStore.js";
+
+/**
+ * A manager whose produced segments live where nothing else can reach them.
+ *
+ * @param {object} [options] - Passed to the manager, over the defaults below.
+ *   A `segmentStore` given here wins, for a test that wants to watch the store
+ *   itself.
+ * @returns {{ manager: object, store: SegmentStore, root: string,
+ *   cleanup: () => void }} `cleanup` removes the root; call it from `t.after`.
+ */
+export function managerWithOwnStore(options = {}) {
+  const root = mkdtempSync(path.join(os.tmpdir(), "ttv-store-"));
+  const store = options.segmentStore ?? new SegmentStore({ root });
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090,
+    ...options,
+    segmentStore: store
+  });
+  return {
+    manager,
+    store,
+    root,
+    cleanup: () => rmSync(root, { recursive: true, force: true })
+  };
+}

package/test/helpers/output-spec.js

@@ -1,63 +1,63 @@
-import { AudioOutput, CutGrid, OutputSpec, VideoOutput } from "../../services/encode/output/OutputSpec.js";
-
-/**
- * Build the output identity used by production objects in focused tests.
- *
- * @param {object} [params]
- * @param {string} [params.sourceKey]
- * @param {number} [params.fileIndex]
- * @param {boolean} [params.transcodeVideo]
- * @param {boolean} [params.transcodeAudio]
- * @param {boolean} [params.audioOnly]
- * @param {boolean} [params.audioSeparate]
- * @param {number} [params.audioFileIndex]
- * @param {number} [params.audioSourceTrackIndex]
- * @param {number} [params.width]
- * @param {number} [params.height]
- * @param {string} [params.encoder]
- * @param {number} [params.fps]
- * @param {string | null} [params.preset]
- * @param {boolean} [params.tonemap]
- * @param {{ maxrateKbps: number, bufsizeKbps: number, level: string | null } | null} [params.rateControl]
- * @param {"keyframe" | "uniform"} [params.cutGrid]
- * @param {string} [params.segmentFormatId]
- * @returns {OutputSpec}
- */
-export function outputSpec({
-  sourceKey = "source-1",
-  fileIndex = 0,
-  transcodeVideo = false,
-  transcodeAudio = true,
-  audioOnly = false,
-  audioSeparate = false,
-  audioFileIndex = fileIndex,
-  audioSourceTrackIndex = 0,
-  width = 0,
-  height = 0,
-  encoder = "libx264",
-  fps = 24,
-  preset = null,
-  tonemap = false,
-  rateControl = null,
-  cutGrid = "uniform",
-  segmentFormatId = "fmp4"
-} = {}) {
-  return new OutputSpec({
-    sourceKey,
-    segmentFormatId,
-    grid: new CutGrid({ kind: cutGrid, fileIndex }),
-    video: audioOnly
-      ? null
-      : new VideoOutput({
-          fileIndex,
-          encode: transcodeVideo ? { encoder, width, height, fps, preset, tonemap, rateControl } : null
-        }),
-    audio: audioSeparate
-      ? null
-      : new AudioOutput({
-          fileIndex: audioFileIndex,
-          trackIndex: audioSourceTrackIndex,
-          transcode: transcodeAudio
-        })
-  });
-}
+import { AudioOutput, CutGrid, OutputSpec, VideoOutput } from "../../services/encode/output/OutputSpec.js";
+
+/**
+ * Build the output identity used by production objects in focused tests.
+ *
+ * @param {object} [params]
+ * @param {string} [params.sourceKey]
+ * @param {number} [params.fileIndex]
+ * @param {boolean} [params.transcodeVideo]
+ * @param {boolean} [params.transcodeAudio]
+ * @param {boolean} [params.audioOnly]
+ * @param {boolean} [params.audioSeparate]
+ * @param {number} [params.audioFileIndex]
+ * @param {number} [params.audioSourceTrackIndex]
+ * @param {number} [params.width]
+ * @param {number} [params.height]
+ * @param {string} [params.encoder]
+ * @param {number} [params.fps]
+ * @param {string | null} [params.preset]
+ * @param {boolean} [params.tonemap]
+ * @param {{ maxrateKbps: number, bufsizeKbps: number, level: string | null } | null} [params.rateControl]
+ * @param {"keyframe" | "uniform"} [params.cutGrid]
+ * @param {string} [params.segmentFormatId]
+ * @returns {OutputSpec}
+ */
+export function outputSpec({
+  sourceKey = "source-1",
+  fileIndex = 0,
+  transcodeVideo = false,
+  transcodeAudio = true,
+  audioOnly = false,
+  audioSeparate = false,
+  audioFileIndex = fileIndex,
+  audioSourceTrackIndex = 0,
+  width = 0,
+  height = 0,
+  encoder = "libx264",
+  fps = 24,
+  preset = null,
+  tonemap = false,
+  rateControl = null,
+  cutGrid = "uniform",
+  segmentFormatId = "fmp4"
+} = {}) {
+  return new OutputSpec({
+    sourceKey,
+    segmentFormatId,
+    grid: new CutGrid({ kind: cutGrid, fileIndex }),
+    video: audioOnly
+      ? null
+      : new VideoOutput({
+          fileIndex,
+          encode: transcodeVideo ? { encoder, width, height, fps, preset, tonemap, rateControl } : null
+        }),
+    audio: audioSeparate
+      ? null
+      : new AudioOutput({
+          fileIndex: audioFileIndex,
+          trackIndex: audioSourceTrackIndex,
+          transcode: transcodeAudio
+        })
+  });
+}

package/test/host-load.test.js

@@ -1,68 +1,68 @@
-/**
- * @file The arithmetic that turns two readings of the machine into shares.
- *
- * The readings themselves are files this host may or may not have; what is
- * tested here is what is DERIVED from them, because that is where a wrong
- * number would quietly become a wrong conclusion about why an encoder is slow.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { readProcessCpuSeconds, readSystemCpu, sampleHost, shareOfMachine } from "../services/encode/host-load.js";
-
-test("a process using one core of four for a second reports a quarter of the machine", () => {
-  const before = { takenAt: 1_000, processCpuSeconds: 10, system: null };
-  const after = { takenAt: 2_000, processCpuSeconds: 11, system: null };
-  const share = shareOfMachine(before, after, 4);
-  assert.equal(share?.elapsedSec, 1);
-  assert.equal(share?.processShare, 0.25);
-});
-
-test("a process using every core reports the whole machine", () => {
-  const share = shareOfMachine(
-    { takenAt: 0, processCpuSeconds: 0, system: null },
-    { takenAt: 2_000, processCpuSeconds: 8, system: null },
-    4
-  );
-  assert.equal(share?.processShare, 1);
-});
-
-test("waiting for a disk is counted apart from working", () => {
-  const before = { takenAt: 0, processCpuSeconds: null, system: { busySeconds: 100, idleSeconds: 900, iowaitSeconds: 10 } };
-  const after = { takenAt: 1_000, processCpuSeconds: null, system: { busySeconds: 101, idleSeconds: 902, iowaitSeconds: 11 } };
-  const share = shareOfMachine(before, after, 4);
-  assert.equal(share?.systemShare, 0.25);
-  assert.equal(share?.iowaitShare, 0.25);
-});
-
-test("two readings taken at the same instant say nothing rather than dividing by zero", () => {
-  assert.equal(shareOfMachine({ takenAt: 5, processCpuSeconds: 1, system: null }, { takenAt: 5, processCpuSeconds: 2, system: null }, 4), null);
-});
-
-test("a missing reading leaves that share unknown, not zero", () => {
-  const share = shareOfMachine(
-    { takenAt: 0, processCpuSeconds: null, system: null },
-    { takenAt: 1_000, processCpuSeconds: 1, system: null },
-    4
-  );
-  assert.equal(share?.processShare, null);
-  assert.equal(share?.systemShare, null);
-});
-
-test("a process that does not exist reports nothing at all", async () => {
-  assert.equal(await readProcessCpuSeconds(0), null);
-  assert.equal(await readProcessCpuSeconds(-1), null);
-  // A pid far above any real one on this machine.
-  assert.equal(await readProcessCpuSeconds(4_000_000), null);
-});
-
-test("on a host without /proc the readings are null and the sampler still answers", async () => {
-  // This runs on Linux in CI and on Windows here; both must be safe. What is
-  // asserted is the SHAPE — a reading is either a number or null, never a throw.
-  const system = await readSystemCpu();
-  assert.ok(system === null || typeof system.busySeconds === "number");
-  const sample = await sampleHost(null);
-  assert.equal(typeof sample.takenAt, "number");
-  assert.equal(sample.processCpuSeconds, null);
-});
+/**
+ * @file The arithmetic that turns two readings of the machine into shares.
+ *
+ * The readings themselves are files this host may or may not have; what is
+ * tested here is what is DERIVED from them, because that is where a wrong
+ * number would quietly become a wrong conclusion about why an encoder is slow.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { readProcessCpuSeconds, readSystemCpu, sampleHost, shareOfMachine } from "../services/encode/host-load.js";
+
+test("a process using one core of four for a second reports a quarter of the machine", () => {
+  const before = { takenAt: 1_000, processCpuSeconds: 10, system: null };
+  const after = { takenAt: 2_000, processCpuSeconds: 11, system: null };
+  const share = shareOfMachine(before, after, 4);
+  assert.equal(share?.elapsedSec, 1);
+  assert.equal(share?.processShare, 0.25);
+});
+
+test("a process using every core reports the whole machine", () => {
+  const share = shareOfMachine(
+    { takenAt: 0, processCpuSeconds: 0, system: null },
+    { takenAt: 2_000, processCpuSeconds: 8, system: null },
+    4
+  );
+  assert.equal(share?.processShare, 1);
+});
+
+test("waiting for a disk is counted apart from working", () => {
+  const before = { takenAt: 0, processCpuSeconds: null, system: { busySeconds: 100, idleSeconds: 900, iowaitSeconds: 10 } };
+  const after = { takenAt: 1_000, processCpuSeconds: null, system: { busySeconds: 101, idleSeconds: 902, iowaitSeconds: 11 } };
+  const share = shareOfMachine(before, after, 4);
+  assert.equal(share?.systemShare, 0.25);
+  assert.equal(share?.iowaitShare, 0.25);
+});
+
+test("two readings taken at the same instant say nothing rather than dividing by zero", () => {
+  assert.equal(shareOfMachine({ takenAt: 5, processCpuSeconds: 1, system: null }, { takenAt: 5, processCpuSeconds: 2, system: null }, 4), null);
+});
+
+test("a missing reading leaves that share unknown, not zero", () => {
+  const share = shareOfMachine(
+    { takenAt: 0, processCpuSeconds: null, system: null },
+    { takenAt: 1_000, processCpuSeconds: 1, system: null },
+    4
+  );
+  assert.equal(share?.processShare, null);
+  assert.equal(share?.systemShare, null);
+});
+
+test("a process that does not exist reports nothing at all", async () => {
+  assert.equal(await readProcessCpuSeconds(0), null);
+  assert.equal(await readProcessCpuSeconds(-1), null);
+  // A pid far above any real one on this machine.
+  assert.equal(await readProcessCpuSeconds(4_000_000), null);
+});
+
+test("on a host without /proc the readings are null and the sampler still answers", async () => {
+  // This runs on Linux in CI and on Windows here; both must be safe. What is
+  // asserted is the SHAPE — a reading is either a number or null, never a throw.
+  const system = await readSystemCpu();
+  assert.ok(system === null || typeof system.busySeconds === "number");
+  const sample = await sampleHost(null);
+  assert.equal(typeof sample.takenAt, "number");
+  assert.equal(sample.processCpuSeconds, null);
+});

package/test/index-accuracy-is-about-the-file.test.js

@@ -1,128 +1,128 @@
-/**
- * @file What a produced piece reveals, and WHOSE fact it is.
- *
- * One reading is taken — how far a produced piece began from where its grid
- * said it would — and three different facts are drawn from it, which the code
- * that draws them already stated in its own three branches:
- *
- * 1. a COPIED picture can only be cut where a keyframe already is, so a
- *    disagreement says the container's keyframe TABLE describes times the file
- *    does not have. A fact of the FILE;
- * 2. a RE-ENCODED rung was told to put a keyframe at that instant and did not,
- *    so its pieces no longer stand where the stream it accompanies would have
- *    put them. A fact of that OUTPUT;
- * 3. a SOUNDTRACK is cut exactly where it is asked to be, to within an audio
- *    frame, so it says nothing about any keyframe at all — only that the
- *    picture's grid has moved under a run already going. A fact of that OUTPUT.
- *
- * Until 2026-09-15 all three went into ONE tally, and the tally was on the cut
- * table — which is held per (file, grid), so a picture and the soundtrack muxed
- * into the same file shared it. Three consequences, and these checks are about
- * all of them: the file's finding died with a grid it does not belong to, one
- * output's reading of a piece number silenced another's reading of its own, and
- * the summary could not say which of the three facts it was summarising.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Timeline, Timelines } from "../services/encode/output/Timeline.js";
-import { Output } from "../services/encode/output/Output.js";
-import { KeyframeTable } from "../services/media/container/KeyframeTable.js";
-
-const KEYFRAMES = [0, 4.004, 8.008, 12.012, 16.016];
-const TOLERANCE = 0.25;
-
-/**
- * @param {number[]} boundaries
- * @returns {Timeline}
- */
-function timelineOver(boundaries) {
-  return new Timeline({ boundaries: [...boundaries], cutGrid: "keyframe" });
-}
-
-/**
- * @returns {Output}
- */
-function anOutput() {
-  return new Output({
-    encodeWidth: 0,
-    encodeHeight: 0,
-    outputFps: 25,
-    softwarePreset: null,
-    applyTonemap: false
-  });
-}
-
-test("a picture and the soundtrack inside the same file share one cut table, and no longer one tally", () => {
-  // Sharing the table is right — it is what makes them cut at the same instants
-  // and is the whole reason it is held per file and grid. What must not be
-  // shared is what each of them LEARNS, since the two learn different things.
-  const tables = new Timelines();
-  const key = Timelines.keyFor("torrent:abc", 3, "keyframe");
-
-  const picture = tables.get(key, () => timelineOver(KEYFRAMES));
-  const sound = tables.get(key, () => timelineOver(KEYFRAMES));
-
-  assert.equal(sound, picture, "one table, so the cuts cannot drift apart");
-  assert.equal(
-    Object.keys(picture).some((field) => /check|tally|deviation|landing/i.test(field)),
-    false,
-    "and nothing on it counts what anybody found, which two outputs would have shared"
-  );
-});
-
-test("two outputs each keep their own reading of the same piece number", () => {
-  // `seen` exists so that a piece asked for twice is not counted twice — right
-  // for one producer, and wrong across two. Shared, it dropped whichever of the
-  // two finished second, so which reading survived was decided by a race.
-  const picture = anOutput();
-  const sound = anOutput();
-
-  picture.noteLanding({ index: 7, deviationSec: 0.9, toleranceSec: TOLERANCE });
-  sound.noteLanding({ index: 7, deviationSec: 0, toleranceSec: TOLERANCE });
-
-  assert.equal(picture.landing.checked, 1);
-  assert.equal(picture.landing.disagreed, 1, "the picture's piece did begin away from its grid");
-  assert.equal(sound.landing.checked, 1, "and the sound's reading of its own #7 is not a repeat");
-  assert.equal(sound.landing.disagreed, 0, "the sound was cut exactly where it was asked");
-
-  // What `seen` is FOR, which the split must not lose: within one output a
-  // piece is produced and served over and over while a viewer is refused it,
-  // and the same piece is one reading however many times it is read.
-  picture.noteLanding({ index: 7, deviationSec: 0.9, toleranceSec: TOLERANCE });
-  picture.noteLanding({ index: 7, deviationSec: 0.9, toleranceSec: TOLERANCE });
-
-  assert.equal(picture.landing.checked, 1, "its own repeat is still the same piece, counted once");
-  assert.equal(picture.landing.disagreed, 1);
-});
-
-test("only a copy's reading reaches the file's table, and it outlives any one grid", () => {
-  // The whole point of moving it: the table is one per FILE, so what a copy
-  // showed about it is there for every step and every later session of those
-  // bytes — while a tally on a cut table died with the grid, and a grid is not
-  // what the reading is about.
-  const table = new KeyframeTable().learn({ times: KEYFRAMES, format: "matroska" });
-
-  table.witness({ index: 2, trueStart: 12.012, deviationSec: 4.004, toleranceSec: TOLERANCE });
-
-  assert.equal(table.evidence.checked, 1);
-  assert.equal(table.evidence.disagreed, 1);
-  assert.equal(
-    table.evidence.landedOnAnotherKeyframe,
-    1,
-    "and the table itself says the piece began at another time it names — the grid was built over a gap"
-  );
-});
-
-test("each tally answers one question, so a summary of it cannot be a mixture", () => {
-  // The distinction the three branches make when they WARN is now kept in what
-  // they count, so the summary can restate it — and the summary is what is read
-  // when nobody was watching the log live.
-  const sound = anOutput();
-  const table = new KeyframeTable().learn({ times: KEYFRAMES, format: "matroska" });
-
-  sound.noteLanding({ index: 1, deviationSec: 0.8, toleranceSec: TOLERANCE });
-
-  assert.equal(sound.landing.disagreed, 1, "the sound's grid moved under its run, and that is all it says");
-  assert.equal(table.evidence, null, "nothing a soundtrack produced is evidence about the file's keyframes");
-});
+/**
+ * @file What a produced piece reveals, and WHOSE fact it is.
+ *
+ * One reading is taken — how far a produced piece began from where its grid
+ * said it would — and three different facts are drawn from it, which the code
+ * that draws them already stated in its own three branches:
+ *
+ * 1. a COPIED picture can only be cut where a keyframe already is, so a
+ *    disagreement says the container's keyframe TABLE describes times the file
+ *    does not have. A fact of the FILE;
+ * 2. a RE-ENCODED rung was told to put a keyframe at that instant and did not,
+ *    so its pieces no longer stand where the stream it accompanies would have
+ *    put them. A fact of that OUTPUT;
+ * 3. a SOUNDTRACK is cut exactly where it is asked to be, to within an audio
+ *    frame, so it says nothing about any keyframe at all — only that the
+ *    picture's grid has moved under a run already going. A fact of that OUTPUT.
+ *
+ * Until 2026-09-15 all three went into ONE tally, and the tally was on the cut
+ * table — which is held per (file, grid), so a picture and the soundtrack muxed
+ * into the same file shared it. Three consequences, and these checks are about
+ * all of them: the file's finding died with a grid it does not belong to, one
+ * output's reading of a piece number silenced another's reading of its own, and
+ * the summary could not say which of the three facts it was summarising.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Timeline, Timelines } from "../services/encode/output/Timeline.js";
+import { Output } from "../services/encode/output/Output.js";
+import { KeyframeTable } from "../services/media/container/KeyframeTable.js";
+
+const KEYFRAMES = [0, 4.004, 8.008, 12.012, 16.016];
+const TOLERANCE = 0.25;
+
+/**
+ * @param {number[]} boundaries
+ * @returns {Timeline}
+ */
+function timelineOver(boundaries) {
+  return new Timeline({ boundaries: [...boundaries], cutGrid: "keyframe" });
+}
+
+/**
+ * @returns {Output}
+ */
+function anOutput() {
+  return new Output({
+    encodeWidth: 0,
+    encodeHeight: 0,
+    outputFps: 25,
+    softwarePreset: null,
+    applyTonemap: false
+  });
+}
+
+test("a picture and the soundtrack inside the same file share one cut table, and no longer one tally", () => {
+  // Sharing the table is right — it is what makes them cut at the same instants
+  // and is the whole reason it is held per file and grid. What must not be
+  // shared is what each of them LEARNS, since the two learn different things.
+  const tables = new Timelines();
+  const key = Timelines.keyFor("torrent:abc", 3, "keyframe");
+
+  const picture = tables.get(key, () => timelineOver(KEYFRAMES));
+  const sound = tables.get(key, () => timelineOver(KEYFRAMES));
+
+  assert.equal(sound, picture, "one table, so the cuts cannot drift apart");
+  assert.equal(
+    Object.keys(picture).some((field) => /check|tally|deviation|landing/i.test(field)),
+    false,
+    "and nothing on it counts what anybody found, which two outputs would have shared"
+  );
+});
+
+test("two outputs each keep their own reading of the same piece number", () => {
+  // `seen` exists so that a piece asked for twice is not counted twice — right
+  // for one producer, and wrong across two. Shared, it dropped whichever of the
+  // two finished second, so which reading survived was decided by a race.
+  const picture = anOutput();
+  const sound = anOutput();
+
+  picture.noteLanding({ index: 7, deviationSec: 0.9, toleranceSec: TOLERANCE });
+  sound.noteLanding({ index: 7, deviationSec: 0, toleranceSec: TOLERANCE });
+
+  assert.equal(picture.landing.checked, 1);
+  assert.equal(picture.landing.disagreed, 1, "the picture's piece did begin away from its grid");
+  assert.equal(sound.landing.checked, 1, "and the sound's reading of its own #7 is not a repeat");
+  assert.equal(sound.landing.disagreed, 0, "the sound was cut exactly where it was asked");
+
+  // What `seen` is FOR, which the split must not lose: within one output a
+  // piece is produced and served over and over while a viewer is refused it,
+  // and the same piece is one reading however many times it is read.
+  picture.noteLanding({ index: 7, deviationSec: 0.9, toleranceSec: TOLERANCE });
+  picture.noteLanding({ index: 7, deviationSec: 0.9, toleranceSec: TOLERANCE });
+
+  assert.equal(picture.landing.checked, 1, "its own repeat is still the same piece, counted once");
+  assert.equal(picture.landing.disagreed, 1);
+});
+
+test("only a copy's reading reaches the file's table, and it outlives any one grid", () => {
+  // The whole point of moving it: the table is one per FILE, so what a copy
+  // showed about it is there for every step and every later session of those
+  // bytes — while a tally on a cut table died with the grid, and a grid is not
+  // what the reading is about.
+  const table = new KeyframeTable().learn({ times: KEYFRAMES, format: "matroska" });
+
+  table.witness({ index: 2, trueStart: 12.012, deviationSec: 4.004, toleranceSec: TOLERANCE });
+
+  assert.equal(table.evidence.checked, 1);
+  assert.equal(table.evidence.disagreed, 1);
+  assert.equal(
+    table.evidence.landedOnAnotherKeyframe,
+    1,
+    "and the table itself says the piece began at another time it names — the grid was built over a gap"
+  );
+});
+
+test("each tally answers one question, so a summary of it cannot be a mixture", () => {
+  // The distinction the three branches make when they WARN is now kept in what
+  // they count, so the summary can restate it — and the summary is what is read
+  // when nobody was watching the log live.
+  const sound = anOutput();
+  const table = new KeyframeTable().learn({ times: KEYFRAMES, format: "matroska" });
+
+  sound.noteLanding({ index: 1, deviationSec: 0.8, toleranceSec: TOLERANCE });
+
+  assert.equal(sound.landing.disagreed, 1, "the sound's grid moved under its run, and that is all it says");
+  assert.equal(table.evidence, null, "nothing a soundtrack produced is evidence about the file's keyframes");
+});