@torrent-tv/proxy 2.107.46 → 2.107.48

package/package.json

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

package/routes/api/sources/files/get.js

@@ -77,17 +77,15 @@ export async function handleApiSourceFilesGet(req, reply, { sourceRegistry, torr
   const generation = generationRaw !== "" && /^\d+$/.test(generationRaw) ? Number(generationRaw) : null;
   const linkMbps = Number(req.query?.linkMbps);
   const linkSampleAgeMs = Number(req.query?.linkSampleAgeMs);
-  const waitElapsedMs = Number(req.query?.waitElapsedMs);
   const earlyLink = Number.isFinite(linkMbps) && linkMbps > 0
     ? { linkMbps, linkSampleAgeMs: Number.isFinite(linkSampleAgeMs) && linkSampleAgeMs >= 0 ? linkSampleAgeMs : null }
     : {};
-  const earlyWaitAge = Number.isFinite(waitElapsedMs) && waitElapsedMs >= 0 ? { waitElapsedMs } : {};
   const files = contents.files().map(file => {
     if (!consumerId || !Number.isSafeInteger(generation) || file.kind !== "video" || file.excludedReason) return file;
-    const waitEstimate = viewerRequests?.waitEstimateForFile?.({ consumerId, generation, sourceKey,
+    viewerRequests?.noteWaitFileSnapshot?.({ consumerId, generation, sourceKey,
       fileIndex: file.fileIndex, fileName: file.relativePath ?? file.name, fileLength: file.length,
-      ...earlyLink, ...earlyWaitAge }) ?? null;
-    return waitEstimate ? { ...file, waitEstimate } : file;
+      ...earlyLink });
+    return file;
   });
   return reply.send({
     name: torrent.name ?? "",

package/routes/api/sources/stats/get.js

@@ -20,6 +20,7 @@ import { performance } from "node:perf_hooks";
  * @returns {Promise<void>}
  */
 export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torrentPool, viewerRequests }) {
+  const requestReceivedAtProxyMs = performance.now();
   const sourceKey = typeof req.params.sourceKey === "string" ? req.params.sourceKey.trim() : "";
   if (!sourceKey) {
     return reply.code(400).send({ error: "sourceKey is required." });
@@ -40,15 +41,15 @@ export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torr
     ? Number(req.query.fileLength) : null;
   const linkMbps = Number(req.query.linkMbps);
   const linkSampleAgeMs = Number(req.query.linkSampleAgeMs);
-  const waitElapsedMs = Number(req.query.waitElapsedMs);
   const earlyLink = Number.isFinite(linkMbps) && linkMbps > 0
     ? { linkMbps, linkSampleAgeMs: Number.isFinite(linkSampleAgeMs) && linkSampleAgeMs >= 0 ? linkSampleAgeMs : null }
     : {};
-  const earlyWaitAge = Number.isFinite(waitElapsedMs) && waitElapsedMs >= 0 ? { waitElapsedMs } : {};
-  const initialEstimate = () => consumerId && Number.isSafeInteger(generation) && Number.isSafeInteger(fileIndex)
-    ? viewerRequests?.waitEstimateForFile?.({ consumerId, generation, sourceKey, fileIndex,
-      fileName: requestedFileName, fileLength: requestedFileLength, ...earlyLink, ...earlyWaitAge }) ?? null
-    : null;
+  const noteInitialSnapshot = () => {
+    if (consumerId && Number.isSafeInteger(generation) && Number.isSafeInteger(fileIndex)) {
+      viewerRequests?.noteWaitFileSnapshot?.({ consumerId, generation, sourceKey, fileIndex,
+        fileName: requestedFileName, fileLength: requestedFileLength, ...earlyLink });
+    }
+  };
 
   let torrent;
   try {
@@ -59,23 +60,25 @@ export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torr
     return reply.code(500).send({ error: `Failed to load torrent: ${message}` });
   }
   if (!torrent) {
-    const waitEstimate = initialEstimate();
-    return reply.code(202).send({ pending: true, ...(waitEstimate ? { waitEstimate } : {}) });
+    noteInitialSnapshot();
+    return reply.code(202).send({ pending: true });
   }
 
   // Awaited: with the torrent on its own thread this is a round trip, not a
   // local lookup. Without the await the reply was the pending promise itself,
   // which serialises to `{}` — the empty stats seen in the field 2026-08-02.
   const statsStartedAt = performance.now();
+  let statsCompletedAt;
   let stats;
   try {
     stats = await torrentPool.getFileStats(torrent, fileIndex);
   } finally {
+    statsCompletedAt = performance.now();
     logger.info(`[stats] ${sourceKey.slice(0, 8)} getFileStatsMs=${(performance.now() - statsStartedAt).toFixed(1)}`);
   }
   if (stats?.pending || !stats) {
-    const waitEstimate = initialEstimate();
-    return reply.code(202).send({ pending: true, ...(waitEstimate ? { waitEstimate } : {}) });
+    noteInitialSnapshot();
+    return reply.code(202).send({ pending: true });
   }
 
   // Diagnostic: surface the real swarm state per poll so a cold-start download
@@ -149,10 +152,16 @@ export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torr
     `file=${filePct} header=${header}${detail}`
   );
 
-  const waitEstimate = consumerId && Number.isSafeInteger(generation)
-    ? viewerRequests?.waitEstimateForSource?.({ consumerId, generation, sourceKey, fileIndex,
+  if (consumerId && Number.isSafeInteger(generation)) {
+    viewerRequests?.noteWaitSourceSnapshot?.({ consumerId, generation, sourceKey, fileIndex,
       fileName: torrent.files?.[fileIndex]?.name ?? requestedFileName, fileLength: requestedFileLength,
-      stats, ...earlyLink, ...earlyWaitAge }) ?? null
-    : null;
-  return reply.send(waitEstimate ? { ...stats, waitEstimate } : stats);
+      stats, ...earlyLink });
+  }
+  const responsePreparedAtProxyMs = performance.now();
+  return reply.send({ ...stats, sourceSnapshotTransport: {
+    requestReceivedAtProxyMs,
+    snapshotStartedAtProxyMs: statsStartedAt,
+    snapshotCompletedAtProxyMs: statsCompletedAt,
+    responsePreparedAtProxyMs
+  } });
 }

package/routes/api/transcode-sessions/net-report/post.js

@@ -8,7 +8,9 @@ import { recordViewerReport } from "../../../../services/viewer/report-intake.js
  *
  * POST /api/transcode-sessions/:sessionId/net-report
  * Body: { consumerId: string, bufferedAheadSec: number, linkMbps?: number,
- *         positionSeconds?: number, playingHeight?: number, … }
+ *         positionSeconds?: number, playingHeight?: number, appendEpoch?: string,
+ *         appendEpochStartedAt?: number, appendSnapshotAt?: number,
+ *         appendService?: object, fragmentService?: object, … }
  *
  * `consumerId` and `positionSeconds` say WHO is reporting and WHERE they are.
  * A copied picture is one session shared by every viewer of it, so without them
@@ -115,6 +117,14 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply,
       linkMbps: Number.isFinite(linkMbps) && linkMbps > 0 ? linkMbps : undefined,
       linkSampleMbps: Number.isFinite(linkSampleMbps) && linkSampleMbps > 0 ? linkSampleMbps : undefined,
       linkSampleAt: Number.isFinite(linkSampleAt) && linkSampleAt > 0 ? linkSampleAt : undefined,
+      appendSessionId: sessionId,
+      appendEpoch: typeof body.appendEpoch === "string" ? body.appendEpoch : undefined,
+      appendEpochStartedAt: Number.isFinite(body.appendEpochStartedAt) && body.appendEpochStartedAt > 0
+        ? body.appendEpochStartedAt : undefined,
+      appendSnapshotAt: Number.isFinite(body.appendSnapshotAt) && body.appendSnapshotAt > 0
+        ? body.appendSnapshotAt : undefined,
+      appendService: body.appendService && typeof body.appendService === "object" ? body.appendService : undefined,
+      fragmentService: body.fragmentService && typeof body.fragmentService === "object" ? body.fragmentService : undefined,
       bufferedAheadSec,
       bufferedRanges: body.bufferedRanges,
       timestampOffsets: body.bufferedRanges?.timestampOffsets,

package/routes/api/transcode-sessions/progress/get.js

@@ -9,6 +9,7 @@
  * @returns {Promise<void>}
  */
 export async function handleApiTranscodeSessionsProgressGet(req, reply, { viewerRequests }) {
+  const requestReceivedAtProxyMs = performance.now();
   const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
   if (!sessionId) {
     return reply.code(400).send({ error: "sessionId is required." });
@@ -23,5 +24,11 @@ export async function handleApiTranscodeSessionsProgressGet(req, reply, { viewer
     return reply.code(404).send({ error: "Transcode session was not found." });
   }
 
+  const responsePreparedAtProxyMs = performance.now();
+  progress.snapshotTransport = {
+    requestReceivedAtProxyMs,
+    snapshotAtProxyMs: progress.playbackReadiness?.snapshotAtProxyMs ?? null,
+    responsePreparedAtProxyMs
+  };
   return reply.send(progress);
 }

package/services/server/ViewerRequests.js

@@ -41,6 +41,36 @@ function sameInputs(left, right) {
   return left.every((input, index) => input.sourceId === right[index].sourceId && input.ranges === right[index].ranges);
 }
 
+function browserServiceSummary(value) {
+  if (!value || typeof value !== "object") return null;
+  return Object.fromEntries(["init", "media"].filter(kind => value[kind]).map(kind => [kind, value[kind]]).map(([kind, service]) => [kind, {
+    bytes: service.bytes,
+    elapsedMs: service.elapsedMs,
+    operations: service.operations,
+    sampleCount: service.samples.length,
+    newestSampleAgeMs: service.samples.reduce((age, sample) => age === null ? sample.ageMs : Math.min(age, sample.ageMs), null),
+    samples: service.samples.map(({ bytes, elapsedMs, ageMs, fragmentId, fragmentSequence, partIndex, fragmentStartSeconds,
+      parseElapsedMs, bufferingElapsedMs, bufferingAgeMs, eventAgesMs }) => ({ bytes, elapsedMs, ageMs, fragmentId,
+      fragmentSequence, partIndex, fragmentStartSeconds,
+      ...(parseElapsedMs === null || parseElapsedMs === undefined ? {} : { parseElapsedMs }),
+      ...(bufferingElapsedMs === null || bufferingElapsedMs === undefined ? {} : { bufferingElapsedMs }),
+      ...(bufferingAgeMs === null || bufferingAgeMs === undefined ? {} : { bufferingAgeMs }),
+      ...(eventAgesMs ? { eventAgesMs } : {}) }))
+  }]));
+}
+
+function browserServiceFingerprint(tracks) {
+  const serviceFingerprint = service => service ? ["init", "media"].map(kind => {
+    const value = service[kind];
+    return value ? [kind, value.bytes, value.elapsedMs, value.operations, value.samples.map(sample => [
+      sample.bytes, sample.elapsedMs, sample.fragmentId, sample.fragmentSequence, sample.partIndex,
+      sample.fragmentStartSeconds, sample.parseElapsedMs, sample.bufferingElapsedMs
+    ])] : [kind, null];
+  }) : null;
+  return JSON.stringify(tracks.map(track => [track.id,
+    serviceFingerprint(track.appendService), serviceFingerprint(track.fragmentService)]));
+}
+
 export function forecastInputState(tracks, identity) {
   if (!identity) return null;
   const track = tracks.find(candidate => candidate.id === identity.trackId);
@@ -91,8 +121,8 @@ export class ViewerRequests {
   #host;
   /** @type {WeakMap<object, Map<string, object>>} */
   #rateStateBySession = new WeakMap();
-  /** @type {Map<string, { consumerId: string, generation: number, fileIndex: number | null, waitId: string, features: object, updatedAt: number, revision: number, observedWaits: Set<number> }>} */
-  #earlyWaits = new Map();
+  /** @type {Map<string, { consumerId: string, generation: number, fileIndex: number | null, waitId: string, features: object, updatedAt: number, observedWaits: Set<number> }>} */
+  #waitObservations = new Map();
   /**
    * What the start forecasts cost, said once a minute: how many there were,
    * their time on the main thread, and for each track whether the times of its
@@ -130,17 +160,10 @@ export class ViewerRequests {
     this.#host = host;
   }
 
-  /**
-   * Attach a host-matched estimate to the file list before the viewer chooses
-   * a file, so the original action need not wait for a torrent-worker round trip.
-   *
-   * @param {{ consumerId: string, generation: number, sourceKey: string, fileIndex: number, fileName: string, fileLength: number }} params
-   * @returns {object | null}
-   */
-  waitEstimateForFile({ consumerId, generation, sourceKey, fileIndex, fileName, fileLength, linkMbps, linkSampleAgeMs,
-    waitElapsedMs }) {
+  /** Record the facts known while listing a source, without producing an ETA. */
+  noteWaitFileSnapshot({ consumerId, generation, sourceKey, fileIndex, fileName, fileLength, linkMbps, linkSampleAgeMs }) {
     if (!consumerId || !Number.isSafeInteger(generation) || typeof sourceKey !== "string" ||
-        !Number.isSafeInteger(fileIndex) || fileIndex < 0) return null;
+        !Number.isSafeInteger(fileIndex) || fileIndex < 0) return;
     const waitId = `${sourceKey}:${fileIndex}:${generation}`;
     const key = `${consumerId}:${waitId}`;
     const extension = typeof fileName === "string" ? fileName.split(".").at(-1)?.toLowerCase() ?? "" : "";
@@ -156,48 +179,23 @@ export class ViewerRequests {
       headerRemaining: null,
       peers: null
     };
-    const current = this.#earlyWaits.get(key);
-    if (current?.waitId === waitId && current.hasSourceObservation) {
-      const context = this.#setEarlyWait({ consumerId, generation, sourceKey, fileIndex, waitId, features,
-        revision: current.revision, current, waitElapsedMs });
-      const changed = this.#recordEarlyWaitSnapshot(context, context.features);
-      if (changed) context.revision += 1;
-      this.#pruneEarlyWaits();
-      const elapsedMs = waitElapsedSince(context, waitElapsedMs);
-      const totalSeconds = context.activeTotalSeconds;
-      const seconds = earlyWaitRemainingSeconds(totalSeconds, elapsedMs);
-      if (!Number.isFinite(seconds) || seconds < 0) return null;
-      this.#logEarlyForecast(context, { elapsedMs, seconds, totalSeconds,
-        firstRequiredSegmentsSeconds: context.activeFirstRequiredSegmentsSeconds });
-      return { version: 1, waitId, revision: context.revision, remainingSeconds: seconds, ageMs: 0 };
-    }
-    const sameWait = current?.waitId === waitId;
-    const revision = sameWait ? current.revision : 0;
-    const context = this.#setEarlyWait({ consumerId, generation, sourceKey, fileIndex, waitId, features, revision, current,
-      waitElapsedMs });
-    const changed = this.#recordEarlyWaitSnapshot(context, context.features);
-    if (sameWait && changed) context.revision += 1;
-    this.#pruneEarlyWaits();
-    const elapsedMs = waitElapsedSince(context, waitElapsedMs);
-    const totalSeconds = context.activeTotalSeconds;
-    const seconds = earlyWaitRemainingSeconds(totalSeconds, elapsedMs);
-    if (!Number.isFinite(seconds) || seconds < 0) return null;
-    this.#logEarlyForecast(context, { elapsedMs, seconds, totalSeconds,
-      firstRequiredSegmentsSeconds: context.activeFirstRequiredSegmentsSeconds,
-      firstRequiredStages: context.activeFirstRequiredStages });
-    return { version: 1, waitId, revision: context.revision, remainingSeconds: seconds, ageMs: 0 };
+    const current = this.#waitObservations.get(key);
+    const context = this.#setWaitObservation({ consumerId, generation, sourceKey, fileIndex, waitId, features, current });
+    this.#recordWaitSnapshot(context);
+    this.#pruneWaitObservations();
   }
 
   /**
-   * Keep the measurements available before the container is inspected and
-   * predict the complete first-frame wait from this host's earlier outcomes.
+   * Record current source and link facts for later forecast evaluation. These
+   * partial inputs do not determine the first presented frame, so this method
+   * does not produce a wait estimate.
    *
    * @param {{ consumerId: string, generation: number, sourceKey: string, fileIndex: number | null, fileName?: string, fileLength?: number | null, stats?: object }} params
    * @returns {object | null}
    */
-  waitEstimateForSource({ consumerId, generation, sourceKey, fileIndex, fileName = "", fileLength = null,
-    stats = {}, linkMbps, linkSampleAgeMs, waitElapsedMs, processing = {} }) {
-    if (!consumerId || !Number.isSafeInteger(generation) || typeof sourceKey !== "string") return null;
+  noteWaitSourceSnapshot({ consumerId, generation, sourceKey, fileIndex, fileName = "", fileLength = null,
+    stats = {}, linkMbps, linkSampleAgeMs, processing = {} }) {
+    if (!consumerId || !Number.isSafeInteger(generation) || typeof sourceKey !== "string") return;
     const waitId = `${sourceKey}:${fileIndex ?? "all"}:${generation}`;
     const key = `${consumerId}:${waitId}`;
     const extension = typeof fileName === "string" ? fileName.split(".").at(-1)?.toLowerCase() ?? "" : "";
@@ -220,68 +218,10 @@ export class ViewerRequests {
       videoSpeedX: processing.videoSpeedX ?? null,
       audioSpeedX: processing.audioSpeedX ?? null
     };
-    const current = this.#earlyWaits.get(key);
-    const sameWait = current?.waitId === waitId;
-    const revision = sameWait ? current.revision : 0;
-    const context = this.#setEarlyWait({ consumerId, generation, sourceKey, fileIndex, waitId, features, revision, current,
-      sourceObserved: true, waitElapsedMs });
-    const featuresChanged = this.#recordEarlyWaitSnapshot(context, context.features);
-    const elapsedMs = waitElapsedSince(context, waitElapsedMs);
-    // The wait ends when the start forecast lets the picture start, and the
-    // first required pieces being there is only part of that: a source
-    // supplied slower than the film plays is held until the cushion carries
-    // it to the end. Counted to the first pieces alone, the estimate reached
-    // zero with seven minutes still to wait, and the page had no time to show
-    // (Home Assistant 2026-10-26, Despicable Me 3 BDRemux at 0.53x,
-    // torrent-tv/meta#239).
-    const firstRequiredSeconds = processing.firstRequiredSegmentsSeconds;
-    const startGateSeconds = processing.startGateSeconds;
-    const measuredWorkSeconds = Number.isFinite(startGateSeconds) && startGateSeconds >= 0
-      ? Math.max(startGateSeconds, Number.isFinite(firstRequiredSeconds) ? firstRequiredSeconds : 0)
-      : firstRequiredSeconds;
-    const hasActiveEstimate = Number.isFinite(measuredWorkSeconds) && measuredWorkSeconds >= 0;
-    const stagesChanged = Array.isArray(processing.firstRequiredStages) &&
-      JSON.stringify(processing.firstRequiredStages) !== JSON.stringify(context.activeFirstRequiredStages);
-    const activeTotalSeconds = hasActiveEstimate
-      ? elapsedMs / 1000 + measuredWorkSeconds
-      : context.activeTotalSeconds;
-    const activeEstimateChanged = hasActiveEstimate &&
-      (activeTotalSeconds !== context.activeTotalSeconds || stagesChanged);
-    if (hasActiveEstimate) {
-      context.activeTotalSeconds = activeTotalSeconds;
-      context.activeFirstRequiredSegmentsSeconds = measuredWorkSeconds;
-      if (Array.isArray(processing.firstRequiredStages)) {
-        context.activeFirstRequiredStages = processing.firstRequiredStages;
-      }
-    }
-    const changed = featuresChanged || activeEstimateChanged;
-    if (sameWait && changed) context.revision += 1;
-    this.#pruneEarlyWaits();
-    const totalSeconds = activeTotalSeconds;
-    const seconds = earlyWaitRemainingSeconds(totalSeconds, elapsedMs);
-    if (!Number.isFinite(seconds) || seconds < 0) return null;
-    this.#logEarlyForecast(context, { elapsedMs, seconds, totalSeconds,
-      firstRequiredSegmentsSeconds: hasActiveEstimate ? firstRequiredSeconds ?? null : context.activeFirstRequiredSegmentsSeconds,
-      startGateSeconds: hasActiveEstimate && Number.isFinite(startGateSeconds) ? startGateSeconds : null,
-      firstRequiredStages: context.activeFirstRequiredStages });
-    return { version: 1, waitId, revision: context.revision, remainingSeconds: seconds, ageMs: 0 };
-  }
-
-  #logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, firstRequiredSegmentsSeconds,
-    startGateSeconds = null, firstRequiredStages }) {
-    if (context.loggedForecastRevision === context.revision) return;
-    const gated = Number.isFinite(startGateSeconds) &&
-      !(Number.isFinite(firstRequiredSegmentsSeconds) && firstRequiredSegmentsSeconds >= startGateSeconds);
-    const basis = gated ? "start-gate" : "first-required";
-    const estimate = { firstRequiredSegmentsSeconds, ...(Number.isFinite(startGateSeconds) ? { startGateSeconds } : {}),
-      ...(Array.isArray(firstRequiredStages) ? { firstRequiredStages } : {}) };
-    logger.info(`early wait forecast ${JSON.stringify({ waitId: context.waitId, consumer: context.consumerId,
-      generation: context.generation, features: context.features, elapsedMs, revision: context.revision,
-      predicted: { remainingSeconds: seconds, totalSeconds, basis, ...estimate } })}`);
-    this.#host.observeWait?.(context.sourceKey, "process", { process: "P15", phase: "event",
-      waitId: context.waitId, consumerId: context.consumerId, generation: context.generation,
-      elapsedMs, revision: context.revision, remainingSeconds: seconds, totalSeconds, basis, ...estimate });
-    context.loggedForecastRevision = context.revision;
+    const current = this.#waitObservations.get(key);
+    const context = this.#setWaitObservation({ consumerId, generation, sourceKey, fileIndex, waitId, features, current });
+    this.#recordWaitSnapshot(context);
+    this.#pruneWaitObservations();
   }
 
   /**
@@ -296,20 +236,19 @@ export class ViewerRequests {
    */
   noteFirstFrameObservation({ consumerId, generation, waitId, wait, elapsedMs, stages = null }) {
     const key = `${consumerId}:${waitId}`;
-    const early = this.#earlyWaits.get(key);
-    if (!early || early.generation !== generation || !Number.isSafeInteger(wait) || wait < 0 || early.observedWaits.has(wait) ||
+    const observation = this.#waitObservations.get(key);
+    if (!observation || observation.generation !== generation || !Number.isSafeInteger(wait) || wait < 0 || observation.observedWaits.has(wait) ||
         !Number.isFinite(elapsedMs) || elapsedMs < 0) return;
-    const initialFeatures = early.snapshots[0];
+    const initialFeatures = observation.snapshots[0];
     if (initialFeatures) {
       this.#host.noteFirstFrame?.({ seconds: elapsedMs / 1000, features: initialFeatures,
-        featureSnapshots: early.snapshots.slice(1), stages });
+        featureSnapshots: observation.snapshots.slice(1), stages });
     }
-    early.observedWaits.add(wait);
-    early.updatedAt = Date.now();
+    observation.observedWaits.add(wait);
+    observation.updatedAt = Date.now();
   }
 
-  #setEarlyWait({ consumerId, generation, sourceKey, fileIndex, waitId, features, revision, current,
-    sourceObserved = false, waitElapsedMs }) {
+  #setWaitObservation({ consumerId, generation, sourceKey, fileIndex, waitId, features, current }) {
     const sameWait = current?.waitId === waitId;
     const context = sameWait ? current : {
       consumerId,
@@ -318,26 +257,21 @@ export class ViewerRequests {
       fileIndex,
       waitId,
       snapshots: [],
-      hasSourceObservation: false,
       observedWaits: new Set()
     };
     const measuredAt = performance.now();
-    const actionElapsedMs = Number.isFinite(waitElapsedMs) && waitElapsedMs >= 0 ? waitElapsedMs : null;
-    const startedAt = actionElapsedMs === null
-      ? Number.isFinite(context.startedAt) ? context.startedAt : measuredAt
-      : measuredAt - actionElapsedMs;
     const ageElapsedMs = Number.isFinite(context.featuresMeasuredAt)
       ? Math.max(0, measuredAt - context.featuresMeasuredAt)
       : 0;
     const mergedFeatures = mergeWaitFeatures(context.features, features, ageElapsedMs);
     Object.assign(context, { consumerId, generation, sourceKey, fileIndex, waitId, features: mergedFeatures,
-      featuresMeasuredAt: measuredAt, startedAt, updatedAt: Date.now(), revision,
-      hasSourceObservation: context.hasSourceObservation || sourceObserved });
-    this.#earlyWaits.set(`${consumerId}:${waitId}`, context);
+      featuresMeasuredAt: measuredAt, updatedAt: Date.now() });
+    this.#waitObservations.set(`${consumerId}:${waitId}`, context);
     return context;
   }
 
-  #recordEarlyWaitSnapshot(context, features) {
+  #recordWaitSnapshot(context) {
+    const features = context.features;
     const previous = context.snapshots.at(-1);
     if (previous && JSON.stringify(previous) === JSON.stringify(features)) return false;
     const snapshot = { ...features };
@@ -373,12 +307,12 @@ export class ViewerRequests {
     return bytes;
   }
 
-  #pruneEarlyWaits() {
+  #pruneWaitObservations() {
     const cutoff = Date.now() - 30 * 60_000;
-    for (const [key, value] of this.#earlyWaits) {
-      if (value.updatedAt < cutoff) this.#earlyWaits.delete(key);
+    for (const [key, value] of this.#waitObservations) {
+      if (value.updatedAt < cutoff) this.#waitObservations.delete(key);
     }
-    while (this.#earlyWaits.size > 1000) this.#earlyWaits.delete(this.#earlyWaits.keys().next().value);
+    while (this.#waitObservations.size > 1000) this.#waitObservations.delete(this.#waitObservations.keys().next().value);
   }
 
   /**
@@ -674,13 +608,12 @@ export class ViewerRequests {
       videoSpeedX: null,
       audioSpeedX: null
     };
-    // A seek is a new waiting action even when a caller repeats the same
-    // generation. Start its clock at the explicit seek request, before the
-    // next readiness poll can return the first current-work estimate.
-    this.#earlyWaits.delete(key);
-    const context = this.#setEarlyWait({ consumerId, generation, sourceKey: file.sourceKey,
-      fileIndex: file.fileIndex, waitId, features, revision: 0, current: null, waitElapsedMs: 0 });
-    this.#recordEarlyWaitSnapshot(context, features);
+    // A seek is a new observation group even when a caller repeats the same
+    // generation; its source facts must not join observations from the prior wait.
+    this.#waitObservations.delete(key);
+    const context = this.#setWaitObservation({ consumerId, generation, sourceKey: file.sourceKey,
+      fileIndex: file.fileIndex, waitId, features, current: null });
+    this.#recordWaitSnapshot(context);
   }
 
   /**
@@ -1009,6 +942,19 @@ export class ViewerRequests {
         clockOffsetSeconds: placedByPlayer ? playerOffset : 0,
         clientRanges: viewerReading?.bufferedRanges?.[output === session ? "video" : "audio"] ??
           viewerReading?.bufferedRanges?.media,
+        // Browser-observed append and fragment-parse samples are retained for
+        // the full model's service schedule; they are not yet used as numeric
+        // predecessors in the partial continuity calculation.
+        appendService: viewerReading?.appendSessionId === session.id && viewerReading?.appendService?.[trackName]
+          ? { ...viewerReading.appendService[trackName], epoch: viewerReading.appendEpoch,
+            epochStartedAt: viewerReading.appendEpochStartedAt, snapshotAt: viewerReading.appendSnapshotAt,
+            receivedAt: viewerReading.appendServiceReceivedAt }
+          : null,
+        fragmentService: viewerReading?.appendSessionId === session.id && viewerReading?.fragmentService?.[trackName]
+          ? { ...viewerReading.fragmentService[trackName], epoch: viewerReading.appendEpoch,
+            epochStartedAt: viewerReading.appendEpochStartedAt, snapshotAt: viewerReading.appendSnapshotAt,
+            receivedAt: viewerReading.appendServiceReceivedAt }
+          : null,
         sourceIds,
         processedSeconds: trackProgress?.processedSeconds,
         startupRemainingSeconds: processingStarted ? 0 : Math.max(0,
@@ -1089,6 +1035,7 @@ export class ViewerRequests {
       `start forecast ${Math.round(predictMs)}ms, in all ${Math.round(performance.now() - parts.enteredAt)}ms`);
     const forecast = withSubtitleReadiness(predicted, subtitle,
       subtitle ? this.#host.subtitleReadyFor?.(viewer) !== false : true);
+    forecast.snapshotAtProxyMs = startedAt;
     forecast.operations = outputs.flatMap((output, index) => {
       const common = { speed: this.#host.playbackReadiness.forecastRate(tracks[index].readings, now, 0, "piece"),
         processedSeconds: tracks[index].processedSeconds,
@@ -1109,11 +1056,11 @@ export class ViewerRequests {
       ? this.#host.generationOfRequest(consumerId) : null;
     const earlyWaitId = Number.isSafeInteger(generation)
       ? `${session.file.sourceKey}:${session.file.fileIndex}:${generation}` : null;
-    if (earlyWaitId && this.#earlyWaits.has(`${consumerId}:${earlyWaitId}`) && primarySourceStats) {
+    if (earlyWaitId && this.#waitObservations.has(`${consumerId}:${earlyWaitId}`) && primarySourceStats) {
       const linkMeasuredAt = Number(viewerReading?.linkMeasuredAt);
       const videoOperation = forecast.operations.find(operation => operation.track === "video");
       const audioOperation = forecast.operations.find(operation => operation.track === "audio");
-      const waitEstimate = this.waitEstimateForSource({ consumerId, generation,
+      this.noteWaitSourceSnapshot({ consumerId, generation,
         sourceKey: session.file.sourceKey, fileIndex: session.file.fileIndex,
         fileName: session.file.relativePath ?? session.file.name ?? "",
         fileLength: primarySourceStats.fileLength, stats: primarySourceStats,
@@ -1125,14 +1072,12 @@ export class ViewerRequests {
           videoSpeedX: videoOperation?.speed,
           audioSpeedX: audioOperation?.speed,
           firstRequiredSegmentsSeconds: forecast.firstRequiredSegmentsSeconds,
-          // When the start forecast lets the picture start: its delay while
-          // it holds the start, and nothing to add once it does not.
           ...(forecast.ready !== true && Number.isFinite(forecast.delaySeconds)
             ? { startGateSeconds: forecast.delaySeconds } : {}),
           firstRequiredStages: forecast.firstRequiredStages
         } });
-      if (waitEstimate) forecast.waitEstimate = waitEstimate;
     }
+    forecast.waitEstimate = null;
     const unavailableInput = forecast.unavailableSource;
     const previousInputState = measurement.forecastInputState ?? null;
     const currentInputState = forecastInputState(tracks, unavailableInput);
@@ -1148,9 +1093,13 @@ export class ViewerRequests {
     const forecastInputKey = unavailableInput ? JSON.stringify([
       unavailableInput.sourceId, unavailableInput.trackId, unavailableInput.segmentIndex, unavailableInput.phase
     ]) : null;
-    if (measurement.forecastReason !== forecast.reason || measurement.forecastInputKey !== forecastInputKey) {
+    const browserEvidenceKey = browserServiceFingerprint(tracks);
+    const browserEvidenceChanged = measurement.browserEvidenceKey !== browserEvidenceKey;
+    if (measurement.forecastReason !== forecast.reason || measurement.forecastInputKey !== forecastInputKey ||
+        browserEvidenceChanged) {
       measurement.forecastReason = forecast.reason;
       measurement.forecastInputKey = forecastInputKey;
+      measurement.browserEvidenceKey = browserEvidenceKey;
       if (forecast.subtitles) this.#host.observeWait?.(session.file.sourceKey, "process", {
         process: "C3", phase: "event", fileIndex: session.file.fileIndex,
         trackIndex: forecast.subtitles.trackIndex, ready: forecast.subtitles.ready,
@@ -1172,8 +1121,10 @@ export class ViewerRequests {
           downloadRateBytesPerSecond: this.#host.playbackReadiness.forecastRate(downloadRateReadings, now, 0, "time"),
           downloadRateSummaries
         })),
-        tracks: tracks.map(({ id, processedSeconds, readings, segments, readySegmentIndices }) => ({
-          id, processedSeconds, readings, segments: segments.length, prepared: readySegmentIndices.length
+        tracks: tracks.map(({ id, processedSeconds, readings, segments, readySegmentIndices, appendService, fragmentService }) => ({
+          id, processedSeconds, readings, appendService: browserServiceSummary(appendService),
+          fragmentService: browserServiceSummary(fragmentService), segments: segments.length,
+          prepared: readySegmentIndices.length
         }))
       })}`);
     }
@@ -1466,31 +1417,6 @@ function linkMeasurementOf(viewer, reportedMbps, reportedAgeMs) {
   return { mbps, ageMs };
 }
 
-/**
- * Convert a learned full wait into the time still expected after this action.
- *
- * @param {number | null} totalSeconds
- * @param {number} elapsedMs
- * @returns {number | null}
- */
-function earlyWaitRemainingSeconds(totalSeconds, elapsedMs) {
-  if (!Number.isFinite(totalSeconds) || totalSeconds < 0 || !Number.isFinite(elapsedMs) || elapsedMs < 0) return null;
-  return Math.max(0, totalSeconds - elapsedMs / 1000);
-}
-
-/**
- * Prefer the browser's monotonic age of the original action; retain a proxy
- * monotonic clock fallback for older pages that do not send it.
- *
- * @param {object} context
- * @param {number | undefined} reportedElapsedMs
- * @returns {number}
- */
-function waitElapsedSince(context, reportedElapsedMs) {
-  if (Number.isFinite(reportedElapsedMs) && reportedElapsedMs >= 0) return reportedElapsedMs;
-  return Number.isFinite(context.startedAt) ? Math.max(0, performance.now() - context.startedAt) : 0;
-}
-
 /**
  * The download service a source's forecast runs on: what the swarm carried
  * while our selection held none of its connections back, but never less than

package/services/viewer/Viewer.js

@@ -43,6 +43,104 @@
 import { Assignments } from "./Assignments.js";
 import { bufferTrend, trendRunStart } from "./buffer-trend.js";
 
+const APPEND_TRACKS = ["video", "audio"];
+const APPEND_KINDS = ["init", "media"];
+const FRAGMENT_EVENT_AGES = ["loadStart", "loadFirstByte", "loadEnd", "parseStart", "parseEnd",
+  "bufferingStart", "bufferingEnd"];
+
+function fragmentEventAges(value) {
+  return Object.fromEntries(FRAGMENT_EVENT_AGES.map(name => [name,
+    Number.isFinite(value?.[name]) && value[name] >= 0 ? value[name] : null]));
+}
+
+function appendServiceSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const snapshot = {};
+  for (const track of APPEND_TRACKS) {
+    if (!value[track] || typeof value[track] !== "object" || Array.isArray(value[track])) return null;
+    snapshot[track] = {};
+    for (const kind of APPEND_KINDS) {
+      const item = value[track][kind];
+      if (!item || !Number.isSafeInteger(item.bytes) || item.bytes < 0 || !Number.isSafeInteger(item.operations) ||
+          item.operations < 0 || !Number.isFinite(item.elapsedMs) || item.elapsedMs < 0 ||
+          (item.operations === 0 && (item.bytes > 0 || item.elapsedMs > 0)) ||
+          (item.operations > 0 && (item.bytes === 0 || item.elapsedMs === 0)) || !Array.isArray(item.samples) ||
+          !item.samples.every(sample => Number.isSafeInteger(sample?.bytes) && sample.bytes > 0 &&
+            Number.isFinite(sample.elapsedMs) && sample.elapsedMs > 0 &&
+            Number.isFinite(sample.ageMs) && sample.ageMs >= 0 &&
+            (sample.fragmentId === null || typeof sample.fragmentId === "string" && sample.fragmentId.length <= 128) &&
+            (sample.fragmentSequence === undefined || sample.fragmentSequence === null ||
+              Number.isSafeInteger(sample.fragmentSequence) && sample.fragmentSequence >= 0) &&
+            (sample.partIndex === undefined || sample.partIndex === null ||
+              Number.isSafeInteger(sample.partIndex) && sample.partIndex >= 0) &&
+            (sample.fragmentStartSeconds === null || Number.isFinite(sample.fragmentStartSeconds)))) return null;
+      snapshot[track][kind] = { bytes: item.bytes, elapsedMs: item.elapsedMs, operations: item.operations,
+        samples: item.samples.map(({ bytes, elapsedMs, ageMs, fragmentId, fragmentSequence, partIndex,
+          fragmentStartSeconds }) => ({ bytes, elapsedMs, ageMs, fragmentId,
+          fragmentSequence: fragmentSequence ?? null, partIndex: partIndex ?? null, fragmentStartSeconds })) };
+    }
+  }
+  return snapshot;
+}
+
+function fragmentServiceSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const snapshot = {};
+  for (const track of APPEND_TRACKS) {
+    if (!value[track] || typeof value[track] !== "object" || Array.isArray(value[track])) return null;
+    snapshot[track] = {};
+    for (const kind of APPEND_KINDS) {
+      const item = value[track][kind];
+      if (!item || typeof item !== "object" || Array.isArray(item) || !Number.isSafeInteger(item.bytes) || item.bytes < 0 ||
+          !Number.isFinite(item.elapsedMs) || item.elapsedMs < 0 || !Number.isSafeInteger(item.operations) ||
+          item.operations < 0 || (item.operations === 0 && (item.bytes > 0 || item.elapsedMs > 0)) ||
+          (item.operations > 0 && (item.bytes === 0 || item.elapsedMs === 0)) || !Array.isArray(item.samples) ||
+          !item.samples.every(sample => Number.isSafeInteger(sample?.bytes) && sample.bytes > 0 &&
+            Number.isFinite(sample.elapsedMs) && sample.elapsedMs > 0 &&
+            Number.isFinite(sample.ageMs) && sample.ageMs >= 0 &&
+            (sample.parseElapsedMs === undefined || sample.parseElapsedMs === null ||
+              Number.isFinite(sample.parseElapsedMs) && sample.parseElapsedMs >= 0) &&
+            (sample.bufferingElapsedMs === undefined || sample.bufferingElapsedMs === null ||
+              Number.isFinite(sample.bufferingElapsedMs) && sample.bufferingElapsedMs >= 0) &&
+            (sample.bufferingAgeMs === undefined || sample.bufferingAgeMs === null ||
+              Number.isFinite(sample.bufferingAgeMs) && sample.bufferingAgeMs >= 0) &&
+            (sample.eventAgesMs === undefined || sample.eventAgesMs && typeof sample.eventAgesMs === "object" &&
+              !Array.isArray(sample.eventAgesMs) && Object.values(sample.eventAgesMs).every(age =>
+                age === null || Number.isFinite(age) && age >= 0)) &&
+            (sample.fragmentId === null || typeof sample.fragmentId === "string" && sample.fragmentId.length <= 128) &&
+            (sample.fragmentSequence === undefined || sample.fragmentSequence === null ||
+              Number.isSafeInteger(sample.fragmentSequence) && sample.fragmentSequence >= 0) &&
+            (sample.partIndex === undefined || sample.partIndex === null ||
+              Number.isSafeInteger(sample.partIndex) && sample.partIndex >= 0) &&
+            (sample.fragmentStartSeconds === null || Number.isFinite(sample.fragmentStartSeconds)))) {
+        return null;
+      }
+      snapshot[track][kind] = { bytes: item.bytes, elapsedMs: item.elapsedMs, operations: item.operations,
+        samples: item.samples.map(({ bytes, elapsedMs, ageMs, fragmentId, fragmentSequence, partIndex, fragmentStartSeconds,
+          parseElapsedMs, bufferingElapsedMs, bufferingAgeMs, eventAgesMs }) =>
+          ({ bytes, elapsedMs, ageMs, fragmentId, fragmentSequence: fragmentSequence ?? null,
+            partIndex: partIndex ?? null, fragmentStartSeconds,
+            parseElapsedMs: parseElapsedMs ?? null, bufferingElapsedMs: bufferingElapsedMs ?? null,
+            bufferingAgeMs: bufferingAgeMs ?? null, eventAgesMs: fragmentEventAges(eventAgesMs) })) };
+    }
+  }
+  return snapshot;
+}
+
+function appendServiceIsMonotonic(next, previous) {
+  return APPEND_TRACKS.every(track => APPEND_KINDS.every(kind =>
+    next[track][kind].bytes >= previous[track][kind].bytes &&
+    next[track][kind].elapsedMs >= previous[track][kind].elapsedMs &&
+    next[track][kind].operations >= previous[track][kind].operations));
+}
+
+function fragmentServiceIsMonotonic(next, previous) {
+  return APPEND_TRACKS.every(track => APPEND_KINDS.every(kind =>
+    next[track][kind].bytes >= previous[track][kind].bytes &&
+    next[track][kind].elapsedMs >= previous[track][kind].elapsedMs &&
+    next[track][kind].operations >= previous[track][kind].operations));
+}
+
 /**
  * How long a generation this viewer has left behind goes on accepting NEW
  * requests.
@@ -373,6 +471,11 @@ export class Viewer {
    *   report still stands: this is a statement about a viewer, not about a link.
    * @param {number} [report.linkSampleAgeMs] - How old the newest raw link
    *   sample was when this report was made.
+   * @param {string} [report.appendSessionId] - Which output the page measured appends for.
+   * @param {string} [report.appendEpoch] - Counter identity; a new page reporter starts a new epoch.
+   * @param {number} [report.appendEpochStartedAt] - Browser epoch start clock used to reject delayed reports from an older reporter.
+   * @param {object} [report.appendService] - Cumulative append totals and recent per-operation byte/time samples.
+   * @param {object} [report.fragmentService] - Cumulative fragment parse totals and recent per-fragment samples.
    * @param {number} report.bufferedAheadSec
    * @param {number} [report.bufferLimitSeconds] - The largest forward buffer
    *   this browser accepted for the current player.
@@ -399,6 +502,12 @@ export class Viewer {
       linkSampleMbps = null,
       linkSampleAt = null,
       linkSampleAgeMs = null,
+      appendSessionId = null,
+      appendEpoch = null,
+      appendEpochStartedAt = null,
+      appendSnapshotAt = null,
+      appendService: appendServiceReading = null,
+      fragmentService: fragmentServiceReading = null,
       bufferedAheadSec,
       bufferedRanges,
       timestampOffsets,
@@ -439,6 +548,20 @@ export class Viewer {
     const sampleMbps = Number(linkSampleMbps);
     const sampleAt = Number(linkSampleAt);
     const previous = this.netReport;
+    const incomingAppendService = typeof appendEpoch === "string" && appendEpoch.length > 0
+      ? appendServiceSnapshot(appendServiceReading) : null;
+    const incomingFragmentService = typeof appendEpoch === "string" && appendEpoch.length > 0
+      ? fragmentServiceSnapshot(fragmentServiceReading) : null;
+    const sameAppendEpoch = appendSessionId === previous?.appendSessionId && appendEpoch === previous?.appendEpoch;
+    const validAppendEpochTime = Number.isFinite(appendEpochStartedAt) && appendEpochStartedAt > 0;
+    const validAppendSnapshotTime = Number.isFinite(appendSnapshotAt) && appendSnapshotAt >= appendEpochStartedAt;
+    const useBrowserService = !stale && typeof appendSessionId === "string" && appendSessionId.length > 0 &&
+      incomingAppendService && incomingFragmentService &&
+      validAppendEpochTime && validAppendSnapshotTime && (sameAppendEpoch
+        ? appendEpochStartedAt === previous?.appendEpochStartedAt && appendSnapshotAt > (previous?.appendSnapshotAt ?? 0) &&
+          (!previous?.appendService || appendServiceIsMonotonic(incomingAppendService, previous.appendService)) &&
+          (!previous?.fragmentService || fragmentServiceIsMonotonic(incomingFragmentService, previous.fragmentService))
+        : appendEpochStartedAt > (previous?.appendEpochStartedAt ?? 0));
     const hasPlaybackSample = Number.isFinite(sampleMbps) && sampleMbps > 0 &&
       Number.isFinite(sampleAt) && sampleAt > 0;
     const newerPlaybackSample = hasPlaybackSample && sampleAt > (this.netReport?.linkSampleAt ?? 0);
@@ -452,6 +575,13 @@ export class Viewer {
           ? now - linkSampleAgeMs
           : now
         : this.netReport?.linkSampleMeasuredAt ?? null,
+      appendSessionId: useBrowserService ? appendSessionId : previous?.appendSessionId ?? null,
+      appendEpoch: useBrowserService ? appendEpoch : previous?.appendEpoch ?? null,
+      appendEpochStartedAt: useBrowserService ? appendEpochStartedAt : previous?.appendEpochStartedAt ?? null,
+      appendSnapshotAt: useBrowserService ? appendSnapshotAt : previous?.appendSnapshotAt ?? null,
+      appendService: useBrowserService ? incomingAppendService : previous?.appendService ?? null,
+      fragmentService: useBrowserService ? incomingFragmentService : previous?.fragmentService ?? null,
+      appendServiceReceivedAt: useBrowserService ? now : previous?.appendServiceReceivedAt ?? null,
       bufferedAheadSec: held,
       timestampOffsets: Object.fromEntries(["video", "audio"].filter((key) =>
         Number.isFinite(timestampOffsets?.[key])).map((key) => [key, timestampOffsets[key]])),

package/services/viewer/playback-readiness.js

@@ -42,6 +42,46 @@ import {
 // timestamps can extend slightly beyond its nominal playlist boundary.
 export const PLAYER_SEEK_TOLERANCE_SECONDS = 0.25;
 
+/**
+ * Choose a point for a supported completion-time distribution under absolute
+ * relative error. For positive completions, minimizing E[|x - T| / T] is a
+ * weighted-median problem with mass p/T. A distribution mixing immediate and
+ * positive completion has no point under this loss definition.
+ *
+ * This summarizes an already-supported probability distribution; it does not
+ * fit one from completed whole waits or supply missing service observations.
+ *
+ * @param {Array<{ completionSeconds: number, probability: number }>} support
+ * @returns {{ pointSeconds: number | null, immediateProbability: number, supportCount: number } | null}
+ */
+export function completionPointUnderRelativeLoss(support) {
+  if (!Array.isArray(support) || support.length === 0 || support.some(sample =>
+    !Number.isFinite(sample?.completionSeconds) || sample.completionSeconds < 0 ||
+    !Number.isFinite(sample?.probability) || sample.probability < 0)) return null;
+  const positiveMass = support.filter(sample => sample.probability > 0);
+  const totalProbability = positiveMass.reduce((sum, sample) => sum + sample.probability, 0);
+  if (!(totalProbability > 0) || !Number.isFinite(totalProbability)) return null;
+  const immediateProbability = positiveMass.filter(sample => sample.completionSeconds === 0)
+    .reduce((sum, sample) => sum + sample.probability, 0) / totalProbability;
+  const positive = positiveMass.filter(sample => sample.completionSeconds > 0);
+  if (positive.length === 0) return { pointSeconds: 0, immediateProbability: 1, supportCount: positiveMass.length };
+  if (immediateProbability > 0) {
+    return { pointSeconds: null, immediateProbability, supportCount: positiveMass.length };
+  }
+  const weighted = positive.map(sample => ({ seconds: sample.completionSeconds,
+    weight: sample.probability / sample.completionSeconds })).sort((left, right) => left.seconds - right.seconds);
+  const totalWeight = weighted.reduce((sum, sample) => sum + sample.weight, 0);
+  if (!(totalWeight > 0) || !Number.isFinite(totalWeight)) return null;
+  let cumulativeWeight = 0;
+  for (const sample of weighted) {
+    cumulativeWeight += sample.weight;
+    if (cumulativeWeight * 2 >= totalWeight) {
+      return { pointSeconds: sample.seconds, immediateProbability: 0, supportCount: positiveMass.length };
+    }
+  }
+  return null;
+}
+
 /**
  * @param {number} segmentEndSeconds
  * @param {number} positionSeconds
@@ -191,6 +231,7 @@ export class RateTrend {
  *   segmentCount?: number,
  *   bitsPerMediaSecond: number, readings: Array<{ at: number, value: number }>,
  *   clockOffsetSeconds?: number, clientRanges?: Array<{ start: number, end: number }>,
+ *   appendService?: object, fragmentService?: object,
  *   segments: Array<{ index: number, startSeconds: number, endSeconds: number,
  *     mediaRanges?: { timescale: bigint | null, ranges: Array<{ start: bigint, end: bigint, frame: bigint }> } }>,
  *   readySegmentIndices: number[], segmentSizesBytes: Map<number, number> | object }>} input.tracks
@@ -300,6 +341,13 @@ export function predictPlaybackReadiness(input = {}) {
       : Math.max(0, ...track.segments.map(segment => segment.index + 1)),
     clockSeconds: Number.isFinite(track.clockOffsetSeconds) ? track.clockOffsetSeconds : 0
   }));
+  const missingFirstGeometry = trackState.slice(0, requiredTracks).some(({ segments }) => {
+    const first = segments.find(segment => segment.endSeconds > position);
+    return first && first.ranges.length === 0;
+  });
+  if (missingFirstGeometry) {
+    return result(false, null, buffered, reserve, null, "first-required-media-ranges-unavailable", 0);
+  }
   for (const state of trackState) {
     state.tailEndSeconds = Number.isFinite(horizonEnd) && horizonEnd < duration
       ? Math.min(duration, state.durationSeconds + state.clockSeconds) : null;
@@ -707,16 +755,68 @@ export function predictPlaybackReadiness(input = {}) {
     const first = state.segments.find(segment => segment.endSeconds > position);
     if (!first) return { track: state.track.id ?? trackIndex, segment: null, alreadyBuffered: true,
       sourceArrivalSeconds: 0, runAdmissionSeconds: null, runOpenSeconds: 0, productionStartSeconds: 0,
-      productionCompleteSeconds: 0, deliveryCompleteSeconds: 0, appendSeconds: 0, completionSeconds: 0 };
+      productionCompleteSeconds: 0, deliveryCompleteSeconds: 0, browserLoadToParseSeconds: 0,
+      appendRequestToAckSeconds: 0, appendSeconds: 0, completionSeconds: 0 };
+    if (!Array.isArray(first.ranges) || first.ranges.length === 0) return {
+      track: state.track.id ?? trackIndex,
+      segment: first.index,
+      alreadyBuffered: null,
+      mediaRangesReason: "first-required-media-ranges-unavailable",
+      sourceArrivalSeconds: null,
+      runAdmissionSeconds: null,
+      runOpenSeconds: null,
+      productionStartSeconds: null,
+      productionCompleteSeconds: null,
+      deliveryCompleteSeconds: null,
+      browserLoadToParseSeconds: null,
+      browserLoadToParseReason: "fragment-load-to-parse-distribution-unavailable",
+      appendRequestToAckSeconds: null,
+      appendRequestToAckReason: "append-request-to-ack-distribution-unavailable",
+      appendSeconds: null,
+      appendReason: "append-request-to-ack-distribution-unavailable",
+      completionSeconds: null
+    };
     if (first.ranges.every(range => contains(state.clientRanges, range.start, range.end))) {
       return { track: state.track.id ?? trackIndex, segment: first.index, alreadyBuffered: true,
         sourceArrivalSeconds: 0, runAdmissionSeconds: null, runOpenSeconds: 0, productionStartSeconds: 0,
-        productionCompleteSeconds: 0, deliveryCompleteSeconds: 0, appendSeconds: 0, completionSeconds: 0 };
+        productionCompleteSeconds: 0, deliveryCompleteSeconds: 0, browserLoadToParseSeconds: 0,
+        appendRequestToAckSeconds: 0, appendSeconds: 0, completionSeconds: 0 };
     }
     const completion = completions.find(item => item.trackIndex === trackIndex && item.segment.index === first.index);
+    // HLS playlists for these generated outputs use MEDIA-SEQUENCE:0, so a
+    // complete media fragment's HLS sequence number is the output segment
+    // index. Keep matched browser observations as evidence only: their recent
+    // completed-work spans are not a future-service distribution.
+    const samplesForFirstSegment = (kind) => (service) => {
+      const samples = service?.[kind]?.samples;
+      return Array.isArray(samples) ? samples.filter(sample => sample.fragmentSequence === first.index &&
+        sample.partIndex === null) : [];
+    };
+    const observedBrowserWork = {
+      evidenceOnly: true,
+      fragmentLoadToParse: samplesForFirstSegment("media")(state.track.fragmentService).map(sample => ({
+        bytes: sample.bytes,
+        elapsedMs: sample.elapsedMs,
+        parseElapsedMs: sample.parseElapsedMs ?? null,
+        bufferingElapsedMs: sample.bufferingElapsedMs ?? null,
+        ageMs: sample.ageMs,
+        bufferingAgeMs: sample.bufferingAgeMs ?? null,
+        eventAgesMs: sample.eventAgesMs ?? null
+      })),
+      appendRequestToAck: samplesForFirstSegment("media")(state.track.appendService).map(sample => ({
+        bytes: sample.bytes,
+        elapsedMs: sample.elapsedMs,
+        ageMs: sample.ageMs
+      }))
+    };
+    const observedBrowserWorkField = observedBrowserWork.fragmentLoadToParse.length > 0 ||
+      observedBrowserWork.appendRequestToAck.length > 0 ? { observedBrowserWork } : {};
     if (!completion) return { track: state.track.id ?? trackIndex, segment: first.index, alreadyBuffered: false,
       sourceArrivalSeconds: null, runAdmissionSeconds: null, runOpenSeconds: null, productionStartSeconds: null,
-      productionCompleteSeconds: null, deliveryCompleteSeconds: null, appendSeconds: null, completionSeconds: null };
+      productionCompleteSeconds: null, deliveryCompleteSeconds: null, browserLoadToParseSeconds: null,
+      browserLoadToParseReason: "fragment-load-to-parse-distribution-unavailable",
+      appendRequestToAckSeconds: null, appendRequestToAckReason: "append-request-to-ack-distribution-unavailable",
+      appendSeconds: null, completionSeconds: null, ...observedBrowserWorkField };
     const production = productions.find(item => item.trackIndex === trackIndex && item.segment.index === first.index);
     return { track: state.track.id ?? trackIndex, segment: first.index, alreadyBuffered: false,
       sourceArrivalSeconds: production?.sourceArrivalAt ?? 0,
@@ -725,8 +825,14 @@ export function predictPlaybackReadiness(input = {}) {
       productionStartSeconds: production?.productionStartAt ?? null,
       productionCompleteSeconds: production?.at ?? null,
       deliveryCompleteSeconds: completion.deliveryAt,
-      appendSeconds: completion.appendSeconds,
-      completionSeconds: completion.at };
+      browserLoadToParseSeconds: null,
+      browserLoadToParseReason: "fragment-load-to-parse-distribution-unavailable",
+      appendRequestToAckSeconds: null,
+      appendRequestToAckReason: "append-request-to-ack-distribution-unavailable",
+      appendSeconds: null,
+      appendReason: "append-request-to-ack-distribution-unavailable",
+      completionSeconds: null,
+      ...observedBrowserWorkField };
   });
   const firstRequiredTrackSeconds = firstRequiredStages.map(stage => stage.completionSeconds);
   const firstRequiredSegmentsSeconds = firstRequiredTrackSeconds.every(Number.isFinite)