@torrent-tv/proxy 2.87.10 → 2.87.12

package/test/installation-id.test.js

@@ -1,39 +1,39 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { installationId } from "../services/identity/installation-id.js";
-
-test("an installation id is reused from its state directory", (t) => {
-  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
-  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
-
-  assert.equal(installationId({ stateDir, makeId: () => "first-id" }), "first-id");
-  assert.equal(installationId({ stateDir, makeId: () => "unexpected-id" }), "first-id");
-  assert.deepEqual(JSON.parse(readFileSync(path.join(stateDir, "proxy-identity.json"), "utf8")), { id: "first-id" });
-});
-
-test("an explicit id takes precedence and becomes the saved installation id", (t) => {
-  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
-  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
-
-  assert.equal(installationId({ stateDir, explicitId: " configured-id " }), "configured-id");
-  assert.equal(installationId({ stateDir, makeId: () => "unexpected-id" }), "configured-id");
-});
-
-test("without a state directory the default id stays ephemeral", () => {
-  let calls = 0;
-  const makeId = () => `id-${++calls}`;
-
-  assert.equal(installationId({ makeId }), "id-1");
-  assert.equal(installationId({ makeId }), "id-2");
-});
-
-test("a damaged saved identity is reported instead of silently replaced", (t) => {
-  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
-  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
-  writeFileSync(path.join(stateDir, "proxy-identity.json"), "{}\n");
-
-  assert.throws(() => installationId({ stateDir, makeId: () => "replacement" }), /Invalid proxy identity file/);
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { installationId } from "../services/identity/installation-id.js";
+
+test("an installation id is reused from its state directory", (t) => {
+  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
+  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
+
+  assert.equal(installationId({ stateDir, makeId: () => "first-id" }), "first-id");
+  assert.equal(installationId({ stateDir, makeId: () => "unexpected-id" }), "first-id");
+  assert.deepEqual(JSON.parse(readFileSync(path.join(stateDir, "proxy-identity.json"), "utf8")), { id: "first-id" });
+});
+
+test("an explicit id takes precedence and becomes the saved installation id", (t) => {
+  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
+  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
+
+  assert.equal(installationId({ stateDir, explicitId: " configured-id " }), "configured-id");
+  assert.equal(installationId({ stateDir, makeId: () => "unexpected-id" }), "configured-id");
+});
+
+test("without a state directory the default id stays ephemeral", () => {
+  let calls = 0;
+  const makeId = () => `id-${++calls}`;
+
+  assert.equal(installationId({ makeId }), "id-1");
+  assert.equal(installationId({ makeId }), "id-2");
+});
+
+test("a damaged saved identity is reported instead of silently replaced", (t) => {
+  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
+  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
+  writeFileSync(path.join(stateDir, "proxy-identity.json"), "{}\n");
+
+  assert.throws(() => installationId({ stateDir, makeId: () => "replacement" }), /Invalid proxy identity file/);
+});

package/test/keeping-period.test.js

@@ -1,83 +1,83 @@
-/**
- * @file How long material nobody is using is kept, and where that number comes
- * from.
- *
- * It was three numbers and they contradicted each other: a torrent went at
- * fifteen minutes while the session it feeds lived to thirty, so between them
- * there was a session with no source. All three stand for one unmeasured thing
- * — whether the viewer comes back — so they are one number now, and the thing
- * they stand for is being measured.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { IDLE_KEEP_MS } from "../services/storage/keep.js";
-import { Returns } from "../services/storage/returns.js";
-
-const MINUTE = 60 * 1000;
-
-test("material outlives the session that reads it", () => {
-  // The contradiction this replaced, stated as the rule it must never break
-  // again: whatever holds a source must not go while something that reads it
-  // is still alive. The session's own period is thirty minutes.
-  const SESSION_TTL_MS = 30 * MINUTE;
-  assert.ok(
-    IDLE_KEEP_MS > SESSION_TTL_MS,
-    "a session would outlive its own source again: material is kept " +
-      `${IDLE_KEEP_MS / MINUTE}min against a session's ${SESSION_TTL_MS / MINUTE}min`
-  );
-});
-
-test("one number, and both kinds of material read it", async () => {
-  // Two guesses about one unknown is what produced the contradiction. Asserted
-  // on the source: a second literal period appearing anywhere is the fault
-  // coming back.
-  const { readFileSync } = await import("node:fs");
-  const path = await import("node:path");
-  const { fileURLToPath } = await import("node:url");
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  const read = (relative) => readFileSync(path.join(here, "..", relative), "utf8");
-
-  assert.match(read("services/torrent/torrent-pool.js"), /TORRENT_IDLE_TTL_MS = IDLE_KEEP_MS/);
-  assert.match(read("services/server/OutputLifecycle.js"), /SEGMENT_STORE_IDLE_MS = IDLE_KEEP_MS/);
-});
-
-test("a session opened on material still held is a return, and its age is kept", () => {
-  const returns = new Returns();
-  const now = 10 * 60 * MINUTE;
-
-  returns.note({ lastReadAt: now - 5 * MINUTE, now });
-  returns.note({ lastReadAt: now - 45 * MINUTE, now });
-  returns.note({ lastReadAt: now - 20 * MINUTE, now });
-
-  const shape = returns.shape();
-  assert.equal(shape.warm, 3);
-  assert.equal(shape.cold, 0);
-  assert.equal(shape.medianMs, 20 * MINUTE, "the middle return is not the median");
-  assert.equal(shape.longestMs, 45 * MINUTE);
-});
-
-test("a session opened on material this proxy never had is not a return", () => {
-  const returns = new Returns();
-  const now = 10 * 60 * MINUTE;
-
-  returns.note({ lastReadAt: null, now });
-  returns.note({ lastReadAt: 0, now });
-
-  assert.equal(returns.shape(), null, "an opening with nothing behind it was counted as a return");
-});
-
-test("the reading says what viewers do beside what is being kept", () => {
-  const returns = new Returns();
-  const now = 10 * 60 * MINUTE;
-  assert.equal(returns.describe(IDLE_KEEP_MS), null, "it spoke before it had anything to say");
-
-  returns.note({ lastReadAt: now - 12 * MINUTE, now });
-  returns.note({ lastReadAt: null, now });
-
-  const line = returns.describe(IDLE_KEEP_MS);
-  assert.match(line, /1 session\(s\) opened on material still held/);
-  assert.match(line, /1 on material gone/);
-  assert.match(line, /median 12min after the last read/);
-  assert.match(line, /kept for 60min/);
-});
+/**
+ * @file How long material nobody is using is kept, and where that number comes
+ * from.
+ *
+ * It was three numbers and they contradicted each other: a torrent went at
+ * fifteen minutes while the session it feeds lived to thirty, so between them
+ * there was a session with no source. All three stand for one unmeasured thing
+ * — whether the viewer comes back — so they are one number now, and the thing
+ * they stand for is being measured.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { IDLE_KEEP_MS } from "../services/storage/keep.js";
+import { Returns } from "../services/storage/returns.js";
+
+const MINUTE = 60 * 1000;
+
+test("material outlives the session that reads it", () => {
+  // The contradiction this replaced, stated as the rule it must never break
+  // again: whatever holds a source must not go while something that reads it
+  // is still alive. The session's own period is thirty minutes.
+  const SESSION_TTL_MS = 30 * MINUTE;
+  assert.ok(
+    IDLE_KEEP_MS > SESSION_TTL_MS,
+    "a session would outlive its own source again: material is kept " +
+      `${IDLE_KEEP_MS / MINUTE}min against a session's ${SESSION_TTL_MS / MINUTE}min`
+  );
+});
+
+test("one number, and both kinds of material read it", async () => {
+  // Two guesses about one unknown is what produced the contradiction. Asserted
+  // on the source: a second literal period appearing anywhere is the fault
+  // coming back.
+  const { readFileSync } = await import("node:fs");
+  const path = await import("node:path");
+  const { fileURLToPath } = await import("node:url");
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const read = (relative) => readFileSync(path.join(here, "..", relative), "utf8");
+
+  assert.match(read("services/torrent/torrent-pool.js"), /TORRENT_IDLE_TTL_MS = IDLE_KEEP_MS/);
+  assert.match(read("services/server/OutputLifecycle.js"), /SEGMENT_STORE_IDLE_MS = IDLE_KEEP_MS/);
+});
+
+test("a session opened on material still held is a return, and its age is kept", () => {
+  const returns = new Returns();
+  const now = 10 * 60 * MINUTE;
+
+  returns.note({ lastReadAt: now - 5 * MINUTE, now });
+  returns.note({ lastReadAt: now - 45 * MINUTE, now });
+  returns.note({ lastReadAt: now - 20 * MINUTE, now });
+
+  const shape = returns.shape();
+  assert.equal(shape.warm, 3);
+  assert.equal(shape.cold, 0);
+  assert.equal(shape.medianMs, 20 * MINUTE, "the middle return is not the median");
+  assert.equal(shape.longestMs, 45 * MINUTE);
+});
+
+test("a session opened on material this proxy never had is not a return", () => {
+  const returns = new Returns();
+  const now = 10 * 60 * MINUTE;
+
+  returns.note({ lastReadAt: null, now });
+  returns.note({ lastReadAt: 0, now });
+
+  assert.equal(returns.shape(), null, "an opening with nothing behind it was counted as a return");
+});
+
+test("the reading says what viewers do beside what is being kept", () => {
+  const returns = new Returns();
+  const now = 10 * 60 * MINUTE;
+  assert.equal(returns.describe(IDLE_KEEP_MS), null, "it spoke before it had anything to say");
+
+  returns.note({ lastReadAt: now - 12 * MINUTE, now });
+  returns.note({ lastReadAt: null, now });
+
+  const line = returns.describe(IDLE_KEEP_MS);
+  assert.match(line, /1 session\(s\) opened on material still held/);
+  assert.match(line, /1 on material gone/);
+  assert.match(line, /median 12min after the last read/);
+  assert.match(line, /kept for 60min/);
+});

package/test/keyframe-index-accuracy.test.js

@@ -1,188 +1,188 @@
-/**
- * @file How well a container's keyframe index describes its own file.
- *
- * The cut times of a copied video ARE its index — ffmpeg can only cut where a
- * keyframe already is — and an index can be wrong: measured 2026-08-06, one
- * claimed a keyframe at 157.99 s where the real ones were 153.82 and 164.247.
- * Whether a re-encoded rung can be cut on that same grid and spliced into the
- * copy depends entirely on how often that happens, so it is counted.
- *
- * No scan is involved and no undownloaded byte is touched: each produced piece
- * states where it truly begins, and it is already read whole in order to be
- * stamped. Only boundaries that were actually produced are counted — the parts
- * somebody watched.
- *
- * Counted ON THE FILE'S OWN TABLE, because that is whose fact it is: the same
- * finding for every quality step of the film and for every later session of it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import { KeyframeTable } from "../services/media/container/KeyframeTable.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const TOLERANCE = 0.25;
-
-/**
- * A table naming keyframes every four seconds, which is what the grid of a
- * copied picture is built from.
- *
- * @returns {KeyframeTable}
- */
-function fourSecondKeyframes() {
-  return new KeyframeTable().learn({
-    times: [0, 4, 8, 12, 16, 20],
-    format: "matroska"
-  });
-}
-
-test("an index that describes its file exactly is reported as such", () => {
-  const table = fourSecondKeyframes();
-
-  for (let index = 0; index < 4; index += 1) {
-    table.witness({ index, trueStart: index * 4, deviationSec: 0, toleranceSec: TOLERANCE });
-  }
-
-  assert.equal(table.evidence.checked, 4);
-  assert.equal(table.evidence.disagreed, 0, "nothing disagreed — which is a finding, not silence");
-  assert.equal(table.evidence.maxDeviationSec, 0);
-});
-
-test("a boundary the index placed wrongly is counted, with how far out it was", () => {
-  const table = fourSecondKeyframes();
-
-  table.witness({ index: 0, trueStart: 0, deviationSec: 0, toleranceSec: TOLERANCE });
-  // The measured shape: the playlist said 157.99 s, the file cut at 153.82 s.
-  table.witness({ index: 2, trueStart: 3.83, deviationSec: 4.17, toleranceSec: TOLERANCE });
-  table.witness({ index: 3, trueStart: 12.01, deviationSec: 0.01, toleranceSec: TOLERANCE });
-
-  assert.equal(table.evidence.checked, 3);
-  assert.equal(table.evidence.disagreed, 1);
-  assert.equal(table.evidence.firstDisagreementIndex, 2);
-  assert.equal(
-    table.evidence.maxDeviationSec,
-    4.17,
-    "the size of the error is what decides whether a rung can be cut on this grid"
-  );
-});
-
-test("a deviation within tolerance is not a disagreement, but still shows in the worst case", () => {
-  const table = fourSecondKeyframes();
-
-  table.witness({ index: 0, trueStart: 0.2, deviationSec: 0.2, toleranceSec: TOLERANCE });
-
-  assert.equal(
-    table.evidence.disagreed,
-    0,
-    "rounding in a container's timestamps is not the index being wrong"
-  );
-  assert.equal(
-    table.evidence.maxDeviationSec,
-    0.2,
-    "and it is still worth knowing how close to the line it ran"
-  );
-});
-
-test("a piece that began at ANOTHER time the table names is told apart from one that began nowhere", () => {
-  // The discriminator, and it decides which of two opposite faults this is. A
-  // piece that began at another keyframe of the same list was not mis-described
-  // by the table: the grid was built over a gap in it. One that began where the
-  // table names nothing is the table describing times the file does not have.
-  // The table answers it itself, because it is the only thing that holds the
-  // list — asked of the caller, it was one more fact travelling by hand.
-  const table = fourSecondKeyframes();
-
-  table.witness({ index: 1, trueStart: 8, deviationSec: 4, toleranceSec: TOLERANCE });
-  table.witness({ index: 2, trueStart: 9.7, deviationSec: 1.7, toleranceSec: TOLERANCE });
-
-  assert.equal(table.evidence.disagreed, 2);
-  assert.equal(table.evidence.landedOnAnotherKeyframe, 1);
-});
-
-test("a table that has read nothing claims no evidence about itself", () => {
-  // It cannot be wrong about a file it has not described. `readable` is false,
-  // every picture of the file is re-encoded, and no copy can witness anything.
-  const table = new KeyframeTable().learn({ times: null, format: "mpegts" });
-
-  assert.equal(table.evidence, null);
-  assert.equal(table.names(4), false);
-});
-
-test("a segment requested again is not new evidence", () => {
-  const table = fourSecondKeyframes();
-
-  for (let repeat = 0; repeat < 3; repeat += 1) {
-    table.witness({ index: 1, trueStart: 4.9, deviationSec: 0.9, toleranceSec: TOLERANCE });
-  }
-
-  assert.equal(table.evidence.checked, 1, "a repeat request is the same boundary, counted once");
-  assert.equal(table.evidence.disagreed, 1);
-});
-
-test("a boundary the index got wrong is replaced by the time the file really has", async (t) => {
-  const { wireOutputs } = await import("../services/server/wire-outputs.js");
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  t.after(() => manager.lifecycle.disposeAll());
-  // ONE table for the film, held by both. It used to be a copy each, kept in
-  // step by writing the correction into every member — which is what the shared
-  // table replaces, and what drifted in the field.
-  const boundaries = [0, 10, 20, 30, 40];
-  const base = {
-    id: "aaaaaaaa11112222",
-    spec: outputSpec({ transcodeVideo: false }),
-    fileName: "film.mkv",
-    state: "ready",
-    timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
-    segmentFormat: { segmentFileName: (index) => `segment-${index}.mp4` }
-  };
-  const rung = {
-    id: "bbbbbbbb11112222",
-    spec: outputSpec({ transcodeVideo: true, height: 540 }),
-    fileName: "film.mkv",
-    state: "ready",
-    timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
-    // A step of the picture: the same file, and made as a step.
-    file: base.file,
-    variantHeight: 540,
-    isStep: true
-  };
-  manager.outputs.set(base.id, base);
-  manager.outputs.set(rung.id, rung);
-  manager.outputs.markStep(rung);
-
-  // The copy produced segment #2, and it really begins at 17.4 s — the index
-  // said 20. This is the shape reproduced from the field on 2026-08-12.
-  manager.outputTimes.correctBoundaryFromSegment(base, 2, 17.4);
-
-  assert.equal(
-    base.timeline.boundaries[2],
-    17.4,
-    "the grid must describe the file, not the index — a rung forced onto 20 s would not join the copy"
-  );
-  assert.equal(
-    rung.timeline.boundaries[2],
-    17.4,
-    "the family shares one grid — the same array, so there is nothing to keep in step"
-  );
-  assert.deepEqual(
-    base.timeline.boundaries,
-    [0, 10, 17.4, 30, 40],
-    "only the boundary that was shown to be wrong moves"
-  );
-
-  // A reading that cannot be a boundary is not evidence about one. It comes
-  // from a run that started somewhere else, and applying it would leave the
-  // table describing nothing.
-  manager.outputTimes.correctBoundaryFromSegment(base, 2, 35);
-  manager.outputTimes.correctBoundaryFromSegment(base, 2, 5);
-  manager.outputTimes.correctBoundaryFromSegment(base, 0, 3);
-  assert.deepEqual(base.timeline.boundaries, [0, 10, 17.4, 30, 40], "out-of-order readings are refused");
-});
+/**
+ * @file How well a container's keyframe index describes its own file.
+ *
+ * The cut times of a copied video ARE its index — ffmpeg can only cut where a
+ * keyframe already is — and an index can be wrong: measured 2026-08-06, one
+ * claimed a keyframe at 157.99 s where the real ones were 153.82 and 164.247.
+ * Whether a re-encoded rung can be cut on that same grid and spliced into the
+ * copy depends entirely on how often that happens, so it is counted.
+ *
+ * No scan is involved and no undownloaded byte is touched: each produced piece
+ * states where it truly begins, and it is already read whole in order to be
+ * stamped. Only boundaries that were actually produced are counted — the parts
+ * somebody watched.
+ *
+ * Counted ON THE FILE'S OWN TABLE, because that is whose fact it is: the same
+ * finding for every quality step of the film and for every later session of it.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { KeyframeTable } from "../services/media/container/KeyframeTable.js";
+import { outputSpec } from "./helpers/output-spec.js";
+
+const TOLERANCE = 0.25;
+
+/**
+ * A table naming keyframes every four seconds, which is what the grid of a
+ * copied picture is built from.
+ *
+ * @returns {KeyframeTable}
+ */
+function fourSecondKeyframes() {
+  return new KeyframeTable().learn({
+    times: [0, 4, 8, 12, 16, 20],
+    format: "matroska"
+  });
+}
+
+test("an index that describes its file exactly is reported as such", () => {
+  const table = fourSecondKeyframes();
+
+  for (let index = 0; index < 4; index += 1) {
+    table.witness({ index, trueStart: index * 4, deviationSec: 0, toleranceSec: TOLERANCE });
+  }
+
+  assert.equal(table.evidence.checked, 4);
+  assert.equal(table.evidence.disagreed, 0, "nothing disagreed — which is a finding, not silence");
+  assert.equal(table.evidence.maxDeviationSec, 0);
+});
+
+test("a boundary the index placed wrongly is counted, with how far out it was", () => {
+  const table = fourSecondKeyframes();
+
+  table.witness({ index: 0, trueStart: 0, deviationSec: 0, toleranceSec: TOLERANCE });
+  // The measured shape: the playlist said 157.99 s, the file cut at 153.82 s.
+  table.witness({ index: 2, trueStart: 3.83, deviationSec: 4.17, toleranceSec: TOLERANCE });
+  table.witness({ index: 3, trueStart: 12.01, deviationSec: 0.01, toleranceSec: TOLERANCE });
+
+  assert.equal(table.evidence.checked, 3);
+  assert.equal(table.evidence.disagreed, 1);
+  assert.equal(table.evidence.firstDisagreementIndex, 2);
+  assert.equal(
+    table.evidence.maxDeviationSec,
+    4.17,
+    "the size of the error is what decides whether a rung can be cut on this grid"
+  );
+});
+
+test("a deviation within tolerance is not a disagreement, but still shows in the worst case", () => {
+  const table = fourSecondKeyframes();
+
+  table.witness({ index: 0, trueStart: 0.2, deviationSec: 0.2, toleranceSec: TOLERANCE });
+
+  assert.equal(
+    table.evidence.disagreed,
+    0,
+    "rounding in a container's timestamps is not the index being wrong"
+  );
+  assert.equal(
+    table.evidence.maxDeviationSec,
+    0.2,
+    "and it is still worth knowing how close to the line it ran"
+  );
+});
+
+test("a piece that began at ANOTHER time the table names is told apart from one that began nowhere", () => {
+  // The discriminator, and it decides which of two opposite faults this is. A
+  // piece that began at another keyframe of the same list was not mis-described
+  // by the table: the grid was built over a gap in it. One that began where the
+  // table names nothing is the table describing times the file does not have.
+  // The table answers it itself, because it is the only thing that holds the
+  // list — asked of the caller, it was one more fact travelling by hand.
+  const table = fourSecondKeyframes();
+
+  table.witness({ index: 1, trueStart: 8, deviationSec: 4, toleranceSec: TOLERANCE });
+  table.witness({ index: 2, trueStart: 9.7, deviationSec: 1.7, toleranceSec: TOLERANCE });
+
+  assert.equal(table.evidence.disagreed, 2);
+  assert.equal(table.evidence.landedOnAnotherKeyframe, 1);
+});
+
+test("a table that has read nothing claims no evidence about itself", () => {
+  // It cannot be wrong about a file it has not described. `readable` is false,
+  // every picture of the file is re-encoded, and no copy can witness anything.
+  const table = new KeyframeTable().learn({ times: null, format: "mpegts" });
+
+  assert.equal(table.evidence, null);
+  assert.equal(table.names(4), false);
+});
+
+test("a segment requested again is not new evidence", () => {
+  const table = fourSecondKeyframes();
+
+  for (let repeat = 0; repeat < 3; repeat += 1) {
+    table.witness({ index: 1, trueStart: 4.9, deviationSec: 0.9, toleranceSec: TOLERANCE });
+  }
+
+  assert.equal(table.evidence.checked, 1, "a repeat request is the same boundary, counted once");
+  assert.equal(table.evidence.disagreed, 1);
+});
+
+test("a boundary the index got wrong is replaced by the time the file really has", async (t) => {
+  const { wireOutputs } = await import("../services/server/wire-outputs.js");
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  t.after(() => manager.lifecycle.disposeAll());
+  // ONE table for the film, held by both. It used to be a copy each, kept in
+  // step by writing the correction into every member — which is what the shared
+  // table replaces, and what drifted in the field.
+  const boundaries = [0, 10, 20, 30, 40];
+  const base = {
+    id: "aaaaaaaa11112222",
+    spec: outputSpec({ transcodeVideo: false }),
+    fileName: "film.mkv",
+    state: "ready",
+    timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
+    segmentFormat: { segmentFileName: (index) => `segment-${index}.mp4` }
+  };
+  const rung = {
+    id: "bbbbbbbb11112222",
+    spec: outputSpec({ transcodeVideo: true, height: 540 }),
+    fileName: "film.mkv",
+    state: "ready",
+    timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
+    // A step of the picture: the same file, and made as a step.
+    file: base.file,
+    variantHeight: 540,
+    isStep: true
+  };
+  manager.outputs.set(base.id, base);
+  manager.outputs.set(rung.id, rung);
+  manager.outputs.markStep(rung);
+
+  // The copy produced segment #2, and it really begins at 17.4 s — the index
+  // said 20. This is the shape reproduced from the field on 2026-08-12.
+  manager.outputTimes.correctBoundaryFromSegment(base, 2, 17.4);
+
+  assert.equal(
+    base.timeline.boundaries[2],
+    17.4,
+    "the grid must describe the file, not the index — a rung forced onto 20 s would not join the copy"
+  );
+  assert.equal(
+    rung.timeline.boundaries[2],
+    17.4,
+    "the family shares one grid — the same array, so there is nothing to keep in step"
+  );
+  assert.deepEqual(
+    base.timeline.boundaries,
+    [0, 10, 17.4, 30, 40],
+    "only the boundary that was shown to be wrong moves"
+  );
+
+  // A reading that cannot be a boundary is not evidence about one. It comes
+  // from a run that started somewhere else, and applying it would leave the
+  // table describing nothing.
+  manager.outputTimes.correctBoundaryFromSegment(base, 2, 35);
+  manager.outputTimes.correctBoundaryFromSegment(base, 2, 5);
+  manager.outputTimes.correctBoundaryFromSegment(base, 0, 3);
+  assert.deepEqual(base.timeline.boundaries, [0, 10, 17.4, 30, 40], "out-of-order readings are refused");
+});