@torrent-tv/proxy 2.92.0 → 2.92.2

package/package.json

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

package/server.js

@@ -409,13 +409,13 @@ export async function startProxyServer({
     resolvePlayback: async (map) => {
       if (map.zones.length === 0) return [];
       const params = await containerOver(map);
-      if (!params) return [];
+      if (!params || !map.isCurrent()) return [];
       const tracks = await containerOrchestrator.inspect(params, "tracks");
-      if (tracks.kind !== "result") return [];
+      if (tracks.kind !== "result" || !map.isCurrent()) return [];
       const container = containerOrchestrator.known(map.sourceKey, map.fileIndex);
       if (typeof container?.readPacketIndex !== "function") return [];
       const media = await containerOrchestrator.inspect(params, "media-info");
-      if (media.kind !== "result") return [];
+      if (media.kind !== "result" || !map.isCurrent()) return [];
       const shift = Number(media.value?.startTimeSeconds) || 0;
       const converted = [];
       const demands = [];
@@ -445,6 +445,7 @@ export async function startProxyServer({
       }
       demands.sort((left, right) => left.deadlineAt - right.deadlineAt || right.priority - left.priority || left.index - right.index);
       for (const zone of demands) {
+        if (!map.isCurrent()) return [];
         const selected = zone.tracks.map(choice => ({ choice, track: tracks.value.filter(track => track.type === choice.type)[choice.index] }));
         if (selected.some(({ track }) => !track)) continue;
         const wanted = selected.map(({ track }) => track);
@@ -454,8 +455,10 @@ export async function startProxyServer({
         const intervalParams = await containerOver({ ...map, packetInterval: interval,
           requestId: `download:${map.sourceKey}:${map.fileIndex}:${zone.outputKey}:${zone.index}`,
           demand: { ...zone.owner, leadSeconds: zone.leadSeconds } });
+        if (!map.isCurrent()) return [];
         if (!intervalParams) continue;
         const packets = await containerOrchestrator.inspect(intervalParams, "packets");
+        if (!map.isCurrent()) return [];
         if (packets.kind !== "result") continue;
         const input = new SegmentInputs({ index: packets.value, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
         if (input.kind !== "result") continue;

package/services/encode/EncodeRun.js

@@ -578,6 +578,15 @@ export class EncodeRun {
         this.#publishClosed(this.#pendingClosed, name);
       }
       if (this.#publicationError) break;
+      const index = this.indexOfName(name);
+      const endOfWork = Number.isFinite(endOfRun(this)) ? this.to : this.lastSegmentIndex();
+      // A packet crossing the final cut can flush a following file. It may
+      // complete its predecessor, but no unadmitted interval can be published.
+      if (Number.isInteger(index) && Number.isInteger(endOfWork) && index > endOfWork) {
+        this.#closedTimings.delete(name);
+        this.#pendingClosed = null;
+        continue;
+      }
       this.#pendingClosed = name;
     }
   }

package/services/media/probe-packets.js

@@ -1,10 +1,15 @@
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
+import { accessSync, constants } from "node:fs";
 import { ffprobeRecord } from "./container/ffprobe-record.js";
 
 const require = createRequire(import.meta.url);
 function bundledProbe() {
-  try { return require("@ffprobe-installer/ffprobe").path; }
+  try {
+    const binary = require("@ffprobe-installer/ffprobe").path;
+    accessSync(binary, constants.X_OK);
+    return binary;
+  }
   catch { return "ffprobe"; }
 }
 

package/services/viewer/DownloadMaps.js

@@ -44,7 +44,8 @@ export class DownloadMaps {
     }
     if (changed) await this.#emit(file);
     if (revision !== file.revision) return;
-    const resolved = await this.#resolvePlayback({ sourceKey, fileIndex, durationSeconds, zones: file.sourceZones });
+    const resolved = await this.#resolvePlayback({ sourceKey, fileIndex, durationSeconds, zones: file.sourceZones,
+      isCurrent: () => this.#files.get(`${sourceKey}:${fileIndex}`) === file && revision === file.revision });
     if (revision !== file.revision) return;
     file.zones = resolved;
     return this.#emit(file);
@@ -53,7 +54,18 @@ export class DownloadMaps {
   refresh(sourceKey, fileIndex) {
     const file = this.#files.get(`${sourceKey}:${fileIndex}`);
     if (!file) return Promise.resolve();
-    return this.playback({ sourceKey, fileIndex, durationSeconds: file.durationSeconds, zones: file.sourceZones });
+    file.refreshAgain = true;
+    if (file.refreshPending) return file.refreshPending;
+    file.refreshPending = (async () => {
+      try {
+        do {
+          file.refreshAgain = false;
+          if (this.#files.get(`${sourceKey}:${fileIndex}`) !== file) return;
+          await this.playback({ sourceKey, fileIndex, durationSeconds: file.durationSeconds, zones: file.sourceZones });
+        } while (file.refreshAgain);
+      } finally { file.refreshPending = null; }
+    })();
+    return file.refreshPending;
   }
 
   epoch(sourceKey, fileIndex) {
@@ -95,7 +107,9 @@ export class DownloadMaps {
         deadlineAt = Number.isFinite(current.deadlineAt) ? current.deadlineAt - leadSeconds * 1000 : current.deadlineAt;
       }
       file.metadata.set(statement, { ranges: result.ranges, requestId: result.requestId, priority, urgent, deadlineAt, interval, leadSeconds, scope, order });
-    } else {
+    } else if (result.kind !== "needs-memory") {
+      // Allocation refusal says nothing about whether previously missing
+      // source bytes have arrived. Keep their demand until the read resolves.
       file.metadata.delete(statement);
     }
     return this.#emit(file);