@torrent-tv/proxy 2.80.18 → 2.80.19

package/test/segment-serve-wiring.test.js

@@ -290,12 +290,12 @@ test("a run's FIRST segment is served once the encoder has passed it, without wa
   // successor and nothing is producing one. Waiting for that successor is what
   // held #317 for 46 s and then answered 404 to a browser that had given up.
   await rm(path.join(dirPath, "segment-00001.mp4"));
-  // WHAT PROVES IT INSTEAD: the encoder named it. ffmpeg writes the name of each
-  // piece on a channel of its own as it closes it, so a run's own first piece is
-  // proven the moment it is finished and the absence of a next one says nothing.
-  // This used to be inferred from the encoder's reported position instead, which
-  // is a different question — where it has read to, not what it has closed.
-  manager.segmentStore.markClosed(OUTPUT_KEY, 0);
+  // WHAT PROVES IT INSTEAD: its own NAME. A piece is called something else while
+  // it is being written and takes its served name when its writer says it is
+  // closed, so a run's first piece is proven the moment it is finished and the
+  // absence of a next one says nothing. This used to be inferred from the
+  // encoder's reported position — a different question, where it has read to
+  // rather than what it has closed.
 
   const result = await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
 
@@ -345,10 +345,9 @@ test("serving a run's own segment moves the run out of STARTING", async (t) => {
   // ITS OWN PIECE, AND FILM STILL TO MAKE BEHIND IT. A run standing on material
   // that already exists is moved forward — correctly — so a fixture that wants a
   // live run has to put it where the work is. #1 is what it is making; #2..#4
-  // are unmade, so it is wanted; and the encoder has named #1 on its ready
-  // channel, which is what makes the piece servable at all.
+  // are unmade, so it is wanted; and #1 stands under its served name, which is
+  // what makes the piece servable at all.
   const run = startRunOn(session, { from: 1, producing: false, usesExplicitCuts: true, speedX: 2 });
-  manager.segmentStore.markClosed(OUTPUT_KEY, 1);
   assert.equal(run.state, ENCODE_RUN_STATE.STARTING);
   assert.deepEqual(run.produced, [], "it has made nothing yet");
 

package/test/segment-store.test.js

@@ -1,216 +1,238 @@
-/**
- * @file One store of segments, addressed by what they are, and what it makes of
- * what a killed process left behind.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { directoryNameFor, SegmentStore } from "../services/encode/SegmentStore.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
-
-/**
- * @returns {{ store: SegmentStore, root: string, lines: string[] }}
- */
-function storeInATempRoot() {
-  const root = mkdtempSync(path.join(os.tmpdir(), "segment-store-"));
-  const lines = [];
-  const store = new SegmentStore({
-    root,
-    logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) }
-  });
-  return { store, root, lines };
-}
-
-/**
- * @param {string} dir
- * @param {number} index
- * @param {number} bytes
- */
-function writeSegment(dir, index, bytes = 16) {
-  writeFileSync(path.join(dir, fmp4Format.segmentFileName(index)), Buffer.alloc(bytes));
-}
-
-const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-
-test("two viewers of one output are given the same directory", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  // Which viewer asked never enters it — the address is what the segments are.
-  assert.equal(store.directoryFor(KEY), store.directoryFor(KEY));
-  assert.notEqual(store.directoryFor(KEY), store.directoryFor(`${KEY}:other`));
-});
-
-test("the directory says what it holds, so a later process can tell", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dir = store.directoryFor(KEY);
-  const names = readdirSync(dir);
-  assert.deepEqual(names, ["key.txt"]);
-});
-
-test("a segment is proven closed by the existence of the next one", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dir = store.directoryFor(KEY);
-  store.useFormat(KEY, fmp4Format);
-  writeSegment(dir, 0);
-  writeSegment(dir, 1);
-  writeSegment(dir, 2);
-
-  // The `hls` muxer carries no channel to report on and renames into place when
-  // it closes a piece, so on that branch existence IS the proof; the same
-  // answers for the pieces a previous life of this process left behind.
-  assert.deepEqual(store.provenNumbers(KEY), [0, 1]);
-  assert.equal(store.unprovenNumber(KEY), 2);
-});
-
-test("a file of no bytes is not a segment, whatever it is called", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dir = store.directoryFor(KEY);
-  store.useFormat(KEY, fmp4Format);
-  writeSegment(dir, 0);
-  writeSegment(dir, 1);
-  writeSegment(dir, 2, 0);
-
-  // What a run killed the moment after opening its next piece leaves behind.
-  // Counted as a segment once, it closed the only hole in the numbering and
-  // convinced the look-ahead the encoder had produced it.
-  assert.equal(store.pathOf(KEY, 2), null);
-  assert.deepEqual(store.provenNumbers(KEY), [0]);
-});
-
-test("a run's own stretch bounds what it unproves", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  store.useFormat(KEY, fmp4Format);
-  store.directoryFor(KEY);
-  for (let index = 0; index <= 5; index += 1) {
-    store.markClosed(KEY, index);
-  }
-
-  // A run of #0..#0 rewrites #0 and nothing else. Unbounded, this forgot the
-  // whole film beyond it — and with readiness a projection of what is proven,
-  // that is an output declaring itself unmade whenever an encoder starts near
-  // the beginning, which is a fresh encoder for every segment of it.
-  //
-  // Asked with no files on the disk, so the successor rule cannot answer for
-  // the statements and only the statements are under test.
-  store.forgetClosed(KEY, 0, 0);
-  assert.equal(store.isClosed(KEY, 0), false, "the one number it will rewrite");
-  assert.equal(store.isClosed(KEY, 1), true, "and nothing beyond its stretch");
-  assert.equal(store.isClosed(KEY, 5), true);
-
-  store.forgetClosed(KEY, 3);
-  assert.equal(store.isClosed(KEY, 2), true);
-  assert.equal(store.isClosed(KEY, 3), false, "no end given means to the end of the film");
-  assert.equal(store.isClosed(KEY, 5), false);
-});
-
-test("a directory that has not moved is not read again", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dir = store.directoryFor(KEY);
-  store.useFormat(KEY, fmp4Format);
-  writeSegment(dir, 0);
-  writeSegment(dir, 1);
-
-  const first = store.refresh(KEY);
-  const second = store.refresh(KEY);
-  assert.equal(first, second, "the same reading is handed back, not a fresh listing");
-});
-
-test("what a killed process left is found, named and counted", (t) => {
-  const { store, root, lines } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dir = path.join(root, directoryNameFor(KEY));
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(path.join(dir, "key.txt"), `${KEY}\n`);
-  writeSegment(dir, 0);
-  writeSegment(dir, 1);
-  const orphan = path.join(root, "0123456789abcdef");
-  mkdirSync(orphan, { recursive: true });
-  writeSegment(orphan, 0);
-
-  const swept = store.sweep();
-  assert.equal(swept.directories, 2);
-  assert.equal(swept.unidentified, 1, "the one with no key file cannot be matched to a request");
-  assert.equal(swept.segments, 3);
-  assert.match(lines.join("\n"), /startup sweep/);
-  assert.match(lines.join("\n"), /ended\s+without anything recording why/);
-});
-
-test("what survived a kill is taken back, minus the piece nothing proves", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dir = path.join(root, directoryNameFor(KEY));
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(path.join(dir, "key.txt"), `${KEY}\n`);
-  for (let index = 0; index <= 5; index += 1) {
-    writeSegment(dir, index);
-  }
-
-  const taken = store.adoptWhatSurvived(() => fmp4Format);
-
-  assert.equal(taken.adopted, 1);
-  assert.equal(taken.unprovenRemoved, 1, "the highest number was being written when the run died");
-  // Five kept rather than six thrown away: a copied segment's bytes depend only
-  // on the source, and re-encoding them costs a machine already short of it.
-  assert.deepEqual(store.provenNumbers(KEY), [0, 1, 2, 3, 4]);
-  assert.equal(store.pathOf(KEY, 5), null);
-});
-
-test("a directory that cannot name itself is thrown away rather than served", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const orphan = path.join(root, "0123456789abcdef");
-  mkdirSync(orphan, { recursive: true });
-  writeSegment(orphan, 0);
-
-  const taken = store.adoptWhatSurvived(() => fmp4Format);
-
-  assert.equal(taken.adopted, 0);
-  assert.equal(taken.dropped, 1);
-  assert.equal(readdirSync(root).length, 0);
-});
-
-test("an output this proxy can no longer serve is thrown away too", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dir = path.join(root, directoryNameFor(KEY));
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(path.join(dir, "key.txt"), `${KEY}\n`);
-  writeSegment(dir, 0);
-
-  const taken = store.adoptWhatSurvived(() => null);
-
-  assert.equal(taken.dropped, 1);
-  assert.equal(readdirSync(root).length, 0);
-});
-
-test("what the store weighs is reported, and dropping one output frees it", (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dir = store.directoryFor(KEY);
-  store.useFormat(KEY, fmp4Format);
-  writeSegment(dir, 0, 1000);
-  writeSegment(dir, 1, 1000);
-
-  assert.equal(store.stats().bytes, 2000);
-  store.drop(KEY, "nobody is watching it");
-  assert.equal(store.stats().outputs, 0);
-});
+/**
+ * @file One store of segments, addressed by what they are, and what it makes of
+ * what a killed process left behind.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { directoryNameFor, SegmentStore } from "../services/encode/SegmentStore.js";
+import { fmp4Format } from "../services/segment-formats/fmp4.js";
+
+/**
+ * @returns {{ store: SegmentStore, root: string, lines: string[] }}
+ */
+function storeInATempRoot() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "segment-store-"));
+  const lines = [];
+  const store = new SegmentStore({
+    root,
+    logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) }
+  });
+  return { store, root, lines };
+}
+
+/**
+ * @param {string} dir
+ * @param {number} index
+ * @param {number} bytes
+ */
+function writeSegment(dir, index, bytes = 16) {
+  writeFileSync(path.join(dir, fmp4Format.segmentFileName(index)), Buffer.alloc(bytes));
+}
+
+const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
+
+test("two viewers of one output are given the same directory", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  // Which viewer asked never enters it — the address is what the segments are.
+  assert.equal(store.directoryFor(KEY), store.directoryFor(KEY));
+  assert.notEqual(store.directoryFor(KEY), store.directoryFor(`${KEY}:other`));
+});
+
+test("the directory says what it holds, so a later process can tell", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = store.directoryFor(KEY);
+  const names = readdirSync(dir);
+  assert.deepEqual(names, ["key.txt"]);
+});
+
+test("a piece under its served name is finished, and the last one too", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  writeSegment(dir, 0);
+  writeSegment(dir, 1);
+  writeSegment(dir, 2);
+
+  // It was "the NEXT number exists", which left the last piece of every run
+  // unprovable for ever and — the moment two runs share an output — declared a
+  // half-written file finished because somebody else had written the one after
+  // it. The name is the proof now, so all three count.
+  assert.deepEqual(store.provenNumbers(KEY), [0, 1, 2]);
+});
+
+test("a piece still being written is not a piece, and its name says so", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  writeSegment(dir, 0);
+  // What ffmpeg is writing into right now, tagged with the run that opened it.
+  writeFileSync(path.join(dir, "making-0-00001.mp4"), Buffer.alloc(64));
+
+  assert.deepEqual(store.provenNumbers(KEY), [0]);
+  assert.equal(store.isClosed(KEY, 1), false);
+  assert.equal(store.pathOf(KEY, 1), null);
+
+  // And closing it is one rename, after which it is servable.
+  assert.equal(store.publish(KEY, "making-0-00001.mp4", fmp4Format), "segment-00001.mp4");
+  assert.equal(store.isClosed(KEY, 1), true);
+});
+
+test("a file of no bytes is not a segment, whatever it is called", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  writeSegment(dir, 0);
+  writeSegment(dir, 1);
+  writeSegment(dir, 2, 0);
+
+  // A file of no bytes under a served name cannot arise from this proxy any
+  // more — a piece takes that name only on being closed — but a killed process
+  // can leave one, and taking it for a segment once closed the only hole in the
+  // numbering and convinced the look-ahead the encoder had produced it.
+  assert.equal(store.pathOf(KEY, 2), null);
+  assert.deepEqual(store.provenNumbers(KEY), [0, 1]);
+});
+
+test("clearing up after one run leaves every other run's work alone", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  // Two live runs, each with a piece open, plus finished pieces of both.
+  writeSegment(dir, 0);
+  writeSegment(dir, 100);
+  writeFileSync(path.join(dir, "making-0-00001.mp4"), Buffer.alloc(64));
+  writeFileSync(path.join(dir, "making-100-00101.mp4"), Buffer.alloc(64));
+
+  // The run that began at #0 ends. Its own unfinished piece goes and nothing
+  // else does — which the old rule could not manage: it took the highest SERVED
+  // name inside the ended run's stretch and judged its bytes, so with the
+  // naming rule above it would have removed #0, a piece that run had closed.
+  assert.equal(store.clearUpAfter(KEY, 0), 1);
+  assert.deepEqual(store.provenNumbers(KEY), [0, 100]);
+  assert.equal(
+    readdirSync(dir).includes("making-100-00101.mp4"),
+    true,
+    "the other run is still writing its own"
+  );
+});
+
+test("a directory that has not moved is not read again", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  writeSegment(dir, 0);
+  writeSegment(dir, 1);
+
+  const first = store.refresh(KEY);
+  const second = store.refresh(KEY);
+  assert.equal(first, second, "the same reading is handed back, not a fresh listing");
+});
+
+test("what a killed process left is found, named and counted", (t) => {
+  const { store, root, lines } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = path.join(root, directoryNameFor(KEY));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path.join(dir, "key.txt"), `${KEY}\n`);
+  writeSegment(dir, 0);
+  writeSegment(dir, 1);
+  const orphan = path.join(root, "0123456789abcdef");
+  mkdirSync(orphan, { recursive: true });
+  writeSegment(orphan, 0);
+
+  const swept = store.sweep();
+  assert.equal(swept.directories, 2);
+  assert.equal(swept.unidentified, 1, "the one with no key file cannot be matched to a request");
+  assert.equal(swept.segments, 3);
+  assert.match(lines.join("\n"), /startup sweep/);
+  assert.match(lines.join("\n"), /ended\s+without anything recording why/);
+});
+
+test("what survived a kill is taken back whole, minus what was still being written", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = path.join(root, directoryNameFor(KEY));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path.join(dir, "key.txt"), `${KEY}
+`);
+  for (let index = 0; index <= 5; index += 1) {
+    writeSegment(dir, index);
+  }
+  // The piece the kernel interrupted. It never had a served name, so it cannot
+  // be mistaken for one — which is what the old rule could only guess at, by
+  // always throwing the highest number away.
+  writeFileSync(path.join(dir, "making-0-00006.mp4"), Buffer.alloc(64));
+
+  const taken = store.adoptWhatSurvived(() => fmp4Format);
+
+  assert.equal(taken.adopted, 1);
+  assert.equal(taken.unprovenRemoved, 1, "the one under a working name");
+  // All six kept rather than five: the highest served name used to be thrown
+  // away because nothing could prove it, and on the copy branch that is a piece
+  // whose bytes depend only on the source and cost a short machine to remake.
+  assert.deepEqual(store.provenNumbers(KEY), [0, 1, 2, 3, 4, 5]);
+});
+
+test("a directory that cannot name itself is thrown away rather than served", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const orphan = path.join(root, "0123456789abcdef");
+  mkdirSync(orphan, { recursive: true });
+  writeSegment(orphan, 0);
+
+  const taken = store.adoptWhatSurvived(() => fmp4Format);
+
+  assert.equal(taken.adopted, 0);
+  assert.equal(taken.dropped, 1);
+  assert.equal(readdirSync(root).length, 0);
+});
+
+test("an output this proxy can no longer serve is thrown away too", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = path.join(root, directoryNameFor(KEY));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path.join(dir, "key.txt"), `${KEY}\n`);
+  writeSegment(dir, 0);
+
+  const taken = store.adoptWhatSurvived(() => null);
+
+  assert.equal(taken.dropped, 1);
+  assert.equal(readdirSync(root).length, 0);
+});
+
+test("what the store weighs is reported, and dropping one output frees it", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  writeSegment(dir, 0, 1000);
+  writeSegment(dir, 1, 1000);
+
+  assert.equal(store.stats().bytes, 2000);
+  store.drop(KEY, "nobody is watching it");
+  assert.equal(store.stats().outputs, 0);
+});

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.
-  }
-}