@torrent-tv/proxy 2.101.6 → 2.101.7

package/package.json

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

package/routes/encode-input/get.js

@@ -1,4 +1,5 @@
 import { parseRange } from "../../utils/parse-range.js";
+import { Readable } from "node:stream";
 
 /** FFmpeg reads only original byte ranges already owned by its live run. */
 export async function handleEncodeInputGet(req, reply, { inputOf, refused = () => {} }) {
@@ -53,10 +54,12 @@ export async function handleEncodeInputGet(req, reply, { inputOf, refused = () =
   const socket = req.raw?.socket;
   const writtenBefore = socket?.bytesWritten ?? 0;
   reply.raw?.once?.("close", () => {
+    held.release?.();
     input.noteAnswer?.({ fileIndex, start: range.start, end: held.end,
       written: Math.max(0, (socket?.bytesWritten ?? writtenBefore) - writtenBefore),
       handedOver: reply.raw?.writableFinished === true });
   });
-  return reply.code(206).header("Content-Length", String(held.bytes.length))
-    .header("Content-Range", `bytes ${range.start}-${held.end}/${length}`).send(held.bytes);
+  return reply.code(206).header("Content-Length", String(held.size ?? held.bytes.length))
+    .header("Content-Range", `bytes ${range.start}-${held.end}/${length}`)
+    .send(held.stream ?? (held.chunks ? Readable.from(held.chunks, { objectMode: false }) : held.bytes));
 }

package/server.js

@@ -978,22 +978,26 @@ export async function startProxyServer({
           return answer && typeof answer.then !== "function" && answer.end === end ? answer.bytes : null;
         };
         const holdsUntil = start => {
+          if (input.heldUntil) return input.heldUntil(source.fileIndex, start);
           const range = source.input.ranges.find(([first, last]) => first <= start && start <= last);
           return range ? range[1] + 1 : null;
         };
         const startedAt = Date.now();
+        const releaseInput = input.retain?.();
         void container.learnPackets({ from: source.input.from, to: source.input.to, trackIds: [...sounds] }, read, holdsUntil).then(learned =>
           logger.info(`encode input #${from}..#${to} of ${output.outputKey}: soundtrack packets of track(s) ${[...sounds].join(",")} ` +
             `over ${source.input.from.toFixed(3)}-${source.input.to.toFixed(3)}s ` +
             (learned === "walked" ? "walked" : `not all walked (${learned === "memory" ? "memory refused" : "the copy does not hold the rest"})`) +
             ` from its copy in ${Date.now() - startedAt}ms`),
-        error => logger.warn(`encode input #${from}..#${to} of ${output.outputKey}: walking the soundtrack from its copy failed: ${error?.message ?? error}`));
+        error => logger.warn(`encode input #${from}..#${to} of ${output.outputKey}: walking the soundtrack from its copy failed: ${error?.message ?? error}`))
+          .finally(() => releaseInput?.());
       }
     },
     readEncodeRanges: async (source, ranges, maxBytes) => {
       const torrent = torrentPool.knownTorrent(source.sourceKey);
       return torrent ? torrentPool.readHeldRangesOf(torrent, source.fileIndex, ranges, maxBytes) : null;
     },
+    openEncodeWholeFile: source => torrentPool.acquireWholeFile(source),
     // Which bytes of a file are downloaded whole now — what an original
     // input's stretch may extend over. A snapshot: the copy that follows
     // holds the pieces it reads, and refuses where one has gone since.
@@ -1036,6 +1040,7 @@ export async function startProxyServer({
     wholeFiles: typeof torrentPool.allowWholeFileBytes === "function"
       ? {
           held: () => torrentPool.wholeFileBytes ?? 0,
+          required: () => torrentPool.wholeFileRequiredBytes ?? 0,
           allow: (bytes) => torrentPool.allowWholeFileBytes(bytes),
           root: completedFilesRoot()
         }

package/services/encode/EncodeInputs.js

@@ -1,5 +1,6 @@
 import { admitInput } from "./AdmittedInput.js";
 import { admitOriginalInput, originalInputBytes } from "./OriginalInput.js";
+import { OriginalInputStore } from "./OriginalInputStore.js";
 
 /**
  * How many recent readings a learned figure here is taken from: long enough
@@ -32,6 +33,7 @@ export class EncodeInputs {
   #preparedIn = new WeakMap();
   #memoryRevision = 0;
   #held = 0;
+  #shared = new OriginalInputStore({ changed: () => queueMicrotask(() => this.memoryChanged()) });
   #allowed = 0;
   /** What each preparing request asks of memory: all it would use, and the least it can run with. */
   #wanted = new Map();
@@ -46,6 +48,7 @@ export class EncodeInputs {
   #openOf;
   #resolve;
   #read;
+  #openWholeFile;
   #heldRanges;
   #revise;
   #changed;
@@ -63,12 +66,13 @@ export class EncodeInputs {
    */
   #stretchCopied;
 
-  constructor({ resolve, readRanges, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true,
+  constructor({ resolve, readRanges, openWholeFile = null, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true,
     rankAt = () => null, openOf = () => null, log = () => {}, now = Date.now, stretchCopied = () => {} }) {
     this.#stretchCopied = stretchCopied;
     this.#openOf = openOf;
     this.#resolve = resolve;
     this.#read = readRanges;
+    this.#openWholeFile = openWholeFile;
     this.#heldRanges = heldRanges;
     this.#revise = reviseBudget;
     this.#changed = changed;
@@ -95,7 +99,7 @@ export class EncodeInputs {
     const serves = request.serves ?? request.from;
     const rank = this.#rankAt(request.output, serves);
     this.#log(`encode input #${request.from}..#${request.to} of ${request.output.outputKey ?? request.output.id}: ${state}` +
-      ` (held ${this.#held} of ${this.#allowed} allowed; for #${serves}` +
+      ` (held ${this.held()} of ${this.#allowed} allowed; for #${serves}` +
       `${rank ? `, rank ${rank.rank} of ${rank.topRank}` : ""})${detail}`);
   }
 
@@ -120,10 +124,10 @@ export class EncodeInputs {
     }
   }
 
-  held() { return this.#held; }
-  wanted() { return this.#held + [...this.#wanted.values()].reduce((sum, asked) => sum + asked.wanted, 0); }
+  held() { return this.#held + this.#shared.bytes; }
+  wanted() { return this.held() + [...this.#wanted.values()].reduce((sum, asked) => sum + asked.wanted, 0); }
   required() {
-    let bytes = this.#held;
+    let bytes = this.#held + this.#shared.required;
     for (const [key, asked] of this.#wanted) {
       // The encode plan already chose this finite input. Its least runnable
       // part must fit before production can advance, even when playback has
@@ -137,6 +141,7 @@ export class EncodeInputs {
   allow(bytes) {
     const changed = this.#allowed !== Math.max(0, bytes);
     this.#allowed = Math.max(0, bytes);
+    this.#shared.trim(this.#allowed - this.#held);
     if (changed) this.memoryChanged();
   }
 
@@ -320,6 +325,7 @@ export class EncodeInputs {
       this.#wanted.delete(key);
       request.result?.release?.();
     }
+    this.#shared.forget(output);
   }
 
   /**
@@ -409,7 +415,23 @@ export class EncodeInputs {
       if (resolved.kind !== "result") {
         result = resolved;
       } else if (resolved.sources?.every(source => source.input.original === true)) {
-        result = await this.#admitStretch(request, resolved.sources);
+        const sharing = resolved.sources.every(source => Array.isArray(source.input.commonRanges));
+        if (sharing) this.#shared.retain(request.output, resolved.sources);
+        const files = new Map();
+        let unpin = () => {};
+        try {
+          for (const source of resolved.sources) {
+            const file = await this.#openWholeFile?.(source);
+            if (file && file.length === source.input.fileLength) files.set(source.fileIndex, file);
+            else if (file) await file.release();
+            if (this.#requests.get(request.key) !== request) return;
+          }
+          if (sharing) unpin = this.#shared.protect(resolved.sources.filter(source => !files.has(source.fileIndex)));
+          result = await this.#admitStretch(request, resolved.sources, files);
+        } finally {
+          unpin();
+          if (result?.kind !== "result") await Promise.all([...files.values()].map(file => file.release()));
+        }
         if (!result) return;
       } else {
         result = await admitInput({ sources: resolved.sources, readRanges: this.#read, reserve: this.#reserveFor(request) });
@@ -475,7 +497,9 @@ export class EncodeInputs {
 
   /** Take `bytes` of the allowance for this request now, or answer null. */
   #hold(request, bytes) {
-    if (this.#requests.get(request.key) !== request || this.#allowed - this.#held < bytes) return null;
+    if (this.#requests.get(request.key) !== request) return null;
+    this.#shared.trim(this.#allowed - this.#held - bytes);
+    if (this.#allowed - this.held() < bytes) return null;
     this.#wanted.delete(request.key);
     this.#held += bytes;
     let released = false;
@@ -497,8 +521,11 @@ export class EncodeInputs {
    *
    * @returns {Promise<object | undefined>} Undefined when the request was withdrawn.
    */
-  async #admitStretch(request, firstSources) {
+  async #admitStretch(request, firstSources, files = new Map()) {
     const { output, from } = request;
+    const sharing = files.size > 0 || firstSources.every(source => Array.isArray(source.input.commonRanges));
+    const inMemory = sources => sources.filter(source => !files.has(source.fileIndex));
+    const memoryBytes = sources => sharing ? this.#shared.bytesNeeded(inMemory(sources)) : originalInputBytes(sources);
     // Record existing decisions only: diagnostics must not resolve another
     // interval or ask storage for an additional availability reading.
     const probes = [], reservations = [];
@@ -515,12 +542,13 @@ export class EncodeInputs {
       }
       return stretches.get(end);
     };
-    const fits = async (end, maxBytes) => {
+    const fits = async (end, maxBytes, memory = false) => {
       const stretch = await at(end);
-      const withinLimit = Boolean(stretch) && stretch.bytes <= maxBytes;
+      const withinLimit = Boolean(stretch) && (memory ? memoryBytes(stretch.sources) <= maxBytes && stretch.bytes <= (target ?? minimum) : stretch.bytes <= maxBytes);
       const result = !stretch ? "unresolved" : !withinLimit ? "size"
-        : await this.#present(stretch.sources, held, request.timing) ? "fits" : "missing-bytes";
-      probes.push({ end, limitBytes: maxBytes, bytes: stretch?.bytes ?? null, result });
+        : await this.#present(stretch.sources, held, request.timing, files) ? "fits" : "missing-bytes";
+      probes.push({ end, limitBytes: maxBytes, bytes: stretch?.bytes ?? null, result,
+        ...(sharing ? { bound: memory ? "memory" : "target", memoryBytes: stretch ? memoryBytes(stretch.sources) : null } : {}) });
       return result === "fits";
     };
     // Grows by doubling and then halves back: a handful of resolutions find
@@ -534,17 +562,17 @@ export class EncodeInputs {
       const covering = await at(serves);
       if (covering) { floor = serves; minimum = covering.bytes; }
     }
-    const longest = async maxBytes => {
+    const longest = async (maxBytes, memory = false) => {
       let good = floor, bad = null, step = 1;
       while (bad === null) {
         const end = good + step;
         if (end > request.to) bad = request.to + 1;
-        else if (await fits(end, maxBytes)) { good = end; step *= 2; }
+        else if (await fits(end, maxBytes, memory)) { good = end; step *= 2; }
         else bad = end;
       }
       while (bad - good > 1) {
         const middle = Math.floor((good + bad) / 2);
-        if (await fits(middle, maxBytes)) good = middle; else bad = middle;
+        if (await fits(middle, maxBytes, memory)) good = middle; else bad = middle;
       }
       return good;
     };
@@ -554,24 +582,26 @@ export class EncodeInputs {
     let end = target === null || this.#heldRanges === null ? floor : await longest(target);
     const targetEnd = end;
     if (this.#requests.get(request.key) !== request) return undefined;
-    this.#wanted.set(request.key, { wanted: stretches.get(end).bytes, required: minimum });
+    const minimumMemory = () => memoryBytes(stretches.get(floor).sources);
+    this.#wanted.set(request.key, { wanted: memoryBytes(stretches.get(end).sources), required: minimumMemory() });
     await this.#spent(request.timing, "budgetMs", () => this.#revise());
     if (this.#requests.get(request.key) !== request) return undefined;
     const capacity = this.#capacity();
-    if (capacity !== null && minimum > capacity && this.#urgent(output, from)) {
-      return { kind: "terminal", reason: "source-input-exceeds-memory-capacity", bytes: minimum, capacity };
+    const minimumCapacity = originalInputBytes(inMemory(stretches.get(floor).sources));
+    if (capacity !== null && minimumCapacity > capacity && this.#urgent(output, from)) {
+      return { kind: "terminal", reason: "source-input-exceeds-memory-capacity", bytes: minimumCapacity, capacity };
     }
-    const roomNow = () => Math.min(capacity ?? Number.POSITIVE_INFINITY, this.#allowed - this.#held);
+    const roomNow = () => Math.min(capacity ?? Number.POSITIVE_INFINITY, this.#allowed - this.held());
     let room = roomNow();
     let result;
     for (;;) {
-      if (minimum > room) {
+      if (minimumMemory() > room) {
         // Wait for memory with the least it can run with, not the larger stretch.
-        this.#wanted.set(request.key, { wanted: minimum, required: minimum });
-        return { kind: "needs-memory", bytes: minimum };
+        this.#wanted.set(request.key, { wanted: minimumMemory(), required: minimumMemory() });
+        return { kind: "needs-memory", bytes: minimumMemory() };
       }
-      if (stretches.get(end).bytes > room) {
-        end = await longest(Math.min(target ?? minimum, room));
+      if (memoryBytes(stretches.get(end).sources) > room) {
+        end = await longest(sharing ? room : Math.min(target ?? minimum, room), sharing);
         if (this.#requests.get(request.key) !== request) return undefined;
       }
       const chosen = stretches.get(end);
@@ -581,17 +611,26 @@ export class EncodeInputs {
       // it waits for the bytes as one read of everything used to. Field
       // 2026-10-12: a cold MKV's first piece was answered, its stretch read
       // found pieces missing, and the run was refused for good (torrent-tv/meta#178).
-      if (this.#heldRanges !== null && !await this.#present(chosen.sources, held, request.timing)) {
+      if (this.#heldRanges !== null && !await this.#present(chosen.sources, held, request.timing, files)) {
         const [first] = chosen.sources;
         return { kind: "needs-bytes", sourceKey: first.sourceKey, fileIndex: first.fileIndex, ranges: first.input.ranges,
           // Every source of the stretch, so the bytes of any of them wake it.
           awaiting: chosen.sources.map(source => ({ sourceKey: source.sourceKey, fileIndex: source.fileIndex, ranges: source.input.ranges })) };
       }
       if (this.#requests.get(request.key) !== request) return undefined;
-      this.#wanted.set(request.key, { wanted: chosen.bytes, required: chosen.bytes });
-      result = await admitOriginalInput({ sources: chosen.sources, readRanges: this.#read, now: this.#now,
+      const needed = memoryBytes(chosen.sources);
+      this.#wanted.set(request.key, { wanted: needed, required: needed });
+      if (sharing) {
+        const reservation = { bytes: needed, minimumMemoryBytes: minimumMemory(), allowed: this.#allowed, held: this.held(), capacity, room: roomNow(), end };
+        const storage = this.#shared.acquire(inMemory(chosen.sources), roomNow(), { readRanges: this.#read, now: this.#now });
+        reservations.push({ ...reservation, admitted: storage !== null });
+        if (storage) {
+          this.#wanted.delete(request.key);
+          result = await admitOriginalInput({ sources: chosen.sources, storage, files, now: this.#now });
+        } else result = { kind: "needs-memory", bytes: needed };
+      } else result = await admitOriginalInput({ sources: chosen.sources, readRanges: this.#read, now: this.#now,
         reserve: async bytes => {
-          const reservation = { bytes, allowed: this.#allowed, held: this.#held, capacity,
+          const reservation = { bytes, allowed: this.#allowed, held: this.held(), capacity,
             room: roomNow(), end };
           const release = this.#hold(request, bytes);
           reservations.push({ ...reservation, admitted: typeof release === "function" });
@@ -603,11 +642,12 @@ export class EncodeInputs {
       if (result.kind !== "needs-memory" || this.#requests.get(request.key) !== request || roomNow() >= room) break;
       room = roomNow();
     }
-    if (result.kind === "needs-memory") this.#wanted.set(request.key, { wanted: minimum, required: minimum });
+    if (result.kind === "needs-memory") this.#wanted.set(request.key, { wanted: minimumMemory(), required: minimumMemory() });
     if (result.kind === "result") {
       this.#log(`encode input selection of ${addressOf(output)}: ${JSON.stringify({
         from, requestedTo: request.to, serves, floor, targetEnd, chosenEnd: end,
         targetBytes: target, minimumBytes: minimum, inputBytes: result.bytes,
+        ...(sharing ? { minimumMemoryBytes: reservations.at(-1)?.minimumMemoryBytes ?? null, reservedMemoryBytes: reservations.at(-1)?.bytes ?? null } : {}),
         copyBytesPerMs: sizing?.copyBytesPerMs ?? null, openSeconds: sizing?.openSeconds ?? null,
         openMeasured: sizing?.openMeasured ?? null, reservations, probes
       })}`);
@@ -616,13 +656,13 @@ export class EncodeInputs {
       // is the whole copy's, learned once it is done.
       const copied = result.whole ?? Promise.resolve(true);
       void copied.then(whole => {
-        if (whole && result.copyMs > 0) keep(this.#copyRates, result.bytes / result.copyMs);
-        if (whole) {
+        if (whole && result.copyMs > 0 && result.copiedBytes > 0) keep(this.#copyRates, result.copiedBytes / result.copyMs);
+        if (whole && result.copiedBytes + result.sharedBytes > 0) {
           try { this.#stretchCopied(output, from, end, result); }
           catch (error) { this.#log(`encode input #${from}..#${end} of ${addressOf(output)}: what was told of its copy failed: ${error?.message ?? error}`); }
         }
         this.#log(`encode input #${from}..#${end} of ${addressOf(output)}: ` + (whole
-          ? `stretch copied, ${result.bytes} bytes in ${result.copyMs}ms of copying since it was admitted`
+          ? `stretch copied, ${result.bytes} bytes in ${result.copyMs}ms of copying since it was admitted; copied ${result.copiedBytes}, shared ${result.sharedBytes}, disk ${result.diskBytes} bytes`
           : result.copyFailed?.() ? "the stretch could not be copied: a piece it needs is no longer held"
             : "released before its stretch was copied"));
       });
@@ -631,12 +671,21 @@ export class EncodeInputs {
   }
 
   /** Whether every range of these sources is downloaded whole now. */
-  async #present(sources, held, timing) {
+  async #present(sources, held, timing, files = new Map()) {
     for (const source of sources) {
+      if (files.has(source.fileIndex)) continue;
       const name = `${source.sourceKey}:${source.fileIndex}`;
       if (!held.has(name)) held.set(name, await this.#spent(timing, "heldMs", () => Promise.resolve().then(() => this.#heldRanges(source)).catch(() => null)) ?? []);
-      const ranges = held.get(name);
-      if (!source.input.ranges.every(([start, end]) => ranges.some(([first, last]) => first <= start && last >= end))) return false;
+      const ranges = [...held.get(name), ...this.#shared.available(source)].sort((a, b) => a[0] - b[0]);
+      if (!source.input.ranges.every(([start, end]) => {
+        let at = start;
+        for (const [first, last] of ranges) {
+          if (first > at) return false;
+          if (last >= at) at = last + 1;
+          if (at > end) return true;
+        }
+        return false;
+      })) return false;
     }
     return true;
   }

package/services/encode/EncodeRuns.js

@@ -1220,7 +1220,11 @@ export class EncodeRuns {
               `ended at ${Date.now() - run.startedAt}ms` + describeTaken(reads.answers, run.startedAt, ended.firstNamedWallMs));
           }
           this.#noteOpen(session, run, ended);
-          admittedInput.release();
+          void Promise.resolve(admittedInput.release()).then(() => {
+            this.#host.logger.info(`encode input storage of run #${run.from}..#${run.to} on ${session.outputKey}: ` +
+              `input ${admittedInput.bytes} bytes, copied ${admittedInput.copiedBytes ?? 0}, ` +
+              `shared ${admittedInput.sharedBytes ?? 0}, disk ${admittedInput.diskBytes ?? 0} bytes`);
+          });
         }
         this.#sayRunCpu(session, run);
         this.noteRunEnded(session, run, ended);

package/services/encode/OriginalInput.js

@@ -13,10 +13,10 @@ import { createHash } from "node:crypto";
  * (torrent-tv/meta#178). `whole` settles when everything is copied — true — or
  * when the copy failed or the input was released first — false.
  */
-export async function admitOriginalInput({ sources, reserve, readRanges, now = Date.now }) {
+export async function admitOriginalInput({ sources, reserve, readRanges, now = Date.now, storage = null, files = new Map() }) {
   const bytes = originalInputBytes(sources);
   if (!Number.isSafeInteger(bytes) || bytes <= 0) throw new TypeError("Original input requires complete finite byte ranges.");
-  const releaseBudget = await reserve(bytes);
+  const releaseBudget = storage ? storage.release : await reserve(bytes);
   if (typeof releaseBudget !== "function") return releaseBudget?.kind === "terminal" ? releaseBudget : { kind: "needs-memory", bytes };
   const held = new Map();
   const hash = createHash("sha256");
@@ -24,10 +24,13 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
   // How long the copy itself took, apart from any wait for memory or bytes
   // before it: the figure a run's stretch is sized from, read where the copy is.
   let copyMs = 0;
+  let diskBytes = 0;
   // Per source, the range copied after the answer: its position in the
   // source's ranges, and the copy's promise once it has begun.
   const later = [];
   const read = async (source, ranges) => {
+    if (files.has(source.fileIndex)) return ranges.map(() => true);
+    if (storage) return await storage.copy(source, ranges) ? ranges.map(() => true) : null;
     const startedAt = now();
     const buffers = await readRanges(source, ranges, bytes);
     copyMs += Math.max(0, now() - startedAt);
@@ -43,7 +46,7 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
       const { ranges } = source.input;
       const largest = ranges.reduce((best, range, index) =>
         range[1] - range[0] > ranges[best][1] - ranges[best][0] ? index : best, 0);
-      const deferred = ranges.length > 1 ? largest : -1;
+      const deferred = !files.has(source.fileIndex) && ranges.length > 1 ? largest : -1;
       const first = ranges.filter((_, index) => index !== deferred);
       const buffers = await read(source, first);
       if (buffers === null) return { kind: "needs-bytes", sourceKey: source.sourceKey, fileIndex: source.fileIndex, ranges };
@@ -59,6 +62,8 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
       if (deferred >= 0) later.push({ entry, position: deferred });
     }
     let released = false;
+    let runReleased = false, owners = 1, finishClose;
+    const closed = new Promise(resolve => { finishClose = resolve; });
     let failed = false;
     retained = true;
     // ONE READ FOR THE STRETCH. Copied a torrent piece per read (2.97.12), a
@@ -102,19 +107,46 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
     // When FFmpeg's reads waited for a stretch still being copied.
     /** @type {{ from: number, to: number | null }[]} */
     const waits = [];
-    const answer = (entry, position, start, stop) => {
+    const answer = (entry, position, start, stop, answeringHttp = false) => {
       const now = Date.now();
       reads.count += 1;
       reads.bytes += stop - start + 1;
       reads.firstAt ||= now;
       reads.lastAt = now;
       const [from] = entry.source.input.ranges[position];
+      const file = files.get(entry.source.fileIndex);
+      if (file) {
+        // Packet learning reads only an already-owned memory copy; disk has no
+        // such copy. Its ordinary container reader already reads this file.
+        if (!answeringHttp) return null;
+        const stream = file.stream(start, stop, bytes => { diskBytes += bytes; });
+        return stream ? { length: file.length, end: stop, size: stop - start + 1, stream } : null;
+      }
+      if (storage) {
+        const held = storage.slices(entry.source, start, stop, answeringHttp);
+        if (!held) return null;
+        return { length: entry.source.input.fileLength, end: stop, size: stop - start + 1,
+          ...(answeringHttp && held.buffers.length > 1 ? { chunks: held.buffers }
+            : { bytes: held.buffers.length === 1 ? held.buffers[0] : Buffer.concat(held.buffers) }),
+          release: held.release };
+      }
       return { length: entry.source.input.fileLength, end: stop, bytes: entry.buffers[position].subarray(start - from, stop - from + 1) };
     };
+    const drop = () => {
+      owners--;
+      if (owners || released) return;
+      released = true;
+      held.clear();
+      releaseBudget();
+      void Promise.all([whole, ...[...files.values()].map(file => file.release())]).then(finishClose);
+    };
     return {
       kind: "result", original: true, sources, bytes, fingerprint: hash.digest("hex"),
       // What the copy took so far; final once `whole` has settled.
-      get copyMs() { return copyMs; },
+      get copyMs() { return storage ? storage.stats.copyMs : copyMs; },
+      get copiedBytes() { return storage ? storage.stats.copiedBytes : bytes; },
+      get sharedBytes() { return storage ? storage.stats.sharedBytes : 0; },
+      get diskBytes() { return diskBytes; },
       whole,
       // Bytes of the stretches still to be copied when the answer was given.
       deferredBytes: later.reduce((sum, job) => {
@@ -126,6 +158,13 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
       // not where each track stops. The final piece is judged by the input
       // reaching the end of the file instead (`piece-completeness.js`).
       tracks: sources.flatMap(source => (source.input.selections ?? []).map(selection => ({ track: selection.track }))),
+      heldUntil(fileIndex, start) {
+        if (released) return null;
+        const entry = held.get(fileIndex);
+        if (!entry || files.has(fileIndex)) return null;
+        const range = entry.source.input.ranges.find(([first, last]) => first <= start && last >= start);
+        return range ? Math.min(range[1] + 1, storage?.endOf(entry.source, start) ?? range[1] + 1) : null;
+      },
       /**
        * The answer to a read from `start`, or null when it lies outside what
        * the run holds. Inside a stretch still being copied the answer is a
@@ -141,12 +180,12 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
         const position = ranges.findIndex(([from, to]) => from <= start && (partial ? start : stop) <= to);
         if (position < 0) return null;
         stop = Math.min(stop, ranges[position][1]);
-        if (entry.buffers[position] !== null) return answer(entry, position, start, stop);
+        if (entry.buffers[position] !== null) return answer(entry, position, start, stop, partial);
         const wait = { from: Date.now(), to: null };
         waits.push(wait);
         return copied(entry, position).then(ok => {
           wait.to = Date.now();
-          return ok && !released ? answer(entry, position, start, stop) : null;
+          return ok && !released ? answer(entry, position, start, stop, partial) : null;
         });
       },
       /**
@@ -163,11 +202,16 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
       noteAnswer(answer) {
         if (!released) answers.push({ ...answer, at: Date.now() });
       },
+      /** Packet learning can finish after the FFmpeg run that supplied it. */
+      retain() {
+        if (released || runReleased) return null;
+        owners++;
+        let dropped = false;
+        return () => { if (!dropped) { dropped = true; drop(); } };
+      },
       release() {
-        if (released) return;
-        released = true;
-        held.clear();
-        releaseBudget();
+        if (!runReleased) { runReleased = true; drop(); }
+        return closed;
       }
     };
   } finally {

package/services/encode/OriginalInputStore.js

@@ -0,0 +1,217 @@
+/** Copied, admitted file ranges shared by live inputs and HTTP responses. */
+export class OriginalInputStore {
+  #files = new Map();
+  #owners = new Map();
+  #parts = new Set();
+  #changed;
+
+  constructor({ changed = () => {} } = {}) { this.#changed = changed; }
+
+  get bytes() { return [...this.#parts].reduce((sum, part) => sum + (part.charged ? sizeOf(part) : 0), 0); }
+  get required() { return [...this.#parts].reduce((sum, part) => sum + (part.charged && (part.refs || part.loading) ? sizeOf(part) : 0), 0); }
+
+  #file(source) {
+    const key = JSON.stringify([source.sourceKey, source.fileIndex]);
+    if (!this.#files.has(key)) this.#files.set(key, { key, parts: [], owners: new Set() });
+    return this.#files.get(key);
+  }
+
+  /** Keep common parts across seeks while an output of this file exists. */
+  retain(owner, sources) {
+    const files = this.#owners.get(owner) ?? new Set();
+    for (const source of sources) {
+      const file = this.#file(source);
+      file.owners.add(owner);
+      files.add(file);
+    }
+    this.#owners.set(owner, files);
+  }
+
+  forget(owner) {
+    for (const file of this.#owners.get(owner) ?? []) {
+      file.owners.delete(owner);
+      for (const part of [...file.parts]) this.#discardUnused(part);
+      this.#prune(file);
+    }
+    this.#owners.delete(owner);
+  }
+
+  /** Unused common bytes are wanted, never required, and can leave for room. */
+  trim(limit) {
+    let bytes = this.bytes;
+    for (const part of this.#parts) {
+      if (bytes <= limit) break;
+      if (part.refs || part.loading) continue;
+      bytes -= part.charged ? sizeOf(part) : 0;
+      this.#discard(part);
+    }
+  }
+
+  #prune(file) {
+    if (!file.parts.length && !file.owners.size) this.#files.delete(file.key);
+  }
+
+  #discard(part) {
+    part.charged = false;
+    part.buffer = null;
+    part.ensure = null;
+    this.#parts.delete(part);
+    const position = part.file.parts.indexOf(part);
+    if (position >= 0) part.file.parts.splice(position, 1);
+    this.#prune(part.file);
+    this.#changed();
+  }
+
+  #discardUnused(part) {
+    if (part.refs || part.loading) return;
+    if (!part.failed && part.buffer && part.common && part.file.owners.size) return;
+    this.#discard(part);
+  }
+
+  #unpin(parts) {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      for (const part of parts) { part.refs--; this.#discardUnused(part); }
+    };
+  }
+
+  /** Protect existing bytes during an asynchronous budget revision. */
+  protect(sources) {
+    const parts = new Set();
+    for (const source of sources) {
+      for (const part of this.#file(source).parts) {
+        if (source.input.ranges.some(([start, end]) => start <= part.end && end >= part.start)) parts.add(part);
+      }
+    }
+    for (const part of parts) part.refs++;
+    return this.#unpin(parts);
+  }
+
+  available(source) {
+    const file = this.#files.get(JSON.stringify([source.sourceKey, source.fileIndex]));
+    return (file?.parts ?? []).filter(part => !part.failed).map(part => [part.start, part.end]);
+  }
+
+  #missing(source) {
+    const file = this.#file(source);
+    const missing = [];
+    for (const [start, end] of source.input.ranges) {
+      let at = start;
+      for (const part of file.parts) {
+        if (part.end < at || part.failed) continue;
+        if (part.start > end) break;
+        if (at < part.start) missing.push([at, Math.min(end, part.start - 1)]);
+        at = Math.max(at, part.end + 1);
+        if (at > end) break;
+      }
+      if (at <= end) missing.push([at, end]);
+    }
+    return missing;
+  }
+
+  bytesNeeded(sources) { return sources.reduce((sum, source) => sum + this.#missing(source).reduce((n, [start, end]) => n + end - start + 1, 0), 0); }
+
+  /** Reserve missing ranges synchronously; a second admission sees them pending. */
+  acquire(sources, room, { readRanges, now = Date.now }) {
+    const additionalBytes = this.bytesNeeded(sources);
+    if (additionalBytes > room) return null;
+    const parts = new Set();
+    const owned = new Set();
+    const stats = { copiedBytes: 0, sharedBytes: 0, copyMs: 0 };
+    for (const source of sources) {
+      const file = this.#file(source);
+      for (const [start, end] of this.#missing(source)) {
+        // A common prefix must never retain the rest of a large media buffer.
+        const cuts = new Set([start, end + 1]);
+        for (const [first, last] of source.input.commonRanges ?? []) {
+          if (first > start && first <= end) cuts.add(first);
+          if (last >= start && last < end) cuts.add(last + 1);
+        }
+        const offsets = [...cuts].sort((a, b) => a - b);
+        for (let i = 1; i < offsets.length; i++) {
+          const first = offsets[i - 1], last = offsets[i] - 1;
+          const part = { file, source, start: first, end: last, refs: 0, charged: true,
+            common: (source.input.commonRanges ?? []).some(([a, b]) => a <= first && b >= last),
+            buffer: null, loading: false, failed: false, promise: null, ensure: null };
+          file.parts.push(part);
+          this.#parts.add(part);
+          owned.add(part);
+        }
+      }
+      file.parts.sort((a, b) => a.start - b.start);
+      for (const part of file.parts) {
+        for (const [start, end] of source.input.ranges) {
+          const bytes = Math.max(0, Math.min(end, part.end) - Math.max(start, part.start) + 1);
+          if (!bytes) continue;
+          parts.add(part);
+          if (!owned.has(part)) stats.sharedBytes += bytes;
+        }
+      }
+    }
+    for (const part of parts) part.refs++;
+    let released = false;
+    const unpin = this.#unpin(parts);
+    const copy = async (source, ranges) => {
+      const selected = [...parts].filter(part => part.file.key === JSON.stringify([source.sourceKey, source.fileIndex]) &&
+        ranges.some(([start, end]) => start <= part.end && end >= part.start));
+      const fresh = selected.filter(part => owned.has(part) && !part.promise);
+      if (fresh.length) {
+        for (const part of fresh) part.loading = true;
+        const startedAt = now();
+        // Defer the read until every part names the same pending operation.
+        const operation = Promise.resolve().then(() => readRanges(source, fresh.map(part => [part.start, part.end]), additionalBytes))
+          .then(buffers => {
+            if (buffers === null) return false;
+            if (!Array.isArray(buffers) || buffers.length !== fresh.length || buffers.some((buffer, i) => !Buffer.isBuffer(buffer) || buffer.length !== sizeOf(fresh[i]))) {
+              throw new Error("Original input reader returned incomplete ranges.");
+            }
+            for (let i = 0; i < fresh.length; i++) fresh[i].buffer = buffers[i];
+            stats.copiedBytes += fresh.reduce((sum, part) => sum + sizeOf(part), 0);
+            return true;
+          }).catch(error => { for (const part of fresh) part.error = error; return false; }).then(ok => {
+            stats.copyMs += Math.max(0, now() - startedAt);
+            for (const part of fresh) {
+              part.loading = false;
+              if (!ok) { part.failed = true; this.#discard(part); }
+              else this.#discardUnused(part);
+            }
+            return ok;
+          });
+        for (const part of fresh) { part.promise = operation; part.ensure = null; }
+      }
+      for (const part of selected) if (!part.promise) part.ensure();
+      const answers = await Promise.all(selected.map(part => part.promise));
+      const failure = selected.find(part => part.error);
+      if (failure) throw failure.error;
+      return !released && answers.every(Boolean);
+    };
+    for (const part of owned) part.ensure = () => copy(part.source, [[part.start, part.end]]);
+    return {
+      stats, additionalBytes,
+      copy,
+      endOf(source, start) {
+        if (released) return null;
+        const part = [...parts].find(part => part.file.key === JSON.stringify([source.sourceKey, source.fileIndex]) &&
+          part.buffer && part.start <= start && part.end >= start);
+        return part ? part.end + 1 : null;
+      },
+      slices(source, start, end, pin = false) {
+        if (released) return null;
+        const selected = [...parts].filter(part => part.file.key === JSON.stringify([source.sourceKey, source.fileIndex]) && part.start <= end && part.end >= start)
+          .sort((a, b) => a.start - b.start);
+        if (selected.some(part => !part.buffer || part.failed)) return null;
+        const buffers = selected.map(part => part.buffer.subarray(Math.max(start, part.start) - part.start, Math.min(end, part.end) - part.start + 1));
+        if (buffers.reduce((sum, buffer) => sum + buffer.length, 0) !== end - start + 1) return null;
+        if (pin) for (const part of selected) part.refs++;
+        return { buffers, release: pin ? this.releaseParts(selected) : () => {} };
+      },
+      // Bound separately because slices' `this` is the lease, not the store.
+      releaseParts: selected => this.#unpin(selected),
+      release() { if (!released) { released = true; unpin(); } }
+    };
+  }
+}
+
+const sizeOf = part => part.end - part.start + 1;

package/services/media/container/AviContainer.js

@@ -275,9 +275,10 @@ export class AviContainer extends Container {
     // media time: every stream's packets in file order, from the first.
     const search = index.mediaRanges({ from: 0, to: FFMPEG_STREAM_SEARCH_SECONDS, picture: null,
       streams: requested.map(track => track.trackNumber) });
-    const ranges = [[0, movi.start + 3], ...index.indexRanges, ...index.firstPackets(), ...search,
-      ...index.mediaRanges({ from: interval.from, to: interval.to, picture: picture?.trackNumber ?? null,
-        streams: requested.map(track => track.trackNumber) })].map(padded);
+    const commonRanges = [[0, movi.start + 3], ...index.indexRanges, ...index.firstPackets(), ...search].map(padded);
+    const intervalRanges = index.mediaRanges({ from: interval.from, to: interval.to, picture: picture?.trackNumber ?? null,
+      streams: requested.map(track => track.trackNumber) }).map(padded);
+    const ranges = [...commonRanges, ...intervalRanges];
     ranges.sort((left, right) => left[0] - right[0]);
     const union = [];
     for (const range of ranges) {
@@ -285,7 +286,7 @@ export class AviContainer extends Container {
       if (previous && range[0] <= previous[1] + 1) previous[1] = Math.max(previous[1], range[1]);
       else union.push([...range]);
     }
-    return { kind: "result", from: interval.from, to: interval.to, ranges: union, fileLength: this.fileSize,
+    return { kind: "result", from: interval.from, to: interval.to, ranges: union, commonRanges, intervalRanges, fileLength: this.fileSize,
       streamSearchSeconds: FFMPEG_STREAM_SEARCH_SECONDS };
   }
 

package/services/media/container/MatroskaContainer.js

@@ -761,8 +761,8 @@ export class MatroskaContainer extends Container {
     // media time and stops on the first packet past it, which lies before the
     // first Cue later than that time; the padding holds its read-ahead.
     const searchEnd = points[firstAt(points[0].seconds + FFMPEG_STREAM_SEARCH_SECONDS, true)];
-    const ranges = [[0, paddedEnd((searchEnd ? searchEnd.at : layout.segmentEnd) - 1)],
-      [points[first].at, paddedEnd(mediaEnd)], [layout.cuesAt, paddedEnd(cuesEnd - 1)],
+    const commonRanges = [[0, paddedEnd((searchEnd ? searchEnd.at : layout.segmentEnd) - 1)],
+      [layout.cuesAt, paddedEnd(cuesEnd - 1)],
       [Math.max(0, this.fileSize - requestBytes), this.fileSize - 1]];
     // SeekHead may name top-level declarations after media clusters. Preserve
     // their original bytes instead of reconstructing declarations for FFmpeg.
@@ -770,8 +770,10 @@ export class MatroskaContainer extends Container {
       if (at === null || at < layout.firstClusterAt) continue;
       const end = await elementEnd(at);
       if (end === null) return { kind: "terminal", reason: "source-declarations-are-unbounded" };
-      ranges.push([at, paddedEnd(end - 1)]);
+      commonRanges.push([at, paddedEnd(end - 1)]);
     }
+    const intervalRanges = [[points[first].at, paddedEnd(mediaEnd)]];
+    const ranges = [...commonRanges, ...intervalRanges];
     ranges.sort((left, right) => left[0] - right[0]);
     const union = [];
     for (const range of ranges) {
@@ -779,7 +781,7 @@ export class MatroskaContainer extends Container {
       if (previous && range[0] <= previous[1] + 1) previous[1] = Math.max(previous[1], range[1]);
       else union.push([...range]);
     }
-    return { kind: "result", from: interval.from, to: interval.to, ranges: union, fileLength: this.fileSize,
+    return { kind: "result", from: interval.from, to: interval.to, ranges: union, commonRanges, intervalRanges, fileLength: this.fileSize,
       streamSearchSeconds: FFMPEG_STREAM_SEARCH_SECONDS };
   }
 

package/services/server/wire-outputs.js

@@ -230,6 +230,7 @@ export function wireOutputs({
     readMetadataActivity = null,
     sourceInputsFor = null,
     readEncodeRanges = null,
+    openEncodeWholeFile = null,
     stretchCopied = () => {},
     readEncodeHeldRanges = null,
     encodeInputs = null,
@@ -1117,6 +1118,7 @@ export function wireOutputs({
   parts.encodeInputs = encodeInputs ?? (typeof resolveEncodeInput === "function" ? new EncodeInputs({
     resolve: resolveEncodeInput,
     readRanges: readEncodeRanges,
+    openWholeFile: openEncodeWholeFile,
     heldRanges: readEncodeHeldRanges,
     stretchCopied,
     reviseBudget: () => parts.machineBudget.revise("memory", "admitted encode inputs"),

package/services/storage/files/CompletedFiles.js

@@ -54,6 +54,8 @@ export class CompletedFiles {
 
   /** Assemblies in flight, so two passes cannot write one file at once. @type {Set<string>} */
   #writing = new Set();
+  #readers = new Map();
+  #removeAfterRead = new Set();
 
   /**
    * What this store may hold, handed to it by the owner of the disk.
@@ -140,6 +142,7 @@ export class CompletedFiles {
    */
   find(infoHash, fileIndex) {
     const key = this.#keyOf(infoHash, fileIndex);
+    if (this.#removeAfterRead.has(key)) return null;
     const file = this.#held.get(key) ?? null;
     if (file) {
       // WHEN IT WAS LAST WANTED, which is the order it leaves in. A whole file
@@ -150,6 +153,26 @@ export class CompletedFiles {
     return file;
   }
 
+  /** Pin a completed file against eviction until all its offset reads finish. */
+  acquire(infoHash, fileIndex) {
+    const key = this.#keyOf(infoHash, fileIndex);
+    const file = this.find(infoHash, fileIndex);
+    if (!file) return null;
+    this.#readers.set(key, (this.#readers.get(key) ?? 0) + 1);
+    let released = false;
+    return { ...file, release: async () => {
+      if (released) return { bytes: this.bytes, removed: 0 };
+      released = true;
+      const remaining = this.#readers.get(key) - 1;
+      if (remaining) this.#readers.set(key, remaining);
+      else {
+        this.#readers.delete(key);
+        if (this.#removeAfterRead.delete(key)) await this.#remove(key);
+      }
+      return this.allow(this.#allowanceBytes);
+    } };
+  }
+
   /**
    * Say how much disk these files may take between them.
    *
@@ -204,7 +227,7 @@ export class CompletedFiles {
     let oldest = null;
     let oldestAt = Number.POSITIVE_INFINITY;
     for (const key of this.#held.keys()) {
-      if (this.#writing.has(key)) {
+      if (this.#writing.has(key) || this.#readers.has(key)) {
         continue;
       }
       const at = this.#lastRead.get(key) ?? 0;
@@ -223,6 +246,7 @@ export class CompletedFiles {
    * @returns {Promise<void>}
    */
   async #remove(key) {
+    if (this.#readers.has(key)) { this.#removeAfterRead.add(key); return; }
     const file = this.#held.get(key);
     this.#held.delete(key);
     this.#lastRead.delete(key);
@@ -400,11 +424,11 @@ export class CompletedFiles {
   async forget(infoHash) {
     for (const key of [...this.#held.keys()]) {
       if (key.startsWith(`${infoHash}/`)) {
-        this.#held.delete(key);
+        await this.#remove(key);
       }
     }
-    await fs.rm(path.join(this.#root, String(infoHash)), { ...REMOVAL, recursive: true }).catch(
-      () => undefined
-    );
+    if (![...this.#held.keys()].some(key => key.startsWith(`${infoHash}/`))) {
+      await fs.rm(path.join(this.#root, String(infoHash)), { ...REMOVAL, recursive: true }).catch(() => undefined);
+    }
   }
 }

package/services/storage/wire.js

@@ -147,6 +147,7 @@ export function wireMachineBudget({
       name: "whole files",
       resource: filesOn,
       held: () => wholeFiles.held?.() ?? 0,
+      required: () => wholeFiles.required?.() ?? 0,
       // A whole file is worth keeping while anybody may read it again, and
       // there is no smaller honest answer than "all of them" — like the rest,
       // it is cut in proportion.

package/services/torrent/worker/client.js

@@ -21,6 +21,7 @@ import { fileURLToPath } from "node:url";
 import { logger, writeAlreadyDecided } from "../../../utils/logger.js";
 import { createCaller, createReceiveStream, workerReplyError } from "./channel.js";
 import { Command, Event } from "./protocol.js";
+import { openCompletedInputFile } from "./completed-input-file.js";
 
 const WORKER_URL = new URL("./worker.js", import.meta.url);
 /**
@@ -106,6 +107,29 @@ export class TorrentWorkerClient {
    * @type {Map<string, { path: string, length: number, name: string }>}
    */
   wholeFiles = new Map();
+  #wholeInputPins = new Map();
+
+  get wholeFileRequiredBytes() {
+    const files = new Map();
+    for (const file of this.#wholeInputPins.values()) files.set(JSON.stringify([file.sourceKey, file.fileIndex]), file.length);
+    return [...files.values()].reduce((sum, length) => sum + length, 0);
+  }
+
+  /** No source is opened or revived: only the worker's completed-file store answers. */
+  async acquireWholeFile({ sourceKey, fileIndex }) {
+    if (!this.#wholeFileOf(sourceKey, fileIndex)) return null;
+    const file = await this.#caller.call(Command.ACQUIRE_WHOLE_FILE, { sourceKey, fileIndex });
+    if (!file) {
+      this.wholeFiles.delete(`${String(sourceKey).slice("torrent:".length).toLowerCase()}/${fileIndex}`);
+      return null;
+    }
+    this.#wholeInputPins.set(file.token, { sourceKey, fileIndex, length: file.length });
+    this.wholeFileBytes = file.heldBytes;
+    return openCompletedInputFile(file, async () => {
+      try { this.wholeFileBytes = await this.#caller.call(Command.RELEASE_WHOLE_FILE, { token: file.token }); }
+      finally { this.#wholeInputPins.delete(file.token); }
+    });
+  }
 
   /** @type {(event: { sourceKey: string, fileIndex: number, trackIndex: number, cues: object[], language: string }) => void} */
   /** @type {(event: { sourceKey: string, fileIndexes: number[] }) => void} */

package/services/torrent/worker/completed-input-file.js

@@ -0,0 +1,50 @@
+import { open } from "node:fs/promises";
+import { Readable } from "node:stream";
+
+/** Open one pinned completed file; every HTTP response owns a separate read. */
+export async function openCompletedInputFile(file, release) {
+  let handle;
+  try {
+    handle = await open(file.path, "r");
+    if ((await handle.stat()).size !== file.length) throw new Error("Completed file length changed.");
+  } catch {
+    await handle?.close();
+    await release();
+    return null;
+  }
+  let references = 1, released = false, closing = false;
+  let finish;
+  const closed = new Promise(resolve => { finish = resolve; });
+  const drop = () => {
+    references--;
+    if (references || closing) return;
+    closing = true;
+    void handle.close().finally(release).then(() => finish(), error => finish(error));
+  };
+  return {
+    length: file.length, closed,
+    stream(start, end, onRead) {
+      if (released || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end >= file.length) return null;
+      references++;
+      let dropped = false;
+      const done = () => { if (!dropped) { dropped = true; drop(); } };
+      const stream = Readable.from((async function* () {
+        for (let at = start; at <= end;) {
+          const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, end - at + 1));
+          const { bytesRead } = await handle.read(buffer, 0, buffer.length, at);
+          if (!bytesRead) throw new Error("Completed file ended inside an admitted range.");
+          at += bytesRead;
+          onRead(bytesRead);
+          yield buffer.subarray(0, bytesRead);
+        }
+      })(), { objectMode: false, highWaterMark: 64 * 1024 });
+      stream.once("end", done);
+      stream.once("close", done);
+      return stream;
+    },
+    release() {
+      if (!released) { released = true; drop(); }
+      return closed;
+    }
+  };
+}

package/services/torrent/worker/pool-adapter.js

@@ -122,6 +122,10 @@ export class WorkerTorrentPool {
     return this.#client.wholeFiles;
   }
 
+  get wholeFileRequiredBytes() { return this.#client.wholeFileRequiredBytes ?? 0; }
+
+  acquireWholeFile(source) { return this.#client.acquireWholeFile(source); }
+
   allowWholeFileBytes(bytes) {
     return this.#client.allowWholeFileBytes(bytes);
   }

package/services/torrent/worker/protocol.js

@@ -94,6 +94,9 @@ export const Command = {
   READ_HELD: "read-held",
   /** Acquire all source pieces of an admitted input before copying its ranges. */
   READ_HELD_RANGES: "read-held-ranges",
+  /** Pin a completed file; only a matching release permits its eviction. */
+  ACQUIRE_WHOLE_FILE: "acquire-whole-file",
+  RELEASE_WHOLE_FILE: "release-whole-file",
 
   /** Shut the client down, optionally deleting downloaded data. */
   /**

package/services/torrent/worker/worker.js

@@ -595,6 +595,22 @@ async function runCommand(command, params, id) {
       return memoryClaim();
     }
 
+    case Command.ACQUIRE_WHOLE_FILE: {
+      const hash = String(params.sourceKey).startsWith("torrent:") ? params.sourceKey.slice("torrent:".length).toLowerCase() : null;
+      const lease = hash === null ? null : completedFiles.acquire(hash, params.fileIndex);
+      if (!lease) return null;
+      wholeFileReaders.set(id, lease);
+      return { token: id, path: lease.path, length: lease.length, name: lease.name, heldBytes: completedFiles.bytes };
+    }
+
+    case Command.RELEASE_WHOLE_FILE: {
+      const lease = wholeFileReaders.get(params.token);
+      wholeFileReaders.delete(params.token);
+      const after = await lease?.release();
+      if (after?.removed) holdingsChanged();
+      return completedFiles.bytes;
+    }
+
     case Command.WHOLE_FILES_ALLOWANCE: {
       // Whole files are held on this thread and the disk has one owner, on the
       // other. What arrives is their share; what goes back is what they hold
@@ -980,6 +996,7 @@ function holdingsChanged() {
  * thread writes them, the main thread serves them without asking anybody.
  */
 const completedFiles = new CompletedFiles({ root: completedFilesRoot() });
+const wholeFileReaders = new Map();
 const wholeSources = createWholeSources({ find: (infoHash, fileIndex) => completedFiles.find(infoHash, fileIndex) });
 
 /** Adopted files and newly completed files state the same availability event. */