@torrent-tv/proxy 2.87.20 → 2.88.0

package/services/torrent/download/registry.js

@@ -1,102 +1,102 @@
-/**
- * @file One demand register and one swarm selection per torrent, found from the
- * torrent itself.
- *
- * The same shape the piece store already uses — `pieceStoreOf(torrent)`
- * reaches the store without it being threaded through every call — and for the
- * same reason: the reader, the pool and the background fill all need the same
- * instance, and passing it through six layers of arguments would make the
- * argument lists bigger than the thing they carry.
- *
- * Kept in a live set as well as a weak map, because one question cannot be
- * answered per torrent: whether ANYTHING anywhere is still missing something
- * urgent. The link and the machine are shared between torrents, so a viewer
- * starving on one film must stop the speculative fetching on the other. Asked
- * per torrent, that question has the wrong answer.
- */
-
-import { DemandRegister } from "../demand/DemandRegister.js";
-import { SwarmSelection } from "./SwarmSelection.js";
-
-/** @type {WeakMap<object, { register: DemandRegister, selection: SwarmSelection }>} */
-const byTorrent = new WeakMap();
-/** @type {Set<{ register: DemandRegister, selection: SwarmSelection }>} */
-const live = new Set();
-
-/**
- * The register and selection for a torrent, made on first use.
- *
- * @param {object} torrent
- * @returns {{ register: DemandRegister, selection: SwarmSelection }}
- */
-export function demandFor(torrent) {
-  const held = byTorrent.get(torrent);
-  if (held) {
-    return held;
-  }
-  const register = new DemandRegister();
-  const entry = { register, selection: new SwarmSelection({ torrent, register }) };
-  byTorrent.set(torrent, entry);
-  live.add(entry);
-  return entry;
-}
-
-/**
- * Whether this torrent is still short of anything anybody asked for.
- *
- * Read by the upload policy: while a reader is missing bytes, a little upload
- * buys the reciprocity that gets them; once nothing declared is missing it buys
- * nothing at all, and on 2026-09-11 the proxy went on offering 512 KB/s of a
- * fully downloaded file to 596 peers for forty-eight minutes, reading a 4 MB
- * piece off the disk for every 16 KB it sent.
- *
- * False for a torrent nothing has been stated about, which is the same answer
- * and the right one: nobody is waiting for it.
- *
- * @param {object} torrent
- * @returns {boolean}
- */
-export function hasUnmetDemand(torrent) {
-  const held = byTorrent.get(torrent);
-  return held ? held.selection.hasUrgentMissing() : false;
-}
-
-/**
- * Give up everything stated for a torrent that is going.
- *
- * @param {object} torrent
- * @returns {void}
- */
-export function forgetTorrent(torrent) {
-  const held = byTorrent.get(torrent);
-  if (!held) {
-    return;
-  }
-  held.selection.releaseAll();
-  held.register.clear();
-  byTorrent.delete(torrent);
-  live.delete(held);
-}
-
-/**
- * Bring every torrent's download set into line with what is stated.
- *
- * The cross-torrent rule lives here and not in a selection, because it is not a
- * per-torrent question: two films on one proxy share the link, so filling the
- * tail of one while a viewer of the other has a still picture spends the same
- * bandwidth twice over. The answer is worked out once and given to all.
- *
- * @returns {{ torrents: number, speculativeAllowed: boolean, stated: number, withdrawn: number }}
- */
-export function reconcileAll() {
-  const entries = [...live];
-  const speculativeAllowed = !entries.some((entry) => entry.selection.hasUrgentMissing());
-  let stated = 0;
-  let withdrawn = 0;
-  for (const entry of entries) {
-    const result = entry.selection.reconcile({ speculativeAllowed });
-    stated += result.stated;
-    withdrawn += result.withdrawn;
-  }
-  return { torrents: entries.length, speculativeAllowed, stated, withdrawn };
-}
+/**
+ * @file One demand register and one swarm selection per torrent, found from the
+ * torrent itself.
+ *
+ * The same shape the piece store already uses — `pieceStoreOf(torrent)`
+ * reaches the store without it being threaded through every call — and for the
+ * same reason: the reader, the pool and the background fill all need the same
+ * instance, and passing it through six layers of arguments would make the
+ * argument lists bigger than the thing they carry.
+ *
+ * Kept in a live set as well as a weak map, because one question cannot be
+ * answered per torrent: whether ANYTHING anywhere is still missing something
+ * urgent. The link and the machine are shared between torrents, so a viewer
+ * starving on one film must stop the speculative fetching on the other. Asked
+ * per torrent, that question has the wrong answer.
+ */
+
+import { DemandRegister } from "../demand/DemandRegister.js";
+import { SwarmSelection } from "./SwarmSelection.js";
+
+/** @type {WeakMap<object, { register: DemandRegister, selection: SwarmSelection }>} */
+const byTorrent = new WeakMap();
+/** @type {Set<{ register: DemandRegister, selection: SwarmSelection }>} */
+const live = new Set();
+
+/**
+ * The register and selection for a torrent, made on first use.
+ *
+ * @param {object} torrent
+ * @returns {{ register: DemandRegister, selection: SwarmSelection }}
+ */
+export function demandFor(torrent) {
+  const held = byTorrent.get(torrent);
+  if (held) {
+    return held;
+  }
+  const register = new DemandRegister();
+  const entry = { register, selection: new SwarmSelection({ torrent, register }) };
+  byTorrent.set(torrent, entry);
+  live.add(entry);
+  return entry;
+}
+
+/**
+ * Whether this torrent is still short of anything anybody asked for.
+ *
+ * Read by the upload policy: while a reader is missing bytes, a little upload
+ * buys the reciprocity that gets them; once nothing declared is missing it buys
+ * nothing at all, and on 2026-09-11 the proxy went on offering 512 KB/s of a
+ * fully downloaded file to 596 peers for forty-eight minutes, reading a 4 MB
+ * piece off the disk for every 16 KB it sent.
+ *
+ * False for a torrent nothing has been stated about, which is the same answer
+ * and the right one: nobody is waiting for it.
+ *
+ * @param {object} torrent
+ * @returns {boolean}
+ */
+export function hasUnmetDemand(torrent) {
+  const held = byTorrent.get(torrent);
+  return held ? held.selection.hasUrgentMissing() : false;
+}
+
+/**
+ * Give up everything stated for a torrent that is going.
+ *
+ * @param {object} torrent
+ * @returns {void}
+ */
+export function forgetTorrent(torrent) {
+  const held = byTorrent.get(torrent);
+  if (!held) {
+    return;
+  }
+  held.selection.releaseAll();
+  held.register.clear();
+  byTorrent.delete(torrent);
+  live.delete(held);
+}
+
+/**
+ * Bring every torrent's download set into line with what is stated.
+ *
+ * The cross-torrent rule lives here and not in a selection, because it is not a
+ * per-torrent question: two films on one proxy share the link, so filling the
+ * tail of one while a viewer of the other has a still picture spends the same
+ * bandwidth twice over. The answer is worked out once and given to all.
+ *
+ * @returns {{ torrents: number, speculativeAllowed: boolean, stated: number, withdrawn: number }}
+ */
+export function reconcileAll() {
+  const entries = [...live];
+  const speculativeAllowed = !entries.some((entry) => entry.selection.hasUrgentMissing());
+  let stated = 0;
+  let withdrawn = 0;
+  for (const entry of entries) {
+    const result = entry.selection.reconcile({ speculativeAllowed });
+    stated += result.stated;
+    withdrawn += result.withdrawn;
+  }
+  return { torrents: entries.length, speculativeAllowed, stated, withdrawn };
+}

package/services/torrent/download/withdraw-claim.js

@@ -1,80 +1,80 @@
-/**
- * @file Withdrawing the claim that this proxy has a piece.
- *
- * **The fact has one owner and it is the store.** The store holds the bytes, so
- * it says what this proxy has. The library keeps a second copy of that fact in
- * its completion bitfield, and until 2026-09-12 nothing reconciled the two: the
- * disk tier drops a piece once every reader is past it — correctly, and that is
- * what bounds the spill — while the bitfield went on saying the piece was
- * verified. A read then concluded the piece was had, asked for it, was told it
- * was absent, and failed. Nor was it ever fetched again, because the library
- * does not download what it believes it already owns.
- *
- * Field 2026-09-12: a film played 80 seconds; the encoder ran on to 725 s, so
- * some 565 spilled pieces fell behind every read head and were dropped,
- * including piece 0; the encoder then lost its input and restarted, which
- * re-opens the input at byte 0; and `/stream` answered `0 of 2363497962 bytes:
- * Piece 0 is verified but absent from the store` to every read for the next 92
- * minutes while the browser retried one segment and the picture stood still.
- *
- * So the eviction's own bargain — "a seek back re-downloads it" — is made true
- * here, and the bitfield becomes a projection of what the store holds.
- *
- * **Why it is a plain function.** It takes the values it needs and holds
- * nothing: no pool, no store, no client. That is what lets it be exercised with
- * an object literal, and it is the rule the layers are checked against — a layer
- * must be usable with plain values alone, with no process, no disk and no clock.
- */
-
-/**
- * Tell the library it no longer has a piece, so the next read of it waits for a
- * download instead of failing.
- *
- * **What it deliberately does not do.** The library's `_markUnverified` would
- * also re-select the piece; it does not here, because every torrent is added
- * with `deselect: true`, which sets the library's own `_startAsDeselected` and
- * makes it skip that call. The download set has exactly one owner —
- * `SwarmSelection`, from the priority map — and a withdrawn piece is fetched
- * again when a read states it, which is the same statement every other piece
- * waits on.
- *
- * @param {object} what
- * @param {number} what.index - The piece the store can no longer produce.
- * @param {object[]} [what.files] - The store's own files; the torrent that owns
- *   them is found through one of them, because the store has no idea what a
- *   torrent is.
- * @param {object} [what.torrent] - Given directly instead of through `files`.
- * @param {(line: string) => void} [what.warn] - Said when the library refuses.
- * @returns {"withdrawn" | "nothing-to-withdraw" | "no-torrent" | "refused"}
- */
-export function withdrawClaim({ index, files, torrent, warn = () => undefined }) {
-  if (!Number.isInteger(index) || index < 0) {
-    return "nothing-to-withdraw";
-  }
-  const owner = torrent ?? files?.[0]?._torrent ?? null;
-  // A torrent being destroyed is the ordinary case at the end of a session, and
-  // it has no claim left to withdraw: the store is going with it.
-  if (!owner || owner.destroyed || typeof owner._markUnverified !== "function") {
-    return "no-torrent";
-  }
-  // NOTHING TO WITHDRAW, which is most of the time: the store also drops pieces
-  // it never completed, and marking one unverified that the library already
-  // knows is missing would re-create the piece and discard whatever blocks are
-  // in flight for it.
-  if (!owner.bitfield?.get?.(index)) {
-    return "nothing-to-withdraw";
-  }
-  try {
-    owner._markUnverified(index);
-  } catch (error) {
-    // This reaches into the library's own bookkeeping. If a later version
-    // changes it, the honest result is a line saying so rather than an eviction
-    // that fails.
-    warn(
-      `could not withdraw the claim on piece ${index} of ${owner.name ?? "?"}: ` +
-      `${error?.message ?? error}`
-    );
-    return "refused";
-  }
-  return "withdrawn";
-}
+/**
+ * @file Withdrawing the claim that this proxy has a piece.
+ *
+ * **The fact has one owner and it is the store.** The store holds the bytes, so
+ * it says what this proxy has. The library keeps a second copy of that fact in
+ * its completion bitfield, and until 2026-09-12 nothing reconciled the two: the
+ * disk tier drops a piece once every reader is past it — correctly, and that is
+ * what bounds the spill — while the bitfield went on saying the piece was
+ * verified. A read then concluded the piece was had, asked for it, was told it
+ * was absent, and failed. Nor was it ever fetched again, because the library
+ * does not download what it believes it already owns.
+ *
+ * Field 2026-09-12: a film played 80 seconds; the encoder ran on to 725 s, so
+ * some 565 spilled pieces fell behind every read head and were dropped,
+ * including piece 0; the encoder then lost its input and restarted, which
+ * re-opens the input at byte 0; and `/stream` answered `0 of 2363497962 bytes:
+ * Piece 0 is verified but absent from the store` to every read for the next 92
+ * minutes while the browser retried one segment and the picture stood still.
+ *
+ * So the eviction's own bargain — "a seek back re-downloads it" — is made true
+ * here, and the bitfield becomes a projection of what the store holds.
+ *
+ * **Why it is a plain function.** It takes the values it needs and holds
+ * nothing: no pool, no store, no client. That is what lets it be exercised with
+ * an object literal, and it is the rule the layers are checked against — a layer
+ * must be usable with plain values alone, with no process, no disk and no clock.
+ */
+
+/**
+ * Tell the library it no longer has a piece, so the next read of it waits for a
+ * download instead of failing.
+ *
+ * **What it deliberately does not do.** The library's `_markUnverified` would
+ * also re-select the piece; it does not here, because every torrent is added
+ * with `deselect: true`, which sets the library's own `_startAsDeselected` and
+ * makes it skip that call. The download set has exactly one owner —
+ * `SwarmSelection`, from the priority map — and a withdrawn piece is fetched
+ * again when a read states it, which is the same statement every other piece
+ * waits on.
+ *
+ * @param {object} what
+ * @param {number} what.index - The piece the store can no longer produce.
+ * @param {object[]} [what.files] - The store's own files; the torrent that owns
+ *   them is found through one of them, because the store has no idea what a
+ *   torrent is.
+ * @param {object} [what.torrent] - Given directly instead of through `files`.
+ * @param {(line: string) => void} [what.warn] - Said when the library refuses.
+ * @returns {"withdrawn" | "nothing-to-withdraw" | "no-torrent" | "refused"}
+ */
+export function withdrawClaim({ index, files, torrent, warn = () => undefined }) {
+  if (!Number.isInteger(index) || index < 0) {
+    return "nothing-to-withdraw";
+  }
+  const owner = torrent ?? files?.[0]?._torrent ?? null;
+  // A torrent being destroyed is the ordinary case at the end of a session, and
+  // it has no claim left to withdraw: the store is going with it.
+  if (!owner || owner.destroyed || typeof owner._markUnverified !== "function") {
+    return "no-torrent";
+  }
+  // NOTHING TO WITHDRAW, which is most of the time: the store also drops pieces
+  // it never completed, and marking one unverified that the library already
+  // knows is missing would re-create the piece and discard whatever blocks are
+  // in flight for it.
+  if (!owner.bitfield?.get?.(index)) {
+    return "nothing-to-withdraw";
+  }
+  try {
+    owner._markUnverified(index);
+  } catch (error) {
+    // This reaches into the library's own bookkeeping. If a later version
+    // changes it, the honest result is a line saying so rather than an eviction
+    // that fails.
+    warn(
+      `could not withdraw the claim on piece ${index} of ${owner.name ?? "?"}: ` +
+      `${error?.message ?? error}`
+    );
+    return "refused";
+  }
+  return "withdrawn";
+}

package/services/torrent/episode-naming.js

@@ -0,0 +1,182 @@
+/**
+ * @file What a picture's NAME says about which episode it is.
+ *
+ * A season pack states its structure in names — `s01e02_Murder.in.the.Mews.avi`,
+ * `Reacher.S04E01.1080p.rus.LostFilm.TV.mkv`, `[HorribleSubs] Drifters - 01
+ * [1080p].mkv` under a folder, or an episode number under `Season_01/`. This
+ * reads that statement and nothing else: which season, which episode numbers,
+ * which part of an episode, whether it is a special, and the text on either
+ * side of the marker.
+ *
+ * The numbers are the RELEASE's numbering. They are often the same as a
+ * metadata provider's and sometimes not — one release numbers the two parts of
+ * a feature-length episode as two episodes, which shifts every number after
+ * them — so nothing here claims to know which episode of the show a file is.
+ * That is decided later, against the provider's own list, by whoever holds it.
+ *
+ * A name without a marker returns `null`: absence of a number is absence of
+ * information, not evidence that the file is not an episode.
+ */
+
+import { stripExtension } from "./naming.js";
+
+/** Most episodes one file may claim before the claim is read as noise. */
+const MAX_EPISODES_PER_FILE = 8;
+
+/** Longest hint returned, in characters; a name longer than this is not a title. */
+const MAX_HINT_LENGTH = 160;
+
+/** `S01E02`, `s03.e01`, `S01E01E02`, `S01E01-E02`, `S01E01-02`. */
+const SEASON_EPISODE = /(?<![a-z0-9])s(\d{1,3})[ ._]?e(\d{1,4})((?:-?e\d{1,4}|-\d{1,4})*)(?![0-9])/i;
+
+/** `1x02`; four-digit sides are picture sizes (`1920x1080`) and never match. */
+const CROSS = /(?<![a-z0-9])(\d{1,2})x(\d{2,3})(?![0-9a-z])/i;
+
+/** `E05`, `Ep 5`, `Episode.05`, `Серия 5` — an episode number with no season in it. */
+const EPISODE_ONLY = /(?<![\p{L}0-9])(?:e|ep|episode|серия)[ ._-]?(\d{1,4})(?![0-9])/iu;
+
+/** `Show - 01`, `Show - 01v2` — the numbering most anime releases use. */
+const DASH_NUMBER = / - (\d{1,4})(?:v\d)?(?=[ .[(]|$)/;
+
+/** A folder that names a season: `Season_01`, `Season 1`, `S01`, `Сезон 1`, `1 сезон`. */
+const SEASON_FOLDER = /^(?:season|сезон|s)[ ._-]*(\d{1,3})$|^(\d{1,3})[ ._-]*(?:season|сезон)$/iu;
+
+/** `Part.1`, `Pt 2`, `Часть 1`. */
+const PART = /(?<![\p{L}0-9])(?:part|pt|часть)[ ._-]?(\d{1,2})(?![0-9])/iu;
+
+/** `Special`, `Specials`, `SP01`. */
+const SPECIAL = /(?<![\p{L}])(?:specials?|sp\d{1,3})(?![\p{L}])/iu;
+
+/** Separators a release puts between words, trimmed off the ends of a hint. */
+const EDGE_SEPARATORS = /^[\s._\-–—]+|[\s._\-–—]+$/g;
+
+/**
+ * An episode marker read from a name.
+ *
+ * @typedef {object} EpisodeMarker
+ * @property {number | null} season - `null` when neither the name nor a folder states one.
+ * @property {number[]} episodes - The release's numbers, one or more.
+ * @property {number | null} part - Which part of one episode, when the name says so.
+ * @property {boolean} special - Season 0, or a name calling itself a special.
+ * @property {string} showHint - The name's text before the marker, as written.
+ * @property {string} titleHint - The name's text after the marker, part removed, as written.
+ */
+
+/**
+ * Trim a piece of a name to a hint.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function hint(text) {
+  return String(text ?? "").replace(EDGE_SEPARATORS, "").slice(0, MAX_HINT_LENGTH);
+}
+
+/**
+ * The numbers after the first episode in `S01E01E02` or `S01E01-03`.
+ *
+ * A `-` joins a range, a repeated `E` lists another episode.
+ *
+ * @param {number} first
+ * @param {string} rest
+ * @returns {number[] | null} `null` when the claim is longer than any file carries.
+ */
+function episodesFrom(first, rest) {
+  const episodes = [first];
+  for (const token of rest.match(/-?e?\d+/gi) ?? []) {
+    const value = Number(token.replace(/[^0-9]/g, ""));
+    const last = episodes[episodes.length - 1];
+    if (token.startsWith("-") && value > last) {
+      for (let next = last + 1; next <= value; next += 1) {
+        episodes.push(next);
+        if (episodes.length > MAX_EPISODES_PER_FILE) {
+          return null;
+        }
+      }
+    } else if (value !== last) {
+      episodes.push(value);
+    }
+  }
+  return episodes.length > MAX_EPISODES_PER_FILE ? null : episodes;
+}
+
+/**
+ * The season the deepest season-naming folder states, if any does.
+ *
+ * @param {string[]} folders
+ * @returns {number | null}
+ */
+function seasonFromFolders(folders) {
+  for (let index = folders.length - 1; index >= 0; index -= 1) {
+    const match = SEASON_FOLDER.exec(String(folders[index] ?? "").trim());
+    if (match) {
+      return Number(match[1] ?? match[2]);
+    }
+  }
+  return null;
+}
+
+/**
+ * Which episode a picture's name says it is.
+ *
+ * @param {{ name: string, folders?: string[] }} file - File name and the folders above it.
+ * @returns {EpisodeMarker | null}
+ */
+export function readEpisodeMarker({ name, folders = [] }) {
+  const stem = stripExtension(String(name ?? ""));
+  const folderSeason = seasonFromFolders(Array.isArray(folders) ? folders : []);
+
+  let season = null;
+  let episodes = null;
+  let before = "";
+  let after = "";
+
+  const seasonEpisode = SEASON_EPISODE.exec(stem);
+  const cross = seasonEpisode ? null : CROSS.exec(stem);
+  const episodeOnly = seasonEpisode || cross ? null : EPISODE_ONLY.exec(stem);
+  const dash = seasonEpisode || cross || episodeOnly ? null : DASH_NUMBER.exec(stem);
+  const match = seasonEpisode ?? cross ?? episodeOnly ?? dash;
+  if (!match) {
+    return null;
+  }
+  before = stem.slice(0, match.index);
+  after = stem.slice(match.index + match[0].length);
+
+  if (seasonEpisode) {
+    season = Number(seasonEpisode[1]);
+    episodes = episodesFrom(Number(seasonEpisode[2]), seasonEpisode[3] ?? "");
+  } else if (cross) {
+    season = Number(cross[1]);
+    episodes = [Number(cross[2])];
+  } else {
+    // `Show S1 - 01` states its season just before the number; a folder is the
+    // other place a release puts it.
+    const trailingSeason = /(?<![a-z0-9])s(\d{1,3})[\s._-]*$/i.exec(before);
+    season = trailingSeason ? Number(trailingSeason[1]) : folderSeason;
+    if (trailingSeason) {
+      before = before.slice(0, trailingSeason.index);
+    }
+    episodes = [Number(match[1])];
+  }
+  // A year where an episode number would be is a year far more often than an
+  // episode: `Film - 2024 [1080p]`, and `WALL-E.2008.mkv` reads as `E` then
+  // `2008`. Only the markers without a season can be fooled this way.
+  if ((dash || episodeOnly) && /^(?:19|20)\d\d$/.test(match[1])) {
+    return null;
+  }
+  if (!episodes) {
+    return null;
+  }
+
+  const part = PART.exec(after);
+  const titleText = part ? `${after.slice(0, part.index)} ${after.slice(part.index + part[0].length)}` : after;
+
+  return {
+    season,
+    episodes,
+    part: part ? Number(part[1]) : null,
+    special: season === 0 || SPECIAL.test(stem),
+    showHint: hint(before),
+    titleHint: hint(titleText)
+  };
+}