@torrent-tv/proxy 2.43.2 → 2.45.0

package/services/subtitle-defaults.js

@@ -0,0 +1,131 @@
+/**
+ * Which subtitle track the FILE says to show, read from the file rather than
+ * from ffmpeg's description of it.
+ *
+ * Why this exists. The browser decides which subtitle track to turn on from
+ * `isDefault`, and until now that came from ffmpeg's `-i` banner, which prints
+ * `(default)`. In Matroska `FlagDefault` DEFAULTS TO 1 and ffmpeg has already
+ * applied that default by the time it prints — so a file whose muxer wrote the
+ * flag on no track arrives looking exactly like one that wrote it on every
+ * track: everything marked. The banner cannot tell the two apart, and the
+ * difference is the whole question, because one of them means "show this one"
+ * and the other means "the file has no opinion".
+ *
+ * The container itself can be asked, and the EBML reader already walks the
+ * Tracks element for subtitle extraction. What it now also records is whether
+ * the element was WRITTEN, which is the fact the banner destroys.
+ *
+ * The awkward part is lining the two readings up. ffmpeg numbers its subtitle
+ * streams `0:s:0`, `0:s:1`, … over EVERY subtitle stream, picture-based ones
+ * included, in the order the container declares them; the container reading is
+ * a list in that same order. So position is the correspondence — but a position
+ * match that is merely assumed is worth nothing, so it is CHECKED: each pair
+ * has to agree on language or on title. One pair that agrees on neither, or a
+ * length that differs, means the two readings are not describing the same
+ * thing in the same order, and then the container reading is not used at all.
+ */
+
+/**
+ * Language codes that carry no information, and so cannot confirm a pairing.
+ *
+ * ffmpeg prints `und` for a stream with no language; Matroska's own default
+ * for `Language` is `eng`, which is why an absent element cannot be read as a
+ * statement either — but `eng` is also a real answer, so it is not listed here
+ * and is compared like any other.
+ */
+const EMPTY_LANGUAGES = new Set(["", "und", "unknown"]);
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+function normalise(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+
+/**
+ * Whether one banner stream and one container track can be the same track.
+ *
+ * Agreement on either the language or the name is enough; both being empty is
+ * not agreement, because two tracks that say nothing about themselves say
+ * nothing about their pairing either.
+ *
+ * @param {{ language?: string, title?: string }} banner
+ * @param {{ language?: string, name?: string }} container
+ * @returns {boolean}
+ */
+export function pairingHolds(banner, container) {
+  const bannerLanguage = normalise(banner?.language);
+  const containerLanguage = normalise(container?.language);
+  if (
+    !EMPTY_LANGUAGES.has(bannerLanguage) &&
+    !EMPTY_LANGUAGES.has(containerLanguage) &&
+    bannerLanguage === containerLanguage
+  ) {
+    return true;
+  }
+  const bannerTitle = normalise(banner?.title);
+  const containerName = normalise(container?.name);
+  if (bannerTitle.length > 0 && bannerTitle === containerName) {
+    return true;
+  }
+  // Nothing to compare on either side. Not a disagreement — a file may name
+  // neither — so it does not break the alignment; it simply adds no support.
+  return (
+    (EMPTY_LANGUAGES.has(bannerLanguage) || EMPTY_LANGUAGES.has(containerLanguage)) &&
+    (bannerTitle.length === 0 || containerName.length === 0)
+  );
+}
+
+/**
+ * The banner's subtitle tracks, with what the container says about each.
+ *
+ * Every returned track gains `declaresDefault`: whether the FILE wrote the flag
+ * for it. When the container reading cannot be trusted — no declarations, a
+ * different number of them, or a pair that agrees on neither language nor name
+ * — every track gets `declaresDefault: false` and its `isDefault` is left as
+ * the banner had it. That is the honest answer for a file we cannot read this
+ * way: the container has not been heard from, so nothing is shown unasked.
+ *
+ * @param {Array<{ index?: number, language?: string, title?: string, isDefault?: boolean }>} bannerTracks
+ * @param {Array<{ language?: string, name?: string, isDefault?: boolean, declaresDefault?: boolean }>} declared
+ * @returns {{ tracks: object[], aligned: boolean, reason: string }}
+ */
+export function mergeContainerSubtitleFlags(bannerTracks, declared) {
+  const banner = Array.isArray(bannerTracks) ? bannerTracks : [];
+  const container = Array.isArray(declared) ? declared : [];
+  const undecided = () => ({
+    tracks: banner.map((track) => ({ ...track, declaresDefault: false }))
+  });
+  if (container.length === 0) {
+    return { ...undecided(), aligned: false, reason: "the container declares no subtitle track" };
+  }
+  if (container.length !== banner.length) {
+    return {
+      ...undecided(),
+      aligned: false,
+      reason: `the container declares ${container.length} subtitle tracks and the probe found ${banner.length}`
+    };
+  }
+  for (const [order, track] of banner.entries()) {
+    if (!pairingHolds(track, container[order])) {
+      return {
+        ...undecided(),
+        aligned: false,
+        reason:
+          `subtitle ${order} is "${normalise(track?.title) || "-"}"/${normalise(track?.language) || "-"} ` +
+          `in the probe and "${normalise(container[order]?.name) || "-"}"/` +
+          `${normalise(container[order]?.language) || "-"} in the container`
+      };
+    }
+  }
+  return {
+    tracks: banner.map((track, order) => ({
+      ...track,
+      isDefault: container[order].isDefault === true,
+      declaresDefault: container[order].declaresDefault === true
+    })),
+    aligned: true,
+    reason: ""
+  };
+}

package/services/torrent-worker/pool-adapter.js

@@ -157,6 +157,24 @@ export class WorkerTorrentPool {
     return Array.isArray(answer?.tracks) ? answer.tracks : [];
   }
 
+  /**
+   * What the container itself declares about its subtitle tracks, in its own
+   * order and including the picture-based ones — for lining up against
+   * ffmpeg's own numbering.
+   *
+   * @param {object} torrent
+   * @param {number} fileIndex
+   * @returns {Promise<object[]>}
+   */
+  async getDeclaredSubtitleTracks(torrent, fileIndex) {
+    const sourceKey = torrent?.sourceKey;
+    if (!sourceKey) {
+      return [];
+    }
+    const answer = await this.#client.getSubtitleTracks({ sourceKey, fileIndex });
+    return Array.isArray(answer?.declared) ? answer.declared : [];
+  }
+
   /**
    * The cues of one subtitle track that the downloaded clusters already carry.
    *

package/services/torrent-worker/subtitle-cues.js

@@ -99,14 +99,19 @@ function readHeld(file, start, end) {
 async function planFor(torrent, fileIndex, key) {
   let state = byFile.get(key);
   if (!state) {
-    state = { plan: null, harvested: new Map(), cues: new Map() };
+    state = { plan: null, harvested: new Map(), cues: new Map(), seq: new Map(), walked: new Set() };
     byFile.set(key, state);
   }
   if (state.plan !== null) {
     return state.plan;
   }
   const file = torrent?.files?.[fileIndex];
-  const empty = { tracks: [], secondsPerTick: 0.001, segmentDataOffset: 0 };
+  // `declared` is what the container itself says about its subtitle tracks, in
+  // its own order. Empty means the container said nothing — which is a real
+  // answer and not a missing one: nothing is then shown unasked. An MP4 has no
+  // element that means "show this subtitle track by default", so it declares
+  // nothing however many tracks it carries.
+  const empty = { tracks: [], declared: [], secondsPerTick: 0.001, segmentDataOffset: 0 };
   if (!file) {
     state.plan = empty;
     return state.plan;
@@ -154,6 +159,31 @@ async function planFor(torrent, fileIndex, key) {
   return state.plan;
 }
 
+/**
+ * The order a cue was FOUND in, which is the only cursor a browser can follow.
+ *
+ * A cue's TIME cannot serve as one. Cues are harvested out of whichever
+ * clusters happen to be downloaded, and those are not contiguous, so the set
+ * grows in the middle as well as at the end. A browser that remembered "the
+ * latest time I hold" and asked for everything past it would never be sent the
+ * cues that turn up BEHIND that mark afterwards — which is exactly the stretch
+ * it is about to play. Measured 2026-08-20 on a viewer at 272 s: one answer
+ * carried cues out to 1176 s, and from then on every cue between the two was
+ * filtered away for the rest of the session, with 59 of 276 clusters read.
+ *
+ * Found-order is monotonic by construction, so `?since=<n>` is exact however
+ * the file arrives.
+ *
+ * @param {{ seq: Map<number, number> }} state
+ * @param {number} trackNumber
+ * @returns {number}
+ */
+function nextSeq(state, trackNumber) {
+  const next = (state.seq.get(trackNumber) ?? 0) + 1;
+  state.seq.set(trackNumber, next);
+  return next;
+}
+
 /**
  * Every cue of one track that can be read from what is already downloaded.
  *
@@ -201,7 +231,12 @@ export async function cuesHeldFor(torrent, fileIndex, sourceKey, trackNumber) {
       harvested.add(sample.offset);
       const text = decodeSubtitleSample(bytes, track.codecId);
       if (text) {
-        cues.push({ startSeconds: sample.startSeconds, endSeconds: sample.endSeconds, text });
+        cues.push({
+          startSeconds: sample.startSeconds,
+          endSeconds: sample.endSeconds,
+          text,
+          seq: nextSeq(state, trackNumber)
+        });
       }
     }
     cues.sort((left, right) => left.startSeconds - right.startSeconds);
@@ -213,8 +248,24 @@ export async function cuesHeldFor(torrent, fileIndex, sourceKey, trackNumber) {
     };
   }
 
-  for (const position of track.clusterPositions) {
-    if (harvested.has(position)) {
+  // ONE walk for the whole file, not one per track. A Matroska cluster carries
+  // the blocks of every track that has anything to say over its span, so the
+  // bytes that answer one track answer them all — and reading them once per
+  // track meant the same cluster was fetched and parsed as many times as the
+  // film has subtitle tracks. Measured 2026-08-20 on a film with five: five
+  // requests every fifteen seconds, each costing 0.2-5.2 s of container
+  // reading, for cues that together weigh a few kilobytes.
+  //
+  // The union of the tracks' cluster lists is what gets walked: each track's
+  // list comes from its own Cues entries, so they overlap but do not coincide.
+  const positions = new Set();
+  for (const candidate of plan.tracks) {
+    for (const position of candidate.clusterPositions ?? []) {
+      positions.add(position);
+    }
+  }
+  for (const position of [...positions].sort((left, right) => left - right)) {
+    if (state.walked.has(position)) {
       continue;
     }
     // The header first: it says how long the cluster is, and a cluster whose
@@ -225,7 +276,7 @@ export async function cuesHeldFor(torrent, fileIndex, sourceKey, trackNumber) {
     const probe = await readHeld(file, position, Math.min(file.length - 1, position + CLUSTER_HEADER_PROBE - 1));
     const header = probe && [...iterateElements(probe, 0, probe.length)][0];
     if (!header || header.size <= 0 || header.size > MAX_CLUSTER_BYTES) {
-      harvested.add(position); // not a cluster we can read; do not look again
+      state.walked.add(position); // not a cluster we can read; do not look again
       continue;
     }
     const last = Math.min(file.length - 1, position + header.dataOffset + header.size - 1);
@@ -236,18 +287,33 @@ export async function cuesHeldFor(torrent, fileIndex, sourceKey, trackNumber) {
     if (!bytes) {
       continue;
     }
-    harvested.add(position);
-    for (const cue of harvestCluster(bytes, trackNumber, plan.secondsPerTick)) {
-      cues.push(cue);
+    state.walked.add(position);
+    for (const candidate of plan.tracks) {
+      let into = state.cues.get(candidate.trackNumber);
+      if (!into) {
+        into = [];
+        state.cues.set(candidate.trackNumber, into);
+      }
+      let found = false;
+      for (const cue of harvestCluster(bytes, candidate.trackNumber, plan.secondsPerTick)) {
+        cue.seq = nextSeq(state, candidate.trackNumber);
+        into.push(cue);
+        found = true;
+      }
+      if (found) {
+        into.sort((left, right) => left.startSeconds - right.startSeconds);
+      }
     }
   }
-  cues.sort((left, right) => left.startSeconds - right.startSeconds);
   return {
-    cues,
-    coveredClusters: harvested.size,
+    cues: state.cues.get(trackNumber) ?? [],
+    // Every track is filled by the same walk, so this is a fact about the FILE
+    // and reads the same whichever track asked.
+    coveredClusters: state.walked.size,
     indexedClusters: track.clusterPositions.length,
     track
   };
+
 }
 
 /**
@@ -270,6 +336,25 @@ export async function subtitleTracksOf(torrent, fileIndex, sourceKey) {
   }));
 }
 
+/**
+ * What the container itself says about its subtitle tracks, in its own order
+ * and including the picture-based ones.
+ *
+ * Separate from `subtitleTracksOf`, which lists only what can be turned into
+ * WebVTT and is indexed by position in the subtitle API. This one exists to be
+ * lined up against ffmpeg's `0:s:N` numbering, which counts every subtitle
+ * stream, so leaving the picture ones out would shift it.
+ *
+ * @param {object} torrent
+ * @param {number} fileIndex
+ * @param {string} sourceKey
+ * @returns {Promise<object[]>}
+ */
+export async function declaredSubtitleTracksOf(torrent, fileIndex, sourceKey) {
+  const plan = await planFor(torrent, fileIndex, `${sourceKey}:${fileIndex}`);
+  return plan?.declared ?? [];
+}
+
 /**
  * Forget a file's cues — the torrent is gone, and holding them would keep the
  * text of a film nobody is watching.

package/services/torrent-worker/worker.js

@@ -27,7 +27,7 @@ import { parentPort, workerData } from "node:worker_threads";
 import { createSendStream } from "./channel.js";
 import { createFileClaims } from "./file-claims.js";
 import { readFragments, supplyFiguresFor } from "./piece-reader.js";
-import { cuesHeldFor, subtitleTracksOf } from "./subtitle-cues.js";
+import { cuesHeldFor, declaredSubtitleTracksOf, subtitleTracksOf } from "./subtitle-cues.js";
 import { Command, Event } from "./protocol.js";
 
 // Imported dynamically, and that is load-bearing: static imports are RESOLVED
@@ -359,7 +359,10 @@ async function runCommand(command, params, id) {
 
     case Command.SUBTITLE_TRACKS: {
       const torrent = await requireTorrent(params.sourceKey);
-      return { tracks: await subtitleTracksOf(torrent, params.fileIndex, params.sourceKey) };
+      return {
+        tracks: await subtitleTracksOf(torrent, params.fileIndex, params.sourceKey),
+        declared: await declaredSubtitleTracksOf(torrent, params.fileIndex, params.sourceKey)
+      };
     }
 
     case Command.SUBTITLE_CUES: {

package/test/cuts-follow-published-grid.test.js

@@ -0,0 +1,73 @@
+/**
+ * @file A run cuts where the player was told the cuts are.
+ *
+ * There are two boundary tables. The live one is corrected as produced segments
+ * reveal where the file's cuts truly are; the published one is the snapshot the
+ * playlist text was written from, and a player places every fragment by that
+ * text and nothing else. The cut list handed to ffmpeg used to come from the
+ * live table, so every correction moved the run away from the timeline the
+ * player is reading.
+ *
+ * Field 2026-08-20, `Minions.and.Monsters.1080p.mkv`: the picture's segments
+ * arrived a uniform 2.002 s before the times its playlist named — 119 of 125 of
+ * them — against the 0.5 s hls.js bridges. A fragment that does not land is
+ * fetched again, and on 2026-08-17 two of them were fetched 1908 times each.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { HlsSessionManager, segmentCutTimesFrom } from "../services/hls-session-manager.js";
+
+/** What the playlist in the player's hands says. */
+const PUBLISHED = [0, 4.004, 8.008, 12.012, 16.016, 20.02];
+/** The same grid after produced segments moved two of its cuts. */
+const CORRECTED = [0, 4.004, 6.006, 12.012, 14.014, 20.02];
+
+/**
+ * A session that has published one grid and since corrected another.
+ *
+ * @returns {{ manager: HlsSessionManager, session: object }}
+ */
+function sessionWithDriftedGrid() {
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const session = {
+    id: "picture",
+    segmentBoundaries: [...CORRECTED],
+    publishedBoundaries: [...PUBLISHED]
+  };
+  return { manager, session };
+}
+
+test("the cut list is the one the playlist was written from", () => {
+  const { manager, session } = sessionWithDriftedGrid();
+  const grid = manager.publishedGridFor(session);
+  assert.deepEqual(grid, PUBLISHED);
+  // Interior cuts of a run starting at #1, rebased on the run's own start
+  // (4.004 s), and stopping before the last entry, which is the file's end.
+  assert.deepEqual(
+    segmentCutTimesFrom(grid, 1).map((time) => Number(time.toFixed(3))),
+    [4.004, 8.008, 12.012]
+  );
+});
+
+test("a corrected grid does not move the cuts of a session already being read", () => {
+  const { manager, session } = sessionWithDriftedGrid();
+  const fromCorrected = segmentCutTimesFrom(session.segmentBoundaries, 1);
+  const fromPublished = segmentCutTimesFrom(manager.publishedGridFor(session), 1);
+  assert.notDeepEqual(fromCorrected, fromPublished);
+  // The gap the field measured: the corrected table would have cut #2 two
+  // seconds early, which is four times what a player bridges.
+  assert.equal(Number((fromPublished[0] - fromCorrected[0]).toFixed(3)), 2.002);
+});
+
+test("a session that published no grid falls back to the live one", () => {
+  const { manager } = sessionWithDriftedGrid();
+  const session = { id: "no-playlist", segmentBoundaries: [...CORRECTED], publishedBoundaries: [] };
+  assert.deepEqual(manager.publishedGridFor(session), CORRECTED);
+});

package/test/subtitle-cursor.test.js

@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+/**
+ * The rule this pins: a subtitle cursor counts the order cues were FOUND, not
+ * where they sit in the film.
+ *
+ * Cues are read out of whichever clusters happen to be downloaded, and a
+ * torrent does not arrive in film order — a seek pulls a later stretch first,
+ * and the earlier one fills in afterwards. So the set of known cues grows in
+ * the MIDDLE as well as at the end.
+ *
+ * A cursor in film time cannot survive that: measured 2026-08-20 on a viewer at
+ * 272 s, one answer carried cues out to 1176 s, and from that moment every cue
+ * between the two was filtered away for the rest of the session — the stretch
+ * they were about to watch. 59 of 276 clusters had been read.
+ *
+ * The filter below is the route's, written out so the property can be checked
+ * without a torrent: `?since=<n>` selects by found-order, `?after=<seconds>` is
+ * the old behaviour kept for an older browser.
+ */
+const bySince = (cues, since) => cues.filter((cue) => (Number(cue.seq) || 0) > since);
+const byAfter = (cues, after) => cues.filter((cue) => cue.startSeconds > after);
+
+/** A late-arriving cluster from EARLIER in the film than what is already held. */
+const held = [
+  { startSeconds: 40, text: "found first, early in the film", seq: 1 },
+  { startSeconds: 1176, text: "found second, far ahead", seq: 2 },
+  { startSeconds: 300, text: "found third, behind the furthest held", seq: 3 }
+];
+
+test("a cue found after a further-ahead one is still delivered", () => {
+  // The browser holds seq 1 and 2 and asks for what came after.
+  const fresh = bySince(held, 2);
+  assert.deepEqual(fresh.map((cue) => cue.startSeconds), [300]);
+});
+
+test("the same case in film time loses that cue for ever", () => {
+  // This is what shipped in 2.43.1 and what the field session showed: the
+  // browser's furthest cue is 1176 s, so the 300 s cue can never reach it.
+  const fresh = byAfter(held, 1176);
+  assert.deepEqual(fresh.map((cue) => cue.startSeconds), []);
+});
+
+test("a browser asking for the first time is sent everything", () => {
+  assert.equal(bySince(held, 0).length, 3);
+});
+
+test("nothing new is answered with nothing", () => {
+  assert.deepEqual(bySince(held, 3), []);
+});
+
+test("the cursor to send back is the highest found-order held", () => {
+  const cursor = held.reduce((highest, cue) => Math.max(highest, Number(cue.seq) || 0), 0);
+  assert.equal(cursor, 3);
+});
+
+test("a cursor is unaffected by the order cues are sorted into", () => {
+  // The list is kept in film order for the WebVTT it becomes; the cursor must
+  // not depend on that.
+  const sorted = [...held].sort((left, right) => left.startSeconds - right.startSeconds);
+  assert.deepEqual(bySince(sorted, 2).map((cue) => cue.startSeconds), [300]);
+});

package/test/subtitle-defaults.test.js

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mergeContainerSubtitleFlags, pairingHolds } from "../services/subtitle-defaults.js";
+
+test("a flag the container wrote is carried through, and one it did not is not", () => {
+  const banner = [
+    { index: 0, language: "rus", title: "Forced", isDefault: true },
+    { index: 1, language: "eng", title: "SDH", isDefault: true }
+  ];
+  const declared = [
+    { language: "rus", name: "Forced", isDefault: true, declaresDefault: true },
+    { language: "eng", name: "SDH", isDefault: true, declaresDefault: false }
+  ];
+  const merged = mergeContainerSubtitleFlags(banner, declared);
+  assert.equal(merged.aligned, true);
+  assert.deepEqual(
+    merged.tracks.map((track) => [track.isDefault, track.declaresDefault]),
+    [[true, true], [true, false]]
+  );
+});
+
+test("a file that wrote nothing is reported as having written nothing, though ffmpeg marked everything", () => {
+  // This is the case the banner cannot express: `FlagDefault` defaults to 1, so
+  // ffmpeg prints `(default)` against every track of a file that chose none.
+  const banner = [
+    { index: 0, language: "rus", title: "", isDefault: true },
+    { index: 1, language: "eng", title: "", isDefault: true }
+  ];
+  const declared = [
+    { language: "rus", name: "", isDefault: true, declaresDefault: false },
+    { language: "eng", name: "", isDefault: true, declaresDefault: false }
+  ];
+  const merged = mergeContainerSubtitleFlags(banner, declared);
+  assert.equal(merged.aligned, true);
+  assert.deepEqual(merged.tracks.map((track) => track.declaresDefault), [false, false]);
+});
+
+test("the container's own answer overrides the banner's, in both directions", () => {
+  const banner = [
+    { index: 0, language: "rus", title: "a", isDefault: true },
+    { index: 1, language: "eng", title: "b", isDefault: false }
+  ];
+  const declared = [
+    { language: "rus", name: "a", isDefault: false, declaresDefault: true },
+    { language: "eng", name: "b", isDefault: true, declaresDefault: true }
+  ];
+  const merged = mergeContainerSubtitleFlags(banner, declared);
+  assert.deepEqual(merged.tracks.map((track) => track.isDefault), [false, true]);
+});
+
+test("a count that differs means the two readings are not the same list", () => {
+  // The container declares a picture track the probe did not report; position
+  // is then not the correspondence and nothing may be read across.
+  const banner = [{ index: 0, language: "rus", title: "", isDefault: true }];
+  const declared = [
+    { language: "rus", name: "", isDefault: false, declaresDefault: true },
+    { language: "eng", name: "", isDefault: true, declaresDefault: true }
+  ];
+  const merged = mergeContainerSubtitleFlags(banner, declared);
+  assert.equal(merged.aligned, false);
+  assert.match(merged.reason, /declares 2 subtitle tracks and the probe found 1/);
+  assert.deepEqual(merged.tracks.map((track) => [track.isDefault, track.declaresDefault]), [[true, false]]);
+});
+
+test("a pair agreeing on neither language nor name refuses the whole alignment", () => {
+  const banner = [
+    { index: 0, language: "rus", title: "", isDefault: true },
+    { index: 1, language: "eng", title: "", isDefault: true }
+  ];
+  const declared = [
+    { language: "eng", name: "", isDefault: true, declaresDefault: true },
+    { language: "rus", name: "", isDefault: false, declaresDefault: true }
+  ];
+  const merged = mergeContainerSubtitleFlags(banner, declared);
+  assert.equal(merged.aligned, false);
+  assert.deepEqual(merged.tracks.map((track) => track.declaresDefault), [false, false]);
+});
+
+test("a container that declares nothing leaves the banner alone", () => {
+  const banner = [{ index: 0, language: "rus", title: "", isDefault: true }];
+  const merged = mergeContainerSubtitleFlags(banner, []);
+  assert.equal(merged.aligned, false);
+  assert.equal(merged.tracks[0].isDefault, true);
+  assert.equal(merged.tracks[0].declaresDefault, false);
+});
+
+test("a name confirms a pairing when the languages are unstated", () => {
+  assert.equal(pairingHolds({ language: "und", title: "Forced" }, { language: "", name: "Forced" }), true);
+});
+
+test("two tracks that say nothing about themselves do not break the alignment", () => {
+  assert.equal(pairingHolds({ language: "und", title: "" }, { language: "", name: "" }), true);
+});
+
+test("a stated language that differs is a disagreement", () => {
+  assert.equal(pairingHolds({ language: "rus", title: "" }, { language: "eng", name: "" }), false);
+});