@torrent-tv/proxy 2.88.4 → 2.88.5

package/test/source-file.test.js

@@ -1,133 +1,133 @@
-/**
- * @file The file as a handle: its key, its name, what a probe said about it,
- * and the address this proxy serves it at.
- *
- * The reason this object exists is the key. Twenty places in the session
- * manager assembled `${sourceKey}:${fileIndex}` by hand, through five different
- * spellings, to reach caches that are keyed by a file. These checks pin the
- * shape those call sites now depend on, and the one property the registry has
- * to have: the same file asked for twice is the same object, or a fact learned
- * through one reference would be invisible through the other.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { SourceFile, SourceFiles, sourceDecodeCharacteristics } from "../services/media/SourceFile.js";
-
-test("a file's key is the pair that identifies it, spelled in one place", () => {
-  const file = new SourceFile({ sourceKey: "abc123", fileIndex: 4 });
-  assert.equal(file.key, "abc123:4");
-  assert.equal(SourceFiles.keyFor("abc123", 4), file.key);
-});
-
-test("a file with no name is named by its index, so no log line is about a nameless thing", () => {
-  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7 }).name, "file#7");
-  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7, name: "  Film.mkv  " }).name, "Film.mkv");
-});
-
-test("facts are absent until a probe answers, and 'absent' is not 'zero'", () => {
-  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
-  assert.equal(file.width, null, "an unread frame size is unknown, not 0x0");
-  assert.equal(file.height, null);
-  assert.equal(file.fps, null);
-  assert.equal(file.durationSeconds, null);
-  assert.equal(file.hasDuration, false);
-  assert.equal(file.isHdr, false, "a file nobody has read is not claimed to be HDR");
-  assert.equal(file.startTime, 0, "no stated start time means the timeline begins at zero");
-  assert.equal(file.decode, null, "and nothing is priced from facts that were never read");
-});
-
-test("readings are merged, because two readers answer about different things", () => {
-  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
-  // ffmpeg's banner: the frame size and rate, and no start time.
-  file.learn({ width: 1920, height: 1080, fps: 24 });
-  // The container's own header, read for one field — a sidecar soundtrack is
-  // read for exactly this and nothing else.
-  file.learn({ startTime: 0.083 });
-  assert.equal(file.startTime, 0.083);
-  assert.equal(file.width, 1920, "the second reader must not erase what the first found");
-});
-
-test("a fresher reading replaces the first, because a cold torrent answers incompletely", () => {
-  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
-  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 0, startTime: 1.5 });
-  assert.equal(file.width, 1920);
-  assert.equal(file.hasDuration, false, "a duration of zero is no duration");
-  assert.equal(file.startTime, 1.5);
-
-  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 5400, startTime: 1.5 });
-  assert.equal(file.durationSeconds, 5400);
-  assert.equal(file.hasDuration, true);
-
-  file.learn(null);
-  assert.equal(file.durationSeconds, 5400, "nothing is unlearned by an answer that did not come");
-});
-
-test("what decoding costs is derived from the file's own facts, per codec family", () => {
-  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
-  file.learn({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000, codec: "hevc", bitDepth: 10 });
-  assert.deepEqual(file.decode, {
-    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
-    megabitsPerSecond: 8,
-    codec: "hevc",
-    bitDepth: 10
-  });
-  // The same arithmetic, still callable on a plain reading — the offer prices a
-  // file it has not made a session for.
-  assert.deepEqual(sourceDecodeCharacteristics({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000 }), {
-    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
-    megabitsPerSecond: 8,
-    codec: "",
-    bitDepth: null
-  });
-});
-
-test("the address carries the file and the session, and the proxy's own base is a parameter", () => {
-  const file = new SourceFile({ sourceKey: "abc", fileIndex: 2 });
-  const url = file.streamUrl("http://127.0.0.1:9090", { sessionId: "sess-1" });
-  assert.equal(url.pathname, "/stream");
-  assert.equal(url.searchParams.get("sourceKey"), "abc");
-  assert.equal(url.searchParams.get("fileIndex"), "2");
-  assert.equal(url.searchParams.get("session"), "sess-1");
-
-  const noSession = file.streamUrl("http://127.0.0.1:9090");
-  assert.equal(noSession.searchParams.has("session"), false, "a read nobody is accounting for says so");
-});
-
-test("the same file asked for twice is the same object, or a fact learned once is lost", () => {
-  const files = new SourceFiles();
-  const first = files.get("abc", 1, "Film.mkv");
-  first.learn({ width: 1280, height: 720, fps: 25, durationSeconds: 60 });
-
-  const second = files.get("abc", 1);
-  assert.equal(second, first, "two viewers of one file must not hold two copies of its facts");
-  assert.equal(second.width, 1280);
-  assert.equal(second.name, "Film.mkv");
-
-  const other = files.get("abc", 2);
-  assert.notEqual(other, first, "and a different file in the same torrent is a different file");
-});
-
-test("a name learned later is kept, since the first caller often has only an index", () => {
-  const files = new SourceFiles();
-  const bare = files.get("abc", 1);
-  assert.equal(bare.name, "file#1");
-  files.get("abc", 1, "Film.mkv");
-  assert.equal(bare.name, "Film.mkv");
-  files.get("abc", 1, "Something.else.mkv");
-  assert.equal(bare.name, "Film.mkv", "and it is not renamed underneath a log line already written");
-});
-
-test("files nobody names are dropped, and a file still named survives the sweep", () => {
-  const files = new SourceFiles();
-  const kept = files.get("abc", 1);
-  files.get("abc", 2);
-  files.get("def", 9);
-  assert.equal(files.size, 3);
-
-  const dropped = files.forgetUnused(new Set([kept]));
-  assert.equal(dropped, 2);
-  assert.equal(files.size, 1);
-  assert.equal(files.peek(kept.key), kept);
-  assert.equal(files.peek("abc:2"), null);
-});
+/**
+ * @file The file as a handle: its key, its name, what a probe said about it,
+ * and the address this proxy serves it at.
+ *
+ * The reason this object exists is the key. Twenty places in the session
+ * manager assembled `${sourceKey}:${fileIndex}` by hand, through five different
+ * spellings, to reach caches that are keyed by a file. These checks pin the
+ * shape those call sites now depend on, and the one property the registry has
+ * to have: the same file asked for twice is the same object, or a fact learned
+ * through one reference would be invisible through the other.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { SourceFile, SourceFiles, sourceDecodeCharacteristics } from "../services/media/SourceFile.js";
+
+test("a file's key is the pair that identifies it, spelled in one place", () => {
+  const file = new SourceFile({ sourceKey: "abc123", fileIndex: 4 });
+  assert.equal(file.key, "abc123:4");
+  assert.equal(SourceFiles.keyFor("abc123", 4), file.key);
+});
+
+test("a file with no name is named by its index, so no log line is about a nameless thing", () => {
+  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7 }).name, "file#7");
+  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7, name: "  Film.mkv  " }).name, "Film.mkv");
+});
+
+test("facts are absent until a probe answers, and 'absent' is not 'zero'", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  assert.equal(file.width, null, "an unread frame size is unknown, not 0x0");
+  assert.equal(file.height, null);
+  assert.equal(file.fps, null);
+  assert.equal(file.durationSeconds, null);
+  assert.equal(file.hasDuration, false);
+  assert.equal(file.isHdr, false, "a file nobody has read is not claimed to be HDR");
+  assert.equal(file.startTime, 0, "no stated start time means the timeline begins at zero");
+  assert.equal(file.decode, null, "and nothing is priced from facts that were never read");
+});
+
+test("readings are merged, because two readers answer about different things", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  // ffmpeg's banner: the frame size and rate, and no start time.
+  file.learn({ width: 1920, height: 1080, fps: 24 });
+  // The container's own header, read for one field — a sidecar soundtrack is
+  // read for exactly this and nothing else.
+  file.learn({ startTime: 0.083 });
+  assert.equal(file.startTime, 0.083);
+  assert.equal(file.width, 1920, "the second reader must not erase what the first found");
+});
+
+test("a fresher reading replaces the first, because a cold torrent answers incompletely", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 0, startTime: 1.5 });
+  assert.equal(file.width, 1920);
+  assert.equal(file.hasDuration, false, "a duration of zero is no duration");
+  assert.equal(file.startTime, 1.5);
+
+  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 5400, startTime: 1.5 });
+  assert.equal(file.durationSeconds, 5400);
+  assert.equal(file.hasDuration, true);
+
+  file.learn(null);
+  assert.equal(file.durationSeconds, 5400, "nothing is unlearned by an answer that did not come");
+});
+
+test("what decoding costs is derived from the file's own facts, per codec family", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  file.learn({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000, codec: "hevc", bitDepth: 10 });
+  assert.deepEqual(file.decode, {
+    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
+    megabitsPerSecond: 8,
+    codec: "hevc",
+    bitDepth: 10
+  });
+  // The same arithmetic, still callable on a plain reading — the offer prices a
+  // file it has not made a session for.
+  assert.deepEqual(sourceDecodeCharacteristics({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000 }), {
+    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
+    megabitsPerSecond: 8,
+    codec: "",
+    bitDepth: null
+  });
+});
+
+test("the address carries the file and the session, and the proxy's own base is a parameter", () => {
+  const file = new SourceFile({ sourceKey: "abc", fileIndex: 2 });
+  const url = file.streamUrl("http://127.0.0.1:9090", { sessionId: "sess-1" });
+  assert.equal(url.pathname, "/stream");
+  assert.equal(url.searchParams.get("sourceKey"), "abc");
+  assert.equal(url.searchParams.get("fileIndex"), "2");
+  assert.equal(url.searchParams.get("session"), "sess-1");
+
+  const noSession = file.streamUrl("http://127.0.0.1:9090");
+  assert.equal(noSession.searchParams.has("session"), false, "a read nobody is accounting for says so");
+});
+
+test("the same file asked for twice is the same object, or a fact learned once is lost", () => {
+  const files = new SourceFiles();
+  const first = files.get("abc", 1, "Film.mkv");
+  first.learn({ width: 1280, height: 720, fps: 25, durationSeconds: 60 });
+
+  const second = files.get("abc", 1);
+  assert.equal(second, first, "two viewers of one file must not hold two copies of its facts");
+  assert.equal(second.width, 1280);
+  assert.equal(second.name, "Film.mkv");
+
+  const other = files.get("abc", 2);
+  assert.notEqual(other, first, "and a different file in the same torrent is a different file");
+});
+
+test("a name learned later is kept, since the first caller often has only an index", () => {
+  const files = new SourceFiles();
+  const bare = files.get("abc", 1);
+  assert.equal(bare.name, "file#1");
+  files.get("abc", 1, "Film.mkv");
+  assert.equal(bare.name, "Film.mkv");
+  files.get("abc", 1, "Something.else.mkv");
+  assert.equal(bare.name, "Film.mkv", "and it is not renamed underneath a log line already written");
+});
+
+test("files nobody names are dropped, and a file still named survives the sweep", () => {
+  const files = new SourceFiles();
+  const kept = files.get("abc", 1);
+  files.get("abc", 2);
+  files.get("def", 9);
+  assert.equal(files.size, 3);
+
+  const dropped = files.forgetUnused(new Set([kept]));
+  assert.equal(dropped, 2);
+  assert.equal(files.size, 1);
+  assert.equal(files.peek(kept.key), kept);
+  assert.equal(files.peek("abc:2"), null);
+});

package/test/source-registry.test.js

@@ -1,18 +1,18 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createSourceRegistry } from "../store/source-registry.js";
-
-const infoHash = "0123456789abcdef0123456789abcdef01234567";
-
-test("magnet links for one torrent share a source key", async () => {
-  const registry = createSourceRegistry();
-  const first = `magnet:?xt=urn:btih:${infoHash}&dn=First+name&tr=udp%3A%2F%2Ftracker.one%3A80`;
-  const second = `magnet:?xt=urn:btih:${infoHash}&dn=Different+name&tr=udp%3A%2F%2Ftracker.two%3A80`;
-
-  const firstKey = await registry.upsert("magnet", first);
-  const secondKey = await registry.upsert("magnet", second);
-
-  assert.equal(firstKey, `torrent:${infoHash}`);
-  assert.equal(secondKey, firstKey);
-  assert.equal(registry.get(firstKey)?.source, second);
-});
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createSourceRegistry } from "../store/source-registry.js";
+
+const infoHash = "0123456789abcdef0123456789abcdef01234567";
+
+test("magnet links for one torrent share a source key", async () => {
+  const registry = createSourceRegistry();
+  const first = `magnet:?xt=urn:btih:${infoHash}&dn=First+name&tr=udp%3A%2F%2Ftracker.one%3A80`;
+  const second = `magnet:?xt=urn:btih:${infoHash}&dn=Different+name&tr=udp%3A%2F%2Ftracker.two%3A80`;
+
+  const firstKey = await registry.upsert("magnet", first);
+  const secondKey = await registry.upsert("magnet", second);
+
+  assert.equal(firstKey, `torrent:${infoHash}`);
+  assert.equal(secondKey, firstKey);
+  assert.equal(registry.get(firstKey)?.source, second);
+});

package/test/split-a-stretch.test.js

@@ -1,139 +1,139 @@
-/**
- * @file Where a second encoder joins a stretch, and whether it is worth having.
- *
- * Both halves are arithmetic and neither was asked before. The stretch used to
- * be halved, unconditionally:
- *
- *     widestFrom = from + Math.floor(Math.min(room, to - from + 1) / 2)
- *
- * Halving IS the answer when both encoders are fresh and owe the same. It is not
- * when one of them is already partway through a piece, and it never asked the
- * other question at all — whether two encoders under this host's measured
- * contention beat one at full speed.
- *
- * The derivation. A stretch of unmade film runs from `from` to `to`; whoever is
- * already on it stands at `from` and owes `w` before the piece under it exists;
- * a fresh one placed at `x` owes `d` — its start and then a whole piece — and
- * both then work at the rate two encoders leave each other:
- *
- *     the one there closes [from, x-1]:  w + (x - 1 - from) / r   rises with x
- *     the fresh one closes [x, to]:      d + (to - x)     / r     falls with x
- *
- *     x* = (from + to + 1) / 2  +  (d - w) * r / 2
- *
- * The shift is `firstByteWait / (2 * perPiece)` pieces, so it depends on how
- * long a piece takes here: 0.24 of a piece at 4.45x on a 4.2 s grid, but 0.96 at
- * 8.9x and 2.14 at 20x — a whole segment and more on the copy branch, where a
- * piece is short and a start is not. Measuring only the re-encode rate
- * understated it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { planEncoders } from "../services/encode/EncodePlan.js";
-import { CoverageMap } from "../services/encode/CoverageMap.js";
-
-const SEGMENT_SECONDS = 4.2;
-const LAST = 199;
-
-/**
- * One encoder on a long stretch nobody has made, and room for more.
- *
- * @param {{ speedX: number, penalty: number, head?: number, ageMs?: number,
- *   maxRuns?: number }} params
- * @returns {{ actions: object[], run: object }}
- */
-function planFor({ speedX, penalty, head = 0, ageMs = 60_000, maxRuns = 3, runs = null }) {
-  const coverage = new CoverageMap({ segmentCount: LAST + 1 });
-  const run = { from: 0, to: -1, head, speedX, isAlive: true, startedAt: 1_000_000 };
-  const live = runs ?? [run];
-  for (const one of live) {
-    coverage.claim(one, one.from, one.to);
-  }
-  return {
-    run,
-    actions: planEncoders({
-      coverage,
-      // One zone over the whole film, due now, so nothing but the arithmetic of
-      // sharing it decides anything.
-      windows: [{ from: 0, to: LAST, priority: 100, withinSeconds: 0, behind: false }],
-      runs: live,
-      maxRuns,
-      segmentSeconds: SEGMENT_SECONDS,
-      speedX,
-      killCostSec: 0.04,
-      firstByteWaitSec: 0.9,
-      moveCostSec: 0.94,
-      refetchSecPerFilmSecond: 0,
-      // Measured on the addon host: 1.70 at 854x480, 1.98 at 1920x1080. Raised
-      // to the power of how many others there are, so a third costs again.
-      contentionPenaltyFor: (others) => (others <= 0 ? 1 : penalty ** others),
-      now: 1_000_000 + ageMs
-    })
-  };
-}
-
-test("one encoder that reaches everything in time is left to do it alone", () => {
-  // A zone whose deadline GROWS with distance — which is what the map states,
-  // one segment at a time — is comfortably served by one encoder at 4.45x: #199
-  // is due in 835 s and arrives in 189 s. So there is no position to fill and
-  // nothing to split, whatever the budget says.
-  //
-  // Measured rather than assumed: this is what the plan answers, and the test
-  // was written expecting two encoders before it was run.
-  const { actions } = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3 });
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["keep #0..#-1"],
-    "one encoder, its road to the end of the film"
-  );
-});
-
-test("a stretch nobody is on is split at the middle, and the halves bound each other", () => {
-  // Both encoders are fresh, so both owe the same and `d - w` is zero: the
-  // meeting point is the midpoint, which is what halving always said. What is
-  // new is that each one's road ENDS where the next begins, so neither writes
-  // into the other's names.
-  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 2, runs: [] }).actions;
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["start #0..#100", "start #101..#199"],
-    "0..199 halved at 100"
-  );
-});
-
-test("a third encoder halves the widest half that is left", () => {
-  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3, runs: [] }).actions;
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["start #0..#50", "start #51..#100", "start #101..#199"],
-    "the first half is halved again, greedily, widest first"
-  );
-});
-
-test("a stretch of one piece is not split at all", () => {
-  const coverage = new CoverageMap({ segmentCount: 2 });
-  const actions = planEncoders({
-    coverage,
-    windows: [{ from: 0, to: 0, priority: 100, withinSeconds: 0, behind: false }],
-    runs: [],
-    maxRuns: 3,
-    segmentSeconds: SEGMENT_SECONDS,
-    speedX: 8.9,
-    killCostSec: 0.04,
-    firstByteWaitSec: 0.9,
-    moveCostSec: 0.94,
-    refetchSecPerFilmSecond: 0,
-    contentionPenaltyFor: () => 1,
-    now: 1_000_000
-  });
-
-  assert.equal(
-    actions.filter((one) => one.type === "start").length,
-    1,
-    "there is nothing to share"
-  );
-});
+/**
+ * @file Where a second encoder joins a stretch, and whether it is worth having.
+ *
+ * Both halves are arithmetic and neither was asked before. The stretch used to
+ * be halved, unconditionally:
+ *
+ *     widestFrom = from + Math.floor(Math.min(room, to - from + 1) / 2)
+ *
+ * Halving IS the answer when both encoders are fresh and owe the same. It is not
+ * when one of them is already partway through a piece, and it never asked the
+ * other question at all — whether two encoders under this host's measured
+ * contention beat one at full speed.
+ *
+ * The derivation. A stretch of unmade film runs from `from` to `to`; whoever is
+ * already on it stands at `from` and owes `w` before the piece under it exists;
+ * a fresh one placed at `x` owes `d` — its start and then a whole piece — and
+ * both then work at the rate two encoders leave each other:
+ *
+ *     the one there closes [from, x-1]:  w + (x - 1 - from) / r   rises with x
+ *     the fresh one closes [x, to]:      d + (to - x)     / r     falls with x
+ *
+ *     x* = (from + to + 1) / 2  +  (d - w) * r / 2
+ *
+ * The shift is `firstByteWait / (2 * perPiece)` pieces, so it depends on how
+ * long a piece takes here: 0.24 of a piece at 4.45x on a 4.2 s grid, but 0.96 at
+ * 8.9x and 2.14 at 20x — a whole segment and more on the copy branch, where a
+ * piece is short and a start is not. Measuring only the re-encode rate
+ * understated it.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { planEncoders } from "../services/encode/EncodePlan.js";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+
+const SEGMENT_SECONDS = 4.2;
+const LAST = 199;
+
+/**
+ * One encoder on a long stretch nobody has made, and room for more.
+ *
+ * @param {{ speedX: number, penalty: number, head?: number, ageMs?: number,
+ *   maxRuns?: number }} params
+ * @returns {{ actions: object[], run: object }}
+ */
+function planFor({ speedX, penalty, head = 0, ageMs = 60_000, maxRuns = 3, runs = null }) {
+  const coverage = new CoverageMap({ segmentCount: LAST + 1 });
+  const run = { from: 0, to: -1, head, speedX, isAlive: true, startedAt: 1_000_000 };
+  const live = runs ?? [run];
+  for (const one of live) {
+    coverage.claim(one, one.from, one.to);
+  }
+  return {
+    run,
+    actions: planEncoders({
+      coverage,
+      // One zone over the whole film, due now, so nothing but the arithmetic of
+      // sharing it decides anything.
+      windows: [{ from: 0, to: LAST, priority: 100, withinSeconds: 0, behind: false }],
+      runs: live,
+      maxRuns,
+      segmentSeconds: SEGMENT_SECONDS,
+      speedX,
+      killCostSec: 0.04,
+      firstByteWaitSec: 0.9,
+      moveCostSec: 0.94,
+      refetchSecPerFilmSecond: 0,
+      // Measured on the addon host: 1.70 at 854x480, 1.98 at 1920x1080. Raised
+      // to the power of how many others there are, so a third costs again.
+      contentionPenaltyFor: (others) => (others <= 0 ? 1 : penalty ** others),
+      now: 1_000_000 + ageMs
+    })
+  };
+}
+
+test("one encoder that reaches everything in time is left to do it alone", () => {
+  // A zone whose deadline GROWS with distance — which is what the map states,
+  // one segment at a time — is comfortably served by one encoder at 4.45x: #199
+  // is due in 835 s and arrives in 189 s. So there is no position to fill and
+  // nothing to split, whatever the budget says.
+  //
+  // Measured rather than assumed: this is what the plan answers, and the test
+  // was written expecting two encoders before it was run.
+  const { actions } = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3 });
+
+  assert.deepEqual(
+    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
+    ["keep #0..#-1"],
+    "one encoder, its road to the end of the film"
+  );
+});
+
+test("a stretch nobody is on is split at the middle, and the halves bound each other", () => {
+  // Both encoders are fresh, so both owe the same and `d - w` is zero: the
+  // meeting point is the midpoint, which is what halving always said. What is
+  // new is that each one's road ENDS where the next begins, so neither writes
+  // into the other's names.
+  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 2, runs: [] }).actions;
+
+  assert.deepEqual(
+    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
+    ["start #0..#100", "start #101..#199"],
+    "0..199 halved at 100"
+  );
+});
+
+test("a third encoder halves the widest half that is left", () => {
+  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3, runs: [] }).actions;
+
+  assert.deepEqual(
+    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
+    ["start #0..#50", "start #51..#100", "start #101..#199"],
+    "the first half is halved again, greedily, widest first"
+  );
+});
+
+test("a stretch of one piece is not split at all", () => {
+  const coverage = new CoverageMap({ segmentCount: 2 });
+  const actions = planEncoders({
+    coverage,
+    windows: [{ from: 0, to: 0, priority: 100, withinSeconds: 0, behind: false }],
+    runs: [],
+    maxRuns: 3,
+    segmentSeconds: SEGMENT_SECONDS,
+    speedX: 8.9,
+    killCostSec: 0.04,
+    firstByteWaitSec: 0.9,
+    moveCostSec: 0.94,
+    refetchSecPerFilmSecond: 0,
+    contentionPenaltyFor: () => 1,
+    now: 1_000_000
+  });
+
+  assert.equal(
+    actions.filter((one) => one.type === "start").length,
+    1,
+    "there is nothing to share"
+  );
+});