@torrent-tv/proxy 2.76.6 → 2.78.0

package/services/viewer/Viewers.js

@@ -1,124 +1,213 @@
-/**
- * @file Every viewer this proxy has met, one object per person.
- *
- * A viewer used to be made per SESSION: the same person watching a picture, a
- * quality step and a soundtrack was three objects, each with its own copy of
- * what that person had chosen and where they were. Two of those copies were
- * always wrong, and the field that says which outputs a person is watching was
- * worse than wrong — being per session, each copy could only ever hold the id
- * of the session that owned it, so it carried no information at all and the one
- * place that read it could learn nothing from it.
- *
- * One person is one object here, keyed by the consumer id the browser sends.
- * That id is minted once per film opened in the page, so one id is one person
- * watching one film, and sharing the object cannot conflate two films.
- *
- * The relation "this person watches this output" is indexed both ways — the
- * output holds its viewers, the viewer holds its outputs — because it is asked
- * from both ends, and both indexes are written here and nowhere else.
- */
-
-import { Viewer, viewersOf } from "./Viewer.js";
-
-export class Viewers {
-  /**
-   * One object per named viewer. An unnamed one is not in here: a viewer that
-   * cannot say who it is is not the same viewer as another that cannot, so it
-   * belongs to the session that met it and to no one else.
-   *
-   * @type {Map<string, Viewer>}
-   */
-  #byId = new Map();
-
-  /**
-   * This viewer, watching this output.
-   *
-   * Both directions of the relation are written here. Asking for a viewer of an
-   * output IS the statement that they are watching it: every caller either
-   * records where they are, what they chose, or what is being prepared for
-   * them, and each of those is only true of somebody watching.
-   *
-   * @param {object} output - A session.
-   * @param {string} consumerId
-   * @returns {Viewer}
-   */
-  of(output, consumerId) {
-    const viewers = viewersOf(output);
-    const known = viewers.get(consumerId);
-    if (known) {
-      known.outputs.add(output.id);
-      return known;
-    }
-    const viewer = consumerId
-      ? this.#byId.get(consumerId) ?? new Viewer(consumerId)
-      : new Viewer("");
-    if (consumerId) {
-      this.#byId.set(consumerId, viewer);
-    }
-    viewers.set(consumerId, viewer);
-    viewer.outputs.add(output.id);
-    return viewer;
-  }
-
-  /**
-   * The viewer with this id, or null when nobody by that name is watching
-   * anything. Never makes one.
-   *
-   * @param {string} consumerId
-   * @returns {Viewer | null}
-   */
-  get(consumerId) {
-    return this.#byId.get(consumerId) ?? null;
-  }
-
-  /**
-   * The outputs this viewer is watching, as ids, copied so that leaving them
-   * can be walked without mutating what is being walked.
-   *
-   * @param {object} anyOutput - A session they are known to, for an unnamed
-   *   viewer whose record lives on that session alone.
-   * @param {string} consumerId
-   * @returns {string[]}
-   */
-  watching(anyOutput, consumerId) {
-    const viewer = consumerId
-      ? this.#byId.get(consumerId)
-      : viewersOf(anyOutput).get("");
-    return viewer ? [...viewer.outputs] : [];
-  }
-
-  /**
-   * This viewer is no longer watching this output.
-   *
-   * Both directions again, and the viewer itself is forgotten once it is
-   * watching nothing — otherwise the registry would be a map that only grows,
-   * which is the shape of half the memory faults recorded in this repository.
-   *
-   * @param {object} output - A session.
-   * @param {string} consumerId
-   * @returns {boolean} Whether they were watching it.
-   */
-  leaves(output, consumerId) {
-    const viewers = viewersOf(output);
-    const viewer = viewers.get(consumerId);
-    if (!viewer) {
-      return false;
-    }
-    viewers.delete(consumerId);
-    viewer.outputs.delete(output.id);
-    if (consumerId && viewer.outputs.size === 0) {
-      this.#byId.delete(consumerId);
-    }
-    return true;
-  }
-
-  /**
-   * How many named viewers are watching anything. For the log line and for a
-   * check that the registry does not grow.
-   *
-   * @returns {number}
-   */
-  get size() {
-    return this.#byId.size;
-  }
-}
+/**
+ * @file Every viewer this proxy has met, one object per person.
+ *
+ * A viewer used to be made per SESSION: the same person watching a picture, a
+ * quality step and a soundtrack was three objects, each with its own copy of
+ * what that person had chosen and where they were. Two of those copies were
+ * always wrong, and the field that says which outputs a person is watching was
+ * worse than wrong — being per session, each copy could only ever hold the id
+ * of the session that owned it, so it carried no information at all and the one
+ * place that read it could learn nothing from it.
+ *
+ * One person is one object here, keyed by the consumer id the browser sends.
+ * That id is minted once per film opened in the page, so one id is one person
+ * watching one film, and sharing the object cannot conflate two films.
+ *
+ * The relation "this person watches this output" is indexed both ways — the
+ * output holds its viewers, the viewer holds its outputs — because it is asked
+ * from both ends, and both indexes are written here and nowhere else.
+ *
+ * **Every change here announces itself.** What encoders should exist is decided
+ * from what viewers want, so a viewer arriving, moving or leaving is a change
+ * to that decision's input. Until 2026-09-05 the decision was instead re-taken
+ * on a five-second timer, which meant a newly created output waited up to five
+ * seconds for anybody to notice it had a viewer at all — and the timer's period
+ * was also the period of a restart loop that ran for sixteen minutes. The
+ * registry does not know what to do about a change; it only says that one
+ * happened.
+ */
+
+import { Viewer, viewersOf } from "./Viewer.js";
+
+export class Viewers {
+  /**
+   * One object per named viewer. An unnamed one is not in here: a viewer that
+   * cannot say who it is is not the same viewer as another that cannot, so it
+   * belongs to the session that met it and to no one else.
+   *
+   * @type {Map<string, Viewer>}
+   */
+  #byId = new Map();
+
+  /** @type {() => void} */
+  #onChange;
+
+  /**
+   * @param {object} [params]
+   * @param {() => void} [params.onChange] - Called after the relation changes:
+   *   a viewer joined an output, or left one. Says only that something moved.
+   */
+  constructor({ onChange } = {}) {
+    this.#onChange = typeof onChange === "function" ? onChange : () => {};
+  }
+
+  /**
+   * This viewer, watching this output.
+   *
+   * Both directions of the relation are written here. Asking for a viewer of an
+   * output IS the statement that they are watching it: every caller either
+   * records where they are, what they chose, or what is being prepared for
+   * them, and each of those is only true of somebody watching. It is also
+   * evidence that they are still there, so it refreshes presence.
+   *
+   * @param {object} output - A session.
+   * @param {string} consumerId
+   * @param {number} [now]
+   * @returns {Viewer}
+   */
+  of(output, consumerId, now = Date.now()) {
+    const viewers = viewersOf(output);
+    const known = viewers.get(consumerId);
+    if (known) {
+      known.seen(now);
+      // Asking again is not a return from the dead, but it IS evidence, and a
+      // viewer marked gone whose id turns up again is a viewer who came back.
+      known.gone = false;
+      const wasWatching = known.outputs.has(output.id);
+      known.outputs.add(output.id);
+      if (!wasWatching) {
+        this.#onChange();
+      }
+      return known;
+    }
+    const viewer = consumerId
+      ? this.#byId.get(consumerId) ?? new Viewer(consumerId, now)
+      : new Viewer("", now);
+    viewer.seen(now);
+    viewer.gone = false;
+    if (consumerId) {
+      this.#byId.set(consumerId, viewer);
+    }
+    viewers.set(consumerId, viewer);
+    viewer.outputs.add(output.id);
+    this.#onChange();
+    return viewer;
+  }
+
+  /**
+   * The viewer with this id, or null when nobody by that name is watching
+   * anything. Never makes one.
+   *
+   * @param {string} consumerId
+   * @returns {Viewer | null}
+   */
+  get(consumerId) {
+    return this.#byId.get(consumerId) ?? null;
+  }
+
+  /**
+   * The outputs this viewer is watching, as ids, copied so that leaving them
+   * can be walked without mutating what is being walked.
+   *
+   * @param {object} anyOutput - A session they are known to, for an unnamed
+   *   viewer whose record lives on that session alone.
+   * @param {string} consumerId
+   * @returns {string[]}
+   */
+  watching(anyOutput, consumerId) {
+    const viewer = consumerId
+      ? this.#byId.get(consumerId)
+      : viewersOf(anyOutput).get("");
+    return viewer ? [...viewer.outputs] : [];
+  }
+
+  /**
+   * This viewer is no longer watching this output.
+   *
+   * Both directions again, and the viewer itself is forgotten once it is
+   * watching nothing — otherwise the registry would be a map that only grows,
+   * which is the shape of half the memory faults recorded in this repository.
+   *
+   * @param {object} output - A session.
+   * @param {string} consumerId
+   * @returns {boolean} Whether they were watching it.
+   */
+  leaves(output, consumerId) {
+    const viewers = viewersOf(output);
+    const viewer = viewers.get(consumerId);
+    if (!viewer) {
+      return false;
+    }
+    viewers.delete(consumerId);
+    viewer.outputs.delete(output.id);
+    if (viewer.outputs.size === 0) {
+      // Watching nothing at all: this is a statement that they are gone, and
+      // not merely that this one output is no longer theirs.
+      viewer.gone = true;
+      if (consumerId) {
+        this.#byId.delete(consumerId);
+      }
+    }
+    this.#onChange();
+    return true;
+  }
+
+  /**
+   * Everything this viewer is watching, let go of at once, because their
+   * connection said they are gone.
+   *
+   * The transport knows a viewer has left before any output does, and it knows
+   * it about the PERSON rather than about one of the three outputs the browser
+   * happens to hold an id for. This is the door that fact comes through.
+   *
+   * @param {string} consumerId
+   * @param {(outputId: string) => object | null} outputById - How to find an
+   *   output by id. The registry holds ids, not sessions.
+   * @returns {string[]} The outputs they were watching.
+   */
+  hasGone(consumerId, outputById) {
+    const viewer = consumerId ? this.#byId.get(consumerId) : null;
+    if (!viewer) {
+      return [];
+    }
+    const left = [...viewer.outputs];
+    for (const outputId of left) {
+      const output = typeof outputById === "function" ? outputById(outputId) : null;
+      if (output) {
+        viewersOf(output).delete(consumerId);
+      }
+    }
+    viewer.outputs.clear();
+    viewer.gone = true;
+    this.#byId.delete(consumerId);
+    this.#onChange();
+    return left;
+  }
+
+  /**
+   * Note that this viewer has been heard from, wherever the evidence came from
+   * — a request, a link report, an echo of a delivery probe.
+   *
+   * @param {string} consumerId
+   * @param {number} [now]
+   * @returns {boolean} Whether anybody by that name is known.
+   */
+  seen(consumerId, now = Date.now()) {
+    const viewer = consumerId ? this.#byId.get(consumerId) : null;
+    if (!viewer) {
+      return false;
+    }
+    viewer.seen(now);
+    return true;
+  }
+
+  /**
+   * How many named viewers are watching anything. For the log line and for a
+   * check that the registry does not grow.
+   *
+   * @returns {number}
+   */
+  get size() {
+    return this.#byId.size;
+  }
+}

package/test/behind-head-repair.test.js

@@ -66,8 +66,8 @@ async function managerWithRunAhead() {
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     lastRestartAt: 0,
-    seekFailureTarget: -1,
-    seekFailureCount: 0,
+    failedStartAt: -1,
+    failedStartCount: 0,
     seekSettleTimer: null,
     seekTarget: null,
     waitEpoch: 0,

package/test/demand-map.test.js

@@ -0,0 +1,102 @@
+/**
+ * @file A map per viewer, merged into one, in the order the work is taken.
+ *
+ * In seconds of film throughout: it is the only unit every term of the
+ * arithmetic is already stated in, and the one two consumers with different
+ * states can both be translated from.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mapForViewer, mergeMaps, inWorkingOrder } from "../services/encode/DemandMap.js";
+
+test("a viewer's own position is the most urgent thing there is", () => {
+  const map = mapForViewer({
+    atSeconds: 100,
+    durationSeconds: 1000,
+    allowanceSeconds: 8,
+    encodeSpeedX: 2
+  });
+
+  assert.equal(map[0].from, 100);
+  assert.equal(map[0].to, 108, "above realtime, only the measured allowance");
+  for (const zone of map.slice(1)) {
+    assert.ok(zone.priority < map[0].priority);
+  }
+});
+
+test("a machine that cannot keep up must have more ready before the viewer sets off", () => {
+  // 900s of film in front. At 0.25x the encoder loses three seconds of film per
+  // second played, so 675s must exist first, or the viewer stalls partway.
+  const slow = mapForViewer({ atSeconds: 100, durationSeconds: 1000, allowanceSeconds: 0, encodeSpeedX: 0.25 });
+  const fast = mapForViewer({ atSeconds: 100, durationSeconds: 1000, allowanceSeconds: 0, encodeSpeedX: 2 });
+
+  assert.equal(slow[0].to, 775, "100 + 900 x 0.75");
+  assert.ok(
+    slow[0].to - slow[0].from > fast[0].to - fast[0].from,
+    "the slower the machine, the more of the film must be made in advance"
+  );
+});
+
+test("the allowance is added to the shortfall, not chosen instead of it", () => {
+  const map = mapForViewer({ atSeconds: 0, durationSeconds: 100, allowanceSeconds: 10, encodeSpeedX: 0.5 });
+
+  assert.equal(map[0].to, 60, "50s of shortfall plus 10s of measured allowance");
+});
+
+test("the rest of the track is still wanted, and wanted last", () => {
+  const map = mapForViewer({ atSeconds: 0, durationSeconds: 1000, allowanceSeconds: 4, encodeSpeedX: 2 });
+
+  assert.equal(map[map.length - 1].to, 1000, "the map reaches the end of the film");
+  assert.ok(map[map.length - 1].priority > 0, "and the far end is still wanted");
+  let previousEnd = 0;
+  for (const zone of map) {
+    assert.equal(zone.from, previousEnd, "no gaps and no overlaps");
+    previousEnd = zone.to;
+  }
+});
+
+test("nothing is measured yet: the middle zone is left out rather than invented", () => {
+  const map = mapForViewer({ atSeconds: 0, durationSeconds: 100, allowanceSeconds: 4, encodeSpeedX: 0 });
+
+  assert.equal(map.length, 2, "what must be ready, and the rest");
+});
+
+test("two viewers merge to the highest priority per second, with no overlaps", () => {
+  const first = mapForViewer({ atSeconds: 0, durationSeconds: 1000, allowanceSeconds: 8, encodeSpeedX: 2 });
+  const second = mapForViewer({ atSeconds: 500, durationSeconds: 1000, allowanceSeconds: 8, encodeSpeedX: 2 });
+
+  const merged = mergeMaps([first, second]);
+
+  let previousEnd = merged[0].from;
+  for (const zone of merged) {
+    assert.equal(zone.from, previousEnd, "no gaps and no overlaps");
+    previousEnd = zone.to;
+  }
+  const priorityAt = (at) => merged.find((zone) => at >= zone.from && at < zone.to)?.priority;
+  assert.equal(priorityAt(0), priorityAt(500), "both viewers' own positions are equally urgent");
+  assert.ok(priorityAt(500) > priorityAt(300), "a viewer at 500 outranks the far zone of the one at 0");
+});
+
+test("the second viewer's position is not buried under the first viewer's far zone", () => {
+  // The case that used to leave a viewer opening the same film further in with
+  // no encoder at all, because the first run claimed everything in front of it.
+  const first = mapForViewer({ atSeconds: 0, durationSeconds: 4000, allowanceSeconds: 8, encodeSpeedX: 2 });
+  const second = mapForViewer({ atSeconds: 2000, durationSeconds: 4000, allowanceSeconds: 8, encodeSpeedX: 2 });
+
+  const order = inWorkingOrder(mergeMaps([first, second]));
+  const firstTwo = order.slice(0, 2).map((zone) => zone.from);
+
+  assert.ok(firstTwo.includes(0), "the first viewer's own position is taken first");
+  assert.ok(firstTwo.includes(2000), "so is the second viewer's, before anything less urgent");
+});
+
+test("within one priority the earliest film goes first — that is where somebody is stopped", () => {
+  const order = inWorkingOrder([
+    { from: 900, to: 1000, priority: 2 },
+    { from: 100, to: 200, priority: 2 },
+    { from: 0, to: 10, priority: 3 }
+  ]);
+
+  assert.deepEqual(order.map((zone) => zone.from), [0, 100, 900]);
+});

package/test/encode-plan.test.js

@@ -176,7 +176,12 @@ test("every encoder stops when nobody is watching the output", () => {
   );
 });
 
-test("a run making material nobody asked for is stopped", () => {
+test("a run standing outside every window keeps working: the file is encoded whole", () => {
+  // The rule, stated by the user 2026-09-05: while a file is being encoded it
+  // is encoded whole, and a viewer decides the ORDER, not whether a run may
+  // live. Stopping a run for standing outside a window is what produced the
+  // field oscillation of that day — placed by one rule, killed by another,
+  // 350-700ms per cycle, nothing ever produced.
   const coverage = new CoverageMap({ segmentCount: 1000 });
   const runA = run({ from: 500, to: 600, head: 520 });
   coverage.claim(runA, 500, 600);
@@ -186,7 +191,44 @@ test("a run making material nobody asked for is stopped", () => {
     runs: [runA],
     ...HOST
   });
-  assert.ok(actions.some((action) => action.type === "stop" && action.run === runA));
+  assert.ok(
+    !actions.some((action) => action.type === "stop" && action.run === runA),
+    "it is making film that will be wanted, and nothing else is making it"
+  );
+});
+
+test("the same plan run twice on an unchanged state gives the same answer", () => {
+  // What the oscillation actually was: two passes over one state disagreeing
+  // with each other. Nothing about the state changes between them here.
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const runA = run({ from: 500, to: 600, head: 520 });
+  coverage.claim(runA, 500, 600);
+  const input = { coverage, windows: [{ from: 0, to: 40 }], runs: [runA], ...HOST };
+
+  const first = planEncoders(input).map((action) => action.type);
+  const second = planEncoders(input).map((action) => action.type);
+
+  assert.deepEqual(first, second);
+  assert.ok(!first.includes("stop"), "and neither pass kills what the other would start");
+});
+
+test("a viewer's most urgent zone is filled before a less urgent one", () => {
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const actions = planEncoders({
+    coverage,
+    // The far zone is lower in number and lower in priority: the order must
+    // come from the priority, not from the number.
+    windows: [
+      { from: 0, to: 100, priority: 1 },
+      { from: 500, to: 530, priority: 3 }
+    ],
+    runs: [],
+    ...HOST,
+    maxRuns: 1
+  });
+  const started = actions.filter((action) => action.type === "start").map((action) => action.from);
+
+  assert.deepEqual(started, [500], "the one machine goes where somebody is stopped");
 });
 
 test("two viewers far apart get an encoder each, when the machine can hold two", () => {

package/test/failed-start-breaker.test.js

@@ -0,0 +1,151 @@
+/**
+ * @file A start that cannot succeed must not be commanded for ever.
+ *
+ * Two defects met here on 2026-09-05, and only together did they produce an
+ * unbounded loop.
+ *
+ * The first is older than the second and had never once run: `#onRunEnded`
+ * removed the run from the session and THEN asked whether the run was still the
+ * session's, a question that always answers "no" after the removal. Everything
+ * below that point was unreachable — the fallback from a failed hardware
+ * encoder to software, the retry when the torrent data goes away, the limit on
+ * retrying a position that keeps failing, and the error line naming the ffmpeg
+ * command. Measured over both of the field host's log files: zero occurrences
+ * of that error line and zero of `fast failure at segment`, across every
+ * session that proxy had ever run.
+ *
+ * The second is that the limit only counted past segment #0, because it was
+ * written for seek restarts and a seek is never to the beginning — leaving the
+ * one position the plan commands first with no count at all.
+ *
+ * With what encoders should exist re-decided on a five-second timer, the two
+ * showed up as a restart every five seconds, for sixteen minutes, in the field.
+ * Re-decided the moment its inputs change, they show up as a loop as fast as
+ * spawning can fail: fifty passes of the plan before a probe stopped it.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { SourceFile } from "../services/source/SourceFile.js";
+import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
+
+const SESSION_ID = "cccccccc-0000-4000-8000-000000000001";
+
+/**
+ * A session with one run in it, shaped as the manager expects.
+ *
+ * @param {string} dirPath
+ * @returns {{ session: object, run: object }}
+ */
+function sessionWithARun(dirPath) {
+  const run = { from: 0, to: -1, argsDescribed: "ffmpeg …", state: "ENDED_FAILED" };
+  const session = {
+    id: SESSION_ID,
+    dirPath,
+    state: "live",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
+    outputKey: "output-under-test",
+    consumers: new Set(["someone"]),
+    viewers: new Map(),
+    runs: new Set([run]),
+    transcodeVideo: false,
+    failedStartAt: -1,
+    failedStartCount: 0,
+    lastError: "",
+    lastRequestedSegment: 0,
+    progress: { updatedAt: 0, processedSeconds: 0, totalSeconds: 100, startPositionSeconds: 0 },
+    lastAccessedAt: Date.now()
+  };
+  return { session, run };
+}
+
+/**
+ * @param {object} run
+ * @param {number} from
+ * @returns {object}
+ */
+function failedFast(run, from) {
+  return {
+    address: "output-under-test",
+    run,
+    ending: ENCODE_EXIT.FAILED,
+    from,
+    to: -1,
+    livedMs: 20,
+    because: "the process could not be started: spawn ffmpeg ENOENT",
+    lastError: "the process could not be started: spawn ffmpeg ENOENT",
+    producedCount: 0
+  };
+}
+
+test("a run that ended is still recognised as the session's own", (t) => {
+  const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
+  t.after(() => rmSync(dirPath, { recursive: true, force: true }));
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const { session, run } = sessionWithARun(dirPath);
+  manager.sessionsById.set(SESSION_ID, session);
+
+  manager.noteRunEnded(session, run, failedFast(run, 0));
+
+  // If the identity were read after the removal, nothing here would have been
+  // written: the handler would have returned at its second line.
+  assert.equal(session.failedStartCount, 1, "the failure was counted");
+  assert.equal(session.failedStartAt, 0, "at the position it happened");
+  assert.ok(session.lastError.length > 0, "and the session knows what went wrong");
+});
+
+test("the count runs at segment 0, which is where a first start happens", (t) => {
+  const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
+  t.after(() => rmSync(dirPath, { recursive: true, force: true }));
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const { session } = sessionWithARun(dirPath);
+  manager.sessionsById.set(SESSION_ID, session);
+
+  for (let attempt = 1; attempt <= 3; attempt += 1) {
+    const run = { from: 0, to: -1, argsDescribed: "ffmpeg …" };
+    session.runs.add(run);
+    manager.noteRunEnded(session, run, failedFast(run, 0));
+    assert.equal(session.failedStartCount, attempt);
+  }
+});
+
+test("real work resets the count, so a transient failure is not permanent", (t) => {
+  const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
+  t.after(() => rmSync(dirPath, { recursive: true, force: true }));
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const { session } = sessionWithARun(dirPath);
+  manager.sessionsById.set(SESSION_ID, session);
+
+  const quick = { from: 0, to: -1 };
+  session.runs.add(quick);
+  manager.noteRunEnded(session, quick, failedFast(quick, 0));
+  assert.equal(session.failedStartCount, 1);
+
+  const lived = { from: 0, to: -1 };
+  session.runs.add(lived);
+  manager.noteRunEnded(session, lived, { ...failedFast(lived, 0), livedMs: 30_000 });
+
+  assert.equal(session.failedStartCount, 0, "a run that did real work is not a failing start");
+  assert.equal(session.failedStartAt, -1);
+});