@torrent-tv/proxy 2.87.1 → 2.87.2

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.87.2
+
+- **Fix**: Close an output directory's file-system watch before removing the directory, so `SegmentStore.drop` actually frees it on Windows.
+- **Fix**: Keep the proxy's registry id in `--state-dir` across restarts. An explicit `--id` remains authoritative; without a state directory, ids remain ephemeral.
+- **Fix**: Do not present Matroska's implicit `eng` language default as a language stated by the subtitle track; let the measured cue-text detector answer when enough text is available.
+
 ## 2.87.1
 
 - **Chore**: Keep HTTP route modules independent by moving shared response and transcode-file handling into server services. Pass encoding components narrow segment-storage interfaces and document the browser-facing HTTP contract.

package/bin/cli.js

@@ -14,7 +14,6 @@
 // for the measurement that made it necessary.
 import "./thread-pool.js";
 import { Command } from "commander";
-import crypto from "node:crypto";
 import os from "node:os";
 import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
@@ -33,6 +32,7 @@ import { startMemoryReport } from "../services/storage/memory-report.js";
 import { fragmentBufferCollection } from "../services/torrent/worker/client.js";
 import { collectHealthMetrics } from "../services/transport/health-collector.js";
 import { createPortMapper } from "../services/transport/port-mapper.js";
+import { installationId } from "../services/identity/installation-id.js";
 import { classifyNat } from "../services/transport/nat-classifier.js";
 import { DEFAULT_SEGMENT_FORMAT_ID, SEGMENT_FORMAT_IDS } from "../services/encode/segment-formats/index.js";
 import { logToFile, logger } from "../utils/logger.js";
@@ -132,7 +132,7 @@ const bindHost = String(options.host);
 const explicitBaseUrl = options.publicBaseUrl
   ? String(options.publicBaseUrl).replace(/\/+$/, "")
   : "";
-const clientId = options.id ? String(options.id) : crypto.randomUUID();
+const clientId = installationId({ stateDir: options.stateDir, explicitId: options.id });
 const clientName = options.name ? String(options.name) : `proxy-${clientId.slice(0, 8)}`;
 const token = String(options.token ?? "");
 const transcodeAudio = options.transcodeAudio !== false;

package/package.json

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

package/services/identity/installation-id.js

@@ -0,0 +1,38 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+const ID_FILE = "proxy-identity.json";
+
+/**
+ * Resolve this installation's registry id. Without a state directory the id
+ * remains ephemeral; with one, the id survives process restarts.
+ *
+ * @param {{ stateDir?: string, explicitId?: string, makeId?: () => string }} options
+ * @returns {string}
+ */
+export function installationId({ stateDir, explicitId, makeId = randomUUID } = {}) {
+  const requestedId = typeof explicitId === "string" ? explicitId.trim() : "";
+  if (!stateDir) {
+    return requestedId || makeId();
+  }
+
+  const file = path.join(stateDir, ID_FILE);
+  let savedId = "";
+  if (existsSync(file)) {
+    const saved = JSON.parse(readFileSync(file, "utf8"));
+    savedId = typeof saved?.id === "string" ? saved.id.trim() : "";
+    if (!savedId) {
+      throw new Error(`Invalid proxy identity file: ${file}`);
+    }
+  }
+
+  const id = requestedId || savedId || makeId();
+  if (id !== savedId) {
+    mkdirSync(stateDir, { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify({ id })}\n`, { mode: 0o600 });
+    renameSync(temporary, file);
+  }
+  return id;
+}

package/services/media/container/Container.js

@@ -272,6 +272,13 @@ export class Container {
       declared,
       "subtitle",
       (track) => ({
+        // Matroska applies `eng` when Language is absent, and ffmpeg reports
+        // that default as if the file had stated it. Preserve only an explicit
+        // container value; otherwise let cue-text detection decide later.
+        language: track.declaresLanguage === true
+          ? (track.languageBcp47 || track.language || "")
+          : "",
+        declaresLanguage: track.declaresLanguage === true,
         isDefault: track.isDefault === true,
         declaresDefault: track.declaresDefault === true,
         // Read from the file rather than guessed from the track's name. Both

package/services/media/container/MatroskaContainer.js

@@ -538,6 +538,7 @@ export class MatroskaContainer extends Container {
       // RFC 9559 LanguageBCP47 MUST — when present, Language ignored
       const resolvedLang = languageBcp47 || language;
       const bcpTag = languageBcp47;
+      const declaresLanguage = resolvedLang.length > 0;
 
       if (typeNum === 1) {
         videoDeclaredIndex += 1;
@@ -547,6 +548,7 @@ export class MatroskaContainer extends Container {
           codecId,
           language: resolvedLang,
           languageBcp47: bcpTag,
+          declaresLanguage,
           name,
           isEnabled,
           isDefault,
@@ -565,6 +567,7 @@ export class MatroskaContainer extends Container {
           codecId,
           language: resolvedLang,
           languageBcp47: bcpTag,
+          declaresLanguage,
           name,
           isEnabled,
           isDefault,
@@ -597,6 +600,7 @@ export class MatroskaContainer extends Container {
             codecId,
             language: resolvedLang,
             languageBcp47: bcpTag,
+            declaresLanguage,
             name,
             isEnabled: finalEnabled,
             isDefault: finalDefault,
@@ -615,6 +619,7 @@ export class MatroskaContainer extends Container {
             codecId,
             language: resolvedLang,
             languageBcp47: bcpTag,
+            declaresLanguage,
             name,
             isEnabled: finalEnabled,
             isDefault: finalDefault,
@@ -634,6 +639,7 @@ export class MatroskaContainer extends Container {
           codecId,
           language: resolvedLang,
           languageBcp47: bcpTag,
+          declaresLanguage,
           name,
           isEnabled,
           isDefault,
@@ -1047,11 +1053,13 @@ async function readSubtitlePlan(readRange, fileSize) {
     // `language` here stays the three-letter code, because this list exists to
     // be lined up against ffmpeg's banner, which prints that code. The RFC 5646
     // tag rides beside it for whoever displays the track.
+    const declaresLanguage = languageBcp47.length > 0 || language.length > 0;
     declared.push({
       trackNumber,
       codecId,
       language,
       languageBcp47,
+      declaresLanguage,
       name,
       isDefault,
       declaresDefault,
@@ -1071,6 +1079,7 @@ async function readSubtitlePlan(readRange, fileSize) {
       // three-letter code MUST be ignored.
       language: languageBcp47 || language,
       languageBcp47,
+      declaresLanguage,
       name,
       isDefault,
       isForced,

package/services/media/tracks/ContainerTrack.js

@@ -25,6 +25,7 @@ export class ContainerTrack {
    * @param {string} params.codecId - Matroska CodecID or MP4 sample entry type (e.g. "S_TEXT/UTF8", "avc1", "mp4a").
    * @param {string} params.language - Three-letter code or packed mdhd code; empty when absent. For Matroska, when LanguageBCP47 is present this is the BCP47 value ignored per MUST — caller stores both, but `language` here is the resolved one.
    * @param {string} params.languageBcp47 - RFC 5646 tag from LanguageBCP47 / elng, or "".
+   * @param {boolean} params.declaresLanguage - Whether the file explicitly supplies a language rather than relying on a container default.
    * @param {string} params.name - Track Name / title, or "".
    * @param {boolean} params.isEnabled - FlagEnabled / tkhd track_enabled. Default true per both specs. Matroska zero-length element means default, not disabled.
    * @param {boolean} params.isDefault - FlagDefault / tkhd? For MP4, derived from handler default? For Matroska, after applying default 1.
@@ -39,6 +40,7 @@ export class ContainerTrack {
     codecId,
     language,
     languageBcp47,
+    declaresLanguage,
     name,
     isEnabled,
     isDefault,
@@ -52,6 +54,7 @@ export class ContainerTrack {
     this.codecId = codecId ?? "";
     this.language = language ?? "";
     this.languageBcp47 = languageBcp47 ?? "";
+    this.declaresLanguage = declaresLanguage === true;
     this.name = name ?? "";
     this.isEnabled = isEnabled !== false;
     this.isDefault = isDefault === true;

package/services/storage/segment-store/SegmentStore.js

@@ -834,12 +834,12 @@ export class SegmentStore {
    */
   drop(key, because) {
     const dir = path.join(this.#root, directoryNameFor(key));
+    this.#unwatch(key);
     try {
       rmSync(dir, { recursive: true, force: true });
     } catch {
       // Already gone, or in use; the next sweep sees it either way.
     }
-    this.#unwatch(key);
     this.#held.delete(key);
     this.#formats.delete(key);
     this.#touched.delete(key);

package/test/installation-id.test.js

@@ -0,0 +1,39 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { installationId } from "../services/identity/installation-id.js";
+
+test("an installation id is reused from its state directory", (t) => {
+  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
+  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
+
+  assert.equal(installationId({ stateDir, makeId: () => "first-id" }), "first-id");
+  assert.equal(installationId({ stateDir, makeId: () => "unexpected-id" }), "first-id");
+  assert.deepEqual(JSON.parse(readFileSync(path.join(stateDir, "proxy-identity.json"), "utf8")), { id: "first-id" });
+});
+
+test("an explicit id takes precedence and becomes the saved installation id", (t) => {
+  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
+  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
+
+  assert.equal(installationId({ stateDir, explicitId: " configured-id " }), "configured-id");
+  assert.equal(installationId({ stateDir, makeId: () => "unexpected-id" }), "configured-id");
+});
+
+test("without a state directory the default id stays ephemeral", () => {
+  let calls = 0;
+  const makeId = () => `id-${++calls}`;
+
+  assert.equal(installationId({ makeId }), "id-1");
+  assert.equal(installationId({ makeId }), "id-2");
+});
+
+test("a damaged saved identity is reported instead of silently replaced", (t) => {
+  const stateDir = mkdtempSync(path.join(os.tmpdir(), "proxy-identity-"));
+  t.after(() => rmSync(stateDir, { recursive: true, force: true }));
+  writeFileSync(path.join(stateDir, "proxy-identity.json"), "{}\n");
+
+  assert.throws(() => installationId({ stateDir, makeId: () => "replacement" }), /Invalid proxy identity file/);
+});

package/test/segment-store.test.js

@@ -319,4 +319,5 @@ test("what the store weighs is reported, and dropping one output frees it", (t)
   assert.equal(store.stats().bytes, 2000);
   store.drop(KEY, "nobody is watching it");
   assert.equal(store.stats().outputs, 0);
+  assert.equal(readdirSync(root).length, 0, "the watched output directory was removed");
 });

package/test/subtitle-defaults.test.js

@@ -84,6 +84,27 @@ test("a container that declares nothing leaves the banner alone", () => {
   assert.equal(merged.tracks[0].declaresDefault, false);
 });
 
+test("an implicit Matroska English default does not become the subtitle language", () => {
+  const banner = [{ index: 0, language: "eng", title: "", isDefault: true }];
+  const declared = [{ language: "", languageBcp47: "", declaresLanguage: false, name: "" }];
+
+  const merged = Container.mergeSubtitleFlags(banner, declared);
+
+  assert.equal(merged.aligned, true);
+  assert.equal(merged.tracks[0].language, "");
+  assert.equal(merged.tracks[0].declaresLanguage, false);
+});
+
+test("an explicitly declared subtitle language is retained", () => {
+  const banner = [{ index: 0, language: "rus", title: "", isDefault: true }];
+  const declared = [{ language: "rus", languageBcp47: "", declaresLanguage: true, name: "" }];
+
+  const merged = Container.mergeSubtitleFlags(banner, declared);
+
+  assert.equal(merged.tracks[0].language, "rus");
+  assert.equal(merged.tracks[0].declaresLanguage, true);
+});
+
 test("a name confirms a pairing when the languages are unstated", () => {
   assert.equal(Container.pairingHolds({ language: "und", title: "Forced" }, { language: "", name: "Forced" }), true);
 });

package/test/subtitle-track-numbering.test.js

@@ -104,9 +104,11 @@ function trackEntry({ number, type, codecId, language, flags = {}, languageBcp47
   const parts = [
     uintElement(ID_TRACK_NUMBER, number),
     uintElement(ID_TRACK_TYPE, type),
-    stringElement(ID_CODEC_ID, codecId),
-    stringElement(ID_LANGUAGE, language)
+    stringElement(ID_CODEC_ID, codecId)
   ];
+  if (language !== undefined && language !== null) {
+    parts.push(stringElement(ID_LANGUAGE, language));
+  }
   if (languageBcp47 !== null) {
     parts.push(stringElement(ID_LANGUAGE_BCP47, languageBcp47));
   }
@@ -281,8 +283,9 @@ test("two walks of one file at the same time read each cluster once", async () =
 
 /**
  * A file whose subtitle tracks carry the flags RFC 9559 defines for them: one
- * forced, one for viewers who cannot hear, one the file marks unusable, and one
- * writing its language as RFC 5646 alongside the three-letter code.
+ * forced, one for viewers who cannot hear, one the file marks unusable, one
+ * writing its language as RFC 5646 alongside the three-letter code, and one
+ * relying on Matroska's default language.
  *
  * @returns {Buffer}
  */
@@ -293,7 +296,8 @@ function fileWithFlags() {
     trackEntry({ number: 2, type: 17, codecId: "S_TEXT/UTF8", language: "rus", flags: { forced: true } }),
     trackEntry({ number: 3, type: 17, codecId: "S_TEXT/UTF8", language: "eng", flags: { hearingImpaired: true } }),
     trackEntry({ number: 4, type: 17, codecId: "S_TEXT/UTF8", language: "fre", flags: { enabled: false } }),
-    trackEntry({ number: 5, type: 17, codecId: "S_TEXT/ASS", language: "por", languageBcp47: "pt-BR" })
+    trackEntry({ number: 5, type: 17, codecId: "S_TEXT/ASS", language: "por", languageBcp47: "pt-BR" }),
+    trackEntry({ number: 6, type: 17, codecId: "S_TEXT/UTF8", language: null })
   ]));
   const seekEntry = (targetId, position) => element(ID_SEEK, Buffer.concat([
     element(ID_SEEK_ID, idBytes(targetId)),
@@ -345,7 +349,7 @@ test("an unusable track keeps its place, so the tracks after it keep theirs", as
   // s:0 forced, s:1 SDH, s:2 the unusable one, s:3 the Brazilian track.
   assert.deepEqual(
     plan.tracks.map((track) => [track.trackNumber, track.declaredIndex]),
-    [[2, 0], [3, 1], [5, 3]]
+    [[2, 0], [3, 1], [5, 3], [6, 4]]
   );
 });
 
@@ -369,3 +373,14 @@ test("where the file writes RFC 5646, that is the language", async () => {
   assert.equal(track.language, "pt-BR", "not the three-letter por");
   assert.equal(track.languageBcp47, "pt-BR");
 });
+
+test("an omitted Matroska Language element stays unstated rather than becoming the RFC default", async () => {
+  const file = fileWithFlags();
+  const plan = await MatroskaContainer.readSubtitlePlan(readerOver(file), file.length);
+
+  const track = plan.tracks.find((entry) => entry.trackNumber === 6);
+  const declared = plan.declared.find((entry) => entry.trackNumber === 6);
+  assert.equal(track.language, "");
+  assert.equal(track.declaresLanguage, false);
+  assert.equal(declared.declaresLanguage, false);
+});