@torrent-tv/proxy 2.89.16 → 2.89.18

package/test/init-compat.test.js

@@ -1,219 +0,0 @@
-/**
- * @file The rule that decides whether one output's pieces may be played under
- * another's header — and it is written BEFORE the experiment that will use it.
- *
- * The order matters and was a review finding: a criterion derived from the
- * differences an experiment happened to produce proves only that those
- * differences were handled. This one compares the whole header, names every
- * difference by where it sits, and refuses anything no listed exception covers.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { INIT_DIFFERENCE_EXCEPTIONS, compareInits, initLeaves } from "../services/encode/segment-formats/init-compat.js";
-
-/**
- * One ISO base media box.
- *
- * @param {string} type
- * @param {...(Buffer | number[])} parts
- * @returns {Buffer}
- */
-function box(type, ...parts) {
-  const body = Buffer.concat(parts.map((part) => (Buffer.isBuffer(part) ? part : Buffer.from(part))));
-  const header = Buffer.alloc(8);
-  header.writeUInt32BE(body.length + 8, 0);
-  header.write(type, 4, "latin1");
-  return Buffer.concat([header, body]);
-}
-
-/**
- * A version-0 `mdhd`: version+flags, creation, modification, timescale,
- * duration, language, quality.
- *
- * @param {number} timescale
- * @returns {Buffer}
- */
-function mdhd(timescale) {
-  const body = Buffer.alloc(24);
-  body.writeUInt32BE(timescale, 12);
-  return box("mdhd", body);
-}
-
-/**
- * A `btrt`: decoding buffer size, maximum rate, average rate.
- *
- * @param {number} maxBitrate
- * @returns {Buffer}
- */
-function btrt(maxBitrate) {
-  const body = Buffer.alloc(12);
-  body.writeUInt32BE(1875072, 0);
-  body.writeUInt32BE(maxBitrate, 4);
-  body.writeUInt32BE(maxBitrate, 8);
-  return box("btrt", body);
-}
-
-/**
- * A `stsd` carrying one visual sample entry: its 78-byte preamble, then the
- * codec configuration, then optionally a bit rate declaration.
- *
- * @param {{ entryType?: string, config?: number[], maxBitrate?: number | null, preamble?: number }} [how]
- * @returns {Buffer}
- */
-function stsd({ entryType = "avc1", config = [1, 100, 0, 31], maxBitrate = null, preamble = 78 } = {}) {
-  const versionAndCount = Buffer.alloc(8);
-  versionAndCount.writeUInt32BE(1, 4);
-  const children = [box("avcC", config)];
-  if (maxBitrate !== null) {
-    children.push(btrt(maxBitrate));
-  }
-  const entry = box(entryType, Buffer.alloc(preamble), ...children);
-  return box("stsd", versionAndCount, entry);
-}
-
-/**
- * A whole init segment, shaped as ffmpeg writes one.
- *
- * @param {{ timescale?: number, tracks?: number } & Parameters<typeof stsd>[0]} [how]
- * @returns {Buffer}
- */
-function init({ timescale = 90000, tracks = 1, ...entry } = {}) {
-  const trak = (index) =>
-    box(
-      "trak",
-      box("tkhd", Buffer.alloc(84, index)),
-      box("mdia", mdhd(timescale), box("hdlr", Buffer.alloc(32)), box("minf", box("stbl", stsd(entry))))
-    );
-  const traks = [];
-  for (let index = 0; index < tracks; index += 1) {
-    traks.push(trak(index));
-  }
-  return Buffer.concat([
-    box("ftyp", Buffer.from("isom")),
-    box("moov", box("mvhd", Buffer.alloc(100)), ...traks, box("mvex", box("trex", Buffer.alloc(24))))
-  ]);
-}
-
-const ENTRY = "moov[0]/trak[0]/mdia[0]/minf[0]/stbl[0]/stsd[0]/avc1[0]";
-
-test("every exception carries the reason it is one", () => {
-  for (const exception of INIT_DIFFERENCE_EXCEPTIONS) {
-    assert.ok(exception.why && exception.why.length > 40, `no reason given for ${JSON.stringify(exception)}`);
-    assert.ok(
-      exception.path !== undefined || exception.sampleEntryBox !== undefined,
-      "an exception says WHAT it covers"
-    );
-  }
-});
-
-test("every leaf of the header is named by whose child it is, inside a sample entry too", () => {
-  const paths = [...initLeaves(init({ tracks: 2, maxBitrate: 3_000_000 })).keys()];
-
-  assert.ok(paths.includes("moov[0]/trak[0]/mdia[0]/mdhd[0]"), paths.join(" "));
-  assert.ok(paths.includes("moov[0]/trak[1]/mdia[0]/mdhd[0]"), "the second track is its own path");
-  assert.ok(paths.includes("moov[0]/mvex[0]/trex[0]"));
-  assert.ok(
-    paths.includes(`${ENTRY}/avcC[0]`),
-    "the codec configuration is a leaf of its own, so it can refuse on its own"
-  );
-  assert.ok(paths.includes(`${ENTRY}/btrt[0]`), "and so is the bit rate declaration");
-});
-
-test("one header serves its own pieces", () => {
-  const answer = compareInits(init(), init());
-
-  assert.equal(answer.compatible, true);
-  assert.deepEqual(answer.differences, []);
-});
-
-test("a bit rate declaration is the one difference that does not refuse", () => {
-  const answer = compareInits(init({ maxBitrate: 3_000_000 }), init({ maxBitrate: 1_200_000 }));
-
-  assert.equal(answer.compatible, true, answer.differences.join(" | "));
-  assert.deepEqual(answer.refusedPaths, []);
-  assert.ok(
-    answer.differences.some((line) => line.includes("max 3000000") && line.includes("max 1200000")),
-    `the difference is still reported, with its numbers: ${answer.differences.join(" | ")}`
-  );
-});
-
-test("allowing the bit rate does not allow the parameter sets beside it", () => {
-  const answer = compareInits(
-    init({ maxBitrate: 3_000_000, config: [1, 100, 0, 31] }),
-    init({ maxBitrate: 1_200_000, config: [1, 100, 0, 30] })
-  );
-
-  assert.equal(answer.compatible, false);
-  assert.deepEqual(answer.refusedPaths, [`${ENTRY}/avcC[0]`]);
-});
-
-test("the bit rate exception is scoped to a sample entry", () => {
-  const strayLeft = box("moov", box("trak", box("mdia", box("minf", box("stbl", btrt(3_000_000))))));
-  const strayRight = box("moov", box("trak", box("mdia", box("minf", box("stbl", btrt(1_200_000))))));
-
-  const answer = compareInits(strayLeft, strayRight);
-
-  assert.equal(answer.compatible, false, "a btrt that is nobody's sample entry is not the box the reason is about");
-  assert.deepEqual(answer.refusedPaths, ["moov[0]/trak[0]/mdia[0]/minf[0]/stbl[0]/btrt[0]"]);
-});
-
-test("a sample entry whose children do not tile is compared whole", () => {
-  const answer = compareInits(init({ preamble: 8, config: [1, 100, 0, 31] }), init({ preamble: 8, config: [1, 100, 0, 30] }));
-
-  assert.equal(answer.compatible, false);
-  assert.deepEqual(
-    answer.refusedPaths,
-    [ENTRY],
-    "the descent is checked, and where it does not hold the whole entry refuses"
-  );
-});
-
-test("a different media timescale is refused, and said in those words", () => {
-  const answer = compareInits(init({ timescale: 90000 }), init({ timescale: 48000 }));
-
-  assert.equal(answer.compatible, false);
-  assert.ok(
-    answer.differences.some((line) => line.includes("timescale 90000 against 48000")),
-    answer.differences.join(" | ")
-  );
-  assert.deepEqual(answer.refusedPaths, ["moov[0]/trak[0]/mdia[0]/mdhd[0]"]);
-});
-
-test("a track present in one header and not the other is refused", () => {
-  const answer = compareInits(init({ tracks: 1 }), init({ tracks: 2 }));
-
-  assert.equal(answer.compatible, false);
-  assert.ok(
-    answer.differences.some((line) => line.includes("trak[1]") && line.includes("absent from the first")),
-    answer.differences.join(" | ")
-  );
-});
-
-test("an exact-path exception decides by path", () => {
-  const served = init({ timescale: 90000 });
-  const made = init({ timescale: 48000 });
-
-  const refused = compareInits(served, made);
-  const permitted = compareInits(served, made, {
-    exceptions: [{ path: "moov[0]/trak[0]/mdia[0]/mdhd[0]", why: "for this check only" }]
-  });
-
-  assert.equal(refused.compatible, false);
-  assert.equal(permitted.compatible, true, "the exception list is what decides, and it is asked by path");
-  assert.equal(permitted.differences.length, 1, "a permitted difference is still reported");
-});
-
-test("allowing one path does not allow the same box of another track", () => {
-  const answer = compareInits(init({ tracks: 2, timescale: 90000 }), init({ tracks: 2, timescale: 48000 }), {
-    exceptions: [{ path: "moov[0]/trak[0]/mdia[0]/mdhd[0]", why: "for this check only" }]
-  });
-
-  assert.equal(answer.compatible, false);
-  assert.deepEqual(answer.refusedPaths, ["moov[0]/trak[1]/mdia[0]/mdhd[0]"]);
-});
-
-test("a missing header is never compatible", () => {
-  assert.equal(compareInits(init(), Buffer.alloc(0)).compatible, false);
-  assert.equal(compareInits(Buffer.alloc(0), init()).compatible, false);
-});

package/test/input-lost-quiets-the-plan.test.js

@@ -1,261 +0,0 @@
-/**
- * @file An output whose input is away gets no encoders until it may.
- *
- * A run whose input has gone is not alive, so the plan reads the stretch it held
- * as free and places another run there at once — which dies the same way,
- * because nothing about the state has changed. A delay existed for exactly this,
- * doubling from 2 s to 15 s, and it was timed against the DEAD RUN, which the
- * plan never consults. Field 2026-09-12: 2432 ffmpeg starts in 23 minutes, one
- * every 0.57 s, for 61 minutes, against a delay that had reached its ceiling
- * long before; the flood also turned the log over twice and destroyed the
- * record of how the failure began.
- *
- * The delay lives beside the decision it governs now, and these check that it
- * binds.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { EncodeRun } from "../services/encode/EncodeRun.js";
-import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
-import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-import { EncodeOrchestrator } from "../services/encode/EncodeOrchestrator.js";
-
-const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-
-class FakeProcess extends EventEmitter {
-  constructor() {
-    super();
-    this.pid = 1;
-  }
-
-  kill(signal) {
-    this.emit("exit", null, signal);
-  }
-}
-
-/** An orchestrator whose clock the test moves, and a count of what it started. */
-function orchestrator() {
-  const lines = [];
-  let clock = 1_000;
-  let started = 0;
-  let asked = 0;
-  /** @type {EncodeOrchestrator} */
-  let made;
-  /** @type {{ run: EncodeRun, process: FakeProcess }[]} */
-  const runs = [];
-  made = new EncodeOrchestrator({
-    maxRunsFor: () => 1,
-    segmentSeconds: 4,
-    startingSpeedFor: () => 2,
-    refetchSecPerFilmSecond: () => 0.25,
-    now: () => clock,
-    planSoon: () => { asked += 1; },
-    logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) },
-    makeRun: ({ address, from, to }) => {
-      started += 1;
-      const process_ = new FakeProcess();
-      const run = new EncodeRun({
-        address,
-        encoder: new SoftwareEncoder(),
-        from,
-        to,
-        buildArgs: () => ["-i", "in", "out"],
-        spawn: () => process_,
-        logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) },
-        now: () => clock,
-        onEnded: (ended) => made.noteEnded(ended)
-      });
-      runs.push({ run, process: process_ });
-      return run;
-    }
-  });
-  made.setSegmentCount(PICTURE, 1000);
-  made.noteStartupCosts({ killCostSec: 0, firstByteWaitSec: 0.12 });
-
-  const wants = () => made.notePriorityMap(PICTURE, [
-    { from: 0, to: 20, priority: 1, withinSeconds: 0 }
-  ]);
-
-  return {
-    made,
-    lines,
-    wants,
-    runs,
-    startedCount: () => started,
-    askedToPlanAgain: () => asked,
-    advance: (ms) => { clock += ms; },
-    /** End the newest run the way a torrent going away ends one. */
-    loseTheInput: () => {
-      const newest = runs[runs.length - 1];
-      made.noteEnded({
-        address: PICTURE,
-        run: newest.run,
-        from: newest.run.from,
-        to: newest.run.to,
-        ending: ENCODE_EXIT.INPUT_LOST,
-        because: "the torrent went away"
-      });
-    }
-  };
-}
-
-test("nothing is placed on an output whose input has just gone", () => {
-  const stand = orchestrator();
-  stand.wants();
-  stand.made.reconcile();
-  assert.equal(stand.startedCount(), 1, "one encoder for the one thing wanted");
-
-  stand.loseTheInput();
-  // The plan is asked again by every event there is — a request, a report, a
-  // piece — and in the field that was about twice a second.
-  for (let attempt = 0; attempt < 20; attempt += 1) {
-    stand.made.reconcile();
-  }
-  assert.equal(
-    stand.startedCount(),
-    1,
-    "twenty decisions while the input is away must not be twenty processes"
-  );
-});
-
-test("once the wait is over the plan places again", () => {
-  const stand = orchestrator();
-  stand.wants();
-  stand.made.reconcile();
-  stand.loseTheInput();
-  stand.made.reconcile();
-  assert.equal(stand.startedCount(), 1);
-
-  // The first wait is the base delay; anything past it lets the plan act.
-  stand.advance(2_001);
-  stand.made.reconcile();
-  assert.equal(stand.startedCount(), 2, "the data may be back, and that is worth one attempt");
-});
-
-test("the wait doubles while the input stays away, and is capped", () => {
-  const stand = orchestrator();
-  stand.wants();
-  stand.made.reconcile();
-
-  const waits = [];
-  for (let attempt = 0; attempt < 8; attempt += 1) {
-    stand.loseTheInput();
-    // Find the shortest advance that lets the plan act again, by stepping to
-    // just before and just after the boundary rather than reading a private.
-    let waited = 0;
-    const step = 250;
-    for (;;) {
-      const before = stand.startedCount();
-      stand.made.reconcile();
-      if (stand.startedCount() > before) {
-        break;
-      }
-      stand.advance(step);
-      waited += step;
-      assert.ok(waited < 60_000, "a wait must not be unbounded");
-    }
-    waits.push(waited);
-  }
-
-  for (let at = 1; at < waits.length; at += 1) {
-    assert.ok(
-      waits[at] >= waits[at - 1],
-      `the wait must not shrink while the input stays away: ${JSON.stringify(waits)}`
-    );
-  }
-  assert.ok(
-    waits[waits.length - 1] <= 15_000,
-    `and it must stop growing: ${JSON.stringify(waits)}`
-  );
-  assert.ok(
-    waits[waits.length - 1] > waits[0],
-    `and it must actually have grown: ${JSON.stringify(waits)}`
-  );
-});
-
-test("a wake-up is asked for, because no event arrives while the data is away", async () => {
-  const stand = orchestrator();
-  stand.wants();
-  stand.made.reconcile();
-  stand.loseTheInput();
-  // The wake-up runs on the real clock — the orchestrator's injected `now` is
-  // what the DECISION reads, and a timer is not a decision. So this waits for
-  // the condition, with a deadline only as a backstop; a fixed pause here would
-  // measure the machine.
-  const deadline = Date.now() + 10_000;
-  while (stand.askedToPlanAgain() === 0) {
-    if (Date.now() > deadline) {
-      assert.fail("nothing about the state changes while the input is missing, so the plan must be recalled");
-    }
-    await new Promise((resolve) => setTimeout(resolve, 25));
-  }
-  assert.ok(stand.askedToPlanAgain() >= 1);
-});
-
-test("an ending that is not about the input clears the wait", () => {
-  const stand = orchestrator();
-  stand.wants();
-  stand.made.reconcile();
-  stand.loseTheInput();
-  stand.made.reconcile();
-  assert.equal(stand.startedCount(), 1, "held back, as it should be");
-
-  stand.advance(2_001);
-  stand.made.reconcile();
-  assert.equal(stand.startedCount(), 2);
-
-  // This one PRODUCED and was then stopped: a segment came out of the input, so
-  // the input was plainly there and the next attempt starts from no delay.
-  const newest = stand.runs[stand.runs.length - 1];
-  stand.made.noteEnded({
-    address: PICTURE,
-    run: newest.run,
-    from: newest.run.from,
-    to: newest.run.to,
-    reached: newest.run.from,
-    firstOutputMs: 120,
-    ending: ENCODE_EXIT.STOPPED,
-    because: "we asked it to"
-  });
-  stand.made.reconcile();
-  assert.equal(stand.startedCount(), 3, "a file that has just produced is not suspect");
-});
-
-test("an ending that produced NOTHING does not lift the wait", () => {
-  const stand = orchestrator();
-  stand.wants();
-  stand.made.reconcile();
-  stand.loseTheInput();
-
-  // At the moment of failure several runs end at once. One of them ending
-  // without having made anything proves nothing about the input, and lifting
-  // the wait on it is the storm again with an extra step.
-  const newest = stand.runs[stand.runs.length - 1];
-  stand.made.noteEnded({
-    address: PICTURE,
-    run: newest.run,
-    from: newest.run.from,
-    to: newest.run.to,
-    reached: newest.run.from - 1,
-    firstOutputMs: null,
-    ending: ENCODE_EXIT.GONE,
-    because: "it is no longer running, and it did not say so"
-  });
-  for (let attempt = 0; attempt < 10; attempt += 1) {
-    stand.made.reconcile();
-  }
-  assert.equal(stand.startedCount(), 1, "an ending with nothing produced is no evidence");
-});
-
-test("the wait is said out loud, with the attempt and how long", () => {
-  const stand = orchestrator();
-  stand.wants();
-  stand.made.reconcile();
-  stand.loseTheInput();
-  assert.ok(
-    stand.lines.some((line) => /its input was not there \(attempt 1\)/.test(line)),
-    `the reason nothing is being placed must be readable: ${JSON.stringify(stand.lines.slice(-4))}`
-  );
-});

package/test/input-unavailable.test.js

@@ -1,48 +0,0 @@
-/**
- * @file Telling "the data is not here yet" from "this cannot be encoded".
- *
- * A run that dies because its input went away used to condemn the whole
- * session: state `failed`, and every request for the playlist answered 500
- * from then on. But the torrent can be added again and the pieces downloaded
- * again, so the data being gone is a wait, not a verdict — measured 2026-08-06,
- * a torrent evicted mid-seek killed a session whose swarm was right there and
- * whose data would have come back in seconds.
- *
- * The classification is what decides which of the two happened, so it is tested
- * on the exact messages the field produced.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { isInputUnavailable } from "../services/encode/EncodeRuns.js";
-
-test("the messages the field produced when data went away are all temporary", () => {
-  for (const message of [
-    "[http @ 0x7f99b19f00] Error reading HTTP response: End of file",
-    "File 0 not found in torrent:17c46f5c36b94865858bfeaa412693c097328a50.",
-    "File 5 not found in magnet:8d3b6c2e74df473e3649521f927ae33b20cd9e67.",
-    "Unknown source 9711bbde2debdcd0d1fbd8cf88d68fd9612e5d31.",
-    "[in#0/matroska,webm @ 0x7f9005f340] Read error at pos. 138556 (0x21d3c)",
-    "Server returned 503 Service Unavailable",
-    "Input/output error"
-  ]) {
-    assert.equal(isInputUnavailable(message), true, `should be retried: ${message}`);
-  }
-});
-
-test("a real encoding failure is not mistaken for one", () => {
-  for (const message of [
-    "Cannot write moov atom before AC3 packets. Set the delay_moov flag to fix this.",
-    "Could not write header (incorrect codec parameters ?): Invalid argument",
-    "Unknown encoder 'h264_v4l2m2m'",
-    "ffmpeg exited with code 1"
-  ]) {
-    assert.equal(isInputUnavailable(message), false, `should stay terminal: ${message}`);
-  }
-});
-
-test("nothing at all is not a reason to retry for ever", () => {
-  assert.equal(isInputUnavailable(""), false);
-  assert.equal(isInputUnavailable(undefined), false);
-  assert.equal(isInputUnavailable(null), false);
-});

package/test/installation-id.test.js

@@ -1,39 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { installationId } from "../services/identity/installation-id.js";
-
-test("an installation id is reused from its state directory", (t) => {
-  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
-  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
-
-  assert.equal(installationId({ stateDir, makeId: () => "first-id" }), "first-id");
-  assert.equal(installationId({ stateDir, makeId: () => "unexpected-id" }), "first-id");
-  assert.deepEqual(JSON.parse(readFileSync(path.join(stateDir, "proxy-identity.json"), "utf8")), { id: "first-id" });
-});
-
-test("an explicit id takes precedence and becomes the saved installation id", (t) => {
-  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
-  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
-
-  assert.equal(installationId({ stateDir, explicitId: " configured-id " }), "configured-id");
-  assert.equal(installationId({ stateDir, makeId: () => "unexpected-id" }), "configured-id");
-});
-
-test("without a state directory the default id stays ephemeral", () => {
-  let calls = 0;
-  const makeId = () => `id-${++calls}`;
-
-  assert.equal(installationId({ makeId }), "id-1");
-  assert.equal(installationId({ makeId }), "id-2");
-});
-
-test("a damaged saved identity is reported instead of silently replaced", (t) => {
-  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
-  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
-  writeFileSync(path.join(stateDir, "proxy-identity.json"), "{}\n");
-
-  assert.throws(() => installationId({ stateDir, makeId: () => "replacement" }), /Invalid proxy identity file/);
-});

package/test/keeping-period.test.js

@@ -1,83 +0,0 @@
-/**
- * @file How long material nobody is using is kept, and where that number comes
- * from.
- *
- * It was three numbers and they contradicted each other: a torrent went at
- * fifteen minutes while the session it feeds lived to thirty, so between them
- * there was a session with no source. All three stand for one unmeasured thing
- * — whether the viewer comes back — so they are one number now, and the thing
- * they stand for is being measured.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { IDLE_KEEP_MS } from "../services/storage/keep.js";
-import { Returns } from "../services/storage/returns.js";
-
-const MINUTE = 60 * 1000;
-
-test("material outlives the session that reads it", () => {
-  // The contradiction this replaced, stated as the rule it must never break
-  // again: whatever holds a source must not go while something that reads it
-  // is still alive. The session's own period is thirty minutes.
-  const SESSION_TTL_MS = 30 * MINUTE;
-  assert.ok(
-    IDLE_KEEP_MS > SESSION_TTL_MS,
-    "a session would outlive its own source again: material is kept " +
-      `${IDLE_KEEP_MS / MINUTE}min against a session's ${SESSION_TTL_MS / MINUTE}min`
-  );
-});
-
-test("one number, and both kinds of material read it", async () => {
-  // Two guesses about one unknown is what produced the contradiction. Asserted
-  // on the source: a second literal period appearing anywhere is the fault
-  // coming back.
-  const { readFileSync } = await import("node:fs");
-  const path = await import("node:path");
-  const { fileURLToPath } = await import("node:url");
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  const read = (relative) => readFileSync(path.join(here, "..", relative), "utf8");
-
-  assert.match(read("services/torrent/torrent-pool.js"), /TORRENT_IDLE_TTL_MS = IDLE_KEEP_MS/);
-  assert.match(read("services/server/OutputLifecycle.js"), /SEGMENT_STORE_IDLE_MS = IDLE_KEEP_MS/);
-});
-
-test("a session opened on material still held is a return, and its age is kept", () => {
-  const returns = new Returns();
-  const now = 10 * 60 * MINUTE;
-
-  returns.note({ lastReadAt: now - 5 * MINUTE, now });
-  returns.note({ lastReadAt: now - 45 * MINUTE, now });
-  returns.note({ lastReadAt: now - 20 * MINUTE, now });
-
-  const shape = returns.shape();
-  assert.equal(shape.warm, 3);
-  assert.equal(shape.cold, 0);
-  assert.equal(shape.medianMs, 20 * MINUTE, "the middle return is not the median");
-  assert.equal(shape.longestMs, 45 * MINUTE);
-});
-
-test("a session opened on material this proxy never had is not a return", () => {
-  const returns = new Returns();
-  const now = 10 * 60 * MINUTE;
-
-  returns.note({ lastReadAt: null, now });
-  returns.note({ lastReadAt: 0, now });
-
-  assert.equal(returns.shape(), null, "an opening with nothing behind it was counted as a return");
-});
-
-test("the reading says what viewers do beside what is being kept", () => {
-  const returns = new Returns();
-  const now = 10 * 60 * MINUTE;
-  assert.equal(returns.describe(IDLE_KEEP_MS), null, "it spoke before it had anything to say");
-
-  returns.note({ lastReadAt: now - 12 * MINUTE, now });
-  returns.note({ lastReadAt: null, now });
-
-  const line = returns.describe(IDLE_KEEP_MS);
-  assert.match(line, /1 session\(s\) opened on material still held/);
-  assert.match(line, /1 on material gone/);
-  assert.match(line, /median 12min after the last read/);
-  assert.match(line, /kept for 60min/);
-});