@torrent-tv/proxy 2.91.0 → 2.92.0

package/services/server/wire-outputs.js

@@ -14,6 +14,7 @@ import { waits } from "./WaitLedger.js";
 import { readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "../encode/host-load.js";
 import { minimumBufferFrom } from "../torrent/supply-margin.js";
 import { PriorityOrchestrator } from "../viewer/PriorityOrchestrator.js";
+import { urgentOutputsReady } from "../viewer/urgent-output-ready.js";
 import { softwareDescriptor } from "../encode/hwaccel.js";
 import { resolveSegmentFormat } from "../encode/segment-formats/index.js";
 import { Timelines } from "../encode/output/Timeline.js";
@@ -74,6 +75,7 @@ import { audioRenditionName } from "../media/audio-inventory.js";
 import { Renditions } from "../encode/Renditions.js";
 import { CushionReport, LOOKAHEAD_PAUSE_SECONDS } from "../encode/CushionReport.js";
 import { EncodeRuns } from "../encode/EncodeRuns.js";
+import { EncodeInputs } from "../encode/EncodeInputs.js";
 import { OutputTimes } from "../encode/OutputTimes.js";
 import { HostLoad } from "../encode/quality/HostLoad.js";
 import { HostTimings } from "../encode/quality/HostTimings.js";
@@ -87,8 +89,6 @@ import { OutputSpec } from "../encode/output/OutputSpec.js";
 import { compareInits } from "../encode/segment-formats/init-compat.js";
 import { nominalKbpsFor, AUDIO_TRANSCODE_KBPS } from "../encode/args.js";
 import { audioReadingFor } from "../encode/audio-work-rate.js";
-import { probeInputMediaInfo } from "../media/media-info-probe.js";
-import { probeVideoKeyframeTimes } from "../media/keyframe-probe.js";
 import { wireMachineBudget } from "../storage/wire.js";
 import { Returns } from "../storage/returns.js";
 import { freeBytesFor } from "../storage/free.js";
@@ -217,7 +217,6 @@ export function wireOutputs({
     getCachedMediaInfo = null,
     getCachedAudioTracks = null,
     getContainerMediaInfo = null,
-    fetchWholeFile = null,
     segmentFormatId = undefined,
     stateDir = "",
     segmentStore = null,
@@ -228,7 +227,15 @@ export function wireOutputs({
     diagnostics = null,
     diagnosticsRoot = "",
     memoryClaimant = null,
-    budgetPolicy = null}) {
+    resolveEncodeInput = null,
+    readSourceMedia = null,
+    readMetadataActivity = null,
+    sourceInputsFor = null,
+    readEncodeRanges = null,
+    encodeInputs = null,
+    indexMemory = null,
+    budgetPolicy = null,
+    onViewerChanged = null}) {
   const parts = {};
   const audioDescriptionOf = (output) => (getCachedAudioTracks?.({
     sourceKey: output.file.sourceKey, fileIndex: output.spec.grid?.fileIndex ?? output.file.fileIndex
@@ -284,6 +291,7 @@ export function wireOutputs({
   parts.limitsFor = (frame) => [nominalKbpsFor(frame)];
   // What the torrent and the proxy itself spend on this host, and how fast each watched torrent moves.
   parts.hostLoad = new HostLoad({
+    readMetadataActivity,
     readMachineState,
     readProcessCpuSeconds,
     readProxyCpuSeconds,
@@ -326,7 +334,7 @@ export function wireOutputs({
       });
     },
     viewerSecondsOn: (output, consumerId, now) => viewerSecondsOn(parts.viewers, output, consumerId, now),
-    inputOf: (...args) => parts.renditions.inputOf(...args),
+    get encodeInputs() { return parts.encodeInputs; },
     producedNumbers: (...args) => parts.serving.producedNumbers(...args),
     servesAudioSeparately: (...args) => parts.renditions.servesAudioSeparately(...args),
     disposeSession: (...args) => parts.lifecycle.disposeSession(...args),
@@ -352,7 +360,6 @@ export function wireOutputs({
     logger,
     producedNumbers: (...args) => parts.serving.producedNumbers(...args),
     get encodeRuns() { return parts.encodeRuns; },
-    get fetchWholeFile() { return parts.fetchWholeFile; },
     get getCachedAudioTracks() { return parts.getCachedAudioTracks; },
     get hostLoad() { return parts.hostLoad; },
     get lookaheadSeconds() { return parts.lookaheadSeconds; },
@@ -523,8 +530,8 @@ export function wireOutputs({
     // carrying here: the only figure an encoder with no bound of its own has.
     observedPeakMbps: (spec) => parts.localObservations?.peakMbps(spec) ?? null,
     limitsFor: (frame) => parts.limitsFor(frame),
-    probeMediaInfo: (url) => probeInputMediaInfo(parts.ffmpegBin, url),
-    probeKeyframeTimes: (url, budgetMs) => probeVideoKeyframeTimes(parts.ffmpegBin, url, budgetMs),
+    readSourceMedia,
+    get encodeInputs() { return parts.encodeInputs; },
     get decodeCostModel() { return parts.decodeCostModel; },
     get enabled() { return parts.enabled; },
     get encodeCost() { return parts.encodeCost; },
@@ -565,6 +572,7 @@ export function wireOutputs({
     // When this viewer's playback can start and run to the end: the viewer
     // component's forecast, which models the viewer's browser.
     playbackReadiness: { predict: predictPlaybackReadiness, forecastRate, RateTrend },
+    sourceInputsFor: (output, index) => parts.sourceInputsFor?.(output, index),
     encodeSpeedReadingOf: (output) => parts.encodeCost.latestSpeedReadingOf(output),
     projectedEncodeSpeedOf: (output) => parts.encodeCost.projectedSpeedOf(output),
     audioDescriptionOf,
@@ -615,6 +623,7 @@ export function wireOutputs({
   });
   parts.enabled = Boolean(enabled);
   parts.ffmpegBin = ffmpegBin;
+  parts.sourceInputsFor = typeof sourceInputsFor === "function" ? sourceInputsFor : null;
   parts.keyframeTables = keyframeTables;
   // Where measurements about this host are kept between runs. Empty means
   // beside the installed proxy; a deployment with somewhere persistent to
@@ -637,12 +646,6 @@ export function wireOutputs({
   // it meant reading a header this proxy had already read.
   parts.getContainerMediaInfo =
     typeof getContainerMediaInfo === "function" ? getContainerMediaInfo : null;
-  // Fetch one whole file of a source, as a bounded read rather than a
-  // selection. Used to pull a soundtrack that ships beside the picture onto
-  // the disk while the swarm has capacity to spare — see
-  // `#fetchSpareSoundtracks`. Optional: a proxy wired without it simply reads
-  // such a soundtrack when it is played.
-  parts.fetchWholeFile = typeof fetchWholeFile === "function" ? fetchWholeFile : null;
   // Optional async accessor for a source's live download stats, used by the
   // realtime budget to tell a CPU limit from a download-starved input:
   // (sourceKey, fileIndex) => Promise<{ downloadSpeed, fileLength, fileProgress } | null>.
@@ -760,7 +763,10 @@ export function wireOutputs({
   // exist, because that decision reads nothing else about viewers. It used to
   // be re-taken on a five-second timer instead, which made a just-created
   // output wait up to five seconds before anything noticed it had a viewer.
-  parts.viewers = new Viewers({ onChange: () => parts.encodeRuns.planEncodersSoon() });
+  parts.viewers = new Viewers({ onChange: () => {
+    parts.encodeRuns.planEncodersSoon();
+    onViewerChanged?.();
+  } });
   // The outputs that exist, and every question about them: the picture a step
   // belongs to, the steps, the soundtracks, the height a step is named by.
   parts.outputs = new OutputCatalog({
@@ -863,6 +869,19 @@ export function wireOutputs({
     // a step supersedes belongs to the film's shape. Neither layer is handed
     // the other — one gets a plain id, the other is read for one field.
     watchedBy: (session, viewer) => !parts.outputs.supersededBy(session, viewer.activeVariantId ?? null),
+    urgentReadyFor: (session, viewer, seconds, now) => {
+      if (parts.subtitleReadyFor?.(viewer) === false) return false;
+      return urgentOutputsReady({
+        sourceKey: session.file.sourceKey, fileIndex: session.file.fileIndex,
+        durationSeconds: session.file.durationSeconds, atSeconds: viewer.positionSeconds(now) ?? 0, seconds,
+        outputs: parts.outputs.values(),
+        consumed: (output) => parts.viewers.forOutput(output).has(viewer.id) &&
+          !parts.outputs.supersededBy(output, viewer.activeVariantId ?? null),
+        segmentIndex: (output, at) => parts.outputTimes.segmentIndexForTime(output, at),
+        segmentStart: (output, index) => parts.outputTimes.segmentStartTime(output, index),
+        closed: (key, index) => parts.segmentStore.isClosed(key, index)
+      });
+    },
     allowanceFor: (session) => minimumBufferFrom({
       segmentSeconds: parts.segmentDurationSec,
       worstSupplyWaitSec: parts.hostLoad.supplyFor(session.file)?.worstWaitSec
@@ -910,6 +929,9 @@ export function wireOutputs({
     availability: () => parts.hostLoad.hostAvailability ?? null
   });
   parts.encodeOrchestrator = new EncodeOrchestrator({
+    inputDemandChanged: (address, windows) => {
+      for (const output of parts.outputs.outputsOn(address)) parts.encodeInputs?.retain(output, windows);
+    },
     admission: parts.admission,
     // What the viewers actually waited for, by band. The ledger is the
     // priority layer's; the encoding is handed a way to ask it.
@@ -951,6 +973,25 @@ export function wireOutputs({
   // one term of the keeping period that is guessed rather than measured, and
   // the only place it can be measured from.
   parts.returns = new Returns();
+  parts.encodeInputs = encodeInputs ?? (typeof resolveEncodeInput === "function" ? new EncodeInputs({
+    resolve: resolveEncodeInput,
+    readRanges: readEncodeRanges,
+    reviseBudget: () => parts.machineBudget.revise(),
+    capacity: () => parts.machineBudget.capacityOf("memory"),
+    urgent: (output, index) => parts.encodeOrchestrator.wantedSegmentsOn(output.outputKey).some(window =>
+      index >= window.from && index <= window.to && window.withinSeconds === 0),
+    changed: (output, result) => {
+      if (result.kind === "terminal") {
+        logger.warn(`encode input output=${output.outputKey} terminal=${result.reason}: ${result.message ?? ""}`);
+        parts.serving.invalidateWaits(output);
+      }
+      parts.encodeRuns.planEncodersSoon();
+    },
+    failed: (output, error) => {
+      logger.warn(`encode input output=${output.outputKey} failed: ${error.message}`);
+      parts.serving.invalidateWaits(output);
+    }
+  }) : null);
   // One owner of the disk, and the list of what takes it lives with the owner.
   parts.machineBudget = wireMachineBudget({
     segmentStore: parts.segmentStore,
@@ -959,6 +1000,8 @@ export function wireOutputs({
     diagnostics: parts.diagnostics,
     diagnosticsRoot: parts.diagnosticsRoot,
     memory: parts.memoryClaimant,
+    encodeInputs: parts.encodeInputs,
+    indexMemory,
     policy: parts.budgetPolicy ?? undefined,
     readFree: freeBytesFor,
     logger

package/services/storage/IndexMemory.js

@@ -0,0 +1,85 @@
+/** Exact binary index ownership and pending growth under the shared budget. */
+export class IndexMemory {
+  #files = new Map();
+  #held = 0;
+  #packetBytes = 0;
+  #allowed = 0;
+  #revise;
+  #changed;
+  #revisionQueued = false;
+
+  constructor({ reviseBudget, changed }) {
+    this.#revise = reviseBudget;
+    this.#changed = changed;
+  }
+
+  held() { return this.#held; }
+  packetBytes() { return this.#packetBytes; }
+  wanted() {
+    return this.#held + [...this.#files.values()].reduce((sum, file) => sum + Math.max(0, file.needed - file.held), 0);
+  }
+  required() { return this.wanted(); }
+
+  allow(bytes) {
+    const allowed = Math.max(0, bytes);
+    if (allowed === this.#allowed) return;
+    this.#allowed = allowed;
+    this.#changed?.();
+  }
+
+  #requestRevision() {
+    if (this.#revisionQueued) return;
+    this.#revisionQueued = true;
+    queueMicrotask(() => {
+      this.#revisionQueued = false;
+      this.#revise?.();
+    });
+  }
+
+  forFile(sourceKey, fileIndex) {
+    const key = JSON.stringify([sourceKey, fileIndex]);
+    let file = this.#files.get(key);
+    if (file) return file.memory;
+    file = { sourceKey, held: 0, needed: 0, records: new Set(), closed: false };
+    file.memory = { forRecord: (record, kind = "packets") => {
+      file.records.add(record);
+      let disposed = false;
+      return {
+        reserve: bytes => {
+          if (file.closed || disposed) return false;
+          if (this.#held + bytes > this.#allowed) {
+            const needed = file.held + bytes;
+            if (needed > file.needed) { file.needed = needed; this.#requestRevision(); }
+            return false;
+          }
+          file.held += bytes;
+          this.#held += bytes;
+          if (kind === "packets") this.#packetBytes += bytes;
+          if (file.held >= file.needed) file.needed = 0;
+          return true;
+        },
+        release: bytes => {
+          file.held -= bytes;
+          this.#held -= bytes;
+          if (kind === "packets") this.#packetBytes -= bytes;
+          this.#requestRevision();
+        },
+        dispose: () => { disposed = true; file.records.delete(record); }
+      };
+    } };
+    this.#files.set(key, file);
+    return file.memory;
+  }
+
+  forget(sourceKey) {
+    for (const [key, file] of this.#files) {
+      if (file.sourceKey !== sourceKey) continue;
+      file.closed = true;
+      file.needed = 0;
+      for (const record of [...file.records]) record.dispose();
+      this.#files.delete(key);
+    }
+    this.#requestRevision();
+    this.#changed?.();
+  }
+}

package/services/storage/MachineBudget.js

@@ -75,6 +75,8 @@ import { OtherDemand, divideAllowance } from "./allowance.js";
  */
 
 export class MachineBudget {
+  #revisionPromise = null;
+  #reviseAgain = false;
   /** Resource name → how to read what is free, and what others have needed. */
   #resources = new Map();
 
@@ -135,12 +137,33 @@ export class MachineBudget {
     this.#claimants = this.#claimants.filter((one) => one.name !== name);
   }
 
+  /** Total measured policy allowance, independent of its current division. */
+  capacityOf(name) {
+    const reading = this.#last.get(name);
+    return reading?.measured ? reading.allowanceBytes : null;
+  }
+
   /**
    * Read every resource, divide each, and tell each claimant its share.
    *
    * @returns {Promise<Map<string, { freeBytes: number, allowanceBytes: number, shares: object[] }>>}
    */
-  async revise() {
+  revise() {
+    if (this.#revisionPromise) {
+      this.#reviseAgain = true;
+      return this.#revisionPromise;
+    }
+    this.#revisionPromise = (async () => {
+      do {
+        this.#reviseAgain = false;
+        await this.#readRevision();
+      } while (this.#reviseAgain);
+      return this.#last;
+    })().finally(() => { this.#revisionPromise = null; });
+    return this.#revisionPromise;
+  }
+
+  async #readRevision() {
     for (const [name, resource] of this.#resources) {
       const claimants = this.#claimants.filter((one) => one.resource === name);
       if (claimants.length === 0) {
@@ -153,14 +176,15 @@ export class MachineBudget {
       // there is how the spill file came to have no limit in the first place.
       const freeBytes = Number.isFinite(free) && free !== null ? Math.max(0, free) : 0;
       const allowanceBytes = this.#allowanceFor(name, resource, freeBytes, held);
-      const shares = divideAllowance(claimants.map((one) => Math.max(0, one.wanted())), allowanceBytes);
+      const shares = divideAllowance(claimants.map((one) => Math.max(0, one.wanted())), allowanceBytes,
+        claimants.map(one => Math.max(0, one.required?.() ?? 0)));
       const reading = claimants.map((one, position) => ({
         name: one.name,
         held: one.held(),
         allowed: shares[position],
         short: Number.isFinite(one.minimum) && shares[position] < one.minimum
       }));
-      this.#last.set(name, { freeBytes, allowanceBytes, shares: reading });
+      this.#last.set(name, { freeBytes, allowanceBytes, measured: Number.isFinite(free) && free !== null, shares: reading });
       for (const [position, one] of claimants.entries()) {
         one.allow(shares[position]);
       }

package/services/storage/allowance.js

@@ -98,7 +98,14 @@ export function machineAllowanceBytes(freeBytes, heldBytes, reserveBytes) {
  * @param {number} allowanceBytes
  * @returns {number[]} What each store may hold, in the same order.
  */
-export function divideAllowance(wantedBytes, allowanceBytes) {
+export function divideAllowance(wantedBytes, allowanceBytes, requiredBytes = []) {
+  const required = wantedBytes.map((wanted, index) => Math.min(Math.max(0, wanted), Math.max(0, requiredBytes[index] ?? 0)));
+  const requiredTotal = required.reduce((sum, bytes) => sum + bytes, 0);
+  if (requiredTotal > 0) {
+    if (requiredTotal >= allowanceBytes) return divideAllowance(required, allowanceBytes);
+    const remaining = divideAllowance(wantedBytes.map((wanted, index) => Math.max(0, wanted - required[index])), allowanceBytes - requiredTotal);
+    return remaining.map((bytes, index) => bytes + required[index]);
+  }
   const total = wantedBytes.reduce((sum, want) => sum + Math.max(0, want), 0);
   if (total <= allowanceBytes || total === 0) {
     return wantedBytes.map((want) => Math.max(0, want));

package/services/storage/piece-store/piece-disk-store.js

@@ -80,6 +80,8 @@ export class PieceDiskStore {
 
   /** Where the live readers stand, from whoever holds that fact. @type {() => number[]} */
   #readHeads;
+  #canForget;
+  #wantedAt;
 
   /**
    * Said whenever this tier stops holding a piece, whatever the reason.
@@ -107,12 +109,16 @@ export class PieceDiskStore {
     allowanceBytes = null,
     now = Date.now,
     readHeads = () => [],
+    canForget = () => true,
+    wantedAt = null,
     onForgotten = () => undefined
   }) {
     this.#directory = path.join(directory, name);
     this.#allowanceBytes = Number.isFinite(allowanceBytes) && allowanceBytes >= 0 ? allowanceBytes : null;
     this.#now = now;
     this.#readHeads = typeof readHeads === "function" ? readHeads : () => [];
+    this.#canForget = canForget;
+    this.#wantedAt = wantedAt;
     this.#onForgotten = typeof onForgotten === "function" ? onForgotten : () => undefined;
     this.#adoptWhatIsAlreadyHere();
   }
@@ -211,6 +217,7 @@ export class PieceDiskStore {
    */
   reviseAllowance(bytes) {
     this.#allowanceBytes = Number.isFinite(bytes) && bytes >= 0 ? bytes : null;
+    this.#makeRoomFor(0, -1);
     return this.#allowanceBytes;
   }
 
@@ -358,7 +365,7 @@ export class PieceDiskStore {
    * @returns {void}
    */
   forget(index) {
-    if (this.#reading.has(index)) {
+    if (this.#reading.has(index) || !this.#canForget(index)) {
       return;
     }
     const length = this.#stored.get(index);
@@ -482,7 +489,7 @@ export class PieceDiskStore {
    * @param {number} incomingIndex
    * @returns {Promise<void>}
    */
-  async #makeRoomFor(incomingBytes, incomingIndex) {
+  #makeRoomFor(incomingBytes, incomingIndex) {
     if (this.#allowanceBytes === null) {
       return;
     }
@@ -519,7 +526,15 @@ export class PieceDiskStore {
     let victim = null;
     let worst = null;
     for (const [index, at] of this.#touched) {
-      if (index === except || this.#reading.has(index)) {
+      if (index === except || this.#reading.has(index) || !this.#canForget(index)) {
+        continue;
+      }
+      if (this.#wantedAt) {
+        const want = this.#wantedAt(index);
+        if (worst === null || want > worst.want || (want === worst.want && at < worst.at)) {
+          worst = { want, at };
+          victim = index;
+        }
         continue;
       }
       const behind = earliest !== null && index < earliest;

package/services/storage/piece-store/piece-lru.js

@@ -251,8 +251,10 @@ export class PieceLru {
   wantAt(index) {
     let want = Number.POSITIVE_INFINITY;
     for (const range of this.#protected.values()) {
-      if (index >= range.from && index <= range.to && range.urgency < want) {
-        want = range.urgency;
+      const deadline = range.deadlineAt === undefined ? range.urgency :
+        Number.isFinite(range.deadlineAt) ? range.deadlineAt : Number.MAX_SAFE_INTEGER - range.priority;
+      if (index >= range.from && index <= range.to && deadline < want) {
+        want = deadline;
       }
     }
     return want;
@@ -432,14 +434,16 @@ export class PieceLru {
    *   displace a stated one.
    * @returns {void}
    */
-  protect(readerId, from, to, urgency) {
+  protect(readerId, from, to, urgency, deadlineAt, priority = 1) {
     if (!Number.isInteger(from) || !Number.isInteger(to) || to < from) {
       return;
     }
     this.#protected.set(readerId, {
       from,
       to,
-      urgency: Number.isFinite(urgency) ? Number(urgency) : Number.MAX_SAFE_INTEGER
+      urgency: Number.isFinite(urgency) ? Number(urgency) : Number.MAX_SAFE_INTEGER,
+      deadlineAt,
+      priority
     });
   }
 

package/services/storage/piece-store/shared-piece-store.js

@@ -530,6 +530,8 @@ export class SharedPieceStore {
       // Where the live readers stand, so what goes first is decided by them and
       // not by which piece happened to be touched longest ago.
       readHeads: () => this.#lru.readHeads(),
+      canForget: (index) => !this.#lru.isPinned(index),
+      wantedAt: (index) => this.#lru.wantAt(index),
       // EVERY WAY A PIECE LEAVES THE DISK COMES THROUGH HERE — behind the read
       // heads, over the allowance, dropped as a duplicate, or forgotten while a
       // spill finished. One listener instead of a list of call sites to
@@ -631,19 +633,13 @@ export class SharedPieceStore {
    * @returns {{ name: string, allowanceBytes: number | null, bytes: number }}
    */
   reviseSpillCeiling(allowedBytes) {
-    // THE OTHER RULE, and it does not wait for the disk to be short. A piece
-    // behind every read head has been read and will not be read again unless
-    // somebody seeks back, and a seek back re-downloads it — the same bargain
-    // this tier makes whenever it drops a piece for room. Without it the spill
-    // is bounded only by a share of free space, which on a roomy host is tens of
-    // gigabytes against a measured growth of 14 400 MB in one viewing: the
-    // ceiling never binds and nothing is ever removed until the torrent goes.
-    const behind = this.#disk.forgetBehind(this.#lru.readHeads());
+    // Downloaded material is removed only for capacity. Playback position
+    // alone cannot invalidate bytes needed by another viewer or a later seek.
     return {
       name: this.#name,
       allowanceBytes: this.#disk.reviseAllowance(allowedBytes),
       bytes: this.#disk.bytes,
-      behind
+      behind: 0
     };
   }
 
@@ -816,10 +812,29 @@ export class SharedPieceStore {
 
   /** Availability belongs to the store, not to a second cached bitfield. */
   locationOf(index) {
+    if (this.#closed || !Number.isSafeInteger(index) || index < 0 ||
+        (this.#lastChunkIndex >= 0 && index > this.#lastChunkIndex)) return "missing";
     return this.#buffers.has(index) ? "memory" : this.#evicting.has(index) ? "writing" :
       this.#disk.has(index) ? "disk" : this.isInWholeFiles(index) ? "whole-file" : "missing";
   }
 
+  /** Atomically acquire holds only when every requested piece is present. */
+  holdAvailable(indexes) {
+    if (this.#closed || !Array.isArray(indexes)) return null;
+    const unique = [...new Set(indexes)];
+    if (unique.some((index) => !Number.isInteger(index) || index < 0 || this.locationOf(index) === "missing")) {
+      return null;
+    }
+    for (const index of unique) this.#lru.pin(index);
+    let held = true;
+    return () => {
+      if (!held) return;
+      held = false;
+      for (const index of unique) this.#lru.unpin(index);
+      this.#noteProgress();
+    };
+  }
+
   pin(index) {
     this.#lru.pin(index);
     // A piece reader pins before it waits for the bytes to arrive or return
@@ -1833,8 +1848,8 @@ export class SharedPieceStore {
    * @param {number} [urgency]
    * @returns {void}
    */
-  protectRange(readerId, from, to, urgency) {
-    this.#lru.protect(readerId, from, to, urgency);
+  protectRange(readerId, from, to, urgency, deadlineAt, priority) {
+    this.#lru.protect(readerId, from, to, urgency, deadlineAt, priority);
     // A READER DECLARES ITSELF IN A MOMENT; the allowance was re-derived once a
     // minute. Between the two a read met whatever the store had shrunk to while
     // nobody was reading, and a claim gives up after five seconds — twelve