@torrent-tv/proxy 2.80.18 → 2.81.0

package/test/video-facts.test.js

@@ -1,102 +1,102 @@
-/**
- * @file The picture's facts, from the two readings that state them.
- *
- * Audio and subtitles have had this reconciliation since their flags were first
- * read from the file. Video never did: every figure the encode is planned from
- * came from ffmpeg's `-i` banner alone, and the `VideoTrack` the container
- * declares was read and then used for nothing but a line in the log — so a file
- * that states its bit depth or its HDR signalling, against a probe that does
- * not print them, disagreed with nobody watching.
- *
- * What each check pins is WHICH reading answers, and why: the size and the
- * frame rate are what the decoder will produce, so the probe answers; the bit
- * depth and the HDR signalling are the file saying how its samples are to be
- * read, so the container answers.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { Container } from "../services/container/Container.js";
-
-const banner = (fields) => ({ width: null, height: null, fps: null, isHdr: false, bitDepth: null, ...fields });
-
-test("with no container reading the probe answers for everything", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1920, height: 1080, fps: 23.976, isHdr: true, bitDepth: 10 }),
-    null
-  );
-  assert.equal(facts.width, 1920);
-  assert.equal(facts.height, 1080);
-  assert.equal(facts.fps, 23.976);
-  assert.equal(facts.isHdr, true);
-  assert.equal(facts.bitDepth, 10);
-  assert.deepEqual(facts.disagreements, []);
-});
-
-test("the size and the frame rate are the probe's, because that is what will be decoded", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1920, height: 1080, fps: 24 }),
-    { width: 1440, height: 1080, fps: 25, displayWidth: 1920, displayHeight: 1080 }
-  );
-  assert.equal(facts.width, 1920, "the ladder and the scale filter are sized to the decoded frame");
-  assert.equal(facts.height, 1080);
-  assert.equal(facts.fps, 24);
-});
-
-test("the bit depth and the HDR signalling are the file's, because the file states them", () => {
-  // A ten-bit HEVC whose probe printed neither: this is the case that decides
-  // whether tone mapping runs and how the decode cost is priced.
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 3840, height: 2160, fps: 24 }),
-    { width: 3840, height: 2160, bitDepth: 10, isHdr: true }
-  );
-  assert.equal(facts.bitDepth, 10);
-  assert.equal(facts.isHdr, true);
-  assert.deepEqual(facts.disagreements, [], "one side saying nothing is not a disagreement");
-});
-
-test("a field only the probe states is still answered", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1280, height: 720, fps: 30, bitDepth: 8 }),
-    { width: null, height: null, fps: null, bitDepth: null }
-  );
-  assert.equal(facts.width, 1280);
-  assert.equal(facts.bitDepth, 8);
-});
-
-test("a real disagreement is reported, with both values and which is which", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1920, height: 1080, bitDepth: 8, isHdr: false }),
-    { width: 1280, height: 720, bitDepth: 10, isHdr: true }
-  );
-  assert.equal(facts.disagreements.length, 3);
-  assert.ok(facts.disagreements.some((line) => /width 1280 in the container against 1920 in the probe/.test(line)));
-  assert.ok(facts.disagreements.some((line) => /bit depth 10 in the container against 8 in the probe/.test(line)));
-  // HDR is not among them, and cannot be: see `mergeVideoFacts`.
-  assert.ok(!facts.disagreements.some((line) => /HDR/.test(line)));
-  // And the rule still decides: the probe for the size, the file for the rest.
-  assert.equal(facts.width, 1920);
-  assert.equal(facts.bitDepth, 10);
-  assert.equal(facts.isHdr, true);
-});
-
-test("the display size is the container's alone — the probe has no such field", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1440, height: 1080 }),
-    { width: 1440, height: 1080, displayWidth: 1920, displayHeight: 1080 }
-  );
-  assert.equal(facts.displayWidth, 1920);
-  assert.equal(facts.displayHeight, 1080);
-});
-
-test("zero and nonsense are not values", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 0, height: 0, fps: 0, bitDepth: 0 }),
-    { width: 1920, height: 1080, fps: 24, bitDepth: 8 }
-  );
-  assert.equal(facts.width, 1920, "a probe that printed nothing does not outrank a file that speaks");
-  assert.equal(facts.fps, 24);
-  assert.equal(facts.bitDepth, 8);
-  assert.deepEqual(facts.disagreements, []);
-});
+/**
+ * @file The picture's facts, from the two readings that state them.
+ *
+ * Audio and subtitles have had this reconciliation since their flags were first
+ * read from the file. Video never did: every figure the encode is planned from
+ * came from ffmpeg's `-i` banner alone, and the `VideoTrack` the container
+ * declares was read and then used for nothing but a line in the log — so a file
+ * that states its bit depth or its HDR signalling, against a probe that does
+ * not print them, disagreed with nobody watching.
+ *
+ * What each check pins is WHICH reading answers, and why: the size and the
+ * frame rate are what the decoder will produce, so the probe answers; the bit
+ * depth and the HDR signalling are the file saying how its samples are to be
+ * read, so the container answers.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { Container } from "../services/container/Container.js";
+
+const banner = (fields) => ({ width: null, height: null, fps: null, isHdr: false, bitDepth: null, ...fields });
+
+test("with no container reading the probe answers for everything", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1920, height: 1080, fps: 23.976, isHdr: true, bitDepth: 10 }),
+    null
+  );
+  assert.equal(facts.width, 1920);
+  assert.equal(facts.height, 1080);
+  assert.equal(facts.fps, 23.976);
+  assert.equal(facts.isHdr, true);
+  assert.equal(facts.bitDepth, 10);
+  assert.deepEqual(facts.disagreements, []);
+});
+
+test("the size and the frame rate are the probe's, because that is what will be decoded", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1920, height: 1080, fps: 24 }),
+    { width: 1440, height: 1080, fps: 25, displayWidth: 1920, displayHeight: 1080 }
+  );
+  assert.equal(facts.width, 1920, "the ladder and the scale filter are sized to the decoded frame");
+  assert.equal(facts.height, 1080);
+  assert.equal(facts.fps, 24);
+});
+
+test("the bit depth and the HDR signalling are the file's, because the file states them", () => {
+  // A ten-bit HEVC whose probe printed neither: this is the case that decides
+  // whether tone mapping runs and how the decode cost is priced.
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 3840, height: 2160, fps: 24 }),
+    { width: 3840, height: 2160, bitDepth: 10, isHdr: true }
+  );
+  assert.equal(facts.bitDepth, 10);
+  assert.equal(facts.isHdr, true);
+  assert.deepEqual(facts.disagreements, [], "one side saying nothing is not a disagreement");
+});
+
+test("a field only the probe states is still answered", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1280, height: 720, fps: 30, bitDepth: 8 }),
+    { width: null, height: null, fps: null, bitDepth: null }
+  );
+  assert.equal(facts.width, 1280);
+  assert.equal(facts.bitDepth, 8);
+});
+
+test("a real disagreement is reported, with both values and which is which", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1920, height: 1080, bitDepth: 8, isHdr: false }),
+    { width: 1280, height: 720, bitDepth: 10, isHdr: true }
+  );
+  assert.equal(facts.disagreements.length, 3);
+  assert.ok(facts.disagreements.some((line) => /width 1280 in the container against 1920 in the probe/.test(line)));
+  assert.ok(facts.disagreements.some((line) => /bit depth 10 in the container against 8 in the probe/.test(line)));
+  // HDR is not among them, and cannot be: see `mergeVideoFacts`.
+  assert.ok(!facts.disagreements.some((line) => /HDR/.test(line)));
+  // And the rule still decides: the probe for the size, the file for the rest.
+  assert.equal(facts.width, 1920);
+  assert.equal(facts.bitDepth, 10);
+  assert.equal(facts.isHdr, true);
+});
+
+test("the display size is the container's alone — the probe has no such field", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1440, height: 1080 }),
+    { width: 1440, height: 1080, displayWidth: 1920, displayHeight: 1080 }
+  );
+  assert.equal(facts.displayWidth, 1920);
+  assert.equal(facts.displayHeight, 1080);
+});
+
+test("zero and nonsense are not values", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 0, height: 0, fps: 0, bitDepth: 0 }),
+    { width: 1920, height: 1080, fps: 24, bitDepth: 8 }
+  );
+  assert.equal(facts.width, 1920, "a probe that printed nothing does not outrank a file that speaks");
+  assert.equal(facts.fps, 24);
+  assert.equal(facts.bitDepth, 8);
+  assert.deepEqual(facts.disagreements, []);
+});

package/test/wedge-certainty.test.js

@@ -1,131 +1,131 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { wedgeIsCertain } from "../services/data-channel-handler.js";
-import { PROBE_INTERVAL_MS } from "../services/delivery-probe.js";
-
-const MEGABYTE = 1024 * 1024;
-
-test("a queue draining at the rate this link was measured at is not a wedge", () => {
-  // 8 MB at 16 MB/s is half a second of draining. Half a second in is normal.
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: 200
-  });
-  assert.equal(verdict.certain, false);
-});
-
-test("the counter standing still past the queue's own drain time is a wedge", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: 4000
-  });
-  assert.equal(verdict.certain, true);
-  assert.equal(verdict.needMs, 500);
-});
-
-test("a big queue on a slow link is given the time it genuinely needs", () => {
-  // 67 MB at 1 MB/s is 67 seconds of honest draining — the field's own numbers
-  // for the wedged channel, at a rate a thin link could really be running at.
-  const patient = wedgeIsCertain({
-    queuedBytes: 67 * MEGABYTE,
-    bytesPerSecond: MEGABYTE,
-    flatForMs: 30_000
-  });
-  assert.equal(patient.certain, false);
-  const later = wedgeIsCertain({
-    queuedBytes: 67 * MEGABYTE,
-    bytesPerSecond: MEGABYTE,
-    flatForMs: 70_000
-  });
-  assert.equal(later.certain, true);
-});
-
-test("the same queue on the link the field actually had is called quickly", () => {
-  // 67 MB at 18 MB/s is under four seconds. The field episode stood still for
-  // 3217 s; the previous rule waited a flat 30 s before recording anything.
-  const verdict = wedgeIsCertain({
-    queuedBytes: 67 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 5000
-  });
-  assert.equal(verdict.certain, true);
-  assert.ok(verdict.needMs < 30_000);
-});
-
-test("a tiny queue still waits for one round of probes", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 512,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: PROBE_INTERVAL_MS - 1
-  });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
-});
-
-test("nothing queued is still a wedge when the counter has been flat long enough — the channel queue was 0 on the real wedge while usrsctp held 399 MB", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 0,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: 600_000
-  });
-  assert.equal(verdict.certain, true);
-  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
-});
-
-test("with no rate measured the answer is that nothing can be said", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 0,
-    flatForMs: 600_000
-  });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, null);
-});
-
-test("a pause no longer than this link's own longest healthy pause is not a wedge", () => {
-  // A retransmission timeout stops the accepted-byte counter dead: a full send
-  // buffer accepts nothing. If this connection has already paused 3 s while
-  // healthy, a 3 s pause says nothing.
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 2500,
-    longestHealthyFlatMs: 3000
-  });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, 3000);
-});
-
-test("a pause longer than any this link has shown is a wedge", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 3500,
-    longestHealthyFlatMs: 3000
-  });
-  assert.equal(verdict.certain, true);
-});
-
-test("the quiet-probe rate cannot be what the queue is divided by", () => {
-  // With the browser's buffer full, the only traffic is the probe: three
-  // channels, a few dozen bytes, twice a second. Dividing 8 MB by that gives
-  // six hours, and the wedge would never be called. The BEST rate seen is what
-  // the watcher keeps, so this case must not arise — pinned here as the
-  // arithmetic that made it matter.
-  const wrong = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 360,
-    flatForMs: 60_000
-  });
-  assert.equal(wrong.certain, false);
-  assert.ok(wrong.needMs > 6 * 60 * 60 * 1000 - 1);
-  const right = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 60_000
-  });
-  assert.equal(right.certain, true);
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { wedgeIsCertain } from "../services/data-channel-handler.js";
+import { PROBE_INTERVAL_MS } from "../services/delivery-probe.js";
+
+const MEGABYTE = 1024 * 1024;
+
+test("a queue draining at the rate this link was measured at is not a wedge", () => {
+  // 8 MB at 16 MB/s is half a second of draining. Half a second in is normal.
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 16 * MEGABYTE,
+    flatForMs: 200
+  });
+  assert.equal(verdict.certain, false);
+});
+
+test("the counter standing still past the queue's own drain time is a wedge", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 16 * MEGABYTE,
+    flatForMs: 4000
+  });
+  assert.equal(verdict.certain, true);
+  assert.equal(verdict.needMs, 500);
+});
+
+test("a big queue on a slow link is given the time it genuinely needs", () => {
+  // 67 MB at 1 MB/s is 67 seconds of honest draining — the field's own numbers
+  // for the wedged channel, at a rate a thin link could really be running at.
+  const patient = wedgeIsCertain({
+    queuedBytes: 67 * MEGABYTE,
+    bytesPerSecond: MEGABYTE,
+    flatForMs: 30_000
+  });
+  assert.equal(patient.certain, false);
+  const later = wedgeIsCertain({
+    queuedBytes: 67 * MEGABYTE,
+    bytesPerSecond: MEGABYTE,
+    flatForMs: 70_000
+  });
+  assert.equal(later.certain, true);
+});
+
+test("the same queue on the link the field actually had is called quickly", () => {
+  // 67 MB at 18 MB/s is under four seconds. The field episode stood still for
+  // 3217 s; the previous rule waited a flat 30 s before recording anything.
+  const verdict = wedgeIsCertain({
+    queuedBytes: 67 * MEGABYTE,
+    bytesPerSecond: 18 * MEGABYTE,
+    flatForMs: 5000
+  });
+  assert.equal(verdict.certain, true);
+  assert.ok(verdict.needMs < 30_000);
+});
+
+test("a tiny queue still waits for one round of probes", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 512,
+    bytesPerSecond: 16 * MEGABYTE,
+    flatForMs: PROBE_INTERVAL_MS - 1
+  });
+  assert.equal(verdict.certain, false);
+  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
+});
+
+test("nothing queued is still a wedge when the counter has been flat long enough — the channel queue was 0 on the real wedge while usrsctp held 399 MB", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 0,
+    bytesPerSecond: 16 * MEGABYTE,
+    flatForMs: 600_000
+  });
+  assert.equal(verdict.certain, true);
+  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
+});
+
+test("with no rate measured the answer is that nothing can be said", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 0,
+    flatForMs: 600_000
+  });
+  assert.equal(verdict.certain, false);
+  assert.equal(verdict.needMs, null);
+});
+
+test("a pause no longer than this link's own longest healthy pause is not a wedge", () => {
+  // A retransmission timeout stops the accepted-byte counter dead: a full send
+  // buffer accepts nothing. If this connection has already paused 3 s while
+  // healthy, a 3 s pause says nothing.
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 18 * MEGABYTE,
+    flatForMs: 2500,
+    longestHealthyFlatMs: 3000
+  });
+  assert.equal(verdict.certain, false);
+  assert.equal(verdict.needMs, 3000);
+});
+
+test("a pause longer than any this link has shown is a wedge", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 18 * MEGABYTE,
+    flatForMs: 3500,
+    longestHealthyFlatMs: 3000
+  });
+  assert.equal(verdict.certain, true);
+});
+
+test("the quiet-probe rate cannot be what the queue is divided by", () => {
+  // With the browser's buffer full, the only traffic is the probe: three
+  // channels, a few dozen bytes, twice a second. Dividing 8 MB by that gives
+  // six hours, and the wedge would never be called. The BEST rate seen is what
+  // the watcher keeps, so this case must not arise — pinned here as the
+  // arithmetic that made it matter.
+  const wrong = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 360,
+    flatForMs: 60_000
+  });
+  assert.equal(wrong.certain, false);
+  assert.ok(wrong.needMs > 6 * 60 * 60 * 1000 - 1);
+  const right = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 18 * MEGABYTE,
+    flatForMs: 60_000
+  });
+  assert.equal(right.certain, true);
+});

package/services/encode/open-piece.js

@@ -1,135 +0,0 @@
-/**
- * @file The piece a run had open when it ended.
- *
- * A fact of a run's output directory, and therefore of the encoding layer. It
- * lived in the eleven-thousand-line file that is being taken apart, where it was
- * called by the one place that killed a run; stopping is decided in one place
- * now and carried out in another, so the cleanup belongs to the layer that owns
- * the directories rather than to whoever happened to do the killing.
- */
-
-import { readdir, readFile, stat, unlink } from "node:fs/promises";
-import path from "node:path";
-
-/**
- * Remove the piece a run had open when it ended, if that piece is unusable.
- *
- * The `segment` muxer creates its output file when it OPENS it and writes into
- * it until the next cut, so at any instant exactly one file in a run's
- * directory is unfinished: the highest-numbered one. A run that reaches the end
- * of its work closes that file and it is a good piece; a run killed for a seek
- * does not — measured 2026-09-03, ffmpeg exited 19 ms after SIGTERM and left
- * `segment-00025.mp4` at zero bytes, which then closed the only hole in the
- * numbering and convinced the look-ahead to keep the encoder stopped for having
- * "produced" it.
- *
- * **A piece is whole only if the run PROVED it, and reading it proves nothing.**
- *
- * The highest-numbered file in a run's stretch is the one it had open. How a
- * run ends decides what became of that file, and all three outcomes leave it
- * readable-looking: stopped with SIGTERM, ffmpeg writes it out and names it on
- * the ready channel exactly as it names a finished one; killed harder, or dying
- * on its own, it leaves the bytes it had written with no name at all. In every
- * case the file decodes and holds film only up to the instant the run ended,
- * under a number whose playlist entry promises a whole span. Field 2026-09-06:
- * `segment-00010.mp4` held 3.92 s of its declared 5.589 s — 96 frames — and the
- * picture jumped 1.5 s at 1:02; the soundtrack did the same at 17.5 s, 2.8 s
- * wide, in the same session. Both decoded, which is how both reached the viewer.
- *
- * So the question asked here is not what the file contains but whether the run
- * named it while it was still running normally. That is a fact the run holds,
- * so there is no span to measure and no tolerance to choose.
- *
- * A piece finished in the moment between the last such name and the end is
- * then made a second time. That is the cheaper error: the other is a hole the
- * viewer sees.
- *
- * @param {string | null | undefined} runDirPath
- * @param {{ isSegmentFileName: (name: string) => boolean, segmentIndexFromName: (name: string) => number }} segmentFormat
- * @param {((raw: Buffer) => boolean) | null} judgeUsable - Whether a non-empty
- *   piece carries what it should. Null where nothing can say, and then only an
- *   empty file is removed.
- * @param {string | null} [provenName] - The last piece the run named while it
- *   was running normally. A file beyond it was open when the run ended and goes
- *   whether or not it reads. Null where the run proved nothing, and then every
- *   piece it left is unproven.
- * @returns {Promise<number | null>} The segment number removed, or null.
- */
-export async function discardOpenPiece(runDirPath, segmentFormat, within, judgeUsable, provenName = null) {
-  if (!runDirPath || typeof segmentFormat?.isSegmentFileName !== "function") {
-    return null;
-  }
-  // Only inside the stretch the ended run was given. Every run of an output
-  // writes into one directory now — they are kept apart by their intervals
-  // rather than by a directory each — so the highest-numbered file in there may
-  // belong to a run that is still going, and removing it would take away a
-  // piece somebody is producing.
-  const from = Number.isInteger(within?.from) ? within.from : 0;
-  // THE RUN'S OWN REACH, which is a fact it holds and needs nothing measured.
-  //
-  // A run cannot have opened a file above the one just past the last it named:
-  // ffmpeg names a piece when it closes it and opens the next, so the open piece
-  // is at most `proven + 1`, and where it named nothing at all the open one is
-  // the first it was given.
-  //
-  // Used only where no end was declared — `to` below `from`, which is how "to
-  // the end of the track" is written everywhere here. Such a run had no bound at
-  // all: the search covered the whole directory and took the highest-numbered
-  // file in it. Every run of an output writes into that one
-  // directory, so what it took was a piece a LIVE run had just finished. Field
-  // 2026-09-06: the piece holding 2:47-2:57 went that way, its number is spent
-  // for good because names only grow, and the picture stood still for 647 s.
-  const provenIndex = typeof provenName === "string" && segmentFormat.isSegmentFileName(provenName)
-    ? segmentFormat.segmentIndexFromName(provenName)
-    : null;
-  const reach = Number.isInteger(provenIndex) && provenIndex >= from ? provenIndex + 1 : from;
-  // The declared end is the bound wherever there is one. The run's own reach is
-  // the bound of LAST RESORT, for a run given none: before it, such a run had no
-  // bound at all and the search covered the whole directory.
-  const to = Number.isInteger(within?.to) && within.to >= from ? within.to : reach;
-  let highest = null;
-  try {
-    for (const name of await readdir(runDirPath)) {
-      if (!segmentFormat.isSegmentFileName(name)) {
-        continue;
-      }
-      const index = segmentFormat.segmentIndexFromName(name);
-      if (index < from || index > to) {
-        continue;
-      }
-      if (index >= 0 && (highest === null || index > highest.index)) {
-        highest = { index, name };
-      }
-    }
-  } catch {
-    return null; // The run wrote nothing, or its directory is already gone.
-  }
-  if (highest === null) {
-    return null;
-  }
-  const filePath = path.join(runDirPath, highest.name);
-  // Proven finished only if the run said so while it was running. Anything
-  // beyond that name was open when the run ended, and its contents cannot say
-  // so — it decodes.
-  const proven = typeof provenName === "string" && provenName === highest.name;
-  let unusable = !proven;
-  try {
-    const info = await stat(filePath);
-    if (info.size === 0) {
-      unusable = true;
-    } else if (!unusable && typeof judgeUsable === "function") {
-      unusable = !judgeUsable(await readFile(filePath));
-    }
-  } catch {
-    return null; // Gone between the listing and the question.
-  }
-  if (!unusable) {
-    return null;
-  }
-  try {
-    await unlink(filePath);
-    return highest.index;
-  } catch {
-    return null; // Already removed.
-  }
-}