@torrent-tv/proxy 2.89.7 → 2.89.9

package/test/coverage-map.test.js

@@ -1,195 +1,195 @@
-/**
- * @file The three states of a segment number, and the two questions that decide
- * where an encoder goes.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { CoverageMap } from "../services/encode/CoverageMap.js";
-
-/**
- * A stand-in for a run.
- *
- * The map files a claim under the run ITSELF: a run has no name, and needs
- * none — what identifies it is that it is itself, and what identifies it in a
- * line is the stretch it was given, which no other live run of one output can
- * hold.
- *
- * @returns {object}
- */
-function aRun() {
-  return {};
-}
-
-test("a number nobody has made and nobody is making is free", () => {
-  const map = new CoverageMap({ segmentCount: 10 });
-  assert.equal(map.stateOf(3), "free");
-  assert.equal(map.firstGapFrom(0), 0);
-});
-
-test("a closed file is ready whoever made it", () => {
-  const map = new CoverageMap({ segmentCount: 10 });
-  map.markReady(0);
-  map.markReady(1);
-  assert.equal(map.stateOf(1), "ready");
-  assert.equal(map.firstGapFrom(0), 2);
-});
-
-test("a run claims a stretch, and the gap search skips it", () => {
-  // The claim is an interval and not a head, which is the whole reason two runs
-  // can work on one output: the second is sent past what the first will reach.
-  const map = new CoverageMap({ segmentCount: 100 });
-  const runA = aRun();
-  map.claim(runA, 0, 40);
-  assert.equal(map.stateOf(20), "making");
-  assert.equal(map.makerOf(20), runA);
-  assert.equal(map.firstGapFrom(0), 41);
-});
-
-test("a run that ends gives back what it did not finish, and keeps what it did", () => {
-  const map = new CoverageMap({ segmentCount: 100 });
-  const runA = aRun();
-  map.claim(runA, 0, 40);
-  map.markReady(0);
-  map.markReady(1);
-  map.release(runA);
-  assert.equal(map.stateOf(0), "ready", "a closed file survives its maker");
-  assert.equal(map.stateOf(2), "free", "the rest of the stretch is free again");
-  assert.equal(map.firstGapFrom(0), 2);
-});
-
-test("a run with no end claims everything ahead of it", () => {
-  // Which is what every run was before ends existed, and is why a second run
-  // could never be placed.
-  const map = new CoverageMap({ segmentCount: 100 });
-  const runA = aRun();
-  map.claim(runA, 10, Number.POSITIVE_INFINITY);
-  assert.equal(map.firstGapFrom(10), null);
-  assert.equal(map.firstGapFrom(0), 0, "behind it is still free");
-});
-
-test("claiming again replaces the earlier claim rather than adding to it", () => {
-  // A run moved forward past ready material states its new stretch; if the two
-  // accumulated, the ground it has left would stay unavailable for ever.
-  const map = new CoverageMap({ segmentCount: 100 });
-  const runA = aRun();
-  map.claim(runA, 0, 20);
-  map.claim(runA, 50, 70);
-  assert.equal(map.stateOf(10), "free");
-  assert.equal(map.stateOf(60), "making");
-});
-
-test("the covered stretch ahead is measured, which is what prices a move", () => {
-  const map = new CoverageMap({ segmentCount: 100 });
-  const runA = aRun();
-  const runB = aRun();
-  for (let index = 10; index <= 24; index += 1) {
-    map.markReady(index);
-  }
-  map.claim(runB, 25, 30);
-  // Ready 10..24 then another run's 25..30, so fifteen plus six.
-  assert.equal(map.coveredRunFrom(10, runA), 21);
-  assert.equal(map.firstGapFrom(10), 31);
-});
-
-test("a run's own claim is not counted as somebody else's coverage", () => {
-  // Otherwise a run would read its own stretch as a reason to move off it.
-  const map = new CoverageMap({ segmentCount: 100 });
-  const runA = aRun();
-  map.claim(runA, 10, 30);
-  assert.equal(map.coveredRunFrom(10, runA), 0);
-});
-
-test("nothing free ahead answers null rather than a number past the end", () => {
-  const map = new CoverageMap({ segmentCount: 5 });
-  map.setReady([0, 1, 2, 3, 4]);
-  assert.equal(map.firstGapFrom(0), null);
-});
-
-test("a file that has gone stops being ready", () => {
-  // THE CHECK THE FIELD FAILURE OF 2026-09-07 NEEDED. Readiness used to
-  // accumulate: a number told once stayed ready for the life of the process
-  // however its file ended, so the map claimed a whole film that was not there,
-  // the plan scored every arrangement as perfect and took the only encoder away.
-  const map = new CoverageMap({ segmentCount: 10 });
-  map.setReady([3, 4]);
-  assert.equal(map.stateOf(4), "ready");
-  map.setReady([3]);
-  assert.equal(map.stateOf(4), "free", "the picture is replaced, not added to");
-  assert.equal(map.stateOf(3), "ready", "and what is still there stays");
-});
-
-test("the whole picture is replaced, so nothing survives that the disk has lost", () => {
-  const map = new CoverageMap({ segmentCount: 500 });
-  for (let index = 0; index < 500; index += 1) {
-    map.markReady(index);
-  }
-  assert.equal(map.stats().ready, 500);
-  map.setReady([]);
-  assert.equal(map.stats().ready, 0, "an empty directory is an empty map");
-  assert.equal(map.firstGapFrom(0), 0, "and the first gap is the beginning again");
-});
-
-test("a run's own claim does not hide the gap it is trying to move into", () => {
-  // Found by the plan's own checks: a run that had claimed the rest of the film
-  // — which is what every run did before ends existed — could find no gap
-  // anywhere, so it was stopped instead of moved.
-  const map = new CoverageMap({ segmentCount: 100 });
-  const runA = aRun();
-  map.claim(runA, 0, 99);
-  map.setReady([10, 11, 12]);
-  assert.equal(map.firstGapFrom(10, 90), null, "to anybody else its ground is taken");
-  assert.equal(map.firstGapFrom(10, 90, runA), 13, "to itself the ground beyond is a gap");
-});
-
-test("the free stretch ahead is measured, which is what gives a run its end", () => {
-  // A run handed the whole rest of the film would drive through the stretch
-  // another run is making. Handed the free stretch, it stops where the covered
-  // material begins.
-  const map = new CoverageMap({ segmentCount: 100 });
-  const runB = aRun();
-  map.claim(runB, 30, 60);
-  assert.equal(map.freeRunFrom(10), 20, "free from 10 up to 29");
-  map.markReady(15);
-  assert.equal(map.freeRunFrom(10), 5, "a ready segment ends the free stretch too");
-  assert.equal(map.freeRunFrom(15), 0, "a number that is not free has no free stretch");
-});
-
-test("a run's own claim does not end its own free stretch", () => {
-  const map = new CoverageMap({ segmentCount: 100 });
-  const runA = aRun();
-  map.claim(runA, 10, 40);
-  assert.equal(map.freeRunFrom(10, runA), 90, "its own ground is still its to fill");
-  assert.equal(map.freeRunFrom(10), 0, "to anybody else it is taken");
-});
-
-test("with the length unknown, a gap search needs its own bound", () => {
-  const map = new CoverageMap();
-  assert.equal(map.firstGapFrom(0), null, "no length and no bound answers nothing");
-  assert.equal(map.firstGapFrom(0, 3), 0);
-});
-
-test("with the length unknown, the free stretch is answered without walking to it", () => {
-  // What this pins: on the addon host, 2026-09-05, a map with no length walked
-  // one number at a time to MAX_SAFE_INTEGER, scanning every claim at each step.
-  // The main thread spun at 100% from the look-ahead timer and the proxy stopped
-  // answering anything, its own log included. The length was missing because the
-  // field naming it had moved to the timeline and three readers were left on the
-  // old name — but this walk must not be able to do that even when it is.
-  //
-  // This check cannot FAIL against the old code — a synchronous walk cannot be
-  // interrupted by the runner, so it would hang the whole run instead, which is
-  // worse than no check. What it pins is the contract that replaced the walk:
-  // the answer comes from what the map holds.
-  const map = new CoverageMap();
-
-  assert.equal(map.freeRunFrom(0), Number.POSITIVE_INFINITY, "nothing is covered, so nothing bounds it");
-
-  const run = aRun();
-  map.claim(run, 500, 900);
-  assert.equal(map.freeRunFrom(0), 500, "and a claim ahead is where the free stretch ends");
-  assert.equal(map.freeRunFrom(0, run), Number.POSITIVE_INFINITY, "its own claim does not bound it");
-
-  map.markReady(200);
-  assert.equal(map.freeRunFrom(0), 200, "so is a segment somebody has already made");
-});
+/**
+ * @file The three states of a segment number, and the two questions that decide
+ * where an encoder goes.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+
+/**
+ * A stand-in for a run.
+ *
+ * The map files a claim under the run ITSELF: a run has no name, and needs
+ * none — what identifies it is that it is itself, and what identifies it in a
+ * line is the stretch it was given, which no other live run of one output can
+ * hold.
+ *
+ * @returns {object}
+ */
+function aRun() {
+  return {};
+}
+
+test("a number nobody has made and nobody is making is free", () => {
+  const map = new CoverageMap({ segmentCount: 10 });
+  assert.equal(map.stateOf(3), "free");
+  assert.equal(map.firstGapFrom(0), 0);
+});
+
+test("a closed file is ready whoever made it", () => {
+  const map = new CoverageMap({ segmentCount: 10 });
+  map.markReady(0);
+  map.markReady(1);
+  assert.equal(map.stateOf(1), "ready");
+  assert.equal(map.firstGapFrom(0), 2);
+});
+
+test("a run claims a stretch, and the gap search skips it", () => {
+  // The claim is an interval and not a head, which is the whole reason two runs
+  // can work on one output: the second is sent past what the first will reach.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 0, 40);
+  assert.equal(map.stateOf(20), "making");
+  assert.equal(map.makerOf(20), runA);
+  assert.equal(map.firstGapFrom(0), 41);
+});
+
+test("a run that ends gives back what it did not finish, and keeps what it did", () => {
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 0, 40);
+  map.markReady(0);
+  map.markReady(1);
+  map.release(runA);
+  assert.equal(map.stateOf(0), "ready", "a closed file survives its maker");
+  assert.equal(map.stateOf(2), "free", "the rest of the stretch is free again");
+  assert.equal(map.firstGapFrom(0), 2);
+});
+
+test("a run with no end claims everything ahead of it", () => {
+  // Which is what every run was before ends existed, and is why a second run
+  // could never be placed.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 10, Number.POSITIVE_INFINITY);
+  assert.equal(map.firstGapFrom(10), null);
+  assert.equal(map.firstGapFrom(0), 0, "behind it is still free");
+});
+
+test("claiming again replaces the earlier claim rather than adding to it", () => {
+  // A run moved forward past ready material states its new stretch; if the two
+  // accumulated, the ground it has left would stay unavailable for ever.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 0, 20);
+  map.claim(runA, 50, 70);
+  assert.equal(map.stateOf(10), "free");
+  assert.equal(map.stateOf(60), "making");
+});
+
+test("the covered stretch ahead is measured, which is what prices a move", () => {
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  const runB = aRun();
+  for (let index = 10; index <= 24; index += 1) {
+    map.markReady(index);
+  }
+  map.claim(runB, 25, 30);
+  // Ready 10..24 then another run's 25..30, so fifteen plus six.
+  assert.equal(map.coveredRunFrom(10, runA), 21);
+  assert.equal(map.firstGapFrom(10), 31);
+});
+
+test("a run's own claim is not counted as somebody else's coverage", () => {
+  // Otherwise a run would read its own stretch as a reason to move off it.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 10, 30);
+  assert.equal(map.coveredRunFrom(10, runA), 0);
+});
+
+test("nothing free ahead answers null rather than a number past the end", () => {
+  const map = new CoverageMap({ segmentCount: 5 });
+  map.setReady([0, 1, 2, 3, 4]);
+  assert.equal(map.firstGapFrom(0), null);
+});
+
+test("a file that has gone stops being ready", () => {
+  // THE CHECK THE FIELD FAILURE OF 2026-09-07 NEEDED. Readiness used to
+  // accumulate: a number told once stayed ready for the life of the process
+  // however its file ended, so the map claimed a whole film that was not there,
+  // the plan scored every arrangement as perfect and took the only encoder away.
+  const map = new CoverageMap({ segmentCount: 10 });
+  map.setReady([3, 4]);
+  assert.equal(map.stateOf(4), "ready");
+  map.setReady([3]);
+  assert.equal(map.stateOf(4), "free", "the picture is replaced, not added to");
+  assert.equal(map.stateOf(3), "ready", "and what is still there stays");
+});
+
+test("the whole picture is replaced, so nothing survives that the disk has lost", () => {
+  const map = new CoverageMap({ segmentCount: 500 });
+  for (let index = 0; index < 500; index += 1) {
+    map.markReady(index);
+  }
+  assert.equal(map.stats().ready, 500);
+  map.setReady([]);
+  assert.equal(map.stats().ready, 0, "an empty directory is an empty map");
+  assert.equal(map.firstGapFrom(0), 0, "and the first gap is the beginning again");
+});
+
+test("a run's own claim does not hide the gap it is trying to move into", () => {
+  // Found by the plan's own checks: a run that had claimed the rest of the film
+  // — which is what every run did before ends existed — could find no gap
+  // anywhere, so it was stopped instead of moved.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 0, 99);
+  map.setReady([10, 11, 12]);
+  assert.equal(map.firstGapFrom(10, 90), null, "to anybody else its ground is taken");
+  assert.equal(map.firstGapFrom(10, 90, runA), 13, "to itself the ground beyond is a gap");
+});
+
+test("the free stretch ahead is measured, which is what gives a run its end", () => {
+  // A run handed the whole rest of the film would drive through the stretch
+  // another run is making. Handed the free stretch, it stops where the covered
+  // material begins.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runB = aRun();
+  map.claim(runB, 30, 60);
+  assert.equal(map.freeRunFrom(10), 20, "free from 10 up to 29");
+  map.markReady(15);
+  assert.equal(map.freeRunFrom(10), 5, "a ready segment ends the free stretch too");
+  assert.equal(map.freeRunFrom(15), 0, "a number that is not free has no free stretch");
+});
+
+test("a run's own claim does not end its own free stretch", () => {
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 10, 40);
+  assert.equal(map.freeRunFrom(10, runA), 90, "its own ground is still its to fill");
+  assert.equal(map.freeRunFrom(10), 0, "to anybody else it is taken");
+});
+
+test("with the length unknown, a gap search needs its own bound", () => {
+  const map = new CoverageMap();
+  assert.equal(map.firstGapFrom(0), null, "no length and no bound answers nothing");
+  assert.equal(map.firstGapFrom(0, 3), 0);
+});
+
+test("with the length unknown, the free stretch is answered without walking to it", () => {
+  // What this pins: on the addon host, 2026-09-05, a map with no length walked
+  // one number at a time to MAX_SAFE_INTEGER, scanning every claim at each step.
+  // The main thread spun at 100% from the look-ahead timer and the proxy stopped
+  // answering anything, its own log included. The length was missing because the
+  // field naming it had moved to the timeline and three readers were left on the
+  // old name — but this walk must not be able to do that even when it is.
+  //
+  // This check cannot FAIL against the old code — a synchronous walk cannot be
+  // interrupted by the runner, so it would hang the whole run instead, which is
+  // worse than no check. What it pins is the contract that replaced the walk:
+  // the answer comes from what the map holds.
+  const map = new CoverageMap();
+
+  assert.equal(map.freeRunFrom(0), Number.POSITIVE_INFINITY, "nothing is covered, so nothing bounds it");
+
+  const run = aRun();
+  map.claim(run, 500, 900);
+  assert.equal(map.freeRunFrom(0), 500, "and a claim ahead is where the free stretch ends");
+  assert.equal(map.freeRunFrom(0, run), Number.POSITIVE_INFINITY, "its own claim does not bound it");
+
+  map.markReady(200);
+  assert.equal(map.freeRunFrom(0), 200, "so is a segment somebody has already made");
+});

package/test/cue-push-carries-what-the-walk-found.test.js

@@ -1,58 +1,58 @@
-/**
- * @file What the subtitle walk found reaches the viewer whole.
- *
- * It did not. The walk has produced `detectedLanguage` on every push since
- * 2.69.0 — the language read from the CUES rather than from a container that
- * often states none — and the whole of the "label moves when the answer
- * arrives" behaviour rests on it. It never arrived: the fact was copied by hand
- * twice on its way out, and each copy listed the fields it knew about. The
- * worker posted `trackIndex, cues, language, cursor`; the main thread's client
- * rebuilt the same four from the message. `detectedLanguage` was in neither
- * list, so the browser was told nothing and the label it shows for an untagged
- * track has never moved.
- *
- * It is not a typo to fix in two places — it is the shape. A fact copied field
- * by field loses whatever the copier did not know about, and says nothing when
- * it does. The walk's own result travels now, so a field added to it arrives
- * without anybody being told to forward it.
- *
- * (Both copies are gone anyway: the walk runs on the thread that pushes.)
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-
-/**
- * @param {string} relative
- * @returns {string}
- */
-function source(relative) {
-  return readFileSync(path.join(ROOT, relative), "utf8");
-}
-
-test("the walk states the language it read from the cues", () => {
-  // The producer. Without this the rest of the check is about nothing.
-  assert.match(source("services/media/SubtitleCues.js"), /detectedLanguage: detectLanguage\(/);
-});
-
-test("the consumer asks for it", () => {
-  // The other end has always destructured it, which is what made the loss
-  // silent: a field nobody forwards is `undefined` and reads as "not detected".
-  assert.match(
-    source("services/transport/data-channel-handler.js"),
-    /function publishSubtitleCues\(\{[^}]*detectedLanguage[^}]*\}\)/
-  );
-});
-
-test("the push forwards the whole of what the walk found, rather than a list of fields", () => {
-  // The one line that closes it. A list of names here is how the fact was lost
-  // twice, and a list cannot say that it is incomplete.
-  const wiring = source("server.js");
-
-  assert.match(wiring, /onSubtitleCues\?\.\(\{ sourceKey, fileIndex, \.\.\.entry \}\)/);
-});
+/**
+ * @file What the subtitle walk found reaches the viewer whole.
+ *
+ * It did not. The walk has produced `detectedLanguage` on every push since
+ * 2.69.0 — the language read from the CUES rather than from a container that
+ * often states none — and the whole of the "label moves when the answer
+ * arrives" behaviour rests on it. It never arrived: the fact was copied by hand
+ * twice on its way out, and each copy listed the fields it knew about. The
+ * worker posted `trackIndex, cues, language, cursor`; the main thread's client
+ * rebuilt the same four from the message. `detectedLanguage` was in neither
+ * list, so the browser was told nothing and the label it shows for an untagged
+ * track has never moved.
+ *
+ * It is not a typo to fix in two places — it is the shape. A fact copied field
+ * by field loses whatever the copier did not know about, and says nothing when
+ * it does. The walk's own result travels now, so a field added to it arrives
+ * without anybody being told to forward it.
+ *
+ * (Both copies are gone anyway: the walk runs on the thread that pushes.)
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+/**
+ * @param {string} relative
+ * @returns {string}
+ */
+function source(relative) {
+  return readFileSync(path.join(ROOT, relative), "utf8");
+}
+
+test("the walk states the language it read from the cues", () => {
+  // The producer. Without this the rest of the check is about nothing.
+  assert.match(source("services/media/SubtitleCues.js"), /detectedLanguage: detectLanguage\(/);
+});
+
+test("the consumer asks for it", () => {
+  // The other end has always destructured it, which is what made the loss
+  // silent: a field nobody forwards is `undefined` and reads as "not detected".
+  assert.match(
+    source("services/transport/data-channel-handler.js"),
+    /function publishSubtitleCues\(\{[^}]*detectedLanguage[^}]*\}\)/
+  );
+});
+
+test("the push forwards the whole of what the walk found, rather than a list of fields", () => {
+  // The one line that closes it. A list of names here is how the fact was lost
+  // twice, and a list cannot say that it is incomplete.
+  const wiring = source("server.js");
+
+  assert.match(wiring, /onSubtitleCues\?\.\(\{ sourceKey, fileIndex, \.\.\.entry \}\)/);
+});

package/test/cut-times-timeline.test.js

@@ -1,65 +1,65 @@
-/**
- * @file The cut list must be stated on the timeline the muxer decides against.
- *
- * Measured 2026-08-17 on a Matroska whose first timestamp is 2.002 s. Asked to
- * cut at 808.808 s on the 0-based grid, the copied picture cut at 806.806 s —
- * exactly the container's start time early, and itself a keyframe the file's
- * own table names, which is why every "disagreement" landed on a real keyframe
- * and the table looked like it was lying. The soundtrack, re-encoded and on the
- * other branch, cut where it was asked. The two then wrote different values
- * into the shared boundary table and corrected each other back and forth
- * (#202: 808.808 → 806.806 → 808.750), so the playlist and the media drifted
- * apart by a whole segment.
- */
-
-import assert from "node:assert/strict";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import test from "node:test";
-
-import { onKeyframeGridFor } from "../services/encode/run-command.js";
-
-test("a copied picture works on the source's timeline", () => {
-  assert.equal(
-    onKeyframeGridFor({ transcodeVideo: false }),
-    true,
-    "video copied means the source's own timestamps are kept"
-  );
-});
-
-test("a re-encoded picture works on the 0-based timeline", () => {
-  assert.equal(onKeyframeGridFor({ transcodeVideo: true }), false);
-});
-
-test("a soundtrack follows the grid it was cut on, not its own encoding", () => {
-  // A rendition is re-encoded by definition, so asking `transcodeVideo` about
-  // it answers nothing. What decides its timeline is the grid it shares with
-  // the picture it plays with.
-  assert.equal(onKeyframeGridFor({ audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "keyframe" }) }), true);
-  assert.equal(onKeyframeGridFor({ audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "uniform" }) }), false);
-  assert.equal(
-    onKeyframeGridFor({ audioOnly: true, transcodeVideo: true, timeline: new Timeline({ boundaries: [], cutGrid: "keyframe" }) }),
-    true,
-    "its own encoding must not decide this — that disagreement is the defect"
-  );
-});
-
-test("one predicate answers for every caller", () => {
-  // The two callers used to answer this separately, in two expressions that
-  // could drift apart. A session put through both must get one answer.
-  for (const session of [
-    { transcodeVideo: false },
-    { transcodeVideo: true },
-    { audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "keyframe" }) },
-    { audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "uniform" }) },
-    {}
-  ]) {
-    assert.equal(onKeyframeGridFor(session), onKeyframeGridFor({ ...session }));
-  }
-});
-
-test("a session that says nothing is treated as copying", () => {
-  // The default matters: an absent `transcodeVideo` means the picture is
-  // copied, which is the branch that needs the shift.
-  assert.equal(onKeyframeGridFor({}), true);
-  assert.equal(onKeyframeGridFor(null), true);
-});
+/**
+ * @file The cut list must be stated on the timeline the muxer decides against.
+ *
+ * Measured 2026-08-17 on a Matroska whose first timestamp is 2.002 s. Asked to
+ * cut at 808.808 s on the 0-based grid, the copied picture cut at 806.806 s —
+ * exactly the container's start time early, and itself a keyframe the file's
+ * own table names, which is why every "disagreement" landed on a real keyframe
+ * and the table looked like it was lying. The soundtrack, re-encoded and on the
+ * other branch, cut where it was asked. The two then wrote different values
+ * into the shared boundary table and corrected each other back and forth
+ * (#202: 808.808 → 806.806 → 808.750), so the playlist and the media drifted
+ * apart by a whole segment.
+ */
+
+import assert from "node:assert/strict";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import test from "node:test";
+
+import { onKeyframeGridFor } from "../services/encode/run-command.js";
+
+test("a copied picture works on the source's timeline", () => {
+  assert.equal(
+    onKeyframeGridFor({ transcodeVideo: false }),
+    true,
+    "video copied means the source's own timestamps are kept"
+  );
+});
+
+test("a re-encoded picture works on the 0-based timeline", () => {
+  assert.equal(onKeyframeGridFor({ transcodeVideo: true }), false);
+});
+
+test("a soundtrack follows the grid it was cut on, not its own encoding", () => {
+  // A rendition is re-encoded by definition, so asking `transcodeVideo` about
+  // it answers nothing. What decides its timeline is the grid it shares with
+  // the picture it plays with.
+  assert.equal(onKeyframeGridFor({ audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "keyframe" }) }), true);
+  assert.equal(onKeyframeGridFor({ audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "uniform" }) }), false);
+  assert.equal(
+    onKeyframeGridFor({ audioOnly: true, transcodeVideo: true, timeline: new Timeline({ boundaries: [], cutGrid: "keyframe" }) }),
+    true,
+    "its own encoding must not decide this — that disagreement is the defect"
+  );
+});
+
+test("one predicate answers for every caller", () => {
+  // The two callers used to answer this separately, in two expressions that
+  // could drift apart. A session put through both must get one answer.
+  for (const session of [
+    { transcodeVideo: false },
+    { transcodeVideo: true },
+    { audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "keyframe" }) },
+    { audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "uniform" }) },
+    {}
+  ]) {
+    assert.equal(onKeyframeGridFor(session), onKeyframeGridFor({ ...session }));
+  }
+});
+
+test("a session that says nothing is treated as copying", () => {
+  // The default matters: an absent `transcodeVideo` means the picture is
+  // copied, which is the branch that needs the shift.
+  assert.equal(onKeyframeGridFor({}), true);
+  assert.equal(onKeyframeGridFor(null), true);
+});