@torrent-tv/proxy 2.87.10 → 2.87.12

package/test/seek-target-not-superseded.test.js

@@ -1,195 +1,195 @@
-/**
- * @file The segment the viewer just seeked TO must not be refused as stale.
- *
- * A seek bumps the wait epoch so that requests made for the position being left
- * stop being held. The request for the position being ARRIVED at races that
- * bump: hls.js asks for the new segment within milliseconds, and if the epoch
- * moves underneath it, the epoch check alone cannot tell the two apart.
- *
- * Measured 2026-08-18: the viewer seeked to 1061.0 s, `segment-00101` — the
- * segment at that very position — was answered 503 twice within 80 ms, the
- * player never asked for it again, and instead looped `a/0/segment-00103` and
- * `a/0/segment-00104` 737 and 736 times over 149 seconds while the picture
- * stood at `t=1061.0s readyState=1`. The session ended without another frame.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-
-const SESSION_ID = "aaaaaaaa11112222";
-const SEGMENT_SECONDS = 10.4;
-const SEEK_TO_SECONDS = 1061;
-const SEGMENT_AT_SEEK = Math.floor(SEEK_TO_SECONDS / SEGMENT_SECONDS);
-
-/**
- * A session whose viewer has just landed at {@link SEEK_TO_SECONDS}.
- *
- * @returns {Promise<{ manager: object, dirPath: string }>}
- */
-async function managerAfterSeek() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "seek-target-"));
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const session = {
-    id: SESSION_ID,
-    dirPath,
-    // Where this file is cut, held by the file. A fixture that stated it
-    // on the session was describing what production no longer does.
-    timeline: new Timeline({
-      boundaries: Array.from({ length: 400 }, (_, index) => index * SEGMENT_SECONDS),
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
-    // An ordinary session reads its own file, and its sound is inside it. The
-    // three differ only for a soundtrack shipped as a file of its own.
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    startedAt: Date.now(),
-    lastAccessedAt: Date.now(),
-    consumers: new Set(),
-    segmentFormat: fmp4Format,
-    transcodeVideo: false,
-    useSyntheticPlaylist: true,
-    segmentCount: 399,
-    encodeStartIndex: SEGMENT_AT_SEEK,
-    waitEpoch: 1,
-    runState: "PRODUCING"
-  };
-  manager.outputs.set(SESSION_ID, session);
-  manager.viewers.of(session, "viewer").moveTo(SEEK_TO_SECONDS);
-  manager.viewers.of(session, "viewer").playing = false;
-  return { manager, dirPath };
-}
-
-test("the segment at the seek target is still wanted", async () => {
-  const { manager, dirPath } = await managerAfterSeek();
-
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(SEGMENT_AT_SEEK).padStart(5, "0")}.mp4`),
-    true,
-    "this is the segment the viewer is waiting for; refusing it is what froze the field session"
-  );
-
-  await rm(dirPath, { recursive: true, force: true });
-});
-
-test("a segment behind the viewer is not wanted any more", async () => {
-  const { manager, dirPath } = await managerAfterSeek();
-
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(SEGMENT_AT_SEEK - 3).padStart(5, "0")}.mp4`),
-    false,
-    "a request for the position the viewer left is exactly what the epoch exists to release"
-  );
-
-  await rm(dirPath, { recursive: true, force: true });
-});
-
-test("a segment far beyond what the run will reach is not wanted", async () => {
-  const { manager, dirPath } = await managerAfterSeek();
-
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(SEGMENT_AT_SEEK + 200).padStart(5, "0")}.mp4`),
-    false,
-    "nothing will produce it before the viewer moves again"
-  );
-
-  await rm(dirPath, { recursive: true, force: true });
-});
-
-test("a playlist belongs to no position and is never stale", async () => {
-  const { manager, dirPath } = await managerAfterSeek();
-
-  assert.equal(manager.serving.requestStillWanted(SESSION_ID, "index.m3u8"), true);
-  assert.equal(manager.serving.requestStillWanted(SESSION_ID, "init.mp4"), true);
-
-  await rm(dirPath, { recursive: true, force: true });
-});
-
-test("a request as deep as the cushion the browser is told to hold is still wanted", async () => {
-  const { manager, dirPath } = await managerAfterSeek();
-
-  // The browser sizes its forward buffer from the proxy's own look-ahead, so
-  // the deepest request it can make is one for the segment at the far edge of
-  // that cushion. Refusing it would be refusing the very depth this proxy
-  // asked for: at the old width — eight segments ahead of the viewer — three
-  // quarters of a full cushion's requests were stale by definition.
-  const edge = Math.floor((SEEK_TO_SECONDS + manager.lookaheadSeconds) / SEGMENT_SECONDS);
-
-  assert.ok(edge - SEGMENT_AT_SEEK > 8, "the case only exists past the old eight-segment width");
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(edge).padStart(5, "0")}.mp4`),
-    true,
-    "the far edge of the cushion the proxy itself keeps produced"
-  );
-
-  await rm(dirPath, { recursive: true, force: true });
-});
-
-test("the viewer who made the request is the one it is judged against", async () => {
-  const { manager, dirPath } = await managerAfterSeek();
-  const session = manager.outputs.get(SESSION_ID);
-  session.viewers = new Map();
-  // Two people watching one copied picture: one at the seek target, one a
-  // hundred segments back and waiting for a segment there. Asked about nobody
-  // in particular the answer is the FURTHEST of them, because what lies behind
-  // that one has already been made.
-  const behind = SEGMENT_AT_SEEK - 100;
-  manager.viewers.of(session, "behind").moveTo(behind * SEGMENT_SECONDS);
-  manager.viewers.of(session, "behind").playing = false;
-  manager.viewers.of(session, "ahead").moveTo(SEEK_TO_SECONDS);
-  manager.viewers.of(session, "ahead").playing = false;
-
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(behind).padStart(5, "0")}.mp4`, "behind"),
-    true,
-    "held for the viewer who is there, whatever the viewer in front is doing"
-  );
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(behind).padStart(5, "0")}.mp4`),
-    false,
-    "unnamed, it is judged against the furthest viewer, which is the leader"
-  );
-
-  await rm(dirPath, { recursive: true, force: true });
-});
-
-test("a seek moves the seeking viewer's own head, and nobody else's", async () => {
-  const { manager, dirPath } = await managerAfterSeek();
-  const session = manager.outputs.get(SESSION_ID);
-  session.viewers = new Map();
-  const staying = SEGMENT_AT_SEEK - 40;
-  manager.viewers.of(session, "staying").position = {
-    segment: staying,
-    seconds: staying * SEGMENT_SECONDS,
-    at: Date.now()
-  };
-
-  const jumpTo = 120;
-  manager.viewerRequests.requestSeek(SESSION_ID, jumpTo, "jumping");
-
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(Math.floor(jumpTo / SEGMENT_SECONDS)).padStart(5, "0")}.mp4`, "jumping"),
-    true,
-    "the segment at the seek target — the request that raced the epoch in 2026-08-18"
-  );
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(staying).padStart(5, "0")}.mp4`, "staying"),
-    true,
-    "somebody else's seek does not move where this viewer is"
-  );
-
-  await rm(dirPath, { recursive: true, force: true });
-});
+/**
+ * @file The segment the viewer just seeked TO must not be refused as stale.
+ *
+ * A seek bumps the wait epoch so that requests made for the position being left
+ * stop being held. The request for the position being ARRIVED at races that
+ * bump: hls.js asks for the new segment within milliseconds, and if the epoch
+ * moves underneath it, the epoch check alone cannot tell the two apart.
+ *
+ * Measured 2026-08-18: the viewer seeked to 1061.0 s, `segment-00101` — the
+ * segment at that very position — was answered 503 twice within 80 ms, the
+ * player never asked for it again, and instead looped `a/0/segment-00103` and
+ * `a/0/segment-00104` 737 and 736 times over 149 seconds while the picture
+ * stood at `t=1061.0s readyState=1`. The session ended without another frame.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+
+const SESSION_ID = "aaaaaaaa11112222";
+const SEGMENT_SECONDS = 10.4;
+const SEEK_TO_SECONDS = 1061;
+const SEGMENT_AT_SEEK = Math.floor(SEEK_TO_SECONDS / SEGMENT_SECONDS);
+
+/**
+ * A session whose viewer has just landed at {@link SEEK_TO_SECONDS}.
+ *
+ * @returns {Promise<{ manager: object, dirPath: string }>}
+ */
+async function managerAfterSeek() {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "seek-target-"));
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const session = {
+    id: SESSION_ID,
+    dirPath,
+    // Where this file is cut, held by the file. A fixture that stated it
+    // on the session was describing what production no longer does.
+    timeline: new Timeline({
+      boundaries: Array.from({ length: 400 }, (_, index) => index * SEGMENT_SECONDS),
+      cutGrid: "uniform"
+    }),
+    state: "ready",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
+    // An ordinary session reads its own file, and its sound is inside it. The
+    // three differ only for a soundtrack shipped as a file of its own.
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
+    startedAt: Date.now(),
+    lastAccessedAt: Date.now(),
+    consumers: new Set(),
+    segmentFormat: fmp4Format,
+    transcodeVideo: false,
+    useSyntheticPlaylist: true,
+    segmentCount: 399,
+    encodeStartIndex: SEGMENT_AT_SEEK,
+    waitEpoch: 1,
+    runState: "PRODUCING"
+  };
+  manager.outputs.set(SESSION_ID, session);
+  manager.viewers.of(session, "viewer").moveTo(SEEK_TO_SECONDS);
+  manager.viewers.of(session, "viewer").playing = false;
+  return { manager, dirPath };
+}
+
+test("the segment at the seek target is still wanted", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+
+  assert.equal(
+    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(SEGMENT_AT_SEEK).padStart(5, "0")}.mp4`),
+    true,
+    "this is the segment the viewer is waiting for; refusing it is what froze the field session"
+  );
+
+  await rm(dirPath, { recursive: true, force: true });
+});
+
+test("a segment behind the viewer is not wanted any more", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+
+  assert.equal(
+    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(SEGMENT_AT_SEEK - 3).padStart(5, "0")}.mp4`),
+    false,
+    "a request for the position the viewer left is exactly what the epoch exists to release"
+  );
+
+  await rm(dirPath, { recursive: true, force: true });
+});
+
+test("a segment far beyond what the run will reach is not wanted", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+
+  assert.equal(
+    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(SEGMENT_AT_SEEK + 200).padStart(5, "0")}.mp4`),
+    false,
+    "nothing will produce it before the viewer moves again"
+  );
+
+  await rm(dirPath, { recursive: true, force: true });
+});
+
+test("a playlist belongs to no position and is never stale", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+
+  assert.equal(manager.serving.requestStillWanted(SESSION_ID, "index.m3u8"), true);
+  assert.equal(manager.serving.requestStillWanted(SESSION_ID, "init.mp4"), true);
+
+  await rm(dirPath, { recursive: true, force: true });
+});
+
+test("a request as deep as the cushion the browser is told to hold is still wanted", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+
+  // The browser sizes its forward buffer from the proxy's own look-ahead, so
+  // the deepest request it can make is one for the segment at the far edge of
+  // that cushion. Refusing it would be refusing the very depth this proxy
+  // asked for: at the old width — eight segments ahead of the viewer — three
+  // quarters of a full cushion's requests were stale by definition.
+  const edge = Math.floor((SEEK_TO_SECONDS + manager.lookaheadSeconds) / SEGMENT_SECONDS);
+
+  assert.ok(edge - SEGMENT_AT_SEEK > 8, "the case only exists past the old eight-segment width");
+  assert.equal(
+    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(edge).padStart(5, "0")}.mp4`),
+    true,
+    "the far edge of the cushion the proxy itself keeps produced"
+  );
+
+  await rm(dirPath, { recursive: true, force: true });
+});
+
+test("the viewer who made the request is the one it is judged against", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+  const session = manager.outputs.get(SESSION_ID);
+  session.viewers = new Map();
+  // Two people watching one copied picture: one at the seek target, one a
+  // hundred segments back and waiting for a segment there. Asked about nobody
+  // in particular the answer is the FURTHEST of them, because what lies behind
+  // that one has already been made.
+  const behind = SEGMENT_AT_SEEK - 100;
+  manager.viewers.of(session, "behind").moveTo(behind * SEGMENT_SECONDS);
+  manager.viewers.of(session, "behind").playing = false;
+  manager.viewers.of(session, "ahead").moveTo(SEEK_TO_SECONDS);
+  manager.viewers.of(session, "ahead").playing = false;
+
+  assert.equal(
+    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(behind).padStart(5, "0")}.mp4`, "behind"),
+    true,
+    "held for the viewer who is there, whatever the viewer in front is doing"
+  );
+  assert.equal(
+    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(behind).padStart(5, "0")}.mp4`),
+    false,
+    "unnamed, it is judged against the furthest viewer, which is the leader"
+  );
+
+  await rm(dirPath, { recursive: true, force: true });
+});
+
+test("a seek moves the seeking viewer's own head, and nobody else's", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+  const session = manager.outputs.get(SESSION_ID);
+  session.viewers = new Map();
+  const staying = SEGMENT_AT_SEEK - 40;
+  manager.viewers.of(session, "staying").position = {
+    segment: staying,
+    seconds: staying * SEGMENT_SECONDS,
+    at: Date.now()
+  };
+
+  const jumpTo = 120;
+  manager.viewerRequests.requestSeek(SESSION_ID, jumpTo, "jumping");
+
+  assert.equal(
+    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(Math.floor(jumpTo / SEGMENT_SECONDS)).padStart(5, "0")}.mp4`, "jumping"),
+    true,
+    "the segment at the seek target — the request that raced the epoch in 2026-08-18"
+  );
+  assert.equal(
+    manager.serving.requestStillWanted(SESSION_ID, `segment-${String(staying).padStart(5, "0")}.mp4`, "staying"),
+    true,
+    "somebody else's seek does not move where this viewer is"
+  );
+
+  await rm(dirPath, { recursive: true, force: true });
+});

package/test/segment-closed-on-both-branches.test.js

@@ -1,96 +1,96 @@
-/**
- * @file A piece is closed by one of two writers, and both must say so.
- *
- * The `segment` muxer writes under a working name and reports the closure on a
- * channel of its own, which reaches `SegmentStore.publish`. The `hls` muxer
- * writes through a temporary name of its own (`+temp_file`) and reports
- * nothing: the file simply appears under the name it is served as. That branch
- * is taken by every re-encoded output cut on the even grid — an ordinary
- * quality step — and for it a wait could only end on its deadline, so a segment
- * lying finished on disk was answered 503 after the whole hold.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-
-const KEY = "torrent:abc:fmt=fmp4:grid=uniform@0:video-only:v=libx264/854x480";
-
-/** A deadline is the backstop of these waits, never what they measure. */
-const BACKSTOP_MS = 10_000;
-
-/**
- * @returns {{ store: SegmentStore, root: string }}
- */
-function storeInATempRoot() {
-  const root = mkdtempSync(path.join(os.tmpdir(), "segment-closed-"));
-  const store = new SegmentStore({ root, logger: { info: () => {}, warn: () => {} } });
-  store.useFormat(KEY, fmp4Format);
-  return { store, root };
-}
-
-test("a piece that simply appears ends the wait that began before it", async (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => {
-    store.dropAll("the test is over");
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  const dir = store.directoryFor(KEY);
-  // The wait begins on a segment nobody has written yet — the cold case, and
-  // the only one the deadline used to decide.
-  const waited = store.waitFor(KEY, 7, BACKSTOP_MS);
-
-  // What the `hls` muxer does: a temporary name of its own, renamed into place
-  // when the piece is whole. Nothing is told; the directory simply moves.
-  const temp = path.join(dir, "segment-00007.mp4.tmp");
-  writeFileSync(temp, Buffer.alloc(64));
-  renameSync(temp, path.join(dir, fmp4Format.segmentFileName(7)));
-
-  assert.equal(await waited, true, "the piece was on disk and the wait did not end");
-  assert.ok(store.pathOf(KEY, 7), "and the store must be able to hand it over");
-});
-
-test("clearing up after a run is not its pieces arriving", async (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => {
-    store.dropAll("the test is over");
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  const dir = store.directoryFor(KEY);
-  const unfinished = path.join(dir, fmp4Format.makingFileNameTemplate("3").replace("%05d", "00009"));
-  writeFileSync(unfinished, Buffer.alloc(64));
-
-  let ended = false;
-  // 200 ms is a grace before asserting that something did NOT happen, which can
-  // only ever pass too easily — never a measurement.
-  const waited = store.waitFor(KEY, 9, 200).then((value) => {
-    ended = value;
-    return value;
-  });
-  rmSync(unfinished, { force: true });
-
-  assert.equal(await waited, false, "a directory that moved because a file went holds nothing new");
-  assert.equal(ended, false);
-});
-
-test("the writer that does report a closure is unaffected", async (t) => {
-  const { store, root } = storeInATempRoot();
-  t.after(() => {
-    store.dropAll("the test is over");
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  const dir = store.directoryFor(KEY);
-  const making = fmp4Format.makingFileNameTemplate("4").replace("%05d", "00004");
-  writeFileSync(path.join(dir, making), Buffer.alloc(64));
-
-  const waited = store.waitFor(KEY, 4, BACKSTOP_MS);
-  assert.equal(store.publish(KEY, making, fmp4Format), fmp4Format.segmentFileName(4));
-  assert.equal(await waited, true);
-});
+/**
+ * @file A piece is closed by one of two writers, and both must say so.
+ *
+ * The `segment` muxer writes under a working name and reports the closure on a
+ * channel of its own, which reaches `SegmentStore.publish`. The `hls` muxer
+ * writes through a temporary name of its own (`+temp_file`) and reports
+ * nothing: the file simply appears under the name it is served as. That branch
+ * is taken by every re-encoded output cut on the even grid — an ordinary
+ * quality step — and for it a wait could only end on its deadline, so a segment
+ * lying finished on disk was answered 503 after the whole hold.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+
+const KEY = "torrent:abc:fmt=fmp4:grid=uniform@0:video-only:v=libx264/854x480";
+
+/** A deadline is the backstop of these waits, never what they measure. */
+const BACKSTOP_MS = 10_000;
+
+/**
+ * @returns {{ store: SegmentStore, root: string }}
+ */
+function storeInATempRoot() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "segment-closed-"));
+  const store = new SegmentStore({ root, logger: { info: () => {}, warn: () => {} } });
+  store.useFormat(KEY, fmp4Format);
+  return { store, root };
+}
+
+test("a piece that simply appears ends the wait that began before it", async (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => {
+    store.dropAll("the test is over");
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  const dir = store.directoryFor(KEY);
+  // The wait begins on a segment nobody has written yet — the cold case, and
+  // the only one the deadline used to decide.
+  const waited = store.waitFor(KEY, 7, BACKSTOP_MS);
+
+  // What the `hls` muxer does: a temporary name of its own, renamed into place
+  // when the piece is whole. Nothing is told; the directory simply moves.
+  const temp = path.join(dir, "segment-00007.mp4.tmp");
+  writeFileSync(temp, Buffer.alloc(64));
+  renameSync(temp, path.join(dir, fmp4Format.segmentFileName(7)));
+
+  assert.equal(await waited, true, "the piece was on disk and the wait did not end");
+  assert.ok(store.pathOf(KEY, 7), "and the store must be able to hand it over");
+});
+
+test("clearing up after a run is not its pieces arriving", async (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => {
+    store.dropAll("the test is over");
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  const dir = store.directoryFor(KEY);
+  const unfinished = path.join(dir, fmp4Format.makingFileNameTemplate("3").replace("%05d", "00009"));
+  writeFileSync(unfinished, Buffer.alloc(64));
+
+  let ended = false;
+  // 200 ms is a grace before asserting that something did NOT happen, which can
+  // only ever pass too easily — never a measurement.
+  const waited = store.waitFor(KEY, 9, 200).then((value) => {
+    ended = value;
+    return value;
+  });
+  rmSync(unfinished, { force: true });
+
+  assert.equal(await waited, false, "a directory that moved because a file went holds nothing new");
+  assert.equal(ended, false);
+});
+
+test("the writer that does report a closure is unaffected", async (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => {
+    store.dropAll("the test is over");
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  const dir = store.directoryFor(KEY);
+  const making = fmp4Format.makingFileNameTemplate("4").replace("%05d", "00004");
+  writeFileSync(path.join(dir, making), Buffer.alloc(64));
+
+  const waited = store.waitFor(KEY, 4, BACKSTOP_MS);
+  assert.equal(store.publish(KEY, making, fmp4Format), fmp4Format.segmentFileName(4));
+  assert.equal(await waited, true);
+});