@torrent-tv/proxy 2.87.9 → 2.87.11

package/test/playback-readiness.test.js

@@ -0,0 +1,323 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { predictPlaybackReadiness, RateTrend, forecastRate } from "../services/server/playback-readiness.js";
+
+function input(overrides = {}) {
+  const now = 10_000;
+  return {
+    now,
+    positionSeconds: 0,
+    durationSeconds: 8,
+    bufferedAheadSeconds: 0,
+    bufferLimitSeconds: 8,
+    reserveSeconds: 4,
+    lookaheadSeconds: 8,
+    sources: [{ id: "source", complete: true, bytesPerMediaSecond: 1, readings: [] }],
+    tracks: [{
+      id: "video",
+      sourceIds: ["source"],
+      processedSeconds: 4,
+      bitsPerMediaSecond: 80,
+      readings: [{ at: now - 1_000, value: 2 }, { at: now, value: 2 }],
+      segments: [
+        { index: 0, startSeconds: 0, endSeconds: 4 },
+        { index: 1, startSeconds: 4, endSeconds: 8 }
+      ],
+      readySegmentIndices: [0],
+      segmentSizesBytes: new Map([[0, 40]])
+    }],
+    linkReadings: [{ at: now - 1_000, value: 320 }, { at: now, value: 320 }],
+    ...overrides
+  };
+}
+
+test("finds the first safe start from segments delivered before playback", () => {
+  const forecast = predictPlaybackReadiness(input());
+
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Math.abs(forecast.delaySeconds - 3) < 1e-8);
+});
+
+test("overlaps source reads and encoding, then waits for the slower stage and delivery", () => {
+  const source = {
+    id: "source",
+    complete: false,
+    bytesPerMediaSecond: 1,
+    readings: [{ at: 9_000, value: 2 }, { at: 10_000, value: 2 }]
+  };
+  const track = {
+    ...input().tracks[0],
+    readings: [{ at: 9_000, value: 10 }, { at: 10_000, value: 10 }]
+  };
+  const forecast = predictPlaybackReadiness(input({ sources: [source], tracks: [track] }));
+
+  assert.equal(forecast.ready, false);
+  assert.ok(Math.abs(forecast.delaySeconds - 3) < 1e-8);
+});
+
+test("does not produce an ETA without a client-link measurement", () => {
+  const forecast = predictPlaybackReadiness(input({ linkReadings: [] }));
+
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.delaySeconds, null);
+  assert.equal(forecast.reason, "link-rate-unavailable");
+});
+
+test("rate trend projects the measured linear trend without a fitted weight", () => {
+  const trend = new RateTrend();
+  trend.add(9_000, 2);
+  trend.add(10_000, 4);
+
+  assert.equal(forecastRate(trend.snapshot(), 10_000, 2), 6);
+});
+
+test("uses each track's own segment boundaries and requires continuous coverage on both tracks", () => {
+  const common = input();
+  const video = common.tracks[0];
+  const audio = {
+    id: "audio",
+    sourceIds: ["source"],
+    processedSeconds: 2,
+    bitsPerMediaSecond: 80,
+    readings: [{ at: 9_000, value: 2 }, { at: 10_000, value: 2 }],
+    segments: [
+      { index: 7, startSeconds: 0, endSeconds: 2 },
+      { index: 8, startSeconds: 2, endSeconds: 4 },
+      { index: 9, startSeconds: 4, endSeconds: 8 }
+    ],
+    readySegmentIndices: [7],
+    segmentSizesBytes: new Map([[7, 20], [8, 20], [9, 40]])
+  };
+  video.segmentSizesBytes.set(1, 40);
+  const forecast = predictPlaybackReadiness({
+    ...common,
+    requiredAudio: true,
+    tracks: [video, audio]
+  });
+
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(forecast.delaySeconds > 0);
+  assert.equal(forecast.preparedSegments, 2);
+});
+
+test("does not start when only one required track has continuous coverage", () => {
+  const common = input();
+  const audio = {
+    id: "audio",
+    sourceIds: ["source"],
+    processedSeconds: 0,
+    bitsPerMediaSecond: 80,
+    readings: [{ at: 9_000, value: 2 }, { at: 10_000, value: 2 }],
+    segments: [
+      { index: 4, startSeconds: 0, endSeconds: 2 },
+      { index: 5, startSeconds: 3, endSeconds: 8 }
+    ],
+    readySegmentIndices: [4, 5],
+    segmentSizesBytes: new Map([[4, 20], [5, 50]])
+  };
+  const forecast = predictPlaybackReadiness({
+    ...common,
+    requiredAudio: true,
+    tracks: [common.tracks[0], audio]
+  });
+
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.delaySeconds, null);
+  assert.equal(forecast.reason, "no-safe-start-found");
+});
+
+test("downloads an overlapping source interval once when two tracks use the same file", () => {
+  const now = 10_000;
+  const readings = [{ at: now - 1_000, value: 10 }, { at: now, value: 10 }];
+  const tracks = [
+    {
+      id: "video",
+      sourceIds: ["shared"],
+      processedSeconds: 2,
+      bitsPerMediaSecond: 80,
+      readings,
+      segments: [
+        { index: 0, startSeconds: 0, endSeconds: 2 },
+        { index: 1, startSeconds: 2, endSeconds: 4 }
+      ],
+      readySegmentIndices: [0],
+      segmentSizesBytes: new Map([[0, 20], [1, 20]])
+    },
+    {
+      id: "audio",
+      sourceIds: ["shared"],
+      processedSeconds: 0,
+      bitsPerMediaSecond: 80,
+      readings,
+      segments: [{ index: 11, startSeconds: 0, endSeconds: 4 }],
+      readySegmentIndices: [],
+      segmentSizesBytes: new Map([[11, 40]])
+    }
+  ];
+  const forecast = predictPlaybackReadiness({
+    now,
+    positionSeconds: 0,
+    durationSeconds: 4,
+    bufferedAheadSeconds: 0,
+    bufferLimitSeconds: 4,
+    reserveSeconds: 4,
+    lookaheadSeconds: 4,
+    requiredAudio: true,
+    sources: [{
+      id: "shared",
+      complete: false,
+      bytesPerMediaSecond: 1,
+      readings: [{ at: now - 1_000, value: 2 }, { at: now, value: 2 }]
+    }],
+    tracks,
+    linkReadings: [{ at: now - 1_000, value: 10_000 }, { at: now, value: 10_000 }]
+  });
+
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Math.abs(forecast.delaySeconds - 2.048) < 1e-8);
+});
+
+test("downloads sources on separate torrents concurrently", () => {
+  const now = 10_000;
+  const readings = [{ at: now - 1_000, value: 10 }, { at: now, value: 10 }];
+  const tracks = [
+    {
+      id: "video",
+      sourceIds: ["video-source"],
+      processedSeconds: 0,
+      bitsPerMediaSecond: 80,
+      readings,
+      segments: [{ index: 0, startSeconds: 0, endSeconds: 4 }],
+      readySegmentIndices: [],
+      segmentSizesBytes: new Map([[0, 40]])
+    },
+    {
+      id: "audio",
+      sourceIds: ["audio-source"],
+      processedSeconds: 0,
+      bitsPerMediaSecond: 80,
+      readings,
+      segments: [{ index: 7, startSeconds: 0, endSeconds: 4 }],
+      readySegmentIndices: [],
+      segmentSizesBytes: new Map([[7, 40]])
+    }
+  ];
+  const sourceReadings = [{ at: now - 1_000, value: 2 }, { at: now, value: 2 }];
+  const forecast = predictPlaybackReadiness({
+    now,
+    positionSeconds: 0,
+    durationSeconds: 4,
+    bufferedAheadSeconds: 0,
+    bufferLimitSeconds: 4,
+    reserveSeconds: 4,
+    lookaheadSeconds: 4,
+    requiredAudio: true,
+    sources: [
+      { id: "video-source", complete: false, bytesPerMediaSecond: 1, readings: sourceReadings },
+      { id: "audio-source", complete: false, bytesPerMediaSecond: 1, readings: sourceReadings }
+    ],
+    tracks,
+    linkReadings: [{ at: now - 1_000, value: 10_000 }, { at: now, value: 10_000 }]
+  });
+
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Math.abs(forecast.delaySeconds - 2.064) < 1e-8);
+});
+
+test("shares one torrent download rate across distinct video and audio files", () => {
+  const now = 10_000;
+  const readings = [{ at: now - 1_000, value: 10 }, { at: now, value: 10 }];
+  const sourceReadings = [{ at: now - 1_000, value: 2 }, { at: now, value: 2 }];
+  const tracks = [
+    {
+      id: "video",
+      sourceIds: ["torrent:video-file"],
+      processedSeconds: 0,
+      bitsPerMediaSecond: 80,
+      readings,
+      segments: [{ index: 0, startSeconds: 0, endSeconds: 4 }],
+      readySegmentIndices: [],
+      segmentSizesBytes: new Map([[0, 40]])
+    },
+    {
+      id: "audio",
+      sourceIds: ["torrent:audio-file"],
+      processedSeconds: 0,
+      bitsPerMediaSecond: 80,
+      readings,
+      segments: [{ index: 7, startSeconds: 0, endSeconds: 4 }],
+      readySegmentIndices: [],
+      segmentSizesBytes: new Map([[7, 40]])
+    }
+  ];
+  const forecast = predictPlaybackReadiness({
+    now,
+    positionSeconds: 0,
+    durationSeconds: 4,
+    bufferedAheadSeconds: 0,
+    bufferLimitSeconds: 4,
+    reserveSeconds: 4,
+    lookaheadSeconds: 4,
+    requiredAudio: true,
+    sources: [
+      {
+        id: "torrent:video-file",
+        serviceId: "torrent",
+        complete: false,
+        bytesPerMediaSecond: 1,
+        readings: sourceReadings
+      },
+      {
+        id: "torrent:audio-file",
+        serviceId: "torrent",
+        complete: false,
+        bytesPerMediaSecond: 1,
+        readings: sourceReadings
+      }
+    ],
+    tracks,
+    linkReadings: [{ at: now - 1_000, value: 10_000 }, { at: now, value: 10_000 }]
+  });
+
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Math.abs(forecast.delaySeconds - 4.032) < 1e-8);
+});
+
+test("finds a safe interval when rising encode speed and falling link speed make the forecast non-monotonic", () => {
+  const now = 1_000;
+  const forecast = predictPlaybackReadiness({
+    now,
+    positionSeconds: 0,
+    durationSeconds: 8,
+    bufferedAheadSeconds: 4,
+    bufferLimitSeconds: 8,
+    reserveSeconds: 1,
+    lookaheadSeconds: 4,
+    sources: [{ id: "source", complete: true, bytesPerMediaSecond: 1, readings: [] }],
+    tracks: [{
+      id: "video",
+      sourceIds: ["source"],
+      processedSeconds: 4,
+      bitsPerMediaSecond: 2,
+      readings: [{ at: 0, value: 0.1 }, { at: now, value: 0.15 }],
+      segments: [
+        { index: 0, startSeconds: 0, endSeconds: 4 },
+        { index: 1, startSeconds: 4, endSeconds: 6 },
+        { index: 2, startSeconds: 6, endSeconds: 8 }
+      ],
+      readySegmentIndices: [0],
+      segmentSizesBytes: new Map([[0, 1], [1, 1], [2, 1]])
+    }],
+    linkReadings: [{ at: 0, value: 105.3 }, { at: now, value: 100 }]
+  });
+
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Number.isFinite(forecast.delaySeconds));
+  assert.ok(forecast.delaySeconds > 7 && forecast.delaySeconds < 10);
+});

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

@@ -1,174 +1,174 @@
-/**
- * @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);
-  }
-});
+/**
+ * @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);
+  }
+});