@torrent-tv/proxy 2.89.6 → 2.89.8

package/docs/playback-start-forecast.md

@@ -1,98 +1,113 @@
-# Playback start forecast
-
-For resource r, measured service is S_r(t) = rate_r * t. New observations
-replace the conditional future rate; polling cannot invent acceleration,
-exponential recovery or a new physical measurement.
-
-Source work uses the file's measured byte density, missing local byte ranges
-and the observed torrent download rate. Shared input ranges are downloaded
-once. Files on the same torrent share a queue; distinct torrents use distinct
-observed services. Local input reading is included in effective processing
-speed, rather than charged again as a separate disk or memory delay.
-
-Each output's remaining processing work subtracts progress only within its
-actual live run intervals. Initial video rates use existing codec/size/encoder
-calibration. Initial audio rates use short packaged per-codec measurements and
-sample work (encoding) or encoded bytes (copying). Actual output progress
-replaces these initial rates. That rate is the run's processing speed: film
-made over the run's own working time, with the time its input waited for the
-swarm and the time it was stopped taken out (`RunClock`, fed by the stream
-route, which marks each wait of a run's input read). The download is charged
-once, by the source service, and not a second time inside the processing rate. Startup is charged once, separately from processing
-throughput, and disappears once actual run progress establishes processing.
-
-Input arrival and processing overlap. With arrival time D(m), processing rate
-e and previous completion C, completion for an interval [a,b] is
-
-    max(C + (b-a)/e, sup_m(D(m) + (b-m)/e)).
-
-Between service boundaries these functions are linear, so only endpoints are
-needed. Client delivery follows production and shares the observed link queue.
-Measured client ranges and prepared media establish each track's deadlines.
-
-The minimum start delay for this conditional trajectory is
-
-    max(0, max_j(completion_j - presentation_deadline_j)).
-
-This covers the remaining finite movie, including rates below real time. Slow
-positive service gives a finite preproduction delay; it is not rejected by a
-browser-capacity threshold or a capped search. Observed supply-interruption
-coverage is held in prepared proxy media and client media, without requiring
-the browser to hold it all.
-
-Critical review: future rates can change, average byte density is an initial
-mapping rather than an exact packet index, initial audio sample-work scaling
-does not model every decoder's nonlinear cost, and client receive/append time
-is not separately measured. These are approximation limits, not hidden weights.
-Actual progress, segment sizes and link observations refine the prediction.
-The client countdown uses elapsed local monotonic time; expiration cannot
-authorize playback. Only the proxy's readiness and real track coverage can.
-
-Zero service, missing media facts and a genuine timestamp gap remain explicit
-noncomputable states. The UI reports their causes instead of an estimating
-placeholder or a fabricated duration.
-
-## Continuity is decided in exact time
-
-The forecast lives in the viewer component (`services/viewer/`), because what
-it predicts is how the viewer's browser will play; the request operation
-(`ViewerRequests`) is handed it by `wire-outputs.js`.
-
-1. **The file states integers.** A piece's media is read as presentation
-   intervals in the integer ticks of each track's timescale
-   (`readPresentationRanges`, `services/encode/segment-formats/mp4-boxes.js`).
-   Intervals are joined there only where they touch or overlap; the format
-   states what the samples say and nothing about browsers.
-2. **One function places a piece.** The position written into `tfdt` when a
-   piece is served and the position its coverage is read at both come from
-   `readTrackEdits`, which converts the movie-timescale edit into track ticks
-   with one stated rounding. The reader and the writer cannot disagree.
-3. **Seconds from the page are exact fractions.** A buffered range, a position
-   or a cut time arrives as a JavaScript number, which is a binary fraction;
-   `services/viewer/media-time.js` converts it to that fraction exactly. No unit
-   is chosen. A buffered range is widened by `REPORTED_TIME_ERROR`, the bound of
-   Chromium's three truncations to whole microseconds, so that it denotes every
-   exact time the report can stand for.
-4. **The join rule holds in every engine.** The Media Source specification
-   leaves the threshold to the implementation, so a gap counts as joined only
-   when Chromium, Gecko and WebKit all join it: twice the gap within the two
-   ranges' longest frames since a keyframe (Gecko's fuzz), and the gap within
-   2002/24000 s (WebKit's `timeFudgeFactor`). Chromium's own bound follows from
-   the first. Old iOS without Media Source plays HLS in a closed player, and
-   nothing is derived for it.
-
-Seconds appear again only for rates, schedules and the answer.
-
-## A piece is finished when its frames reach its cut
-
-A closed non-final fragment is reusable only if the end of its last frame, on
-every track, reaches its next declared cut less `SEGMENT_CUT_TIME_DELTA_SECONDS`,
-the delta the muxer is configured with. That is a fact of production, so no
-browser rule enters it, and the encoding decides it
-(`encode/piece-completeness.js`): `EncodeRuns` judges a closed file before it is
-published, and judges a stored piece left by an earlier process when the
-forecast asks for it, taking a short one off the disk. The segment store keeps
-the bytes and the media intervals read from them and judges nothing. Interrupted
-fragments are therefore never served or counted, so the production schedule
-treats their media as unfinished work. The final fragment uses its actual media
-end rather than the container's approximate duration.
+# Playback start forecast
+
+For resource r, measured service is S_r(t) = rate_r * t. New observations
+replace the conditional future rate; polling cannot invent acceleration,
+exponential recovery or a new physical measurement.
+
+Source work uses the file's measured byte density, missing local byte ranges
+and the observed torrent download rate. Shared input ranges are downloaded
+once. Files on the same torrent share a queue; distinct torrents use distinct
+observed services. Local input reading is included in effective processing
+speed, rather than charged again as a separate disk or memory delay.
+
+Each output's remaining processing work subtracts progress only within its
+actual live run intervals. Initial video rates use existing codec/size/encoder
+calibration. Initial audio rates use short packaged per-codec measurements and
+sample work (encoding) or encoded bytes (copying). Actual output progress
+replaces these initial rates. That rate is the run's processing speed: film
+made over the run's own working time, with the time its input waited for the
+swarm and the time it was stopped taken out (`RunClock`, fed by the stream
+route, which marks each wait of a run's input read). The download is charged
+once, by the source service, and not a second time inside the processing rate. Startup is charged once, separately from processing
+throughput, and disappears once actual run progress establishes processing.
+
+Input arrival and processing overlap. With arrival time D(m), processing rate
+e and previous completion C, completion for an interval [a,b] is
+
+    max(C + (b-a)/e, sup_m(D(m) + (b-m)/e)).
+
+Between service boundaries these functions are linear, so only endpoints are
+needed. Client delivery follows production and shares the observed link queue.
+Measured client ranges and prepared media establish each track's deadlines.
+
+The minimum start delay for this conditional trajectory is
+
+    max(0, max_j(completion_j - presentation_deadline_j)).
+
+This covers the remaining finite movie, including rates below real time. Slow
+positive service gives a finite preproduction delay; it is not rejected by a
+browser-capacity threshold or a capped search. Observed supply-interruption
+coverage is held in prepared proxy media and client media, without requiring
+the browser to hold it all.
+
+Critical review: future rates can change, average byte density is an initial
+mapping rather than an exact packet index, initial audio sample-work scaling
+does not model every decoder's nonlinear cost, and client receive/append time
+is not separately measured. These are approximation limits, not hidden weights.
+Actual progress, segment sizes and link observations refine the prediction.
+The client countdown uses elapsed local monotonic time; expiration cannot
+authorize playback. Only the proxy's readiness and real track coverage can.
+
+Zero service, missing media facts and a genuine timestamp gap remain explicit
+noncomputable states. The UI reports their causes instead of an estimating
+placeholder or a fabricated duration.
+
+## Continuity is decided in exact time
+
+The forecast lives in the viewer component (`services/viewer/`), because what
+it predicts is how the viewer's browser will play; the request operation
+(`ViewerRequests`) is handed it by `wire-outputs.js`.
+
+1. **The file states integers.** A piece's media is read as presentation
+   intervals in the integer ticks of each track's timescale
+   (`readPresentationRanges`, `services/encode/segment-formats/mp4-boxes.js`).
+   Intervals are joined there only where they touch or overlap; the format
+   states what the samples say and nothing about browsers.
+2. **One function places a piece.** The position written into `tfdt` when a
+   piece is served and the position its coverage is read at both come from
+   `readTrackEdits`, which converts the movie-timescale edit into track ticks
+   with one stated rounding. The reader and the writer cannot disagree.
+3. **Seconds from the page are exact fractions.** A buffered range, a position
+   or a cut time arrives as a JavaScript number, which is a binary fraction;
+   `services/viewer/media-time.js` converts it to that fraction exactly. No unit
+   is chosen. A buffered range is widened by `REPORTED_TIME_ERROR`, the bound of
+   Chromium's three truncations to whole microseconds, so that it denotes every
+   exact time the report can stand for.
+4. **The join rule holds in every engine.** The Media Source specification
+   leaves the threshold to the implementation, so a gap counts as joined only
+   when Chromium, Gecko and WebKit all join it: twice the gap within the two
+   ranges' longest frames since a keyframe (Gecko's fuzz), and the gap within
+   2002/24000 s (WebKit's `timeFudgeFactor`). Chromium's own bound follows from
+   the first. Old iOS without Media Source plays HLS in a closed player, and
+   nothing is derived for it.
+
+Seconds appear again only for rates, schedules and the answer.
+
+## A piece is finished when its frames reach its cut
+
+A closed non-final fragment is reusable only if the end of its last frame, on
+every track, reaches its muxer's cut less `SEGMENT_CUT_TIME_DELTA_SECONDS`,
+the delta the muxer is configured with. That is a fact of production, so no
+browser frame allowance is used to decide completeness. For explicit cuts the
+closure channel is CSV: its reference packet end has not lost the fraction of
+a movie tick that MP4's empty edit loses. The first reference packet's time is
+recovered from that end minus the first piece's exact sample span (the first
+CSV start is zero even after a seek), and is added to the relative cut times
+handed to FFmpeg. Comparisons use integer microseconds, as FFmpeg's segment
+muxer does. A stored piece without this closure reading carries the upper
+uncertainty of its empty edit, read from the movie and track timescales.
+
+The last frame must still reach the cut on every track. No playable media, a
+missing full frame, or a failed rename remains a publication failure. Such a
+failure stops the run, records that cause and releases its claimed interval;
+the existing repeated-start failure limit applies to subsequent attempts. A
+refused file cannot stay claimed while the encoder finishes the whole film.
+
+The encoding decides completeness
+(`encode/piece-completeness.js`): `EncodeRuns` judges a closed file before it is
+published, and judges a stored piece left by an earlier process when the
+forecast asks for it, taking a short one off the disk. The segment store keeps
+the bytes and the media intervals read from them and judges nothing. Interrupted
+fragments are therefore never served or counted, so the production schedule
+treats their media as unfinished work. The final fragment uses its actual media
+end rather than the container's approximate duration.

package/package.json

@@ -1,50 +1,51 @@
-{
-  "name": "@torrent-tv/proxy",
-  "version": "2.89.6",
-  "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
-  "license": "GPL-3.0-or-later",
-  "publishConfig": {
-    "access": "public"
-  },
-  "type": "module",
-  "engines": {
-    "node": ">=24"
-  },
-  "bin": {
-    "torrent-tv-proxy": "./bin/cli.js"
-  },
-  "scripts": {
-    "patch": "npm whoami && npm version patch && npm publish && git push --follow-tags",
-    "minor": "npm whoami && npm version minor && npm publish && git push --follow-tags",
-    "major": "npm whoami && npm version major && npm publish && git push --follow-tags",
-    "start": "node ./bin/cli.js",
-    "dev": "node --inspect=0 --experimental-network-inspection ./bin/cli.js",
-    "test": "npm run lint && node --test",
-    "graph": "node scripts/render-run-graph.js",
-    "lint": "biome lint ."
-  },
-  "dependencies": {
-    "@fastify/cors": "^11.2.0",
-    "@fastify/helmet": "^13.0.2",
-    "@fastify/static": "^10.1.2",
-    "@silentbot1/nat-api": "^0.4.9",
-    "chalk": "^5.4.1",
-    "commander": "^12.1.0",
-    "fastify": "^5.8.5",
-    "ffmpeg-static": "^5.3.0",
-    "franc": "^6.2.0",
-    "get-port": "^7.1.0",
-    "node-datachannel": "^0.32.0",
-    "parse-torrent": "^11.0.23",
-    "uint8-util": "2.2.6",
-    "webtorrent": "2.8.5",
-    "werift": "^0.24.2",
-    "ws": "^8.18.2"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "^2.5.7"
-  },
-  "overrides": {
-    "utp-native": "npm:@torrent-tv/utp-native@2.5.3-ttv.8"
-  }
-}
+{
+  "name": "@torrent-tv/proxy",
+  "version": "2.89.8",
+  "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
+  "license": "GPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/torrent-tv/proxy.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "torrent-tv-proxy": "bin/cli.js"
+  },
+  "scripts": {
+    "start": "node ./bin/cli.js",
+    "dev": "node --inspect=0 --experimental-network-inspection ./bin/cli.js",
+    "test": "npm run lint && node --test",
+    "graph": "node scripts/render-run-graph.js",
+    "lint": "biome lint ."
+  },
+  "dependencies": {
+    "@fastify/cors": "^11.2.0",
+    "@fastify/helmet": "^13.0.2",
+    "@fastify/static": "^10.1.2",
+    "@silentbot1/nat-api": "^0.4.9",
+    "chalk": "^5.4.1",
+    "commander": "^12.1.0",
+    "fastify": "^5.8.5",
+    "ffmpeg-static": "^5.3.0",
+    "franc": "^6.2.0",
+    "get-port": "^7.1.0",
+    "node-datachannel": "^0.32.0",
+    "parse-torrent": "^11.0.23",
+    "uint8-util": "2.2.6",
+    "webtorrent": "2.8.5",
+    "werift": "^0.24.2",
+    "ws": "^8.18.2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.7"
+  },
+  "overrides": {
+    "utp-native": "npm:@torrent-tv/utp-native@2.5.3-ttv.8"
+  }
+}

package/routes/api/sources/files/get.js

@@ -1,106 +1,106 @@
-import { contentsOf } from "../../../../services/torrent/Contents.js";
-
-/**
- * List the files of a registered source (torrent file OR magnet).
- *
- * GET /api/sources/:sourceKey/files
- *
- * The browser parses `.torrent` files locally, but a magnet URI carries no
- * file list — the metadata comes from the swarm and can take a while to
- * arrive on a cold magnet. Rather than block the request until it does (a
- * single long request racing the transport timeout, which surfaced as a
- * premature "no peers" error while the metadata was in fact still arriving),
- * this waits only a short per-request budget: if the metadata is not ready it
- * returns `{ pending: true }` while the fetch continues in the background. The
- * caller polls again until the file list comes back — mirroring the cold-
- * torrent playback-plan poll.
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{
- *   sourceRegistry: ReturnType<import("../../../../store/source-registry.js").createSourceRegistry>,
- *   torrentPool: import("../../../../services/torrent/torrent-pool.js").TorrentPool
- * }} deps
- * @returns {Promise<void>}
- */
-
-/** Sentinel resolved when the per-request wait elapses before metadata. */
-const PENDING = Symbol("pending");
-
-export async function handleApiSourceFilesGet(req, reply, { sourceRegistry, torrentPool }) {
-  const sourceKey = typeof req.params?.sourceKey === "string" ? req.params.sourceKey.trim() : "";
-  if (!sourceKey) {
-    return reply.code(400).send({ error: "sourceKey is required." });
-  }
-  const sourceRecord = sourceRegistry.get(sourceKey);
-  if (!sourceRecord) {
-    return reply.code(404).send({ error: "Source key was not found." });
-  }
-
-  // How long to wait within THIS request before returning `pending`. Well
-  // under the transport's request timeout so a single poll never races it.
-  const rawWait = Number(req.query?.maxWaitMs);
-  const maxWaitMs = Number.isFinite(rawWait) && rawWait > 0 ? Math.min(rawWait, 20_000) : 8_000;
-
-  // getTorrent dedupes concurrent/repeated calls via the pool's in-flight map,
-  // so polling keeps joining the same background fetch (metadata keeps
-  // downloading between polls). Race it against the wait budget; if the wait
-  // wins, the fetch is left running for the next poll to observe.
-  let timer;
-  const waitPromise = new Promise((resolve) => {
-    timer = setTimeout(() => resolve(PENDING), maxWaitMs);
-    timer.unref?.();
-  });
-  const torrentPromise = torrentPool
-    .getTorrent(sourceRecord.sourceType, sourceRecord.source)
-    // Swallow so a rejection that loses the race is not an unhandled rejection;
-    // the next poll re-issues getTorrent and re-observes any real error.
-    .catch((error) => (error instanceof Error ? error : new Error(String(error))));
-
-  let result;
-  try {
-    result = await Promise.race([torrentPromise, waitPromise]);
-  } finally {
-    clearTimeout(timer);
-  }
-
-  if (result === PENDING) {
-    return reply.send({ pending: true });
-  }
-  if (result instanceof Error) {
-    return reply.code(502).send({ error: `Could not load torrent metadata: ${result.message}` });
-  }
-
-  const torrent = result;
-  // WHAT IS IN THIS TORRENT, decided here and nowhere else. The browser used to
-  // decide it again — a list of video extensions in its parser and a second,
-  // shorter pair inside its picker — and the three answers had already diverged
-  // (measured 2026-09-12: `.dat` was offered there and not counted here, which
-  // also decides whether a sidecar whose name matches nothing can belong to the
-  // only video present). It ships the paths already relative to the torrent
-  // root, so there is no stripping rule on the other side either.
-  const contents = contentsOf(torrent);
-  return reply.send({
-    name: torrent.name ?? "",
-    infoHash: torrent.infoHash ?? "",
-    // In the order a person reads them — by folder, then by name, with runs of
-    // digits compared as numbers. A torrent's own order is whatever the tool
-    // that made it chose, and it is routinely by size.
-    files: contents.files(),
-    // The pictures, each with what belongs to it. By index, because the files
-    // themselves are in the list above and saying them twice is how two copies
-    // of one fact start.
-    items: contents.items.map((item) => ({
-      fileIndex: item.fileIndex,
-      audio: item.audio.map((part) => part.fileIndex),
-      subtitles: item.subtitles.map((part) => part.fileIndex),
-      images: item.images.map((part) => part.fileIndex),
-      // What the name says about which episode this is, in the release's own
-      // numbering — read by the page to ask which episode of the show it is.
-      episode: item.episode
-    })),
-    // One film, a series, or not known — whether one identification of the
-    // whole release applies to its pictures at all.
-    shape: contents.shape
-  });
-}
+import { contentsOf } from "../../../../services/torrent/Contents.js";
+
+/**
+ * List the files of a registered source (torrent file OR magnet).
+ *
+ * GET /api/sources/:sourceKey/files
+ *
+ * The browser parses `.torrent` files locally, but a magnet URI carries no
+ * file list — the metadata comes from the swarm and can take a while to
+ * arrive on a cold magnet. Rather than block the request until it does (a
+ * single long request racing the transport timeout, which surfaced as a
+ * premature "no peers" error while the metadata was in fact still arriving),
+ * this waits only a short per-request budget: if the metadata is not ready it
+ * returns `{ pending: true }` while the fetch continues in the background. The
+ * caller polls again until the file list comes back — mirroring the cold-
+ * torrent playback-plan poll.
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{
+ *   sourceRegistry: ReturnType<import("../../../../store/source-registry.js").createSourceRegistry>,
+ *   torrentPool: import("../../../../services/torrent/torrent-pool.js").TorrentPool
+ * }} deps
+ * @returns {Promise<void>}
+ */
+
+/** Sentinel resolved when the per-request wait elapses before metadata. */
+const PENDING = Symbol("pending");
+
+export async function handleApiSourceFilesGet(req, reply, { sourceRegistry, torrentPool }) {
+  const sourceKey = typeof req.params?.sourceKey === "string" ? req.params.sourceKey.trim() : "";
+  if (!sourceKey) {
+    return reply.code(400).send({ error: "sourceKey is required." });
+  }
+  const sourceRecord = sourceRegistry.get(sourceKey);
+  if (!sourceRecord) {
+    return reply.code(404).send({ error: "Source key was not found." });
+  }
+
+  // How long to wait within THIS request before returning `pending`. Well
+  // under the transport's request timeout so a single poll never races it.
+  const rawWait = Number(req.query?.maxWaitMs);
+  const maxWaitMs = Number.isFinite(rawWait) && rawWait > 0 ? Math.min(rawWait, 20_000) : 8_000;
+
+  // getTorrent dedupes concurrent/repeated calls via the pool's in-flight map,
+  // so polling keeps joining the same background fetch (metadata keeps
+  // downloading between polls). Race it against the wait budget; if the wait
+  // wins, the fetch is left running for the next poll to observe.
+  let timer;
+  const waitPromise = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(PENDING), maxWaitMs);
+    timer.unref?.();
+  });
+  const torrentPromise = torrentPool
+    .getTorrent(sourceRecord.sourceType, sourceRecord.source)
+    // Swallow so a rejection that loses the race is not an unhandled rejection;
+    // the next poll re-issues getTorrent and re-observes any real error.
+    .catch((error) => (error instanceof Error ? error : new Error(String(error))));
+
+  let result;
+  try {
+    result = await Promise.race([torrentPromise, waitPromise]);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (result === PENDING) {
+    return reply.send({ pending: true });
+  }
+  if (result instanceof Error) {
+    return reply.code(502).send({ error: `Could not load torrent metadata: ${result.message}` });
+  }
+
+  const torrent = result;
+  // WHAT IS IN THIS TORRENT, decided here and nowhere else. The browser used to
+  // decide it again — a list of video extensions in its parser and a second,
+  // shorter pair inside its picker — and the three answers had already diverged
+  // (measured 2026-09-12: `.dat` was offered there and not counted here, which
+  // also decides whether a sidecar whose name matches nothing can belong to the
+  // only video present). It ships the paths already relative to the torrent
+  // root, so there is no stripping rule on the other side either.
+  const contents = contentsOf(torrent);
+  return reply.send({
+    name: torrent.name ?? "",
+    infoHash: torrent.infoHash ?? "",
+    // In the order a person reads them — by folder, then by name, with runs of
+    // digits compared as numbers. A torrent's own order is whatever the tool
+    // that made it chose, and it is routinely by size.
+    files: contents.files(),
+    // The pictures, each with what belongs to it. By index, because the files
+    // themselves are in the list above and saying them twice is how two copies
+    // of one fact start.
+    items: contents.items.map((item) => ({
+      fileIndex: item.fileIndex,
+      audio: item.audio.map((part) => part.fileIndex),
+      subtitles: item.subtitles.map((part) => part.fileIndex),
+      images: item.images.map((part) => part.fileIndex),
+      // What the name says about which episode this is, in the release's own
+      // numbering — read by the page to ask which episode of the show it is.
+      episode: item.episode
+    })),
+    // One film, a series, or not known — whether one identification of the
+    // whole release applies to its pictures at all.
+    shape: contents.shape
+  });
+}

package/scripts/build-audio-samples.mjs

@@ -1,31 +1,31 @@
-/** Build-time only. No sample generation runs when the proxy starts. */
-import { spawnSync } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const directory = fileURLToPath(new URL("../assets/calibration/audio/", import.meta.url));
-const formats = [
-  ["aac", "aac", "m4a"], ["ac3", "ac3", "ac3"], ["eac3", "eac3", "eac3"],
-  ["dts", "dca", "dts"], ["flac", "flac", "flac"], ["opus", "libopus", "opus"],
-  ["vorbis", "libvorbis", "ogg"], ["truehd", "truehd", "thd"], ["mp3", "libmp3lame", "mp3"],
-  ["mp2", "mp2", "mp2"], ["alac", "alac", "m4a"], ["pcm", "pcm_s16le", "wav"]
-];
-mkdirSync(directory, { recursive: true });
-const manifest = [];
-for (const [codec, encoder, extension] of formats) {
-  const file = `${codec}.${extension}`;
-  const result = spawnSync("ffmpeg", ["-hide_banner", "-loglevel", "error", "-y",
-    "-f", "lavfi", "-i", "anoisesrc=color=pink:seed=1:sample_rate=48000",
-    "-t", "4", "-ac", "2", "-strict", "-2", "-c:a", encoder, path.join(directory, file)],
-  { encoding: "utf8", windowsHide: true });
-  if (result.status !== 0) throw new Error(`${codec}: ${result.stderr}`);
-  const probe = spawnSync("ffprobe", ["-v", "error", "-show_streams", "-show_format", "-of", "json",
-    path.join(directory, file)], { encoding: "utf8", windowsHide: true });
-  if (probe.status !== 0) throw new Error(`${codec}: ${probe.stderr}`);
-  const { streams, format } = JSON.parse(probe.stdout);
-  const stream = streams.find(({ codec_type }) => codec_type === "audio");
-  manifest.push({ codec, file, durationSeconds: Number(format.duration), channels: stream.channels,
-    samplingFrequency: Number(stream.sample_rate), bytes: Number(format.size) });
-}
-writeFileSync(path.join(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+/** Build-time only. No sample generation runs when the proxy starts. */
+import { spawnSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const directory = fileURLToPath(new URL("../assets/calibration/audio/", import.meta.url));
+const formats = [
+  ["aac", "aac", "m4a"], ["ac3", "ac3", "ac3"], ["eac3", "eac3", "eac3"],
+  ["dts", "dca", "dts"], ["flac", "flac", "flac"], ["opus", "libopus", "opus"],
+  ["vorbis", "libvorbis", "ogg"], ["truehd", "truehd", "thd"], ["mp3", "libmp3lame", "mp3"],
+  ["mp2", "mp2", "mp2"], ["alac", "alac", "m4a"], ["pcm", "pcm_s16le", "wav"]
+];
+mkdirSync(directory, { recursive: true });
+const manifest = [];
+for (const [codec, encoder, extension] of formats) {
+  const file = `${codec}.${extension}`;
+  const result = spawnSync("ffmpeg", ["-hide_banner", "-loglevel", "error", "-y",
+    "-f", "lavfi", "-i", "anoisesrc=color=pink:seed=1:sample_rate=48000",
+    "-t", "4", "-ac", "2", "-strict", "-2", "-c:a", encoder, path.join(directory, file)],
+  { encoding: "utf8", windowsHide: true });
+  if (result.status !== 0) throw new Error(`${codec}: ${result.stderr}`);
+  const probe = spawnSync("ffprobe", ["-v", "error", "-show_streams", "-show_format", "-of", "json",
+    path.join(directory, file)], { encoding: "utf8", windowsHide: true });
+  if (probe.status !== 0) throw new Error(`${codec}: ${probe.stderr}`);
+  const { streams, format } = JSON.parse(probe.stdout);
+  const stream = streams.find(({ codec_type }) => codec_type === "audio");
+  manifest.push({ codec, file, durationSeconds: Number(format.duration), channels: stream.channels,
+    samplingFrequency: Number(stream.sample_rate), bytes: Number(format.size) });
+}
+writeFileSync(path.join(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);