@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/failed-encoder-still-serves-what-exists.test.js

@@ -1,354 +0,0 @@
-/**
- * @file A failed encoder explains what is MISSING, and takes nothing away.
- *
- * Whether production failed used to be asked at the door, before the request
- * had even been looked at, so an output whose encoding ended in an error
- * answered 500 to every request — including requests for segments it had
- * already finished and which were lying on disk under their served names. The
- * viewer lost what was made as well as what was not, and a seek back into the
- * finished stretch could not be served either.
- *
- * A piece under its served name is whole by construction, whoever wrote it and
- * whatever has become of the encoder since. The failure belongs where a file is
- * absent: there it is the truthful answer, and holding the request instead only
- * spends the viewer's patience.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { rm, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import { Output } from "../services/encode/output/Output.js";
-import { KeyframeTable } from "../services/media/container/KeyframeTable.js";
-import { ENCODE_RUN_STATE } from "../services/encode/encode-run-state.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { EncodeRun } from "../services/encode/EncodeRun.js";
-import { fakeProcess, silentLogger } from "./helpers/encode-run.js";
-import { waitForSessionFile } from "../services/server/transcode-session-files.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const SESSION_ID = "3333333344445555";
-const OUTPUT_KEY = "failed-serves:fmt=fmp4:grid=uniform:video-only:v=0/copy";
-// The other branch: a picture cut at the source's own keyframes, where the
-// muxer is handed the cut times and writes each piece self-contained. It has no
-// init FILE at all — the header is lifted out of the first piece — which is the
-// case `#initFromFirstSegment` answers `null` for instead of throwing `ENOENT`.
-const KEYFRAME_OUTPUT_KEY = "failed-serves-kf:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-
-/**
- * One output with segment #0 finished on disk and its encoder dead.
- *
- * @returns {Promise<{ manager: object, dirPath: string, outputKey: string }>}
- */
-async function outputWhoseEncoderDied({ failed = true, segments = [0], cutsAtGivenTimes = false } = {}) {
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  manager.encodeRuns.planEncodersNow = () => {};
-  manager.encodeRuns.planEncodersSoon = () => {};
-  const outputKey = cutsAtGivenTimes ? KEYFRAME_OUTPUT_KEY : OUTPUT_KEY;
-  manager.segmentStore.useFormat(outputKey, fmp4Format);
-  const dirPath = manager.segmentStore.directoryFor(outputKey);
-  // On the even grid — the branch that writes finished files outright, so their
-  // existence is the proof and the fixture needs no header. The other branch
-  // writes no init file at all.
-  for (const index of segments) {
-    await writeFile(path.join(dirPath, fmp4Format.segmentFileName(index)), Buffer.alloc(256, 0x5a));
-  }
-
-  const session = {
-    id: SESSION_ID,
-    spec: cutsAtGivenTimes
-      ? outputSpec({ transcodeVideo: false, cutGrid: "keyframe" })
-      : outputSpec({ transcodeVideo: true, cutGrid: "uniform" }),
-    outputKey,
-    dirPath,
-    timeline: new Timeline({
-      boundaries: [0, 12.5, 25, 37.5, 50, 62.5],
-      cutGrid: cutsAtGivenTimes ? "keyframe" : "uniform"
-    }),
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }).learn({ durationSeconds: 62.5 }),
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    lastAloneSpeed: 2,
-    startedAt: Date.now(),
-    lastAccessedAt: Date.now(),
-    runs: new Set(),
-    lastError: "",
-    consumers: new Set(),
-    viewers: new Map(),
-    segmentCount: 5,
-    segmentFormat: fmp4Format,
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    output: new Output({ encodeWidth: 0, encodeHeight: 0, outputFps: 25, softwarePreset: null, applyTonemap: false }),
-    keyframes: new KeyframeTable().learn({ times: [0, 12.5, 25, 37.5, 50], format: "matroska" }),
-    audioOnly: false,
-    waitEpoch: 0
-  };
-  manager.outputs.set(SESSION_ID, session);
-  manager.viewers.of(session, "viewer-a").moveTo(0);
-  // The encoder ended for good, which is what every request below is asked
-  // against.
-  if (failed) {
-    manager.encodeOrchestrator.noteEnded({
-      address: outputKey,
-      run: { state: ENCODE_RUN_STATE.ENDED_FAILED },
-      lastError: "ffmpeg exited with code 255"
-    });
-    assert.equal(manager.encodeRuns.hasFailed(session), true, "the fixture must describe a failed output");
-  }
-  return { manager, dirPath, outputKey };
-}
-
-/**
- * Wait until the store really holds a wait for this output.
- *
- * A check that ends a wait it has not yet registered proves nothing: it passes
- * on the code that answers a request AFTER the event just as well as on the code
- * that answers one already standing. The deadline is a backstop, never the
- * measurement.
- *
- * @param {object} store
- * @param {string} key
- * @param {number} [howMany]
- * @returns {Promise<void>}
- */
-async function untilWaitsAreRegistered(store, key, howMany = 1) {
-  const giveUpAt = Date.now() + 5_000;
-  while (store.waitingFor(key) < howMany) {
-    if (Date.now() > giveUpAt) {
-      throw new Error(`no wait registered on ${key} after 5s — the check would prove nothing`);
-    }
-    await new Promise((resolve) => setImmediate(resolve));
-  }
-}
-
-test("a segment that is on disk is served although the encoder failed", async (t) => {
-  const { manager, dirPath } = await outputWhoseEncoderDied();
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  const answer = await manager.serving.getFileStream(SESSION_ID, "segment-00000.mp4", { consumerId: "viewer-a" });
-
-  assert.equal(answer.kind, "file", `what is made is made — the answer was ${answer.kind}`);
-  assert.equal(answer.contentType, fmp4Format.segmentContentType);
-});
-
-test("a segment that is not there says the encoder failed, instead of being held", async (t) => {
-  const { manager, dirPath } = await outputWhoseEncoderDied();
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  const answer = await manager.serving.getFileStream(SESSION_ID, "segment-00003.mp4", { consumerId: "viewer-a" });
-
-  assert.equal(answer.kind, "failed", "nothing is going to write it, and the viewer is owed the reason");
-  assert.match(answer.message, /255/);
-});
-
-test("the playlist is a fact of the timeline and outlives the encoder", async (t) => {
-  const { manager, dirPath } = await outputWhoseEncoderDied();
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  const answer = await manager.serving.getFileStream(SESSION_ID, "index.m3u8", { consumerId: "viewer-a" });
-
-  assert.equal(answer.kind, "file");
-  assert.equal(answer.isPlaylist, true);
-});
-
-test("a failure reaches a request that was ALREADY waiting", async (t) => {
-  // The case the other checks in this file do not reach: they set the failure
-  // and then ask. A wait that began BEFORE it is ended by the publication, by a
-  // wake, by the requester going or by its own deadline — and a failure is none
-  // of those, so it sat out the whole deadline for a piece nothing was going to
-  // make, and where the page states no deadline, until the viewer disconnected.
-  const { manager, dirPath } = await outputWhoseEncoderDied({ failed: false });
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  const session = manager.outputs.get(SESSION_ID);
-  const child = fakeProcess();
-  const run = new EncodeRun({
-    address: OUTPUT_KEY,
-    encoder: { name: "libx264", kind: "software" },
-    from: 3,
-    to: 4,
-    buildArgs: () => [],
-    spawn: () => child,
-    logger: silentLogger,
-    lastSegmentIndex: () => 4,
-    because: "a check asked for it",
-    onEnded: (ended) => manager.encodeRuns.noteRunEnded(session, run, ended)
-  });
-  manager.encodeOrchestrator.adopt(OUTPUT_KEY, run);
-
-  // Held with a deadline long enough that running it out IS the failure.
-  const held = waitForSessionFile(manager.serving, SESSION_ID, "segment-00003.mp4", {
-    holdMs: 30_000,
-    consumerId: "viewer-a"
-  });
-  // The wait must EXIST before it can be said to have been woken.
-  await untilWaitsAreRegistered(manager.segmentStore, OUTPUT_KEY);
-
-  child.exit(255);
-
-  // Bounded, because a regression here would otherwise HANG for the whole
-  // thirty-second hold and take the rest of the file down with it.
-  const answer = await settledWithin(held, 5_000);
-
-  assert.notEqual(answer, STILL_WAITING, "it was left to sit out its whole hold");
-  assert.equal(answer.kind, "failed", "a wait nothing will satisfy must be told");
-});
-
-/** What a race answers when the promise did not settle in time. */
-const STILL_WAITING = Symbol("still waiting");
-
-/**
- * The promise's answer, or {@link STILL_WAITING} if it has not settled yet.
- *
- * Used for BOTH directions, and the direction decides what the bound means. On
- * "it must be told", the bound is a backstop that turns a regression into a
- * failure in seconds instead of a test that hangs until the hold runs out — and
- * a hanging test is worse than an absent one, because it takes the rest of the
- * file down with it (measured here: three checks cancelled by one hang). On
- * "it must go on waiting", the bound IS the grace, and it cannot fail red — it
- * can only pass too easily.
- *
- * @param {Promise<unknown>} promise
- * @param {number} withinMs
- * @returns {Promise<unknown>}
- */
-async function settledWithin(promise, withinMs) {
-  return await Promise.race([
-    promise,
-    new Promise((resolve) => setTimeout(() => resolve(STILL_WAITING), withinMs))
-  ]);
-}
-
-test("a run that exits 0 having produced less than promised also reaches a waiting request", async (t) => {
-  // ffmpeg exits 0 both at the end of the file and when its input stops
-  // delivering, so a run that stopped short claims success. That ending is
-  // terminal all the same — and it was the one branch of the exit handler that
-  // returned before anybody waiting was told.
-  const { manager, dirPath } = await outputWhoseEncoderDied({ failed: false });
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  const session = manager.outputs.get(SESSION_ID);
-  const child = fakeProcess();
-  const run = new EncodeRun({
-    address: OUTPUT_KEY,
-    encoder: { name: "libx264", kind: "software" },
-    from: 3,
-    to: 4,
-    buildArgs: () => [],
-    spawn: () => child,
-    logger: silentLogger,
-    lastSegmentIndex: () => 4,
-    because: "a check asked for it",
-    onEnded: (ended) => manager.encodeRuns.noteRunEnded(session, run, ended)
-  });
-  manager.encodeOrchestrator.adopt(OUTPUT_KEY, run);
-
-  const held = waitForSessionFile(manager.serving, SESSION_ID, "segment-00003.mp4", {
-    holdMs: 30_000,
-    consumerId: "viewer-a"
-  });
-  await untilWaitsAreRegistered(manager.segmentStore, OUTPUT_KEY);
-
-  // Zero, having made none of the two segments it was given.
-  child.exit(0);
-
-  const answer = await settledWithin(held, 5_000);
-
-  assert.equal(manager.encodeRuns.hasFailed(session), true, "stopping short is a failure, not a finished file");
-  assert.notEqual(answer, STILL_WAITING, "it was left to sit out its whole hold");
-  assert.equal(answer.kind, "failed", "a wait nothing will satisfy must be told");
-});
-
-test("one run of two ending in failure tells nobody — the other is still making it", async (t) => {
-  // The condition is the OUTPUT's state, not this run's ending. A run that
-  // failed while another is alive on the same output has not made the segment
-  // unobtainable, so a request for it goes on waiting rather than being handed
-  // an error by the run that lost.
-  const { manager, dirPath } = await outputWhoseEncoderDied({ failed: false });
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  const session = manager.outputs.get(SESSION_ID);
-  const runOf = (from, to, child) => {
-    const run = new EncodeRun({
-      address: OUTPUT_KEY,
-      encoder: { name: "libx264", kind: "software" },
-      from,
-      to,
-      buildArgs: () => [],
-      spawn: () => child,
-      logger: silentLogger,
-      lastSegmentIndex: () => 4,
-      because: "a check asked for it",
-      onEnded: (ended) => manager.encodeRuns.noteRunEnded(session, run, ended)
-    });
-    manager.encodeOrchestrator.adopt(OUTPUT_KEY, run);
-    return run;
-  };
-  const dying = fakeProcess();
-  const working = fakeProcess();
-  runOf(3, 3, dying);
-  runOf(4, 4, working);
-
-  const held = waitForSessionFile(manager.serving, SESSION_ID, "segment-00003.mp4", {
-    holdMs: 30_000,
-    consumerId: "viewer-a"
-  });
-  await untilWaitsAreRegistered(manager.segmentStore, OUTPUT_KEY);
-
-  dying.exit(255);
-
-  assert.equal(
-    manager.encodeRuns.hasFailed(session),
-    false,
-    "the output has not failed while a run is alive on it"
-  );
-  assert.equal(await settledWithin(held, 300), STILL_WAITING, "the request must go on waiting");
-});
-
-test("an init that will never be made says so instead of warming up for ever", async (t) => {
-  // On the branch that lifts the header out of the first piece there is no file
-  // to be missing: `#initFromFirstSegment` answers null rather than throwing, so
-  // the catch that names a failure is never reached and the answer was always
-  // "still warming up".
-  //
-  // THE FIXTURE MUST BE ON THAT BRANCH, and it was not: with a re-encode on the
-  // even grid `cutsAtGivenTimes` is false, so the check read a missing init
-  // FILE and exercised the `ENOENT` path instead — the one that was never
-  // broken. A copy cut at the source's own keyframes is the configuration that
-  // writes no init file at all.
-  const { manager, dirPath } = await outputWhoseEncoderDied({ segments: [], cutsAtGivenTimes: true });
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  const answer = await manager.serving.getFileStream(SESSION_ID, "init.mp4", { consumerId: "viewer-a" });
-
-  assert.equal(answer.kind, "failed", "nothing is going to produce the header it would come from");
-  assert.match(answer.message, /255/);
-});

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

@@ -1,202 +0,0 @@
-/**
- * @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 { wireOutputs } from "../services/server/wire-outputs.js";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const SESSION_ID = "cccccccc00004000";
-
-/**
- * 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,
-    spec: outputSpec({ transcodeVideo: false }),
-    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",
-    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 = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const { session, run } = sessionWithARun(dirPath);
-  manager.outputs.set(SESSION_ID, session);
-  manager.encodeOrchestrator.adopt(session.outputKey, run);
-
-  manager.encodeRuns.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(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, 1, "the failure was counted");
-  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).at, 0, "at the position it happened");
-  assert.ok(manager.encodeOrchestrator.errorOf(session.outputKey).length > 0, "and the encoding owner knows what went wrong");
-  assert.equal(
-    manager.encodeOrchestrator.stateOf(session.outputKey),
-    "ENDED_FAILED",
-    "the ending remains observable after the ended run leaves the registry"
-  );
-});
-
-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 = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const { session } = sessionWithARun(dirPath);
-  manager.outputs.set(SESSION_ID, session);
-
-  for (let attempt = 1; attempt <= 3; attempt += 1) {
-    const run = { from: 0, to: -1, argsDescribed: "ffmpeg …" };
-    manager.encodeOrchestrator.adopt(session.outputKey, run);
-    manager.encodeRuns.noteRunEnded(session, run, failedFast(run, 0));
-    assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, attempt);
-    assert.equal(manager.encodeOrchestrator.mayStartAt(session.outputKey, 0), attempt < 3);
-  }
-  assert.equal(manager.encodeOrchestrator.mayStartAt(session.outputKey, 1), true, "another position has its own budget");
-});
-
-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 = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const { session } = sessionWithARun(dirPath);
-  manager.outputs.set(SESSION_ID, session);
-
-  const quick = { from: 0, to: -1 };
-  manager.encodeOrchestrator.adopt(session.outputKey, quick);
-  manager.encodeRuns.noteRunEnded(session, quick, failedFast(quick, 0));
-  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, 1);
-
-  const lived = { from: 0, to: -1 };
-  manager.encodeOrchestrator.adopt(session.outputKey, lived);
-  manager.encodeRuns.noteRunEnded(session, lived, { ...failedFast(lived, 0), livedMs: 30_000 });
-
-  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, 0, "a run that did real work is not a failing start");
-  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).at, -1);
-});
-
-test("a failure belongs to the output it happened on, not to the next output of the same address", async (t) => {
-  const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
-  t.after(() => rmSync(dirPath, { recursive: true, force: true }));
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  t.after(() => manager.lifecycle.disposeAll());
-  const { session } = sessionWithARun(dirPath);
-  manager.outputs.set(SESSION_ID, session);
-  for (let attempt = 1; attempt <= 3; attempt += 1) {
-    const run = { from: 0, to: -1, argsDescribed: "ffmpeg …" };
-    manager.encodeOrchestrator.adopt(session.outputKey, run);
-    manager.encodeRuns.noteRunEnded(session, run, failedFast(run, 0));
-  }
-  assert.equal(manager.encodeOrchestrator.mayStartAt(session.outputKey, 0), false, "the first output is blocked");
-
-  await manager.lifecycle.disposeSession(SESSION_ID);
-
-  // The same parameters opened again: the name follows from the key, so the
-  // new output has the same address. What failed on the disposed one is not a
-  // fact about this one — a viewer arriving is new information.
-  assert.equal(manager.encodeOrchestrator.stateOf(session.outputKey), "IDLE", "no ending is inherited");
-  assert.equal(manager.encodeOrchestrator.errorOf(session.outputKey), "", "no error is inherited");
-  assert.equal(manager.encodeOrchestrator.mayStartAt(session.outputKey, 0), true, "no blocked position is inherited");
-});
-
-test("a run ending after its output was disposed leaves nothing behind for the next output", (t) => {
-  const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
-  t.after(() => rmSync(dirPath, { recursive: true, force: true }));
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const { session, run } = sessionWithARun(dirPath);
-  manager.encodeOrchestrator.adopt(session.outputKey, run);
-  // Disposal removed the output from the registry; its process ends later.
-  manager.encodeRuns.noteRunEnded(session, run, failedFast(run, 0));
-
-  assert.equal(manager.encodeOrchestrator.stateOf(session.outputKey), "IDLE");
-  assert.equal(manager.encodeOrchestrator.errorOf(session.outputKey), "");
-  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, 0);
-});