@torrent-tv/proxy 2.107.33 → 2.107.35

package/bin/cli.js

@@ -405,7 +405,6 @@ try {
     onSubtitleCues: (event) => dataChannelHandler?.publishSubtitleCues(event),
     // Late-bound for the same reason: what the connections carry beyond the
     // film is counted by the data-channel handler, built further down.
-    serviceShare: () => dataChannelHandler?.serviceShare?.() ?? null,
     onStateChanged: () => void stateReporter.changed(),
     onChaptersChanged: (event) => dataChannelHandler?.publishChaptersChanged(event)
   });

package/package.json

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

package/server.js

@@ -140,9 +140,6 @@ export async function startProxyServer({
   // The one software preset every picture is encoded at, for runs compared at
   // one quality; null leaves the choice to the machine.
   pinnedPreset = null,
-  // What viewers' connections carry beyond the film, per byte of film; the
-  // transport counts it and is built after this server, so it is late-bound.
-  serviceShare = () => null,
   // Where the proxy writes its own log. Its DIRECTORY is what matters here:
   // the browser's half of every session is written beside it, so the two are
   // on one durable disk and join by name.
@@ -652,6 +649,7 @@ export async function startProxyServer({
       return downloadMaps.refresh(sourceKey, fileIndex);
     }).catch(error => logger.warn(`download map after a packet table: ${error?.message ?? error}`));
   };
+  let outputPartsReady = false;
   const downloadMaps = new DownloadMaps({
     // The ranges a picture reads at open are named again by every segment;
     // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
@@ -668,6 +666,12 @@ export async function startProxyServer({
     pack: (zones) => coalescedZones(zones),
     log: (line) => logger.info(line),
     observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields),
+    // A file's own reads are wanted while a present viewer has the file chosen
+    // or on screen. The viewers are assembled below; until they exist no read
+    // can have been asked for by one.
+    fileWanted: (sourceKey, fileIndex) => (outputPartsReady ? outputParts.viewers.forSource(sourceKey) : [])
+      .some(viewer => viewer.source?.selectedFileIndex === fileIndex ||
+        viewer.source?.visibleFileIndices?.includes(fileIndex)),
     resolvePlayback: async (map) => {
       const fileKey = `${map.sourceKey}:${map.fileIndex}`;
       if (map.zones.length === 0) {
@@ -1003,7 +1007,10 @@ export async function startProxyServer({
             ...(demand ? { priority: demand.priority, urgent: demand.urgent, deadlineAt: demand.deadlineAt, interval: demand, leadSeconds: demand.leadSeconds ?? 0 } : {}),
             ...(readPriority?.requestId ? { priority: readPriority.rank, urgent: readPriority.urgent === true,
               deadlineAt: Number.isFinite(readPriority.deadlineAt) ? readPriority.deadlineAt : Number.POSITIVE_INFINITY,
-              scope: "preparation" } : {}) });
+              scope: "preparation" } : {}),
+            // Neither a viewer's interval nor an encode input asked for it: the
+            // file read itself, and that read is wanted while the file is.
+            ...(!demand && !readPriority?.requestId ? { owner: "file" } : {}) });
         }
         if (finished && result.kind === "result") {
           void downloadMaps.refresh(sourceKey, fileIndex).catch(error =>
@@ -1041,9 +1048,12 @@ export async function startProxyServer({
     observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields),
     pinnedPreset,
     indexMemory,
-    serviceShare,
     readMetadataActivity: () => containerOrchestrator.activity(),
-    onViewerChanged: () => { void sourcePreparation?.refresh(); onStateChanged(); },
+    onViewerChanged: () => {
+      void sourcePreparation?.refresh();
+      void downloadMaps.viewersChanged().catch(error => logger.warn(`download maps after a viewer change: ${error.message}`));
+      onStateChanged();
+    },
     onEncodersChanged: () => onStateChanged(),
     sourceInputsFor: (output, index) => segmentInputs.inputsFor(output.file.sourceKey, output.outputKey, index),
     readSourceMedia: async (params) => {
@@ -1337,6 +1347,7 @@ export async function startProxyServer({
       await torrentPool.fillFileInBackground?.(torrent, fileIndex);
     }
   });
+  outputPartsReady = true;
   // Where the processor goes, and at a cold start what the main thread does
   // with it, when the operator asks (torrent-tv/meta#177).
   const startupProfile = startupCpuProfile({

package/services/encode/OutputOpening.js

@@ -599,8 +599,7 @@ export class OutputOpening {
         linkMbps: viewerLinkMbps,
         keys: [...this.#host.outputs.values()].map((other) => other.outputKey).concat(this.#host.segmentOutputFiles.addresses()),
         readyAt: (key) => this.#host.segmentOutputFiles.isClosed(key, timeline.indexForTime(Math.max(0, startPositionSeconds))),
-        observedPeakMbps: (candidate) => this.#host.observedPeakMbps?.(candidate) ?? null,
-        serviceShare: () => this.#host.serviceShare?.() ?? null
+        observedPeakMbps: (candidate) => this.#host.observedPeakMbps?.(candidate) ?? null
       }
     });
     // Which picture rate the link was asked about, and where it came from

package/services/encode/Renditions.js

@@ -148,8 +148,7 @@ export class Renditions {
             Number.isFinite(base.file.pictureKbps) ? base.file.pictureKbps / 1000 : null,
             this.#host.observedPeakMbps?.(spec) ?? null
           ),
-          audioLoad,
-          this.#host.serviceShare?.() ?? null
+          audioLoad
         )
       )
     });
@@ -504,8 +503,8 @@ export class Renditions {
    * size whose bounds are two neighbouring limits of `limitsFor(frame, file)` — the
    * source-scaled nominal for the frame on screen, the same nominal used
    * to open the output (`output-format.js`). Down,
-   * the highest lower limit their link admits; up, the next limit only, and
-   * only if their link admits it. A copy has no limit and a hardware encode is
+   * the highest lower limit the measured link supports; up, the next limit
+   * only, and only if the measured link supports it. A copy has no limit and a hardware encode is
    * given none, so neither has anywhere to move to here, and the caller's other
    * lever — another height — is what remains.
    *
@@ -551,11 +550,10 @@ export class Renditions {
     }
     const linkMbps = this.#host.linkMbpsOf(base, consumerId);
     const audioLoad = this.viewerAudioLoadOf(base, consumerId);
-    const serviceShare = this.#host.serviceShare?.() ?? null;
-    const admits = (limit) => linkCouldCarry(linkMbps, loadOf(videoLoadOfLimit(limit), audioLoad, serviceShare)).admitted;
+    const fits = (limit) => linkCouldCarry(linkMbps, loadOf(videoLoadOfLimit(limit), audioLoad)).fits;
     const target = direction === "down"
-      ? limits.slice(at + 1).find(admits)
-      : (at > 0 && admits(limits[at - 1]) ? limits[at - 1] : undefined);
+      ? limits.slice(at + 1).find(fits)
+      : (at > 0 && fits(limits[at - 1]) ? limits[at - 1] : undefined);
     if (target === undefined) {
       return refuse(direction === "down"
         ? `no lower limit of ${encode.height}p is admitted by this viewer's link`

package/services/encode/quality/QualityController.js

@@ -276,8 +276,8 @@ export class QualityController {
    *    being told (roadmap item 97, step 12). A limit is part of an output, so
    *    this is a move between outputs, prepared for one viewer.
    * 2. ANOTHER HEIGHT, asked of the player in AUTO — only for a viewer with no
-   *    higher limit to go to on the height they watch, and only if their own
-   *    link admits the next height's whole load.
+   *    higher limit to go to on the height they watch, and when the measured
+   *    link supports the next height's whole load.
    *
    * Both follow one window: the machine and the viewer's link have held the
    * output on screen, with room to spare, for four times as long as a step
@@ -382,10 +382,9 @@ export class QualityController {
     const report = this.#host.linkReportOf(session, consumerId);
     const load = loadOf(
       this.#host.qualityOffer.videoLoadFor(base, height, this.#host.videoEncoder?.kind ?? ""),
-      this.#host.viewerAudioLoadOf(base, consumerId),
-      this.#host.serviceShare?.() ?? null
+      this.#host.viewerAudioLoadOf(base, consumerId)
     );
-    return linkCouldCarry(report?.linkMbps ?? null, load).admitted;
+    return linkCouldCarry(report?.linkMbps ?? null, load).fits;
   }
 
   /**

package/services/encode/quality/link-budget.js

@@ -5,7 +5,7 @@
  * the last report showed — and never as a reference to a viewer. Nothing here
  * holds anybody, reads anything or can be asked at the wrong moment.
  *
- * WHAT A LINK CARRIES IS A LOAD, NOT A PICTURE (roadmap item 97, step 11). The
+ * WHAT A LINK CARRIES IS A LOAD, NOT A PICTURE. The
  * viewer receives the picture AND the soundtrack they chose — inside the
  * picture's own stream, or as a separate one — so both are added before the
  * link is asked. And each part says how much its figure can be trusted:
@@ -14,20 +14,16 @@
  *    most a copied soundtrack's codec allows it to carry;
  * 2. `estimated` — an average: a copied picture's or soundtrack's rate as the
  *    FILE states it, or the target a re-encoded soundtrack is asked for. An
- *    average is not a bound, so a load built on it is admitted only by
- *    estimate and is never confirmed;
+ *    average is not a bound, so a load built on it is only estimated to fit
+ *    and is never confirmed;
  * 3. `unknown` — no figure at all: a hardware encoder given no limit, a copied
  *    soundtrack whose rate nothing states.
  *
  * A load is as trustworthy as its least trustworthy part.
  *
- * AND WHAT THE CONNECTION CARRIES BESIDES THE FILM (torrent-tv/meta#169). The
- * same connection carries message framing, playlists, poll answers, probes and
- * pushed cues. Their share is measured by the transport over everything this
- * proxy has delivered (`transport/delivery-shares.js`) and added on top of the
- * picture and the sound. It is an average proportion and not a bound, so it
- * moves the figure without deciding the load's class; unmeasured, nothing is
- * added and the figures say so (`serviceShare: null`).
+ * Control traffic and measurement transfers cannot be apportioned to a new
+ * output from lifetime byte counters; doing so turned short or interrupted
+ * playback into fictitious per-video rates.
  */
 
 import { AUDIO_TRANSCODE_KBPS, maxrateKbpsFor, nominalKbpsFor } from "../args.js";
@@ -52,7 +48,7 @@ const CLASS_ORDER = [PEAK_CLASS.KNOWN, PEAK_CLASS.ESTIMATED, PEAK_CLASS.UNKNOWN]
 
 /**
  * @typedef {{ mbps: number | null, peakClass: string }} LoadPart
- * @typedef {{ video: LoadPart | null, audio: LoadPart | null, serviceMbps: number | null, serviceShare: number | null, totalMbps: number | null, peakClass: string }} Load
+ * @typedef {{ video: LoadPart | null, audio: LoadPart | null, totalMbps: number | null, peakClass: string }} Load
  */
 
 /**
@@ -233,52 +229,43 @@ export const SOUNDTRACK_MODE_CAUSE = Object.freeze({
  *
  * @param {LoadPart | null} video
  * @param {LoadPart | null} audio
- * @param {number | null} [serviceShare] - What the connection carries beyond
- *   the film, per byte of film, as the transport measured it; null while
- *   nothing has been measured.
  * @returns {Load}
  */
-export function loadOf(video, audio, serviceShare = null) {
+export function loadOf(video, audio) {
   const parts = [video, audio].filter(Boolean);
   const peakClass = parts.reduce(
     (worst, one) => (CLASS_ORDER.indexOf(one.peakClass) > CLASS_ORDER.indexOf(worst) ? one.peakClass : worst),
     PEAK_CLASS.KNOWN
   );
-  const share = Number.isFinite(serviceShare) && serviceShare >= 0 ? serviceShare : null;
   const filmMbps = peakClass === PEAK_CLASS.UNKNOWN
     ? null
     : parts.reduce((sum, one) => sum + one.mbps, 0);
-  const serviceMbps = filmMbps === null || share === null ? null : filmMbps * share;
-  const totalMbps = filmMbps === null ? null : filmMbps + (serviceMbps ?? 0);
-  return { video, audio, serviceMbps, serviceShare: share, totalMbps, peakClass };
+  return { video, audio, totalMbps: filmMbps, peakClass };
 }
 
 /**
  * What a link that measured `linkMbps` does with a load.
  *
- * 1. nothing measured the link — every class is admitted, since the link gave
- *    no ground to refuse, and nothing is confirmed;
- * 2. an `unknown` load against a measured link — `no safe bound`, refused:
- *    there is no number to compare;
- * 3. otherwise the load is compared with the usable share of the link: a
- *    `known` load that passes FITS and is confirmed, an `estimated` one that
- *    passes is admitted by estimate and is NOT confirmed.
+ * 1. nothing measured the link — no comparison can be made;
+ * 2. an `unknown` load against a measured link — `no safe bound`;
+ * 3. otherwise the load is compared with the measured link. The result helps
+ *    choose a sustainable format, but every result remains playable.
  *
  * @param {number | null} linkMbps
  * @param {Load} load
- * @returns {{ verdict: string, admitted: boolean, confirmed: boolean, linkMbps: number | null, load: Load }}
+ * @returns {{ verdict: string, confirmed: boolean, fits: boolean, linkMbps: number | null, load: Load }}
  */
 export function linkCouldCarry(linkMbps, load) {
   const measured = Number.isFinite(linkMbps) && linkMbps > 0;
-  const answer = (verdict, admitted, confirmed) => ({
+  const answer = (verdict, confirmed, fits) => ({
     verdict,
-    admitted,
     confirmed,
+    fits,
     linkMbps: measured ? linkMbps : null,
     load
   });
   if (!measured) {
-    return answer(LINK_VERDICT.NO_MEASUREMENT, true, false);
+    return answer(LINK_VERDICT.NO_MEASUREMENT, false, true);
   }
   if (load.peakClass === PEAK_CLASS.UNKNOWN) {
     return answer(LINK_VERDICT.NO_SAFE_BOUND, false, false);
@@ -292,44 +279,20 @@ export function linkCouldCarry(linkMbps, load) {
   }
   return load.peakClass === PEAK_CLASS.KNOWN
     ? answer(LINK_VERDICT.FITS, true, true)
-    : answer(LINK_VERDICT.ESTIMATED_TO_FIT, true, false);
+    : answer(LINK_VERDICT.ESTIMATED_TO_FIT, false, true);
 }
 
 /**
- * Why a link refused a load, in words naming what was missing or too much.
- *
- * `no safe bound` names every part that has no figure — the picture, the
- * soundtrack or both — because that, and not the link, is what the refusal is
- * about. Any other refusal is about the size of the load and is described by
- * the caller, who knows which outputs were weighed.
- *
- * @param {{ verdict: string, load: Load }} answer
- * @param {string} otherwise - The words for a load that is too large.
- * @returns {string}
- */
-export function linkRefusalReason(answer, otherwise) {
-  if (answer?.verdict !== LINK_VERDICT.NO_SAFE_BOUND) {
-    return otherwise;
-  }
-  const missing = [
-    answer.load?.video?.peakClass === PEAK_CLASS.UNKNOWN ? "the picture" : "",
-    answer.load?.audio?.peakClass === PEAK_CLASS.UNKNOWN ? "the soundtrack" : ""
-  ].filter(Boolean);
-  return `nothing states how much ${missing.length > 0 ? missing.join(" or ") : "this output"} would send, ` +
-    "so this viewer's link cannot be asked whether it fits";
-}
-
-/**
- * How strongly an answer is admitted, for ordering: a load whose figure is a
+ * How strongly a sustainable answer ranks, for selection: a load whose figure is a
  * bound before one whose figure is an average, and both before one with no
- * figure (which is only ever admitted with nothing measured). Zero for a
- * refusal.
+ * figure. A load above the measured link remains playable but ranks below
+ * outputs the measurement supports.
  *
- * @param {{ admitted: boolean, load: Load }} answer
+ * @param {{ fits: boolean, load: Load }} answer
  * @returns {number}
  */
 export function admissionRank(answer) {
-  if (!answer.admitted) {
+  if (!answer.fits) {
     return 0;
   }
   return 3 - CLASS_ORDER.indexOf(answer.load.peakClass);
@@ -350,8 +313,6 @@ export function linkAnswerFigures(answer) {
     videoClass: answer.load.video?.peakClass ?? null,
     audioMbps: answer.load.audio?.mbps ?? null,
     audioClass: answer.load.audio?.peakClass ?? null,
-    serviceMbps: answer.load.serviceMbps ?? null,
-    serviceShare: answer.load.serviceShare ?? null,
     totalMbps: answer.load.totalMbps,
     peakClass: answer.load.peakClass
   };

package/services/encode/quality/output-format.js

@@ -18,17 +18,16 @@
  * for (`capKbps`), and declared at that source and size's nominal level. A
  * hardware encoder is given no bound. Unknown source rates mean no bound.
  *
- * AND THE VIEWER'S LINK DECIDES WHETHER IT MAY BE GIVEN AT ALL (roadmap item
- * 97, step 11). Every format considered is judged by what this viewer's link
- * does with its whole load — the picture and the soundtrack THEY chose
- * (`link-budget.js`). In order:
+ * THE VIEWER'S LINK HELPS CHOOSE A SUSTAINABLE FORMAT, BUT NEVER DECIDES
+ * WHETHER THE VIDEO MAY OPEN. Every format is compared with the measured rate
+ * against the picture and soundtrack they chose (`link-budget.js`). In order:
  *
  * 1. an output already here that suits them (`serving-output.js`);
- * 2. the size wanted, at the highest limit their link admits;
- * 3. in AUTO only, a smaller rung of their ladder at the highest limit their
- *    link admits — a smaller size proves nothing by itself;
- * 4. otherwise NOTHING: the answer is `unavailable`, with the figures, and no
- *    output is named. A format known not to fit is never handed over.
+ * 2. the size wanted, at the highest limit the measured link supports;
+ * 3. in AUTO only, a smaller rung when its measured load fits;
+ * 4. when no sustainable format is available, prepare the first
+ *    machine-supported format in this order and let playback readiness wait
+ *    for its continuous media.
  *
  * Nothing here reads the machine or the disk: what it needs arrives as values
  * and as functions over them.
@@ -39,7 +38,7 @@ import { buildResolutionLadder, canSustainOutput, pickSoftwarePreset } from "../
 import { OutputSpec } from "../output/OutputSpec.js";
 import { throughputAt } from "../throughput.js";
 import { chooseServingOutput, nextRungAreaBelow, servingCandidates } from "./serving-output.js";
-import { linkAnswerFigures, linkCouldCarry, linkRefusalReason, loadOf, videoLoadOfSpec } from "./link-budget.js";
+import { linkAnswerFigures, linkCouldCarry, loadOf, videoLoadOfSpec } from "./link-budget.js";
 
 /**
  * @param {object} params
@@ -67,7 +66,7 @@ import { linkAnswerFigures, linkCouldCarry, linkRefusalReason, loadOf, videoLoad
  *   soundtrack this viewer receives with the picture, from it or beside it.
  * @param {(encode: object | null) => OutputSpec} params.specWith - The output
  *   with this picture format and every other part as the request made it.
- * @param {{ mode: "auto" | "manual", linkMbps: number | null, keys: Iterable<string>, readyAt: (key: string) => boolean, observedPeakMbps?: (spec: OutputSpec) => number | null, serviceShare?: () => number | null }} params.serving
+ * @param {{ mode: "auto" | "manual", linkMbps: number | null, keys: Iterable<string>, readyAt: (key: string) => boolean, observedPeakMbps?: (spec: OutputSpec) => number | null }} params.serving
  * @returns {{
  *   spec: OutputSpec | null,
  *   budget: object | null,
@@ -103,8 +102,7 @@ export function decideOutputFormat({
     loadOf(
       videoLoadOfSpec(spec, Number.isFinite(source.pictureKbps) ? source.pictureKbps / 1000 : null,
         serving.observedPeakMbps?.(spec) ?? null),
-      audioLoad,
-      serving.serviceShare?.() ?? null
+      audioLoad
     )
   );
   const given = (spec, answer, extra = {}) => ({
@@ -122,7 +120,7 @@ export function decideOutputFormat({
     wantedKey: spec.toKey(),
     reusedKey: null,
     answer,
-    unavailable: { reason, figures: answer ? linkAnswerFigures(answer) : null, bound: "link" },
+    unavailable: { reason, figures: answer ? linkAnswerFigures(answer) : null },
     ...extra
   });
 
@@ -134,9 +132,7 @@ export function decideOutputFormat({
       return given(spec, null);
     }
     const answer = judge(spec);
-    return answer.admitted
-      ? given(spec, answer)
-      : refused(spec, answer, linkRefusalReason(answer, "the source's own picture is more than this viewer's link carries"));
+    return given(spec, answer);
   }
 
   const ceiling = computeOutputDimensions(target.width, target.height, source.width, source.height);
@@ -277,6 +273,7 @@ export function decideOutputFormat({
   }
 
   let anySizeHeld = false;
+  let fallback = null;
   if (machineCan(width, height)) {
     for (const spec of wantedFormats) {
       if (!admittedByMachine(spec)) {
@@ -284,7 +281,8 @@ export function decideOutputFormat({
       }
       anySizeHeld = true;
       const answer = judge(spec);
-      if (answer.admitted) {
+      fallback ??= { spec, answer };
+      if (answer.fits) {
         return given(spec, answer, { budget: budgetFor(spec), wantedKey });
       }
     }
@@ -300,7 +298,8 @@ export function decideOutputFormat({
         }
         anySizeHeld = true;
         const answer = judge(spec);
-        if (answer.admitted) {
+        fallback ??= { spec, answer };
+        if (answer.fits) {
           return given(spec, answer, { budget: budgetFor(spec), wantedKey });
         }
       }
@@ -329,16 +328,7 @@ export function decideOutputFormat({
       }
     };
   }
-  const wantedAnswer = judge(wantedSpec);
-  return refused(
-    wantedSpec,
-    wantedAnswer,
-    linkRefusalReason(
-      wantedAnswer,
-      serving.mode === "manual"
-        ? "no limit of the size picked is admitted by this viewer's link"
-        : "no size and limit this viewer's ladder offers is admitted by their link"
-    ),
-    { budget, wantedKey }
-  );
+  // Link measurements are advisory. If none of the sustainable formats can be
+  // used yet, keep the best machine-supported output and let readiness wait.
+  return given(fallback.spec, fallback.answer, { budget: budgetFor(fallback.spec), wantedKey });
 }

package/services/encode/quality/serving-output.js

@@ -3,14 +3,14 @@
  * encode of the format they would otherwise be given.
  *
  * Decided with the user 2026-09-16, and made one rule for every path on
- * 2026-09-23 (roadmap item 97, step 11). Quality is compared by the number of
- * points in the picture. An output qualifies only if the piece at the viewer's
+ * 2026-09-23. Quality is compared by the number of points in the picture.
+ * An output qualifies only if the piece at the viewer's
  * position is already made — material somewhere else in the film spares them
- * nothing — AND the viewer's own link admits its load (`link-budget.js`), in
- * every mode and on every branch. A load whose figure is a bound (`known`) is
+ * nothing — and the viewer's own link can carry its load (`link-budget.js`)
+ * where possible. A load whose figure is a bound (`known`) is
  * taken before one whose figure is an average (`estimated`), whatever their
- * sizes; an `unknown` load is admitted only while nothing has measured the
- * link.
+ * sizes. If none fit the measured rate, format selection prepares a supported
+ * output and readiness waits for media to arrive.
  *
  * AUTOMATIC:
  * 1. at least the quality wanted — the nearest to it;
@@ -20,9 +20,9 @@
  *    waiting: this machine does not hold it at the speed the file needs — the
  *    largest of those.
  *
- * CHOSEN BY HAND: exactly the size chosen — of those, the one with the highest
- * bitrate the link admits. Which encoder made it and at which speed setting do
- * not matter to the viewer.
+ * CHOSEN BY HAND: exactly the size chosen — of sustainable outputs, use the
+ * one with the highest bitrate. Which encoder made it and at which speed
+ * setting do not matter to the viewer.
  *
  * No reading of disk or machine here: every figure arrives as a plain value.
  */
@@ -50,7 +50,7 @@ import { admissionRank } from "./link-budget.js";
  *   keep up with what the file needs. False where nothing measured it.
  * @param {(candidate: Candidate) => boolean} [params.canProduce] - Whether
  *   this machine can keep producing an output that is not finished.
- * @param {(candidate: Candidate) => { admitted: boolean, load: object }} params.judge -
+ * @param {(candidate: Candidate) => { fits: boolean, load: object }} params.judge -
  *   What this viewer's link does with the candidate's whole load.
  * @param {Candidate[]} params.candidates
  * @returns {{ key: string, answer: object } | null} The output to serve, or
@@ -60,7 +60,7 @@ export function chooseServingOutput({ mode, wanted, nextLowerArea, atRisk, canPr
   const admitted = (candidates ?? [])
     .filter((candidate) => candidate.readyHere === true && canProduce(candidate))
     .map((candidate) => ({ candidate, answer: judge(candidate) }))
-    .filter((one) => one.answer.admitted);
+    .filter((one) => one.answer.fits);
   const areaOf = (one) => one.candidate.width * one.candidate.height;
   const rateOf = (one) => one.answer.load.totalMbps ?? 0;
   const byRank = (left, right) => admissionRank(right.answer) - admissionRank(left.answer);
@@ -185,8 +185,8 @@ export function servingCandidates({ wanted, keys, source, encoderName, readyAt }
 
 /**
  * Whether ONE output may serve this viewer: the same material as the picture
- * it would stand in for, the size their mode requires, and a load their own
- * link admits.
+ * it would stand in for, the size their mode requires, and its link estimate
+ * for quality selection.
  *
  * THE ONE RULE EVERY PATH ASKS (roadmap item 97, step 11). The picture
  * answering for its own height, an output found already producing a height,
@@ -201,7 +201,7 @@ export function servingCandidates({ wanted, keys, source, encoderName, readyAt }
  *   output produces; for a copy, the source's.
  * @param {{ width: number, height: number } | null} params.wanted - The size a
  *   viewer who picked by hand must get exactly; ignored in AUTO.
- * @param {(spec: OutputSpec) => { admitted: boolean }} params.judge
+ * @param {(spec: OutputSpec) => { fits: boolean }} params.judge
  * @returns {{ suits: boolean, answer: object | null, reason: string }}
  */
 export function outputSuits({ spec, pictureSpec, mode, size, wanted, judge }) {
@@ -212,7 +212,7 @@ export function outputSuits({ spec, pictureSpec, mode, size, wanted, judge }) {
     return { suits: false, answer: null, reason: "not the size picked" };
   }
   const answer = judge(spec);
-  return answer.admitted
+  return answer.fits
     ? { suits: true, answer, reason: answer.verdict }
     : { suits: false, answer, reason: answer.verdict };
 }

package/services/server/http-responses.js

@@ -2,10 +2,7 @@
  * Shared HTTP responses used by more than one route.
  */
 /**
- * The answer given when no output suits this viewer: nothing this proxy holds
- * or could produce is admitted by their link. Machine-readable, because the
- * page has to explain it to the viewer and offer what they can do; the
- * figures are the ones the decision was made on.
+ * The answer given when no output can be opened.
  *
  * 409 and not a 5xx: nothing is wrong with the proxy, and repeating the same
  * request against the same link gives the same answer.

package/services/server/wire-outputs.js

@@ -239,10 +239,6 @@ export function wireOutputs({
     encodeInputs = null,
     indexMemory = null,
     budgetPolicy = null,
-    // What viewers' connections carry beyond the film, per byte of film, as
-    // the transport measured it (`transport/delivery-shares.js`); null while
-    // nothing has been delivered.
-    serviceShare = () => null,
     onViewerChanged = null,
     // Told when an encoder starts or ends: the room this host has for one more
     // encode changes with it, and the server chooses proxies by that room.
@@ -400,7 +396,6 @@ export function wireOutputs({
     // re-encoded where it may be, and copied where it may not.
     get transcodeEnabled() { return parts.enabled; },
     observedPeakMbps: (spec) => parts.localObservations?.peakMbps(spec) ?? null,
-    serviceShare,
     // A viewer has been moved onto an output prepared for them: how long it
     // took, and what they held.
     notePreparation: (output, seconds, bufferedSec) =>
@@ -599,7 +594,6 @@ export function wireOutputs({
     // The largest peak an output of this mode and rate control has been seen
     // carrying here: the only figure an encoder with no bound of its own has.
     observedPeakMbps: (spec) => parts.localObservations?.peakMbps(spec) ?? null,
-    serviceShare,
     limitsFor: (frame, file) => parts.limitsFor(frame, file),
     readSourceMedia,
     get encodeInputs() { return parts.encodeInputs; },
@@ -1268,7 +1262,6 @@ export function wireOutputs({
   // otherwise.
   // The quality budget: what each output is asked to step to, and the bitrate ceiling a viewer's link sets. Everything it reads of the rest of the proxy is listed here.
   parts.quality = new QualityController({
-    serviceShare,
     // The longest an output of this mode has been seen taking to be ready for
     // a viewer moving onto it, in milliseconds, or null.
     observedPreparationMs: (output) => {

package/services/torrent/download/SwarmSelection.js

@@ -89,6 +89,9 @@ export class SwarmSelection {
     const strictFirstClass = first !== null && !isConditional(first.urgency);
     /** @type {Map<string, { from: number, to: number, priority: number }>} */
     const wanted = new Map();
+    // Who asked for the first class here, for the line that says what the
+    // swarm is told first: which file and which request holds it.
+    const holders = new Set();
     for (const priority of [1, 0]) {
       const ranges = [];
       for (const window of missing) {
@@ -99,6 +102,7 @@ export class SwarmSelection {
           && window.urgency === first.urgency && window.priority >= first.priority;
         if (strictFirstClass && !inFirstClass) continue;
         if ((inFirstClass ? 1 : 0) !== priority) continue;
+        if (priority === 1) holders.add(`${window.fileIndex}:${window.requestId}`);
         const range = this.#piecesFor(window);
         if (range) ranges.push(range);
       }
@@ -114,6 +118,7 @@ export class SwarmSelection {
       for (const range of union) wanted.set(`${range.from}-${range.to}-${priority}`, range);
       if (priority === 1) {
         this.firstClassPieces = union.map(range => range.from === range.to ? `${range.from}` : `${range.from}-${range.to}`);
+        this.firstClassHolders = [...holders].sort();
         this.#required = strictFirstClass ? union.map(({ from, to }) => ({ from, to })) : [];
       }
     }

package/services/torrent/download/registry.js

@@ -285,9 +285,16 @@ export function reconcileAll() {
   for (const entry of entries) entry.limit.sample();
   // What the swarm is told to fetch FIRST, said when it changes. Lower classes
   // are withheld because a wire with no first-class piece would fall through.
+  // And who asked for it, as file:request: a class one torrent holds is what
+  // every other torrent waits behind, so the line names the request holding it.
+  const holdersOf = entry => {
+    const holders = entry.selection.firstClassPieces?.length ? entry.selection.firstClassHolders ?? [] : [];
+    return holders.length ? ` (held by ${holders.slice(0, 4).join(", ")}${holders.length > 4 ? ` +${holders.length - 4} more` : ""})` : "";
+  };
   const said = entries.map(entry => `${String(entry.torrent.infoHash ?? "").slice(0, 8)}: ` +
     `${(entry.selection.firstClassPieces ?? []).slice(0, 8).join(",") || "nothing"}` +
-    `${(entry.selection.firstClassPieces?.length ?? 0) > 8 ? ` +${entry.selection.firstClassPieces.length - 8} more` : ""}`).join("; ");
+    `${(entry.selection.firstClassPieces?.length ?? 0) > 8 ? ` +${entry.selection.firstClassPieces.length - 8} more` : ""}` +
+    holdersOf(entry)).join("; ");
   const head = firstClass ? `${urgencyName(firstClass.urgency)} priority ${firstClass.priority}` : "none";
   firstClassStated = `${head} — pieces ${said}`;
   return { torrents: entries.length, speculativeAllowed, stated, withdrawn };

package/services/transport/data-channel-handler.js

@@ -47,7 +47,6 @@
 /** @import { DataChannel } from 'node-datachannel' */
 
 import { createDeliveryProbe, PROBE_INTERVAL_MS } from "./delivery-probe.js";
-import { DeliveryShares } from "./delivery-shares.js";
 import { Agent } from "undici";
 
 // Route availability and caller cancellation determine media request lifetime.
@@ -885,7 +884,6 @@ export function createDataChannelHandler({
       }
       try {
         channel.sendMessage(message);
-        deliveryShares.recordSent(Buffer.byteLength(message));
         sent += 1;
       } catch {
         // Closed between the lookup and the send. The subscription belongs to
@@ -903,9 +901,7 @@ export function createDataChannelHandler({
   /** Channel-scoped requests cannot be cancelled by a different connection. */
   const activeRequests = new WeakMap();
 
-  // How much of what the connections carry is not the film
-  // (`delivery-shares.js`), counted where both halves are seen.
-  const deliveryShares = new DeliveryShares();
+  // Transport delivery observations used to report link quality.
   const { watchSendQueue, readDelivery, noteBrowserReport } = makeSendQueueWatcher({
     log: (message) => log(message),
     getTransportSnapshot,
@@ -931,8 +927,7 @@ export function createDataChannelHandler({
     readDelivery,
     getTransportSnapshot,
     witness,
-    usrsctpState,
-    onSent: (bytes) => deliveryShares.recordSent(bytes)
+    usrsctpState
   });
 
   /**
@@ -1307,7 +1302,6 @@ export function createDataChannelHandler({
         if (done) {
           chunks += body.flush();
           sendChunk(channel, requestId, null, true);
-          deliveryShares.recordBody(path, totalBytes);
           const elapsedMs = Date.now() - sendStartedAt;
           let bufferedNow = 0;
           try { bufferedNow = typeof channel.bufferedAmount === "function" ? channel.bufferedAmount() : 0; } catch { /* ignore */ }
@@ -1396,7 +1390,6 @@ export function createDataChannelHandler({
     try {
       const frame = encodeFrame(requestIdBytes(requestId), bytes, done);
       channel.sendMessageBinary(frame);
-      deliveryShares.recordSent(frame.length);
     } catch {
       // Channel closed between check and send — safe to ignore.
     }
@@ -1503,7 +1496,6 @@ export function createDataChannelHandler({
     try {
       const text = JSON.stringify(message);
       channel.sendMessage(text);
-      deliveryShares.recordSent(Buffer.byteLength(text));
     } catch {
       // Channel closed between check and send — safe to ignore.
     }
@@ -1512,8 +1504,6 @@ export function createDataChannelHandler({
   return {
     handleChannel,
     publishSubtitleCues,
-    /** What the film costs viewers' links beyond itself, per byte of film, or null. */
-    serviceShare: () => deliveryShares.serviceShare(),
     publishChaptersChanged
   };
 }

package/services/transport/delivery-probe.js

@@ -427,10 +427,7 @@ export function createDeliveryProbe({
   readDelivery,
   getTransportSnapshot,
   witness,
-  usrsctpState,
-  // Every probe handed to a channel, in bytes: what it costs the viewer's link
-  // is counted with everything else the connection carries.
-  onSent = () => {}
+  usrsctpState
 }) {
   /** @type {Map<string, ProbeConnection>} */
   const connections = new Map();
@@ -461,7 +458,6 @@ export function createDeliveryProbe({
     for (const channel of connection.channels.keys()) {
       try {
         channel.sendMessage(message);
-        onSent(Buffer.byteLength(message));
       } catch {
         // A channel closing between the check and the send is ordinary.
       }

package/services/viewer/DownloadMaps.js

@@ -21,13 +21,21 @@ export class DownloadMaps {
   /** What the torrent is told of the playback zones: as many windows as say the same thing. */
   #pack;
   #observeWait;
+  /**
+   * Whether a present viewer holds this file, chosen or listed. A read the
+   * file itself made — its track table, media info, keyframes, cover — has no
+   * owner of its own, so it is wanted exactly while the file is.
+   */
+  #fileWanted;
 
   constructor({ publish, resolvePlayback = async map => map.zones, log = null, now = Date.now,
-    clock = () => performance.timeOrigin + performance.now(), pack = zones => zones, observeWait = null }) {
+    clock = () => performance.timeOrigin + performance.now(), pack = zones => zones, observeWait = null,
+    fileWanted = () => true }) {
     if (typeof publish !== "function") throw new TypeError("Download map publication is required.");
     this.#publish = publish;
     this.#resolvePlayback = resolvePlayback;
     this.#pack = pack;
+    this.#fileWanted = fileWanted;
     this.#log = typeof log === "function" ? log : null;
     this.#now = now;
     this.#clock = clock;
@@ -178,7 +186,14 @@ export class DownloadMaps {
     return Boolean(file && zoneIndexOf(file).exactly({ from, to }));
   }
 
-  metadata({ sourceKey, fileIndex, statement, result, priority = 100, urgent = true, deadlineAt = 0, interval, leadSeconds = 0, scope = "playback", order = 0 }) {
+  /**
+   * @param {object} params
+   * @param {"file"} [params.owner] - `"file"` for a read the file made for
+   *   itself with no viewer's demand behind it. Such a statement is published
+   *   only while {@link DownloadMaps#viewersChanged}'s question says the file
+   *   is held by somebody.
+   */
+  metadata({ sourceKey, fileIndex, statement, result, priority = 100, urgent = true, deadlineAt = 0, interval, leadSeconds = 0, scope = "playback", order = 0, owner }) {
     if (!Number.isFinite(leadSeconds) || leadSeconds < 0) throw new TypeError("Metadata preparation time must be finite and nonnegative.");
     const file = this.#file(sourceKey, fileIndex);
     if (result.kind === "needs-ranges") {
@@ -189,7 +204,8 @@ export class DownloadMaps {
         urgent = current.urgent;
         deadlineAt = Number.isFinite(current.deadlineAt) ? current.deadlineAt - leadSeconds * 1000 : current.deadlineAt;
       }
-      const entry = { ranges: result.ranges, requestId: result.requestId, priority, urgent, deadlineAt, interval, leadSeconds, scope, order };
+      const entry = { ranges: result.ranges, requestId: result.requestId, priority, urgent, deadlineAt, interval, leadSeconds, scope, order,
+        ...(owner === "file" ? { owner } : {}) };
       const previous = file.metadata.get(statement);
       if (previous && sameMetadata(previous, entry) && this.#standing(file)) return this.#unchanged(file);
       file.metadata.set(statement, entry);
@@ -254,6 +270,35 @@ export class DownloadMaps {
     return Promise.all(changed);
   }
 
+  /**
+   * The viewers changed: a file's own reads are published again where whether
+   * anybody holds the file has changed.
+   *
+   * A read the file made for itself states its bytes at the urgency of a
+   * stopped viewer, and the swarm fetches only the most urgent class across
+   * every torrent. Kept after its viewer had gone, the head of a film nobody
+   * was opening any more held that class for the whole proxy: its swarm gave
+   * nothing, and every other film was told to fetch only the piece its viewer
+   * stood on (Home Assistant 2026-10-26, PPPD-452, torrent-tv/meta#239).
+   *
+   * @returns {Promise<unknown[]>}
+   */
+  viewersChanged() {
+    const sent = [];
+    for (const file of this.#files.values()) {
+      const own = [...file.metadata].filter(([, metadata]) => metadata.owner === "file");
+      if (own.length === 0) continue;
+      const wanted = this.#fileWanted(file.sourceKey, file.fileIndex) === true;
+      if (file.ownReadsWanted === wanted) continue;
+      file.ownReadsWanted = wanted;
+      this.#log?.(`download map ${file.sourceKey}:${file.fileIndex}: ${own.length} read(s) of the file itself ` +
+        `${wanted ? "stated again — a viewer holds the file" : "withheld — no present viewer holds the file"} ` +
+        `[${own.map(([statement]) => statement).join(", ")}]`);
+      sent.push(this.#emit(file));
+    }
+    return Promise.all(sent);
+  }
+
   forget(sourceKey, fileIndex, { keepPreparation = false } = {}) {
     const file = this.#file(sourceKey, fileIndex);
     this.#setZones(file, []);
@@ -302,7 +347,10 @@ export class DownloadMaps {
     // Compared and sent as the torrent is to act on it: the playback zones
     // packed into as few windows as say the same (`coalescedZones`).
     const zones = [...this.#packedPlayback(file)];
-    for (const { ranges, requestId, priority, urgent, deadlineAt, order } of file.metadata.values()) {
+    const ownReadsWanted = this.#fileWanted(file.sourceKey, file.fileIndex) === true;
+    file.ownReadsWanted = ownReadsWanted;
+    for (const { ranges, requestId, priority, urgent, deadlineAt, order, owner } of file.metadata.values()) {
+      if (owner === "file" && !ownReadsWanted) continue;
       for (const [byteStart, byteEnd] of ranges) {
         zones.push({ byteStart, byteEnd, priority, urgent, downloadOnly: true, requestId, deadlineAt, ...(order ? { order } : {}) });
       }
@@ -520,6 +568,7 @@ function sameMetadata(left, right) {
   return left.requestId === right.requestId && Object.is(left.priority, right.priority) &&
     left.urgent === right.urgent && Object.is(left.deadlineAt, right.deadlineAt) &&
     Object.is(left.leadSeconds, right.leadSeconds) && left.scope === right.scope && left.order === right.order &&
+    left.owner === right.owner &&
     (left.interval?.from ?? null) === (right.interval?.from ?? null) &&
     (left.interval?.to ?? null) === (right.interval?.to ?? null) &&
     left.ranges.length === right.ranges.length &&

package/services/transport/delivery-shares.js

@@ -1,108 +0,0 @@
-/**
- * @file How much of what this proxy hands to its viewers' connections is not
- * the film.
- *
- * A viewer's link carries the picture and the soundtrack AND everything else
- * this proxy sends down the same connection: the framing of every data-channel
- * message, playlists, answers to progress polls, delivery probes, pushed
- * subtitle cues, segments sent and then abandoned. A load that counts only the
- * picture and the sound asks the link for less than it will be given
- * (torrent-tv/meta#169).
- *
- * What is counted, all of it in bytes handed to a data channel, which is the
- * level the browser's own link measurement is taken at — application bytes,
- * without SCTP, DTLS, UDP or IP framing — and all of it at the moment it is
- * sent, so the three counts always describe the same messages:
- *
- * 1. `sent` — every message handed to a channel, frame headers included;
- * 2. `media` — the bodies of segment and init responses delivered whole;
- * 3. `measurement` — the bodies of the link measurement and the delivery sink,
- *    which are sent when a connection is made or on request and are not part
- *    of watching a film.
- *
- * The share is `(sent - media - measurement) / media`: what the film costs
- * the link beyond itself, per byte of film. Counted over the life of the
- * process and across every connection, because a viewer about to open a film
- * has no history of their own and the traffic around a film is the proxy's,
- * not the person's.
- */
-
-/** Which kind of response a request path asks for. */
-export const DELIVERY_KIND = Object.freeze({
-  MEDIA: "media",
-  MEASUREMENT: "measurement",
-  SERVICE: "service"
-});
-
-const MEDIA_FILE = /\/(?:segment-\d+\.[a-z0-9]+|init\.mp4)$/u;
-const MEASUREMENT_ROUTE = /^\/api\/(?:link-probe|delivery-sink)$/u;
-
-/**
- * What a data-channel request path asks for.
- *
- * @param {string} path - The request path, query included or not.
- * @returns {string} One of {@link DELIVERY_KIND}.
- */
-export function deliveryKindOf(path) {
-  const bare = String(path ?? "").split("?")[0];
-  if (MEDIA_FILE.test(bare)) return DELIVERY_KIND.MEDIA;
-  if (MEASUREMENT_ROUTE.test(bare)) return DELIVERY_KIND.MEASUREMENT;
-  return DELIVERY_KIND.SERVICE;
-}
-
-export class DeliveryShares {
-  #sent = 0;
-  #media = 0;
-  #measurement = 0;
-
-  /**
-   * A response body handed over whole.
-   *
-   * @param {string} path
-   * @param {number} bytes
-   */
-  recordBody(path, bytes) {
-    if (!(Number.isFinite(bytes) && bytes > 0)) return;
-    const kind = deliveryKindOf(path);
-    if (kind === DELIVERY_KIND.MEDIA) this.#media += bytes;
-    else if (kind === DELIVERY_KIND.MEASUREMENT) this.#measurement += bytes;
-  }
-
-  /**
-   * One message handed to a channel, whatever it carries.
-   *
-   * @param {number} bytes
-   */
-  recordSent(bytes) {
-    if (Number.isFinite(bytes) && bytes > 0) this.#sent += bytes;
-  }
-
-  /**
-   * What the film costs the link beyond itself, per byte of film, or null
-   * while no film has been delivered.
-   *
-   * Never below zero: a body is counted once its last message has gone, so
-   * the two counts agree exactly between responses and the body's own
-   * messages are already in `sent` when it is counted.
-   *
-   * @returns {number | null}
-   */
-  serviceShare() {
-    if (this.#media <= 0) return null;
-    return Math.max(0, (this.#sent - this.#media - this.#measurement) / this.#media);
-  }
-
-  /**
-   * The counts behind the share, for a log line.
-   *
-   * @returns {{ sentBytes: number, mediaBytes: number, measurementBytes: number, serviceShare: number | null }}
-   */
-  figures() {
-    return {
-      sentBytes: this.#sent,
-      mediaBytes: this.#media,
-      measurementBytes: this.#measurement,
-      serviceShare: this.serviceShare()
-    };
-  }
-}