@torrent-tv/proxy 2.86.0 → 2.87.1

package/test/segment-judged-by-its-own-header.test.js

@@ -0,0 +1,221 @@
+/**
+ * @file A piece short of a track is judged against ITS OWN header.
+ *
+ * The question "does this piece carry every track" has two possible answers and
+ * they call for opposite actions, which is why asking it against the session's
+ * cached header alone was not enough: a piece that disagrees with that header
+ * may be short, or the header may be the odd one out. A self-contained piece
+ * carries a `moov` of its own, so it can be compared with itself, and that
+ * comparison tells the two apart without asking anything about encoders.
+ *
+ * WHAT THIS REPLACED. The action used to be chosen by "is any run of this
+ * session alive?" — a question about the SESSION, asked about a fact of the
+ * BYTES. A run anywhere in the film meant "still being written; waiting for
+ * it", and nothing re-judged or re-made the piece afterwards, so one
+ * misjudgement became permanent.
+ *
+ * Field 2026-09-14: `segment-00033.mp4` of a copied picture, already served
+ * whole to one viewer at 5 099 421 bytes, was refused to a second viewer for
+ * five minutes — four holds of sixty seconds each, then 503 — while the run in
+ * force was at #192 and beyond. That viewer's picture stood still 196.2 s and
+ * then a further 56.2 s.
+ *
+ * The run question is also unanswerable and does not need asking: a piece being
+ * written is called `making-<tag>-NNNNN.mp4` and takes its served name by a
+ * rename, which is atomic. A file under its served name is never being written.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { access, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { managerWithOwnStore } from "./helpers/manager.js";
+import { startRunOn } from "./helpers/encode-run.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+import { outputSpec } from "./helpers/output-spec.js";
+
+const SESSION_ID = "3333333344445555";
+const OUTPUT_KEY = "own-header:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
+const MOVIE_TIMESCALE = 1000;
+
+/**
+ * @param {string} type
+ * @param {Buffer} body
+ * @returns {Buffer}
+ */
+function box(type, body) {
+  const head = Buffer.alloc(8);
+  head.writeUInt32BE(8 + body.length, 0);
+  head.write(type, 4, "latin1");
+  return Buffer.concat([head, body]);
+}
+
+/**
+ * @param {number} trackId
+ * @returns {Buffer}
+ */
+function trak(trackId) {
+  const tkhdBody = Buffer.alloc(84);
+  tkhdBody.writeUInt32BE(trackId, 12);
+  const mdhdBody = Buffer.alloc(20);
+  mdhdBody.writeUInt32BE(90_000, 12);
+  return box("trak", Buffer.concat([
+    box("tkhd", tkhdBody),
+    box("mdia", box("mdhd", mdhdBody))
+  ]));
+}
+
+/**
+ * A header declaring `tracks` tracks.
+ *
+ * @param {number} tracks
+ * @returns {Buffer}
+ */
+function moovOf(tracks) {
+  const mvhdBody = Buffer.alloc(100);
+  mvhdBody.writeUInt32BE(MOVIE_TIMESCALE, 12);
+  const traks = [];
+  for (let id = 1; id <= tracks; id += 1) {
+    traks.push(trak(id));
+  }
+  return box("moov", Buffer.concat([box("mvhd", mvhdBody), ...traks]));
+}
+
+/**
+ * @param {number} trackId
+ * @returns {Buffer}
+ */
+function traf(trackId) {
+  const tfhdBody = Buffer.alloc(8);
+  tfhdBody.writeUInt32BE(trackId, 4);
+  const tfdtBody = Buffer.alloc(12);
+  tfdtBody.writeUInt8(1, 0);
+  tfdtBody.writeBigUInt64BE(0n, 4);
+  return box("traf", Buffer.concat([box("tfhd", tfhdBody), box("tfdt", tfdtBody)]));
+}
+
+/**
+ * A piece shaped like the `segment` muxer's output.
+ *
+ * @param {{ declares: number, carries: number }} shape - How many tracks its own
+ *   header declares, and how many its fragments actually carry. The two differ
+ *   only in a piece a run closed short.
+ * @returns {Buffer}
+ */
+function selfContainedPiece({ declares, carries }) {
+  const trafs = [];
+  for (let id = 1; id <= carries; id += 1) {
+    trafs.push(traf(id));
+  }
+  return Buffer.concat([
+    box("ftyp", Buffer.alloc(16, 0)),
+    moovOf(declares),
+    box("moof", Buffer.concat(trafs)),
+    box("mdat", Buffer.alloc(64, 0x5a)),
+    box("mfra", Buffer.alloc(24, 0))
+  ]);
+}
+
+/**
+ * A manager with one session whose first two pieces are already on disk.
+ *
+ * @param {{ piece: Buffer, sessionHeader: Buffer }} params - The piece written
+ *   for every number, and what the session has cached as its header.
+ * @returns {Promise<{ manager: object, dirPath: string }>}
+ */
+async function managerHolding({ piece, sessionHeader }) {
+  const { manager } = managerWithOwnStore();
+  manager.segmentStore.useFormat(OUTPUT_KEY, fmp4Format);
+  const dirPath = manager.segmentStore.directoryFor(OUTPUT_KEY);
+  await writeFile(path.join(dirPath, "segment-00000.mp4"), piece);
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), piece);
+
+  const session = {
+    id: SESSION_ID,
+    spec: outputSpec({ transcodeVideo: false }),
+    outputKey: OUTPUT_KEY,
+    dirPath,
+    timeline: new Timeline({ boundaries: [0, 12.5, 25, 37.5, 50, 62.5], cutGrid: "uniform" }),
+    state: "ready",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" })
+      .learn({ durationSeconds: 62.5 }),
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
+    lastAloneSpeed: 2,
+    startedAt: Date.now(),
+    lastAccessedAt: Date.now(),
+    runs: new Set(),
+    lastError: "",
+    segmentCount: 5,
+    segmentFormat: fmp4Format,
+    useSyntheticPlaylist: true,
+    playlistText: "#EXTM3U\n",
+    initBytes: sessionHeader,
+    waitEpoch: 0
+  };
+  manager.outputs.set(SESSION_ID, session);
+  // No plan runs here: this file is about the path that answers a request.
+  manager.encodeRuns.planEncodersNow = () => {};
+  manager.encodeRuns.planEncodersSoon = () => {};
+  // A LIVE RUN, deliberately. Under the rule this replaced, a live run anywhere
+  // was what turned a refusal into a permanent one — so both cases below are
+  // asked with one running, which is the state the field failure happened in.
+  startRunOn(session, { from: 0, usesExplicitCuts: true, speedX: 2 });
+  return { manager, dirPath };
+}
+
+test("a piece that agrees with its own header is served, whatever the session's header says", async () => {
+  // Two tracks declared, two carried: whole by its own account. The session's
+  // cached header declares three — the state that cannot be told from a short
+  // piece without asking the piece itself.
+  const piece = selfContainedPiece({ declares: 2, carries: 2 });
+  const { manager, dirPath } = await managerHolding({
+    piece,
+    sessionHeader: moovOf(3)
+  });
+
+  const answer = await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
+
+  assert.equal(answer.kind, "file", "the piece is whole and must reach the viewer");
+  await access(path.join(dirPath, "segment-00000.mp4"));
+});
+
+test("a piece that disagrees with its own header is removed, so it can be made again", async () => {
+  // Two tracks declared, one carried: closed short by a run that was killed
+  // mid-piece, which is what this check exists to catch.
+  const piece = selfContainedPiece({ declares: 2, carries: 1 });
+  const { manager, dirPath } = await managerHolding({
+    piece,
+    sessionHeader: moovOf(2)
+  });
+
+  const answer = await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
+
+  assert.equal(answer.kind, "warming-up", "a short piece is not servable");
+  await assert.rejects(
+    () => access(path.join(dirPath, "segment-00000.mp4")),
+    /ENOENT/,
+    "and it is removed, or nothing will ever make it again"
+  );
+});
+
+test("a live run elsewhere in the film does not make a short piece permanent", async () => {
+  const piece = selfContainedPiece({ declares: 2, carries: 1 });
+  const { manager, dirPath } = await managerHolding({
+    piece,
+    sessionHeader: moovOf(2)
+  });
+  // The field state exactly: the run in force is hundreds of segments ahead of
+  // the piece being asked for.
+  startRunOn(manager.outputs.get(SESSION_ID), { from: 192, usesExplicitCuts: true, speedX: 2 });
+
+  await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
+
+  await assert.rejects(
+    () => access(path.join(dirPath, "segment-00000.mp4")),
+    /ENOENT/,
+    "a run a thousand segments away says nothing about these bytes"
+  );
+});

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

@@ -17,20 +17,23 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.js";
-import { Timeline } from "../services/output/Timeline.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { Output } from "../services/encode/output/Output.js";
+import { KeyframeTable } from "../services/media/container/KeyframeTable.js";
 import { rm, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
 import { ENCODE_RUN_STATE } from "../services/encode/encode-run-state.js";
 import { startRunOn } from "./helpers/encode-run.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+import { outputSpec } from "./helpers/output-spec.js";
 
 const MOVIE_TIMESCALE = 1000;
 const VIDEO_TIMESCALE = 90_000;
 const AUDIO_TIMESCALE = 48_000;
 const SEGMENT_START_SECONDS = 12.5;
-const SESSION_ID = "11111111-2222-3333-4444-555555555555";
+const SESSION_ID = "1111111122223333";
 // Its own address, so this file's directory in the shared store is nobody
 // else's.
 const OUTPUT_KEY = "serve-wiring:fmt=fmp4:grid=uniform:video-only:v=0/copy";
@@ -118,11 +121,11 @@ function selfContainedPiece(offsetSeconds) {
  * A manager holding one session whose segments are already on disk, cut at
  * explicit times — the ordinary keyframe-cut path.
  *
- * @param {{ segmentFormat?: object }} [overrides]
- * @returns {Promise<{ manager: HlsSessionManager, session: object, dirPath: string }>}
+ * @param {{ segmentFormat?: object, audioOnly?: boolean, withRun?: boolean }} [overrides]
+ * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
  */
 async function managerWithReadySegment(overrides = {}) {
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -143,6 +146,11 @@ async function managerWithReadySegment(overrides = {}) {
 
   const session = {
     id: SESSION_ID,
+    spec: outputSpec({
+      transcodeVideo: overrides.transcodeVideo === true,
+      audioOnly: overrides.audioOnly === true,
+      cutGrid: "uniform"
+    }),
     outputKey: OUTPUT_KEY,
     dirPath,
     // Where this file is cut, held by the file. A fixture that stated it
@@ -168,7 +176,6 @@ async function managerWithReadySegment(overrides = {}) {
     // and the plan takes the encoder away for changing nothing.
     lastAloneSpeed: 2,
     startedAt: Date.now(),
-    createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
     runs: new Set(),
     lastError: "",
@@ -181,11 +188,26 @@ async function managerWithReadySegment(overrides = {}) {
     segmentFormat: overrides.segmentFormat ?? fmp4Format,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    initBytes: fmp4Format.extractInit(piece),
-    firstSegmentLogged: false,
+    // WHAT IS BEING PRODUCED, which is also where a produced piece's landing is
+    // recorded. Per output, so one output's reading of a piece number cannot
+    // silence another output's reading of its own.
+    output: new Output({ encodeWidth: 0, encodeHeight: 0, outputFps: 25, softwarePreset: null, applyTonemap: false }),
+    // WHERE THIS FILE'S KEYFRAMES ARE, held by the file. A copied picture is cut
+    // at these and nowhere else, which is what makes its landing evidence about
+    // this table — and what makes a soundtrack's landing evidence about nothing
+    // of the sort.
+    keyframes: new KeyframeTable().learn({ times: [0, 12.5, 25, 37.5, 50], format: "matroska" }),
+    audioOnly: overrides.audioOnly === true,
     waitEpoch: 0
   };
-  manager.sessionsById.set(SESSION_ID, session);
+  // THE INIT IS THE STORE'S, and a player fetches it before any segment — so a
+  // fixture that wants segments served as production serves them has to put it
+  // there first. It used to sit on the session, which nothing reads any more:
+  // `prepareSegmentBytes` has no timescales without it and hands the piece back
+  // unstamped, which is silent and is exactly the fault stamping exists to
+  // prevent.
+  manager.segmentStore.keepInit(OUTPUT_KEY, fmp4Format.extractInit(piece));
+  manager.outputs.set(SESSION_ID, session);
   // SOMEBODY IS WATCHING IT. A segment is requested by a viewer, so a fixture
   // that asks for one without stating a viewer describes a state production
   // never reaches — and an output nobody is watching has every encoder on it
@@ -195,38 +217,73 @@ async function managerWithReadySegment(overrides = {}) {
   // question with its own checks, and letting it run inside these would spawn
   // real ffmpeg processes and replace the very run each test is watching — the
   // test would then be about the plan, and about it at its least stable.
-  manager.planEncodersNow = () => {};
-  manager.planEncodersSoon = () => {};
+  manager.encodeRuns.planEncodersNow = () => {};
+  manager.encodeRuns.planEncodersSoon = () => {};
   // The run in force. The fixture's segments live directly in the session
   // directory, which is exactly what one run's directory is here.
-  startRunOn(session, { from: 0, usesExplicitCuts: true, speedX: 2 });
+  if (overrides.withRun !== false) {
+    const run = startRunOn(session, { from: 0, usesExplicitCuts: true, speedX: 2 });
+    manager.encodeOrchestrator.adopt(OUTPUT_KEY, run);
+  }
   return { manager, session, dirPath };
 }
 
 test("serving a segment records what its real start says about the container's index", async (t) => {
   const { manager, session, dirPath } = await managerWithReadySegment();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // The tally is counted in the module tests; what this pins is that serving a
   // segment reaches it at all. A counter nothing increments reports a clean
-  // index for every file forever, which is worse than no measurement.
-  session.timeline.indexCheck = { checked: 0, disagreed: 0, maxDeviationSec: 0, firstDisagreementIndex: -1, seen: new Set() };
+  // grid for every output forever, which is worse than no measurement.
+  assert.equal(session.output.landing, null, "nothing has been produced yet");
+
+  await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
+
+  assert.equal(session.output.landing.checked, 1, "the piece that was just produced must have been examined");
+});
+
+test("only a copied picture's landing is taken as evidence about the file's keyframe table", async (t) => {
+  // The one reading, sent to the two owners the manager decides between. A
+  // soundtrack is cut exactly where it is asked to be and has no keyframes, so
+  // its landing is about its own output and about nothing else; sent to the
+  // file's table it would report the file's index wrong on the strength of a
+  // stream that never consulted it.
+  const sound = await managerWithReadySegment({ audioOnly: true });
+  t.after(async () => {
+    await sound.manager.lifecycle.disposeAll();
+    await rm(sound.dirPath, { recursive: true, force: true });
+  });
+
+  await sound.manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
+
+  assert.equal(sound.session.output.landing.checked, 1, "the sound's own landing is recorded");
+  assert.equal(
+    sound.session.keyframes.evidence,
+    null,
+    "and nothing it produced is evidence about where the file's keyframes are"
+  );
 
-  await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
+  const picture = await managerWithReadySegment();
+  t.after(async () => {
+    await picture.manager.lifecycle.disposeAll();
+    await rm(picture.dirPath, { recursive: true, force: true });
+  });
 
-  assert.equal(session.timeline.indexCheck.checked, 1, "the boundary that was just produced must have been examined");
+  await picture.manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
+
+  assert.equal(picture.session.keyframes.evidence.checked, 1, "a copy's landing does reach the file's table");
 });
 
 test("a segment that exists is served, not reported as still being produced", async (t) => {
   const { manager, dirPath, session } = await managerWithReadySegment();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
 
-  const result = await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
+  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
 
   assert.equal(result.kind, "file", "a finished segment on disk must come back as bytes");
   assert.equal(result.contentType, fmp4Format.segmentContentType);
@@ -251,9 +308,9 @@ test("a segment that exists is served, not reported as still being produced", as
     "the segment must be stamped with where it really begins"
   );
   assert.equal(
-    session.timeline.indexCheck.checked,
+    session.output.landing.checked,
     1,
-    "and the piece's own position must still have been read, or nothing measures the index"
+    "and the piece's own position must still have been read, or nothing measures the landing"
   );
 });
 
@@ -266,11 +323,11 @@ test("a fault while preparing an existing segment is named, not turned into a wa
   };
   const { manager, dirPath } = await managerWithReadySegment({ segmentFormat: broken });
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
 
-  const result = await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
+  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
 
   assert.equal(
     result.kind,
@@ -283,7 +340,7 @@ test("a fault while preparing an existing segment is named, not turned into a wa
 test("a run's FIRST segment is served once the encoder has passed it, without waiting for a next one", async (t) => {
   const { manager, dirPath } = await managerWithReadySegment();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // The shape a resume takes: a run begun mid-file, so its first segment has no
@@ -297,7 +354,7 @@ test("a run's FIRST segment is served once the encoder has passed it, without wa
   // 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 });
+  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
 
   assert.equal(
     result.kind,
@@ -309,16 +366,17 @@ test("a run's FIRST segment is served once the encoder has passed it, without wa
 test("a segment an earlier run made is served by whatever run is going now", async (t) => {
   const { manager, session, dirPath } = await managerWithReadySegment();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // Every run of an output writes into that output's own directory — there is
   // one, and runs are kept apart by their stretches instead. So a viewer who
   // seeks back is served what an earlier run made, with no restart and no
   // search: the run going now began at #40 and #0 is simply there.
-  startRunOn(session, { from: 40, usesExplicitCuts: true });
+  const run = startRunOn(session, { from: 40, usesExplicitCuts: true });
+  manager.encodeOrchestrator.adopt(OUTPUT_KEY, run);
 
-  const result = await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
+  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
 
   assert.equal(result.kind, "file", "what any run of this output made is what this output holds");
   const chunks = [];
@@ -329,9 +387,9 @@ test("a segment an earlier run made is served by whatever run is going now", asy
 });
 
 test("serving a run's own segment moves the run out of STARTING", async (t) => {
-  const { manager, session, dirPath } = await managerWithReadySegment();
+  const { manager, session, dirPath } = await managerWithReadySegment({ withRun: false });
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // The table lives in `encode/encode-run-state.js` and is tested there as a graph.
@@ -341,17 +399,17 @@ test("serving a run's own segment moves the run out of STARTING", async (t) => {
   // A run that has not yet made anything: starting. The fixture's own run is
   // let go first, because this test is about ONE run and what serving does to
   // it.
-  session.runs.clear();
   // 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 #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.encodeOrchestrator.adopt(OUTPUT_KEY, run);
   assert.equal(run.state, ENCODE_RUN_STATE.STARTING);
   assert.deepEqual(run.produced, [], "it has made nothing yet");
 
-  await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
+  await manager.serving.getFileStream(SESSION_ID, "segment-00001.mp4");
 
   // ASKED OF WHAT THE SERVE WROTE, not of the state that happens to follow it.
   // The plan owns a run's life and may end it in the same turn for reasons of
@@ -364,9 +422,9 @@ test("serving a run's own segment moves the run out of STARTING", async (t) => {
 });
 
 test("a segment behind a run's own start does not claim that run has produced", async (t) => {
-  const { manager, session, dirPath } = await managerWithReadySegment();
+  const { manager, session, dirPath } = await managerWithReadySegment({ withRun: false });
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // What moves a run out of starting is ITS OWN first segment. An earlier run's
@@ -374,11 +432,44 @@ test("a segment behind a run's own start does not claim that run has produced",
   // lies ahead of the new run's beginning — so the question cannot be asked of
   // the number alone, and a run believed to be producing is one the look-ahead
   // may suspend and the seek path may wave through as "already covered".
-  session.runs.clear();
   const run = startRunOn(session, { from: 5, producing: false, usesExplicitCuts: true, speedX: 2 });
+  manager.encodeOrchestrator.adopt(OUTPUT_KEY, run);
 
-  await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
+  await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4");
 
   assert.deepEqual(run.produced, [], "#0 is somebody else's work and says nothing about this run");
   assert.equal(run.head, 5, "which is still where it began");
 });
+
+test("a request behind the run that nobody is coming for is answered absent, not held", async (t) => {
+  // A HOLD IS ONLY RIGHT WHILE SOMETHING IS COMING. Field 2026-08-15: hls.js
+  // asked a freshly prepared track for segment #0 while the run stood at #354,
+  // the request was held for the whole minute, and only when it failed did the
+  // player ask for the segment it actually needed — 63 s of spinner after a
+  // track that had been ready in 7. Answered absent, the player moves on at
+  // once.
+  //
+  // Whether anybody is coming is the encoding's answer, from the map it was
+  // given. An EMPTY map is not that answer: a session created a moment ago has
+  // no map yet, and read as "nobody is coming" every request behind the run
+  // would be refused for as long as that lasted.
+  const { manager, session, dirPath } = await managerWithReadySegment({ withRun: false });
+  t.after(async () => {
+    await manager.lifecycle.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  const run = startRunOn(session, { from: 3, producing: true, usesExplicitCuts: true, speedX: 2 });
+  manager.encodeOrchestrator.adopt(OUTPUT_KEY, run);
+
+  // No map yet: the request is HELD, because nothing has said otherwise.
+  const held = await manager.serving.getFileStream(SESSION_ID, "segment-00002.mp4");
+  assert.notEqual(held.kind, "not-found", "a session with no map waits, it does not refuse");
+
+  // Now the map says where the viewers are, and #2 is not in it.
+  manager.encodeOrchestrator.notePriorityMap(OUTPUT_KEY, [
+    { from: 3, to: 4, priority: 100, withinSeconds: 0 }
+  ]);
+  const refused = await manager.serving.getFileStream(SESSION_ID, "segment-00002.mp4");
+
+  assert.equal(refused.kind, "not-found");
+});

package/test/segment-store-eviction.test.js

@@ -12,7 +12,7 @@ import assert from "node:assert/strict";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { SegmentStore } from "../services/encode/SegmentStore.js";
+import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
 
 const SEGMENT = 1024;
 
@@ -213,19 +213,34 @@ test("told nothing about viewers, it falls back to the oldest directory", async
   }
 });
 
-test("a clean exit leaves nothing of ours, so what is found next time is from a kill", async () => {
+test("a clean exit leaves nothing of ours, and nothing of anybody else's either", async () => {
   const { store, root } = await makeStore();
   try {
     await fill(store, "one", [0, 1, 2]);
     await fill(store, "two", [0, 1]);
-    // A directory this process adopted at startup and no session owns: the very
-    // thing the old rule left behind, which is how an orphan became permanent.
-    await fs.mkdir(path.join(root, "abandoned"), { recursive: true });
-    await fs.writeFile(path.join(root, "abandoned", "segment-00000.mp4"), Buffer.alloc(SEGMENT));
+    // A directory this store never adopted. It is either an orphan of a killed
+    // process or ANOTHER PROXY'S LIVE OUTPUT, and from here the two are
+    // indistinguishable — the root is a fixed path on the machine, not this
+    // process's property. So it is left alone: an orphan gets an owner at the
+    // next startup sweep and goes with the exit after that, while a live output
+    // of another process must not be taken from under it.
+    //
+    // What this replaced removed the ROOT, recursively, which took both.
+    // Measured 2026-09-14 under `node --test`, where a second process is
+    // ordinary: 2 to 4 checks of a neighbouring file failed per run, never the
+    // same ones, reporting segments missing that they had just written.
+    await fs.mkdir(path.join(root, "not-ours"), { recursive: true });
+    await fs.writeFile(path.join(root, "not-ours", "segment-00000.mp4"), Buffer.alloc(SEGMENT));
 
     assert.equal(store.dropAll("the proxy is shutting down"), 2);
 
-    await assert.rejects(() => fs.stat(root), /ENOENT/, "the store left its root behind");
+    assert.deepEqual(await heldNumbers(store, "one"), [], "what this store made is gone");
+    assert.deepEqual(await heldNumbers(store, "two"), []);
+    assert.ok((await fs.stat(root)).isDirectory(), "the root is the machine's, and it stays");
+    assert.ok(
+      (await fs.stat(path.join(root, "not-ours", "segment-00000.mp4"))).size > 0,
+      "a directory this store never adopted is not its to remove"
+    );
   } finally {
     await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }