@torrent-tv/proxy 2.17.0 → 2.19.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 2.19.0
+
+- **New**: What the torrent itself costs this machine is measured and charged. Downloading a file, verifying every piece of it and pushing segments down a data channel are work on the same box as the encoder, they scale with the file's own bitrate, and the budget counted none of it — measured on the addon host with every encoder suspended, the machine was still 20-29 % busy. The figure is taken only while NOTHING is encoding, which is the one moment it can be attributed without arithmetic, and it is expressed per megabyte moved so any file's rate can be priced from it. A viewer's file is then charged at its own byte rate when deciding what quality this host can offer.
+- **New**: The host-load line reports the proxy's own share of the machine beside the encoders'. The two answer different questions — whether ffmpeg is getting the cores, and how much of the box goes to everything around it — and only the first was visible.
+
+## 2.18.0
+
+- **New**: Copying the picture is no longer priced at nothing. It demuxes, re-encodes the audio and writes segments, and it is what runs BESIDE every rung warmed for a quality change — the field measured it at 7.92-8.02x, about an eighth of a second of work per second of video. The figure is not a constant: a session that is copying reports its own speed, and the reciprocal of that IS the cost, learned per file as the decode cost already is (median of recent readings, only from a run past its own start, never from a suspended one).
+- **New**: A rung is judged against the machine it will actually have. The cost of what the family is already committed to is added to the rung's own before the check, so the arithmetic of 2026-08-15 comes out as it did in the field: 0.125 for the copy plus about 1.05 for the 240p rung is more than the one second of work per second the machine has. Unmeasured means zero, so a host that has observed nothing is exactly as permissive as before.
+- **Fix**: A copy reading taken while the torrent is short is discarded. A re-encode near realtime may be the host's limit; a copy near realtime is a copy waiting for data, since copying runs at eight times realtime — and filing that as the price of copying would refuse rungs on the download's account. An audio rendition is excluded from this learning too: it carries no picture, and its speed is the price of a soundtrack, not of a copy.
+
 ## 2.17.0
 
 - **New**: The encoder is benchmarked on real footage instead of a generated test pattern, and measured by ffmpeg's own progress rather than by the clock around the process. The pattern has flat areas and no grain and encodes **1.23x** cheaper than film on the same machine and preset — an error that always points at offering a rung the host cannot hold. Timing whole runs was the second error: process startup is ~0.4 s, which put `fast` and `ultrafast` within 1.24x of each other when they differ by three times. The clip is decoded once to raw frames in a temp file (feeding them through a pipe measured the pipe: the fastest presets want hundreds of megabytes a second), each preset is read from the slope between two progress reports, and the run is stopped as soon as a second of it has been covered.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.17.0",
+  "version": "2.19.0",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/server.js

@@ -152,6 +152,17 @@ export async function startProxyServer({ host, port, transcodeAudio, ffmpegBin,
     stateDir,
     // Live download stats accessor for the realtime budget: lets it tell a
     // CPU-bound transcode from a download-starved input before downscaling.
+    // What every torrent here has moved, so the proxy can price its own
+    // downloading, hashing and delivery against the machine (roadmap item 7).
+    getTorrentTotals: async () => {
+      let bytesMoved = 0;
+      for (const torrent of torrentPool.client?.torrents ?? []) {
+        const downloaded = Number(torrent?.downloaded);
+        const uploaded = Number(torrent?.uploaded);
+        bytesMoved += (Number.isFinite(downloaded) ? downloaded : 0) + (Number.isFinite(uploaded) ? uploaded : 0);
+      }
+      return { bytesMoved };
+    },
     getSourceStats: async (sourceKey, fileIndex) => {
       const record = sourceRegistry.get(sourceKey);
       if (!record) {

package/services/hls-session-manager.js

@@ -18,7 +18,7 @@ import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { logger } from "../utils/logger.js";
 import { readKeyframeIndex } from "./container-index/index.js";
-import { readMachineState, readProcessCpuSeconds, readSystemCpu, shareOfMachine } from "./host-load.js";
+import { readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "./host-load.js";
 
 /** Own package version, stamped onto session-start log lines. */
 const PROXY_VERSION = createRequire(import.meta.url)("../package.json").version;
@@ -466,6 +466,8 @@ const DEFAULT_STARTUP_WAIT_MS = 5_000;
 // and restart at the current segment. Conservative so it never thrashes: a long
 // sustained window, a post-action cooldown, a step cap, and no upswitch (v1).
 const BUDGET_CHECK_INTERVAL_MS = 5_000;
+/** Below this, a tick has not moved enough of the torrent to price it. */
+const TORRENT_COST_MIN_MEGABYTES = 2;
 // Speed below this (cumulative ffmpeg average) counts as "slow"; recovery to
 // realtime resets the slow window (hysteresis).
 const BUDGET_SPEED_SLOW = 0.95;
@@ -1161,6 +1163,23 @@ function normalizeLogFileName(fileName, fileIndex) {
  * combination. Sessions are reused across consumers and are automatically
  * expired after {@link HlsSessionManagerOptions.sessionTtlMs} of idle time.
  */
+/**
+ * How many megabytes a second of this source is, from what the probe read.
+ *
+ * A viewer consumes the file at its own rate, so this is also the rate at which
+ * the machine must fetch, verify and deliver it while they watch.
+ *
+ * @param {HlsSession} session
+ * @returns {number | null}
+ */
+function sourceMegabytesPerSecond(session) {
+  const megabitsPerSecond = Number(session.sourceDecode?.megabitsPerSecond);
+  if (!Number.isFinite(megabitsPerSecond) || megabitsPerSecond <= 0) {
+    return null;
+  }
+  return megabitsPerSecond / 8;
+}
+
 export class HlsSessionManager {
   /**
    * Recent times from session-create to a servable first segment, in ms.
@@ -1194,8 +1213,23 @@ export class HlsSessionManager {
    * @type {Map<string, { costSec: number, version: number }>}
    */
   #observedDecodeCost = new Map();
+  /**
+   * What copying costs, per source file, learned the same way: `key ->
+   * { costSec, readings, version }`. A copy is what runs BESIDE a rung being
+   * warmed, and pricing it at nothing is what let a host be told it had a whole
+   * machine for the rung.
+   *
+   * @type {Map<string, { costSec: number, readings: number[], version: number }>}
+   */
+  #observedCopyCost = new Map();
   /** The previous reading of the machine, to compare the next one against. */
   #hostLoadSample = null;
+  /** The previous reading taken while nothing was encoding, for the torrent's own cost. */
+  #idleLoadSample = null;
+  /** Seconds of this process's CPU per megabyte the torrent moves, once measured. */
+  #observedTorrentCostPerMegabyte = null;
+  /** @type {number[]} Recent readings behind that median. */
+  #torrentCostReadings = [];
 
   /**
    * @param {HlsSessionManagerOptions} options
@@ -1216,8 +1250,8 @@ export class HlsSessionManager {
     getCachedMediaInfo = null,
     getCachedAudioTracks = null,
     segmentFormatId = undefined,
-    stateDir = ""
-  }) {
+    stateDir = "",
+    getTorrentTotals}) {
     this.enabled = Boolean(enabled);
     this.ffmpegBin = ffmpegBin;
     // Where measurements about this host are kept between runs. Empty means
@@ -1238,6 +1272,10 @@ export class HlsSessionManager {
     // realtime budget to tell a CPU limit from a download-starved input:
     // (sourceKey, fileIndex) => Promise<{ downloadSpeed, fileLength, fileProgress } | null>.
     this.getSourceStats = typeof getSourceStats === "function" ? getSourceStats : null;
+    // Totals across every torrent this proxy holds, used to price what the
+    // torrent itself costs the machine (item 7). Optional: a proxy wired
+    // without it simply never learns that figure.
+    this.getTorrentTotals = typeof getTorrentTotals === "function" ? getTorrentTotals : null;
     // Detected H.264 encoder descriptor (hardware or software). Defaults to
     // software libx264 when no detection result is supplied. May be downgraded
     // to software at runtime if a hardware encode fails.
@@ -2657,14 +2695,85 @@ export class HlsSessionManager {
    * Written only while something is encoding, and only when a reading is
    * available: on a host without `/proc` this says nothing at all.
    */
+  /**
+   * What the torrent itself costs this machine, per megabyte it moves.
+   *
+   * Downloading, verifying every piece and pushing segments down a data channel
+   * are work on the same box as the encoder, they scale with the file's own
+   * bitrate, and the budget counts none of it. Measured on the addon host with
+   * every encoder suspended, the machine was still 20-29 % busy.
+   *
+   * Taken only while NOTHING is encoding, because that is the only moment the
+   * spending can be attributed without arithmetic: what this process uses then
+   * is the torrent's.
+   */
+  async #learnTorrentCost() {
+    const now = {
+      takenAt: Date.now(),
+      cpuSeconds: readProxyCpuSeconds(),
+      bytes: await this.#torrentBytesMoved()
+    };
+    const previous = this.#idleLoadSample;
+    this.#idleLoadSample = now;
+    if (previous === null || now.bytes === null || previous.bytes === null) {
+      return;
+    }
+    const elapsedSec = (now.takenAt - previous.takenAt) / 1000;
+    const megabytes = (now.bytes - previous.bytes) / 1e6;
+    const cpuSeconds = now.cpuSeconds - previous.cpuSeconds;
+    // Enough movement to divide by: a tick with almost nothing downloaded
+    // measures the idle loop, not the torrent.
+    if (!(elapsedSec > 0) || !(megabytes >= TORRENT_COST_MIN_MEGABYTES) || !(cpuSeconds > 0)) {
+      return;
+    }
+    const costPerMegabyte = cpuSeconds / megabytes;
+    const readings = [...this.#torrentCostReadings, costPerMegabyte].slice(-DECODE_LEARNING_READINGS);
+    this.#torrentCostReadings = readings;
+    const sorted = [...readings].sort((left, right) => left - right);
+    const median = sorted[Math.floor(sorted.length / 2)];
+    if (this.#observedTorrentCostPerMegabyte !== null &&
+        Math.abs(median - this.#observedTorrentCostPerMegabyte) / this.#observedTorrentCostPerMegabyte < DECODE_LEARNING_CHANGE) {
+      return;
+    }
+    this.#observedTorrentCostPerMegabyte = median;
+    logger.info(
+      `host-load: the torrent costs ${(median * 1000).toFixed(1)}ms of CPU per MB on this host ` +
+      `(median of ${readings.length}, latest ${(costPerMegabyte * 1000).toFixed(1)}ms over ${megabytes.toFixed(1)}MB)`
+    );
+  }
+
+  /**
+   * Bytes this proxy's torrents have moved in total, or null when it cannot be
+   * asked.
+   *
+   * @returns {Promise<number | null>}
+   */
+  async #torrentBytesMoved() {
+    if (typeof this.getTorrentTotals !== "function") {
+      return null;
+    }
+    try {
+      const totals = await this.getTorrentTotals();
+      const moved = Number(totals?.bytesMoved);
+      return Number.isFinite(moved) ? moved : null;
+    } catch {
+      return null; // the pool is busy or gone; a reading missed is not a fault
+    }
+  }
+
   async #reportHostLoad() {
     const encoding = [...this.sessionsById.values()].filter(
       (session) => session?.ffmpeg != null && !hasChildExited(session.ffmpeg) && session.state !== "disposed"
     );
     if (encoding.length === 0) {
+      // Nothing is encoding, which is the ONLY moment the torrent's own cost
+      // can be attributed cleanly: whatever this process spends now is the
+      // download, the hashing, the piece store and the delivery. Item 7.
+      await this.#learnTorrentCost();
       this.#hostLoadSample = null;
       return;
     }
+    this.#idleLoadSample = null;
     // EVERY encoder, added up. One of them is meaningless on a host that runs a
     // picture and an audio track at once, and picking the first would have
     // reported whichever the map happened to hold.
@@ -2688,7 +2797,16 @@ export class HlsSessionManager {
         byPid.set(pid, seconds);
       }
     });
-    const sample = { takenAt: Date.now(), byPid, system };
+    const sample = {
+      takenAt: Date.now(),
+      byPid,
+      system,
+      // The proxy's own CPU, across every thread: the torrent, the hashing, the
+      // piece store and the delivery. None of it is in the encode budget, and
+      // on the addon host it is most of what the machine does while encoders
+      // are suspended.
+      proxyCpuSeconds: readProxyCpuSeconds()
+    };
     const previous = this.#hostLoadSample;
     this.#hostLoadSample = sample;
     if (previous === null) {
@@ -2722,8 +2840,13 @@ export class HlsSessionManager {
     const running = encoding.length - suspended;
     const machine = await readMachineState();
     const asPercent = (value) => (value === null ? "n/a" : `${Math.round(value * 100)}%`);
+    const cores = Math.max(1, os.cpus().length);
+    const proxyShare = Number.isFinite(previous.proxyCpuSeconds)
+      ? (sample.proxyCpuSeconds - previous.proxyCpuSeconds) / (share.elapsedSec * cores)
+      : null;
     logger.info(
-      `host-load: ffmpeg=${asPercent(share.processShare)} system=${asPercent(share.systemShare)} ` +
+      `host-load: ffmpeg=${asPercent(share.processShare)} proxy=${asPercent(proxyShare)} ` +
+      `system=${asPercent(share.systemShare)} ` +
       `iowait=${asPercent(share.iowaitShare)} cpu=${machine.megahertz === null ? "n/a" : `${machine.megahertz}MHz`} ` +
       `temp=${machine.celsius === null ? "n/a" : `${machine.celsius}C`} ` +
       `encoders=${running} running` + (suspended > 0 ? ` +${suspended} suspended` : "") +
@@ -4549,6 +4672,10 @@ export class HlsSessionManager {
       heights: ordered,
       ownHeight: own,
       playingHeight: playing,
+      // What the family is already spending while a rung is considered. The
+      // picture being COPIED is the common case and used to be priced at
+      // nothing; measured, it is about an eighth of the machine.
+      concurrentCostSec: this.#committedCostOf(owner),
       sourceWidth: Number(owner.sourceWidth) || 0,
       sourceHeight: Math.round(Number(owner.sourceHeight) || 0),
       fps: Number(owner.outputFps) || TRANSCODE_FPS,
@@ -4648,9 +4775,76 @@ export class HlsSessionManager {
     this.#learnDecodeCost(session, speed);
   }
 
+  /**
+   * What COPYING this file costs on this host, learned from a session that is
+   * doing it: seconds of work per second of video.
+   *
+   * A copy is not free. It demuxes, it re-encodes the audio, it writes
+   * segments, and it runs BESIDE every rung warmed for a quality change — so a
+   * budget that prices it at nothing predicts a machine that does not exist.
+   * The figure is the reciprocal of the speed the session reports, which is the
+   * measurement itself rather than a model of it.
+   *
+   * Median of recent readings, taken only from a run past its own start, for
+   * the same reasons as the decode cost beside it.
+   *
+   * @param {HlsSession} session
+   * @param {number} speed
+   */
+  async #learnCopyCost(session, speed) {
+    const runStartedAt = Number(session.encodeRunStartedAt);
+    if (!Number.isFinite(runStartedAt) || Date.now() - runStartedAt < DECODE_LEARNING_SETTLE_MS) {
+      return;
+    }
+    if (session.encoderPaused === true) {
+      return; // a suspended run reports a cumulative figure that is decaying
+    }
+    // Always asked, not only below realtime. A re-encode near 1x may be the
+    // host; a COPY near 1x is a copy waiting for the torrent, because copying
+    // is what a machine does at eight times realtime — and a starved reading
+    // filed as the price of copying would refuse rungs on the download's
+    // account.
+    if (await this.#classifyTranscodeBound(session) === "download") {
+      return;
+    }
+    const costSec = 1 / speed;
+    if (!(costSec > 0) || !Number.isFinite(costSec)) {
+      return;
+    }
+    const key = `${session.sourceKey}:${session.fileIndex}`;
+    const known = this.#observedCopyCost.get(key);
+    const readings = [...(known?.readings ?? []), costSec].slice(-DECODE_LEARNING_READINGS);
+    const sorted = [...readings].sort((left, right) => left - right);
+    const median = sorted[Math.floor(sorted.length / 2)];
+    if (known && Math.abs(median - known.costSec) / known.costSec < DECODE_LEARNING_CHANGE) {
+      this.#observedCopyCost.set(key, { ...known, readings });
+      return;
+    }
+    this.#observedCopyCost.set(key, { costSec: median, readings, version: (known?.version ?? 0) + 1 });
+    logger.info(
+      `transcode: ${session.fileName} copies at ${(1 / median).toFixed(2)}x on this host ` +
+        `(median of ${readings.length}, latest ${speed.toFixed(2)}x)`
+    );
+  }
+
   #learnDecodeCost(session, speed) {
-    if (session.transcodeVideo !== true || !(speed > 0)) {
-      return; // a copied video decodes nothing, so it says nothing about decoding
+    if (!(speed > 0)) {
+      return;
+    }
+    if (session.transcodeVideo !== true) {
+      // A copied video decodes nothing, so it says nothing about DECODING —
+      // but it says exactly what COPYING costs, which the budget has been
+      // treating as free. Field 2026-08-15: a copy ran at 7.92-8.02x, i.e.
+      // about an eighth of a second of work per second of video, while a rung
+      // warmed beside it needed the rest of the machine.
+      //
+      // An audio rendition also carries no video, and its speed is the cost of
+      // encoding a soundtrack — a different quantity that must not be filed
+      // under what copying the picture costs.
+      if (session.audioOnly !== true) {
+        void this.#learnCopyCost(session, speed);
+      }
+      return;
     }
     const runStartedAt = Number(session.encodeRunStartedAt);
     if (!Number.isFinite(runStartedAt) || Date.now() - runStartedAt < DECODE_LEARNING_SETTLE_MS) {
@@ -4788,6 +4982,39 @@ export class HlsSessionManager {
    * @param {{ heights: number[], ownHeight: number, sourceWidth: number, sourceHeight: number, fps: number, source: { megapixelsPerSecond: number, megabitsPerSecond: number } | null, transcodeVideo: boolean }} params
    * @returns {number[]}
    */
+  /**
+   * Seconds of work per second of video this family is ALREADY committed to,
+   * beside any rung being considered.
+   *
+   * Today that is the copy of the picture, where the video is copied and its
+   * cost has been observed. An encoded picture is not added: a viewer changing
+   * quality leaves the rung they are on, so the two do not overlap for long,
+   * and the warm-up that does overlap is bounded by the switch. An audio
+   * rendition is not added either, until its cost is measured the same way —
+   * counting it at a guess would refuse rungs on arithmetic nobody took.
+   *
+   * @param {HlsSession} session
+   * @returns {number}
+   */
+  #committedCostOf(session) {
+    let cost = 0;
+    if (session.transcodeVideo !== true) {
+      const observed = this.#observedCopyCost.get(`${session.sourceKey}:${session.fileIndex}`);
+      cost += observed && observed.costSec > 0 ? observed.costSec : 0;
+    }
+    // And what the FILE costs simply by being fetched and delivered while it is
+    // watched: a viewer consumes it at its own byte rate, and every one of
+    // those bytes is downloaded, verified and pushed by this process. Priced
+    // per megabyte from readings taken while nothing was encoding, so the two
+    // measurements do not contain each other.
+    const perMegabyte = this.#observedTorrentCostPerMegabyte;
+    const megabytesPerSecond = sourceMegabytesPerSecond(session);
+    if (perMegabyte !== null && megabytesPerSecond !== null) {
+      cost += perMegabyte * megabytesPerSecond;
+    }
+    return cost;
+  }
+
   #sustainableHeights({
     heights,
     ownHeight,
@@ -4797,7 +5024,8 @@ export class HlsSessionManager {
     fps,
     source,
     transcodeVideo,
-    observedDecodeCostSec = null
+    observedDecodeCostSec = null,
+    concurrentCostSec = 0
   }) {
     const benchmark = this.softwarePresetBenchmark;
     if (!Array.isArray(benchmark) || benchmark.length === 0 || sourceHeight <= 0 || sourceWidth <= 0) {
@@ -4835,7 +5063,8 @@ export class HlsSessionManager {
         decodeModel: this.decodeCostModel,
         source,
         outputPixelsPerSec: width * height * fps,
-        observedDecodeCostSec
+        observedDecodeCostSec,
+        concurrentCostSec
       });
       if (sustainable) {
         kept.push(height);

package/services/host-load.js

@@ -152,3 +152,23 @@ export async function sampleHost(pid) {
   ]);
   return { takenAt: Date.now(), processCpuSeconds, system };
 }
+
+/**
+ * How much CPU THIS process has used, across every thread it owns.
+ *
+ * The proxy is not only its encoders. It downloads the torrent, verifies every
+ * piece it receives, keeps the piece store, and pushes segments down a data
+ * channel — work that happens in this process and its workers, that scales with
+ * the file's own bitrate, and that the encode budget counts as nothing.
+ * Measured on the addon host with both encoders suspended, the machine was
+ * still 20-29 % busy; this is the number that says how much of that is ours.
+ *
+ * `process.cpuUsage()` covers all threads of the process, so the torrent
+ * worker's hashing is included without asking it anything.
+ *
+ * @returns {number} Seconds of CPU used since this process began.
+ */
+export function readProxyCpuSeconds() {
+  const usage = process.cpuUsage();
+  return (usage.user + usage.system) / 1e6;
+}

package/services/hwaccel.js

@@ -1054,7 +1054,8 @@ export function canSustainOutput({
   decodeModel = null,
   source = null,
   outputPixelsPerSec,
-  observedDecodeCostSec = null
+  observedDecodeCostSec = null,
+  concurrentCostSec = 0
 }) {
   if (!Array.isArray(benchmark) || benchmark.length === 0) {
     // Nothing measured on this host: the budget cannot refuse what it cannot
@@ -1070,13 +1071,28 @@ export function canSustainOutput({
     // term the ladder is offered whole, exactly as it was before.
     return { speed: null, sustainable: true };
   }
-  const speed = predictedRealtimeSpeed({
+  const alone = predictedRealtimeSpeed({
     decodeModel,
     encodePixelsPerSec: cheapestPresetPixelsPerSec(benchmark),
     outputPixelsPerSec,
     source,
     observedDecodeCostSec: observed
   });
+  // What ELSE will be running while this rung is. A rung is never the only
+  // thing on the machine: the picture it accompanies is being copied or
+  // encoded, an audio track may have its own encoder, and a warm-up is two
+  // encoders by design. Measured on the addon host, a copy alone takes about an
+  // eighth of the machine per second of video, and the field case of
+  // 2026-08-15 adds up exactly: 0.125 for the copy plus ~1.05 for the rung is
+  // more than the one second per second the machine has, which is what was
+  // observed.
+  //
+  // Zero when nothing else is known to be running, or when nothing has been
+  // measured yet — then this is a LOWER bound on the cost and the check is as
+  // permissive as it was before.
+  const speed = alone === null || !(concurrentCostSec > 0)
+    ? alone
+    : 1 / (1 / alone + concurrentCostSec);
   if (speed === null) {
     return { speed: null, sustainable: true };
   }

package/test/concurrent-cost.test.js

@@ -0,0 +1,82 @@
+/**
+ * @file A rung is judged against the machine it will actually have.
+ *
+ * The field case of 2026-08-15, in arithmetic: a copy of the picture took about
+ * 0.125 s of work per second of video (7.9-8.0x measured), a 240p rung needed
+ * about 1.05, and the two together are more than the one second per second the
+ * machine has. The budget priced the copy at nothing, offered the rung, and the
+ * viewer watched it fail.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { canSustainOutput } from "../services/hwaccel.js";
+
+// A host that encodes 640x360 at 24 fps about eleven times over, and decodes
+// 1080p24 at 2.6x — the addon host's own figures.
+const BENCHMARK = [
+  { preset: "fast", pixelsPerSec: 17.0e6 },
+  { preset: "ultrafast", pixelsPerSec: 67.5e6 }
+];
+const DECODE_MODEL = { pixelTerm: 0.007742, bitrateTerm: 0, constantTerm: 0 };
+const SOURCE = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
+const RUNG_240P = 426 * 240 * 24;
+
+test("a rung is judged on the machine it will have, not on an empty one", () => {
+  const alone = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P
+  });
+  const beside = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    // The picture is being copied beside it, at the cost the field measured.
+    concurrentCostSec: 0.125
+  });
+  assert.ok(alone.speed !== null && beside.speed !== null);
+  assert.ok(beside.speed < alone.speed, "sharing the machine cannot make a rung faster");
+});
+
+test("nothing else running leaves the answer exactly as it was", () => {
+  const withZero = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0
+  });
+  const without = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P
+  });
+  assert.equal(withZero.speed, without.speed);
+});
+
+test("a host with nothing measured still refuses nothing", () => {
+  const answer = canSustainOutput({
+    benchmark: [],
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0.125
+  });
+  assert.equal(answer.sustainable, true);
+  assert.equal(answer.speed, null);
+});
+
+test("a cost heavy enough to fill the machine puts a rung below realtime", () => {
+  const answer = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0.9
+  });
+  assert.ok(answer.speed !== null && answer.speed < 1, "0.9 of the machine spent elsewhere leaves less than realtime");
+  assert.equal(answer.sustainable, false);
+});