@torrent-tv/proxy 2.101.13 → 2.101.15

package/package.json

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

package/routes/stream/get.js

@@ -108,6 +108,65 @@ function wholeFileFor(torrentPool, sourceKey, fileIndex) {
   return held.get(`${infoHash}/${fileIndex}`) ?? null;
 }
 
+/**
+ * Open the whole file a response under way can continue from, if there is one.
+ *
+ * Any failure to open it leaves the response on the torrent, which can still
+ * answer; a file the disk owner removed is also forgotten here, as the route
+ * does before headers.
+ *
+ * @param {{ wholeFiles?: Map<string, { path: string, length: number, name: string }> }} torrentPool
+ * @param {string} sourceKey
+ * @param {number} fileIndex
+ * @param {number} length - The length the response was promised for.
+ * @returns {Promise<import("node:fs/promises").FileHandle | null>}
+ */
+async function openWholeFileToContinue(torrentPool, sourceKey, fileIndex, length) {
+  const whole = wholeFileFor(torrentPool, sourceKey, fileIndex);
+  if (!whole || whole.length !== length) {
+    return null;
+  }
+  try {
+    return await open(whole.path, "r");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      const key = `${sourceKey.slice("torrent:".length).toLowerCase()}/${fileIndex}`;
+      if (torrentPool.wholeFiles.get(key) === whole) torrentPool.wholeFiles.delete(key);
+    }
+    return null;
+  }
+}
+
+/**
+ * Write bytes `from`..`end` of an open file to a response, each write waited
+ * for, and close the file.
+ *
+ * @param {import("node:http").ServerResponse} raw
+ * @param {import("node:fs/promises").FileHandle} handle
+ * @param {number} from - Inclusive.
+ * @param {number} end - Inclusive.
+ * @param {(length: number) => void} onWritten
+ * @returns {Promise<number>} Bytes written.
+ */
+async function writeFromWholeFile(raw, handle, from, end, onWritten) {
+  let written = 0;
+  try {
+    for await (const chunk of handle.createReadStream({ start: from, end, autoClose: false })) {
+      if (raw.writableEnded || raw.destroyed) {
+        break;
+      }
+      await new Promise((resolve, reject) => {
+        raw.write(chunk, (error) => (error ? reject(error) : resolve()));
+      });
+      written += chunk.length;
+      onWritten(chunk.length);
+    }
+  } finally {
+    await handle.close().catch(() => undefined);
+  }
+  return written;
+}
+
 /**
  * Serve a whole file off the disk, with ranges.
  *
@@ -264,34 +323,66 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool,
     reply.raw.once("close", () => fragments.cancel());
 
     let sent = 0;
+    // THE TORRENT STOPS ANSWERING FOR A FILE AS SOON AS IT IS A FILE, also for
+    // a response that began before (user, 2026-10-09, torrent-tv/meta#173). An
+    // encoder slower than the film is never suspended and reads one response
+    // to the end of the file; left on the piece store, that read keeps the
+    // torrent alive for as long as the viewer stays (torrent-tv/meta#105). So
+    // between fragments, and when the torrent's read fails, the rest of the
+    // range is taken from the file — the same bytes at the same offsets.
+    let continueFrom = null;
     try {
-      for await (const fragment of markWaits ? markingWaits(fragments, markWaits) : fragments) {
-        if (reply.raw.writableEnded || reply.raw.destroyed) {
-          fragment.release();
-          break;
-        }
-        try {
-          await new Promise((resolve, reject) => {
-            reply.raw.write(fragment.bytes, (error) => (error ? reject(error) : resolve()));
-          });
-          sent += fragment.bytes.length;
-        // Say so, if this read belongs to a transcode session. It is the only
-        // proof that a session which has produced nothing yet is nevertheless
-        // being fed: the encoder's own progress cannot move until its first
-        // frame is decoded, and a viewer waiting for that first frame was being
-        // told the proxy had died while the swarm was delivering to it. Field
-        // 2026-09-03: 46.3 s on one piece, `processedSeconds` frozen at the
-        // start position throughout, and the browser gave up 0.4 s before the
-        // piece landed.
-        if (noteInputBytes) {
-          noteInputBytes(sessionId, fragment.bytes.length);
-        }
-        // Only now are these bytes gone: the piece can be unpinned, and the
-        // slot it occupies reused. Releasing before this point corrupts the
-        // response silently.
-        } finally {
-          fragment.release();
+      try {
+        for await (const fragment of markWaits ? markingWaits(fragments, markWaits) : fragments) {
+          if (reply.raw.writableEnded || reply.raw.destroyed) {
+            fragment.release();
+            break;
+          }
+          continueFrom = await openWholeFileToContinue(torrentPool, sourceKey, fileIndex, file.length);
+          if (continueFrom) {
+            fragment.release();
+            break;
+          }
+          try {
+            await new Promise((resolve, reject) => {
+              reply.raw.write(fragment.bytes, (error) => (error ? reject(error) : resolve()));
+            });
+            sent += fragment.bytes.length;
+          // Say so, if this read belongs to a transcode session. It is the only
+          // proof that a session which has produced nothing yet is nevertheless
+          // being fed: the encoder's own progress cannot move until its first
+          // frame is decoded, and a viewer waiting for that first frame was being
+          // told the proxy had died while the swarm was delivering to it. Field
+          // 2026-09-03: 46.3 s on one piece, `processedSeconds` frozen at the
+          // start position throughout, and the browser gave up 0.4 s before the
+          // piece landed.
+          if (noteInputBytes) {
+            noteInputBytes(sessionId, fragment.bytes.length);
+          }
+          // Only now are these bytes gone: the piece can be unpinned, and the
+          // slot it occupies reused. Releasing before this point corrupts the
+          // response silently.
+          } finally {
+            fragment.release();
+          }
         }
+      } catch (error) {
+        if (sent >= contentLength || req.raw.aborted || reply.raw.destroyed) throw error;
+        continueFrom = await openWholeFileToContinue(torrentPool, sourceKey, fileIndex, file.length);
+        if (!continueFrom) throw error;
+      }
+      if (continueFrom) {
+        fragments.cancel();
+        const fromTorrent = sent;
+        sent += await writeFromWholeFile(reply.raw, continueFrom, start + sent, end, (length) => {
+          if (noteInputBytes) {
+            noteInputBytes(sessionId, length);
+          }
+        });
+        logger.info(
+          `stream: read of "${file.name}" bytes ${start}-${end} continued from the whole file: ` +
+          `${fromTorrent} byte(s) from the torrent, ${sent - fromTorrent} from the file`
+        );
       }
       // THE BODY MUST BE AS LONG AS THE HEADER PROMISED, and nothing checked.
       //

package/services/encode/EncodeOrchestrator.js

@@ -457,6 +457,9 @@ export class EncodeOrchestrator {
    * @param {string} address
    */
   forgetOutput(address) {
+    // The output no longer exists. Its last map must not remain an input to
+    // later plans while stopped child processes finish exiting.
+    this.notePriorityMap(address, []);
     if (this.runsOn(address).length > 0) {
       return;
     }

package/services/torrent/worker/files-in-use.js

@@ -1,6 +1,7 @@
 /**
  * @file Which files of a torrent somebody is using, for the sweep that writes
- * whole files out and removes a torrent that has nothing left to fetch.
+ * whole files out and removes a torrent that has nothing left to fetch, and
+ * the two decisions that sweep makes with it.
  *
  * Two facts, and both are needed. A file somebody has stated a need for is in
  * use. So is a file being read: a read whose pieces are all here waits for
@@ -34,6 +35,59 @@ export function filesInUse({ torrent, windows, openReads }) {
   return used;
 }
 
+/**
+ * Which downloaded files to write out whole now.
+ *
+ * WHILE SOMEBODY WATCHES IT, and only then (user, 2026-10-09,
+ * torrent-tv/meta#173): as soon as a media file is downloaded it becomes a file
+ * and is read from that file. Written after its last viewer has left, it serves
+ * nobody — field 2026-10-09: a film re-encoded at 0.56x reached 100 % while it
+ * played, stayed 667 spilled pieces for the whole showing because the encoder
+ * read it without a pause, and was written a minute after the tab closed.
+ *
+ * @param {object} options
+ * @param {Array<{ done?: boolean }>} options.files - The torrent's files.
+ * @param {(fileIndex: number) => boolean} options.isKept - Already a file, or being written.
+ * @param {Set<number>} options.inUse - {@link filesInUse}.
+ * @returns {number[]} File indices.
+ */
+export function filesToKeep({ files, isKept, inUse }) {
+  const indices = [];
+  for (const [fileIndex, file] of files.entries()) {
+    if (file?.done === true && inUse.has(fileIndex) && !isKept(fileIndex)) {
+      indices.push(fileIndex);
+    }
+  }
+  return indices;
+}
+
+/**
+ * Whether a torrent downloaded whole may be removed now.
+ *
+ * Every file of it is a file on disk, so a viewer's stated need is answered
+ * from those files and does not keep the torrent (torrent-tv/meta#173). A read
+ * still running on the piece store does, because removing the torrent closes
+ * that store under it (torrent-tv/meta#105). Nor in the sweep that announced a
+ * file: the main thread learns of it from that announcement, and a read it
+ * sent to this thread before then would find the torrent gone.
+ *
+ * @param {object} options
+ * @param {object} options.torrent
+ * @param {(fileIndex: number) => boolean} options.isKept - Already a file.
+ * @param {Iterable<{ torrent: object, fileIndex: number }>} options.openReads - Reads in flight, read just now.
+ * @param {boolean} options.announcedNow - A file of it was announced in this sweep.
+ * @returns {boolean}
+ */
+export function mayRemoveWholeTorrent({ torrent, isKept, openReads, announcedNow }) {
+  if (torrent?.done !== true || !Array.isArray(torrent.files) || announcedNow) {
+    return false;
+  }
+  if (!torrent.files.every((unused, fileIndex) => isKept(fileIndex))) {
+    return false;
+  }
+  return filesInUse({ torrent, windows: [], openReads }).size === 0;
+}
+
 /** Range admission owns its read before any asynchronous storage operation. */
 export async function readWhileInUse(openReads, id, torrent, fileIndex, read) {
   if (!torrent) return read();

package/services/torrent/worker/worker.js

@@ -33,7 +33,7 @@ import { heldRangesOf, ownsItsMemory, readHeldBytes, readHeldRanges } from "./he
 import { CompletedFiles, completedFilesRoot } from "../../storage/files/CompletedFiles.js";
 import { pieceFromWholeFiles, pieceIsInWholeFiles } from "../../storage/files/piece-from-whole-file.js";
 import { Command, Event } from "./protocol.js";
-import { filesInUse, readWhileInUse } from "./files-in-use.js";
+import { filesInUse, filesToKeep, mayRemoveWholeTorrent, readWhileInUse } from "./files-in-use.js";
 import { createWholeSources } from "./whole-sources.js";
 import { wholeFileStats } from "./whole-file-stats.js";
 import { describeHeldObjects, readUtpOpenCount } from "./held-objects.js";
@@ -1069,8 +1069,8 @@ const WHOLE_FILE_SWEEP_MS = 10_000;
 const beingKept = new Set();
 
 /**
- * Keep every file that is now whole, and let go of a torrent that has nothing
- * left to fetch.
+ * Keep every file that is now whole while it is watched, and let go of a
+ * torrent that has nothing left to fetch.
  *
  * The instruction this serves, 2026-09-11: as soon as a torrent is fully
  * downloaded, downloading stops, the torrent is deleted, and what was
@@ -1098,21 +1098,22 @@ async function keepWholeFiles() {
       windows: demandFor(torrent).register.windows(),
       openReads: openReads.values()
     });
-    for (const [fileIndex, file] of torrent.files.entries()) {
+    // WHILE SOMEBODY WATCHES IT, and only then: see `filesToKeep`. Its cost
+    // beside the viewer is the disk — the pieces are read with `store.get`,
+    // which takes no block of memory from anybody.
+    const toKeep = filesToKeep({
+      files: torrent.files,
+      isKept: (fileIndex) =>
+        completedFiles.find(infoHash, fileIndex) !== null || beingKept.has(`${infoHash}/${fileIndex}`),
+      inUse: wanted
+    });
+    let announcedNow = false;
+    for (const fileIndex of toKeep) {
+      const file = torrent.files[fileIndex];
       const key = `${infoHash}/${fileIndex}`;
-      if (file?.done !== true || completedFiles.find(infoHash, fileIndex) || beingKept.has(key)) {
-        continue;
-      }
-      // NOT WHILE ANYBODY WANTS IT. Writing a film out is a read of the whole
-      // of it and a write of the whole of it — a gigabyte and a half on the
-      // file this was measured against — and doing that beside a viewer takes
-      // the disk and the piece store from them for nothing they asked for. The
-      // file is complete; it will still be complete when they leave.
-      if (wanted.has(fileIndex)) {
-        continue;
-      }
       beingKept.add(key);
       try {
+        const startedAt = performance.now();
         const kept = await completedFiles.keep({
           infoHash,
           fileIndex,
@@ -1122,7 +1123,8 @@ async function keepWholeFiles() {
         });
         if (kept) {
           logger.info(
-            `whole files: kept "${file.name}" (${Math.round(kept.length / 1048576)}MB) — ` +
+            `whole files: kept "${file.name}" (${Math.round(kept.length / 1048576)}MB, ` +
+            `written in ${((performance.now() - startedAt) / 1000).toFixed(1)}s) — ` +
             "it is a file now, and reading it needs no torrent"
           );
           // The pieces it was built from are a second copy of the same bytes.
@@ -1145,6 +1147,7 @@ async function keepWholeFiles() {
             length: kept.length,
             name: kept.name
           });
+          announcedNow = true;
           holdingsChanged();
         }
       } catch (error) {
@@ -1159,12 +1162,18 @@ async function keepWholeFiles() {
     //
     // Safe to destroy only because a piece can now be read out of those files:
     // a path that asks for this source again adds the torrent back, and what it
-    // verifies it reads from the files rather than from the swarm. Not while
-    // anybody is reading it, for the same reason the writing above waits.
-    const isWhole =
-      torrent.done === true &&
-      torrent.files.every((unused, fileIndex) => completedFiles.find(infoHash, fileIndex) !== null);
-    if (isWhole && wanted.size === 0) {
+    // verifies it reads from the files rather than from the swarm. A viewer
+    // still watching does not keep it — the files answer them — but a read
+    // still running on its piece store does: see `mayRemoveWholeTorrent`. The
+    // reads are taken now, not from the start of this sweep, because a write
+    // above can take minutes and a read can open while it runs.
+    const isRemovable = mayRemoveWholeTorrent({
+      torrent,
+      isKept: (fileIndex) => completedFiles.find(infoHash, fileIndex) !== null,
+      openReads: openReads.values(),
+      announcedNow
+    });
+    if (isRemovable) {
       logger.info(
         `whole files: "${torrent.name}" is downloaded whole and saved — removing the torrent, keeping the files`
       );