@torrent-tv/proxy 2.71.1 → 2.72.1

package/services/piece-store/piece-lru.js

@@ -248,6 +248,49 @@ export class PieceLru {
     };
   }
 
+  /**
+   * How long this piece will be waited for, in pieces.
+   *
+   * A window starts at what its reader needs NEXT and runs forward, so a piece
+   * near the start of a window is wanted sooner than one at its far end, and
+   * one beyond every window is wanted later still. That is the comparison the
+   * store needs when a piece arrives at a full store: is the arrival wanted
+   * sooner or later than the piece it would displace?
+   *
+   * `#distanceToWindow` cannot answer it — everything inside any window is zero
+   * there, so a piece at the front of the reader's own window and one at the
+   * far end of somebody else's look identical.
+   *
+   * A piece BEHIND every window is counted by how far behind, because a reader
+   * walking forward will not come back to it: behind is late, not early.
+   *
+   * @param {number} index
+   * @returns {number} -1 when nobody has declared anything.
+   */
+  waitFor(index) {
+    let soonest = -1;
+    for (const range of this.#protected.values()) {
+      const wait = index < range.from ? range.from - index : index - range.from;
+      if (soonest === -1 || wait < soonest) {
+        soonest = wait;
+      }
+    }
+    return soonest;
+  }
+
+  /**
+   * The piece that would be evicted next, and how long it will be waited for.
+   *
+   * @returns {{ index: number | null, wait: number }}
+   */
+  nextVictim() {
+    const choice = this.evictionChoice();
+    return {
+      index: choice.index,
+      wait: choice.index === null ? -1 : this.waitFor(choice.index)
+    };
+  }
+
   /**
    * Whether a reader is holding this piece right now.
    *

package/services/piece-store/shared-piece-store.js

@@ -272,6 +272,12 @@ const REVIVAL_AGE_SAMPLES = 200;
  */
 const REUSE_GAP_SAMPLES = 200;
 
+/** How many write durations are kept for the median. */
+const WRITE_DURATION_SAMPLES = 50;
+/** How many admission times are kept, and how far back they are counted. */
+const ARRIVAL_SAMPLES = 100;
+const ARRIVAL_WINDOW_MS = 10_000;
+
 /**
  * The middle value of a sample, or null when there is nothing to take a middle
  * of. Null rather than zero: no revivals and instant revivals are different
@@ -355,7 +361,29 @@ export class SharedPieceStore {
      */
     returnedWhilePinned: 0,
     /** Spills that found the disk already holding identical bytes. */
-    spillsSkipped: 0
+    spillsSkipped: 0,
+    /**
+     * Blocks a second registration of the same piece displaced. Expected to be
+     * small and non-zero: two callers racing for one piece is ordinary. What is
+     * NOT ordinary is the block going missing when it happens, which is what
+     * killed the process on 2026-09-02.
+     */
+    blocksDisplaced: 0,
+    /** Admissions that waited for the disk instead of evicting another piece. */
+    waitedForDisk: 0,
+    /**
+     * Admissions that grew memory because the disk had stopped answering.
+     * Non-zero means the store exceeded its allowance on purpose, and by how
+     * many pieces.
+     */
+    grewWaitingForDisk: 0,
+    /**
+     * Times a block was wanted, none was free, and the pool was already at its
+     * ceiling. Zero by construction — a block is only taken after a slot has
+     * been claimed, and slots are what the ceiling counts — so a number here
+     * means the two have come apart and the pool is growing past its allowance.
+     */
+    blocksBeyondCeiling: 0
   };
   /**
    * Blocks that hold no piece, most recently freed last.
@@ -384,6 +412,19 @@ export class SharedPieceStore {
    * @type {number[]}
    */
   #reuseGaps = [];
+  /**
+   * How long recent writes to disk took, in milliseconds, and when pieces were
+   * admitted. Together they say how much room the store needs beyond what the
+   * readers ask for: while one write is finishing, more pieces arrive, and each
+   * needs somewhere to go. Without that room every arrival evicts something,
+   * which is what produced 233 evictions against 119 completed writes in a
+   * minute on 2026-09-02.
+   *
+   * @type {number[]}
+   */
+  #writeDurations = [];
+  /** When the last few pieces were admitted, for the arrival rate. */
+  #admittedAt = [];
   /** Piece index → when it was written out, for the age it comes back at. */
   #spilledAt = new Map();
   /**
@@ -460,6 +501,10 @@ export class SharedPieceStore {
       // grows (roadmap item 2).
       blocksAllocated: this.#blocksAllocated,
       blocksFree: this.#freeBlocks.length,
+      blocksDisplaced: this.#counters.blocksDisplaced,
+      blocksInUse: this.#blocksInUse(),
+      blocksInFlight: this.#blocksInFlight(),
+      blocksBeyondCeiling: this.#counters.blocksBeyondCeiling,
       blockBytes: this.#blocksAllocated * this.#chunkLength,
       reuseGapMs: this.#reuseGapCeilingMs(),
       revivalAgeMedianMs: median(this.#revivalAges),
@@ -505,7 +550,12 @@ export class SharedPieceStore {
     if (demand.readers > 0) {
       this.#everHadReader = true;
       const pieces = Math.max(MIN_RESIDENT_PIECES, demand.unionPieces, demand.widestPieces);
-      return pieces * this.#chunkLength;
+      // Plus room to absorb what arrives while a write is finishing. Asking for
+      // exactly what the readers want leaves no free place ever, so every
+      // arrival evicts one of them — measured 2026-09-02: `6 reader(s) want 23
+      // piece(s) of 23 the store may hold`, and 233 evictions in the minute
+      // that followed.
+      return (pieces + this.slackPieces()) * this.#chunkLength;
     }
     // Readers that have GONE are not the same as readers that have not arrived.
     // A store whose readers ended has nothing to hold pieces for — its torrent
@@ -515,7 +565,7 @@ export class SharedPieceStore {
     // reader is being filled for one that is on its way, and asks for what it
     // was opened with until the first read says what it needs.
     return this.#everHadReader
-      ? MIN_RESIDENT_PIECES * this.#chunkLength
+      ? (MIN_RESIDENT_PIECES + this.slackPieces()) * this.#chunkLength
       : this.#growthCeiling * this.#chunkLength;
   }
 
@@ -700,7 +750,21 @@ export class SharedPieceStore {
   }
 
   #registerPiece(index, buffer) {
+    // A piece may already be here. Both paths that register one look first and
+    // then await — `put` waits for a slot, `#revive` waits for the disk — and
+    // in that gap another caller can register the same index. Overwriting the
+    // entry used to drop the previous block on the floor: its memory was not
+    // returned to the pool and the pool's own count was never decremented, so
+    // the count climbed past the ceiling for ever and the pool degenerated into
+    // allocating a fresh block per piece. Field 2026-09-02: a store holding
+    // THREE pieces reported 812 MB committed against 68 MB allowed, 739 blocks
+    // allocated and 676 still alive, and the process was killed at 4.37 GB.
+    const displaced = this.#buffers.get(index);
     this.#buffers.set(index, buffer);
+    if (displaced !== undefined && displaced !== buffer) {
+      this.#counters.blocksDisplaced += 1;
+      this.#returnBlock(displaced);
+    }
     this.#lru.touch(index);
     this.#noteProgress();
   }
@@ -730,8 +794,10 @@ export class SharedPieceStore {
     }
 
     const bytes = Buffer.from(buffer, 0, this.#lengthOf(index));
+    const startedAt = Date.now();
     const spill = this.#disk.write(index, bytes).then(
       () => {
+        this.#noteWriteDuration(Date.now() - startedAt);
         this.#counters.spills += 1;
         this.#spilledAt.set(index, Date.now());
         this.#evicting.delete(index);
@@ -760,6 +826,84 @@ export class SharedPieceStore {
     this.#wake();
   }
 
+  /**
+   * Record how long one write to disk took.
+   *
+   * @param {number} durationMs
+   * @returns {void}
+   */
+  #noteWriteDuration(durationMs) {
+    this.#writeDurations.push(Math.max(0, durationMs));
+    if (this.#writeDurations.length > WRITE_DURATION_SAMPLES) {
+      this.#writeDurations.shift();
+    }
+  }
+
+  /** Record that a piece arrived, for the arrival rate. */
+  #noteArrival() {
+    const now = Date.now();
+    this.#admittedAt.push(now);
+    while (this.#admittedAt.length > ARRIVAL_SAMPLES
+      || (this.#admittedAt.length > 0 && now - this.#admittedAt[0] > ARRIVAL_WINDOW_MS)) {
+      this.#admittedAt.shift();
+    }
+  }
+
+  /**
+   * How many pieces the store needs room for beyond what the readers ask for.
+   *
+   * Measured, not chosen: the pieces that arrive while one write to disk is
+   * finishing. Without this room every arrival must evict something, and each
+   * eviction holds its block until its write completes — so a disk slower than
+   * the swarm turns every admission into one more block held. On 2026-09-02
+   * that was 233 evictions against 119 completed writes in a minute, and 203
+   * blocks held with three pieces resident.
+   *
+   * Zero until both quantities have been seen, because a slack invented before
+   * anything is measured is a chosen number, and this store has been bitten by
+   * those.
+   *
+   * @returns {number} Pieces.
+   */
+  slackPieces() {
+    if (this.#writeDurations.length === 0 || this.#admittedAt.length < 2) {
+      return 0;
+    }
+    const sorted = [...this.#writeDurations].sort((left, right) => left - right);
+    const writeMs = sorted[Math.floor(sorted.length / 2)];
+    const spanMs = this.#admittedAt[this.#admittedAt.length - 1] - this.#admittedAt[0];
+    if (!(spanMs > 0)) {
+      return 0;
+    }
+    const perMs = (this.#admittedAt.length - 1) / spanMs;
+    return Math.ceil(perMs * writeMs);
+  }
+
+  /**
+   * Blocks that are not free: resident pieces, blocks being written out, and
+   * blocks taken but not yet registered.
+   *
+   * This is what the ceiling has to bound, and until 2026-09-02 it bounded
+   * resident pieces instead. The difference is exactly the memory that goes
+   * missing from the count: a piece being spilled leaves `#buffers` the moment
+   * the eviction begins, while its block stays held until the write it feeds
+   * has finished.
+   *
+   * @returns {number}
+   */
+  #blocksInUse() {
+    return this.#blocksAllocated - this.#freeBlocks.length;
+  }
+
+  /**
+   * Blocks held by writes that have not finished.
+   *
+   * @returns {number}
+   */
+  #blocksInFlight() {
+    return Math.max(0, this.#blocksInUse() - this.#buffers.size);
+  }
+
   /**
    * Whether admitting one more piece would need something evicted first.
    *
@@ -769,7 +913,7 @@ export class SharedPieceStore {
    * @returns {boolean}
    */
   #isFullNow() {
-    return this.#buffers.size + this.#outstandingPieces >= this.#growthCeiling;
+    return this.#blocksInUse() + this.#outstandingPieces >= this.#growthCeiling;
   }
 
   /**
@@ -859,12 +1003,39 @@ export class SharedPieceStore {
 
   async #claimSlotOnce() {
     // Reserve before suspension so concurrent callers see the reservation.
-    if (this.#buffers.size + this.#outstandingPieces < this.#growthCeiling) {
+    if (this.#blocksInUse() + this.#outstandingPieces < this.#growthCeiling) {
       this.#outstandingPieces += 1;
       this.#pinnedWaitStartedAt = 0;
       return true;
     }
 
+    // Full, and evicting would make it worse rather than better. A piece being
+    // written out has already left `#buffers` while its block is still held —
+    // the write reads from that block — so evicting another one converts a
+    // resident block into an in-flight block and takes a fresh block for the
+    // arrival: the memory in use goes UP by one per admission for as long as
+    // the disk is behind. Field 2026-09-02: 233 evictions against 119 completed
+    // writes in a minute, 203 blocks held with three pieces resident, and the
+    // process killed at 4.37 GB.
+    //
+    // So when the disk is what the store is waiting for, it waits. A completing
+    // write calls `#noteProgress`, which wakes whoever is here.
+    if (this.#blocksInFlight() > 0 && this.#blocksInUse() >= this.#growthCeiling) {
+      if (this.#pinnedWaitStartedAt === 0) {
+        this.#pinnedWaitStartedAt = Date.now();
+      }
+      const stillFor = Date.now() - Math.max(this.#pinnedWaitStartedAt, this.#lastProgressAt);
+      if (stillFor < PINNED_WAIT_MS) {
+        this.#counters.waitedForDisk += 1;
+        return false;
+      }
+      // The disk has stopped answering. Falling through to eviction is the
+      // lesser failure: it grows memory, and the line above says by how much,
+      // where refusing would fail the read outright.
+      this.#pinnedWaitStartedAt = 0;
+      this.#counters.grewWaitingForDisk += 1;
+    }
+
     const { index: victim, protectionYielded, distance } = this.#lru.evictionChoice();
     if (victim === null) {
       // Nothing may leave. Wait while the store is still MOVING — a spill
@@ -984,6 +1155,19 @@ export class SharedPieceStore {
       this.#noteReuseGap(Date.now() - spare.freedAt);
       return spare.buffer;
     }
+    // Nothing spare and the pool is already as large as it is allowed to be.
+    // This cannot happen while the accounting is sound: a block is taken only
+    // after a slot has been claimed, and slots are exactly what the ceiling
+    // counts. It is recorded rather than hidden because when it does happen the
+    // pool grows without bound, and every block it then allocates is used once
+    // and thrown to a collector that has no reason to run — the heap stays at
+    // 50 MB of 2240 while the process reaches four gigabytes.
+    // Strictly greater: reaching the ceiling exactly is what a full store looks
+    // like, and a slot has just been claimed for this block. Being ALREADY past
+    // it and allocating anyway is the state that runs away.
+    if (this.#blocksAllocated > this.#growthCeiling) {
+      this.#counters.blocksBeyondCeiling += 1;
+    }
     this.#blocksAllocated += 1;
     return this.#watchForCollection(new SharedArrayBuffer(this.#chunkLength));
   }
@@ -1162,6 +1346,7 @@ export class SharedPieceStore {
         return;
       }
 
+      this.#noteArrival();
       const declared = this.#lru.wants(index);
       if (declared) {
         this.#counters.admittedInsideWindow += 1;
@@ -1169,12 +1354,30 @@ export class SharedPieceStore {
         this.#counters.admittedOutsideWindow += 1;
       }
 
-      // A piece no reader has declared, arriving at a store with no room, goes
-      // straight to disk. It costs the same one write it would have cost when
-      // the next arrival evicted it, and it saves pushing out a piece a reader
-      // is about to read. Only when SOMETHING is declared: before the first
-      // read there is no basis for calling a piece unwanted.
-      if (!declared && this.#lru.protectedCount > 0 && this.#isFullNow()) {
+      // A piece that will be wanted LATER than the one it would displace goes
+      // straight to disk instead of being admitted.
+      //
+      // Two cases, and the second was missing until 2026-09-02. The first: the
+      // arrival is in nobody's window at all. The second: it IS in somebody's
+      // window, but further from every read head than the piece the store would
+      // have to evict to make room for it — so admitting it would write out the
+      // nearer piece and read it back sooner. The field session had six readers
+      // whose windows covered the whole file, so the first case never applied
+      // and `0 of those went straight to disk` while the store spilled 233
+      // pieces in a minute.
+      //
+      // Only when SOMETHING is declared: before the first read there is no
+      // basis for calling one piece more wanted than another.
+      const worseThanTheVictim = () => {
+        const arriving = this.#lru.waitFor(index);
+        if (arriving < 0) {
+          return false;
+        }
+        const victim = this.#lru.nextVictim();
+        return victim.index !== null && victim.wait >= 0 && arriving > victim.wait;
+      };
+      if (this.#lru.protectedCount > 0 && this.#isFullNow()
+        && (!declared || worseThanTheVictim())) {
         this.#counters.admittedToDisk += 1;
         await this.#writeThrough(index, bytes);
         this.#noteProgress();

package/services/playback-planner.js

@@ -502,6 +502,13 @@ export function createPlaybackPlanner({
     if (offer && offer.copy.length === 0 && offer.transcode.length === 0) {
       withOffer.cannotServe =
         "This proxy cannot keep up with this file at any quality right now.";
+      // The description travels with the refusal, and only with it. It is what
+      // lets the browser ask the rest of the pool the same question without
+      // anybody else adding the torrent, fetching a byte or running ffmpeg —
+      // the expensive half of finding out what this file IS has been paid here,
+      // once. Everyone else answers by arithmetic against their own startup
+      // benchmarks.
+      withOffer.mediaInfoForOffer = plan.mediaInfoForOffer;
     }
     return withOffer;
   }

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);
 }