@torrent-tv/proxy 2.72.0 → 2.72.2

package/services/subtitle-convert.js

@@ -5,8 +5,17 @@
  * ASS/SSA (.ass/.ssa) to WebVTT so the browser can attach them to a `<track>`
  * without any client-side conversion. The proxy owns subtitle conversion so it
  * can also run language detection where the full text is available.
+ *
+ * Reading a format's own framing is NOT here — it is `SubtitleFileContainer`
+ * for a file beside the film, and `MatroskaContainer` / `Mp4Container` for a
+ * track inside it. What is here is everything after that: a cue's missing end
+ * time, its codec's markup, and writing the WebVTT document. One writer, so a
+ * pushed cue and a pulled one cannot read differently.
  */
 
+import { SubtitleFileContainer } from "./container/SubtitleFileContainer.js";
+import { plainCueText } from "./tracks/subtitle-markup.js";
+
 /**
  * Decode subtitle bytes to text. Prefers UTF-8 (honouring a BOM); if the UTF-8
  * decode yields many replacement characters the bytes are re-decoded as
@@ -41,110 +50,95 @@ function stripBom(text) {
   return typeof text === "string" && text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
 }
 
-function srtTsToVtt(ts) {
-  return ts.replace(",", ".");
-}
-
 /**
- * Convert SubRip (.srt) text to WebVTT.
+ * One cue's start or end as WebVTT writes it: `hh:mm:ss.mmm`.
  *
- * @param {string} text
+ * @param {number} seconds
  * @returns {string}
  */
-function srtToVtt(text) {
-  const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-  const out = ["WEBVTT", ""];
-  for (const line of lines) {
-    const m = line.match(/^(\d{2}:\d{2}:\d{2},\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2},\d{3})(.*)?$/);
-    out.push(m ? `${srtTsToVtt(m[1])} --> ${srtTsToVtt(m[2])}${m[3] ?? ""}` : line);
-  }
-  return out.join("\n");
+export function vttTime(seconds) {
+  const safe = Math.max(0, Number(seconds) || 0);
+  const hours = Math.floor(safe / 3600);
+  const minutes = Math.floor((safe % 3600) / 60);
+  const rest = safe % 60;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${rest.toFixed(3).padStart(6, "0")}`;
 }
 
-function assTsToVtt(ts) {
-  const m = ts.match(/^(\d+):(\d{2}):(\d{2})\.(\d{2})$/);
-  if (!m) {
-    return "00:00:00.000";
-  }
-  const ms = (parseInt(m[4], 10) * 10).toString().padStart(3, "0");
-  return `${m[1].padStart(2, "0")}:${m[2]}:${m[3]}.${ms}`;
-}
-
-function stripAssTags(text) {
-  return text
-    .replace(/\{[^}]*\}/g, "")
-    .replace(/\\N/g, "\n")
-    .replace(/\\n/g, "\n")
-    .replace(/\\h/g, " ")
-    .trim();
+/**
+ * Resolve what a cue is missing and take its codec's markup off, so what is
+ * left is what a player shows.
+ *
+ * The container's framing is NOT undone here — it is undone where the cue is
+ * read, by the container that framed it, which is the only place the framing is
+ * known. Until 2.72.1 this function tried to do both by counting commas, and
+ * on an embedded ASS track it showed every field of the dialogue row to the
+ * viewer.
+ *
+ * A cue with no duration — a Matroska SimpleBlock, which subtitles rarely use —
+ * is given the time until the next one IN THIS LIST, and the last such cue a
+ * few seconds. Not an invention about the film: it is what a player does with
+ * an open-ended cue, made explicit so every consumer agrees on it.
+ *
+ * @param {{ startSeconds: number, endSeconds?: number | null, text: string }[]} cues
+ * @param {string} codecId
+ * @returns {{ startSeconds: number, endSeconds: number, text: string }[]}
+ */
+export function finalizeCues(cues, codecId) {
+  const result = [];
+  (Array.isArray(cues) ? cues : []).forEach((cue, index) => {
+    const next = cues[index + 1];
+    const endSeconds = cue.endSeconds ?? (next ? next.startSeconds : cue.startSeconds + 4);
+    const text = plainCueText(cue.text, codecId);
+    if (!text) {
+      return;
+    }
+    result.push({ startSeconds: cue.startSeconds, endSeconds, text });
+  });
+  return result;
 }
 
 /**
- * Convert ASS/SSA text to WebVTT (only the [Events] section; styling dropped).
+ * A WebVTT document from a list of cues — the one writer, used by every path
+ * that produces subtitles: a file beside the film, a track inside it, a pull
+ * and a push.
  *
- * @param {string} text
+ * @param {{ startSeconds: number, endSeconds?: number | null, text: string }[]} cues
+ * @param {string} codecId
  * @returns {string}
  */
-function assToVtt(text) {
-  const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-  let inEvents = false;
-  let formatCols = null;
-  const cues = [];
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed === "[Events]") {
-      inEvents = true;
-      continue;
-    }
-    if (trimmed.startsWith("[") && trimmed.endsWith("]") && inEvents) {
-      inEvents = false;
-      continue;
-    }
-    if (!inEvents) {
-      continue;
-    }
-    if (trimmed.startsWith("Format:")) {
-      formatCols = trimmed.slice("Format:".length).split(",").map((c) => c.trim().toLowerCase());
-      continue;
-    }
-    if (trimmed.startsWith("Dialogue:") && formatCols) {
-      const parts = trimmed.slice("Dialogue:".length).split(",");
-      const startIdx = formatCols.indexOf("start");
-      const endIdx = formatCols.indexOf("end");
-      const textIdx = formatCols.indexOf("text");
-      if (startIdx < 0 || endIdx < 0 || textIdx < 0) {
-        continue;
-      }
-      const cueText = stripAssTags(parts.slice(textIdx).join(","));
-      if (!cueText) {
-        continue;
-      }
-      cues.push(`${assTsToVtt((parts[startIdx] ?? "").trim())} --> ${assTsToVtt((parts[endIdx] ?? "").trim())}\n${cueText}`);
-    }
+export function cuesToVtt(cues, codecId) {
+  const lines = ["WEBVTT", ""];
+  for (const cue of finalizeCues(cues, codecId)) {
+    lines.push(`${vttTime(cue.startSeconds)} --> ${vttTime(cue.endSeconds)}`);
+    lines.push(cue.text);
+    lines.push("");
   }
-  return cues.length === 0 ? "WEBVTT\n" : `WEBVTT\n\n${cues.join("\n\n")}`;
+  return lines.join("\n");
 }
 
 /**
  * Convert subtitle text to WebVTT by file extension. Returns null for formats
  * that cannot be converted in-place (image-based .sup, ambiguous .sub, .ttml).
  *
+ * The reading is `SubtitleFileContainer`'s: the file states how its own cues
+ * are framed — SubRip by position, ASS by the `Format:` line of `[Events]` —
+ * and that is a fact about the file, not about this conversion.
+ *
  * @param {string} text
  * @param {string} ext - Lowercase extension including the dot, e.g. ".srt".
  * @returns {string | null}
  */
 export function convertSubtitleToVtt(text, ext) {
   const clean = stripBom(text);
-  switch (ext) {
-    case ".vtt":
-    case ".webvtt":
-      return clean.trimStart().startsWith("WEBVTT") ? clean : `WEBVTT\n\n${clean}`;
-    case ".srt":
-      return srtToVtt(clean);
-    case ".ass":
-    case ".ssa":
-      return assToVtt(clean);
-    default:
-      return null;
+  const extension = String(ext ?? "").toLowerCase();
+  if (extension === ".vtt" || extension === ".webvtt") {
+    // Already what a browser reads. Parsing it to write it back would drop its
+    // styles, its regions and its cue identifiers for nothing.
+    return clean.trimStart().startsWith("WEBVTT") ? clean : `WEBVTT\n\n${clean}`;
+  }
+  if (!SubtitleFileContainer.detect(extension)) {
+    return null;
   }
+  const cues = new SubtitleFileContainer({ extension }).readCues(clean);
+  return cues === null ? null : cuesToVtt(cues, extension);
 }

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

@@ -18,8 +18,11 @@
  */
 
 import { readSubtitlePlan, harvestCluster } from "../container-index/matroska-subtitles.js";
-import { decodeSubtitleSample, readMp4SubtitlePlan } from "../container-index/mp4-subtitles.js";
+import { readMp4SubtitlePlan } from "../container-index/mp4-subtitles.js";
 import { iterateElements } from "../container-index/ebml-reader.js";
+import { MatroskaContainer } from "../container/MatroskaContainer.js";
+import { Mp4Container } from "../container/Mp4Container.js";
+import { finalizeCues } from "../subtitle-convert.js";
 import { detectLanguage } from "../language-detect.js";
 import { logger } from "../../utils/logger.js";
 
@@ -358,7 +361,8 @@ async function walkFor(torrent, fileIndex, state, plan, track, trackNumber) {
         continue;
       }
       harvested.add(sample.offset);
-      const text = decodeSubtitleSample(bytes, track.codecId);
+      // The MP4 has framed this cue and is the one that unframes it.
+      const text = Mp4Container.cueTextOf(bytes, track.codecId);
       if (text) {
         cues.push({
           startSeconds: sample.startSeconds,
@@ -424,9 +428,18 @@ async function walkFor(torrent, fileIndex, state, plan, track, trackNumber) {
         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);
+      for (const block of harvestCluster(bytes, candidate.trackNumber, plan.secondsPerTick)) {
+        // The block's bytes become this track's text HERE, where the container
+        // that framed them is known. A cue kept in its framed form and unframed
+        // later cannot be unframed at all: nothing downstream knows which
+        // container it came out of, and guessing from the field count is what
+        // showed the dialogue row's own fields to the viewer.
+        into.push({
+          startSeconds: block.startSeconds,
+          endSeconds: block.endSeconds,
+          text: MatroskaContainer.cueTextOf(block.payload, candidate.codecId),
+          seq: nextSeq(state, candidate.trackNumber)
+        });
         found = true;
       }
       if (found) {
@@ -515,54 +528,6 @@ export async function warmSubtitleCues(torrent, fileIndex, sourceKey) {
   return fresh;
 }
 
-/**
- * Resolve a cue's end time and strip codec-specific formatting, turning a raw
- * block-derived cue into text a player can show directly. The same step
- * `routes/api/subtitles/get.js` applies when building WebVTT for a pull —
- * factored out here so a pushed cue and a pulled one read identically.
- *
- * A cue with no duration — a SimpleBlock, which subtitles rarely use — is
- * given the time until the next one IN THIS LIST, and the last such cue a few
- * seconds. Not an invention about the film: it is what a player does with an
- * open-ended cue, made explicit so every consumer agrees on it.
- *
- * @param {{ startSeconds: number, endSeconds: number | null, text: string }[]} cues
- * @param {string} codecId
- * @returns {{ startSeconds: number, endSeconds: number, text: string }[]}
- */
-export function finalizeCues(cues, codecId) {
-  const isAss = codecId === "S_TEXT/ASS" || codecId === "S_TEXT/SSA";
-  const result = [];
-  cues.forEach((cue, index) => {
-    const next = cues[index + 1];
-    const endSeconds = cue.endSeconds ?? (next ? next.startSeconds : cue.startSeconds + 4);
-    const text = isAss ? assDialogueToText(cue.text) : cue.text.trim();
-    if (!text) {
-      return;
-    }
-    result.push({ startSeconds: cue.startSeconds, endSeconds, text });
-  });
-  return result;
-}
-
-/**
- * The visible text of an ASS dialogue row.
- *
- * A block carries the fields after `Dialogue:` without their header — nine of
- * them, then the text, which itself holds override groups in braces.
- *
- * @param {string} raw
- * @returns {string}
- */
-function assDialogueToText(raw) {
-  const fields = raw.split(",");
-  const text = fields.length > 9 ? fields.slice(9).join(",") : raw;
-  return text
-    .replace(/\{[^}]*\}/g, "")
-    .replace(/\\N/gi, "\n")
-    .trim();
-}
-
 /**
  * The text subtitle tracks of a file, for the menu the viewer sees.
  *

package/services/tracks/TextSubtitleTrack.js

@@ -7,6 +7,7 @@
  */
 
 import { SubtitleTrack } from "./SubtitleTrack.js";
+import { markupKindOf, plainCueText } from "./subtitle-markup.js";
 
 const TEXT_CODECS_MATROSKA = new Set(["S_TEXT/UTF8", "S_TEXT/ASS", "S_TEXT/SSA", "S_TEXT/WEBVTT"]);
 const TEXT_FORMATS_MP4 = new Set(["tx3g", "text", "wvtt"]);
@@ -21,6 +22,23 @@ export class TextSubtitleTrack extends SubtitleTrack {
     return true;
   }
 
+  /** Which markup this track's cue text carries — see `subtitle-markup.js`. */
+  get markupKind() {
+    return markupKindOf(this.textCodec);
+  }
+
+  /**
+   * The visible text of one of this track's cues.
+   *
+   * @param {string} textField - The cue's text field, already out of its
+   *   container's framing. This method knows the codec and not the container,
+   *   which is why it cannot be handed a whole dialogue row.
+   * @returns {string}
+   */
+  plainText(textField) {
+    return plainCueText(textField, this.textCodec);
+  }
+
   static isTextCodec(codecId) {
     return TEXT_CODECS_MATROSKA.has(codecId) || TEXT_FORMATS_MP4.has(codecId);
   }

package/services/tracks/index.js

@@ -4,6 +4,7 @@ export { AudioTrack } from "./AudioTrack.js";
 export { SubtitleTrack } from "./SubtitleTrack.js";
 export { TextSubtitleTrack, TEXT_CODECS_MATROSKA, TEXT_FORMATS_MP4 } from "./TextSubtitleTrack.js";
 export { ImageSubtitleTrack } from "./ImageSubtitleTrack.js";
+export { MarkupKind, markupKindOf, plainCueText } from "./subtitle-markup.js";
 // There is deliberately no class for a track that lives in a file of its own.
 // `<name>.mka` is a Matroska container holding an `AudioTrack`, and
 // `MatroskaContainer` reads it exactly as it reads the picture's — so "external"

package/services/tracks/subtitle-markup.js

@@ -0,0 +1,104 @@
+/**
+ * @file The markup a subtitle codec puts INSIDE the text of one cue, and how to
+ * take it off. One axis of variation, and only one.
+ *
+ * Nothing here knows which container the text came out of. That is the other
+ * axis and it belongs to `container/`: how a cue's bytes are framed is stated by
+ * the CONTAINER's specification, not by the subtitle format's. Matroska
+ * reorders an ASS dialogue row and drops its two timing fields
+ * (`matroska.org/technical/subtitles.html`); a `.ass` file states its own field
+ * order in the `Format:` line of `[Events]`; an MP4 carries each cue as a sample
+ * with a length prefix. Every one of those is a fact about the container.
+ *
+ * What IS a fact about ASS, wherever it is stored: override groups in braces,
+ * `\N` and `\n` for a line break, `\h` for a hard space. That is this file.
+ *
+ * The two were mixed in one function until 2.72.1, which is what broke English
+ * subtitles on an embedded ASS track: the function counted commas to guess
+ * which framing it had been handed, expected ten fields — the shape of a row in
+ * a FILE — and a Matroska block carries nine. Every field of the row was then
+ * shown to the viewer as if it were dialogue. A function that has to guess the
+ * shape of its input is being called by someone who knew and did not say.
+ */
+
+/** How a cue's text is marked up, once the container's framing is off. */
+export const MarkupKind = {
+  /** Sub Station Alpha and its advanced form: `{\pos(…)}`, `\N`, `\h`. */
+  ASS: "ass",
+  /** Nothing to strip: the text is what is shown. */
+  NONE: "none"
+};
+
+/**
+ * Which markup a codec's cue text carries.
+ *
+ * The keys are every name this proxy has for a text subtitle codec: Matroska
+ * CodecIDs (RFC 9559 §5.1.4.1.28 and the codec mappings beside it), MP4 sample
+ * entry types (ISO/IEC 14496-12 §12.6, plus Apple's `tx3g`), and the file
+ * extensions a subtitle shipped beside the film uses. They are listed together
+ * because the ANSWER is the same for all of them — ASS is ASS whether it sits
+ * in a Matroska block, in a file, or nowhere yet — and keeping three tables
+ * would mean three places to forget.
+ *
+ * @type {Map<string, string>}
+ */
+const MARKUP_BY_CODEC = new Map([
+  ["S_TEXT/ASS", MarkupKind.ASS],
+  ["S_TEXT/SSA", MarkupKind.ASS],
+  [".ass", MarkupKind.ASS],
+  [".ssa", MarkupKind.ASS],
+  ["S_TEXT/UTF8", MarkupKind.NONE],
+  ["S_TEXT/WEBVTT", MarkupKind.NONE],
+  [".srt", MarkupKind.NONE],
+  [".vtt", MarkupKind.NONE],
+  [".webvtt", MarkupKind.NONE],
+  ["tx3g", MarkupKind.NONE],
+  ["text", MarkupKind.NONE],
+  ["wvtt", MarkupKind.NONE]
+]);
+
+/**
+ * The markup kind of a codec, by any of its names.
+ *
+ * An unknown codec is answered `NONE` rather than refused: the text is then
+ * shown as it is, which is wrong only in so far as some markup stays visible,
+ * where a refusal would show nothing at all.
+ *
+ * @param {string} codecId - Matroska CodecID, MP4 sample entry type, or a file
+ *   extension including the dot. Case is ignored for extensions, which arrive
+ *   from file names, and kept for the others, which are spelled by a spec.
+ * @returns {string} One of {@link MarkupKind}.
+ */
+export function markupKindOf(codecId) {
+  const name = String(codecId ?? "");
+  return MARKUP_BY_CODEC.get(name) ?? MARKUP_BY_CODEC.get(name.toLowerCase()) ?? MarkupKind.NONE;
+}
+
+/**
+ * The visible text of one cue: its markup taken off, nothing else touched.
+ *
+ * @param {string} text - The cue's text FIELD, already out of the container's
+ *   framing. Handing a whole dialogue row to this is the mistake described at
+ *   the top of this file.
+ * @param {string} codecId
+ * @returns {string} Possibly empty — a cue whose text is only a drawing command
+ *   or a positioning group has nothing to show, and the caller drops it.
+ */
+export function plainCueText(text, codecId) {
+  const raw = String(text ?? "");
+  if (markupKindOf(codecId) !== MarkupKind.ASS) {
+    return raw.trim();
+  }
+  return raw
+    // An override group. Any brace content is a directive, never dialogue:
+    // drawing commands, karaoke timing, positioning, font changes.
+    .replace(/\{[^}]*\}/g, "")
+    // Both breaks reach a player as a break. ASS distinguishes them — `\N` is
+    // always a break, `\n` only where the style does not wrap — and a WebVTT
+    // cue has no way to express the difference, so it takes the break.
+    .replace(/\\N/g, "\n")
+    .replace(/\\n/g, "\n")
+    // A space the renderer may not collapse.
+    .replace(/\\h/g, " ")
+    .trim();
+}

package/test/piece-store-reservations.test.js

@@ -156,7 +156,12 @@ test("a spill that fails gives back the slot the eviction claimed", async () =>
   }
 });
 
-test("a claim that cannot be met ends in an error, not in waiting for ever", async () => {
+// A bound, because the failure this catches is a claim that never ends: without
+// it the check does not fail, it HANGS, and `node --test` then cannot finish at
+// all — which is what happened between 2026-08-31 and 2026-09-03 (roadmap item
+// 54). The store gives up after PINNED_WAIT_MS, so 30 s is ample for the answer
+// and short enough to be a failure rather than a stoppage.
+test("a claim that cannot be met ends in an error, not in waiting for ever", { timeout: 30_000 }, async () => {
   const disk = makeDisk({ holdWrites: true });
   const { store } = makeStore({ pieces: 2, disk });
   try {
@@ -183,7 +188,7 @@ test("a claim that cannot be met ends in an error, not in waiting for ever", asy
   }
 });
 
-test("closing the store fails whoever is waiting for room", async () => {
+test("closing the store fails whoever is waiting for room", { timeout: 30_000 }, async () => {
   const disk = makeDisk({ holdWrites: true });
   const { store } = makeStore({ pieces: 2, disk });
   try {
@@ -194,7 +199,15 @@ test("closing the store fails whoever is waiting for room", async () => {
     store.pin(1);
 
     const waiting = put(store, 3);
-    await until(() => store.stats().waitedForPins > 0, "the claim is waiting");
+    // Either counter: the claim waits for the disk first — a block is in flight
+    // and the store is full, so evicting another piece would only raise the
+    // memory in use — and reaches the pinned wait five seconds later. Asking for
+    // `waitedForPins` alone named one of the two ways of waiting and timed out
+    // while the store was demonstrably doing the other.
+    await until(
+      () => store.stats().waitedForPins + store.stats().waitedForDisk > 0,
+      "the claim is waiting"
+    );
 
     await new Promise((resolve) => store.close(resolve));
     await assert.rejects(() => waiting, /closed/);
@@ -207,20 +220,30 @@ test("closing the store fails whoever is waiting for room", async () => {
   }
 });
 
-test("a piece written back to memory is not resurrected on disk by its own spill", async () => {
+test("a piece written back to memory is not resurrected on disk by its own spill", { timeout: 30_000 }, async () => {
   const disk = makeDisk({ holdWrites: true });
-  const { store } = makeStore({ pieces: 3, disk });
+  const { store } = makeStore({ pieces: 4, disk });
   try {
     await put(store, 0);
     await put(store, 1);
     await put(store, 2);
 
     // Piece 0 leaves memory because the machine's allowance fell; its write is
-    // still in flight. The allowance then recovers, so there is room again
-    // without waiting for that write.
+    // still in flight. The allowance then recovers to MORE than it was, so the
+    // piece coming back needs no eviction and no wait for that write.
+    //
+    // Four blocks, not three, and the reason is what this check is about. A
+    // block being written out is still memory in use, so with a ceiling of three
+    // and one block in flight the store is full, and the claim correctly waits
+    // for the disk — which the earlier setup did not allow for, so the check
+    // timed out on an admission policy it never meant to measure. Whether a
+    // piece arriving while its OWN spill is in flight should be admitted without
+    // taking a second block is a real question about the accounting and is
+    // roadmap item 9, not this check's subject: the subject is that the spill,
+    // when it completes, must not put the stale copy back on disk.
     store.reviseGrowthCeiling(CHUNK * 2);
     await until(() => disk.heldCount > 0, "the spill of piece 0 is in flight");
-    store.reviseGrowthCeiling(CHUNK * 3);
+    store.reviseGrowthCeiling(CHUNK * 4);
 
     // The swarm hands piece 0 back while that write is still going. The store
     // must drop the disk copy AFTER the write has recorded it, not before —