@torrent-tv/proxy 2.86.0 → 2.87.0

package/test/available-share.test.js

@@ -9,7 +9,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { availableShareFrom, correctForAvailability } from "../services/available-share.js";
+import { availableShareFrom, correctForAvailability } from "../services/encode/available-share.js";
 
 test("only the work nobody has been charged for is subtracted", () => {
   // The field reading: the box is saturated, our encoder has more than half of

package/test/background-fill.test.js

@@ -11,7 +11,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { EventEmitter } from "node:events";
-import { fillFileInBackground, fillIsRunning } from "../services/torrent-worker/background-fill.js";
+import { fillFileInBackground, fillIsRunning } from "../services/torrent/worker/background-fill.js";
 
 /**
  * A file whose reads resolve when the test says so, recording what was asked

package/test/client-log-file.test.js

@@ -1,110 +1,110 @@
-/**
- * @file The browser's log, written beside the proxy's.
- *
- * What these hold is the naming, because the name is the whole point: the two
- * halves of a session have to join without guessing, and a torrent name is
- * arbitrary bytes chosen by a stranger that is about to become a path.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, readdirSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { createClientLogFiles } from "../utils/client-log-file.js";
-
-/** A directory with a proxy log in it, which is what the sink is given. */
-function aDirectory() {
-  const dir = mkdtempSync(join(tmpdir(), "ttv-client-log-"));
-  return { dir, proxyLog: join(dir, "proxy.log") };
-}
-
-const aSession = (over = {}) => ({
-  sessionId: "abcd1234",
-  startedAt: "2026-09-13T16:05:24.123Z",
-  torrentName: "Reacher.S04E07.1080p.rus.LostFilm.TV.mkv",
-  infoHash: "94dda59fdf252447d6ca5a8775dab2d11a832da5",
-  ...over
-});
-
-test("the file lands beside the proxy log, named by when it started and what is watched", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession(), ["first line"]);
-  await logs.close();
-
-  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.ok(name, "a client log file was written");
-  // The stamp is UTC and sorts; the session id joins it to the proxy's lines;
-  // the film says which one it is without opening the file.
-  assert.match(name, /^client-20260913-160524-abcd1234-Reacher\.S04E07\.1080p\.rus\.LostFilm\.TV\.mkv-94dda59f\.log$/);
-  assert.equal(readFileSync(join(dir, name), "utf8"), "first line\n");
-});
-
-test("lines from one session go on appending to the one file", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession(), ["one", "two"]);
-  logs.write(aSession(), ["three"]);
-  await logs.close();
-
-  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.equal(names.length, 1);
-  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "one\ntwo\nthree\n");
-});
-
-test("a session that has not chosen a film yet still gets its own file", async () => {
-  // The page opening, a proxy being chosen, a connection failing — all before
-  // any torrent exists, and all worth keeping.
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before any film"]);
-  await logs.close();
-
-  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.match(name, /-no-torrent-yet\.log$/);
-});
-
-test("the file keeps its name when the film arrives mid-session", async () => {
-  // Keyed by the session, not by the name: the earlier lines belong to the same
-  // viewing and must not start a second file.
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before"]);
-  logs.write(aSession(), ["after"]);
-  await logs.close();
-
-  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.equal(names.length, 1);
-  assert.match(names[0], /-no-torrent-yet\.log$/);
-  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "before\nafter\n");
-});
-
-test("a hostile torrent name cannot escape the directory", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ torrentName: "../../etc/passwd" }), ["x"]);
-  await logs.close();
-
-  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.equal(names.length, 1);
-  assert.ok(!names[0].includes(".."), `no traversal in ${names[0]}`);
-  assert.ok(!names[0].includes("/"), `no separator in ${names[0]}`);
-});
-
-test("two sessions of one film are two files", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ sessionId: "aaaa1111" }), ["one viewer"]);
-  logs.write(aSession({ sessionId: "bbbb2222", startedAt: "2026-09-13T16:07:11.000Z" }), ["another"]);
-  await logs.close();
-
-  assert.equal(readdirSync(dir).filter((f) => f.startsWith("client-")).length, 2);
-});
-
-test("no proxy log path means nothing is written and nothing throws", async () => {
-  const logs = createClientLogFiles("");
-  logs.write(aSession(), ["dropped"]);
-  await logs.close();
-});
+/**
+ * @file The browser's log, written beside the proxy's.
+ *
+ * What these hold is the naming, because the name is the whole point: the two
+ * halves of a session have to join without guessing, and a torrent name is
+ * arbitrary bytes chosen by a stranger that is about to become a path.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readdirSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createClientLogFiles } from "../utils/client-log-file.js";
+
+/** A directory with a proxy log in it, which is what the sink is given. */
+function aDirectory() {
+  const dir = mkdtempSync(join(tmpdir(), "ttv-client-log-"));
+  return { dir, proxyLog: join(dir, "proxy.log") };
+}
+
+const aSession = (over = {}) => ({
+  sessionId: "abcd1234",
+  startedAt: "2026-09-13T16:05:24.123Z",
+  torrentName: "Reacher.S04E07.1080p.rus.LostFilm.TV.mkv",
+  infoHash: "94dda59fdf252447d6ca5a8775dab2d11a832da5",
+  ...over
+});
+
+test("the file lands beside the proxy log, named by when it started and what is watched", async () => {
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession(), ["first line"]);
+  await logs.close();
+
+  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.ok(name, "a client log file was written");
+  // The stamp is UTC and sorts; the session id joins it to the proxy's lines;
+  // the film says which one it is without opening the file.
+  assert.match(name, /^client-20260913-160524-abcd1234-Reacher\.S04E07\.1080p\.rus\.LostFilm\.TV\.mkv-94dda59f\.log$/);
+  assert.equal(readFileSync(join(dir, name), "utf8"), "first line\n");
+});
+
+test("lines from one session go on appending to the one file", async () => {
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession(), ["one", "two"]);
+  logs.write(aSession(), ["three"]);
+  await logs.close();
+
+  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.equal(names.length, 1);
+  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "one\ntwo\nthree\n");
+});
+
+test("a session that has not chosen a film yet still gets its own file", async () => {
+  // The page opening, a proxy being chosen, a connection failing — all before
+  // any torrent exists, and all worth keeping.
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before any film"]);
+  await logs.close();
+
+  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.match(name, /-no-torrent-yet\.log$/);
+});
+
+test("the file keeps its name when the film arrives mid-session", async () => {
+  // Keyed by the session, not by the name: the earlier lines belong to the same
+  // viewing and must not start a second file.
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before"]);
+  logs.write(aSession(), ["after"]);
+  await logs.close();
+
+  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.equal(names.length, 1);
+  assert.match(names[0], /-no-torrent-yet\.log$/);
+  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "before\nafter\n");
+});
+
+test("a hostile torrent name cannot escape the directory", async () => {
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession({ torrentName: "../../etc/passwd" }), ["x"]);
+  await logs.close();
+
+  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.equal(names.length, 1);
+  assert.ok(!names[0].includes(".."), `no traversal in ${names[0]}`);
+  assert.ok(!names[0].includes("/"), `no separator in ${names[0]}`);
+});
+
+test("two sessions of one film are two files", async () => {
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession({ sessionId: "aaaa1111" }), ["one viewer"]);
+  logs.write(aSession({ sessionId: "bbbb2222", startedAt: "2026-09-13T16:07:11.000Z" }), ["another"]);
+  await logs.close();
+
+  assert.equal(readdirSync(dir).filter((f) => f.startsWith("client-")).length, 2);
+});
+
+test("no proxy log path means nothing is written and nothing throws", async () => {
+  const logs = createClientLogFiles("");
+  logs.write(aSession(), ["dropped"]);
+  await logs.close();
+});

package/test/completed-files.test.js

@@ -13,7 +13,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { Readable } from "node:stream";
-import { CompletedFiles } from "../services/files/CompletedFiles.js";
+import { CompletedFiles } from "../services/storage/files/CompletedFiles.js";
 
 const INFO_HASH = "abcdef0123456789abcdef0123456789abcdef01";
 

package/test/concurrent-cost.test.js

@@ -11,7 +11,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { canSustainOutput } from "../services/hwaccel.js";
+import { canSustainOutput } from "../services/encode/hwaccel.js";
 
 // A host that encodes 640x360 at 24 fps about eleven times over, and decodes
 // 1080p24 at 2.6x — the addon host's own figures.
@@ -59,9 +59,9 @@ test("nothing else running leaves the answer exactly as it was", () => {
   assert.equal(withZero.speed, without.speed);
 });
 
-test("a host with nothing measured still refuses nothing", () => {
+test("a wiring made without the startup calibration judges nothing", () => {
   const answer = canSustainOutput({
-    benchmark: [],
+    benchmark: null,
     outputPixelsPerSec: RUNG_240P,
     concurrentCostSec: 0.125
   });
@@ -69,6 +69,16 @@ test("a host with nothing measured still refuses nothing", () => {
   assert.equal(answer.speed, null);
 });
 
+test("a host calibrated with no mode qualified refuses a re-encode (roadmap item 97, step 14)", () => {
+  const answer = canSustainOutput({
+    benchmark: [],
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0.125
+  });
+  assert.equal(answer.sustainable, false, "unknown capacity is not capacity");
+  assert.equal(answer.speed, null);
+});
+
 test("a cost heavy enough to fill the machine puts a rung below realtime", () => {
   const answer = canSustainOutput({
     benchmark: BENCHMARK,

package/test/container-media-info.test.js

@@ -17,9 +17,9 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { MatroskaContainer } from "../services/container/MatroskaContainer.js";
-import { Mp4Container } from "../services/container/Mp4Container.js";
-import { AviContainer } from "../services/container/AviContainer.js";
+import { MatroskaContainer } from "../services/media/container/MatroskaContainer.js";
+import { Mp4Container } from "../services/media/container/Mp4Container.js";
+import { AviContainer } from "../services/media/container/AviContainer.js";
 
 /**
  * An EBML element: its id bytes, a four-byte size, then the payload.

package/test/core-dumps.test.js

@@ -9,7 +9,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { dumpsToRemove, isCoreDump } from "../services/core-dumps.js";
+import { dumpsToRemove, isCoreDump } from "../services/storage/core-dumps.js";
 
 const dumps = [
   { name: "core.WorkerThread.81.1787176646", writtenAt: 1787176646000 },

package/test/coverage-follows-the-disk.test.js

@@ -29,10 +29,10 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { EncodeRun } from "../services/encode/EncodeRun.js";
-import { SegmentStore } from "../services/encode/SegmentStore.js";
+import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
 import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-import { EncodeOrchestrator } from "../services/orchestrators/EncodeOrchestrator.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { EncodeOrchestrator } from "../services/encode/EncodeOrchestrator.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 
 const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
 const SEGMENTS = 482;
@@ -114,7 +114,15 @@ function theWholeFilmIsOnDisk(store, dir) {
 
 test("a film that is entirely made needs no encoder", (t) => {
   const { made, store, dir, root } = orchestratorWithAStore();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // THE STORE LETS ITS DIRECTORIES GO, and only then is the root removed. It
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch on it cannot be removed on Windows: `rmSync` retries until it
+    // gives up, and the check reads as a hang.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   theWholeFilmIsOnDisk(store, dir);
   aViewerAtTheStart(made);
@@ -128,7 +136,15 @@ test("a film that is entirely made needs no encoder", (t) => {
 
 test("segments the store has lost stop being ready, and an encoder is placed again", (t) => {
   const { made, store, dir, root } = orchestratorWithAStore();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // THE STORE LETS ITS DIRECTORIES GO, and only then is the root removed. It
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch on it cannot be removed on Windows: `rmSync` retries until it
+    // gives up, and the check reads as a hang.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   theWholeFilmIsOnDisk(store, dir);
   aViewerAtTheStart(made);
@@ -151,7 +167,15 @@ test("segments the store has lost stop being ready, and an encoder is placed aga
 
 test("a piece discarded with the run that had it open is not ready either", (t) => {
   const { made, store, dir, root } = orchestratorWithAStore();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // THE STORE LETS ITS DIRECTORIES GO, and only then is the root removed. It
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch on it cannot be removed on Windows: `rmSync` retries until it
+    // gives up, and the check reads as a hang.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   theWholeFilmIsOnDisk(store, dir);
   aViewerAtTheStart(made);
@@ -169,8 +193,16 @@ test("a piece discarded with the run that had it open is not ready either", (t)
 });
 
 test("nobody making what somebody waits for is said out loud", (t) => {
-  const { made, root, lines } = orchestratorWithAStore();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  const { made, store, root, lines } = orchestratorWithAStore();
+  t.after(() => {
+    // THE STORE LETS ITS DIRECTORIES GO, and only then is the root removed. It
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch on it cannot be removed on Windows: `rmSync` retries until it
+    // gives up, and the check reads as a hang.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   // A HOST THAT CANNOT BUILD AN ENCODER. Whatever the reason — and there are
   // several — the state it leaves is the one that cost two sessions on

package/test/cue-push-carries-what-the-walk-found.test.js

@@ -0,0 +1,58 @@
+/**
+ * @file What the subtitle walk found reaches the viewer whole.
+ *
+ * It did not. The walk has produced `detectedLanguage` on every push since
+ * 2.69.0 — the language read from the CUES rather than from a container that
+ * often states none — and the whole of the "label moves when the answer
+ * arrives" behaviour rests on it. It never arrived: the fact was copied by hand
+ * twice on its way out, and each copy listed the fields it knew about. The
+ * worker posted `trackIndex, cues, language, cursor`; the main thread's client
+ * rebuilt the same four from the message. `detectedLanguage` was in neither
+ * list, so the browser was told nothing and the label it shows for an untagged
+ * track has never moved.
+ *
+ * It is not a typo to fix in two places — it is the shape. A fact copied field
+ * by field loses whatever the copier did not know about, and says nothing when
+ * it does. The walk's own result travels now, so a field added to it arrives
+ * without anybody being told to forward it.
+ *
+ * (Both copies are gone anyway: the walk runs on the thread that pushes.)
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+/**
+ * @param {string} relative
+ * @returns {string}
+ */
+function source(relative) {
+  return readFileSync(path.join(ROOT, relative), "utf8");
+}
+
+test("the walk states the language it read from the cues", () => {
+  // The producer. Without this the rest of the check is about nothing.
+  assert.match(source("services/media/SubtitleCues.js"), /detectedLanguage: detectLanguage\(/);
+});
+
+test("the consumer asks for it", () => {
+  // The other end has always destructured it, which is what made the loss
+  // silent: a field nobody forwards is `undefined` and reads as "not detected".
+  assert.match(
+    source("services/transport/data-channel-handler.js"),
+    /function publishSubtitleCues\(\{[^}]*detectedLanguage[^}]*\}\)/
+  );
+});
+
+test("the push forwards the whole of what the walk found, rather than a list of fields", () => {
+  // The one line that closes it. A list of names here is how the fact was lost
+  // twice, and a list cannot say that it is incomplete.
+  const wiring = source("server.js");
+
+  assert.match(wiring, /onSubtitleCues\?\.\(\{ sourceKey, fileIndex, \.\.\.entry \}\)/);
+});

package/test/cut-times-timeline.test.js

@@ -13,10 +13,10 @@
  */
 
 import assert from "node:assert/strict";
-import { Timeline } from "../services/output/Timeline.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
 import test from "node:test";
 
-import { onKeyframeGridFor } from "../services/hls-session-manager.js";
+import { onKeyframeGridFor } from "../services/encode/run-command.js";
 
 test("a copied picture works on the source's timeline", () => {
   assert.equal(

package/test/cuts-follow-published-grid.test.js

@@ -15,11 +15,12 @@
  */
 
 import assert from "node:assert/strict";
-import { computeCutGrid } from "../services/output/cut-grid.js";
-import { Timeline } from "../services/output/Timeline.js";
+import { computeCutGrid } from "../services/encode/output/cut-grid.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
 import test from "node:test";
 
-import { HlsSessionManager, segmentCutTimesFrom } from "../services/hls-session-manager.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { segmentCutTimesFrom } from "../services/encode/run-command.js";
 
 /** What the playlist in the player's hands says. */
 const PUBLISHED = [0, 4.004, 8.008, 12.012, 16.016, 20.02];
@@ -29,10 +30,10 @@ const CORRECTED = [0, 4.004, 6.006, 12.012, 14.014, 20.02];
 /**
  * A session that has published one grid and since corrected another.
  *
- * @returns {{ manager: HlsSessionManager, session: object }}
+ * @returns {{ manager: object, session: object }}
  */
 function sessionWithDriftedGrid() {
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -47,7 +48,7 @@ function sessionWithDriftedGrid() {
 
 test("the cut list is the one the playlist was written from", () => {
   const { manager, session } = sessionWithDriftedGrid();
-  const grid = manager.publishedGridFor(session);
+  const grid = manager.outputTimes.publishedGridFor(session);
   assert.deepEqual(grid, PUBLISHED);
   // Interior cuts of a run starting at #1, rebased on the run's own start
   // (4.004 s), and stopping before the last entry, which is the file's end.
@@ -60,7 +61,7 @@ test("the cut list is the one the playlist was written from", () => {
 test("a corrected grid does not move the cuts of a session already being read", () => {
   const { manager, session } = sessionWithDriftedGrid();
   const fromCorrected = segmentCutTimesFrom(session.timeline.boundaries, 1);
-  const fromPublished = segmentCutTimesFrom(manager.publishedGridFor(session), 1);
+  const fromPublished = segmentCutTimesFrom(manager.outputTimes.publishedGridFor(session), 1);
   assert.notDeepEqual(fromCorrected, fromPublished);
   // The gap the field measured: the corrected table would have cut #2 two
   // seconds early, which is four times what a player bridges.
@@ -70,7 +71,7 @@ test("a corrected grid does not move the cuts of a session already being read",
 test("a session that published no grid falls back to the live one", () => {
   const { manager } = sessionWithDriftedGrid();
   const session = { id: "no-playlist", timeline: new Timeline({ boundaries: [...CORRECTED], published: [], cutGrid: "uniform" }) };
-  assert.deepEqual(manager.publishedGridFor(session), CORRECTED);
+  assert.deepEqual(manager.outputTimes.publishedGridFor(session), CORRECTED);
 });
 
 test("no segment is left shorter than a segment at the end of the film", () => {

package/test/data-channel-frame.test.js

@@ -10,7 +10,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { encodeFrame } from "../services/data-channel-handler.js";
+import { encodeFrame } from "../services/transport/data-channel-handler.js";
 
 const requestId = Buffer.from("abc123", "ascii");
 

package/test/dead-torrent-handle.test.js

@@ -19,7 +19,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { isUsableTorrentHandle } from "../services/torrent-worker/handle-state.js";
+import { isUsableTorrentHandle } from "../services/torrent/worker/handle-state.js";
 
 test("a live torrent is usable", () => {
   assert.equal(isUsableTorrentHandle({ destroyed: false, files: [{ name: "a.mkv" }] }), true);

package/test/declared-rates.test.js

@@ -10,8 +10,8 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { declaredRates } from "../services/output/rates.js";
-import { bitrateFor } from "../services/output/playlists.js";
+import { declaredRates } from "../services/encode/output/rates.js";
+import { bitrateFor } from "../services/encode/output/playlists.js";
 
 // The field file: 2 806 246 976 bytes over 20:18, cut into 291 pieces.
 const FIELD = { fileLength: 2_806_246_976, durationSeconds: 1218.73 };

package/test/declared-tracks.test.js

@@ -16,8 +16,8 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 
-const planner = readFileSync(new URL("../services/playback-planner.js", import.meta.url), "utf8");
-const sessions = readFileSync(new URL("../services/hls-session-manager.js", import.meta.url), "utf8");
+const planner = readFileSync(new URL("../services/media/playback-planner.js", import.meta.url), "utf8");
+const sessions = readFileSync(new URL("../services/encode/Renditions.js", import.meta.url), "utf8");
 
 test("every field the declaration reads is a field the cache stores", () => {
   // What `declaredTracks` reads off the cached media info.

package/test/decode-cost-fit.test.js

@@ -11,7 +11,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { decodeCostOf, fitDecodeCost } from "../services/decode-cost-fit.js";
+import { decodeCostOf, fitDecodeCost } from "../services/encode/decode-cost-fit.js";
 
 const FPS = 24;