@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/priority-map-download.test.js

@@ -1,174 +0,0 @@
-/**
- * @file What the download is told when the priority map changes.
- *
- * The map states seconds of film against a number. This is the one place those
- * seconds become bytes, and the one place the map's own scale — as many bands
- * as the film needs — is fitted onto the five levels the register has. Both
- * were written on 2026-09-05 to replace the windows the reads themselves used
- * to declare: fifteen reads on one file were fifteen windows on a piece store
- * holding sixteen pieces, and half of all evictions then took a piece a reader
- * had said it wanted.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { TorrentPool } from "../services/torrent/torrent-pool.js";
-import { demandFor, forgetTorrent } from "../services/torrent/download/registry.js";
-import { Urgency } from "../services/torrent/demand/index.js";
-import { mapForViewer, runsOf } from "../services/viewer/PriorityMap.js";
-
-/** A torrent that is nothing but one file of a known length. */
-function torrentOf({ length = 1_000_000, offset = 0 } = {}) {
-  return {
-    infoHash: `hash-${Math.random().toString(36).slice(2)}`,
-    pieceLength: 1024,
-    files: [{ offset, length, name: "film.mkv" }],
-    _selections: { _items: [] },
-    _select() {},
-    _deselect() {},
-    critical() {}
-  };
-}
-
-/** The pool's method under test, called without building a pool. */
-const applyPriorityMap = TorrentPool.prototype.applyPriorityMap;
-
-test("seconds of film become bytes of the file", () => {
-  const torrent = torrentOf({ length: 1000 });
-  try {
-    applyPriorityMap.call(null, torrent, 0, [
-      { from: 0, to: 100, priority: 5 },
-      { from: 100, to: 200, priority: 3 }
-    ], 200);
-
-    const { register } = demandFor(torrent);
-    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
-    assert.equal(stated.length, 2);
-    const first = stated.find((one) => one.byteStart === 0);
-    assert.equal(first.byteEnd, 499, "half the film is half the file");
-    const second = stated.find((one) => one.byteStart === 500);
-    assert.equal(second.byteEnd, 999, "the last byte of the file, not one past it");
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("a zone is stated at the level it means, not at the level of its position", () => {
-  const torrent = torrentOf();
-  try {
-    // A viewer 300 s into a 3000 s film: one band behind them that nobody is
-    // approaching, then bands of decreasing urgency ahead.
-    const zones = runsOf(mapForViewer({
-      atSeconds: 300,
-      durationSeconds: 3000,
-      allowanceSeconds: 10
-    }));
-    assert.ok(zones.length > 5, "the map should be finer than the register's levels");
-
-    applyPriorityMap.call(null, torrent, 0, zones, 3000);
-    const { register } = demandFor(torrent);
-    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
-
-    const near = stated.filter((one) => one.urgency === Urgency.NEAR);
-    assert.equal(near.length, 1, "exactly one band is where the viewer is");
-    assert.equal(near[0].byteStart, Math.floor((300 / 3000) * 1_000_000));
-
-    const behind = stated.filter((one) => one.urgency === Urgency.BEHIND);
-    assert.equal(behind.length, 1, "what nobody is approaching is the one thing wanted last");
-    assert.equal(behind[0].byteStart, 0, "and it is the stretch behind the viewer");
-
-    assert.ok(
-      stated.some((one) => one.urgency === Urgency.AHEAD),
-      "the lead being built was stated at no level of its own"
-    );
-    assert.ok(
-      stated.every((one) => one.urgency !== Urgency.BLOCKED),
-      "the map claimed BLOCKED, which only a reader stopped on those bytes may say"
-    );
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("a viewer who has stopped the picture makes the whole film wanted last", () => {
-  const torrent = torrentOf();
-  try {
-    const zones = runsOf(mapForViewer({
-      atSeconds: 300,
-      durationSeconds: 3000,
-      allowanceSeconds: 10,
-      playing: false
-    }));
-    applyPriorityMap.call(null, torrent, 0, zones, 3000);
-
-    const { register } = demandFor(torrent);
-    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
-    // A PAUSE REMOVES THE TIME, NOT THE DIRECTION. What they have watched is
-    // behind them and what they have not is in front, exactly as while they were
-    // watching; what changes is that nothing has a time any more, so every band
-    // of theirs yields to anybody who is on their way somewhere.
-    assert.ok(stated.length >= 2, "their position survives the pause");
-    for (const one of stated) {
-      assert.ok(
-        one.urgency === Urgency.BEHIND || one.urgency === Urgency.TAIL,
-        "and nothing of theirs is urgent, because nobody is coming"
-      );
-    }
-    const front = stated.filter((one) => one.urgency === Urgency.TAIL);
-    assert.ok(front.length >= 1, "the film in front of them is still in front");
-    assert.ok(
-      front[0].byteStart >= Math.floor((300 / 3000) * 1_000_000),
-      "and it begins where they stopped"
-    );
-    // Wanted last ABSOLUTELY, not relative to this film's own map. The two
-    // speculative levels are withheld across every torrent at once while
-    // anything urgent is missing anywhere, so this has to lose to a film
-    // somebody is actually watching — and judged against itself alone it would
-    // be the most urgent thing there is.
-    const behind = stated.filter((one) => one.urgency === Urgency.BEHIND);
-    assert.equal(behind.length, 1, "what they have already watched is wanted last of all");
-    assert.equal(behind[0].byteStart, 0, "and it is the stretch from the beginning to where they stopped");
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("a map with fewer bands than the last one leaves nothing stated behind", () => {
-  const torrent = torrentOf();
-  try {
-    applyPriorityMap.call(null, torrent, 0, [
-      { from: 0, to: 100, priority: 5 },
-      { from: 100, to: 200, priority: 4 },
-      { from: 200, to: 300, priority: 3 }
-    ], 300);
-    const { register } = demandFor(torrent);
-    assert.equal(
-      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
-      3
-    );
-
-    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 300, priority: 5 }], 300);
-    assert.equal(
-      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
-      1,
-      "bands the map no longer has went on being asked for"
-    );
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("a file of unknown length or duration is not guessed at", () => {
-  const torrent = torrentOf();
-  try {
-    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 100, priority: 5 }], 0);
-    applyPriorityMap.call(null, torrent, 7, [{ from: 0, to: 100, priority: 5 }], 300);
-    const { register } = demandFor(torrent);
-    assert.equal(
-      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
-      0
-    );
-  } finally {
-    forgetTorrent(torrent);
-  }
-});

package/test/priority-map-emptied.test.js

@@ -1,204 +0,0 @@
-/**
- * @file WHEN NOBODY WANTS A FILE ANY MORE, THE MAP SAYS SO.
- *
- * The map is the only statement of what is wanted, and until 2.83.4 it could
- * make only one of the two statements it exists for. A file whose viewers had
- * gone was deleted from the orchestrator's own memory and published nowhere, so
- * the bands it had stated on the swarm's behalf stood until the torrent itself
- * was removed — read from the demand register, a film nobody had watched for an
- * hour was indistinguishable from one being watched now.
- *
- * Two halves, and both are here: the side that builds the map has to say it,
- * and the side that receives it has to act on it without needing the file's
- * length, the torrent's list, or the torrent to exist at all.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { PriorityOrchestrator } from "../services/viewer/PriorityOrchestrator.js";
-import { Viewers } from "../services/viewer/Viewers.js";
-import { TorrentPool } from "../services/torrent/torrent-pool.js";
-import { demandFor, forgetTorrent } from "../services/torrent/download/registry.js";
-import { Urgency } from "../services/torrent/demand/index.js";
-
-/**
- * A session, as much of one as the orchestrator reads.
- *
- * @param {{ id: string, fileIndex?: number }} params
- * @returns {object}
- */
-function outputOf({ id, fileIndex = 0 }) {
-  return {
-    id,
-    outputKey: `out:${id}`,
-    sourceKey: "source-1",
-    fileIndex,
-    file: { key: `film-${fileIndex}`, durationSeconds: 600 }
-  };
-}
-
-/**
- * The real orchestrator, with everything it publishes kept.
- *
- * @param {object[]} sessions
- * @returns {{ priority: PriorityOrchestrator, viewers: Viewers, published: object[], publish: (sessions?: object[]) => void }}
- */
-function over(sessions) {
-  const published = [];
-  const viewers = new Viewers();
-  const priority = new PriorityOrchestrator({
-    publish: (one) => published.push(one),
-    viewers,
-    allowanceFor: () => 10
-  });
-  return {
-    priority,
-    viewers,
-    published,
-    publish: (live = sessions) =>
-      priority.publishFor({ sessionGroups: [live] })
-  };
-}
-
-test("a file whose viewers have all gone is published as wanting nothing", () => {
-  const picture = outputOf({ id: "pic" });
-  const { viewers, published, publish } = over([picture]);
-  const person = viewers.of(picture, "p");
-  person.moveTo(300);
-  publish();
-  assert.ok(published.at(-1).zones.length > 0, "somebody is watching, so something is wanted");
-
-  // They leave. The session is still there — it outlives them by half an hour —
-  // so this is the case that used to say nothing at all.
-  viewers.leaves(picture, "p");
-  publish();
-
-  const last = published.at(-1);
-  assert.deepEqual(last.zones, []);
-  assert.equal(last.sourceKey, "source-1");
-  assert.equal(last.fileIndex, 0);
-});
-
-test("a file whose session has gone is published as wanting nothing, once", () => {
-  const picture = outputOf({ id: "pic" });
-  const { viewers, published, publish } = over([picture]);
-  viewers.of(picture, "p").moveTo(300);
-  publish();
-  const said = published.length;
-
-  // The session is disposed: it is not among the live ones any more.
-  publish([]);
-  assert.deepEqual(published.at(-1).zones, []);
-  assert.equal(published.length, said + 1);
-
-  // And it is not repeated on every pass afterwards — the file is gone from
-  // this class's memory, and a departure is said once.
-  publish([]);
-  publish([]);
-  assert.equal(published.length, said + 1);
-});
-
-test("an unchanged map is still not republished", () => {
-  const picture = outputOf({ id: "pic" });
-  const { viewers, published, publish } = over([picture]);
-  viewers.of(picture, "p").moveTo(300);
-  publish();
-  const said = published.length;
-  publish();
-  publish();
-  assert.equal(published.length, said, "the downloading rebuilds its requests on every one");
-});
-
-/** A torrent that is nothing but one file of a known length. */
-function torrentOf({ length = 1_000_000 } = {}) {
-  return {
-    infoHash: `hash-${Math.random().toString(36).slice(2)}`,
-    pieceLength: 1024,
-    files: [{ offset: 0, length, name: "film.mkv" }],
-    _selections: { _items: [] },
-    _select() {},
-    _deselect() {},
-    critical() {}
-  };
-}
-
-const applyPriorityMap = TorrentPool.prototype.applyPriorityMap;
-
-/**
- * @param {object} torrent
- * @returns {object[]}
- */
-function stated(torrent) {
-  return demandFor(torrent)
-    .register.windows()
-    .filter((one) => String(one.claimant).startsWith("priority-map:"));
-}
-
-test("a map with nothing in it withdraws everything that file had stated", () => {
-  const torrent = torrentOf();
-  try {
-    applyPriorityMap.call(null, torrent, 0, [
-      { from: 0, to: 100, priority: 100 },
-      { from: 100, to: 600, priority: 50 }
-    ], 600);
-    assert.equal(stated(torrent).length, 2);
-
-    applyPriorityMap.call(null, torrent, 0, [], 600);
-    assert.equal(stated(torrent).length, 0);
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("it withdraws that file's bands and nobody else's", () => {
-  const torrent = torrentOf();
-  try {
-    const { register } = demandFor(torrent);
-    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 600, priority: 100 }], 600);
-    // A read stopped on a piece right now, which only a read can say, and the
-    // background fill, which the pool states for itself. Neither is the map's
-    // to withdraw.
-    register.state({
-      claimant: "read-7:blocked",
-      fileIndex: 0,
-      byteStart: 0,
-      byteEnd: 999,
-      urgency: Urgency.BLOCKED
-    });
-    register.state({
-      claimant: "background-fill:0",
-      fileIndex: 0,
-      byteStart: 1000,
-      byteEnd: 9999,
-      urgency: Urgency.TAIL
-    });
-
-    applyPriorityMap.call(null, torrent, 0, [], 600);
-
-    assert.equal(stated(torrent).length, 0);
-    assert.deepEqual(
-      register.windows().map((one) => one.claimant).sort(),
-      ["background-fill:0", "read-7:blocked"]
-    );
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("a departure is answered even when nothing else about the file is known", () => {
-  // The length, the duration and the torrent's own list are what the ordinary
-  // path needs to turn seconds into bytes. A departure needs none of them, and
-  // it arrives exactly when they are going away: the map that says it is
-  // published as the last viewer leaves.
-  const torrent = torrentOf();
-  try {
-    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 600, priority: 100 }], 600);
-    assert.equal(stated(torrent).length, 1);
-
-    torrent.files = [];
-    applyPriorityMap.call(null, torrent, 0, [], 0);
-    assert.equal(stated(torrent).length, 0);
-  } finally {
-    forgetTorrent(torrent);
-  }
-});

package/test/priority-map-per-output.test.js

@@ -1,215 +0,0 @@
-/**
- * @file One fact asked at two scopes: what the swarm is asked for, and what the
- * encoders are placed by.
- *
- * Both are right for what asks them. The swarm is asked for bytes of a FILE,
- * and the picture, a quality step and a soundtrack of one film read the same
- * bytes — so every viewer of any of them wants that file's bytes. Encoders are
- * placed per OUTPUT, and a person watching 480p wants nothing of the 1080p
- * output at all.
- *
- * One map for both was the second authority over encoders. Every output of a
- * film was handed the whole film's map, so the plan wanted an encoder on every
- * one of them; what actually stopped the ones nobody was watching was the
- * session manager killing them by its own judgement — and since a viewer moving
- * between steps also announces itself, the plan started them again on the next
- * pass. Field 2026-09-08.
- *
- * Built out of the real classes throughout: the real viewer registry holds real
- * viewers, the real `OutputCatalog` answers what a film's shape is, and the real
- * `PriorityOrchestrator` builds the maps. A session is a plain object in this
- * proxy — there is no class for one — so the literals below are the thing
- * itself and not a stand-in for it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { PriorityOrchestrator } from "../services/viewer/PriorityOrchestrator.js";
-import { OutputCatalog } from "../services/encode/output/OutputCatalog.js";
-import { Viewers } from "../services/viewer/Viewers.js";
-import { runsOf } from "../services/viewer/PriorityMap.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const FILM = { sourceKey: "source-1", fileIndex: 0, durationSeconds: 600 };
-const STALE_AFTER_MS = 60_000;
-
-/**
- * A session, as much of one as these classes read.
- *
- * @param {{ id: string, outputKey: string, isStep?: boolean, audioOnly?: boolean }} params
- * @returns {object}
- */
-function outputOf({ id, outputKey, isStep = false, audioOnly = false }) {
-  return {
-    id,
-    spec: outputSpec({ sourceKey: FILM.sourceKey, audioOnly }),
-    outputKey,
-    isStep,
-    audioOnly,
-    state: "ready",
-    sourceKey: FILM.sourceKey,
-    fileIndex: FILM.fileIndex,
-    file: { key: "film-1", durationSeconds: FILM.durationSeconds }
-  };
-}
-
-/**
- * The real orchestrator over the real registry, wired the way the session
- * manager wires it.
- *
- * @param {object[]} sessions
- * @returns {{ priority: PriorityOrchestrator, viewers: Viewers, publish: () => void }}
- */
-function over(sessions) {
-  const live = new OutputCatalog();
-  for (const one of sessions) {
-    live.set(one.id, one);
-    if (one.isStep) live.markStep(one);
-  }
-  const viewers = new Viewers();
-  const priority = new PriorityOrchestrator({
-    publish: () => {},
-    viewers,
-    allowanceFor: () => 10,
-    watchedBy: (session, viewer) => !live.supersededBy(session, viewer.activeVariantId ?? null)
-  });
-  return {
-    priority,
-    viewers,
-    live,
-    publish: () => priority.publishFor({ sessionGroups: [sessions], staleAfterMs: STALE_AFTER_MS })
-  };
-}
-
-test("a person on a step wants nothing of the picture they stepped off", () => {
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const step = outputOf({ id: "step", outputKey: "out:480", isStep: true });
-  const { priority, viewers, publish } = over([picture, step]);
-  // ONE viewer object per person, referenced from both outputs — which is why
-  // the step they are on is known when the picture is asked about.
-  viewers.of(picture, "p");
-  const person = viewers.of(step, "p");
-  person.moveTo(300);
-  person.activeVariantId = "step";
-  publish();
-
-  assert.ok(
-    runsOf(priority.mapForOutput("out:480")).length > 0,
-    "the step they are watching is wanted"
-  );
-  assert.deepEqual(
-    runsOf(priority.mapForOutput("out:1080")),
-    [],
-    "and the picture is producing for nobody, which is what makes its encoder unwanted"
-  );
-  // The bytes are another matter: both outputs read the same file, and the
-  // swarm is asked for the file.
-  assert.ok(
-    runsOf(priority.mapFor(FILM.sourceKey, FILM.fileIndex)).length > 0,
-    "the download still wants the film, because that is what is being watched"
-  );
-});
-
-test("a soundtrack is wanted by whoever is registered on it", () => {
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const sound = outputOf({ id: "rus", outputKey: "out:a1", audioOnly: true });
-  const { priority, viewers, publish } = over([picture, sound]);
-  // Standing on a STEP of the picture says nothing about the sound: the tracks
-  // nobody chose are let go of where a track is chosen, so being known to a
-  // soundtrack is listening to it.
-  const person = viewers.of(sound, "p");
-  person.moveTo(120);
-  person.activeVariantId = "step";
-  publish();
-
-  assert.ok(runsOf(priority.mapForOutput("out:a1")).length > 0);
-});
-
-test("a step being warmed is wanted, and so is the picture still on screen", () => {
-  // Both are genuinely being produced through a warm-up, which is the price of
-  // the switch not being visible. Whether the machine can afford two encoders
-  // is the budget's question and not this one's.
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const step = outputOf({ id: "step", outputKey: "out:480", isStep: true });
-  const { priority, viewers, publish } = over([picture, step]);
-  viewers.of(picture, "p");
-  const person = viewers.of(step, "p");
-  person.moveTo(300);
-  person.warmingVariantId = "step";
-  publish();
-
-  assert.ok(runsOf(priority.mapForOutput("out:1080")).length > 0, "still on screen");
-  assert.ok(runsOf(priority.mapForOutput("out:480")).length > 0, "being made ready");
-});
-
-test("an output everybody has left is stated as empty, not left as it was", () => {
-  // The difference matters: the plan stops the encoders of an output whose map
-  // is empty, and would keep the map it had when somebody was watching.
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const { priority, viewers, publish } = over([picture]);
-  viewers.of(picture, "p").moveTo(300);
-
-  publish();
-  assert.ok(runsOf(priority.mapForOutput("out:1080")).length > 0);
-
-  viewers.leaves(picture, "p");
-  publish();
-  assert.deepEqual(runsOf(priority.mapForOutput("out:1080")), []);
-});
-
-test("a viewer who has gone is not watching anything", () => {
-  // Presence is the connection and nothing else. Silence — however long — is a
-  // paused viewer, a throttled hidden tab, or a full cushion, and none of those
-  // is leaving; what ends it is a statement.
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const live = new OutputCatalog();
-  live.set("pic", picture);
-  const viewers = new Viewers();
-  const priority = new PriorityOrchestrator({
-    publish: () => {},
-    viewers,
-    allowanceFor: () => 10,
-    watchedBy: (session, viewer) => !live.supersededBy(session, viewer.activeVariantId ?? null)
-  });
-  const person = viewers.of(picture, "p");
-  person.moveTo(300);
-  viewers.leaves(picture, "p");
-
-  priority.publishFor({ sessionGroups: [[picture]], now: Date.now() });
-
-  assert.deepEqual(runsOf(priority.mapForOutput("out:1080")), []);
-});
-
-test("a file and an output that are gone are forgotten", () => {
-  // These are the projection of the live sessions, never a memory of them. Left
-  // to accumulate they were three maps that only grew, and `forget` was written
-  // for that and called from nowhere.
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const { priority, viewers, publish } = over([picture]);
-  viewers.of(picture, "p").moveTo(300);
-
-  publish();
-  assert.ok(runsOf(priority.mapForOutput("out:1080")).length > 0);
-
-  priority.publishFor({ sessionGroups: [[]], staleAfterMs: STALE_AFTER_MS });
-  assert.deepEqual(runsOf(priority.mapForOutput("out:1080")), [], "the output is gone");
-  assert.deepEqual(
-    runsOf(priority.mapFor(FILM.sourceKey, FILM.fileIndex)),
-    [],
-    "and so is the file"
-  );
-});
-
-test("the picture is watched by a person who never moved off it", () => {
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const { viewers, live } = over([picture]);
-  const person = viewers.of(picture, "p");
-
-  assert.equal(live.supersededBy(picture, null), false, "no step is active");
-  person.activeVariantId = "pic";
-  assert.equal(
-    live.supersededBy(picture, person.activeVariantId),
-    false,
-    "and naming the picture itself as the step is the same statement"
-  );
-});