@torrent-tv/proxy 2.64.3 → 2.64.5

package/services/torrent-worker/client.js

@@ -59,11 +59,7 @@ export class TorrentWorkerClient {
    *
    * @type {Map<number, number>}
    */
-  #lastPieceByRead = new Map();
-  /** Each torrent's piece pool, so a fragment can be read where it lies. */
-  #poolBySource = new Map();
-  /** Which pool an in-flight read belongs to, keyed by request id. */
-  #poolByRead = new Map();
+   #lastPieceByRead = new Map();
   /** Reads consuming fragments in place, keyed by request id. */
   #fragmentReaders = new Map();
 
@@ -96,7 +92,6 @@ export class TorrentWorkerClient {
       if (message?.type === Event.ERROR && this.#fragmentReaders.has(message.id)) {
         const reader = this.#fragmentReaders.get(message.id);
         this.#fragmentReaders.delete(message.id);
-        this.#poolByRead.delete(message.id);
         reader.fail(new Error(message.error ?? "Torrent worker read failed."));
         return;
       }
@@ -105,28 +100,17 @@ export class TorrentWorkerClient {
       }
       switch (message?.type) {
         case Event.FRAGMENT: {
-          const pool = this.#poolByRead.get(message.id);
-          if (!pool) {
-            // No pool means no way to read the fragment; confirm it so the
+          const buffer = message.buffer;
+          if (!buffer) {
+            // No buffer means no way to read the fragment; confirm it so the
             // worker is not left waiting, and let the read end short.
             this.#worker.postMessage({ type: Event.FRAGMENT_DONE, id: message.id });
             break;
           }
-          // The pool is a growable SharedArrayBuffer shared with the worker
-          // thread, and an offset is only meaningful against the buffer of the
-          // store that produced it. When the two disagree — a second store
-          // opened for the same torrent, a slot handed out before the buffer
-          // grew — this threw `RangeError: Invalid typed array length`, which
-          // the process-wide handler swallowed. Reads then stopped answering
-          // for good: field 2026-08-09, one segment was held for a minute
-          // eight times running while the audio decoder was fed cut-up frames
-          // and reported them as a broken AC-3 stream. A read that cannot be
-          // satisfied must end short and say so, not take the whole source
-          // down silently.
-          if (message.offset + message.length > pool.byteLength) {
+          if (message.offset + message.length > buffer.byteLength) {
             logger.warn(
               `torrent-worker: fragment ${message.offset}+${message.length} lies outside ` +
-              `its pool of ${pool.byteLength}B (read ${message.id}) — ending the read short`
+              `its buffer of ${buffer.byteLength}B (read ${message.id}) — ending the read short`
             );
             this.#worker.postMessage({ type: Event.FRAGMENT_DONE, id: message.id });
             break;
@@ -150,7 +134,7 @@ export class TorrentWorkerClient {
             );
           }
           this.#lastPieceByRead.set(message.id, message.pieceIndex);
-          const view = new Uint8Array(pool, message.offset, message.length);
+          const view = new Uint8Array(buffer, message.offset, message.length);
 
           const reader = this.#fragmentReaders.get(message.id);
           if (reader) {
@@ -183,7 +167,6 @@ export class TorrentWorkerClient {
           this.#reads.delete(message.id);
           this.#fragmentReaders.get(message.id)?.close();
           this.#fragmentReaders.delete(message.id);
-          this.#poolByRead.delete(message.id);
           break;
         case Event.LOG:
           logger.info(`torrent-worker: ${message.message}`);
@@ -373,17 +356,10 @@ export class TorrentWorkerClient {
       onCancel: () => {
         void this.#caller.call(Command.CANCEL_READ, { readId }).catch(() => undefined);
         this.#reads.delete(readId);
-        this.#poolByRead.delete(readId);
         this.#lastPieceByRead.delete(readId);
       }
     });
     this.#reads.set(readId, receive);
-    // Which pool this read's fragments will point into. Recorded before the
-    // command is sent, because the first fragment can arrive immediately.
-    const pool = this.#poolBySource.get(sourceKey);
-    if (pool) {
-      this.#poolByRead.set(readId, pool);
-    }
 
     // The worker replies to READ_RANGE only once the body is fully sent; a
     // failure before that must surface on the stream, not vanish.
@@ -414,11 +390,6 @@ export class TorrentWorkerClient {
    * @returns {{ [Symbol.asyncIterator]: () => AsyncGenerator<{ bytes: Uint8Array, release: () => void }>, cancel: () => void } | null}
    */
   createFragmentReader({ sourceKey, fileIndex, start = null, end = null, windowBytes }) {
-    const pool = this.#poolBySource.get(sourceKey);
-    if (!pool) {
-      return null;
-    }
-
     const readId = this.#caller.nextId();
     /** @type {{ bytes: Uint8Array, release: () => void }[]} */
     const queue = [];
@@ -447,11 +418,9 @@ export class TorrentWorkerClient {
         notify();
       }
     });
-    this.#poolByRead.set(readId, pool);
 
     const cancel = () => {
       if (this.#fragmentReaders.delete(readId)) {
-        this.#poolByRead.delete(readId);
         void this.#caller.call(Command.CANCEL_READ, { readId }).catch(() => undefined);
       }
       finished = true;
@@ -513,11 +482,6 @@ export class TorrentWorkerClient {
    */
   async getTorrent({ sourceKey, sourceType, source }) {
     const info = await this.addSource({ sourceKey, sourceType, source });
-    // The torrent's piece pool. Both threads now hold the same memory, so a
-    // read can be answered with an offset instead of with bytes.
-    if (info.sharedBuffer) {
-      this.#poolBySource.set(sourceKey, info.sharedBuffer);
-    }
     const client = this;
     return {
       infoHash: info.infoHash,

package/services/torrent-worker/piece-reader.js

@@ -1082,6 +1082,7 @@ export async function* readFragments({
       deliveredBytes += toWithinPiece - fromWithinPiece + 1;
       yield {
         pieceIndex,
+        buffer: located.buffer,
         offset: located.offset + fromWithinPiece,
         length: toWithinPiece - fromWithinPiece + 1,
         release() {

package/services/torrent-worker/worker.js

@@ -37,7 +37,7 @@ import { startMemoryReport } from "../memory-report.js";
 // the hook above had a chance to register. Verified the hard way: with a static
 // import the process still aborted, and the stack named the genuine polyfill.
 const { TorrentPool, resolveDhtBootstrap } = await import("../torrent-pool.js");
-const { collectStoreStats, findSharedStore, reviseStoreBudgets } = await import("../piece-store/shared-piece-store.js");
+const { collectStoreStats, reviseStoreBudgets } = await import("../piece-store/shared-piece-store.js");
 
 // Resolved before the client exists, because the client builds its DHT in its
 // own constructor and the addresses have to be in hand by then. Awaiting here
@@ -176,6 +176,7 @@ function sendFragment(id, fragment) {
       type: Event.FRAGMENT,
       id,
       pieceIndex: fragment.pieceIndex,
+      buffer: fragment.buffer,
       offset: fragment.offset,
       length: fragment.length
     });
@@ -304,10 +305,6 @@ async function runCommand(command, params, id) {
       return {
         infoHash: torrent.infoHash,
         name: torrent.name,
-        // The piece pool itself. A `SharedArrayBuffer` crosses as a reference to
-        // the same memory rather than a copy, which is what lets the main thread
-        // read a piece where it already lies instead of being sent its bytes.
-        sharedBuffer: findSharedStore(torrent)?.sharedBuffer ?? null,
         // Files cross as plain data; the objects stay here.
         files: (torrent.files ?? []).map((file, index) => ({
           index,
@@ -502,21 +499,26 @@ const lastReported = new Map();
 
 setInterval(() => {
   // What the machine can spare NOW, not what it could spare when each store was
-  // created. Lowering a ceiling frees nothing already committed — the pool
-  // cannot shrink — but it stops growth into memory the host no longer has, and
-  // those pieces go to disk instead (roadmap item 2).
+  // created. With per-piece buffers a lowered ceiling is honoured immediately:
+  // excess pieces are evicted to disk and their memory is reclaimable.
   for (const revised of reviseStoreBudgets()) {
-    if (revised.committedBytes > revised.ceilingBytes) {
+    if (revised.evicted > 0) {
+      log(
+        `piece-store "${revised.name.slice(0, 40)}": allowance is now ` +
+        `${Math.round(revised.ceilingBytes / 1048576)}MB, evicted ${revised.evicted} piece(s) to meet it — ` +
+        `now ${Math.round(revised.committedBytes / 1048576)}MB committed`
+      );
+    } else if (revised.committedBytes > revised.ceilingBytes) {
       log(
         `piece-store "${revised.name.slice(0, 40)}": allowance is now ` +
         `${Math.round(revised.ceilingBytes / 1048576)}MB and ` +
-        `${Math.round(revised.committedBytes / 1048576)}MB is already committed — ` +
-        `it will not grow further, and cannot give back what it holds`
+        `${Math.round(revised.committedBytes / 1048576)}MB is committed — ` +
+        `all resident pieces are pinned, cannot shrink yet`
       );
     }
   }
   for (const stats of collectStoreStats()) {
-    const signature = `${stats.fromMemory}/${stats.fromDisk}/${stats.spills}/${stats.revivals}/${stats.blockedByPins}`;
+    const signature = `${stats.fromMemory}/${stats.fromDisk}/${stats.spills}/${stats.revivals}/${stats.blockedByPins}/${stats.evictedOnRevise}`;
     if (lastReported.get(stats.name) === signature) {
       continue;
     }
@@ -525,21 +527,15 @@ setInterval(() => {
     const reads = stats.fromMemory + stats.fromDisk;
     const fromMemoryShare = reads > 0 ? ((stats.fromMemory / reads) * 100).toFixed(1) : "—";
     log(
-      // In BYTES as well as in pieces. The count alone says nothing without the
-      // piece size, and the piece size differs per torrent: on the film the
-      // proxy was killed under, 2026-08-28, "63" meant 504 MB.
       `piece-store "${stats.name.slice(0, 40)}": resident=${stats.resident}/${stats.capacity} ` +
       `(${Math.round((stats.residentBytes || 0) / 1048576)}MB of ` +
       `${Math.round((stats.budgetBytes || 0) / 1048576)}MB allowed) ` +
-      // What the machine has actually parted with, which is not what is held:
-      // the pool only grows, so a spilled piece frees its slot and no memory.
-      // Reporting the first without the second is what hid 650 MB on
-      // 2026-08-28 (roadmap item 2).
       `committed=${Math.round((stats.committedBytes || 0) / 1048576)}MB ` +
       `on-disk=${Math.round((stats.spilledBytes || 0) / 1048576)}MB ` +
       `pinned=${stats.pinned} spilled=${stats.spilled} reads=${reads} (${fromMemoryShare}% from memory) ` +
       `spills=${stats.spills} revivals=${stats.revivals}` +
-      (stats.blockedByPins > 0 ? ` blocked-by-pins=${stats.blockedByPins}` : "")
+      (stats.blockedByPins > 0 ? ` blocked-by-pins=${stats.blockedByPins}` : "") +
+      (stats.evictedOnRevise > 0 ? ` evictedOnRevise=${stats.evictedOnRevise}` : "")
     );
   }
 }, STORE_REPORT_INTERVAL_MS).unref();

package/test/piece-reader.test.js

@@ -63,7 +63,6 @@ async function fakeTorrent({ fileOffset, fileLength, totalLength }) {
 async function readRange(torrent, start, end) {
   const collected = [];
   const positions = [];
-  const pool = Buffer.from(torrent.store.sharedBuffer);
   for await (const fragment of readFragments({
     torrent,
     fileIndex: 0,
@@ -71,7 +70,8 @@ async function readRange(torrent, start, end) {
     end,
     cancellation: { isCancelled: () => false }
   })) {
-    collected.push(Buffer.from(pool.subarray(fragment.offset, fragment.offset + fragment.length)));
+    const source = fragment.buffer ? Buffer.from(fragment.buffer, fragment.offset, fragment.length) : Buffer.alloc(0);
+    collected.push(Buffer.from(source));
     positions.push({ piece: fragment.pieceIndex, length: fragment.length });
     fragment.release();
   }

package/test/shared-piece-store.test.js

@@ -133,7 +133,7 @@ test("a pinned piece is not evicted to make room", async () => {
 
     const located = store.locate(0);
     assert.ok(located, "the pinned piece was evicted while held");
-    const view = Buffer.from(store.sharedBuffer, located.offset, located.length);
+    const view = Buffer.from(located.buffer, located.offset, located.length);
     assert.deepEqual(view, piece(0), "the pinned piece was overwritten in place");
 
     store.unpin(0);
@@ -175,7 +175,7 @@ test("a piece revived from disk is readable by offset again", async () => {
     await get(store, 0); // brings it back
     const located = store.locate(0);
     assert.ok(located, "piece 0 was not brought back into memory");
-    const view = Buffer.from(store.sharedBuffer, located.offset, located.length);
+    const view = Buffer.from(located.buffer, located.offset, located.length);
     assert.deepEqual(view, piece(0));
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
@@ -215,25 +215,19 @@ test("takes memory as it needs it, not the whole budget up front", async () => {
   const { store, directory } = await makeStore({ pieces: 16, totalPieces: 64 });
   try {
     assert.equal(store.capacity, 16);
-    const initial = store.sharedBuffer.byteLength;
-    assert.ok(initial <= CHUNK * 2, `claimed ${initial} bytes before holding anything`);
+    const initial = store.stats().committedBytes;
+    assert.ok(initial === 0, `claimed ${initial} bytes before holding anything`);
 
     for (let index = 0; index < 5; index += 1) {
       await put(store, index, piece(index));
     }
 
     assert.equal(store.residentCount, 5);
-    assert.ok(
-      store.sharedBuffer.byteLength >= CHUNK * 5,
-      "the pool did not grow to hold what was put in it"
-    );
-    assert.ok(
-      store.sharedBuffer.byteLength <= CHUNK * 6,
-      "the pool grew past what was actually needed"
-    );
+    assert.equal(store.stats().committedBytes, CHUNK * 5, "committed should equal resident");
+    assert.equal(store.stats().residentBytes, CHUNK * 5);
 
-    // Growing must not move bytes already written.
-    assert.deepEqual(await get(store, 0), piece(0), "an early piece was disturbed by growth");
+    // Per-piece buffers must not disturb early pieces.
+    assert.deepEqual(await get(store, 0), piece(0), "an early piece was disturbed");
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
     await fs.rm(directory, { recursive: true, force: true });