@torrent-tv/proxy 2.81.1 → 2.81.2

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.81.2
+
+- **Fix**: `disk: 0MB free` on a host with 103 GB. The free space was read from the segments’ own directory, which is made when the first session starts and removed when the proxy stops — so at every start, and after every clean exit, the reading failed and answered zero, which means “no room” to everything downstream. It reads the nearest ancestor that exists; the disk is the same disk either way.
+- **Fix**: The spilled pieces were never registered with the owner of the disk, so it divided nothing and they kept the ceiling they had. The session manager holds no torrent pool — it is handed closures over the thread boundary — and 2.81.0 asked it for a field that does not exist. They arrive the same way everything else from that thread does.
+
 ## 2.81.1
 
 - **Fix**: The `disk:` line is actually said. 2.81.0 built the reading and called it from nowhere, so the one thing that can answer "why is there no room" was absent from the log. The owner says it itself, once a pass, in the series beside the memory reading.

package/package.json

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

package/server.js

@@ -178,6 +178,15 @@ export async function startProxyServer({
     // CPU-bound transcode from a download-starved input before downscaling.
     // What every torrent here has moved, so the proxy can price its own
     // downloading, hashing and delivery against the machine (roadmap item 7).
+    // What the spilled pieces weigh on the torrent thread, and how to tell them
+    // their share of the disk. The owner of the disk is on this side, where the
+    // segments are; the pieces are on the other.
+    spillDisk: typeof torrentPool.allowSpillBytes === "function"
+      ? {
+          held: () => torrentPool.spilledBytes ?? 0,
+          allow: (bytes) => torrentPool.allowSpillBytes(bytes)
+        }
+      : null,
     getTorrentTotals: async () => {
       if (typeof torrentPool.getTorrentTotals !== "function") {
         return null;

package/services/disk/free.js

@@ -0,0 +1,38 @@
+/**
+ * @file How much room the disk holding a directory has.
+ *
+ * Separate from the plain `statfs` reading because of one case that is the
+ * normal one, not an edge: the directory may not exist yet. The segments live
+ * under `os.tmpdir()/torrent-tv-hls`, which is made when the first session is
+ * created and removed when the proxy stops — so at every start, and after every
+ * clean exit, `statfs` on it fails. Field 2026-09-10: the first reading said
+ * `disk: 0MB free` on a host with 103 GB, and zero means "no room" to everything
+ * that reads it.
+ *
+ * The disk is the same disk whether or not that directory has been made yet, so
+ * the answer is the nearest ancestor that exists.
+ */
+
+import { statfs } from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * @param {string} directory
+ * @returns {Promise<number | null>} Bytes free, or null where nothing answered.
+ */
+export async function freeBytesFor(directory) {
+  let at = path.resolve(directory);
+  for (let depth = 0; depth < 16; depth += 1) {
+    try {
+      const stats = await statfs(at);
+      return Number(stats.bavail) * Number(stats.bsize);
+    } catch {
+      const up = path.dirname(at);
+      if (up === at) {
+        return null;
+      }
+      at = up;
+    }
+  }
+  return null;
+}

package/services/disk/wire.js

@@ -19,14 +19,16 @@ import { DiskSpace } from "./DiskSpace.js";
  *
  * @param {object} params
  * @param {{ root: string, stats: () => { bytes: number } }} params.segmentStore
- * @param {{ spilledBytes?: number, allowSpillBytes?: (bytes: number) => unknown }} [params.torrentPool]
+ * @param {{ held: () => number, allow: (bytes: number) => unknown }} [params.spill] -
+ *   The pieces the memory store spills. They live on the torrent thread, so
+ *   this is a pair of closures over the channel rather than the pool itself.
  * @param {(directory: string) => Promise<number | null>} params.readFree
  * @param {{ info: Function, warn?: Function }} [params.logger]
  * @returns {{ revise: () => Promise<unknown>, segmentBytes: () => number, describe: () => string }}
  *   What the segments may hold is asked for rather than pushed: zero until the
  *   first revision, and zero stops growth rather than licensing it.
  */
-export function wireDiskSpace({ segmentStore, torrentPool, readFree, logger }) {
+export function wireDiskSpace({ segmentStore, spill, readFree, logger }) {
   const space = new DiskSpace({ readFree: () => readFree(segmentStore.root), logger });
   let segmentBytes = 0;
   space.register({
@@ -39,16 +41,15 @@ export function wireDiskSpace({ segmentStore, torrentPool, readFree, logger }) {
       segmentBytes = bytes;
     }
   });
-  if (typeof torrentPool?.allowSpillBytes === "function") {
-    // The pieces the memory store spills. They live on the torrent thread, so
-    // the share travels the channel that already carries everything else, and
+  if (typeof spill?.allow === "function") {
+    // The share travels the channel that already carries everything else, and
     // the reply says what they hold — one exchange, both directions.
     space.register({
       name: "spilled pieces",
-      held: () => torrentPool.spilledBytes ?? 0,
+      held: () => spill.held?.() ?? 0,
       wanted: () => Number.MAX_SAFE_INTEGER,
       allow: (bytes) => {
-        void torrentPool.allowSpillBytes?.(bytes);
+        void spill.allow(bytes);
       }
     });
   }

package/services/hls-session-manager.js

@@ -93,8 +93,8 @@ import { Viewers } from "./viewer/Viewers.js";
 import { LiveOutputs } from "./output/LiveOutputs.js";
 import { variantHeightsFor } from "./output/ladder.js";
 import { EncodeOrchestrator } from "./orchestrators/EncodeOrchestrator.js";
-import { readDiskFree } from "./memory-report.js";
 import { wireDiskSpace } from "./disk/wire.js";
+import { freeBytesFor } from "./disk/free.js";
 
 /**
  * Whether an encoder run died because its INPUT went away, rather than because
@@ -1398,7 +1398,8 @@ export class HlsSessionManager {
     segmentFormatId = undefined,
     stateDir = "",
     segmentStore = null,
-    getTorrentTotals}) {
+    getTorrentTotals,
+    spillDisk = null}) {
     this.enabled = Boolean(enabled);
     this.ffmpegBin = ffmpegBin;
     this.keyframeTableBudgetMs = Number.isFinite(keyframeTableBudgetMs) && keyframeTableBudgetMs > 0
@@ -1451,6 +1452,10 @@ export class HlsSessionManager {
     // torrent itself costs the machine (item 7). Optional: a proxy wired
     // without it simply never learns that figure.
     this.getTorrentTotals = typeof getTorrentTotals === "function" ? getTorrentTotals : null;
+    // The spilled pieces, as a pair of closures over the torrent thread: what
+    // they weigh and how to tell them their share. Not the pool — the pool is
+    // on the other side of the thread boundary and this side holds none of it.
+    this.spillDisk = spillDisk;
     // Detected H.264 encoder descriptor (hardware or software). Defaults to
     // software libx264 when no detection result is supplied. May be downgraded
     // to software at runtime if a hardware encode fails.
@@ -1597,8 +1602,8 @@ export class HlsSessionManager {
     // One owner of the disk, and the list of what takes it lives with the owner.
     this.diskSpace = wireDiskSpace({
       segmentStore: this.segmentStore,
-      torrentPool: this.torrentPool,
-      readFree: readDiskFree,
+      spill: this.spillDisk,
+      readFree: freeBytesFor,
       logger
     });
     // Realtime-budget monitor: only meaningful for the software encoder with a

package/test/disk-space.test.js

@@ -148,3 +148,18 @@ test("it says what it decided, every pass", async () => {
   assert.equal(lines.length, 1, "a pass that decided the shares said nothing about them");
   assert.match(lines[0], /disk: 100MB free; segments 4MB of 8MB/);
 });
+
+test("the free space is read from the nearest directory that exists", async () => {
+  // The segments' directory is made when the first session starts and removed
+  // when the proxy stops, so at every start `statfs` on it fails. Field
+  // 2026-09-10: the first reading said `disk: 0MB free` on a host with 103 GB,
+  // and zero means "no room" to everything that reads it.
+  const { freeBytesFor } = await import("../services/disk/free.js");
+  const os = await import("node:os");
+  const path = await import("node:path");
+  const missing = path.join(os.tmpdir(), "no-such-directory-here", "nor-here");
+
+  const bytes = await freeBytesFor(missing);
+
+  assert.ok(Number.isFinite(bytes) && bytes > 0, "a directory that does not exist read as no disk");
+});