@torrent-tv/proxy 2.80.19 → 2.81.0

package/test/video-facts.test.js

@@ -1,102 +1,102 @@
-/**
- * @file The picture's facts, from the two readings that state them.
- *
- * Audio and subtitles have had this reconciliation since their flags were first
- * read from the file. Video never did: every figure the encode is planned from
- * came from ffmpeg's `-i` banner alone, and the `VideoTrack` the container
- * declares was read and then used for nothing but a line in the log — so a file
- * that states its bit depth or its HDR signalling, against a probe that does
- * not print them, disagreed with nobody watching.
- *
- * What each check pins is WHICH reading answers, and why: the size and the
- * frame rate are what the decoder will produce, so the probe answers; the bit
- * depth and the HDR signalling are the file saying how its samples are to be
- * read, so the container answers.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { Container } from "../services/container/Container.js";
-
-const banner = (fields) => ({ width: null, height: null, fps: null, isHdr: false, bitDepth: null, ...fields });
-
-test("with no container reading the probe answers for everything", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1920, height: 1080, fps: 23.976, isHdr: true, bitDepth: 10 }),
-    null
-  );
-  assert.equal(facts.width, 1920);
-  assert.equal(facts.height, 1080);
-  assert.equal(facts.fps, 23.976);
-  assert.equal(facts.isHdr, true);
-  assert.equal(facts.bitDepth, 10);
-  assert.deepEqual(facts.disagreements, []);
-});
-
-test("the size and the frame rate are the probe's, because that is what will be decoded", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1920, height: 1080, fps: 24 }),
-    { width: 1440, height: 1080, fps: 25, displayWidth: 1920, displayHeight: 1080 }
-  );
-  assert.equal(facts.width, 1920, "the ladder and the scale filter are sized to the decoded frame");
-  assert.equal(facts.height, 1080);
-  assert.equal(facts.fps, 24);
-});
-
-test("the bit depth and the HDR signalling are the file's, because the file states them", () => {
-  // A ten-bit HEVC whose probe printed neither: this is the case that decides
-  // whether tone mapping runs and how the decode cost is priced.
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 3840, height: 2160, fps: 24 }),
-    { width: 3840, height: 2160, bitDepth: 10, isHdr: true }
-  );
-  assert.equal(facts.bitDepth, 10);
-  assert.equal(facts.isHdr, true);
-  assert.deepEqual(facts.disagreements, [], "one side saying nothing is not a disagreement");
-});
-
-test("a field only the probe states is still answered", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1280, height: 720, fps: 30, bitDepth: 8 }),
-    { width: null, height: null, fps: null, bitDepth: null }
-  );
-  assert.equal(facts.width, 1280);
-  assert.equal(facts.bitDepth, 8);
-});
-
-test("a real disagreement is reported, with both values and which is which", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1920, height: 1080, bitDepth: 8, isHdr: false }),
-    { width: 1280, height: 720, bitDepth: 10, isHdr: true }
-  );
-  assert.equal(facts.disagreements.length, 3);
-  assert.ok(facts.disagreements.some((line) => /width 1280 in the container against 1920 in the probe/.test(line)));
-  assert.ok(facts.disagreements.some((line) => /bit depth 10 in the container against 8 in the probe/.test(line)));
-  // HDR is not among them, and cannot be: see `mergeVideoFacts`.
-  assert.ok(!facts.disagreements.some((line) => /HDR/.test(line)));
-  // And the rule still decides: the probe for the size, the file for the rest.
-  assert.equal(facts.width, 1920);
-  assert.equal(facts.bitDepth, 10);
-  assert.equal(facts.isHdr, true);
-});
-
-test("the display size is the container's alone — the probe has no such field", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1440, height: 1080 }),
-    { width: 1440, height: 1080, displayWidth: 1920, displayHeight: 1080 }
-  );
-  assert.equal(facts.displayWidth, 1920);
-  assert.equal(facts.displayHeight, 1080);
-});
-
-test("zero and nonsense are not values", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 0, height: 0, fps: 0, bitDepth: 0 }),
-    { width: 1920, height: 1080, fps: 24, bitDepth: 8 }
-  );
-  assert.equal(facts.width, 1920, "a probe that printed nothing does not outrank a file that speaks");
-  assert.equal(facts.fps, 24);
-  assert.equal(facts.bitDepth, 8);
-  assert.deepEqual(facts.disagreements, []);
-});
+/**
+ * @file The picture's facts, from the two readings that state them.
+ *
+ * Audio and subtitles have had this reconciliation since their flags were first
+ * read from the file. Video never did: every figure the encode is planned from
+ * came from ffmpeg's `-i` banner alone, and the `VideoTrack` the container
+ * declares was read and then used for nothing but a line in the log — so a file
+ * that states its bit depth or its HDR signalling, against a probe that does
+ * not print them, disagreed with nobody watching.
+ *
+ * What each check pins is WHICH reading answers, and why: the size and the
+ * frame rate are what the decoder will produce, so the probe answers; the bit
+ * depth and the HDR signalling are the file saying how its samples are to be
+ * read, so the container answers.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { Container } from "../services/container/Container.js";
+
+const banner = (fields) => ({ width: null, height: null, fps: null, isHdr: false, bitDepth: null, ...fields });
+
+test("with no container reading the probe answers for everything", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1920, height: 1080, fps: 23.976, isHdr: true, bitDepth: 10 }),
+    null
+  );
+  assert.equal(facts.width, 1920);
+  assert.equal(facts.height, 1080);
+  assert.equal(facts.fps, 23.976);
+  assert.equal(facts.isHdr, true);
+  assert.equal(facts.bitDepth, 10);
+  assert.deepEqual(facts.disagreements, []);
+});
+
+test("the size and the frame rate are the probe's, because that is what will be decoded", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1920, height: 1080, fps: 24 }),
+    { width: 1440, height: 1080, fps: 25, displayWidth: 1920, displayHeight: 1080 }
+  );
+  assert.equal(facts.width, 1920, "the ladder and the scale filter are sized to the decoded frame");
+  assert.equal(facts.height, 1080);
+  assert.equal(facts.fps, 24);
+});
+
+test("the bit depth and the HDR signalling are the file's, because the file states them", () => {
+  // A ten-bit HEVC whose probe printed neither: this is the case that decides
+  // whether tone mapping runs and how the decode cost is priced.
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 3840, height: 2160, fps: 24 }),
+    { width: 3840, height: 2160, bitDepth: 10, isHdr: true }
+  );
+  assert.equal(facts.bitDepth, 10);
+  assert.equal(facts.isHdr, true);
+  assert.deepEqual(facts.disagreements, [], "one side saying nothing is not a disagreement");
+});
+
+test("a field only the probe states is still answered", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1280, height: 720, fps: 30, bitDepth: 8 }),
+    { width: null, height: null, fps: null, bitDepth: null }
+  );
+  assert.equal(facts.width, 1280);
+  assert.equal(facts.bitDepth, 8);
+});
+
+test("a real disagreement is reported, with both values and which is which", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1920, height: 1080, bitDepth: 8, isHdr: false }),
+    { width: 1280, height: 720, bitDepth: 10, isHdr: true }
+  );
+  assert.equal(facts.disagreements.length, 3);
+  assert.ok(facts.disagreements.some((line) => /width 1280 in the container against 1920 in the probe/.test(line)));
+  assert.ok(facts.disagreements.some((line) => /bit depth 10 in the container against 8 in the probe/.test(line)));
+  // HDR is not among them, and cannot be: see `mergeVideoFacts`.
+  assert.ok(!facts.disagreements.some((line) => /HDR/.test(line)));
+  // And the rule still decides: the probe for the size, the file for the rest.
+  assert.equal(facts.width, 1920);
+  assert.equal(facts.bitDepth, 10);
+  assert.equal(facts.isHdr, true);
+});
+
+test("the display size is the container's alone — the probe has no such field", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1440, height: 1080 }),
+    { width: 1440, height: 1080, displayWidth: 1920, displayHeight: 1080 }
+  );
+  assert.equal(facts.displayWidth, 1920);
+  assert.equal(facts.displayHeight, 1080);
+});
+
+test("zero and nonsense are not values", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 0, height: 0, fps: 0, bitDepth: 0 }),
+    { width: 1920, height: 1080, fps: 24, bitDepth: 8 }
+  );
+  assert.equal(facts.width, 1920, "a probe that printed nothing does not outrank a file that speaks");
+  assert.equal(facts.fps, 24);
+  assert.equal(facts.bitDepth, 8);
+  assert.deepEqual(facts.disagreements, []);
+});

package/test/wedge-certainty.test.js

@@ -1,131 +1,131 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { wedgeIsCertain } from "../services/data-channel-handler.js";
-import { PROBE_INTERVAL_MS } from "../services/delivery-probe.js";
-
-const MEGABYTE = 1024 * 1024;
-
-test("a queue draining at the rate this link was measured at is not a wedge", () => {
-  // 8 MB at 16 MB/s is half a second of draining. Half a second in is normal.
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: 200
-  });
-  assert.equal(verdict.certain, false);
-});
-
-test("the counter standing still past the queue's own drain time is a wedge", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: 4000
-  });
-  assert.equal(verdict.certain, true);
-  assert.equal(verdict.needMs, 500);
-});
-
-test("a big queue on a slow link is given the time it genuinely needs", () => {
-  // 67 MB at 1 MB/s is 67 seconds of honest draining — the field's own numbers
-  // for the wedged channel, at a rate a thin link could really be running at.
-  const patient = wedgeIsCertain({
-    queuedBytes: 67 * MEGABYTE,
-    bytesPerSecond: MEGABYTE,
-    flatForMs: 30_000
-  });
-  assert.equal(patient.certain, false);
-  const later = wedgeIsCertain({
-    queuedBytes: 67 * MEGABYTE,
-    bytesPerSecond: MEGABYTE,
-    flatForMs: 70_000
-  });
-  assert.equal(later.certain, true);
-});
-
-test("the same queue on the link the field actually had is called quickly", () => {
-  // 67 MB at 18 MB/s is under four seconds. The field episode stood still for
-  // 3217 s; the previous rule waited a flat 30 s before recording anything.
-  const verdict = wedgeIsCertain({
-    queuedBytes: 67 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 5000
-  });
-  assert.equal(verdict.certain, true);
-  assert.ok(verdict.needMs < 30_000);
-});
-
-test("a tiny queue still waits for one round of probes", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 512,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: PROBE_INTERVAL_MS - 1
-  });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
-});
-
-test("nothing queued is still a wedge when the counter has been flat long enough — the channel queue was 0 on the real wedge while usrsctp held 399 MB", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 0,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: 600_000
-  });
-  assert.equal(verdict.certain, true);
-  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
-});
-
-test("with no rate measured the answer is that nothing can be said", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 0,
-    flatForMs: 600_000
-  });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, null);
-});
-
-test("a pause no longer than this link's own longest healthy pause is not a wedge", () => {
-  // A retransmission timeout stops the accepted-byte counter dead: a full send
-  // buffer accepts nothing. If this connection has already paused 3 s while
-  // healthy, a 3 s pause says nothing.
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 2500,
-    longestHealthyFlatMs: 3000
-  });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, 3000);
-});
-
-test("a pause longer than any this link has shown is a wedge", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 3500,
-    longestHealthyFlatMs: 3000
-  });
-  assert.equal(verdict.certain, true);
-});
-
-test("the quiet-probe rate cannot be what the queue is divided by", () => {
-  // With the browser's buffer full, the only traffic is the probe: three
-  // channels, a few dozen bytes, twice a second. Dividing 8 MB by that gives
-  // six hours, and the wedge would never be called. The BEST rate seen is what
-  // the watcher keeps, so this case must not arise — pinned here as the
-  // arithmetic that made it matter.
-  const wrong = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 360,
-    flatForMs: 60_000
-  });
-  assert.equal(wrong.certain, false);
-  assert.ok(wrong.needMs > 6 * 60 * 60 * 1000 - 1);
-  const right = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 60_000
-  });
-  assert.equal(right.certain, true);
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { wedgeIsCertain } from "../services/data-channel-handler.js";
+import { PROBE_INTERVAL_MS } from "../services/delivery-probe.js";
+
+const MEGABYTE = 1024 * 1024;
+
+test("a queue draining at the rate this link was measured at is not a wedge", () => {
+  // 8 MB at 16 MB/s is half a second of draining. Half a second in is normal.
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 16 * MEGABYTE,
+    flatForMs: 200
+  });
+  assert.equal(verdict.certain, false);
+});
+
+test("the counter standing still past the queue's own drain time is a wedge", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 16 * MEGABYTE,
+    flatForMs: 4000
+  });
+  assert.equal(verdict.certain, true);
+  assert.equal(verdict.needMs, 500);
+});
+
+test("a big queue on a slow link is given the time it genuinely needs", () => {
+  // 67 MB at 1 MB/s is 67 seconds of honest draining — the field's own numbers
+  // for the wedged channel, at a rate a thin link could really be running at.
+  const patient = wedgeIsCertain({
+    queuedBytes: 67 * MEGABYTE,
+    bytesPerSecond: MEGABYTE,
+    flatForMs: 30_000
+  });
+  assert.equal(patient.certain, false);
+  const later = wedgeIsCertain({
+    queuedBytes: 67 * MEGABYTE,
+    bytesPerSecond: MEGABYTE,
+    flatForMs: 70_000
+  });
+  assert.equal(later.certain, true);
+});
+
+test("the same queue on the link the field actually had is called quickly", () => {
+  // 67 MB at 18 MB/s is under four seconds. The field episode stood still for
+  // 3217 s; the previous rule waited a flat 30 s before recording anything.
+  const verdict = wedgeIsCertain({
+    queuedBytes: 67 * MEGABYTE,
+    bytesPerSecond: 18 * MEGABYTE,
+    flatForMs: 5000
+  });
+  assert.equal(verdict.certain, true);
+  assert.ok(verdict.needMs < 30_000);
+});
+
+test("a tiny queue still waits for one round of probes", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 512,
+    bytesPerSecond: 16 * MEGABYTE,
+    flatForMs: PROBE_INTERVAL_MS - 1
+  });
+  assert.equal(verdict.certain, false);
+  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
+});
+
+test("nothing queued is still a wedge when the counter has been flat long enough — the channel queue was 0 on the real wedge while usrsctp held 399 MB", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 0,
+    bytesPerSecond: 16 * MEGABYTE,
+    flatForMs: 600_000
+  });
+  assert.equal(verdict.certain, true);
+  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
+});
+
+test("with no rate measured the answer is that nothing can be said", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 0,
+    flatForMs: 600_000
+  });
+  assert.equal(verdict.certain, false);
+  assert.equal(verdict.needMs, null);
+});
+
+test("a pause no longer than this link's own longest healthy pause is not a wedge", () => {
+  // A retransmission timeout stops the accepted-byte counter dead: a full send
+  // buffer accepts nothing. If this connection has already paused 3 s while
+  // healthy, a 3 s pause says nothing.
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 18 * MEGABYTE,
+    flatForMs: 2500,
+    longestHealthyFlatMs: 3000
+  });
+  assert.equal(verdict.certain, false);
+  assert.equal(verdict.needMs, 3000);
+});
+
+test("a pause longer than any this link has shown is a wedge", () => {
+  const verdict = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 18 * MEGABYTE,
+    flatForMs: 3500,
+    longestHealthyFlatMs: 3000
+  });
+  assert.equal(verdict.certain, true);
+});
+
+test("the quiet-probe rate cannot be what the queue is divided by", () => {
+  // With the browser's buffer full, the only traffic is the probe: three
+  // channels, a few dozen bytes, twice a second. Dividing 8 MB by that gives
+  // six hours, and the wedge would never be called. The BEST rate seen is what
+  // the watcher keeps, so this case must not arise — pinned here as the
+  // arithmetic that made it matter.
+  const wrong = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 360,
+    flatForMs: 60_000
+  });
+  assert.equal(wrong.certain, false);
+  assert.ok(wrong.needMs > 6 * 60 * 60 * 1000 - 1);
+  const right = wedgeIsCertain({
+    queuedBytes: 8 * MEGABYTE,
+    bytesPerSecond: 18 * MEGABYTE,
+    flatForMs: 60_000
+  });
+  assert.equal(right.certain, true);
+});

package/services/piece-store/disk-tier.js

@@ -1,151 +0,0 @@
-/**
- * @file The second tier: pieces that no longer fit in memory.
- *
- * One sparse file per torrent, a piece at `index * chunkLength`. Not the
- * torrent's real files — nobody reads those directly; playback goes through
- * `/stream`, and the data is discarded when the torrent goes idle. A single
- * file by piece index keeps the mapping arithmetic instead of bookkeeping, and
- * sparseness means the untouched gaps cost nothing.
- *
- * Reads take a destination buffer rather than returning a fresh one. That is
- * not a style preference — measured on the field host, an 8 MB piece costs
- * 22.08 ms via `readFile`, which allocates, and **7.63 ms** read into a buffer
- * we already hold. Two thirds of the apparent "disk" cost was allocation.
- */
-
-import fs from "node:fs/promises";
-import { constants } from "node:fs";
-import path from "node:path";
-
-export class DiskTier {
-  #filePath;
-  #chunkLength;
-  /** @type {import("node:fs/promises").FileHandle | null} */
-  #handle = null;
-  /** Piece indices known to be on disk. */
-  #stored = new Set();
-  /** @type {Promise<void> | null} */
-  #opening = null;
-
-  /**
-   * @param {object} params
-   * @param {string} params.directory - Where the backing file lives.
-   * @param {string} params.name - File name, unique per torrent.
-   * @param {number} params.chunkLength - Piece size; fixes the stride on disk.
-   */
-  constructor({ directory, name, chunkLength }) {
-    this.#filePath = path.join(directory, name);
-    this.#chunkLength = chunkLength;
-  }
-
-  /** Where the backing file lives, for logging and cleanup. */
-  get filePath() {
-    return this.#filePath;
-  }
-
-  /** How many pieces are currently held on disk. */
-  get size() {
-    return this.#stored.size;
-  }
-
-  /**
-   * Open the backing file, creating it and its directory if needed.
-   *
-   * Concurrent callers share one open — several evictions can start at once.
-   *
-   * @returns {Promise<import("node:fs/promises").FileHandle>}
-   */
-  async #open() {
-    if (this.#handle) {
-      return this.#handle;
-    }
-    if (!this.#opening) {
-      this.#opening = (async () => {
-        await fs.mkdir(path.dirname(this.#filePath), { recursive: true });
-        // Read/write, created if absent — NOT append mode. Under `a+` POSIX
-        // ignores the position on every write and puts the bytes at the end of
-        // the file, so pieces would pile up in arrival order and each read
-        // would return whichever piece happened to land at that offset.
-        this.#handle = await fs.open(this.#filePath, constants.O_RDWR | constants.O_CREAT);
-      })();
-    }
-    await this.#opening;
-    if (!this.#handle) {
-      throw new Error(`Could not open the piece file at ${this.#filePath}.`);
-    }
-    return this.#handle;
-  }
-
-  /**
-   * @param {number} index
-   * @returns {boolean}
-   */
-  has(index) {
-    return this.#stored.has(index);
-  }
-
-  /**
-   * Write a piece out.
-   *
-   * @param {number} index
-   * @param {Uint8Array} bytes
-   * @returns {Promise<void>}
-   */
-  async write(index, bytes) {
-    const handle = await this.#open();
-    await handle.write(bytes, 0, bytes.length, index * this.#chunkLength);
-    this.#stored.add(index);
-  }
-
-  /**
-   * Read a piece back into a buffer the caller already owns.
-   *
-   * @param {number} index
-   * @param {Uint8Array} target - Destination; its length is what gets read.
-   * @returns {Promise<number>} Bytes read.
-   */
-  async read(index, target) {
-    if (!this.#stored.has(index)) {
-      throw new Error(`Piece ${index} is not on disk.`);
-    }
-    const handle = await this.#open();
-    const { bytesRead } = await handle.read(target, 0, target.length, index * this.#chunkLength);
-    return bytesRead;
-  }
-
-  /**
-   * Forget a piece. The bytes stay on disk until the file is removed — there is
-   * nothing to gain from punching them out, since the file is discarded whole.
-   *
-   * @param {number} index
-   * @returns {void}
-   */
-  forget(index) {
-    this.#stored.delete(index);
-  }
-
-  /**
-   * Close the file, leaving its contents in place.
-   *
-   * @returns {Promise<void>}
-   */
-  async close() {
-    const handle = this.#handle;
-    this.#handle = null;
-    this.#opening = null;
-    if (handle) {
-      await handle.close();
-    }
-  }
-
-  /**
-   * Close and delete the backing file.
-   *
-   * @returns {Promise<void>}
-   */
-  async destroy() {
-    await this.close();
-    this.#stored.clear();
-    await fs.rm(this.#filePath, { force: true });
-  }
-}