@torrent-tv/proxy 2.12.0 → 2.12.2

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 2.12.2
+
+- **Fix**: The transport heartbeat is written once per connection, with each channel's queue beside it. The counters it reports belong to the peer connection, not to a channel, so printing the line per channel produced two byte-for-byte identical readings — `sent=5153491` under both "proxy" and "proxy-control" on 2026-08-14 — which read as two independent measurements agreeing. The one figure that IS per channel, its queue depth, was the only real difference and was buried in a line that looked like a duplicate, leaving the second channel unobservable in the log.
+- **Fix**: A channel watch ends when the transport stops knowing about its session, not only when the channel reports itself closed. The close callback is the ordinary way it ends and it does not always arrive — a peer connection can die without one — leaving a timer sampling a session that no longer exists for the life of the process.
+- **Chore**: `host-timings.json` is no longer under version control, and no longer ships in the package. It is runtime state the proxy rewrites every session, so it arrived in every diff, would have carried one developer machine's medians into every published version, and would have conflicted on every release.
+
+## 2.12.1
+
+- **Fix**: The grid a copied stream is cut on now describes the FILE, not the container's index. A copy can only be cut where a keyframe already is, and nothing cheaper than the index can say where that is before a byte is encoded — but an index can be wrong. Reproduced 2026-08-12 against one file, both ways: with an honest index every produced segment started exactly where declared; with the index moved 1.8 s, every segment started 1.8 s early and matched no boundary at all. The field showed the second shape, so the mechanism was never at fault and the data was. The truth arrives anyway, one segment at a time — a produced piece states where it really begins — and it is now written back into the grid, which the whole family shares. That is what lets a re-encoded rung be cut to match a copied one: it is forced onto times the copy really uses. A correction that would cross its neighbours is refused, since that is a reading from a run that began somewhere else.
+- **Fix**: A warm-up is no longer cancelled by the stream that is still playing. The cancellation stood before the check for whether the active rung had actually changed, and the rung on screen asks for its own segments every few seconds — so the rung being prepared was stopped 117 ms and 1.5 s after two warm-ups began (measured 2026-08-12), and the viewer then waited out the full thirty-second warm-up for a segment nobody was making, and waited again for the switch. One switch took 43.6 s.
+- **Fix**: Warming the height the base session itself serves repositions it. It was skipped because it "is the base", but the base is parked wherever the viewer left it with its encoder stopped: warming 400p found it still at `run from #0`, so the switch had nothing to fetch.
+- **Fix**: Repositioning inside this class names the session it means. `requestSeek` forwards to the rung on screen, which is right for the browser — it knows only the base id — and wrong for everything internal: warming a rung moved the rung already playing instead. Split into the public forwarding call and an internal literal one.
+
 ## 2.12.0
 
 - **Fix**: A rung warmed for a switch the viewer did not make is stopped. Only becoming active stopped the rung being left, so trying two rungs in a row left the first encoding for nobody — three encoders at once on a host sized for one, which is the opposite of what warming is for.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.12.0",
+  "version": "2.12.2",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/data-channel-handler.js

@@ -103,10 +103,73 @@
  * @returns {() => void} Stops the watch.
  */
 function makeSendQueueWatcher({ log, getTransportSnapshot }) {
+  // Every channel of one connection reads the SAME transport counters — the
+  // snapshot describes the peer connection, not the channel — so the heartbeat
+  // belongs to the connection and is printed once for it. Printed per channel
+  // it produced two byte-for-byte identical lines (measured 2026-08-14:
+  // `sent=5153491` under both "proxy" and "proxy-control"), which read as two
+  // independent readings agreeing and made the second channel invisible: the
+  // one thing that IS per channel, its queue depth, was the only real
+  // difference and it was buried in a line that looked like a duplicate.
+  //
+  // sessionId → the channels currently open on that connection, and when it was
+  // last reported. Channels are keyed by the channel OBJECT, not by its label:
+  // a label is whatever the peer chose and two channels can carry the same one
+  // (or none, where `getLabel` is missing and both fall back to "?"), and a
+  // Map keyed on that would let one channel evict the other and then, on
+  // closing, delete the survivor's entry.
+  /** @type {Map<string, { channels: Map<DataChannel, string>, at: number, previous: object | null, unknown: number }>} */
+  const connections = new Map();
+
+  /**
+   * What each channel of a connection is holding, right now.
+   *
+   * @param {Map<DataChannel, string>} channels
+   * @returns {string} `label:NB` per channel, in the order they opened.
+   */
+  const queueDepths = (channels) => {
+    const parts = [];
+    for (const [openChannel, channelLabel] of channels) {
+      let depth = -1;
+      try {
+        depth = typeof openChannel.bufferedAmount === "function" ? openChannel.bufferedAmount() : 0;
+      } catch {
+        depth = -1;
+      }
+      parts.push(`${channelLabel}:${depth}B`);
+    }
+    return parts.join(" ");
+  };
+
   return function watchSendQueue(sessionId, tag, label, channel) {
     let lowestSinceDrain = Number.POSITIVE_INFINITY;
     let stuckSince = 0;
     let previous = null;
+    let connection = connections.get(sessionId);
+    if (!connection) {
+      connection = { channels: new Map(), at: 0, previous: null, unknown: 0 };
+      connections.set(sessionId, connection);
+    }
+    connection.channels.set(channel, label);
+    /** @type {ReturnType<typeof setInterval> | null} */
+    let timer = null;
+    /**
+     * End this channel's watch and let go of its entry.
+     *
+     * @returns {void}
+     */
+    const stop = () => {
+      if (timer) {
+        clearInterval(timer);
+      }
+      connection.channels.delete(channel);
+      // Only if the map still holds THIS record: a late stop, after the same
+      // session id has been reused and a new record made for it, must not evict
+      // the live one.
+      if (connection.channels.size === 0 && connections.get(sessionId) === connection) {
+        connections.delete(sessionId);
+      }
+    };
     // Independent of the queue: the transport's own counters, sampled for as
     // long as the channel is open. The queue was the wrong thing to watch —
     // field 2026-08-06, a 9.26 MB segment was accepted by the transport with
@@ -115,30 +178,38 @@ function makeSendQueueWatcher({ log, getTransportSnapshot }) {
     // same way while requests kept coming the other direction. With nothing
     // queued this watcher never woke, so the one question that matters — did
     // those bytes leave the machine — has no answer in the log. It does now.
-    let heartbeatPrevious = null;
-    let heartbeatAt = 0;
-
-    const timer = setInterval(() => {
+    // A connection the transport no longer knows about is gone, whatever the
+    // channel says. `onClosed` is the ordinary way this watch ends, and it does
+    // not always come — a peer connection can die without it, leaving the timer
+    // and this channel's entry behind for the life of the process.
+    //
+    // The count is kept on the CONNECTION: exactly one channel enters the
+    // heartbeat branch per interval, so a per-channel count would advance only
+    // on that channel's turn and the teardown would take three heartbeats per
+    // channel rather than three in total.
+    timer = setInterval(() => {
       const sampledAt = Date.now();
-      if (sampledAt - heartbeatAt >= TRANSPORT_HEARTBEAT_MS) {
-        heartbeatAt = sampledAt;
+      // Whichever channel's timer arrives first past the interval reports for
+      // the whole connection; the others find the timestamp already moved and
+      // skip. So the line appears once however many channels are open.
+      if (sampledAt - connection.at >= TRANSPORT_HEARTBEAT_MS) {
+        connection.at = sampledAt;
         const snapshot = getTransportSnapshot?.(sessionId) ?? null;
+        connection.unknown = snapshot ? 0 : connection.unknown + 1;
+        if (connection.unknown >= TRANSPORT_UNKNOWN_HEARTBEATS) {
+          stop();
+          return;
+        }
         if (snapshot) {
-          const sent = heartbeatPrevious ? snapshot.bytesSent - heartbeatPrevious.bytesSent : null;
-          const received = heartbeatPrevious
-            ? snapshot.bytesReceived - heartbeatPrevious.bytesReceived
+          const sent = connection.previous ? snapshot.bytesSent - connection.previous.bytesSent : null;
+          const received = connection.previous
+            ? snapshot.bytesReceived - connection.previous.bytesReceived
             : null;
-          heartbeatPrevious = snapshot;
-          let depth = 0;
-          try {
-            depth = typeof channel.bufferedAmount === "function" ? channel.bufferedAmount() : 0;
-          } catch {
-            depth = -1;
-          }
+          connection.previous = snapshot;
           log(
-            `[dc-transport] ${tag} "${label}" sent=${snapshot.bytesSent}` +
+            `[dc-transport] ${tag} sent=${snapshot.bytesSent}` +
             `${sent === null ? "" : ` (+${sent})`} received=${snapshot.bytesReceived}` +
-            `${received === null ? "" : ` (+${received})`} queued=${depth}B ` +
+            `${received === null ? "" : ` (+${received})`} queued[${queueDepths(connection.channels)}] ` +
             `rtt=${snapshot.rtt}ms pc=${snapshot.state} ice=${snapshot.iceState} pair=${snapshot.pair}`
           );
         }
@@ -184,7 +255,7 @@ function makeSendQueueWatcher({ log, getTransportSnapshot }) {
     if (typeof timer.unref === "function") {
       timer.unref();
     }
-    return () => clearInterval(timer);
+    return stop;
   };
 }
 
@@ -668,6 +739,11 @@ const SEND_QUEUE_SAMPLE_MS = 1_000;
 // send queue is doing. Frequent enough to place a loss within a few seconds,
 // sparse enough that a two-hour film costs a few hundred lines.
 const TRANSPORT_HEARTBEAT_MS = 5_000;
+
+// How many heartbeats in a row may find no transport for this session before
+// the watch gives up. Several rather than one, so a momentary gap in the
+// registry does not end a healthy watch.
+const TRANSPORT_UNKNOWN_HEARTBEATS = 3;
 const SEND_QUEUE_STUCK_MS = 5_000;
 const DC_BUFFER_HIGH_WATER = 8 * 1024 * 1024;
 /** Resume sending once the channel buffer drains to this many bytes. */

package/services/hls-session-manager.js

@@ -1419,15 +1419,23 @@ export class HlsSessionManager {
       Array.isArray(keyframeTimes) &&
       keyframeTimes.length > 0 &&
       (!transcodeVideo || inheritedGrid != null);
-    const segmentBoundaries = hasDuration
-      ? computeSegmentBoundaries({
-          useKeyframeGrid,
-          durationSeconds,
-          segDur: this.segmentDurationSec,
-          keyframeTimes,
-          startTime: sourceStartTime
-        })
-      : [];
+    // A rung takes the grid it was handed, rather than working one out again
+    // from the same index. The two are not the same table: the one it is handed
+    // has been CORRECTED wherever a produced segment showed the index to be
+    // wrong, and it is those corrected times the copy actually cuts at. Building
+    // it afresh here would put the rung back on the index's fiction and undo the
+    // alignment it exists for.
+    const segmentBoundaries = Array.isArray(inheritedGrid?.boundaries) && inheritedGrid.boundaries.length > 1
+      ? [...inheritedGrid.boundaries]
+      : (hasDuration
+        ? computeSegmentBoundaries({
+            useKeyframeGrid,
+            durationSeconds,
+            segDur: this.segmentDurationSec,
+            keyframeTimes,
+            startTime: sourceStartTime
+          })
+        : []);
     const usingKeyframeBoundaries = useKeyframeGrid;
     const segmentCount = segmentBoundaries.length > 1 ? segmentBoundaries.length - 1 : 0;
 
@@ -3354,7 +3362,27 @@ export class HlsSessionManager {
     // variants, so a seek it reports means the stream on screen.
     named.viewerPositionSeconds = positionSeconds;
     named.lastAccessedAt = Date.now();
-    const session = this.#activeVariant(named);
+    return this.#seekSession(this.#activeVariant(named), positionSeconds);
+  }
+
+  /**
+   * Reposition THIS session, with no forwarding.
+   *
+   * {@link requestSeek} exists for the browser, which names the base session and
+   * means the rung on screen. Everything inside this class means the session it
+   * is holding: warming a rung has to move THAT rung, and forwarding sent the
+   * seek to the one already playing instead — measured 2026-08-12, warming the
+   * base's own height moved the 540p rung and left the base parked at the start,
+   * so the switch had nothing to fetch.
+   *
+   * @param {HlsSession} session
+   * @param {number} positionSeconds
+   * @returns {boolean}
+   */
+  #seekSession(session, positionSeconds) {
+    if (!session || session.state === "disposed") {
+      return false;
+    }
     session.viewerPositionSeconds = positionSeconds;
     session.lastAccessedAt = Date.now();
     // Every segment request being held right now was made for the position the
@@ -3794,6 +3822,92 @@ export class HlsSessionManager {
           : "the container's keyframe index disagrees with the file; using the file")
       );
     }
+    this.correctBoundaryFromSegment(session, index, trueStart);
+  }
+
+  /**
+   * Replace a boundary the index got wrong with the time the file actually has.
+   *
+   * The grid of a copied stream comes from the container's keyframe index,
+   * because a copy can only be cut where a keyframe already is and nothing
+   * cheaper than the index can say where that is before a single byte is
+   * encoded. An index can be wrong — proven 2026-08-12 by reproducing both
+   * cases against the same file: with an honest index every produced segment
+   * started exactly where declared, and with one moved 1.8 s the segments
+   * started 1.8 s early, matching no boundary at all. The field showed the
+   * second shape.
+   *
+   * The truth arrives anyway, one segment at a time: a produced piece states
+   * where it really begins. Writing it back makes the grid describe the file
+   * instead of the index — and it is what lets a re-encoded rung be cut to
+   * match a copied one, because the rung is then forced onto times the copy
+   * really uses. The alternative considered and rejected was to stop offering
+   * quality on files with a bad index, which is not a fix but a withdrawal.
+   *
+   * The whole family shares one grid, so a correction reaches all of it: a rung
+   * created afterwards inherits a table that is true wherever anyone has looked.
+   *
+   * @param {HlsSession} session
+   * @param {number} index
+   * @param {number} trueStart
+   * @returns {void}
+   */
+  correctBoundaryFromSegment(session, index, trueStart) {
+    const boundaries = session.segmentBoundaries;
+    if (!Array.isArray(boundaries) || index <= 0 || index >= boundaries.length - 1) {
+      // Index 0 is the start of the file and the last entry is its end; neither
+      // is a cut, and neither can be learned from a segment.
+      return;
+    }
+    if (Math.abs(boundaries[index] - trueStart) <= SEGMENT_START_DISAGREEMENT_SEC) {
+      return;
+    }
+    // A correction that would put this boundary at or past its neighbours is not
+    // a correction — it is a reading from a run that started somewhere else, and
+    // applying it would make the table describe nothing at all.
+    if (trueStart <= boundaries[index - 1] || trueStart >= boundaries[index + 1]) {
+      return;
+    }
+    const wasAt = boundaries[index];
+    for (const member of this.#familyOf(session)) {
+      if (Array.isArray(member.segmentBoundaries) && member.segmentBoundaries.length === boundaries.length) {
+        member.segmentBoundaries[index] = trueStart;
+      }
+    }
+    logger.info(
+      `transcode ${session.id} boundary #${index} corrected ${wasAt.toFixed(3)}s → ` +
+      `${trueStart.toFixed(3)}s from the file itself`
+    );
+  }
+
+  /**
+   * Every session cut on one grid: a base and its quality rungs.
+   *
+   * @param {HlsSession} session
+   * @returns {HlsSession[]}
+   */
+  #familyOf(session) {
+    const bases = session.variantBases instanceof Set
+      ? [...session.variantBases]
+      : [];
+    const roots = bases.length > 0 ? bases : [session.id];
+    const family = new Set([session]);
+    for (const rootId of roots) {
+      const root = this.sessionsById.get(rootId);
+      if (!root) {
+        continue;
+      }
+      family.add(root);
+      if (root.variants instanceof Map) {
+        for (const variantId of root.variants.values()) {
+          const variant = this.sessionsById.get(variantId);
+          if (variant) {
+            family.add(variant);
+          }
+        }
+      }
+    }
+    return [...family];
   }
 
   /**
@@ -4103,7 +4217,13 @@ export class HlsSessionManager {
       // be interchangeable with it. A base on the uniform grid needs nothing
       // passed: the variant computes the same even grid from the same duration.
       inheritedGrid: base.cutGrid === "keyframe"
-        ? { keyframeTimes: base.keyframeTimes, containerFormat: base.containerFormat }
+        ? {
+            // The table as it stands NOW, corrections included — not the index
+            // it was first built from.
+            boundaries: base.segmentBoundaries,
+            keyframeTimes: base.keyframeTimes,
+            containerFormat: base.containerFormat
+          }
         : null,
       acquireSource: base.acquireSource
     })
@@ -4257,8 +4377,14 @@ export class HlsSessionManager {
     // the switch position exactly as an activation would — the difference is
     // only that the rung on screen keeps its own encoder meanwhile.
     variant.lastAccessedAt = Date.now();
-    if (variant.id !== base.id) {
-      this.requestSeek(variant.id, this.#segmentStartTime(base, index));
+    // Anything that is not the rung on screen has to be pointed at the switch
+    // position — INCLUDING the base. Skipping it because it is the base was a
+    // defect: the base is parked wherever it was when the viewer left it, and
+    // its encoder was stopped then. Measured 2026-08-12, warming 400p at
+    // 6506.5s found the base still at `run from #0`, so the segment the switch
+    // needed was never produced and the viewer got nothing at all.
+    if (variant.id !== this.#activeVariant(base).id) {
+      this.#seekSession(variant, this.#segmentStartTime(base, index));
     }
     logger.info(
       `transcode ${base.id} warming ${height}p at ${positionSeconds.toFixed(1)}s (segment #${index})`
@@ -4281,10 +4407,20 @@ export class HlsSessionManager {
    */
   #noteVariantActive(base, variant, wantedIndex = -1) {
     const previous = this.#activeVariant(base);
-    // Whatever was warmed is decided now: either it is the rung being switched
-    // to, or the viewer went elsewhere and it must stop like any other rung
-    // nobody is watching. Nothing else would ever stop it — only the rung being
-    // LEFT is stopped below.
+    if (previous.id === variant.id) {
+      // The rung on screen asking for more of itself, which it does every few
+      // seconds. Nothing is being decided here — and deciding anything was the
+      // defect: the warm-up was cancelled by the next segment the CURRENT rung
+      // fetched, measured 2026-08-12 at 117 ms and 1.5 s after two warm-ups
+      // began, so the rung being prepared was stopped before it had encoded
+      // anything and the viewer waited out the full thirty-second warm-up for a
+      // segment nobody was making, then waited again for the switch itself.
+      return;
+    }
+    // A rung is being left, so whatever was warmed is decided: either it is the
+    // rung now being switched to, or the viewer went somewhere else and it must
+    // stop like any other rung nobody is watching. Nothing else would ever stop
+    // it — only the rung being LEFT is stopped below.
     const warmed = base.warmingVariantId;
     base.warmingVariantId = null;
     if (warmed && warmed !== variant.id && warmed !== previous.id) {
@@ -4293,9 +4429,6 @@ export class HlsSessionManager {
         this.#stopEncodeRun(abandoned, "warmed for a switch the viewer did not make");
       }
     }
-    if (previous.id === variant.id) {
-      return;
-    }
     const position = this.#variantStartSeconds(base, wantedIndex);
     base.activeVariantId = variant.id;
     logger.info(
@@ -4310,10 +4443,12 @@ export class HlsSessionManager {
     this.#stopEncodeRun(previous, `the viewer moved to ${this.variantHeightOf(variant)}p`);
     if (position > 0) {
       variant.viewerPositionSeconds = position;
-      // A variant just created already starts here, and requestSeek says so
-      // rather than restarting it. One that existed before is parked where it
-      // was left, and this is what brings it to the viewer.
-      this.requestSeek(variant.id, position);
+      // The rung being switched TO, named literally: a warm-up may have left
+      // the family pointing elsewhere, and forwarding would move that one
+      // instead. A rung just created already starts here and is told so rather
+      // than restarted; one that existed before is parked where it was left,
+      // and this is what brings it to the viewer.
+      this.#seekSession(variant, position);
     }
   }
 

package/test/keyframe-index-accuracy.test.js

@@ -56,6 +56,67 @@ test("a deviation within tolerance is not a disagreement, but still shows in the
   assert.equal(check.maxDeviationSec, 0.2, "and it is still worth knowing how close to the line it ran");
 });
 
+test("a boundary the index got wrong is replaced by the time the file really has", async (t) => {
+  const { HlsSessionManager } = await import("../services/hls-session-manager.js");
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  t.after(() => manager.disposeAll());
+  const base = {
+    id: "aaaaaaaa-1111-2222-3333-444444444444",
+    fileName: "film.mkv",
+    state: "ready",
+    transcodeVideo: false,
+    segmentBoundaries: [0, 10, 20, 30, 40],
+    indexCheck: newIndexCheck(),
+    variants: new Map(),
+    segmentFormat: { segmentFileName: (index) => `segment-${index}.mp4` }
+  };
+  const rung = {
+    id: "bbbbbbbb-1111-2222-3333-444444444444",
+    fileName: "film.mkv",
+    state: "ready",
+    transcodeVideo: true,
+    segmentBoundaries: [0, 10, 20, 30, 40],
+    indexCheck: newIndexCheck(),
+    variantBases: new Set([base.id])
+  };
+  base.variants.set(540, rung.id);
+  manager.sessionsById.set(base.id, base);
+  manager.sessionsById.set(rung.id, rung);
+
+  // The copy produced segment #2, and it really begins at 17.4 s — the index
+  // said 20. This is the shape reproduced from the field on 2026-08-12.
+  manager.correctBoundaryFromSegment(base, 2, 17.4);
+
+  assert.equal(
+    base.segmentBoundaries[2],
+    17.4,
+    "the grid must describe the file, not the index — a rung forced onto 20 s would not join the copy"
+  );
+  assert.equal(
+    rung.segmentBoundaries[2],
+    17.4,
+    "the family shares one grid, so a correction reaches the rungs cut against it"
+  );
+  assert.deepEqual(
+    base.segmentBoundaries,
+    [0, 10, 17.4, 30, 40],
+    "only the boundary that was shown to be wrong moves"
+  );
+
+  // A reading that cannot be a boundary is not evidence about one. It comes
+  // from a run that started somewhere else, and applying it would leave the
+  // table describing nothing.
+  manager.correctBoundaryFromSegment(base, 2, 35);
+  manager.correctBoundaryFromSegment(base, 2, 5);
+  manager.correctBoundaryFromSegment(base, 0, 3);
+  assert.deepEqual(base.segmentBoundaries, [0, 10, 17.4, 30, 40], "out-of-order readings are refused");
+});
+
 test("a segment requested again is not new evidence", () => {
   const check = newIndexCheck();
 

package/test/quality-variants.test.js

@@ -310,6 +310,62 @@ test("warming a rung prepares it without taking the encoder from the one on scre
   assert.deepEqual(encoder.signals, [], "stopping it here is what would put the spinner back");
 });
 
+test("the rung on screen fetching its own segments does not cancel a warm-up", async (t) => {
+  const { manager, base, dirPath } = await managerWithBase();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  const variant = fakeSession({ id: VARIANT_ID, encodeHeight: 540, dirPath });
+  variant.variantHeight = 540;
+  variant.variantBases = new Set([BASE_ID]);
+  manager.sessionsById.set(VARIANT_ID, variant);
+  base.variants = new Map([[540, VARIANT_ID]]);
+  const warmedEncoder = fakeEncoder();
+  variant.ffmpeg = warmedEncoder;
+  base.ffmpeg = fakeEncoder();
+  await manager.prepareVariant(BASE_ID, 540, 100);
+
+  // The viewer has not moved: the rung they are watching goes on asking for its
+  // own segments, every few seconds, for as long as they watch.
+  await manager.resolveVariantFile(BASE_ID, 812, "segment-00026.mp4");
+  await manager.resolveVariantFile(BASE_ID, 812, "segment-00027.mp4");
+
+  assert.equal(base.warmingVariantId, VARIANT_ID, "the rung being prepared is still being prepared");
+  assert.deepEqual(
+    warmedEncoder.signals,
+    [],
+    "cancelling it here left the viewer waiting out the whole warm-up for a segment nobody was making"
+  );
+});
+
+test("warming the height the base itself serves still points it at the switch", async (t) => {
+  const { manager, base, dirPath } = await managerWithBase();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // The viewer is on another rung; the base is parked where they left it, with
+  // its encoder stopped. Warming its height must bring it back.
+  const variant = fakeSession({ id: VARIANT_ID, encodeHeight: 540, dirPath });
+  variant.variantHeight = 540;
+  manager.sessionsById.set(VARIANT_ID, variant);
+  base.variants = new Map([[540, VARIANT_ID]]);
+  base.activeVariantId = VARIANT_ID;
+  base.ffmpeg = null;
+  base.encodeStartIndex = 0;
+
+  await manager.prepareVariant(BASE_ID, 812, 400);
+
+  // 400 s falls on the boundary between #99 and #100, and a run starts one
+  // segment back so the player has the preceding keyframe.
+  assert.equal(
+    base.seekTarget,
+    98,
+    "the base is parked at the start, so warming its height must reposition it like any other rung"
+  );
+});
+
 test("the viewer's position is kept current by the segments they ask for", async (t) => {
   const { manager, base, dirPath } = await managerWithBase();
   t.after(async () => {

package/host-timings.json

@@ -1 +0,0 @@
-{"firstSegment":[3,1,4,11,3,1,3,17],"sessionCreate":[]}