@torrent-tv/proxy 2.89.17 → 2.89.19

package/research/priority-map-is-the-truth-2026-09-12.md

@@ -1,225 +0,0 @@
-# The priority map is the only statement of what is wanted
-
-Measurements and decisions behind the work listed in the roadmap as "the
-priority map is the only source of truth about what is wanted". Written
-2026-09-12, extended as the steps land.
-
-Everything below is tagged by where it comes from: READ (from the source),
-MEASURED (a number produced here), DECIDED (agreed with the user), or REFUSED
-(considered and not built, with the reason).
-
-## Why 2.83.1 stopped playback — READ
-
-The map is built by `PriorityOrchestrator.publishFor`, and its only input is the
-live SESSIONS (`hls-session-manager.js` hands it `sessionGroups`). A session
-exists once a file has been chosen and its playback plan built. The torrent,
-however, is added on `POST /api/sources/:key/warm`, while the person is still
-reading the list of episodes.
-
-So there is an interval in which the map cannot say anything at all, and in it
-"the map wants nothing" is indistinguishable from "there is nobody to ask yet".
-The field record of 2026-09-11 lies entirely inside that interval: added
-20:57:17, first peer 20:57:18, out of the swarm 20:57:21 with 741 connections
-let go.
-
-## The same fault with the opposite sign — READ
-
-When the last viewer of a file leaves, `publishFor` deletes that file's map from
-its own memory and publishes NOTHING:
-
-```js
-for (const key of [...this.#maps.keys()]) {
-  if (!byFile.has(key)) { this.#maps.delete(key); this.#last.delete(key); }
-}
-```
-
-`applyPriorityMap` withdraws a file's claimants only when it is CALLED, so the
-demand register keeps that file's zones for the life of the torrent — nothing
-else removes them but `forgetTorrent`, which runs when the torrent is removed
-altogether.
-
-Both ends are therefore broken: today the map can say neither "wanted" nor "not
-wanted". That is what has to be fixed before the register can be believed by
-anybody.
-
-## The register alone cannot be asked — READ
-
-A read states a claim only while it is STOPPED on a missing piece
-(`piece-reader.js:765`, `Urgency.BLOCKED`) and withdraws it when the read ends
-(`:1052`). So an empty register routinely means "at this instant everybody has
-what they need", not "nobody wants this". A swarm rule built on the register
-alone would release and rejoin repeatedly. The stable statement is the map,
-which holds while people are there.
-
-## No viewer-to-torrent link is needed — DECIDED
-
-A session carries `sourceKey`, and the map is addressed by source and file. So
-"is anybody here for this source" is already answered by any file of it having a
-non-empty map. A second holder of that same relation would be the two-owners
-fault this work removes, in a new place.
-
-## What is in a torrent, as one statement — MEASURED
-
-`services/torrent/Contents.js`, validated against the survey collection in
-`Dropbox/trn` on 2026-09-12 (137 files, 134 parsed):
-
-| | |
-|---|---|
-| torrents parsed | 134 |
-| of them with more than one picture | 44 |
-| items (pictures with what belongs to them) | 1357 |
-| files paired to a picture | 421 |
-| files paired to more than one picture | 0 |
-| largest torrent | 265 pictures |
-| items whose grouping differs from the per-picture call it replaces | 0 |
-
-The last row is what says this is a move rather than a change: every one of the
-1357 groupings agrees with `matchSidecarFiles` asked the old way, one picture at
-a time.
-
-The largest figure matters to the step that follows: a pack of 265 pictures is
-why the edges are claimed one item at a time rather than for the whole list —
-two pieces outstanding at a time, and the order is what bounds the cost.
-
-## Telling an episode from an extra — REFUSED
-
-Proposed, measured, and not built.
-
-**Words.** `sample|trailer|extras?|bonus|preview|teaser|making|interview|
-deleted|featurette` as whole tokens against every video path of the 134
-torrents: **four matches, all four false**. Three are the word "making" inside
-ordinary episode titles ("Making cash with her pussy", "Perfect pleasure making
-pussy") and their sizes are 0.84 to 2.35 of their torrent's median, i.e. they
-are the content. Not one real `Sample/` file exists in the collection, so the
-rule cannot even be validated here — that is a property of this collection, not
-a claim that extras do not exist.
-
-**Size.** The ratio of each video to the median of the videos in its own torrent
-runs continuously from 0.0000 to 1.0 with no gap anywhere: 53 videos sit under a
-quarter of their median, and they are short clips that ARE what the torrent is
-for (`REX1080_<name> - 720P_4000K_….mp4`, 6-23 MB, in collections of them). Two
-shapes are genuinely not content — `preview1..5.mp4` in one torrent, and
-`VIDEO_TS/VIDEO_TS.VOB` plus `VTS_01_0.VOB`, which are a DVD's menu and a
-structure question rather than a size one.
-
-So there is nothing here to derive a threshold from, and an invented one would
-decide the order in which a stranger's bandwidth is spent. Every picture is an
-item. The survey script is `scratchpad`-only and is reproduced by walking the
-collection with `parse-torrent` and the two functions named above.
-
-## Two classifications of one torrent, and they have already diverged — MEASURED
-
-The browser classifies the file list itself (`public/domain/torrent-parser.js`,
-`VIDEO_EXTENSIONS`, `classifyMediaFiles`, `orderForDisplay`) and the proxy does
-it again (`services/torrent/files.js`). Compared 2026-09-12: the browser offers
-`.dat` as video and the proxy does not count it, every other extension agreeing.
-On such a torrent the person is offered a file the proxy does not consider a
-picture, and `countVideoFiles` answers 0 — which also changes the one-picture
-relaxation in the pairing.
-
-One fact, one owner: the proxy owns the composition and the file-list route
-returns it. The cost is one round trip for a `.torrent` the browser parsed
-locally; the proxy holds those same bytes from registration, so it can answer
-without the swarm.
-
-## What the pool asks now, and the two things it no longer counts — DECIDED
-
-One question: **is anything wanted of this torrent**, answered from the register
-(`isWanted`). It is true from the moment a torrent is opened, because a torrent
-with no file list yet cannot be stated about and is being fetched precisely
-because somebody asked for it; and it becomes false exactly when the last
-viewer leaves, because that is when the map is published with nothing in it.
-
-Two facts decide the swarm, and they are separated from the doing
-(`swarmDecisionFor`) because this is the rule that has failed twice in the
-field:
-
-| wanted | ever wanted | swarm | idle clock |
-|---|---|---|---|
-| yes | — | take | stopped |
-| no | yes | let go | running |
-| no | no | leave alone | running |
-
-The last row is the 2.83.1 failure as a rule rather than as a mechanism: a
-torrent nobody has ever wanted is one being OPENED, and taking its swarm away
-there destroys the connections it will need a minute later.
-
-**Leaving on `done` was considered and NOT built.** A complete torrent can want
-nothing from a swarm, and the field case of 596 connections was exactly that.
-But a piece can be lost after the fact — the disk tier discards pieces under
-its own cap — and rejoining would then need a trigger nothing states today, so
-the failure mode is a read that waits for ever. The complete-file case is
-already answered from two directions: the upload policy refuses to seed when
-nothing anybody asked for is missing, and `keepWholeFiles` destroys a torrent
-whose every file has been written out whole.
-
-**What is accepted as narrowed, and stated so it is not discovered as a
-surprise.** A read that is flowing states nothing — it is reading bytes that
-are present — so a torrent is no longer held by the mere existence of a read.
-Three cases were checked: a `/stream` read belongs to a session whose map is
-live; the subtitle walk reads only what is downloaded; the background fill of a
-sidecar is covered by that file's ends. What is left is the disk cap evicting a
-torrent whose read is in flight during a moment when nothing is stated for it.
-The eviction order is the mitigation rather than a guard: candidates are sorted
-by when they were last WANTED, so a torrent an encoder is reading sorts last
-among them.
-
-**A torrent is on the idle clock from the moment it exists.** Until now the only
-thing that ever started that clock was a reader letting go, so a file list
-fetched and never played was held for the life of the process.
-
-## What the review of this work caught — READ
-
-Two defects, both found by reading the finished code rather than by a test, and
-both fixed with a check apiece.
-
-1. **A warm-up could take the urgency away from a plan somebody was waiting
-   for.** The two ends of a file are stated by whoever asks for them, and there
-   are two such callers: the playback plan, which a person is watching a loading
-   screen for, and the warm-up, which by its whole purpose nobody is waiting
-   for. The warm-up fires off the files beside the picture without awaiting
-   them, so it can arrive second — and it restated the same claimants at its own
-   lower level. The statement is raise-only now; the one caller entitled to put
-   them back down is the read that has just finished, which says so.
-2. **A departure could be noticed by nobody.** The background fill states a
-   claim of its own per file and withdraws it once nothing else wants that file
-   — but the withdrawal happened inside a pass that nothing acted on, so a
-   torrent everybody had left could be held "wanted" by the fill's own claim at
-   the moment of the departure and then never re-examined: in its swarm, with no
-   idle clock running. The pass acts on what it just said now.
-
-## Where the shared statement lives — DECIDED, then REVERSED the same day
-
-It was first published as a package, `@torrent-tv/torrent-contents`, so that
-both runtimes could read the same three files: the proxy states what to fetch
-from them, and the browser showed the list of episodes the instant a `.torrent`
-was dropped, before a proxy had been chosen.
-
-**Withdrawn within the hour, on the user's question: is the package better than
-moving it all to the proxy, when the torrent has to go there after the choice
-anyway.** It is not. The package bought one property — the instant list — with
-three permanent costs: a third artifact to version and publish, two copies at
-runtime that drift by version (a test was written for that drift, which is an
-admission the risk is real), and three wiring points that break the page at load
-with no error anybody sees (a second test was written for those).
-
-The answer is the route that already lists a source's files. For a magnet
-nothing changes at all — that is the path it has always taken — and the dropped
-`.torrent` now takes the same one. What leaves the browser with it is not only
-the classification but the whole notion of deciding anything from a name; what
-stays is what only the browser can see (the trackers and the web seeds in the
-file it holds) and how a name is SHOWN.
-
-**The cost is answered by connecting earlier, which is the user's own point.**
-Everything a viewer does needs a proxy, and choosing one and connecting to it
-used to begin only after a file had been picked. It begins when the page loads
-now, silently and with its failure swallowed, and `#acquireTransport` is
-joinable — so whatever the viewer does next joins that attempt instead of
-starting a second. Verified in a browser 2026-09-12: the page opens, the connect
-runs on its own (`public-only connect failed …; trying local path` on a dev
-server with no proxies registered), nothing is shown for it, and the page's own
-adapter turns the proxy's answer into the three lists with the order preserved,
-the torrent's own numbers kept and the release's repeated part taken off the
-names.
-
-`@torrent-tv/torrent-contents@1.0.0` is deprecated on npm with the reason.

package/scripts/build-audio-samples.mjs

@@ -1,31 +0,0 @@
-/** 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`);

package/scripts/render-run-graph.js

@@ -1,173 +0,0 @@
-#!/usr/bin/env node
-/**
- * @file Render the encoder-run table as a document, FROM the table.
- *
- * The picture is not drawn beside the code — it is produced from the same data
- * the code executes, so it cannot describe a machine that no longer exists. A
- * test regenerates it and compares, which is what makes "the table is the
- * single source" enforceable rather than a promise.
- *
- * Run it with `npm run graph`.
- */
-
-import { writeFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  ABSENT_EDGE_INVARIANTS,
-  ENCODE_RUN_EVENT,
-  ENCODE_RUN_STATE,
-  EVENT_MEANING,
-  INITIAL_RUN_STATE,
-  STATE_MEANING,
-  answerForMissingSegment,
-  declaredContainment,
-  declaredEdges,
-  isInputBeingRead,
-  mayRestart,
-  processCanBeSignalled,
-  wireState
-} from "../services/encode/encode-run-state.js";
-
-/** Where the rendered document lives. */
-export const GRAPH_DOC_PATH = path.join(
-  path.dirname(fileURLToPath(import.meta.url)),
-  "..",
-  "docs",
-  "encode-run-state.md"
-);
-
-const ALL_STATES = Object.values(ENCODE_RUN_STATE);
-const ALL_EVENTS = Object.values(ENCODE_RUN_EVENT);
-
-/**
- * Children of each node of the containment tree, in declaration order.
- *
- * @returns {{ root: string, childrenOf: Map<string, string[]> }}
- */
-function containmentTree() {
-  const childrenOf = new Map();
-  let root = null;
-  for (const { state, parent } of declaredContainment()) {
-    if (parent === null) {
-      root = state;
-      continue;
-    }
-    if (!childrenOf.has(parent)) {
-      childrenOf.set(parent, []);
-    }
-    childrenOf.get(parent).push(state);
-  }
-  return { root, childrenOf };
-}
-
-/**
- * One composite block, and everything nested inside it.
- *
- * @param {string} node
- * @param {Map<string, string[]>} childrenOf
- * @param {number} depth
- * @returns {string[]} Lines, already indented.
- */
-function renderBlock(node, childrenOf, depth) {
-  const pad = "    ".repeat(depth);
-  const children = childrenOf.get(node) ?? [];
-  if (children.length === 0) {
-    return [`${pad}${node}`];
-  }
-  const lines = [`${pad}state ${node} {`];
-  if (children.includes(INITIAL_RUN_STATE)) {
-    lines.push(`${pad}    [*] --> ${INITIAL_RUN_STATE}`);
-  }
-  for (const child of children) {
-    lines.push(...renderBlock(child, childrenOf, depth + 1));
-  }
-  lines.push(`${pad}}`);
-  return lines;
-}
-
-/**
- * The whole document.
- *
- * @returns {string}
- */
-export function renderRunGraphMarkdown() {
-  const { root, childrenOf } = containmentTree();
-  const lines = [];
-
-  lines.push(
-    "<!-- GENERATED from services/encode/encode-run-state.js by scripts/render-run-graph.js.",
-    "     Do not edit by hand: change the table and run `npm run graph`. -->",
-    "",
-    "# The encoder run — states and transitions",
-    "",
-    "One run of one ffmpeg inside one transcode session. The table this is drawn",
-    "from is executed by `services/encode/EncodeRuns.js`; every transition a real",
-    "run makes is logged as state, event and target, so a run that takes an edge",
-    "absent here is a violation the log names.",
-    "",
-    "```mermaid",
-    "stateDiagram-v2"
-  );
-  lines.push(...renderBlock(root, childrenOf, 1));
-  lines.push("");
-  for (const edge of declaredEdges()) {
-    lines.push(`    ${edge.from} --> ${edge.to} : ${edge.event}`);
-  }
-  lines.push("```", "");
-
-  lines.push("## States", "", "| state | means |", "|---|---|");
-  for (const state of ALL_STATES) {
-    lines.push(`| \`${state}\` | ${STATE_MEANING[state]} |`);
-  }
-  lines.push("");
-
-  lines.push("## Events", "", "| event | means |", "|---|---|");
-  for (const event of ALL_EVENTS) {
-    lines.push(`| \`${event}\` | ${EVENT_MEANING[event]} |`);
-  }
-  lines.push("");
-
-  lines.push(
-    "## What each state answers",
-    "",
-    "Outputs depend on the state alone — computed here by calling the same",
-    "functions the session manager calls.",
-    "",
-    "| state | reads its input | can be signalled | a missing segment | on the wire | may restart |",
-    "|---|---|---|---|---|---|"
-  );
-  for (const state of ALL_STATES) {
-    lines.push(
-      `| \`${state}\` | ${isInputBeingRead(state) ? "yes" : "no"} | ` +
-        `${processCanBeSignalled(state) ? "yes" : "no"} | ${answerForMissingSegment(state)} | ` +
-        `\`${wireState(state)}\` | ${mayRestart(state) ? "yes" : "no"} |`
-    );
-  }
-  lines.push("");
-
-  lines.push(
-    "## Edges that must never exist",
-    "",
-    "The machine's real content: a near-complete digraph asserts nothing.",
-    "",
-    "| from | event | must not reach | because |",
-    "|---|---|---|---|"
-  );
-  for (const invariant of ABSENT_EDGE_INVARIANTS) {
-    lines.push(
-      `| \`${invariant.from}\` | \`${invariant.event}\` | \`${invariant.mustNotReach}\` | ${invariant.because} |`
-    );
-  }
-  lines.push("");
-
-  return `${lines.join("\n")}`;
-}
-
-// Written only when this file is the program being run, so importing it from a
-// test cannot rewrite the very file the test is about to compare against.
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  writeFileSync(GRAPH_DOC_PATH, renderRunGraphMarkdown(), "utf8");
-  process.stdout.write(`wrote ${GRAPH_DOC_PATH}\n`);
-}

package/test/asset-paths.test.js

@@ -1,28 +0,0 @@
-/**
- * @file Paths a module builds from its own location still name what they meant.
- *
- * A file that joins `..` onto its own directory is right only at the depth it
- * was written at. Moving files into their components (2.87.0) left the gdb
- * script of the usrsctp reader pointing one directory short, and no check
- * noticed: the path is read only when a wedge is diagnosed.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { CALIBRATION_DIR } from "../services/encode/hwaccel.js";
-import { PROXY_ROOT } from "../services/encode/quality/HostTimings.js";
-import { SCTPSTATE_SCRIPT_PATH } from "../services/transport/usrsctp-state.js";
-
-test("the calibration clips are where the benchmark looks", () => {
-  assert.ok(existsSync(CALIBRATION_DIR), CALIBRATION_DIR);
-});
-
-test("the usrsctp state script is where the reader looks", () => {
-  assert.ok(existsSync(SCTPSTATE_SCRIPT_PATH), SCTPSTATE_SCRIPT_PATH);
-});
-
-test("the default place for host timings is the proxy's own directory", () => {
-  assert.ok(existsSync(path.join(PROXY_ROOT, "package.json")), PROXY_ROOT);
-});

package/test/audio-buffer-continuity.test.js

@@ -1,77 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import test from "node:test";
-import { readPresentationRanges, servedPresentationRanges, walkBoxes } from "../services/encode/segment-formats/mp4-boxes.js";
-import { predictPlaybackReadiness } from "../services/viewer/playback-readiness.js";
-
-const evidence = JSON.parse(readFileSync(new URL("./fixtures/audio-frame-boundary.json", import.meta.url), "utf8"));
-const header = Buffer.from(evidence.files["init.mp4"], "base64");
-
-function served(name, shiftedFrames = 0) {
-  const bytes = Buffer.from(evidence.files[name], "base64");
-  let frameTicks;
-  walkBoxes(bytes, (type, start) => {
-    if (type === "tfhd") {
-      const flags = bytes.readUIntBE(start + 1, 3);
-      const at = start + 8 + ((flags & 1) ? 8 : 0) + ((flags & 2) ? 4 : 0);
-      if (flags & 8) frameTicks = bytes.readUInt32BE(at);
-    }
-    if (type === "tfdt" && shiftedFrames) {
-      assert.ok(frameTicks > 0);
-      bytes.writeBigUInt64BE(bytes.readBigUInt64BE(start + 4) + BigInt(frameTicks * shiftedFrames), start + 4);
-    }
-  });
-  return servedPresentationRanges(readPresentationRanges(Buffer.concat([header, bytes])), header);
-}
-
-const seconds = ({ timescale }, ticks) => Number(ticks) / Number(timescale);
-
-function state(second = served("segment-00172.mp4")) {
-  const first = served("segment-00171.mp4");
-  const now = 1000;
-  const firstStart = seconds(first, first.ranges[0].start);
-  const secondStart = seconds(second, second.ranges[0].start);
-  const secondEnd = seconds(second, second.ranges.at(-1).end);
-  return {
-    now,
-    positionSeconds: firstStart,
-    durationSeconds: secondEnd,
-    reserveSeconds: 0,
-    lookaheadSeconds: secondEnd - firstStart,
-    sources: [{ id: "source", complete: true }],
-    linkReadings: [{ at: now, value: 1_000_000 }],
-    tracks: [{
-      id: "audio", sourceIds: ["source"], clockOffsetSeconds: 0, clientRanges: [
-        { start: evidence.browserBufferedRanges[0][0], end: evidence.browserBufferedRanges[0][1] }
-      ],
-      readings: [{ at: now, value: 1 }],
-      readySegmentIndices: [0, 1], segmentSizesBytes: { 0: 170000, 1: 170000 },
-      segments: [
-        { index: 0, startSeconds: firstStart, endSeconds: secondStart, mediaRanges: first },
-        { index: 1, startSeconds: secondStart, endSeconds: secondEnd, mediaRanges: second }
-      ]
-    }]
-  };
-}
-
-test("the captured AAC join, 432 ticks at 48 kHz, is one Chrome closed and every engine closes", () => {
-  const input = state();
-  assert.equal(predictPlaybackReadiness(input).ready, true);
-  // Without the frame durations the pieces state, nothing allows the gap.
-  for (const segment of input.tracks[0].segments) {
-    segment.mediaRanges = { ...segment.mediaRanges,
-      ranges: segment.mediaRanges.ranges.map((range) => ({ ...range, frame: 0n })) };
-  }
-  assert.equal(predictPlaybackReadiness(input).reason, "media-continuity-unavailable");
-});
-
-test("four missing AAC frames preserve the discontinuity observed in Chrome", () => {
-  assert.equal(predictPlaybackReadiness(state(served("segment-00172.mp4", 4))).reason,
-    "media-continuity-unavailable");
-});
-
-test("a join never supplies audio before the adjacent segment arrives", () => {
-  const input = state();
-  input.linkReadings[0].value = 1;
-  assert.notEqual(predictPlaybackReadiness(input).ready, true);
-});

package/test/audio-calibration.test.js

@@ -1,23 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { audioReadingFor } from "../services/encode/audio-calibration.js";
-
-const readings = [
-  { codec: "ac3", operation: "aac", channels: 2, samplingFrequency: 48000, speed: 120 },
-  { codec: "aac", operation: "copy", channels: 2, samplingFrequency: 48000, speed: 200,
-    bytes: 64000, durationSeconds: 4 }
-];
-
-test("audio processing uses codec and sample work instead of a video-copy rate", () => {
-  assert.equal(audioReadingFor(readings, { codec: "ac3", transcode: true, channels: 6,
-    samplingFrequency: 48000 }).speed, 40);
-  assert.equal(audioReadingFor(readings, { codec: "ac3", transcode: true, channels: 2,
-    samplingFrequency: 24000 }).speed, 240);
-  assert.equal(audioReadingFor(readings, { codec: "dts", transcode: true }), null);
-});
-
-test("copying uses encoded byte work when the source declares its bitrate", () => {
-  assert.equal(audioReadingFor(readings, { codec: "aac", transcode: false, bitrateKbps: 256 }).speed, 100);
-  assert.equal(audioReadingFor(readings, { codec: "aac", transcode: false }).speed, 200);
-  assert.equal(audioReadingFor(readings, { codec: "aac", transcode: true }), null);
-});