@torrent-tv/proxy 2.89.7 → 2.89.8

package/test/drain-threat.test.js

@@ -1,65 +1,65 @@
-/**
- * @file When a move to a smaller output is prepared for a viewer, and when it is
- * not (roadmap item 98), and which way their buffer is going.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { drainThreat } from "../services/encode/quality/drain-threat.js";
-import { bufferTrend } from "../services/viewer/buffer-trend.js";
-
-test("a buffer that falls but lasts past the new piece's readiness moves nothing", () => {
-  // 60 s held, draining at 0.5 s/s: empty in 120 s. The new output would have
-  // the piece in 8 s, and the next report comes in 10 s.
-  const answer = drainThreat({ bufferedSec: 60, slope: -0.5, reportGapSec: 10, secondsToReady: 8 });
-  assert.equal(answer.threat, false);
-  assert.equal(answer.secondsToEmpty, 120);
-});
-
-test("a buffer that would end before the new piece is ready starts the move", () => {
-  // 6 s held, draining at 0.5 s/s: empty in 12 s — sooner than 8 s of making
-  // plus the 10 s until this viewer is heard from again.
-  assert.equal(drainThreat({ bufferedSec: 6, slope: -0.5, reportGapSec: 10, secondsToReady: 8 }).threat, true);
-});
-
-test("the wait for the next report is part of the reckoning", () => {
-  const without = drainThreat({ bufferedSec: 10, slope: -1, reportGapSec: 0, secondsToReady: 8 });
-  const withGap = drainThreat({ bufferedSec: 10, slope: -1, reportGapSec: 3, secondsToReady: 8 });
-  assert.equal(without.threat, false, "10 s left against 8 s of making");
-  assert.equal(withGap.threat, true, "but the next chance to act is 3 s away, too late");
-});
-
-test("a buffer that holds or grows is no threat, and neither is one with no trend yet", () => {
-  assert.equal(drainThreat({ bufferedSec: 1, slope: 0, reportGapSec: 10, secondsToReady: 30 }).threat, false);
-  assert.equal(drainThreat({ bufferedSec: 1, slope: 0.4, reportGapSec: 10, secondsToReady: 30 }).threat, false);
-  assert.equal(drainThreat({ bufferedSec: 1, slope: null, reportGapSec: 10, secondsToReady: 30 }).threat, false);
-});
-
-test("a readiness nobody can state is not assumed to be quick", () => {
-  assert.equal(drainThreat({ bufferedSec: 600, slope: -0.1, reportGapSec: 10, secondsToReady: null }).threat, true);
-});
-
-test("the trend is read over one segment's period, not from two readings", () => {
-  // A sawtooth over a flat line: a 4 s segment arrives, then 4 s play out.
-  const at = (seconds) => seconds * 1000;
-  const flat = [
-    { at: at(0), seconds: 20 },
-    { at: at(2), seconds: 18 },
-    { at: at(4), seconds: 20 },
-    { at: at(6), seconds: 18 },
-    { at: at(8), seconds: 20 }
-  ];
-  const trend = bufferTrend(flat, 4);
-  assert.ok(Math.abs(trend.slope) < 0.5, `the last two readings alone say +1 s/s; the period says ${trend.slope}`);
-  assert.equal(trend.reportGapSec, 2);
-});
-
-test("readings that do not yet span one segment say nothing", () => {
-  assert.equal(bufferTrend([{ at: 0, seconds: 10 }, { at: 1000, seconds: 9 }], 4), null);
-  assert.equal(bufferTrend([{ at: 0, seconds: 10 }], 4), null);
-});
-
-test("a steady drain reads as the rate it drains at", () => {
-  const readings = [0, 5, 10].map((second) => ({ at: second * 1000, seconds: 30 - second }));
-  assert.equal(bufferTrend(readings, 4).slope, -1);
-});
+/**
+ * @file When a move to a smaller output is prepared for a viewer, and when it is
+ * not (roadmap item 98), and which way their buffer is going.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { drainThreat } from "../services/encode/quality/drain-threat.js";
+import { bufferTrend } from "../services/viewer/buffer-trend.js";
+
+test("a buffer that falls but lasts past the new piece's readiness moves nothing", () => {
+  // 60 s held, draining at 0.5 s/s: empty in 120 s. The new output would have
+  // the piece in 8 s, and the next report comes in 10 s.
+  const answer = drainThreat({ bufferedSec: 60, slope: -0.5, reportGapSec: 10, secondsToReady: 8 });
+  assert.equal(answer.threat, false);
+  assert.equal(answer.secondsToEmpty, 120);
+});
+
+test("a buffer that would end before the new piece is ready starts the move", () => {
+  // 6 s held, draining at 0.5 s/s: empty in 12 s — sooner than 8 s of making
+  // plus the 10 s until this viewer is heard from again.
+  assert.equal(drainThreat({ bufferedSec: 6, slope: -0.5, reportGapSec: 10, secondsToReady: 8 }).threat, true);
+});
+
+test("the wait for the next report is part of the reckoning", () => {
+  const without = drainThreat({ bufferedSec: 10, slope: -1, reportGapSec: 0, secondsToReady: 8 });
+  const withGap = drainThreat({ bufferedSec: 10, slope: -1, reportGapSec: 3, secondsToReady: 8 });
+  assert.equal(without.threat, false, "10 s left against 8 s of making");
+  assert.equal(withGap.threat, true, "but the next chance to act is 3 s away, too late");
+});
+
+test("a buffer that holds or grows is no threat, and neither is one with no trend yet", () => {
+  assert.equal(drainThreat({ bufferedSec: 1, slope: 0, reportGapSec: 10, secondsToReady: 30 }).threat, false);
+  assert.equal(drainThreat({ bufferedSec: 1, slope: 0.4, reportGapSec: 10, secondsToReady: 30 }).threat, false);
+  assert.equal(drainThreat({ bufferedSec: 1, slope: null, reportGapSec: 10, secondsToReady: 30 }).threat, false);
+});
+
+test("a readiness nobody can state is not assumed to be quick", () => {
+  assert.equal(drainThreat({ bufferedSec: 600, slope: -0.1, reportGapSec: 10, secondsToReady: null }).threat, true);
+});
+
+test("the trend is read over one segment's period, not from two readings", () => {
+  // A sawtooth over a flat line: a 4 s segment arrives, then 4 s play out.
+  const at = (seconds) => seconds * 1000;
+  const flat = [
+    { at: at(0), seconds: 20 },
+    { at: at(2), seconds: 18 },
+    { at: at(4), seconds: 20 },
+    { at: at(6), seconds: 18 },
+    { at: at(8), seconds: 20 }
+  ];
+  const trend = bufferTrend(flat, 4);
+  assert.ok(Math.abs(trend.slope) < 0.5, `the last two readings alone say +1 s/s; the period says ${trend.slope}`);
+  assert.equal(trend.reportGapSec, 2);
+});
+
+test("readings that do not yet span one segment say nothing", () => {
+  assert.equal(bufferTrend([{ at: 0, seconds: 10 }, { at: 1000, seconds: 9 }], 4), null);
+  assert.equal(bufferTrend([{ at: 0, seconds: 10 }], 4), null);
+});
+
+test("a steady drain reads as the rate it drains at", () => {
+  const readings = [0, 5, 10].map((second) => ({ at: second * 1000, seconds: 30 - second }));
+  assert.equal(bufferTrend(readings, 4).slope, -1);
+});

package/test/duplicate-add.test.js

@@ -1,48 +1,48 @@
-/**
- * @file One infohash, two sources: what happens when the second add is refused.
- *
- * The same film arrives as a magnet and as a `.torrent`. WebTorrent refuses the
- * second add — one infohash, one torrent — and the pool then has to decide what
- * to hand back. Adopting the one already there is right when it is ready, and
- * wrong when it is not: a magnet whose swarm has not answered has no file list,
- * so everything bound to it is answered 404.
- *
- * Measured 2026-08-15 on the addon host: a magnet with no reachable trackers
- * was added first and never became ready; the same film's own `.torrent`, which
- * carries the file list, the piece hashes and the trackers, then joined that
- * empty torrent instead of replacing it. `/stream` answered 404, the encoder
- * died on its first read, and the film stayed unplayable until the proxy was
- * restarted — one bad magnet poisoning every later attempt at that infohash.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { duplicateAddDecision } from "../services/torrent/torrent-pool.js";
-
-test("a ready torrent is adopted, whatever the new source carries", () => {
-  assert.equal(
-    duplicateAddDecision({ existingIsReady: true, incomingHasMetadata: true }),
-    "adopt",
-    "one swarm per infohash: a second copy would download the same pieces twice"
-  );
-  assert.equal(
-    duplicateAddDecision({ existingIsReady: true, incomingHasMetadata: false }),
-    "adopt"
-  );
-});
-
-test("an unready torrent is replaced when this add brings the metadata", () => {
-  assert.equal(
-    duplicateAddDecision({ existingIsReady: false, incomingHasMetadata: true }),
-    "replace",
-    "the .torrent holds what the swarm was being asked for; waiting for it is waiting for nothing"
-  );
-});
-
-test("two magnets wait, because neither has anything the other lacks", () => {
-  assert.equal(
-    duplicateAddDecision({ existingIsReady: false, incomingHasMetadata: false }),
-    "wait",
-    "replacing here would only restart the same search, and the caller's own bound answers"
-  );
-});
+/**
+ * @file One infohash, two sources: what happens when the second add is refused.
+ *
+ * The same film arrives as a magnet and as a `.torrent`. WebTorrent refuses the
+ * second add — one infohash, one torrent — and the pool then has to decide what
+ * to hand back. Adopting the one already there is right when it is ready, and
+ * wrong when it is not: a magnet whose swarm has not answered has no file list,
+ * so everything bound to it is answered 404.
+ *
+ * Measured 2026-08-15 on the addon host: a magnet with no reachable trackers
+ * was added first and never became ready; the same film's own `.torrent`, which
+ * carries the file list, the piece hashes and the trackers, then joined that
+ * empty torrent instead of replacing it. `/stream` answered 404, the encoder
+ * died on its first read, and the film stayed unplayable until the proxy was
+ * restarted — one bad magnet poisoning every later attempt at that infohash.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { duplicateAddDecision } from "../services/torrent/torrent-pool.js";
+
+test("a ready torrent is adopted, whatever the new source carries", () => {
+  assert.equal(
+    duplicateAddDecision({ existingIsReady: true, incomingHasMetadata: true }),
+    "adopt",
+    "one swarm per infohash: a second copy would download the same pieces twice"
+  );
+  assert.equal(
+    duplicateAddDecision({ existingIsReady: true, incomingHasMetadata: false }),
+    "adopt"
+  );
+});
+
+test("an unready torrent is replaced when this add brings the metadata", () => {
+  assert.equal(
+    duplicateAddDecision({ existingIsReady: false, incomingHasMetadata: true }),
+    "replace",
+    "the .torrent holds what the swarm was being asked for; waiting for it is waiting for nothing"
+  );
+});
+
+test("two magnets wait, because neither has anything the other lacks", () => {
+  assert.equal(
+    duplicateAddDecision({ existingIsReady: false, incomingHasMetadata: false }),
+    "wait",
+    "replacing here would only restart the same search, and the caller's own bound answers"
+  );
+});

package/test/encode-admission.test.js

@@ -1,146 +1,146 @@
-/**
- * @file Whether the whole machine has a place for one more encoder (roadmap
- * item 97, step 13).
- *
- * What is pinned here:
- *
- * 1. a place is held by an OUTPUT: two preparations onto one output take one
- *    place, and the second is admitted without arithmetic;
- * 2. two preparations onto two DIFFERENT outputs with room for one: the first
- *    is admitted, the second refused, because it is asked after the first is
- *    recorded;
- * 3. one of two viewers giving up a preparation of one output does not free
- *    its place;
- * 4. the cost is what an encoder costs, not a count of processes: a picture
- *    and its soundtrack fit where two pictures do not — the addon host's own
- *    figures, 1080p alone at 1.96x;
- * 5. an admitted encoder is never taken away: the machine's answer is never
- *    below what already runs, nor below one for an output a preparation holds;
- * 6. a new output on a full machine is given no encoder.
- *
- * The records of who is being prepared are stood in for by a set the check
- * writes to, which is what the viewers' records are read as.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EncodeAdmission } from "../services/encode/EncodeAdmission.js";
-
-// 1080p re-encoded on the addon host: 1.96x alone.
-const PICTURE_1080 = 1 / 1.96;
-// A re-encoded soundtrack: a small fraction of a picture.
-const SOUNDTRACK = 0.02;
-
-/**
- * A machine with the outputs named, their costs, what runs and who is being
- * prepared onto what.
- *
- * @param {{ costs: Record<string, number | null>, running?: Record<string, number>, share?: number | null }} how
- */
-function machine(how) {
-  const running = new Map(Object.entries(how.running ?? {}));
-  /** Output address to the viewers being prepared onto it. @type {Map<string, Set<string>>} */
-  const preparing = new Map();
-  const admission = new EncodeAdmission({
-    liveRunsByAddress: () => new Map([...running].filter(([, count]) => count > 0)),
-    preparedAddresses: () => new Set([...preparing].filter(([, viewers]) => viewers.size > 0).map(([address]) => address)),
-    loadOf: (address) => (address in how.costs ? { costSec: how.costs[address], fileKey: "", fileCostSec: 0 } : null),
-    availability: () => (how.share === undefined || how.share === null ? null : { share: how.share, known: true })
-  });
-  return {
-    admission,
-    running,
-    /** A viewer's preparation recorded, as `Viewer` records it. */
-    prepare: (address, viewer) => {
-      const viewers = preparing.get(address) ?? new Set();
-      viewers.add(viewer);
-      preparing.set(address, viewers);
-    },
-    /** A viewer's preparation ended, on whichever path. */
-    giveUp: (address, viewer) => preparing.get(address)?.delete(viewer)
-  };
-}
-
-test("two preparations onto one output take one place", () => {
-  const { admission, prepare } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 } });
-  assert.equal(admission.admitsPreparation("a").admitted, true);
-  prepare("a", "viewer-1");
-  const second = admission.admitsPreparation("a");
-  assert.equal(second.admitted, true, "the second viewer shares the place");
-  assert.match(second.reason, /already holds a place/);
-});
-
-test("two preparations onto two different outputs with room for one: the second is refused", () => {
-  const { admission, prepare } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 } });
-  // The first is asked and recorded in one stretch, as the preparation does it.
-  assert.equal(admission.admitsPreparation("a").admitted, true);
-  prepare("a", "viewer-1");
-  const second = admission.admitsPreparation("b");
-  assert.equal(second.admitted, false, "both together would make 0.98x of each");
-  assert.ok(second.speedX < 1);
-});
-
-test("one of two viewers giving up a preparation of one output does not free its place", () => {
-  const { admission, prepare, giveUp } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 } });
-  prepare("a", "viewer-1");
-  prepare("a", "viewer-2");
-  giveUp("a", "viewer-1");
-  assert.equal(admission.admitsPreparation("b").admitted, false, "viewer-2 still holds the place on a");
-  assert.equal(admission.placesFor("a", 0).runs, 1, "and a keeps its encoder's place");
-  giveUp("a", "viewer-2");
-  assert.equal(admission.admitsPreparation("b").admitted, true, "the place ends with the last record");
-});
-
-test("a picture and its soundtrack fit where two pictures do not", () => {
-  const { admission } = machine({
-    costs: { picture: PICTURE_1080, sound: SOUNDTRACK, other: PICTURE_1080 },
-    running: { picture: 1 }
-  });
-  assert.equal(admission.admitsPreparation("sound").admitted, true, "0.53 s/s makes 1.89x");
-  assert.equal(admission.placesFor("sound", 0).runs >= 1, true);
-  assert.equal(admission.admitsPreparation("other").admitted, false, "1.02 s/s makes 0.98x");
-});
-
-test("an admitted encoder is never taken away, and a held place is kept", () => {
-  const { admission } = machine({
-    costs: { a: PICTURE_1080, b: PICTURE_1080 },
-    running: { a: 1, b: 1 }
-  });
-  assert.equal(admission.placesFor("a", 1).runs, 1, "both running: each keeps its one");
-  assert.equal(admission.placesFor("b", 1).runs, 1);
-  const { admission: held, prepare: prepareHeld } = machine({
-    costs: { a: PICTURE_1080, b: PICTURE_1080 },
-    running: { b: 1 }
-  });
-  prepareHeld("a", "viewer-1");
-  assert.equal(held.placesFor("a", 0).runs, 1, "a place promised to a preparation is not withdrawn");
-});
-
-test("a new output on a full machine is given no encoder", () => {
-  const { admission } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 }, running: { a: 1 } });
-  assert.equal(admission.placesFor("b", 0).runs, 0);
-});
-
-test("the share of the machine nobody has priced is taken off what there is", () => {
-  // 0.6 s/s alone makes 1.67x; with a third of the machine taken by work
-  // nobody priced it makes 1.11x, and a soundtrack beside it still fits.
-  const quiet = machine({ costs: { a: 0.6, b: 0.4 }, share: 1 });
-  assert.equal(quiet.admission.admitsPreparation("a").admitted, true);
-  const busy = machine({ costs: { a: 0.6, b: 0.4 }, running: { a: 1 }, share: 0.6 });
-  assert.equal(busy.admission.admitsPreparation("b").admitted, false, "1.0 s/s at 0.6 of the machine makes 0.6x");
-});
-
-test("an output with no measured cost is not admitted", () => {
-  const { admission } = machine({ costs: { a: PICTURE_1080, b: null }, running: { a: 1 } });
-  const answer = admission.admitsPreparation("b");
-  assert.equal(answer.admitted, false);
-  assert.match(answer.reason, /no measured encoding cost/);
-});
-
-test("unpriced occupied work is neither spare pool headroom nor capacity for another output", () => {
-  const { admission } = machine({ costs: { a: null, b: PICTURE_1080 }, running: { a: 1 } });
-  assert.equal(admission.headroom().encodeSpeedX, 0, "the pool sees no confirmed room");
-  const answer = admission.admitsPreparation("b");
-  assert.equal(answer.admitted, false);
-  assert.match(answer.reason, /capacity is unknown/);
-});
+/**
+ * @file Whether the whole machine has a place for one more encoder (roadmap
+ * item 97, step 13).
+ *
+ * What is pinned here:
+ *
+ * 1. a place is held by an OUTPUT: two preparations onto one output take one
+ *    place, and the second is admitted without arithmetic;
+ * 2. two preparations onto two DIFFERENT outputs with room for one: the first
+ *    is admitted, the second refused, because it is asked after the first is
+ *    recorded;
+ * 3. one of two viewers giving up a preparation of one output does not free
+ *    its place;
+ * 4. the cost is what an encoder costs, not a count of processes: a picture
+ *    and its soundtrack fit where two pictures do not — the addon host's own
+ *    figures, 1080p alone at 1.96x;
+ * 5. an admitted encoder is never taken away: the machine's answer is never
+ *    below what already runs, nor below one for an output a preparation holds;
+ * 6. a new output on a full machine is given no encoder.
+ *
+ * The records of who is being prepared are stood in for by a set the check
+ * writes to, which is what the viewers' records are read as.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EncodeAdmission } from "../services/encode/EncodeAdmission.js";
+
+// 1080p re-encoded on the addon host: 1.96x alone.
+const PICTURE_1080 = 1 / 1.96;
+// A re-encoded soundtrack: a small fraction of a picture.
+const SOUNDTRACK = 0.02;
+
+/**
+ * A machine with the outputs named, their costs, what runs and who is being
+ * prepared onto what.
+ *
+ * @param {{ costs: Record<string, number | null>, running?: Record<string, number>, share?: number | null }} how
+ */
+function machine(how) {
+  const running = new Map(Object.entries(how.running ?? {}));
+  /** Output address to the viewers being prepared onto it. @type {Map<string, Set<string>>} */
+  const preparing = new Map();
+  const admission = new EncodeAdmission({
+    liveRunsByAddress: () => new Map([...running].filter(([, count]) => count > 0)),
+    preparedAddresses: () => new Set([...preparing].filter(([, viewers]) => viewers.size > 0).map(([address]) => address)),
+    loadOf: (address) => (address in how.costs ? { costSec: how.costs[address], fileKey: "", fileCostSec: 0 } : null),
+    availability: () => (how.share === undefined || how.share === null ? null : { share: how.share, known: true })
+  });
+  return {
+    admission,
+    running,
+    /** A viewer's preparation recorded, as `Viewer` records it. */
+    prepare: (address, viewer) => {
+      const viewers = preparing.get(address) ?? new Set();
+      viewers.add(viewer);
+      preparing.set(address, viewers);
+    },
+    /** A viewer's preparation ended, on whichever path. */
+    giveUp: (address, viewer) => preparing.get(address)?.delete(viewer)
+  };
+}
+
+test("two preparations onto one output take one place", () => {
+  const { admission, prepare } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 } });
+  assert.equal(admission.admitsPreparation("a").admitted, true);
+  prepare("a", "viewer-1");
+  const second = admission.admitsPreparation("a");
+  assert.equal(second.admitted, true, "the second viewer shares the place");
+  assert.match(second.reason, /already holds a place/);
+});
+
+test("two preparations onto two different outputs with room for one: the second is refused", () => {
+  const { admission, prepare } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 } });
+  // The first is asked and recorded in one stretch, as the preparation does it.
+  assert.equal(admission.admitsPreparation("a").admitted, true);
+  prepare("a", "viewer-1");
+  const second = admission.admitsPreparation("b");
+  assert.equal(second.admitted, false, "both together would make 0.98x of each");
+  assert.ok(second.speedX < 1);
+});
+
+test("one of two viewers giving up a preparation of one output does not free its place", () => {
+  const { admission, prepare, giveUp } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 } });
+  prepare("a", "viewer-1");
+  prepare("a", "viewer-2");
+  giveUp("a", "viewer-1");
+  assert.equal(admission.admitsPreparation("b").admitted, false, "viewer-2 still holds the place on a");
+  assert.equal(admission.placesFor("a", 0).runs, 1, "and a keeps its encoder's place");
+  giveUp("a", "viewer-2");
+  assert.equal(admission.admitsPreparation("b").admitted, true, "the place ends with the last record");
+});
+
+test("a picture and its soundtrack fit where two pictures do not", () => {
+  const { admission } = machine({
+    costs: { picture: PICTURE_1080, sound: SOUNDTRACK, other: PICTURE_1080 },
+    running: { picture: 1 }
+  });
+  assert.equal(admission.admitsPreparation("sound").admitted, true, "0.53 s/s makes 1.89x");
+  assert.equal(admission.placesFor("sound", 0).runs >= 1, true);
+  assert.equal(admission.admitsPreparation("other").admitted, false, "1.02 s/s makes 0.98x");
+});
+
+test("an admitted encoder is never taken away, and a held place is kept", () => {
+  const { admission } = machine({
+    costs: { a: PICTURE_1080, b: PICTURE_1080 },
+    running: { a: 1, b: 1 }
+  });
+  assert.equal(admission.placesFor("a", 1).runs, 1, "both running: each keeps its one");
+  assert.equal(admission.placesFor("b", 1).runs, 1);
+  const { admission: held, prepare: prepareHeld } = machine({
+    costs: { a: PICTURE_1080, b: PICTURE_1080 },
+    running: { b: 1 }
+  });
+  prepareHeld("a", "viewer-1");
+  assert.equal(held.placesFor("a", 0).runs, 1, "a place promised to a preparation is not withdrawn");
+});
+
+test("a new output on a full machine is given no encoder", () => {
+  const { admission } = machine({ costs: { a: PICTURE_1080, b: PICTURE_1080 }, running: { a: 1 } });
+  assert.equal(admission.placesFor("b", 0).runs, 0);
+});
+
+test("the share of the machine nobody has priced is taken off what there is", () => {
+  // 0.6 s/s alone makes 1.67x; with a third of the machine taken by work
+  // nobody priced it makes 1.11x, and a soundtrack beside it still fits.
+  const quiet = machine({ costs: { a: 0.6, b: 0.4 }, share: 1 });
+  assert.equal(quiet.admission.admitsPreparation("a").admitted, true);
+  const busy = machine({ costs: { a: 0.6, b: 0.4 }, running: { a: 1 }, share: 0.6 });
+  assert.equal(busy.admission.admitsPreparation("b").admitted, false, "1.0 s/s at 0.6 of the machine makes 0.6x");
+});
+
+test("an output with no measured cost is not admitted", () => {
+  const { admission } = machine({ costs: { a: PICTURE_1080, b: null }, running: { a: 1 } });
+  const answer = admission.admitsPreparation("b");
+  assert.equal(answer.admitted, false);
+  assert.match(answer.reason, /no measured encoding cost/);
+});
+
+test("unpriced occupied work is neither spare pool headroom nor capacity for another output", () => {
+  const { admission } = machine({ costs: { a: null, b: PICTURE_1080 }, running: { a: 1 } });
+  assert.equal(admission.headroom().encodeSpeedX, 0, "the pool sees no confirmed room");
+  const answer = admission.admitsPreparation("b");
+  assert.equal(answer.admitted, false);
+  assert.match(answer.reason, /capacity is unknown/);
+});