@torrent-tv/proxy 2.89.6 → 2.89.7

package/test/subtitle-cursor.test.js

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

package/test/subtitle-defaults.test.js

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