@torrent-tv/proxy 2.73.1 → 2.74.0

package/services/container-index/matroska-blocks.js

@@ -1,202 +0,0 @@
-/**
- * @file Subtitle blocks out of Matroska clusters, from bytes already in hand.
- *
- * A subtitle track is sparse — a few kilobytes spread across a whole film — and
- * ffmpeg cannot extract a time range of one without walking the container to
- * the end. Measured 2026-08-19 on `Minions.and.Monsters.1080p.mkv`: asking for
- * four seconds at minute twenty read the file through and pulled the download
- * from 2.7 % to 81 %; asking with `-copyts -ss -to` took 154 s on a copy that
- * was already 81 % local and still emitted the whole track. So the subtitles
- * are not asked of ffmpeg.
- *
- * They do not have to be. A subtitle block sits in the same cluster as the
- * picture around it, and those clusters are being downloaded anyway for the
- * viewer to watch. Reading them as they arrive costs no network at all, and it
- * puts the cues ahead of the playhead by construction — which is the whole
- * requirement: subtitles arrive like the picture does, or they are not offered.
- *
- * This module is the byte-level half: given a cluster's bytes, it returns the
- * blocks of one track with their times. It reads element headers and skips
- * payloads by their declared length; nothing is decoded.
- *
- * Structure, from RFC 9559 §5.1.3 and §5.1.4:
- *
- *   Cluster (0x1F43B675)
- *     Timestamp (0xE7)            — the cluster's own time, in ticks
- *     SimpleBlock (0xA3)          — a block with no duration of its own
- *     BlockGroup (0xA0)
- *       Block (0xA1)              — the same header, and where subtitles live
- *       BlockDuration (0x9B)      — how long the cue stays on screen
- *
- * A block's header is: the track number as a variable-length integer, a signed
- * 16-bit timestamp relative to the cluster, and one byte of flags. Subtitles
- * are normally in a BlockGroup, because a cue without a duration has no end.
- */
-
-import { iterateElements, readUint, readVint } from "./ebml-reader.js";
-
-const ID_TIMESTAMP = 0xe7;
-const ID_SIMPLE_BLOCK = 0xa3;
-const ID_BLOCK_GROUP = 0xa0;
-const ID_BLOCK = 0xa1;
-const ID_BLOCK_DURATION = 0x9b;
-
-/** Bits 1-2 of the flags byte say how a block is laced, or that it is not. */
-const LACING_MASK = 0x06;
-const LACING_NONE = 0x00;
-const LACING_XIPH = 0x02;
-const LACING_FIXED = 0x04;
-const LACING_EBML = 0x06;
-
-/**
- * @typedef {object} SubtitleBlock
- * @property {number} startSeconds - When the cue appears.
- * @property {number | null} durationSeconds - How long it stays, or null when
- *   the block carried no duration (a SimpleBlock; the caller decides).
- * @property {Buffer} payload - The block's own bytes, still in the codec's form.
- */
-
-/**
- * Read one block's header.
- *
- * @param {Buffer} buffer
- * @param {number} start - First byte of the block's payload.
- * @param {number} end - One past its last byte.
- * @returns {{ trackNumber: number, relativeTicks: number, flags: number, dataOffset: number } | null}
- */
-function readBlockHeader(buffer, start, end) {
-  const track = readVint(buffer, start, false);
-  if (!track || track.value === null) {
-    return null;
-  }
-  const timestampAt = start + track.length;
-  // Signed, and it can be negative: a block may belong slightly before the
-  // cluster it is stored in.
-  if (timestampAt + 3 > end) {
-    return null;
-  }
-  return {
-    trackNumber: Number(track.value),
-    relativeTicks: buffer.readInt16BE(timestampAt),
-    flags: buffer[timestampAt + 2],
-    dataOffset: timestampAt + 3
-  };
-}
-
-/**
- * Where a laced block's first frame begins.
- *
- * Subtitles are rarely laced, but a block that IS laced starts with a frame
- * count and a table of sizes, and reading the payload without stepping over
- * them yields the table as though it were text.
- *
- * @param {Buffer} buffer
- * @param {number} dataOffset - First byte after the block header.
- * @param {number} end
- * @param {number} flags
- * @returns {number | null} The offset of the first frame, or null when the
- *   lacing cannot be read.
- */
-function firstFrameOffset(buffer, dataOffset, end, flags) {
-  const lacing = flags & LACING_MASK;
-  if (lacing === LACING_NONE) {
-    return dataOffset;
-  }
-  if (dataOffset >= end) {
-    return null;
-  }
-  const frames = buffer[dataOffset] + 1;
-  let at = dataOffset + 1;
-  if (lacing === LACING_FIXED) {
-    return at;
-  }
-  if (lacing === LACING_XIPH) {
-    // Each size but the last is a run of 0xFF bytes ending in a smaller one.
-    for (let frame = 0; frame < frames - 1; frame += 1) {
-      while (at < end && buffer[at] === 0xff) {
-        at += 1;
-      }
-      at += 1;
-    }
-    return at <= end ? at : null;
-  }
-  if (lacing === LACING_EBML) {
-    // The first size is a plain variable-length integer, the rest are signed
-    // differences from it; either way each is one such integer to step over.
-    for (let frame = 0; frame < frames - 1; frame += 1) {
-      const size = readVint(buffer, at, false);
-      if (!size) {
-        return null;
-      }
-      at += size.length;
-    }
-    return at <= end ? at : null;
-  }
-  return null;
-}
-
-/**
- * Every block of one track inside one cluster.
- *
- * @param {Buffer} buffer - Bytes holding the cluster's payload.
- * @param {{ dataOffset: number, size: number }} cluster - Where that payload is.
- * @param {number} trackNumber - The track to keep.
- * @param {number} secondsPerTick - From the segment's timestamp scale.
- * @returns {SubtitleBlock[]}
- */
-export function blocksOfTrack(buffer, cluster, trackNumber, secondsPerTick) {
-  const end = Math.min(buffer.length, cluster.dataOffset + cluster.size);
-  /** @type {SubtitleBlock[]} */
-  const blocks = [];
-  let clusterTicks = null;
-
-  const take = (blockStart, blockEnd, durationTicks) => {
-    const header = readBlockHeader(buffer, blockStart, blockEnd);
-    if (!header || header.trackNumber !== trackNumber || clusterTicks === null) {
-      return;
-    }
-    const payloadAt = firstFrameOffset(buffer, header.dataOffset, blockEnd, header.flags);
-    if (payloadAt === null || payloadAt >= blockEnd) {
-      return;
-    }
-    blocks.push({
-      startSeconds: (clusterTicks + header.relativeTicks) * secondsPerTick,
-      durationSeconds: durationTicks === null ? null : durationTicks * secondsPerTick,
-      payload: buffer.subarray(payloadAt, blockEnd)
-    });
-  };
-
-  for (const element of iterateElements(buffer, cluster.dataOffset, end)) {
-    const elementEnd = Math.min(end, element.dataOffset + element.size);
-    if (element.id === ID_TIMESTAMP) {
-      clusterTicks = readUint(buffer, element.dataOffset, element.size);
-      continue;
-    }
-    if (element.id === ID_SIMPLE_BLOCK) {
-      take(element.dataOffset, elementEnd, null);
-      continue;
-    }
-    if (element.id !== ID_BLOCK_GROUP) {
-      continue;
-    }
-    // A group holds the block and, for a subtitle, the duration that says when
-    // the cue leaves the screen. Both are read before either is used, because
-    // the duration may be written after the block.
-    let blockStart = null;
-    let blockEnd = null;
-    let durationTicks = null;
-    for (const field of iterateElements(buffer, element.dataOffset, elementEnd)) {
-      const fieldEnd = Math.min(elementEnd, field.dataOffset + field.size);
-      if (field.id === ID_BLOCK) {
-        blockStart = field.dataOffset;
-        blockEnd = fieldEnd;
-      } else if (field.id === ID_BLOCK_DURATION) {
-        durationTicks = readUint(buffer, field.dataOffset, field.size);
-      }
-    }
-    if (blockStart !== null) {
-      take(blockStart, blockEnd, durationTicks);
-    }
-  }
-  return blocks;
-}

package/services/container-index/matroska-subtitles.js

@@ -1,372 +0,0 @@
-/**
- * @file The subtitle tracks of a Matroska file, and where their cues live.
- *
- * Two halves, both reading only what is asked for by byte range:
- *
- *   - {@link readSubtitlePlan} — once per file: which tracks are text
- *     subtitles, in what codec, and the cluster positions their cue points
- *     name. Two short reads, the head and the Cues element, exactly as the
- *     keyframe reader already does.
- *   - {@link harvestCluster} — per cluster, over bytes already downloaded:
- *     the cues inside it, ready to be shown.
- *
- * Kept apart from `matroska.js` because that file answers one question (where
- * are the keyframes) and is read on the path that starts playback; this one is
- * only ever consulted for a viewer who asked for subtitles.
- */
-
-import { findElement, iterateElements, readUint } from "./ebml-reader.js";
-import { blocksOfTrack } from "./matroska-blocks.js";
-
-const ID_SEGMENT = 0x18538067;
-const ID_SEEK_HEAD = 0x114d9b74;
-const ID_SEEK = 0x4dbb;
-const ID_SEEK_ID = 0x53ab;
-const ID_SEEK_POSITION = 0x53ac;
-const ID_INFO = 0x1549a966;
-const ID_TIMESTAMP_SCALE = 0x2ad7b1;
-const ID_TRACKS = 0x1654ae6b;
-const ID_TRACK_ENTRY = 0xae;
-const ID_TRACK_NUMBER = 0xd7;
-const ID_TRACK_TYPE = 0x83;
-const ID_CODEC_ID = 0x86;
-const ID_CODEC_PRIVATE = 0x63a2;
-const ID_LANGUAGE = 0x22b59c;
-const ID_NAME = 0x536e;
-const ID_FLAG_DEFAULT = 0x88;
-/**
- * The rest of what a TrackEntry says about itself, RFC 9559 §5.1.4.1. Read
- * because the file states them and a releaser's own wording in `Name` is the
- * only thing we had before: "fors" and "SDH" in a menu were whatever text
- * someone happened to type.
- *
- * `FlagEnabled` defaults to 1 and means "the track is usable"; a track that
- * says 0 is counted but not offered. `FlagForced` applies only to subtitles and
- * defaults to 0. `FlagHearingImpaired` is set "if and only if the track is
- * suitable for users with hearing impairments". `FlagVisualImpaired`,
- * `FlagOriginal` and `FlagCommentary` bear on the AUDIO choice and are read
- * with that work, not here — see roadmap item 55.
- */
-const ID_FLAG_ENABLED = 0xb9;
-const ID_FLAG_FORCED = 0x55aa;
-const ID_FLAG_HEARING_IMPAIRED = 0x55ab;
-/**
- * The language as RFC 5646 writes it. The specification is a MUST: "If this
- * element is used, then any Language elements used in the same TrackEntry MUST
- * be ignored" — so where both are present, this one is the answer and the
- * three-letter code is not.
- */
-const ID_LANGUAGE_BCP47 = 0x22b59d;
-const ID_CUES = 0x1c53bb6b;
-const ID_CUE_POINT = 0xbb;
-const ID_CUE_TRACK_POSITIONS = 0xb7;
-const ID_CUE_TRACK = 0xf7;
-const ID_CUE_CLUSTER_POSITION = 0xf1;
-
-/** TrackType 17 is subtitles; 1 is video and 2 audio. */
-const TRACK_TYPE_SUBTITLE = 17;
-/** How much of the file start to read: the same window the keyframe reader uses. */
-const HEAD_BYTES = 64 * 1024;
-/** Cap on the Cues read; a long film indexes to tens of KB. */
-const MAX_CUES_BYTES = 8 * 1024 * 1024;
-const DEFAULT_TIMESTAMP_SCALE = 1_000_000;
-
-/**
- * The codecs whose blocks are text this proxy can turn into WebVTT.
- *
- * `S_TEXT/UTF8` is a plain line of text and needs nothing. `S_TEXT/ASS` and
- * `S_TEXT/SSA` carry a dialogue row whose fields have to be stripped, and their
- * header lives in CodecPrivate — supported, with the stripping done where the
- * cue is turned into WebVTT. `S_HDMV/PGS` and `S_VOBSUB` are pictures, not
- * text, and are deliberately absent: offering them would promise something this
- * path cannot deliver.
- */
-const TEXT_CODECS = new Set(["S_TEXT/UTF8", "S_TEXT/ASS", "S_TEXT/SSA"]);
-
-/**
- * @typedef {object} SubtitleTrackPlan
- * @property {number} trackNumber - As the blocks name it.
- * @property {number} declaredIndex - Its position among ALL of the file's
- *   subtitle tracks, picture-based ones included — which is the number ffmpeg
- *   gives the same stream in `0:s:N`, and therefore the only number the browser
- *   ever names. Text tracks alone are not a numbering: a file whose PGS track
- *   comes first would have every text track one lower here than in the browser.
- * @property {string} codecId
- * @property {string} language - The language the file declares: its RFC 5646
- *   tag where it writes one, and the three-letter code otherwise. The
- *   specification requires that order — where `LanguageBCP47` is present, the
- *   `Language` element MUST be ignored.
- * @property {string} languageBcp47 - The RFC 5646 tag alone, or "".
- * @property {string} name - What the file calls the track, if anything.
- * @property {boolean} isDefault
- * @property {boolean} isForced - `FlagForced`: the track carries what a viewer
- *   needs even when they asked for no subtitles — signs, and dialogue in
- *   another language. It does NOT carry the film's own dialogue.
- * @property {boolean} isHearingImpaired - `FlagHearingImpaired`: suitable for
- *   viewers who cannot hear, so it carries non-speech sound as well as speech.
- * @property {string} codecPrivate - The ASS/SSA header, base64, or "".
- * @property {number[]} clusterPositions - File offsets of clusters whose cue
- *   points name this track, ascending. Empty when the file indexes only its
- *   picture, and then the caller has to walk clusters as they arrive instead.
- */
-
-/**
- * Read a string element, trimming the padding some muxers leave.
- *
- * @param {Buffer} buffer
- * @param {{ dataOffset: number, size: number }} element
- * @returns {string}
- */
-function readString(buffer, element) {
-  return buffer
-    .toString("utf8", element.dataOffset, element.dataOffset + element.size)
-    .replace(/\0+$/, "");
-}
-
-/**
- * Everything about a file's text subtitle tracks that can be learned without
- * reading the film.
- *
- * @param {(start: number, end: number) => Promise<Buffer | null>} readRange
- * @param {number} fileSize
- * @returns {Promise<{ tracks: SubtitleTrackPlan[], declared: object[], secondsPerTick: number, segmentDataOffset: number } | null>}
- */
-export async function readSubtitlePlan(readRange, fileSize) {
-  const head = await readRange(0, Math.min(HEAD_BYTES, Math.max(0, fileSize - 1)));
-  if (!head || head.length < 4 || head.readUInt32BE(0) !== 0x1a45dfa3) {
-    return null;
-  }
-  const segment = findElement(head, ID_SEGMENT, []);
-  if (!segment) {
-    return null;
-  }
-  const base = segment.dataOffset;
-
-  const info = findElement(head, ID_INFO, [], base);
-  let scale = DEFAULT_TIMESTAMP_SCALE;
-  if (info) {
-    const declared = findElement(head, ID_TIMESTAMP_SCALE, [], info.dataOffset, info.dataOffset + info.size);
-    if (declared) {
-      const value = readUint(head, declared.dataOffset, declared.size);
-      if (value > 0) {
-        scale = value;
-      }
-    }
-  }
-
-  const tracksElement = findElement(head, ID_TRACKS, [], base);
-  if (!tracksElement) {
-    return null;
-  }
-  const tracksEnd = Math.min(head.length, tracksElement.dataOffset + tracksElement.size);
-  /** @type {SubtitleTrackPlan[]} */
-  const tracks = [];
-  /**
-   * Every subtitle track the file declares, in the order the Tracks element
-   * names them, text or picture. This is not for extraction — `tracks` is —
-   * but for lining ffmpeg's `0:s:N` numbering up against the container, which
-   * only holds while nothing is missing from the middle of the list.
-   *
-   * @type {Array<{ trackNumber: number, codecId: string, language: string, name: string, isDefault: boolean, declaresDefault: boolean }>}
-   */
-  const declared = [];
-  for (const entry of iterateElements(head, tracksElement.dataOffset, tracksEnd)) {
-    if (entry.id !== ID_TRACK_ENTRY) {
-      continue;
-    }
-    const entryEnd = Math.min(tracksEnd, entry.dataOffset + entry.size);
-    let trackNumber = null;
-    let type = null;
-    let codecId = "";
-    let language = "";
-    let name = "";
-    let codecPrivate = "";
-    // Matroska's `FlagDefault` DEFAULTS TO 1, so a file whose muxer wrote it on
-    // no track is indistinguishable, once the default has been applied, from
-    // one that wrote it on every track — which is how ffmpeg's banner prints it
-    // and why the banner cannot answer this. Both are kept: what the flag
-    // amounts to, and whether the file said anything at all.
-    let isDefault = true;
-    let declaresDefault = false;
-    // Defaults straight from RFC 9559: a track is usable and not forced unless
-    // the file says otherwise, and the impaired flags are absent until claimed.
-    let isEnabled = true;
-    let isForced = false;
-    let isHearingImpaired = false;
-    let languageBcp47 = "";
-    for (const field of iterateElements(head, entry.dataOffset, entryEnd)) {
-      if (field.id === ID_TRACK_NUMBER) {
-        trackNumber = readUint(head, field.dataOffset, field.size);
-      } else if (field.id === ID_TRACK_TYPE) {
-        type = readUint(head, field.dataOffset, field.size);
-      } else if (field.id === ID_CODEC_ID) {
-        codecId = readString(head, field);
-      } else if (field.id === ID_LANGUAGE) {
-        language = readString(head, field);
-      } else if (field.id === ID_LANGUAGE_BCP47) {
-        languageBcp47 = readString(head, field);
-      } else if (field.id === ID_NAME) {
-        name = readString(head, field);
-      } else if (field.id === ID_FLAG_DEFAULT) {
-        isDefault = readUint(head, field.dataOffset, field.size) === 1;
-        declaresDefault = true;
-      } else if (field.id === ID_FLAG_ENABLED) {
-        // An element written with zero length carries its default, which for
-        // this one is 1 — so an empty element must not read as "unusable", and
-        // neither must a value outside the declared 0-1 range. Only an explicit
-        // zero takes a track away.
-        isEnabled = field.size === 0 || readUint(head, field.dataOffset, field.size) !== 0;
-      } else if (field.id === ID_FLAG_FORCED) {
-        isForced = field.size > 0 && readUint(head, field.dataOffset, field.size) !== 0;
-      } else if (field.id === ID_FLAG_HEARING_IMPAIRED) {
-        isHearingImpaired = field.size > 0 && readUint(head, field.dataOffset, field.size) !== 0;
-      } else if (field.id === ID_CODEC_PRIVATE) {
-        codecPrivate = head.toString("base64", field.dataOffset, field.dataOffset + field.size);
-      }
-    }
-    if (type !== TRACK_TYPE_SUBTITLE || trackNumber === null) {
-      continue;
-    }
-    // A track the file marks unusable is still COUNTED. FlagEnabled says "the
-    // track is usable", and a player should not offer it — but ffmpeg does not
-    // drop it: `matroskadec.c` parses `MATROSKA_ID_TRACKFLAGENABLED` as
-    // `EBML_NONE`, reading the element and keeping nothing, so the stream is
-    // created and numbered like any other. Leaving it out of this list would
-    // therefore shift `declaredIndex` off ffmpeg's `0:s:N` for every track
-    // after it, which is the numbering defect this file was fixed for a day
-    // earlier. It is counted here and refused where it is offered instead.
-    //
-    // `language` here stays the three-letter code, because this list exists to
-    // be lined up against ffmpeg's banner, which prints that code. The RFC 5646
-    // tag rides beside it for whoever displays the track.
-    declared.push({
-      trackNumber,
-      codecId,
-      language,
-      languageBcp47,
-      name,
-      isDefault,
-      declaresDefault,
-      isEnabled,
-      isForced,
-      isHearingImpaired
-    });
-    if (!TEXT_CODECS.has(codecId) || !isEnabled) {
-      continue;
-    }
-    tracks.push({
-      trackNumber,
-      declaredIndex: declared.length - 1,
-      codecId,
-      // This list is ours and is not compared with ffmpeg's, so it carries the
-      // language the file states most precisely: where RFC 5646 is written, the
-      // three-letter code MUST be ignored.
-      language: languageBcp47 || language,
-      languageBcp47,
-      name,
-      isDefault,
-      isForced,
-      isHearingImpaired,
-      codecPrivate,
-      clusterPositions: []
-    });
-  }
-  if (tracks.length === 0) {
-    return { tracks, declared, secondsPerTick: scale / 1e9, segmentDataOffset: base };
-  }
-
-  // Where the clusters holding those tracks are. A file that indexes only its
-  // picture leaves these empty, which is not a failure: the caller then reads
-  // the clusters the viewer's own playback brings in.
-  const seekHead = findElement(head, ID_SEEK_HEAD, [], base);
-  let cuesRelative;
-  if (seekHead) {
-    const seekEnd = Math.min(head.length, seekHead.dataOffset + seekHead.size);
-    for (const seek of iterateElements(head, seekHead.dataOffset, seekEnd)) {
-      if (seek.id !== ID_SEEK) {
-        continue;
-      }
-      let target = null;
-      let position = null;
-      for (const field of iterateElements(head, seek.dataOffset, Math.min(seekEnd, seek.dataOffset + seek.size))) {
-        if (field.id === ID_SEEK_ID) {
-          target = readUint(head, field.dataOffset, field.size);
-        } else if (field.id === ID_SEEK_POSITION) {
-          position = readUint(head, field.dataOffset, field.size);
-        }
-      }
-      if (target === ID_CUES && position !== null) {
-        cuesRelative = position;
-      }
-    }
-  }
-  if (cuesRelative !== undefined) {
-    const cuesAt = base + cuesRelative;
-    if (cuesAt > 0 && cuesAt < fileSize) {
-      const chunk = await readRange(cuesAt, Math.min(fileSize - 1, cuesAt + MAX_CUES_BYTES));
-      const element = chunk && [...iterateElements(chunk, 0, chunk.length)][0];
-      if (element && element.id === ID_CUES) {
-        const body = chunk.subarray(element.dataOffset, Math.min(chunk.length, element.dataOffset + element.size));
-        const byTrack = new Map(tracks.map((track) => [track.trackNumber, new Set()]));
-        for (const point of iterateElements(body, 0, body.length)) {
-          if (point.id !== ID_CUE_POINT) {
-            continue;
-          }
-          const pointEnd = Math.min(body.length, point.dataOffset + point.size);
-          for (const field of iterateElements(body, point.dataOffset, pointEnd)) {
-            if (field.id !== ID_CUE_TRACK_POSITIONS) {
-              continue;
-            }
-            let cueTrack = null;
-            let position = null;
-            for (const inner of iterateElements(body, field.dataOffset, Math.min(pointEnd, field.dataOffset + field.size))) {
-              if (inner.id === ID_CUE_TRACK) {
-                cueTrack = readUint(body, inner.dataOffset, inner.size);
-              } else if (inner.id === ID_CUE_CLUSTER_POSITION) {
-                position = readUint(body, inner.dataOffset, inner.size);
-              }
-            }
-            if (position !== null && byTrack.has(cueTrack)) {
-              byTrack.get(cueTrack).add(base + position);
-            }
-          }
-        }
-        for (const track of tracks) {
-          track.clusterPositions = [...byTrack.get(track.trackNumber)].sort((left, right) => left - right);
-        }
-      }
-    }
-  }
-  return { tracks, declared, secondsPerTick: scale / 1e9, segmentDataOffset: base };
-}
-
-/**
- * The cues of one track inside one cluster.
- *
- * @param {Buffer} bytes - The cluster, from its own element header onward.
- * @param {number} trackNumber
- * @param {number} secondsPerTick
- * @returns {{ startSeconds: number, endSeconds: number | null, text: string }[]}
- */
-export function harvestCluster(bytes, trackNumber, secondsPerTick) {
-  const header = [...iterateElements(bytes, 0, bytes.length)][0];
-  if (!header) {
-    return [];
-  }
-  const blocks = blocksOfTrack(
-    bytes,
-    { dataOffset: header.dataOffset, size: header.size },
-    trackNumber,
-    secondsPerTick
-  );
-  // The payload is handed on as BYTES. What those bytes mean — which of them
-  // are the text and which are the eight fields Matroska puts before it — is
-  // stated by the container's specification and answered by
-  // `MatroskaContainer.cueTextOf`, not here: this function's subject is where a
-  // block sits and how long it lasts.
-  return blocks.map((block) => ({
-    startSeconds: block.startSeconds,
-    endSeconds: block.durationSeconds === null ? null : block.startSeconds + block.durationSeconds,
-    payload: block.payload
-  }));
-}