@torrent-tv/proxy 2.72.0 → 2.72.2

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

@@ -0,0 +1,361 @@
+/**
+ * @file When several runs have written the same segment number, which copy
+ * answers — and what happens to the one that cannot.
+ *
+ * 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. A complete copy of
+ * #25 lay in the previous run's directory the whole time and was never reached,
+ * because the search returned the first name it found and stopped.
+ *
+ * The viewer's picture stood still for ten minutes with the bytes they needed
+ * already on the disk, on a transport measuring 3-9 ms round trip.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import {
+  HlsSessionManager,
+  discardOpenPiece,
+  usableSegmentIndices
+} from "../services/hls-session-manager.js";
+import { fmp4Format } from "../services/segment-formats/fmp4.js";
+
+const MOVIE_TIMESCALE = 1000;
+const VIDEO_TIMESCALE = 90_000;
+const AUDIO_TIMESCALE = 48_000;
+const SEGMENT_SECONDS = 12.5;
+const SESSION_ID = "aef21c88-a8d6-4a9a-8e7a-d0a9536351cf";
+
+/**
+ * @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))
+  ]);
+}
+
+/**
+ * The same shape with ONE track in the fragment — what a run killed mid-write
+ * leaves when it had muxed the picture and not yet the sound.
+ *
+ * @param {number} offsetSeconds
+ * @returns {Buffer}
+ */
+function halfPiece(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)
+  ]));
+  return Buffer.concat([
+    box("ftyp", Buffer.alloc(16, 0)),
+    moov,
+    box("moof", traf(1)),
+    box("mdat", Buffer.alloc(64, 0x5a))
+  ]);
+}
+
+/**
+ * A session whose runs are laid out on disk exactly as the field case was.
+ *
+ * @returns {Promise<{ manager: HlsSessionManager, session: object, dirPath: string }>}
+ */
+async function sessionWithTwoRuns() {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "produced-copy-"));
+  await mkdir(path.join(dirPath, "run-1"), { recursive: true });
+  await mkdir(path.join(dirPath, "run-2"), { recursive: true });
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const session = {
+    id: SESSION_ID,
+    dirPath,
+    runDirPath: path.join(dirPath, "run-2"),
+    runSerial: 2,
+    state: "ready",
+    fileName: "Drifters - 04.mkv",
+    startedAt: Date.now(),
+    createEntryMs: Date.now(),
+    lastAccessedAt: Date.now(),
+    // 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".
+    ffmpeg: { pid: 0, killed: false, kill() {} },
+    lastError: "",
+    consumers: new Set(),
+    netReports: new Map(),
+    segmentFormat: fmp4Format,
+    usesExplicitCuts: true,
+    useSyntheticPlaylist: true,
+    playlistText: "#EXTM3U\n",
+    segmentBoundaries: [0, SEGMENT_SECONDS, 25, 37.5, 50],
+    initBytes: fmp4Format.extractInit(wholePiece(0)),
+    encodeStartIndex: 0,
+    firstSegmentLogged: false,
+    waitEpoch: 0
+  };
+  manager.sessionsById.set(SESSION_ID, session);
+  return { manager, session, dirPath };
+}
+
+test("the complete copy answers when the newest run's is empty", async (t) => {
+  const { manager, dirPath } = await sessionWithTwoRuns();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // run-1 made this segment and finished it; run-2 opened it and was stopped.
+  await writeFile(path.join(dirPath, "run-1", "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
+  await writeFile(path.join(dirPath, "run-1", "segment-00002.mp4"), wholePiece(25));
+  await writeFile(path.join(dirPath, "run-2", "segment-00001.mp4"), Buffer.alloc(0));
+
+  const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
+
+  assert.equal(
+    result.kind,
+    "file",
+    "a complete copy exists one run away; holding here is what froze the picture for ten minutes"
+  );
+  const chunks = [];
+  for await (const chunk of result.stream) {
+    chunks.push(chunk);
+  }
+  assert.ok(Buffer.concat(chunks).length > 0, "and it must be the copy with bytes in it");
+});
+
+test("a copy short of a track is passed over for an older one that is whole", async (t) => {
+  const { manager, dirPath } = await sessionWithTwoRuns();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // Not empty — a terminated run closes its file properly, with only what it
+  // had muxed by then, which after a seek-restart is routinely one track of two.
+  await writeFile(path.join(dirPath, "run-1", "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
+  await writeFile(path.join(dirPath, "run-1", "segment-00002.mp4"), wholePiece(25));
+  await writeFile(path.join(dirPath, "run-2", "segment-00001.mp4"), halfPiece(SEGMENT_SECONDS));
+
+  const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
+
+  assert.equal(result.kind, "file", "a piece carrying one track of two is not servable; the whole one is");
+});
+
+test("a leftover of a run that has ended is removed, not waited on", async (t) => {
+  const { manager, dirPath } = await sessionWithTwoRuns();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // The only copy, and it belongs to a run that is gone. The current run —
+  // run-2 — has written nothing, so calling this "still being written" waits on
+  // a process that will never touch it.
+  await writeFile(path.join(dirPath, "run-1", "segment-00001.mp4"), Buffer.alloc(0));
+
+  const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
+
+  assert.equal(result.kind, "warming-up", "nothing servable exists yet, so the viewer waits");
+  const left = await readdir(path.join(dirPath, "run-1"));
+  assert.deepEqual(
+    left,
+    [],
+    "and the unusable file must go, or the current run's own output is never looked for"
+  );
+});
+
+test("the current run's own unfinished piece is waited for, never deleted", async (t) => {
+  const { manager, session, dirPath } = await sessionWithTwoRuns();
+  t.after(async () => {
+    await manager.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.
+  session.encodeStartIndex = 1;
+  await writeFile(path.join(dirPath, "run-2", "segment-00001.mp4"), Buffer.alloc(0));
+
+  const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
+
+  assert.equal(result.kind, "warming-up");
+  const left = await readdir(path.join(dirPath, "run-2"));
+  assert.deepEqual(left, ["segment-00001.mp4"], "the live run's own output must be left alone");
+});
+
+test("the look-ahead does not count a file with nothing in it", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "usable-indices-"));
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  const runTwo = path.join(dirPath, "run-2");
+  const runOne = path.join(dirPath, "run-1");
+  await mkdir(runTwo, { recursive: true });
+  await mkdir(runOne, { recursive: true });
+  await writeFile(path.join(runTwo, "segment-00000.mp4"), wholePiece(0));
+  await writeFile(path.join(runTwo, "segment-00001.mp4"), Buffer.alloc(0));
+
+  assert.deepEqual(
+    [...usableSegmentIndices([runTwo, runOne], fmp4Format, new Set())].sort((a, b) => a - b),
+    [0],
+    "an empty file bridged the hole and bought the encoder a suspension it had not earned"
+  );
+
+  // The same number, made properly by an earlier run: now it genuinely is ready.
+  await writeFile(path.join(runOne, "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
+  assert.deepEqual(
+    [...usableSegmentIndices([runTwo, runOne], fmp4Format, new Set())].sort((a, b) => a - b),
+    [0, 1],
+    "some run holds a copy with bytes in it, which is what the serving path will find"
+  );
+});
+
+test("what a run holds is asked of the filesystem once per file", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "usable-memo-"));
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  const runOne = path.join(dirPath, "run-1");
+  await mkdir(runOne, { recursive: true });
+  await writeFile(path.join(runOne, "segment-00000.mp4"), wholePiece(0));
+  const known = new Set();
+
+  usableSegmentIndices([runOne], fmp4Format, known);
+
+  assert.deepEqual(
+    [...known],
+    [path.join(runOne, "segment-00000.mp4")],
+    "a piece that has bytes never loses them, and this runs on the thread carrying the data channel"
+  );
+});
+
+test("a run killed with a piece open leaves nothing behind", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "open-piece-"));
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  await writeFile(path.join(dirPath, "segment-00000.mp4"), wholePiece(0));
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
+
+  assert.equal(await discardOpenPiece(dirPath, fmp4Format, null), 1);
+  assert.deepEqual(
+    await readdir(dirPath),
+    ["segment-00000.mp4"],
+    "only the piece that was open goes; everything the run finished stays"
+  );
+});
+
+test("a run that finished its last piece keeps it", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "open-piece-good-"));
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  await writeFile(path.join(dirPath, "segment-00000.mp4"), wholePiece(0));
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
+
+  assert.equal(
+    await discardOpenPiece(dirPath, fmp4Format, () => true),
+    null,
+    "a stop between two cuts leaves good output; deleting it means encoding it twice"
+  );
+  assert.equal((await readdir(dirPath)).length, 2);
+});
+
+test("a last piece short of a track goes, even though it has bytes", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "open-piece-half-"));
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  await writeFile(path.join(dirPath, "segment-00000.mp4"), wholePiece(0));
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), halfPiece(SEGMENT_SECONDS));
+  const init = fmp4Format.extractInit(wholePiece(0));
+
+  assert.equal(
+    await discardOpenPiece(dirPath, fmp4Format, (raw) =>
+      fmp4Format.hasEveryTrack(fmp4Format.stripInit(raw), init)),
+    1,
+    "a size above zero is not the same as a piece that can be played"
+  );
+});

package/test/subtitle-cue-framing.test.js

@@ -0,0 +1,202 @@
+/**
+ * @file Two axes, kept apart: the framing a CONTAINER puts round a cue, and the
+ * markup the CODEC puts inside it.
+ *
+ * Field 2026-09-03, an English track of an embedded `.mkv`: the viewer was
+ * shown `21,0,Default,,0000,0000,0000,,I am the powerful Demon King of the
+ * Sixth Heaven.` — the whole dialogue row, fields and all. The cause was one
+ * function doing both jobs and deciding which framing it held by counting
+ * commas: it expected the ten fields a row has in a FILE, a Matroska block
+ * carries nine, so it returned the row untouched.
+ *
+ * What each check here pins is therefore not "ASS is stripped" but "the right
+ * side answers": the container takes off what it put on, and the codec takes
+ * off what it put in. The case that matters most is the last one — the same
+ * line of dialogue, stored two ways, coming out identical.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { AviContainer } from "../services/container/AviContainer.js";
+import { MatroskaContainer } from "../services/container/MatroskaContainer.js";
+import { Mp4Container } from "../services/container/Mp4Container.js";
+import { SubtitleFileContainer } from "../services/container/SubtitleFileContainer.js";
+import { convertSubtitleToVtt, cuesToVtt, finalizeCues } from "../services/subtitle-convert.js";
+import { MarkupKind, markupKindOf, plainCueText } from "../services/tracks/subtitle-markup.js";
+import { TextSubtitleTrack } from "../services/tracks/TextSubtitleTrack.js";
+
+/** The line from the field report, as Matroska stores it. */
+const FIELD_BLOCK =
+  "21,0,Default,,0000,0000,0000,,I am the powerful Demon King of the Sixth Heaven. Good... Evil...";
+
+function block(text) {
+  return Buffer.from(text, "utf8");
+}
+
+test("a Matroska ASS block gives up its text and nothing else", () => {
+  // Nine fields exactly, and no comma in the dialogue: the shape that defeated
+  // the old field count and put the whole row on the viewer's screen.
+  assert.equal(
+    MatroskaContainer.cueTextOf(block(FIELD_BLOCK), "S_TEXT/ASS"),
+    "I am the powerful Demon King of the Sixth Heaven. Good... Evil..."
+  );
+});
+
+test("commas in the dialogue are dialogue, not fields", () => {
+  assert.equal(
+    MatroskaContainer.cueTextOf(block("7,0,Main,Nobunaga,0000,0000,0000,,Yes, of course, my lord"), "S_TEXT/ASS"),
+    "Yes, of course, my lord"
+  );
+});
+
+test("an SSA block is framed the same way as an ASS one", () => {
+  // SSA writes `Marked` where ASS writes `Layer`; the count is the same and so
+  // is the answer.
+  assert.equal(
+    MatroskaContainer.cueTextOf(block("3,,Default,,0000,0000,0000,,Toujours rien."), "S_TEXT/SSA"),
+    "Toujours rien."
+  );
+});
+
+test("a row too short to hold a text field yields nothing to show", () => {
+  assert.equal(MatroskaContainer.cueTextOf(block("21,0,Default,,0000"), "S_TEXT/ASS"), "");
+  assert.equal(MatroskaContainer.cueTextOf(block("21,0,Default,,0000,0000,0000,,"), "S_TEXT/ASS"), "");
+});
+
+test("a plain-text Matroska block is not touched at all", () => {
+  // `S_TEXT/UTF8` has no framing: the block IS the text, commas included.
+  const line = "Yes, of course, my lord";
+  assert.equal(MatroskaContainer.cueTextOf(block(line), "S_TEXT/UTF8"), line);
+  assert.equal(MatroskaContainer.cueTextOf(block(line), "S_TEXT/WEBVTT"), line);
+});
+
+test("an MP4 sample is unframed by the MP4, length prefix and all", () => {
+  const text = Buffer.from("Yes, of course, my lord", "utf8");
+  const sample = Buffer.concat([Buffer.from([0x00, text.length]), text]);
+  assert.equal(Mp4Container.cueTextOf(sample, "tx3g"), "Yes, of course, my lord");
+});
+
+test("a container with no framing of its own refuses to guess", () => {
+  // AVI declares no subtitle tracks, so no cue can reach it. If one ever did,
+  // the answer must be an error and not a guess at somebody else's framing.
+  assert.throws(() => AviContainer.cueTextOf(block("x"), "S_TEXT/ASS"), /cueTextOf not implemented/);
+});
+
+test("ASS markup is taken off wherever the text came from", () => {
+  assert.equal(plainCueText("{\\pos(640,620)}Hello{\\i1} there{\\i0}", "S_TEXT/ASS"), "Hello there");
+  assert.equal(plainCueText("First\\NSecond\\nThird", "S_TEXT/ASS"), "First\nSecond\nThird");
+  assert.equal(plainCueText("Wide\\hspace", "S_TEXT/ASS"), "Wide space");
+  // The same text under a codec that has no such markup keeps its characters.
+  assert.equal(plainCueText("{\\pos(1,2)}Hello", "S_TEXT/UTF8"), "{\\pos(1,2)}Hello");
+});
+
+test("a codec is known by any of its names", () => {
+  assert.equal(markupKindOf("S_TEXT/ASS"), MarkupKind.ASS);
+  assert.equal(markupKindOf(".ASS"), MarkupKind.ASS);
+  assert.equal(markupKindOf("S_TEXT/UTF8"), MarkupKind.NONE);
+  assert.equal(markupKindOf("wvtt"), MarkupKind.NONE);
+  // Unknown: shown as it is, rather than refused.
+  assert.equal(markupKindOf("S_TEXT/SOMETHING"), MarkupKind.NONE);
+});
+
+test("a text track answers for its own markup", () => {
+  const track = new TextSubtitleTrack({ trackNumber: 3, declaredIndex: 0, codecId: "S_TEXT/ASS" });
+  assert.equal(track.markupKind, MarkupKind.ASS);
+  assert.equal(track.plainText("{\\be1}Готовьте лучников"), "Готовьте лучников");
+});
+
+test("a file states its own column order and is obeyed", () => {
+  // This `Format:` has no `Name` column, so the text is the ninth field and not
+  // the tenth. A reader that assumed a position would take the effect field as
+  // the line — which is the file-side form of the defect this suite is about.
+  const file = [
+    "[Script Info]",
+    "ScriptType: v4.00+",
+    "[Events]",
+    "Format: Layer, Start, End, Style, MarginL, MarginR, MarginV, Effect, Text",
+    "Dialogue: 0,0:00:01.00,0:00:03.50,Default,0000,0000,0000,,Ты видишь их?",
+    ""
+  ].join("\n");
+
+  const cues = new SubtitleFileContainer({ extension: ".ass" }).readCues(file);
+  assert.deepEqual(cues, [{ startSeconds: 1, endSeconds: 3.5, text: "Ты видишь их?" }]);
+});
+
+test("a dialogue row before any Format line is not guessed at", () => {
+  const file = ["[Events]", "Dialogue: 0,0:00:01.00,0:00:02.00,Default,,0,0,0,,Ignored", ""].join("\n");
+  assert.deepEqual(new SubtitleFileContainer({ extension: ".ass" }).readCues(file), []);
+});
+
+test("SubRip cues keep their words and lose their numbering", () => {
+  const file = [
+    "1",
+    "00:00:01,000 --> 00:00:03,500",
+    "Ты видишь их?",
+    "",
+    "2",
+    "00:01:02,250 --> 00:01:04,000",
+    "<i>Да.</i>",
+    "Но не столько вижу.",
+    ""
+  ].join("\n");
+
+  const cues = new SubtitleFileContainer({ extension: ".srt" }).readCues(file);
+  assert.deepEqual(cues, [
+    { startSeconds: 1, endSeconds: 3.5, text: "Ты видишь их?" },
+    { startSeconds: 62.25, endSeconds: 64, text: "<i>Да.</i>\nНо не столько вижу." }
+  ]);
+});
+
+test("a SubRip file with no blank line between cues does not swallow the ordinal", () => {
+  const file = [
+    "1",
+    "00:00:01,000 --> 00:00:02,000",
+    "First",
+    "2",
+    "00:00:03,000 --> 00:00:04,000",
+    "Second"
+  ].join("\n");
+
+  const cues = new SubtitleFileContainer({ extension: ".srt" }).readCues(file);
+  assert.deepEqual(cues.map((cue) => cue.text), ["First", "Second"]);
+});
+
+test("a WebVTT file is passed through, not taken apart", () => {
+  const file = "WEBVTT\n\nSTYLE\n::cue { color: yellow }\n\nintro\n00:00:01.000 --> 00:00:02.000\nHello\n";
+  assert.equal(convertSubtitleToVtt(file, ".vtt"), file);
+  assert.equal(new SubtitleFileContainer({ extension: ".vtt" }).readCues(file), null);
+});
+
+test("a format nothing here reads is refused rather than mangled", () => {
+  assert.equal(convertSubtitleToVtt("whatever", ".sup"), null);
+  assert.equal(convertSubtitleToVtt("whatever", ".ttml"), null);
+});
+
+test("one line of dialogue, two framings, one result", () => {
+  // The whole point of the split. The same ASS line stored in a Matroska block
+  // and in a file must reach the viewer identically, and neither path may know
+  // anything about the other.
+  const spoken = "Yes, of course, my lord";
+  const markup = `{\\pos(640,620)}${spoken}`;
+
+  const fromBlock = finalizeCues(
+    [{
+      startSeconds: 1,
+      endSeconds: 3,
+      text: MatroskaContainer.cueTextOf(block(`21,0,Default,,0000,0000,0000,,${markup}`), "S_TEXT/ASS")
+    }],
+    "S_TEXT/ASS"
+  );
+
+  const fromFile = new SubtitleFileContainer({ extension: ".ass" }).readCues([
+    "[Events]",
+    "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",
+    `Dialogue: 0,0:00:01.00,0:00:03.00,Default,,0000,0000,0000,,${markup}`,
+    ""
+  ].join("\n"));
+
+  assert.equal(fromBlock[0].text, spoken);
+  assert.equal(finalizeCues(fromFile, ".ass")[0].text, spoken);
+  assert.equal(cuesToVtt(fromBlock, "S_TEXT/ASS"), cuesToVtt(fromFile, ".ass"));
+});

package/test/subtitle-language.test.js

@@ -26,7 +26,8 @@ import assert from "node:assert/strict";
 
 import { cueTextOfVtt, detectLanguage, detectLanguageFromVtt } from "../services/language-detect.js";
 import { convertSubtitleToVtt } from "../services/subtitle-convert.js";
-import { finalizeCues } from "../services/torrent-worker/subtitle-cues.js";
+import { finalizeCues } from "../services/subtitle-convert.js";
+import { MatroskaContainer } from "../services/container/MatroskaContainer.js";
 
 /** Varied Russian dialogue, the length a few minutes of an episode carries. */
 const RUSSIAN_DIALOGUE = [
@@ -176,20 +177,30 @@ test("a document with no cues yields no language rather than a guess", () => {
   assert.equal(detectLanguageFromVtt(null), null);
 });
 
-test("an embedded ASS cue is read through finalizeCues, not raw", () => {
-  // What the cluster walk holds: the dialogue row without its `Dialogue:`
-  // header — nine comma-separated fields, then the text with override groups.
-  const cues = RUSSIAN_DIALOGUE.map((line, index) => ({
+test("an embedded ASS cue is unframed by the container, then read", () => {
+  // What a Matroska block actually holds, per
+  // `matroska.org/technical/subtitles.html`: "Events are stored in the Block in
+  // this order: ReadOrder, Layer, Style, Name, MarginL, MarginR, MarginV,
+  // Effect, Text", with Start and End taken out into the block's own timing.
+  // Eight fields, and the earlier fixture here wrongly carried ten — it kept
+  // the two timestamps a FILE has, which is why it passed while the field
+  // subtitles of a real `.mkv` were shown to the viewer whole.
+  const blocks = RUSSIAN_DIALOGUE.map((line, index) => Buffer.from(
+    `${index + 1},0,Default,,0000,0000,0000,,` +
+    `${index % 5 === 4 ? "{\\pos(640,620)}" : ""}${line}`,
+    "utf8"
+  ));
+
+  const cues = blocks.map((payload, index) => ({
     startSeconds: index * 4,
     endSeconds: index * 4 + 3,
-    text: `0,${assTime(index * 4)},${assTime(index * 4 + 3)},Default,,0,0,0,,` +
-      `${index % 5 === 4 ? "{\\pos(640,620)}" : ""}${line}`
+    text: MatroskaContainer.cueTextOf(payload, "S_TEXT/ASS")
   }));
 
   const spoken = finalizeCues(cues, "S_TEXT/ASS").map((cue) => cue.text).join("\n");
   assert.ok(!spoken.includes("Default"), "the style field survived into the text");
+  assert.ok(!spoken.includes("0000"), "a margin field survived into the text");
   assert.ok(!spoken.includes("pos("), "an override group survived into the text");
-  assert.ok(!spoken.includes("0:00:12"), "a timestamp field survived into the text");
   assert.deepEqual(detectLanguage(spoken), { code: "ru", name: "Russian" });
 });