@torrent-tv/proxy 2.88.4 → 2.88.5

package/test/produced-copy-choice.test.js

@@ -1,213 +1,213 @@
-/**
- * @file A piece that cannot be played: waited for, or removed and made again.
- *
- * Field 2026-09-03. A run was suspended 548 ms after it started with
- * `segment-00025.mp4` newly opened, so the file stayed at zero bytes. From then
- * on the two halves of the proxy disagreed about it and neither could see the
- * other's reason: the look-ahead counted the NAME, found the numbering unbroken
- * through #83, called it `420s ahead of the viewer` and kept the encoder
- * stopped; the serving path read the FILE, found it short of a track, and
- * waited for a run that had produced nothing to finish it.
- *
- * The viewer's picture stood still for ten minutes on a transport measuring
- * 3-9 ms round trip.
- *
- * The question of WHICH copy answers is gone with the directory-per-run scheme:
- * there is one directory per output, runs are kept apart by their stretches,
- * and one name is one file. What is left is the question that remains real —
- * whether a file that cannot be played is being written now or was left by a
- * run that has ended.
- */
-
-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 { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { managerWithOwnStore } from "./helpers/manager.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const MOVIE_TIMESCALE = 1000;
-const VIDEO_TIMESCALE = 90_000;
-const AUDIO_TIMESCALE = 48_000;
-const SEGMENT_SECONDS = 12.5;
-const SESSION_ID = "aef21c88a8d64a9a";
-
-/**
- * @param {string} type
- * @param {Buffer} body
- * @returns {Buffer}
- */
-function box(type, body) {
-  const head = Buffer.alloc(8);
-  head.writeUInt32BE(8 + body.length, 0);
-  head.write(type, 4, "latin1");
-  return Buffer.concat([head, body]);
-}
-
-/**
- * @param {number} offsetSeconds
- * @returns {Buffer}
- */
-function emptyEdit(offsetSeconds) {
-  const body = Buffer.alloc(16);
-  body.writeUInt32BE(1, 4);
-  body.writeUInt32BE(Math.round(offsetSeconds * MOVIE_TIMESCALE), 8);
-  body.writeInt32BE(-1, 12);
-  return box("elst", body);
-}
-
-/**
- * @param {number} trackId
- * @param {number} timescale
- * @param {number} offsetSeconds
- * @returns {Buffer}
- */
-function trak(trackId, timescale, offsetSeconds) {
-  const tkhdBody = Buffer.alloc(84);
-  tkhdBody.writeUInt32BE(trackId, 12);
-  const mdhdBody = Buffer.alloc(20);
-  mdhdBody.writeUInt32BE(timescale, 12);
-  return box("trak", Buffer.concat([
-    box("tkhd", tkhdBody),
-    box("edts", emptyEdit(offsetSeconds)),
-    box("mdia", box("mdhd", mdhdBody))
-  ]));
-}
-
-/**
- * @param {number} trackId
- * @returns {Buffer}
- */
-function traf(trackId) {
-  const tfhdBody = Buffer.alloc(8);
-  tfhdBody.writeUInt32BE(trackId, 4);
-  const tfdtBody = Buffer.alloc(12);
-  tfdtBody.writeUInt8(1, 0);
-  tfdtBody.writeBigUInt64BE(0n, 4);
-  return box("traf", Buffer.concat([box("tfhd", tfhdBody), box("tfdt", tfdtBody)]));
-}
-
-/**
- * A piece shaped like the `segment` muxer's output, carrying both tracks.
- *
- * @param {number} offsetSeconds
- * @returns {Buffer}
- */
-function wholePiece(offsetSeconds) {
-  const mvhdBody = Buffer.alloc(100);
-  mvhdBody.writeUInt32BE(MOVIE_TIMESCALE, 12);
-  const moov = box("moov", Buffer.concat([
-    box("mvhd", mvhdBody),
-    trak(1, VIDEO_TIMESCALE, offsetSeconds),
-    trak(2, AUDIO_TIMESCALE, offsetSeconds)
-  ]));
-  const moof = box("moof", Buffer.concat([traf(1), traf(2)]));
-  return Buffer.concat([
-    box("ftyp", Buffer.alloc(16, 0)),
-    moov,
-    moof,
-    box("mdat", Buffer.alloc(64, 0x5a)),
-    box("mfra", Buffer.alloc(24, 0))
-  ]);
-}
-
-
-/**
- * A session with the output directory every run writes into.
- *
- * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
- */
-async function sessionOnOneDirectory() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "produced-copy-"));
-  // Its own store root — see `helpers/manager.js` for what sharing one cost.
-  const { manager } = managerWithOwnStore();
-  const session = {
-    id: SESSION_ID,
-    spec: outputSpec({ transcodeVideo: false }),
-    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.
-    timeline: new Timeline({
-      boundaries: [0, SEGMENT_SECONDS, 25, 37.5, 50],
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "Drifters - 04.mkv" }),
-    // An ordinary session reads its own file, and its sound is inside it. The
-    // three differ only for a soundtrack shipped as a file of its own.
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    startedAt: Date.now(),
-    lastAccessedAt: Date.now(),
-    runs: new Set(),
-    lastError: "",
-    segmentFormat: fmp4Format,
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    initBytes: fmp4Format.extractInit(wholePiece(0)),
-    waitEpoch: 0
-  };
-  manager.outputs.set(SESSION_ID, session);
-  // A run exists and is alive — the state the field case was in, and the one in
-  // which the old test called every leftover "still being written".
-  startRunOn(session, { from: 0, usesExplicitCuts: true });
-  return { manager, session, dirPath };
-}
-
-
-
-test("a leftover of a run that has ended is not served, and answering does not delete it", async (t) => {
-  const { manager, session, dirPath } = await sessionOnOneDirectory();
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // Opened by a run that is gone. It has a name and no bytes, so there is
-  // nothing to serve.
-  session.runs = new Set();
-  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
-
-  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00001.mp4");
-
-  assert.equal(result.kind, "warming-up", "nothing servable exists yet, so the viewer waits");
-  // AND ANSWERING A REQUEST DELETES NOTHING. It used to: this test was written
-  // when the serving path cleared up after ended runs, and several runs of an
-  // output share one directory — so what a request removed could be the piece a
-  // LIVE run had just finished. Clearing up belongs to the ending of a run,
-  // which is the only thing that knows what it left open and what it named
-  // and it knows because the piece is under that run's own working name
-  // (`SegmentStore.clearUpAfter`, checked in `segment-store.test.js`). A file
-  // with no bytes is
-  // ignored by everything that reads the directory, so leaving it costs nothing
-  // and deleting it from here costs a segment.
-  const left = (await readdir(dirPath)).filter((name) => name === "segment-00001.mp4");
-  assert.deepEqual(left, ["segment-00001.mp4"]);
-});
-
-test("the current run's own unfinished piece is waited for, never deleted", async (t) => {
-  const { manager, session, dirPath } = await sessionOnOneDirectory();
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // The same file, in the directory of the run that is alive. It is being
-  // written right now. Deleting it is the 2026-08-06 incident: #225 was removed
-  // 14 s into the run producing it, which then wrote on into a file nobody
-  // could open, and the segment never appeared.
-  //
-  // The live run begins at #1, so #1 is its own first piece.
-  startRunOn(session, { from: 1, producing: false, usesExplicitCuts: true });
-  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
-
-  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00001.mp4");
-
-  assert.equal(result.kind, "warming-up");
-  const left = (await readdir(dirPath)).filter((name) => name === "segment-00001.mp4");
-  assert.deepEqual(left, ["segment-00001.mp4"], "the live run's own output must be left alone");
-});
-
+/**
+ * @file A piece that cannot be played: waited for, or removed and made again.
+ *
+ * Field 2026-09-03. A run was suspended 548 ms after it started with
+ * `segment-00025.mp4` newly opened, so the file stayed at zero bytes. From then
+ * on the two halves of the proxy disagreed about it and neither could see the
+ * other's reason: the look-ahead counted the NAME, found the numbering unbroken
+ * through #83, called it `420s ahead of the viewer` and kept the encoder
+ * stopped; the serving path read the FILE, found it short of a track, and
+ * waited for a run that had produced nothing to finish it.
+ *
+ * The viewer's picture stood still for ten minutes on a transport measuring
+ * 3-9 ms round trip.
+ *
+ * The question of WHICH copy answers is gone with the directory-per-run scheme:
+ * there is one directory per output, runs are kept apart by their stretches,
+ * and one name is one file. What is left is the question that remains real —
+ * whether a file that cannot be played is being written now or was left by a
+ * run that has ended.
+ */
+
+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 { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { managerWithOwnStore } from "./helpers/manager.js";
+import { startRunOn } from "./helpers/encode-run.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+import { outputSpec } from "./helpers/output-spec.js";
+
+const MOVIE_TIMESCALE = 1000;
+const VIDEO_TIMESCALE = 90_000;
+const AUDIO_TIMESCALE = 48_000;
+const SEGMENT_SECONDS = 12.5;
+const SESSION_ID = "aef21c88a8d64a9a";
+
+/**
+ * @param {string} type
+ * @param {Buffer} body
+ * @returns {Buffer}
+ */
+function box(type, body) {
+  const head = Buffer.alloc(8);
+  head.writeUInt32BE(8 + body.length, 0);
+  head.write(type, 4, "latin1");
+  return Buffer.concat([head, body]);
+}
+
+/**
+ * @param {number} offsetSeconds
+ * @returns {Buffer}
+ */
+function emptyEdit(offsetSeconds) {
+  const body = Buffer.alloc(16);
+  body.writeUInt32BE(1, 4);
+  body.writeUInt32BE(Math.round(offsetSeconds * MOVIE_TIMESCALE), 8);
+  body.writeInt32BE(-1, 12);
+  return box("elst", body);
+}
+
+/**
+ * @param {number} trackId
+ * @param {number} timescale
+ * @param {number} offsetSeconds
+ * @returns {Buffer}
+ */
+function trak(trackId, timescale, offsetSeconds) {
+  const tkhdBody = Buffer.alloc(84);
+  tkhdBody.writeUInt32BE(trackId, 12);
+  const mdhdBody = Buffer.alloc(20);
+  mdhdBody.writeUInt32BE(timescale, 12);
+  return box("trak", Buffer.concat([
+    box("tkhd", tkhdBody),
+    box("edts", emptyEdit(offsetSeconds)),
+    box("mdia", box("mdhd", mdhdBody))
+  ]));
+}
+
+/**
+ * @param {number} trackId
+ * @returns {Buffer}
+ */
+function traf(trackId) {
+  const tfhdBody = Buffer.alloc(8);
+  tfhdBody.writeUInt32BE(trackId, 4);
+  const tfdtBody = Buffer.alloc(12);
+  tfdtBody.writeUInt8(1, 0);
+  tfdtBody.writeBigUInt64BE(0n, 4);
+  return box("traf", Buffer.concat([box("tfhd", tfhdBody), box("tfdt", tfdtBody)]));
+}
+
+/**
+ * A piece shaped like the `segment` muxer's output, carrying both tracks.
+ *
+ * @param {number} offsetSeconds
+ * @returns {Buffer}
+ */
+function wholePiece(offsetSeconds) {
+  const mvhdBody = Buffer.alloc(100);
+  mvhdBody.writeUInt32BE(MOVIE_TIMESCALE, 12);
+  const moov = box("moov", Buffer.concat([
+    box("mvhd", mvhdBody),
+    trak(1, VIDEO_TIMESCALE, offsetSeconds),
+    trak(2, AUDIO_TIMESCALE, offsetSeconds)
+  ]));
+  const moof = box("moof", Buffer.concat([traf(1), traf(2)]));
+  return Buffer.concat([
+    box("ftyp", Buffer.alloc(16, 0)),
+    moov,
+    moof,
+    box("mdat", Buffer.alloc(64, 0x5a)),
+    box("mfra", Buffer.alloc(24, 0))
+  ]);
+}
+
+
+/**
+ * A session with the output directory every run writes into.
+ *
+ * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
+ */
+async function sessionOnOneDirectory() {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "produced-copy-"));
+  // Its own store root — see `helpers/manager.js` for what sharing one cost.
+  const { manager } = managerWithOwnStore();
+  const session = {
+    id: SESSION_ID,
+    spec: outputSpec({ transcodeVideo: false }),
+    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.
+    timeline: new Timeline({
+      boundaries: [0, SEGMENT_SECONDS, 25, 37.5, 50],
+      cutGrid: "uniform"
+    }),
+    state: "ready",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "Drifters - 04.mkv" }),
+    // An ordinary session reads its own file, and its sound is inside it. The
+    // three differ only for a soundtrack shipped as a file of its own.
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
+    startedAt: Date.now(),
+    lastAccessedAt: Date.now(),
+    runs: new Set(),
+    lastError: "",
+    segmentFormat: fmp4Format,
+    useSyntheticPlaylist: true,
+    playlistText: "#EXTM3U\n",
+    initBytes: fmp4Format.extractInit(wholePiece(0)),
+    waitEpoch: 0
+  };
+  manager.outputs.set(SESSION_ID, session);
+  // A run exists and is alive — the state the field case was in, and the one in
+  // which the old test called every leftover "still being written".
+  startRunOn(session, { from: 0, usesExplicitCuts: true });
+  return { manager, session, dirPath };
+}
+
+
+
+test("a leftover of a run that has ended is not served, and answering does not delete it", async (t) => {
+  const { manager, session, dirPath } = await sessionOnOneDirectory();
+  t.after(async () => {
+    await manager.lifecycle.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // Opened by a run that is gone. It has a name and no bytes, so there is
+  // nothing to serve.
+  session.runs = new Set();
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
+
+  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00001.mp4");
+
+  assert.equal(result.kind, "warming-up", "nothing servable exists yet, so the viewer waits");
+  // AND ANSWERING A REQUEST DELETES NOTHING. It used to: this test was written
+  // when the serving path cleared up after ended runs, and several runs of an
+  // output share one directory — so what a request removed could be the piece a
+  // LIVE run had just finished. Clearing up belongs to the ending of a run,
+  // which is the only thing that knows what it left open and what it named
+  // and it knows because the piece is under that run's own working name
+  // (`SegmentStore.clearUpAfter`, checked in `segment-store.test.js`). A file
+  // with no bytes is
+  // ignored by everything that reads the directory, so leaving it costs nothing
+  // and deleting it from here costs a segment.
+  const left = (await readdir(dirPath)).filter((name) => name === "segment-00001.mp4");
+  assert.deepEqual(left, ["segment-00001.mp4"]);
+});
+
+test("the current run's own unfinished piece is waited for, never deleted", async (t) => {
+  const { manager, session, dirPath } = await sessionOnOneDirectory();
+  t.after(async () => {
+    await manager.lifecycle.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // The same file, in the directory of the run that is alive. It is being
+  // written right now. Deleting it is the 2026-08-06 incident: #225 was removed
+  // 14 s into the run producing it, which then wrote on into a file nobody
+  // could open, and the segment never appeared.
+  //
+  // The live run begins at #1, so #1 is its own first piece.
+  startRunOn(session, { from: 1, producing: false, usesExplicitCuts: true });
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
+
+  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00001.mp4");
+
+  assert.equal(result.kind, "warming-up");
+  const left = (await readdir(dirPath)).filter((name) => name === "segment-00001.mp4");
+  assert.deepEqual(left, ["segment-00001.mp4"], "the live run's own output must be left alone");
+});
+

package/test/published-timeline.test.js

@@ -1,83 +1,83 @@
-/**
- * @file A segment must be stamped where the playlist the player holds says.
- *
- * The field case this pins, 2026-08-17: a seek to 1590.4 s restarted the audio
- * rendition at #291; the produced segments #292 and #293 carried their own
- * positions, 1587.892 s and 1592.692 s, while the playlist the browser was
- * holding said 1585.376 s and 1590.585 s. The browser fetched those two
- * segments **1908 times each** over ten minutes, every one served in 4 ms, and
- * the film never moved: a fragment appended more than `maxBufferHole` away from
- * where the playlist put it is not recognised as buffered, so the player asks
- * for it again.
- *
- * The rule, and the reason it is not simply "always use the file's own time":
- * the boundary table keeps being corrected from produced segments, and the
- * playlist does not. Whichever is right about the FILE, only one of them was
- * sent to the player.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-/**
- * hls.js's own default. A gap smaller than this is skipped; a larger one is a
- * hole, and the fragment across it counts as not loaded.
- */
-const PLAYER_BUFFER_HOLE_SEC = 0.5;
-
-/**
- * The decision under test, in the shape the session manager applies it.
- *
- * @param {{ trueStart: number | null, publishedStart: number }} reading
- * @returns {{ stamp: number, followedPlaylist: boolean }}
- */
-function stampFor({ trueStart, publishedStart }) {
-  if (trueStart === null) {
-    return { stamp: publishedStart, followedPlaylist: true };
-  }
-  if (Math.abs(trueStart - publishedStart) > PLAYER_BUFFER_HOLE_SEC) {
-    return { stamp: publishedStart, followedPlaylist: true };
-  }
-  return { stamp: trueStart, followedPlaylist: false };
-}
-
-test("the field case: a segment far from its playlist position is stamped where the playlist says", () => {
-  const segment292 = stampFor({ trueStart: 1587.892, publishedStart: 1585.376 });
-  assert.equal(segment292.stamp, 1585.376);
-  assert.equal(segment292.followedPlaylist, true);
-
-  const segment293 = stampFor({ trueStart: 1592.692, publishedStart: 1590.585 });
-  assert.equal(segment293.stamp, 1590.585);
-});
-
-test("a file whose index is honest keeps its own position", () => {
-  // Within what a player bridges, the file's own figure is the truthful one and
-  // it is what keeps speech and subtitles together (2026-08-06, 4.17 s of drift
-  // when the picture was stamped from a lying index).
-  const reading = stampFor({ trueStart: 120.13, publishedStart: 120.0 });
-  assert.equal(reading.stamp, 120.13);
-  assert.equal(reading.followedPlaylist, false);
-});
-
-test("the boundary is exactly the player's own tolerance", () => {
-  assert.equal(stampFor({ trueStart: 10.5, publishedStart: 10.0 }).stamp, 10.5);
-  assert.equal(stampFor({ trueStart: 10.51, publishedStart: 10.0 }).stamp, 10.0);
-});
-
-test("a segment that does not say where it begins is stamped from the playlist", () => {
-  assert.equal(stampFor({ trueStart: null, publishedStart: 42.0 }).stamp, 42.0);
-});
-
-test("a corrected boundary does not move the stamp of a session already playing", () => {
-  // The correction writes into the live table; the published one is frozen. If
-  // the stamp followed the live table, every correction would move segments
-  // under a player holding the original playlist — which is the same failure
-  // seen from the other side.
-  const published = [0, 4, 8, 12];
-  const live = [...published];
-  live[2] = 9.7; // corrected from a produced segment
-  const publishedStart = published[2];
-  const reading = stampFor({ trueStart: live[2], publishedStart });
-  assert.equal(publishedStart, 8);
-  assert.equal(reading.stamp, 8, "the player was told 8 s and must be given 8 s");
-});
+/**
+ * @file A segment must be stamped where the playlist the player holds says.
+ *
+ * The field case this pins, 2026-08-17: a seek to 1590.4 s restarted the audio
+ * rendition at #291; the produced segments #292 and #293 carried their own
+ * positions, 1587.892 s and 1592.692 s, while the playlist the browser was
+ * holding said 1585.376 s and 1590.585 s. The browser fetched those two
+ * segments **1908 times each** over ten minutes, every one served in 4 ms, and
+ * the film never moved: a fragment appended more than `maxBufferHole` away from
+ * where the playlist put it is not recognised as buffered, so the player asks
+ * for it again.
+ *
+ * The rule, and the reason it is not simply "always use the file's own time":
+ * the boundary table keeps being corrected from produced segments, and the
+ * playlist does not. Whichever is right about the FILE, only one of them was
+ * sent to the player.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+/**
+ * hls.js's own default. A gap smaller than this is skipped; a larger one is a
+ * hole, and the fragment across it counts as not loaded.
+ */
+const PLAYER_BUFFER_HOLE_SEC = 0.5;
+
+/**
+ * The decision under test, in the shape the session manager applies it.
+ *
+ * @param {{ trueStart: number | null, publishedStart: number }} reading
+ * @returns {{ stamp: number, followedPlaylist: boolean }}
+ */
+function stampFor({ trueStart, publishedStart }) {
+  if (trueStart === null) {
+    return { stamp: publishedStart, followedPlaylist: true };
+  }
+  if (Math.abs(trueStart - publishedStart) > PLAYER_BUFFER_HOLE_SEC) {
+    return { stamp: publishedStart, followedPlaylist: true };
+  }
+  return { stamp: trueStart, followedPlaylist: false };
+}
+
+test("the field case: a segment far from its playlist position is stamped where the playlist says", () => {
+  const segment292 = stampFor({ trueStart: 1587.892, publishedStart: 1585.376 });
+  assert.equal(segment292.stamp, 1585.376);
+  assert.equal(segment292.followedPlaylist, true);
+
+  const segment293 = stampFor({ trueStart: 1592.692, publishedStart: 1590.585 });
+  assert.equal(segment293.stamp, 1590.585);
+});
+
+test("a file whose index is honest keeps its own position", () => {
+  // Within what a player bridges, the file's own figure is the truthful one and
+  // it is what keeps speech and subtitles together (2026-08-06, 4.17 s of drift
+  // when the picture was stamped from a lying index).
+  const reading = stampFor({ trueStart: 120.13, publishedStart: 120.0 });
+  assert.equal(reading.stamp, 120.13);
+  assert.equal(reading.followedPlaylist, false);
+});
+
+test("the boundary is exactly the player's own tolerance", () => {
+  assert.equal(stampFor({ trueStart: 10.5, publishedStart: 10.0 }).stamp, 10.5);
+  assert.equal(stampFor({ trueStart: 10.51, publishedStart: 10.0 }).stamp, 10.0);
+});
+
+test("a segment that does not say where it begins is stamped from the playlist", () => {
+  assert.equal(stampFor({ trueStart: null, publishedStart: 42.0 }).stamp, 42.0);
+});
+
+test("a corrected boundary does not move the stamp of a session already playing", () => {
+  // The correction writes into the live table; the published one is frozen. If
+  // the stamp followed the live table, every correction would move segments
+  // under a player holding the original playlist — which is the same failure
+  // seen from the other side.
+  const published = [0, 4, 8, 12];
+  const live = [...published];
+  live[2] = 9.7; // corrected from a produced segment
+  const publishedStart = published[2];
+  const reading = stampFor({ trueStart: live[2], publishedStart });
+  assert.equal(publishedStart, 8);
+  assert.equal(reading.stamp, 8, "the player was told 8 s and must be given 8 s");
+});