@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/one-budget.test.js

@@ -1,149 +0,0 @@
-/**
- * @file One budget: one owner, one policy, a share per resource.
- *
- * What it replaced was two owners applying one rule to two readings — memory
- * divided inside the torrent thread, disk divided on the main one, neither able
- * to see the other. The claimants TRADE ACROSS RESOURCES: pieces that do not
- * fit in memory are spilled to disk, so how much memory the piece store is
- * given decides how much disk it needs. Field 2026-08-31: 14 400 MB spilled in
- * fifty minutes while the memory store held 312-424 MB.
- *
- * And "disk" is not one resource. Measured on the addon host 2026-09-05,
- * `/tmp` is the overlay filesystem and `/data` is ext4 on the nvme — two
- * devices, so one figure divided between claimants on both gives each a share
- * of a disk it does not write to.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { MachineBudget } from "../services/storage/MachineBudget.js";
-
-const MEGABYTE = 1024 * 1024;
-
-/**
- * @param {{ name: string, resource: string, held?: number, wanted: number, minimum?: number }} shape
- * @returns {{ claimant: object, allowed: () => number }}
- */
-function claimantOf({ name, resource, held = 0, wanted, minimum }) {
-  let allowed = 0;
-  return {
-    claimant: {
-      name,
-      resource,
-      minimum,
-      held: () => held,
-      wanted: () => wanted,
-      allow: (bytes) => {
-        allowed = bytes;
-      }
-    },
-    allowed: () => allowed
-  };
-}
-
-test("each resource is divided on its own — a share of memory is not a share of disk", async () => {
-  const budget = new MachineBudget({ logger: { info: () => {}, warn: () => {} } });
-  budget.defineResource({ name: "memory", readFree: () => 100 * MEGABYTE });
-  budget.defineResource({ name: "disk:tmp", readFree: () => 10 * MEGABYTE });
-
-  const pieces = claimantOf({ name: "pieces in memory", resource: "memory", wanted: Number.MAX_SAFE_INTEGER });
-  const segments = claimantOf({ name: "segments", resource: "disk:tmp", wanted: Number.MAX_SAFE_INTEGER });
-  budget.register(pieces.claimant);
-  budget.register(segments.claimant);
-
-  await budget.revise();
-
-  assert.equal(pieces.allowed(), 100 * MEGABYTE, "memory is divided from what memory has");
-  assert.equal(segments.allowed(), 10 * MEGABYTE, "and disk from what that disk has");
-});
-
-test("two devices are two resources — one is not cut to pay for the other", async () => {
-  const budget = new MachineBudget({ logger: { info: () => {}, warn: () => {} } });
-  budget.defineResource({ name: "disk:66305", readFree: () => 8 * MEGABYTE });
-  budget.defineResource({ name: "disk:68", readFree: () => 80 * MEGABYTE });
-
-  // The shape on the addon host: segments and spill on the overlay, the
-  // evidence on the nvme.
-  const segments = claimantOf({ name: "segments", resource: "disk:68", wanted: Number.MAX_SAFE_INTEGER });
-  const spill = claimantOf({ name: "spilled pieces", resource: "disk:68", wanted: Number.MAX_SAFE_INTEGER });
-  const evidence = claimantOf({ name: "diagnostics", resource: "disk:66305", wanted: Number.MAX_SAFE_INTEGER });
-  for (const one of [segments, spill, evidence]) {
-    budget.register(one.claimant);
-  }
-
-  await budget.revise();
-
-  assert.equal(evidence.allowed(), 8 * MEGABYTE, "the evidence gets the disk it actually writes to, whole");
-  assert.equal(segments.allowed() + spill.allowed(), 80 * MEGABYTE, "and the other device is divided among its own");
-});
-
-test("a fixed ceiling is the operator's, and it binds", async () => {
-  const budget = new MachineBudget({
-    policy: { kind: "fixed", bytes: 5 * MEGABYTE },
-    logger: { info: () => {}, warn: () => {} }
-  });
-  budget.defineResource({ name: "disk", readFree: () => 1000 * MEGABYTE });
-  const segments = claimantOf({ name: "segments", resource: "disk", wanted: Number.MAX_SAFE_INTEGER });
-  budget.register(segments.claimant);
-
-  await budget.revise();
-
-  assert.equal(segments.allowed(), 5 * MEGABYTE, "a disk with a gigabyte free is still capped at what was asked for");
-});
-
-test("a share of free is the operator's too", async () => {
-  const budget = new MachineBudget({
-    policy: { kind: "share", share: 0.25 },
-    logger: { info: () => {}, warn: () => {} }
-  });
-  budget.defineResource({ name: "disk", readFree: () => 40 * MEGABYTE });
-  const segments = claimantOf({ name: "segments", resource: "disk", held: 0, wanted: Number.MAX_SAFE_INTEGER });
-  budget.register(segments.claimant);
-
-  await budget.revise();
-
-  assert.equal(segments.allowed(), 10 * MEGABYTE);
-});
-
-test("a floor lifts a policy that would allow less, and cannot invent room", async () => {
-  const budget = new MachineBudget({
-    policy: { kind: "fixed", bytes: MEGABYTE, floors: { disk: 6 * MEGABYTE } },
-    logger: { info: () => {}, warn: () => {} }
-  });
-  budget.defineResource({ name: "disk", readFree: () => 4 * MEGABYTE });
-  const segments = claimantOf({ name: "segments", resource: "disk", wanted: Number.MAX_SAFE_INTEGER });
-  budget.register(segments.claimant);
-
-  await budget.revise();
-
-  assert.equal(
-    segments.allowed(),
-    4 * MEGABYTE,
-    "the floor lifts the ceiling above the fixed one, but never past what the machine has"
-  );
-});
-
-test("a resource that cannot be read allows nothing to grow", async () => {
-  const budget = new MachineBudget({ logger: { info: () => {}, warn: () => {} } });
-  budget.defineResource({ name: "disk", readFree: () => null });
-  const segments = claimantOf({ name: "segments", resource: "disk", held: 0, wanted: Number.MAX_SAFE_INTEGER });
-  budget.register(segments.claimant);
-
-  await budget.revise();
-
-  assert.equal(segments.allowed(), 0, "unreadable is not the same as unbounded");
-});
-
-test("a claimant below its own minimum says so", async () => {
-  const said = [];
-  const budget = new MachineBudget({ logger: { info: () => {}, warn: (line) => said.push(line) } });
-  budget.defineResource({ name: "memory", readFree: () => MEGABYTE });
-  budget.register(claimantOf({
-    name: "pieces in memory", resource: "memory", wanted: Number.MAX_SAFE_INTEGER, minimum: 64 * MEGABYTE
-  }).claimant);
-
-  await budget.revise();
-
-  assert.equal(said.length, 1, "working below what it needs is a fault of the machine, and invisible otherwise");
-  assert.match(said[0], /below the 64MB it needs/);
-});

package/test/one-output-one-session.test.js

@@ -1,273 +0,0 @@
-/**
- * @file Many viewers of one output are handed one session.
- *
- * This is the product behaviour the whole output key exists for: two people
- * watching the same film, in the same form, at whatever moments, are served by
- * one encode and one set of pieces. It had no check of any kind — every test
- * that needed a session either built one by hand or replaced
- * `createOrGetSession` with a stub — so the one line that decides it could have
- * been broken by any edit without a word.
- *
- * What is checked here is the decision, not the creation: a session under the
- * name this request produces already exists, and the request must be answered
- * with it rather than with a new one. The name is the format produced, so the
- * request is first taken as far as the format — the file's facts and its
- * keyframe table are given as already known — and making the FIRST session,
- * which reaches the disk, is a different subject.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { AudioOutput, CutGrid, OutputSpec, VideoOutput } from "../services/encode/output/OutputSpec.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import { SourceFile } from "../services/media/SourceFile.js";
-
-const TORRENT = "torrent:11f0929918e2b5aa2e5b71ecdbe5c0f1a4bbf7d1";
-
-/**
- * What a browser asks for: this file, copied, sound inside the stream.
- *
- * @param {object} [over]
- * @returns {object}
- */
-function request(over = {}) {
-  return {
-    sourceKey: TORRENT,
-    fileIndex: 0,
-    fileName: "film.mkv",
-    transcodeVideo: false,
-    transcodeAudio: false,
-    audioTrackIndex: 0,
-    segmentFormatId: "fmp4",
-    ...over
-  };
-}
-
-/**
- * The name the manager will look that request up under, built the way it builds
- * it: a copied picture carrying its own sound, cut at the file's keyframes.
- *
- * @returns {string}
- */
-function specOfThatOutput({ trackIndex = 0, transcode = false } = {}) {
-  return new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    video: new VideoOutput({ fileIndex: 0, encode: null }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex, transcode })
-  });
-}
-
-/** @returns {string} */
-function nameOfThatOutput(sound) {
-  return specOfThatOutput(sound).toName();
-}
-
-/**
- * @param {object} manager
- * @param {{ trackIndex?: number, transcode?: boolean }} [sound] - The soundtrack
- *   the seeded output carries; the file's own, copied, when left out.
- * @returns {object} The session it is seeded with.
- */
-function seedOneSession(manager, sound = {}) {
-  const session = {
-    id: nameOfThatOutput(sound),
-    spec: specOfThatOutput(sound),
-    // Its own address, so two seeded outputs are two places for viewers.
-    outputKey: specOfThatOutput(sound).toKey(),
-    state: "ready",
-    file: new SourceFile({ sourceKey: TORRENT, fileIndex: 0, name: "film.mkv" }),
-    timeline: new Timeline({ boundaries: [0, 4, 8], cutGrid: "keyframe" }),
-    runs: new Set(),
-    progress: { processedSeconds: 0, startPositionSeconds: 0, updatedAt: Date.now() },
-    lastAccessedAt: Date.now(),
-    // READY, because a joining viewer waits for the session to be able to
-    // answer them, and this file is about which session answers rather than
-    // about that wait. A session publishing its own playlist from the probed
-    // duration has nothing to wait for; left out, every check here would sit
-    // out the warm-up deadline and would be measuring that timer.
-    useSyntheticPlaylist: true
-  };
-  manager.outputs.set(session.id, session);
-  return session;
-}
-
-/**
- * What the proxy already knows about the file when a second viewer arrives:
- * what a probe said, and where its keyframes are.
- *
- * @param {object} manager
- */
-function knownFile(manager) {
-  // This check exercises output identity. Machine admission has its own tests.
-  manager.admission.admitsWatching = () => ({ admitted: true, reason: "", speedX: 8 });
-  manager.admission.previewCandidate = () => ({ admitted: true, reason: "", speedX: 8 });
-  manager.getCachedMediaInfo = () => ({ durationSeconds: 8, width: 1920, height: 1080, fps: 24 });
-  // The soundtracks the plan listed: the file's own, at the rate it states, and
-  // a dub beside it that states nothing — which no link can be asked about as a
-  // copy, so it is sent re-encoded.
-  manager.getCachedAudioTracks = () => [
-    { index: 0, fileIndex: 0, sourceTrackIndex: 0, bitrateKbps: 128 },
-    { index: 1, fileIndex: 0, sourceTrackIndex: 1, bitrateKbps: null, peakKbps: null }
-  ];
-  manager.keyframeTables.learn({ sourceKey: TORRENT, fileIndex: 0 }, { times: [0, 4], format: "test" });
-}
-
-test("a second viewer of one output is served by the session that exists", async (t) => {
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  t.after(() => manager.lifecycle.disposeAll());
-  // No plan runs here: this file is about which session answers a request, and
-  // placing encoders would spawn real processes.
-  manager.encodeRuns.planEncodersNow = () => {};
-  manager.encodeRuns.planEncodersSoon = () => {};
-  knownFile(manager);
-  const seeded = seedOneSession(manager);
-
-  const answered = await manager.viewerRequests.createOrGetSession(request({ consumerId: "viewer-two" }));
-
-  assert.equal(answered, seeded, "one output, one session");
-  assert.ok(manager.viewers.forOutput(seeded).has("viewer-two"), "and the second viewer is on it");
-});
-
-test("a request whose parameters differ is not that session", async (t) => {
-  // The other half, and it is what makes the first mean anything: the name is
-  // the output's, so a request producing something else must not find it. Here
-  // the sound is to be re-encoded, which is a different output and a different
-  // set of bytes.
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    // A session made for real here waits for a playlist that nothing is going
-    // to write. Zero, so this check spends no time on a deadline it is not
-    // about — the deadline has its own subject elsewhere.
-    startupWaitMs: 0
-  });
-  t.after(() => manager.lifecycle.disposeAll());
-  manager.encodeRuns.planEncodersNow = () => {};
-  manager.encodeRuns.planEncodersSoon = () => {};
-  const seeded = seedOneSession(manager);
-
-  let answered = null;
-  try {
-    answered = await manager.viewerRequests.createOrGetSession(request({ consumerId: "viewer-two", transcodeAudio: true }));
-  } catch {
-    // Making a session for real needs a probe and a disk, which this file does
-    // not give it. Failing there is the proof: it did not take the seeded one.
-    answered = null;
-  }
-
-  assert.notEqual(answered, seeded);
-  assert.ok(!manager.viewers.forOutput(seeded).has("viewer-two"), "and nobody was added to somebody else's output");
-});
-
-test("two screens that come to the same format share one output, and a different format does not", async (t) => {
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    startupWaitMs: 0,
-    // A host with no ladder to choose from: the box asked for, fitted to the
-    // source, is what is produced.
-    videoEncoder: { kind: "vaapi", name: "h264_vaapi", inputArgs: [] }
-  });
-  t.after(() => manager.lifecycle.disposeAll());
-  manager.encodeRuns.planEncodersNow = () => {};
-  manager.encodeRuns.planEncodersSoon = () => {};
-  knownFile(manager);
-  const spec = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
-    video: new VideoOutput({
-      fileIndex: 0,
-      encode: { encoder: "h264_vaapi", width: 1920, height: 1080, fps: 24, preset: null, tonemap: false }
-    }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: false })
-  });
-  const seeded = { ...seedOneSession(manager), id: spec.toName(), spec, timeline: new Timeline({ boundaries: [0, 4, 8], cutGrid: "uniform" }) };
-  manager.outputs.delete(nameOfThatOutput());
-  manager.outputs.set(seeded.id, seeded);
-
-  // A taller window than the film: fitted to the source it is the same 1920x1080.
-  const joined = await manager.viewerRequests.createOrGetSession(
-    request({ consumerId: "tall-window", transcodeVideo: true, targetWidth: 1920, targetHeight: 1200 })
-  );
-  assert.equal(joined, seeded, "the key names the format produced, not the window it was asked for");
-
-  let other = null;
-  try {
-    other = await manager.viewerRequests.createOrGetSession(
-      request({ consumerId: "small-window", transcodeVideo: true, targetWidth: 1280, targetHeight: 720 })
-    );
-  } catch {
-    other = null;
-  }
-  assert.notEqual(other, seeded, "a smaller picture is another output");
-  assert.ok(!manager.viewers.forOutput(seeded).has("small-window"));
-});
-
-test("a remembered dub with no stated rate opens on the output that sends it as AAC, not on its copy", async (t) => {
-  // The field case of 2026-10-01: the next episode opened on a dub the page
-  // remembered, which its browser plays as it stands and nothing states a rate
-  // for. Opened as a copy, no link could be asked about it and the episode was
-  // refused; it is the AAC output that answers.
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    // A measured copy speed, so this machine can price the output and the
-    // admission answers on room rather than on knowing nothing.
-    copySpeedX: 20
-  });
-  t.after(() => manager.lifecycle.disposeAll());
-  manager.encodeRuns.planEncodersNow = () => {};
-  manager.encodeRuns.planEncodersSoon = () => {};
-  knownFile(manager);
-  const copied = seedOneSession(manager, { trackIndex: 1, transcode: false });
-  const encoded = seedOneSession(manager, { trackIndex: 1, transcode: true });
-
-  const answered = await manager.viewerRequests.createOrGetSession(
-    request({ consumerId: "viewer-two", audioTrackIndex: 1, transcodeAudio: false })
-  );
-
-  assert.equal(answered, encoded, "the dub is re-encoded");
-  assert.notEqual(answered, copied);
-  assert.deepEqual(
-    manager.renditions.soundtrackOf(answered, "viewer-two"),
-    { trackIndex: 1, transcode: true },
-    "and the viewer is recorded as receiving AAC"
-  );
-});
-
-test("a track whose rate is stated is still copied for a browser that plays it", async (t) => {
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    // A measured copy speed, so this machine can price the output and the
-    // admission answers on room rather than on knowing nothing.
-    copySpeedX: 20
-  });
-  t.after(() => manager.lifecycle.disposeAll());
-  manager.encodeRuns.planEncodersNow = () => {};
-  manager.encodeRuns.planEncodersSoon = () => {};
-  knownFile(manager);
-  const copied = seedOneSession(manager);
-  seedOneSession(manager, { trackIndex: 0, transcode: true });
-
-  const answered = await manager.viewerRequests.createOrGetSession(request({ consumerId: "viewer-two" }));
-
-  assert.equal(answered, copied);
-});

package/test/one-resource-divided.test.js

@@ -1,185 +0,0 @@
-/**
- * @file One disk, one owner, three claimants.
- *
- * What these pin is the thing that was wrong: each consumer read the free space
- * as though it were alone, so three ceilings each stood for the whole disk.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { MachineBudget } from "../services/storage/MachineBudget.js";
-
-const MEGABYTE = 1024 * 1024;
-
-/**
- * @param {string} name
- * @param {number} held
- * @param {number} wanted
- */
-function consumerOf(name, held, wanted) {
-  const state = { allowed: -1 };
-  return {
-    state,
-    consumer: {
-      name,
-      held: () => held,
-      wanted: () => wanted,
-      allow: (bytes) => {
-        state.allowed = bytes;
-      }
-    }
-  };
-}
-
-/**
- * A budget over ONE resource, which is what this file is about: the division
- * itself, with the several-resources question asked in `one-budget.test.js`.
- *
- * @param {{ readFree: () => Promise<number | null>, logger?: object }} params
- */
-function diskOf({ readFree, logger }) {
-  const budget = new MachineBudget({ logger });
-  budget.defineResource({ name: "disk", readFree });
-  return {
-    register: (consumer) => budget.register({ ...consumer, resource: "disk" }),
-    forget: (name) => budget.forget(name),
-    describe: () => budget.describe(),
-    revise: async () => {
-      const readings = await budget.revise();
-      return readings.get("disk") ?? { freeBytes: 0, allowanceBytes: 0, shares: [] };
-    }
-  };
-}
-
-test("what everyone may hold together never exceeds what the disk has", async () => {
-  const free = 100 * MEGABYTE;
-  const space = diskOf({ readFree: async () => free });
-  const segments = consumerOf("segments", 10 * MEGABYTE, 1000 * MEGABYTE);
-  const pieces = consumerOf("pieces", 20 * MEGABYTE, 1000 * MEGABYTE);
-  const diagnostics = consumerOf("diagnostics", 5 * MEGABYTE, 1000 * MEGABYTE);
-  space.register(segments.consumer);
-  space.register(pieces.consumer);
-  space.register(diagnostics.consumer);
-
-  const { allowanceBytes } = await space.revise();
-
-  const together = segments.state.allowed + pieces.state.allowed + diagnostics.state.allowed;
-  assert.ok(together <= allowanceBytes, "the shares add up to more than the allowance");
-  // Free space plus what they already hold: that pair is the ceiling they could
-  // reach, which is the same statement the memory allowance makes.
-  assert.equal(allowanceBytes, free + 35 * MEGABYTE);
-  assert.ok(
-    together <= free + 35 * MEGABYTE,
-    "three consumers were between them allowed more than the disk has"
-  );
-});
-
-test("when everyone's ask fits, everyone gets it and the disk never binds", async () => {
-  const space = diskOf({ readFree: async () => 1000 * MEGABYTE });
-  const small = consumerOf("diagnostics", 0, 5 * MEGABYTE);
-  const large = consumerOf("segments", 0, 500 * MEGABYTE);
-  space.register(small.consumer);
-  space.register(large.consumer);
-
-  await space.revise();
-
-  assert.equal(small.state.allowed, 5 * MEGABYTE);
-  assert.equal(large.state.allowed, 500 * MEGABYTE);
-});
-
-test("when they do not fit, each is cut in proportion to what it asked", async () => {
-  // The same rule memory divides by, and the same reason: a share taken from
-  // whoever asked most would hand the disk to whoever grew fastest.
-  const space = diskOf({ readFree: async () => 200 * MEGABYTE });
-  const modest = consumerOf("diagnostics", 0, 100 * MEGABYTE);
-  const greedy = consumerOf("segments", 0, 300 * MEGABYTE);
-  space.register(modest.consumer);
-  space.register(greedy.consumer);
-
-  await space.revise();
-
-  assert.equal(modest.state.allowed, 50 * MEGABYTE);
-  assert.equal(greedy.state.allowed, 150 * MEGABYTE);
-  assert.equal(modest.state.allowed + greedy.state.allowed, 200 * MEGABYTE);
-});
-
-test("a disk that fills lowers every share, rather than keeping one taken when it was empty", async () => {
-  let free = 1000 * MEGABYTE;
-  const space = diskOf({ readFree: async () => free });
-  const segments = consumerOf("segments", 0, 10_000 * MEGABYTE);
-  const pieces = consumerOf("pieces", 0, 10_000 * MEGABYTE);
-  space.register(segments.consumer);
-  space.register(pieces.consumer);
-
-  await space.revise();
-  const roomy = segments.state.allowed;
-
-  free = 40 * MEGABYTE;
-  await space.revise();
-
-  assert.ok(segments.state.allowed < roomy, "the share did not follow the disk down");
-  assert.ok(pieces.state.allowed < roomy, "the other share did not follow either");
-});
-
-test("what another process took is left for it, not spent", async () => {
-  // Between two readings the disk lost 400 MB that none of our consumers took.
-  // That is a measurement of somebody else's demand, and it is what the next
-  // allowance leaves alone.
-  let free = 1000 * MEGABYTE;
-  const space = diskOf({ readFree: async () => free });
-  const only = consumerOf("segments", 0, 10_000 * MEGABYTE);
-  space.register(only.consumer);
-
-  await space.revise();
-  free = 600 * MEGABYTE;
-  const { allowanceBytes } = await space.revise();
-
-  assert.equal(allowanceBytes, 200 * MEGABYTE, "the fall we did not cause was spent anyway");
-});
-
-test("a disk that cannot be read allows nothing to grow", async () => {
-  const space = diskOf({ readFree: async () => null });
-  const segments = consumerOf("segments", 0, 500 * MEGABYTE);
-  space.register(segments.consumer);
-
-  const { freeBytes, allowanceBytes } = await space.revise();
-
-  assert.equal(freeBytes, 0);
-  assert.equal(allowanceBytes, 0);
-  assert.equal(segments.state.allowed, 0, "an unreadable disk was treated as an empty one");
-});
-
-test("it says what the disk has and what each claimant may hold", async () => {
-  const space = diskOf({ readFree: async () => 100 * MEGABYTE });
-  assert.match(space.describe(), /nothing has claimed/);
-  space.register(consumerOf("segments", 4 * MEGABYTE, 8 * MEGABYTE).consumer);
-  await space.revise();
-  assert.match(space.describe(), /disk: 100MB free; segments 4MB of 8MB/);
-});
-
-test("it says what it decided, every pass", async () => {
-  const lines = [];
-  const space = diskOf({
-    readFree: async () => 100 * MEGABYTE,
-    logger: { info: (line) => lines.push(line) }
-  });
-  space.register(consumerOf("segments", 4 * MEGABYTE, 8 * MEGABYTE).consumer);
-  await space.revise();
-  assert.equal(lines.length, 1, "a pass that decided the shares said nothing about them");
-  assert.match(lines[0], /disk: 100MB free; segments 4MB of 8MB/);
-});
-
-test("the free space is read from the nearest directory that exists", async () => {
-  // The segments' directory is made when the first session starts and removed
-  // when the proxy stops, so at every start `statfs` on it fails. Field
-  // 2026-09-10: the first reading said `disk: 0MB free` on a host with 103 GB,
-  // and zero means "no room" to everything that reads it.
-  const { freeBytesFor } = await import("../services/storage/free.js");
-  const os = await import("node:os");
-  const path = await import("node:path");
-  const missing = path.join(os.tmpdir(), "no-such-directory-here", "nor-here");
-
-  const bytes = await freeBytesFor(missing);
-
-  assert.ok(Number.isFinite(bytes) && bytes > 0, "a directory that does not exist read as no disk");
-});