@torrent-tv/proxy 2.87.0 → 2.87.2

package/services/encode/EncodeOrchestrator.js

@@ -33,6 +33,14 @@ import { contentionPenalty } from "./contention.js";
 import { SegmentDemand } from "./SegmentDemand.js";
 import { runStateOf } from "./encode-run-state.js";
 
+/**
+ * @typedef {Object} SegmentCoverage
+ * @property {(address: string) => number[]} provenNumbers
+ * @property {(address: string, index: number) => void} announce
+ * @property {(address: string) => number} filesHeld
+ * @property {(address: string, startedAt: number) => number} clearUpAfter
+ */
+
 /**
  * How long nothing is placed on an output whose input has just gone, and the
  * ceiling that doubling reaches.
@@ -58,6 +66,9 @@ export class EncodeOrchestrator {
   /** Output address to what has been made of it. @type {Map<string, CoverageMap>} */
   #coverage = new Map();
 
+  /** @type {SegmentCoverage | null} */
+  #segmentCoverage = null;
+
   /** Output address to the runs on it. @type {Map<string, import("../encode/EncodeRun.js").EncodeRun[]>} */
   #runs = new Map();
 
@@ -148,6 +159,7 @@ export class EncodeOrchestrator {
    *   HANDED IN: what anybody waited for belongs to the priority layer, and
    *   this one may be asked about encoders with no ledger, no clock and no
    *   viewer anywhere. Absent, the line simply does not carry it.
+   * @param {SegmentCoverage | null} [params.segmentCoverage]
    */
   constructor({
     maxRunsFor,
@@ -156,7 +168,7 @@ export class EncodeOrchestrator {
     contentionPenalties = null,
     refetchSecPerFilmSecond = () => 0,
     startingSpeedFor = () => 0,
-    segmentStore = null,
+    segmentCoverage = null,
     planSoon = null,
     describeWaits = null,
     admission = null,
@@ -169,11 +181,9 @@ export class EncodeOrchestrator {
     // is about one output, and then only the per-output limit binds.
     this.admission = admission && typeof admission.placesFor === "function" ? admission : null;
     this.#describeWaits = typeof describeWaits === "function" ? describeWaits : () => "";
-    // The store of produced segments — the layer below this one. It is asked to
-    // clean up after a run that ended other than by reaching the end of its
-    // stretch, which is the one thing an ending must not leave behind: a file
-    // under a name that promises a whole segment.
-    this.segmentStore = segmentStore;
+    // Only the segment facts and operations this planner needs cross the
+    // storage boundary; the concrete storage remains in the server assembly.
+    this.#segmentCoverage = segmentCoverage;
     this.maxRunsFor = maxRunsFor;
     // Seconds of swarm time per second of film: what re-encoding material that
     // already exists costs the download, over and above the encoder's own time.
@@ -238,8 +248,8 @@ export class EncodeOrchestrator {
    */
   #upToDateCoverage(address) {
     const coverage = this.coverageOf(address);
-    if (this.segmentStore) {
-      coverage.setReady(this.segmentStore.provenNumbers(address));
+    if (this.#segmentCoverage) {
+      coverage.setReady(this.#segmentCoverage.provenNumbers(address));
     }
     return coverage;
   }
@@ -549,9 +559,9 @@ export class EncodeOrchestrator {
     // Nothing is told to the store: by the time this is called the piece is
     // ALREADY under its served name, because the rename is what closing it
     // means. A statement kept beside the disk would be a second owner of one
-    // fact, which is what item 87 removed from the coverage map.
+    // fact, which removed the stale second owner from the coverage map.
     this.coverageOf(address).markReady(index);
-    this.segmentStore?.announce?.(address, index);
+    this.#segmentCoverage?.announce?.(address, index);
     for (const run of this.runsOn(address)) {
       run.noteProduced(index);
     }
@@ -805,7 +815,7 @@ export class EncodeOrchestrator {
       this.#lastUnmet.delete(address);
     } else if (this.#lastUnmet.get(address) !== wanting) {
       this.#lastUnmet.set(address, wanting);
-      const held = this.segmentStore ? this.segmentStore.filesHeld(address) : -1;
+      const held = this.#segmentCoverage ? this.#segmentCoverage.filesHeld(address) : -1;
       this.logger.warn(
         `encode: #${wanting} of ${address} is wanted and NO ENCODER IS MAKING IT — ` +
         `ready=${coverage.stats().ready} of ${coverage.segmentCount} ` +
@@ -1009,7 +1019,7 @@ export class EncodeOrchestrator {
     // is a name match: no stretch to search and no bytes to judge. Done for
     // every ending, the normal one included, since a run that finished cleanly
     // has nothing under a working name and the sweep then removes nothing.
-    this.segmentStore?.clearUpAfter(ended.address, ended.from);
+    this.#segmentCoverage?.clearUpAfter(ended.address, ended.from);
     this.coverageOf(ended.address).release(ended.run);
     const remaining = this.runsOn(ended.address).filter((run) => run !== ended.run);
     if (remaining.length === 0) {
@@ -1182,7 +1192,7 @@ export class EncodeOrchestrator {
       // different statements: files with nothing proving them closed reads as a
       // reporting fault, no files at all reads as an output yet to be made, and
       // the difference decides where to look.
-      const held = this.segmentStore ? this.segmentStore.filesHeld(address) : -1;
+      const held = this.#segmentCoverage ? this.#segmentCoverage.filesHeld(address) : -1;
       // AND WHETHER THE MAP IS BEING SERVED IN ITS OWN ORDER. The zones say
       // what matters most; this says what the viewer actually waited for, by
       // band. Waits at `now` are the ones that cost a spinner, and until this

package/services/encode/EncodeRuns.js

@@ -15,6 +15,14 @@ import { ENCODE_EXIT } from "./encode-exit.js";
 import { EncodeRun } from "./EncodeRun.js";
 import { computeOutputDimensions } from "./args.js";
 import { buildRunCommand, trueStartOf } from "./run-command.js";
+
+/**
+ * @typedef {Object} SegmentFiles
+ * @property {(address: string) => string} pathFor
+ * @property {(address: string) => Buffer | null} initOf
+ * @property {(address: string) => string} directoryFor
+ * @property {(address: string, makingName: string, format: object) => string | null} publish
+ */
 // How far the accounting of a backward restart looks for work about to be done
 // twice. It runs on the restart path and a session an hour in has thousands of
 // segments; the figure is for a comparison, not an inventory.
@@ -147,7 +155,9 @@ export class EncodeRuns {
   #planScheduled = false;
 
   /**
-   * @param {object} host - `logger`, `viewerSecondsOn`, `noteRunStarting`, `inputOf`, `producedNumbers`, `servesAudioSeparately`, `disposeSession`, `contentionPenalties`, `encodeCost`, `encodeOrchestrator`, `encoders`, `ffmpegBin`, `outputTimes`, `outputs`, `priority`, `segmentDurationSec`, `segmentStore`, `videoEncoder`
+   * @param {object} host - `logger`, `viewerSecondsOn`, `noteRunStarting`, `inputOf`, `producedNumbers`, `servesAudioSeparately`, `disposeSession`, `contentionPenalties`, `encodeCost`, `encodeOrchestrator`, `encoders`, `ffmpegBin`, `outputTimes`, `outputs`, `priority`, `segmentDurationSec`, `segmentFiles`, `videoEncoder`
+   * @param {SegmentFiles} host.segmentFiles - The storage operations used to
+   *   write and inspect output files.
    */
   constructor(host) {
     this.#host = host;
@@ -542,7 +552,7 @@ export class EncodeRuns {
    * @returns {void}
    */
   noteRunProducedSegment(session, filePath) {
-    if (typeof filePath !== "string" || path.dirname(filePath) !== this.#host.segmentStore.pathFor(session.outputKey ?? "")) {
+    if (typeof filePath !== "string" || path.dirname(filePath) !== this.#host.segmentFiles.pathFor(session.outputKey ?? "")) {
       return;
     }
     const index = session.segmentFormat.segmentIndexFromName(path.basename(filePath));
@@ -580,7 +590,7 @@ export class EncodeRuns {
    * @returns {void}
    */
   #warnIfRunLeavesTheInitBehind(session) {
-    const initBytes = this.#host.segmentStore.initOf(session.outputKey ?? "");
+    const initBytes = this.#host.segmentFiles.initOf(session.outputKey ?? "");
     if (!session.spec.transcodesVideo || !initBytes || initBytes.length === 0) {
       return; // nothing served yet, or nothing being encoded
     }
@@ -804,7 +814,7 @@ export class EncodeRuns {
       totalSeconds: Number(session.file.durationSeconds) || null,
       spawn: (spawnArgs) =>
         spawn(this.#host.ffmpegBin, spawnArgs, {
-          cwd: this.#host.segmentStore.directoryFor(session.outputKey ?? ""),
+          cwd: this.#host.segmentFiles.directoryFor(session.outputKey ?? ""),
           // A fourth channel: the encoder names every piece it has CLOSED on it,
           // which is the only proof a piece is whole.
           stdio: ["ignore", "pipe", "pipe", "pipe"]
@@ -821,7 +831,7 @@ export class EncodeRuns {
       // Why this encoder exists, recorded with its argument list. It used to be
       // handed to a separate `start` call; there is no separate call now.
       because,
-      onClosed: (name) => this.#host.segmentStore.publish(session.outputKey ?? "", name, session.segmentFormat),
+      onClosed: (name) => this.#host.segmentFiles.publish(session.outputKey ?? "", name, session.segmentFormat),
       onEnded: (ended) => this.noteRunEnded(session, run, ended)
     });
     // THE ONE FAULT THAT IS OTHERWISE SILENT, asked before this run produces a

package/services/encode/OutputOpening.js

@@ -28,6 +28,14 @@ import { rungForVisiblePicture } from "./quality/visible-rung.js";
 import { audioLoadOf, linkAnswerFigures as linkFiguresOf } from "./quality/link-budget.js";
 import { AUDIO_TRANSCODE_KBPS } from "./args.js";
 
+/**
+ * @typedef {Object} SegmentOutputFiles
+ * @property {() => string[]} addresses
+ * @property {(address: string, index: number) => boolean} isClosed
+ * @property {(address: string) => number | null} lastReadAt
+ * @property {(address: string) => string} directoryFor
+ * @property {(address: string, format: object) => void} useFormat
+ */
 
 /** Own package version, stamped onto output-start log lines. */
 const PROXY_VERSION = createRequire(import.meta.url)("../../package.json").version;
@@ -37,7 +45,9 @@ export class OutputOpening {
   #host;
 
   /**
-   * @param {object} host - `logger`, `probeMediaInfo`, `probeKeyframeTimes`, `enabled`, `segmentFormat`, `renditions`, `sourceFiles`, `getCachedMediaInfo`, `localBaseUrl`, `tonemapSupported`, `videoEncoder`, `hostLoad`, `keyframeTables`, `timelines`, `segmentDurationSec`, `softwarePresetBenchmark`, `decodeCostModel`, `encodeCost`, `outputs`, `segmentStore`, `hostTimings`, `returns`, `encodeRuns`
+   * @param {object} host - `logger`, `probeMediaInfo`, `probeKeyframeTimes`, `enabled`, `segmentFormat`, `renditions`, `sourceFiles`, `getCachedMediaInfo`, `localBaseUrl`, `tonemapSupported`, `videoEncoder`, `hostLoad`, `keyframeTables`, `timelines`, `segmentDurationSec`, `softwarePresetBenchmark`, `decodeCostModel`, `encodeCost`, `outputs`, `segmentOutputFiles`, `hostTimings`, `returns`, `encodeRuns`
+   * @param {SegmentOutputFiles} host.segmentOutputFiles - The storage
+   *   operations needed while selecting or opening an output.
    */
   constructor(host) {
     this.#host = host;
@@ -586,8 +596,8 @@ export class OutputOpening {
       serving: {
         mode: servingMode ?? (forceExactSize ? "manual" : "auto"),
         linkMbps: viewerLinkMbps,
-        keys: [...this.#host.outputs.values()].map((other) => other.outputKey).concat(this.#host.segmentStore.addresses()),
-        readyAt: (key) => this.#host.segmentStore.isClosed(key, timeline.indexForTime(Math.max(0, startPositionSeconds))),
+        keys: [...this.#host.outputs.values()].map((other) => other.outputKey).concat(this.#host.segmentOutputFiles.addresses()),
+        readyAt: (key) => this.#host.segmentOutputFiles.isClosed(key, timeline.indexForTime(Math.max(0, startPositionSeconds))),
         observedPeakMbps: (candidate) => this.#host.observedPeakMbps?.(candidate) ?? null
       }
     });
@@ -679,9 +689,9 @@ export class OutputOpening {
     // A RETURN, if this output was held before — and its age, which is the one
     // term of the keeping period that nothing measures. Read BEFORE the
     // directory is claimed, since claiming it is what marks it read.
-    this.#host.returns.note({ lastReadAt: this.#host.segmentStore.lastReadAt(spec.toKey()), now: Date.now() });
-    this.#host.segmentStore.directoryFor(spec.toKey());
-    this.#host.segmentStore.useFormat(spec.toKey(), segmentFormat);
+    this.#host.returns.note({ lastReadAt: this.#host.segmentOutputFiles.lastReadAt(spec.toKey()), now: Date.now() });
+    this.#host.segmentOutputFiles.directoryFor(spec.toKey());
+    this.#host.segmentOutputFiles.useFormat(spec.toKey(), segmentFormat);
     this.#host.hostTimings.noteOutputCreated(session, createEntryMs);
     this.#host.encodeRuns.setReadWindow(session, readWindowBytes);
     this.#host.encodeCost.notePredictionFor(session, output.encodeHeight);

package/services/encode/quality/QualityController.js

@@ -59,6 +59,8 @@ const BUDGET_DOWNLOAD_OK_FACTOR = 1.0;
 // segments (the newest file on disk may still be written and is excluded).
 const LINK_OBSERVED_SEGMENTS = 5;
 
+/** @typedef {{ pathOf: (address: string, index: number) => string | null }} SegmentPathLookup */
+
 export class QualityController {
   /** What this reads and asks of the rest of the proxy, and nothing else. @type {object} */
   #host;
@@ -70,7 +72,9 @@ export class QualityController {
   #judging = new Set();
 
   /**
-   * @param {object} host - `isLive`, `liveConsumers`, `liveRunsOf`, `producedNumbers`, `reportHostLoad`, `runStateOf`, `sampleDownloadRates`, `encodeCost`, `getSourceStats`, `outputs`, `qualityOffer`, `segmentDurationSec`, `segmentStore`, `videoEncoder`, `prepareSameHeightSwitch`, `sameHeightSwitchPending`, `sameHeightSwitchDirection`, `cancelSameHeightSwitch`, `heightReadyFor`, `bufferOf`, `visiblePictureOf`, `expectedFirstSegmentMs`
+   * @param {object} host - `isLive`, `liveConsumers`, `liveRunsOf`, `producedNumbers`, `reportHostLoad`, `runStateOf`, `sampleDownloadRates`, `encodeCost`, `getSourceStats`, `outputs`, `qualityOffer`, `segmentDurationSec`, `segmentPaths`, `videoEncoder`, `prepareSameHeightSwitch`, `sameHeightSwitchPending`, `sameHeightSwitchDirection`, `cancelSameHeightSwitch`, `heightReadyFor`, `bufferOf`, `visiblePictureOf`, `expectedFirstSegmentMs`
+   * @param {SegmentPathLookup} host.segmentPaths - Lookup for completed
+   *   segment paths needed by quality decisions.
    */
   constructor(host) {
     this.#host = host;
@@ -751,7 +755,7 @@ export class QualityController {
     let bytes = 0;
     try {
       for (const index of completed) {
-        const segmentPath = this.#host.segmentStore.pathOf(session.outputKey ?? "", index);
+        const segmentPath = this.#host.segmentPaths.pathOf(session.outputKey ?? "", index);
         if (!segmentPath) {
           break;
         }

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/server/http-responses.js

@@ -0,0 +1,60 @@
+/**
+ * Shared HTTP responses used by more than one route.
+ */
+/**
+ * The answer given when no output suits this viewer: nothing this proxy holds
+ * or could produce is admitted by their link. Machine-readable, because the
+ * page has to explain it to the viewer and offer what they can do; the
+ * figures are the ones the decision was made on.
+ *
+ * 409 and not a 5xx: nothing is wrong with the proxy, and repeating the same
+ * request against the same link gives the same answer.
+ *
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ reason: string, figures: object | null, wantedKey?: string }} details
+ * @returns {import("fastify").FastifyReply}
+ */
+export function replyOutputUnavailable(reply, details) {
+  return reply.code(409).send({
+    error: `No output suits this viewer: ${details?.reason ?? "unknown"}.`,
+    outcome: "output-unavailable",
+    reason: details?.reason ?? "",
+    figures: details?.figures ?? null
+  });
+}
+
+/**
+ * The answer given when this machine cannot take the output asked for: nothing
+ * it has shown it can encode fits, or it has no place for one more encoder.
+ * The page answers it by asking the rest of the pool before anything plays.
+ *
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ reason: string, figures?: object | null }} details
+ * @returns {import("fastify").FastifyReply}
+ */
+export function replyNoCapacity(reply, details) {
+  return reply.code(409).send({
+    error: `This proxy cannot take this video now: ${details?.reason ?? "unknown"}.`,
+    outcome: "no-capacity",
+    reason: details?.reason ?? "",
+    figures: details?.figures ?? null
+  });
+}
+
+/**
+ * The answer given when an address this viewer was already given cannot be
+ * given again without risking a piece under a header it may not match. The
+ * page answers it by starting a new viewing where the picture is — which is
+ * why it is not a "retry": the same request would be answered the same way.
+ *
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ reason: string }} details
+ * @returns {import("fastify").FastifyReply}
+ */
+export function replyAssignmentLost(reply, details) {
+  return reply.code(409).send({
+    error: `This part was answered by an output that has gone: ${details?.reason ?? "unknown"}.`,
+    outcome: "assignment-lost",
+    reason: details?.reason ?? ""
+  });
+}