From 7fdc2559013527f5c5ace542b33b992c3929fcd8 Mon Sep 17 00:00:00 2001
From: Christian Pillsbury <cpillsbury@mux.com>
Date: Mon, 27 Jul 2026 11:55:21 -0700
Subject: [PATCH] feat(spf): relocate non-zero-PTS sources to a 0-based
 timeline (VOD) (#1847)

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 apps/sandbox/app/shared/sources.ts            |   8 +
 .../templates/spf-segment-loading/favicon.svg |   7 +
 .../templates/spf-segment-loading/index.html  |  33 +-
 .../templates/spf-segment-loading/main.ts     |  98 +++-
 .../end-of-stream-av-skew-recovery.md         | 102 ++++
 internal/decisions/mse-timestamp-offset.md    | 192 ++++++++
 .../spf/features/edit-list-compensation.md    |  42 +-
 .../spf/features/non-zero-pts-support.md      | 455 ++++++++----------
 .../design/spf/presentation-timeline-model.md | 402 ++++++++++++++++
 .../spf/src/media/buffer/forward-buffer.ts    |  41 +-
 .../media/buffer/tests/forward-buffer.test.ts |  85 +++-
 .../spf/src/media/dom/mse/append-segment.ts   |   6 +-
 packages/spf/src/media/dom/mse/duration.ts    |  45 +-
 .../src/media/dom/mse/tests/duration.test.ts  |  53 +-
 .../src/media/dom/text/resolve-vtt-segment.ts |  34 +-
 .../text/tests/resolve-vtt-segment.test.ts    |  53 +-
 packages/spf/src/media/mp4/box.ts             |  88 ++++
 packages/spf/src/media/mp4/tests/box.test.ts  |  66 +++
 .../src/media/mp4/tests/synthetic-boxes.ts    | 124 +++++
 .../media/mp4/tests/timestamp-origin.test.ts  | 103 ++++
 .../spf/src/media/mp4/timestamp-origin.ts     | 155 ++++++
 .../src/media/text/parse-vtt-timestamp-map.ts |  55 +++
 .../src/media/text/resolve-vtt-metadata.ts    |  28 ++
 .../tests/parse-vtt-timestamp-map.test.ts     |  34 ++
 packages/spf/src/media/types/index.ts         |  45 ++
 .../src/playback/actors/dom/segment-loader.ts | 247 ++++------
 .../src/playback/actors/dom/source-buffer.ts  |  39 +-
 .../src/playback/actors/dom/text-tracks.ts    |  10 +-
 .../spf/src/playback/actors/dom/tsconfig.json |   3 +-
 .../actors/text-track-segment-loader.ts       |  75 +--
 .../spf/src/playback/actors/text-tracks.ts    |  10 +-
 .../spf/src/playback/actors/tsconfig.json     |   7 +-
 .../playback/behaviors/dom/end-of-stream.ts   |  26 +-
 .../behaviors/dom/recover-end-stall.ts        | 123 +++++
 .../behaviors/dom/setup-buffer-actors.ts      |  36 +-
 .../behaviors/dom/setup-text-track-actors.ts  |  36 +-
 .../tests/load-segments-track-switch.test.ts  | 226 ++++++++-
 .../tests/load-text-track-segments.test.ts    |   6 +-
 .../dom/tests/recover-end-stall.test.ts       |  50 ++
 .../behaviors/establish-start-media-time.ts   | 233 +++++++++
 .../tests/establish-start-media-time.test.ts  | 159 ++++++
 .../playback/engines/hls/engine-audio-only.ts |  33 +-
 .../spf/src/playback/engines/hls/engine.ts    |  69 ++-
 .../spf/src/playback/engines/hls/index.ts     |   8 +
 .../src/playback/engines/hls/tsconfig.json    |   1 +
 .../primitives/derive-start-media-time.ts     |  25 +
 .../spf/src/playback/primitives/head-peek.ts  |  45 ++
 .../primitives/relocation-pipelines.ts        | 267 ++++++++++
 .../primitives/segment-load-pipeline.ts       | 210 ++++++++
 .../primitives/source-buffer-messages.ts      |  38 ++
 .../tests/relocation-pipelines.test.ts        | 152 ++++++
 .../primitives/text-segment-load-pipeline.ts  | 161 +++++++
 .../primitives/text-track-messages.ts         |  16 +
 53 files changed, 4127 insertions(+), 538 deletions(-)
 create mode 100644 apps/sandbox/templates/spf-segment-loading/favicon.svg
 create mode 100644 internal/decisions/end-of-stream-av-skew-recovery.md
 create mode 100644 internal/decisions/mse-timestamp-offset.md
 create mode 100644 internal/design/spf/presentation-timeline-model.md
 create mode 100644 packages/spf/src/media/mp4/box.ts
 create mode 100644 packages/spf/src/media/mp4/tests/box.test.ts
 create mode 100644 packages/spf/src/media/mp4/tests/synthetic-boxes.ts
 create mode 100644 packages/spf/src/media/mp4/tests/timestamp-origin.test.ts
 create mode 100644 packages/spf/src/media/mp4/timestamp-origin.ts
 create mode 100644 packages/spf/src/media/text/parse-vtt-timestamp-map.ts
 create mode 100644 packages/spf/src/media/text/resolve-vtt-metadata.ts
 create mode 100644 packages/spf/src/media/text/tests/parse-vtt-timestamp-map.test.ts
 create mode 100644 packages/spf/src/playback/behaviors/dom/recover-end-stall.ts
 create mode 100644 packages/spf/src/playback/behaviors/dom/tests/recover-end-stall.test.ts
 create mode 100644 packages/spf/src/playback/behaviors/establish-start-media-time.ts
 create mode 100644 packages/spf/src/playback/behaviors/tests/establish-start-media-time.test.ts
 create mode 100644 packages/spf/src/playback/primitives/derive-start-media-time.ts
 create mode 100644 packages/spf/src/playback/primitives/head-peek.ts
 create mode 100644 packages/spf/src/playback/primitives/relocation-pipelines.ts
 create mode 100644 packages/spf/src/playback/primitives/segment-load-pipeline.ts
 create mode 100644 packages/spf/src/playback/primitives/source-buffer-messages.ts
 create mode 100644 packages/spf/src/playback/primitives/tests/relocation-pipelines.test.ts
 create mode 100644 packages/spf/src/playback/primitives/text-segment-load-pipeline.ts
 create mode 100644 packages/spf/src/playback/primitives/text-track-messages.ts

diff --git a/apps/sandbox/app/shared/sources.ts b/apps/sandbox/app/shared/sources.ts
index eedd5ab9..0bfcce50 100644
--- a/apps/sandbox/app/shared/sources.ts
+++ b/apps/sandbox/app/shared/sources.ts
@@ -43,6 +43,14 @@ export const SOURCES = {
     type: 'hls',
     subType: 'mp4',
   },
+  'hls-instant-clip': {
+    // Clipped 60s→600s of the multi-audio asset, so A/V encode at native PTS ≈ 60s.
+    // Exercises non-zero-PTS timestampOffset relocation: currentTime stays 0-based.
+    label: 'HLS - Instant Clip (non-zero PTS)',
+    url: 'https://stream.mux.com/s41JYeqIpBMBzE4OzxDyGR2yrp2hD1CQ6gJN9SlVGDQ.m3u8?asset_start_time=60&asset_end_time=600',
+    type: 'hls',
+    subType: 'mp4',
+  },
   'hls-live': {
     label: 'HLS - Live Stream Big Buck Bunny',
     url: 'https://stream.mux.com/v69RSHhFelSm4701snP22dYz2jICy4E4FUyk02rW4gxRM.m3u8',
diff --git a/apps/sandbox/templates/spf-segment-loading/favicon.svg b/apps/sandbox/templates/spf-segment-loading/favicon.svg
new file mode 100644
index 00000000..e253e300
--- /dev/null
+++ b/apps/sandbox/templates/spf-segment-loading/favicon.svg
@@ -0,0 +1,7 @@
+<svg viewBox="0 0 90 90" xmlns="http://www.w3.org/2000/svg">
+  <path fill="#fcb116" d="M0 0h90v90H0z" />
+  <path fill="#f26222" d="M0 22.5h90V90H0z" />
+  <path fill="#ea3837" d="M0 45h90v45H0z" />
+  <path fill="#a83b71" d="M0 67.5h90V90H0z" />
+  <path d="M71.954 45L28.046 73.125v-56.25L71.954 45z" fill="#ebe4c1" />
+</svg>
diff --git a/apps/sandbox/templates/spf-segment-loading/index.html b/apps/sandbox/templates/spf-segment-loading/index.html
index 9c3b862a..6a3c8c42 100644
--- a/apps/sandbox/templates/spf-segment-loading/index.html
+++ b/apps/sandbox/templates/spf-segment-loading/index.html
@@ -3,6 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" href="./favicon.svg" type="image/svg+xml" />
     <title>Sandbox — SPF Segment Loading POC</title>
     <style>
       body {
@@ -24,14 +25,27 @@
 
       /* ── Src controls ── */
       #src-controls {
+        display: flex;
+        flex-direction: column;
+        gap: 8px;
+        align-items: stretch;
+        max-width: 620px;
+        margin-bottom: 10px;
+      }
+      #src-preset {
+        padding: 6px 10px;
+        font-family: monospace;
+        font-size: 12px;
+        border: 1px solid #999;
+        border-radius: 4px;
+      }
+      #src-input-row {
         display: flex;
         gap: 8px;
         align-items: center;
-        margin-bottom: 10px;
       }
       #src-input {
         flex: 1;
-        max-width: 540px;
         padding: 6px 10px;
         font-family: monospace;
         font-size: 12px;
@@ -207,13 +221,19 @@
     <p>Testing segment loading pipeline with real Mux HLS stream</p>
 
     <div id="src-controls">
-      <input type="text" id="src-input" placeholder="Stream URL…" />
-      <button type="button" id="set-src">Set Src</button>
+      <select id="src-preset" title="Load a preset source">
+        <option value="">— preset sources —</option>
+      </select>
+      <div id="src-input-row">
+        <input type="text" id="src-input" placeholder="Stream URL…" />
+        <button type="button" id="set-src">Set Src</button>
+      </div>
     </div>
 
     <div id="playback-config">
       <label><input type="checkbox" id="muted-toggle" /> Muted</label>
       <label><input type="checkbox" id="autoplay-toggle" /> Autoplay</label>
+      <label><input type="checkbox" id="loop-toggle" /> Loop</label>
       <label>
         Preload:
         <select id="preload-select">
@@ -222,6 +242,11 @@
           <option value="auto">auto</option>
         </select>
       </label>
+      <label
+        title="Filter out HEVC renditions so ABR stays within one codec family, avoiding SourceBuffer.changeType() (not yet implemented). Needed for mixed-codec sources like the Apple bipbop example."
+      >
+        <input type="checkbox" id="avc-only-toggle" /> AVC-only (avoid changeType)
+      </label>
     </div>
 
     <div id="share-url-section">
diff --git a/apps/sandbox/templates/spf-segment-loading/main.ts b/apps/sandbox/templates/spf-segment-loading/main.ts
index 85915122..4b36acda 100644
--- a/apps/sandbox/templates/spf-segment-loading/main.ts
+++ b/apps/sandbox/templates/spf-segment-loading/main.ts
@@ -6,8 +6,11 @@ import '@app/styles.css';
 //   src=<url>            Stream URL (overrides TEST_STREAM default)
 //   muted=true           Start muted
 //   autoplay=true        Start with autoplay enabled
+//   loop=true            Loop playback
 //   preload=auto|metadata|none  Initial preload mode
+//   avcOnly=true         Filter out HEVC renditions (avoids changeType; see the toggle)
 
+import { SOURCE_IDS, SOURCES } from '@app/shared/sources';
 import { effect, snapshot } from '@videojs/spf';
 import type { SimpleHlsEngineSignals, SimpleHlsEngineState } from '@videojs/spf/hls';
 import { createSimpleHlsEngine } from '@videojs/spf/hls';
@@ -22,26 +25,83 @@ const textTrackButtonsDiv = document.getElementById('text-track-buttons') as HTM
 const resolutionListDiv = document.getElementById('resolution-list') as HTMLDivElement;
 const nowPlayingQualityDiv = document.getElementById('now-playing-quality') as HTMLDivElement;
 const throughputDiv = document.getElementById('throughput-display') as HTMLDivElement;
+const srcPreset = document.getElementById('src-preset') as HTMLSelectElement;
 const srcInput = document.getElementById('src-input') as HTMLInputElement;
 const setSrcBtn = document.getElementById('set-src') as HTMLButtonElement;
+const avcOnlyToggle = document.getElementById('avc-only-toggle') as HTMLInputElement;
 const mutedToggle = document.getElementById('muted-toggle') as HTMLInputElement;
 const autoplayToggle = document.getElementById('autoplay-toggle') as HTMLInputElement;
+const loopToggle = document.getElementById('loop-toggle') as HTMLInputElement;
 const preloadSelect = document.getElementById('preload-select') as HTMLSelectElement;
 const shareLink = document.getElementById('share-link') as HTMLAnchorElement;
 
 // ── Query params ──────────────────────────────────────────────────────────────
 const DEFAULT_STREAM = 'https://stream.mux.com/JX01bG8eB4uaoV3OpDuK602rBfvdSgrMObjwuUOBn4JrQ.m3u8';
+
+// Preset sources. The non-zero-PTS examples exercise `timestampOffset` relocation
+// (A/V encodes at native PTS ≠ 0, but currentTime/seekable stay 0-based). Apple's
+// example muxes HEVC + AVC renditions, so it needs AVC-only (see `avcOnly`).
+// `unsupported`, when set, is the reason SPF can't play the source; such presets
+// are shown disabled (see the picker population) rather than hidden.
+type Preset = { label: string; url: string; avcOnly?: boolean; unsupported?: string };
+
+// Harness-specific sources not in the shared registry. The Apple bipbop example
+// muxes HEVC + AVC, so it needs AVC-only — engine-limitation metadata that
+// doesn't belong in shared SOURCES (no other template needs it).
+const HARNESS_PRESETS: Preset[] = [
+  {
+    label: 'Apple bipbop HEVC (44ms A/V skew + VTT X-TIMESTAMP-MAP · needs AVC-only)',
+    url: 'https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_adv_example_hevc/master.m3u8',
+    avcOnly: true,
+  },
+];
+
+// Dropdown = every HLS source from the shared registry (DASH/raw-mp4 filtered out
+// since the raw SPF HLS engine can't play them) plus the harness-specific extras.
+// SPF only demuxes fmp4/CMAF segments, not MPEG-TS, so TS sources are kept visible
+// but flagged unsupported (disabled in the picker) rather than silently dropped.
+// Unsupported presets sort to the end (stable sort preserves registry order otherwise).
+const PRESETS: Preset[] = [
+  ...SOURCE_IDS.filter((id) => SOURCES[id].type === 'hls').map((id) => {
+    const source = SOURCES[id];
+    const preset: Preset = { label: source.label, url: source.url };
+    if ('subType' in source && source.subType === 'ts') preset.unsupported = 'TS — unsupported';
+    return preset;
+  }),
+  ...HARNESS_PRESETS,
+].sort((a, b) => Number(!!a.unsupported) - Number(!!b.unsupported));
+
+// Apple's bipbop example muxes HEVC (`hvc1`/`hev1`) + AVC renditions of the same content;
+// cross-codec ABR would need `SourceBuffer.changeType()` (not yet implemented), so filtering
+// to AVC keeps ABR within one codec family. Harmless for single-codec Mux sources.
+const avcOnly = (track: { codecs?: string[] }) =>
+  !track.codecs?.some((codec) => codec.startsWith('hvc1') || codec.startsWith('hev1'));
+
 const params = new URLSearchParams(window.location.search);
 const INITIAL_SRC = params.get('src') ?? DEFAULT_STREAM;
 const INITIAL_MUTED = params.get('muted') === 'true';
 const INITIAL_AUTOPLAY = params.get('autoplay') === 'true';
+const INITIAL_LOOP = params.get('loop') === 'true';
 const INITIAL_PRELOAD = (params.get('preload') as 'auto' | 'metadata' | 'none') ?? 'none';
+const INITIAL_AVC_ONLY = params.get('avcOnly') === 'true';
+
+// Populate the preset picker; selecting one loads it (and enables AVC-only if the
+// preset needs it). Reflects the current src when it matches a preset.
+for (const preset of PRESETS) {
+  const label = preset.unsupported ? `${preset.label} (${preset.unsupported})` : preset.label;
+  const option = new Option(label, preset.url);
+  option.disabled = !!preset.unsupported;
+  srcPreset.add(option);
+}
 
 // Apply initial query-param values to UI
 srcInput.value = INITIAL_SRC;
+srcPreset.value = PRESETS.some((preset) => preset.url === INITIAL_SRC) ? INITIAL_SRC : '';
 mutedToggle.checked = INITIAL_MUTED;
 autoplayToggle.checked = INITIAL_AUTOPLAY;
+loopToggle.checked = INITIAL_LOOP;
 preloadSelect.value = INITIAL_PRELOAD;
+avcOnlyToggle.checked = INITIAL_AVC_ONLY;
 updateShareUrl();
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
@@ -60,6 +120,12 @@ function formatBandwidth(bps: number): string {
   return `${Math.round(bps / 1000)} Kbps`;
 }
 
+function formatFrameRate(frameRate: { frameRateNumerator: number; frameRateDenominator?: number }): string {
+  const fps = frameRate.frameRateNumerator / (frameRate.frameRateDenominator ?? 1);
+  // Trim to two decimals then drop trailing zeros so 30 shows as "30" and 29.97 stays "29.97".
+  return `${Number.parseFloat(fps.toFixed(2))} fps`;
+}
+
 function getVideoTracks(presentation: SimpleHlsEngineState['presentation']) {
   return presentation?.selectionSets?.find((s) => s.type === 'video')?.switchingSets[0]?.tracks ?? [];
 }
@@ -92,7 +158,9 @@ function updateShareUrl() {
   if (src && src !== DEFAULT_STREAM) p.set('src', src);
   if (mutedToggle.checked) p.set('muted', 'true');
   if (autoplayToggle.checked) p.set('autoplay', 'true');
+  if (loopToggle.checked) p.set('loop', 'true');
   if (preloadSelect.value !== 'none') p.set('preload', preloadSelect.value);
+  if (avcOnlyToggle.checked) p.set('avcOnly', 'true');
   const url = `${window.location.origin}${window.location.pathname}${p.size > 0 ? `?${p}` : ''}`;
   shareLink.href = url;
   shareLink.textContent = url;
@@ -202,10 +270,11 @@ function getVideoSelectionGroups(tracks: ReturnType<typeof getVideoTracks>): Vid
       const width = 'width' in track ? track.width : undefined;
       const height = 'height' in track ? track.height : undefined;
       const res = width && height ? `${width}×${height} @ ` : '';
+      const fps = 'frameRate' in track && track.frameRate ? ` · ${formatFrameRate(track.frameRate)}` : '';
       const filter: VideoSelectionGroup['filter'] = { bandwidth: track.bandwidth };
       if (width) filter.width = width;
       if (height) filter.height = height;
-      group = { key, label: `${res}${formatBandwidth(track.bandwidth)}`, filter, members: [] };
+      group = { key, label: `${res}${formatBandwidth(track.bandwidth)}${fps}`, filter, members: [] };
       groups.set(key, group);
     }
     // Member ids (one per CDN for redundant streams) are surfaced in the
@@ -612,6 +681,9 @@ function startEngine(src: string) {
 
   engine = createSimpleHlsEngine({
     initialBandwidth: 1_000_000,
+    // AVC-only filters HEVC so ABR never crosses codec families (no changeType).
+    // Omitted (not set to undefined) when off, per exactOptionalPropertyTypes.
+    ...(avcOnlyToggle.checked ? { canPlayTrack: avcOnly } : {}),
     onSignalsReady: (refs) => {
       signals = refs;
     },
@@ -758,6 +830,7 @@ function startEngine(src: string) {
 try {
   video.muted = INITIAL_MUTED;
   video.autoplay = INITIAL_AUTOPLAY;
+  video.loop = INITIAL_LOOP;
   startEngine(INITIAL_SRC);
 } catch (error) {
   log(`✗ Error creating engine: ${(error as Error).message}`, 'error');
@@ -784,12 +857,29 @@ setSrcBtn.addEventListener('click', () => {
   const url = srcInput.value.trim();
   if (!url) return;
   log(`Setting src: ${url}`, 'info');
+  srcPreset.value = PRESETS.some((preset) => preset.url === url) ? url : '';
   startEngine(url);
   updateShareUrl();
 });
 
 srcInput.addEventListener('input', updateShareUrl);
 
+srcPreset.addEventListener('change', () => {
+  const preset = PRESETS.find((p) => p.url === srcPreset.value);
+  if (!preset) return;
+  srcInput.value = preset.url;
+  if (preset.avcOnly) avcOnlyToggle.checked = true;
+  log(`Preset: ${preset.label}${preset.avcOnly ? ' (AVC-only enabled)' : ''}`, 'info');
+  startEngine(preset.url);
+  updateShareUrl();
+});
+
+avcOnlyToggle.addEventListener('change', () => {
+  log(`AVC-only: ${avcOnlyToggle.checked} — re-creating engine`, 'warning');
+  startEngine(srcInput.value.trim() || DEFAULT_STREAM);
+  updateShareUrl();
+});
+
 mutedToggle.addEventListener('change', () => {
   video.muted = mutedToggle.checked;
   log(`Muted: ${mutedToggle.checked}`);
@@ -802,6 +892,12 @@ autoplayToggle.addEventListener('change', () => {
   updateShareUrl();
 });
 
+loopToggle.addEventListener('change', () => {
+  video.loop = loopToggle.checked;
+  log(`Loop: ${loopToggle.checked}`);
+  updateShareUrl();
+});
+
 preloadSelect.addEventListener('change', () => {
   const value = preloadSelect.value as 'auto' | 'metadata' | 'none';
   signals.state.preload.set(value);
diff --git a/internal/decisions/end-of-stream-av-skew-recovery.md b/internal/decisions/end-of-stream-av-skew-recovery.md
new file mode 100644
index 00000000..f5444a7d
--- /dev/null
+++ b/internal/decisions/end-of-stream-av-skew-recovery.md
@@ -0,0 +1,102 @@
+---
+status: decided
+date: 2026-07-13
+---
+
+# End-of-Stream Recovery for Skewed / Tiny-Final-Segment A/V
+
+## Decision
+
+Make a complete VOD reach native `ended` (and therefore loop) reliably, even when the
+audio and video tracks don't end at exactly the same time, via **two narrow changes** in
+the two behaviors that already own the end of playback:
+
+1. **`end-of-stream` reactor** — add slack to the "playhead reached the last segment"
+   gate: fire `endOfStream()` once `currentTime >= lastSegStart − LAST_SEGMENT_REACHED_SLACK`
+   (0.5 s) rather than `>= lastSegStart` exactly.
+2. **`recover-end-stall` behavior** (new, DOM) — on the `waiting` event, if the
+   MediaSource is `'ended'`, the stream is finite, and the playhead is within
+   `endStallNudgeWindow` (default 0.2 s) of the reachable buffered end, set
+   `currentTime = duration` to force native `ended`.
+
+Both are event-driven; neither polls. `recover-end-stall` reads only `mediaElement` +
+`mediaSource`. The window/slack are config-tunable.
+
+## Context
+
+Chrome hangs at the end of the Apple `bipbop_adv_example_hevc` VOD (a source with a ~44 ms
+A/V PTS skew): the playhead freezes a few frames short of the end and native `ended` never
+fires, so playback stalls and loop never re-triggers. Investigation (measured in the
+`spf-non-zero-pts` sandbox) found **two** compounding causes:
+
+- **A tiny final segment deadlocks the EOS reactor.** Apple's last video segment is ~44 ms
+  and starts right at the buffered end (`lastSegStart ≈ 600.0`, buffered end ≈ `600.044`).
+  Chrome paces `currentTime` off the audio clock and freezes the playhead ~50–70 ms short of
+  the buffered end — i.e. *below* `lastSegStart`. The reactor's `currentTime >= lastSegStart`
+  gate never opens → `endOfStream()` is never called → the MediaSource stays `'open'` → the
+  browser keeps the playhead frozen waiting for data/EOS that never comes. A seek past
+  `lastSegStart` (e.g. to `duration`) breaks the deadlock.
+- **Even once `endOfStream()` fires, the playhead still freezes short of `duration`.** With
+  MS `'ended'`, Chrome still stops ~50–70 ms short (the audio clock can't advance past the
+  shorter track's end), so `currentTime` never reaches `duration` and `ended` never fires.
+  Nudging `currentTime = duration` fires it immediately.
+
+Empirical findings that shaped the design:
+
+- The freeze gap (playhead-stop → reachable buffered end) is stably ~50–70 ms (measured 52,
+  58, 62, 71 ms), with ~20 ms non-deterministic jitter in the exact stop position. The
+  reachable end (`buffered.end(last)` = `min(video, audio)`, the audio/pacing track) is
+  stable; `duration` (= `max`, the video end) varies run-to-run with ABR rendition.
+- `waiting` fires at the freeze with ~0 ms latency (measured −3.2 ms vs a rAF sampler), so a
+  poll would only add latency — no reason to poll for this.
+- A MediaSource reaches `'ended'` **only** via `endOfStream()` (MSE spec); the browser never
+  does it spontaneously. The manual nudge appeared to "end without EOS" only because the
+  seek re-triggered our own reactor, which then called `endOfStream()`.
+- hls.js handles the same class of stall in its `GapController`: it does **not** trim buffers;
+  it detects the near-end stall (MS `'ended'` + within 1 s of the edge) and, in a player-layer
+  event, declares ended. We adapt this to SPF's native-`ended` shape by nudging to `duration`.
+
+## Alternatives Considered
+
+- **Trim the longer track's tail to align A/V ends, and set `duration` to the min.**
+  Prototyped and rejected: trimming *video* by PTS can orphan B-frames (removing frames a
+  displayable frame depends on), and it doesn't even fix the stall (the freeze persists), and
+  the mismatch is frame-granular so exact alignment is impossible. It also needs a per-cycle
+  trim target + re-entry bookkeeping. Adds risk for no benefit once the nudge is in place.
+- **Poll for the stall (hls.js's `GapController` 100 ms tick).** Unnecessary here: `waiting`
+  fires at the freeze with ~0 latency; a poll adds its interval + a stall threshold
+  (hls.js waits up to `detectStallWithCurrentTimeMs = 1250 ms`).
+- **hls.js's "within ~1 s of `duration`" window.** Looser than needed. We gate on proximity to
+  the reachable buffered end (`buffered.end(last)`), which is tied to real buffered content and
+  ~5× tighter, sized just above the measured freeze gap.
+- **A single fix in one behavior.** Neither alone suffices: without the reactor slack the MS
+  never reaches `'ended'`; without the nudge the playhead never reaches `duration`.
+
+## Rationale
+
+- **Root + residual, in their owners.** The reactor slack fixes the *root* (EOS never firing);
+  `recover-end-stall` handles the *residual* audio-clock freeze. Each change lives in the
+  behavior whose concern it is (MediaSource finalization vs. playhead recovery), mirroring
+  hls.js's separation.
+- **Ordering removes the race.** With slack, `endOfStream()` fires as `currentTime` crosses
+  `lastSegStart − slack` — *before* the freeze — so by the time `waiting` fires the MS is
+  already `'ended'` and `recover-end-stall`'s gate is satisfied.
+- **Grounded constants.** `LAST_SEGMENT_REACHED_SLACK` (0.5 s) and `endStallNudgeWindow`
+  (0.2 s) both comfortably exceed the measured ~50–71 ms freeze gap. Too-tight risks *missing*
+  the stall (a permanent hang — worse than the bug), so both bias generous and are tunable.
+- **Inert when not needed.** `recover-end-stall` no-ops for live (MS never `'ended'` while
+  growing) and for streams that end cleanly (no `waiting`); the reactor slack only shifts EOS
+  slightly earlier near the true end (harmless — the last segment is already appended).
+
+## Scope
+
+General EOS robustness for any skewed / short-final-segment A/V — not specific to the
+non-zero-PTS relocation work it was discovered alongside. Composed in `engine.ts` and
+`engine-audio-only.ts`.
+
+## Follow-ups
+
+- The nudge is a single jump to `duration`; if a stream ever freezes *further* short than
+  `endStallNudgeWindow`, add a bounded retry rather than widening the default blindly.
+- `recover-end-stall` currently keys off `waiting`; if a pathological stream froze without a
+  `waiting`, a one-shot re-check on the MS→`'ended'` transition is the fallback.
diff --git a/internal/decisions/mse-timestamp-offset.md b/internal/decisions/mse-timestamp-offset.md
new file mode 100644
index 00000000..0ff2b346
--- /dev/null
+++ b/internal/decisions/mse-timestamp-offset.md
@@ -0,0 +1,192 @@
+---
+status: decided
+date: 2026-06-12
+---
+
+# MSE timeline derivation and `timestampOffset` usage
+
+## Decision
+
+Place media on the MSE presentation timeline at its **native PTS** by default
+— neither rewriting timestamps nor applying a `timestampOffset` for the common
+case. Reach for `timestampOffset` only to *relocate* a region. Concretely:
+
+1. **`segments` mode, not `sequence` mode.** The engine's own timeline model
+   is the source of truth; `segments` mode keeps frame placement legible to
+   that model. `sequence` mode delegates placement (and an implicit
+   `timestampOffset` recomputation) to the user agent, which we don't want.
+2. **Default (continuous live): append at native PTS, offset 0.** Declare the
+   seekable window with `MediaSource.setLiveSeekableRange()` in that native
+   timeline; seek into the window on load. No timeline remapping is required —
+   live UIs are window-relative (DVR: differences against
+   `seekable.start`/`seekable.end`) or position-less (pure live edge), so the
+   origin is irrelevant; absolute-time display comes from PDT separately. This
+   is the simplest *and* safest path: large positive timestamps are
+   precision-safe in JS doubles (microsecond-fine even at 10⁹ s) and sidestep
+   the Chromium negative-DTS append failure entirely (timestamps never go
+   negative). For a CMAF-first engine there is no remux step, so byte-level
+   rewriting never even arises.
+3. **Reach for `timestampOffset` only to *relocate* a region**, set once
+   before the first append of that region (after `abort()` + feeding a
+   keyframe first), never per-segment. The relocation cases: instant-clip /
+   "`currentTime` starts at 0" product semantics; mid-stream discontinuities /
+   encoder restart; and aligning tracks whose PTS epochs differ onto a common
+   timeline. VHS's "offset only at boundaries" shape applies here; per-segment
+   offsetting is the anti-pattern.
+4. **Derive any relocation offset empirically / by introspection, then
+   validate.**
+   Read the first segment's `tfdt` `baseMediaDecodeTime` (timescale-aware) and
+   confirm against read-back `SourceBuffer.buffered` rather than assuming a
+   fixed relationship between encoded media time and presentation time.
+5. **When you do offset, guard it to keep DTS ≥ 0 on Chromium.** A negative
+   DTS after offsetting is a hard append failure on Chrome/Chromium (not
+   Firefox). Any relocation offset that could push B-frame DTS negative must be
+   clamped or paired with a DTS rebase. (The native-PTS default avoids this by
+   construction.)
+6. **Audio sample-continuity across discontinuities is a separate, hard
+   requirement.** Chrome paces the audio clock from decoded *sample counts*,
+   not from appended per-frame timestamps. `timestampOffset` anchors where a
+   coded-frame-group starts; it does **not** make Chrome honor per-frame audio
+   PTS mid-run. Across a discontinuity the audio must be made sample-continuous
+   (or the gap handled explicitly), independent of the offset.
+
+This resolves the mechanism fork in
+[non-zero-pts-support](../design/spf/features/non-zero-pts-support.md) and
+informs open question **[4]** in
+[live-presentation-modeling](../design/spf/live-presentation-modeling.md).
+
+## Context
+
+Live HLS does **not** need a zero-based presentation timeline — that's a VOD /
+instant-clip requirement, not a live one. A non-seekable live UI renders no
+position at all (a "LIVE" indicator, not a scrubber), and a DVR UI is entirely
+window-relative — scrubber fill, "behind live", and window length are all
+differences against `seekable.start`/`seekable.end`, so the timeline's origin
+cancels out. Absolute-time display (time-of-day) comes from
+`EXT-X-PROGRAM-DATE-TIME`, a separate media→wall-clock mapping orthogonal to
+`currentTime`'s origin. What live actually needs from the engine is narrower:
+a consistent monotonic timeline in the buffer (native PTS satisfies this), a
+declared seekable window via `setLiveSeekableRange` in whatever coordinates
+were appended, a one-time seek *into* that window on load, optional PDT
+wall-clock mapping, and A/V sync across the window and any discontinuities
+(e.g. SSAI ad splices). The engine maintains its own timeline model separate
+from MSE, so the question is how that model drives the SourceBuffer — and
+whether to touch `timestampOffset` at all, given every production OSS web
+engine uses it in some form.
+
+A deep research pass (W3C MSE spec, byte-stream registry, Chromium/WebKit/
+Gecko trackers, and the source of hls.js / shaka / VHS) plus targeted reading
+of specific Chromium and WebAudio/WebCodecs issues grounded the trade-offs.
+See **Evidence** below for citations.
+
+## Alternatives Considered
+
+- **Byte-level timestamp rewriting** (rewrite PTS/DTS in the segment before
+  append — hls.js's historical path). Rejected: hls.js maintainers call it
+  "costly and result in issues" and are migrating *to* `timestampOffset`
+  (hls.js #5715), with negative-DTS decode artifacts as a documented failure
+  class (#5710). Walking away from `timestampOffset` means walking into the
+  path the industry is abandoning.
+
+- **Rebase to zero via `timestampOffset`** (buffer `currentTime` becomes
+  ~0-based at source start; browser does the math). Considered as the default
+  but **not** chosen for continuous live. It does *not* actually shrink the
+  live translation surface: zero-at-encoder-start is still not zero-at-window-
+  start, so DVR UIs compute window-relative time from `seekable` either way.
+  And it gives up the native-PTS path's two free wins (negative-DTS immunity,
+  no offset to maintain). Kept as the mechanism for the *relocation* cases
+  (Decision §3), where 0-based product semantics or cross-epoch alignment are
+  the actual requirement.
+
+- **`sequence` mode** (Shaka's HLS default). Rejected: it still uses
+  `timestampOffset` under the hood (UA sets it from the group-start
+  timestamp), so it doesn't "avoid" the mechanism — it just hides placement
+  from our model. We want the model authoritative and placement explicit.
+
+- **Per-segment `timestampOffset`** (Shaka's per-segment empirical offset).
+  Rejected for our continuous-run case: VHS explicitly *removed* per-segment
+  offset changes because they "produce bad behavior, especially around
+  long-running live streams." Per-segment offsetting also fights Chrome's
+  audio sample clock. We keep the offset stable within a run and re-anchor
+  only at boundaries (the VHS shape).
+
+## Rationale
+
+The OSS field converges on `timestampOffset`, but mostly because those engines
+remux TS→fMP4 (hls.js) or stitch multi-period content (Shaka/DASH) and need to
+*relocate* media as a matter of course. A CMAF-first live engine that holds its
+own timeline model has no such standing need: appending at native PTS lets the
+media place itself, and `setLiveSeekableRange` declares the window in the same
+coordinates. That default is strictly safer — large positive timestamps are
+precision-safe and can't trip the Chromium negative-DTS abort — and the failure
+modes the field works around (long-running-live drift, A/V divergence,
+negative-DTS) all trace to *applying or changing* an offset, which we now do
+only when relocation genuinely requires it. The mechanism remains the right
+tool for that narrow job; the decision is to stop reaching for it by default.
+
+## Evidence
+
+Spec / mechanics:
+- MSE coded-frame processing adds `timestampOffset` to both PTS and DTS;
+  `segments` vs `sequence` placement; coded-frame-group / need-random-access-
+  point rules — <https://www.w3.org/TR/media-source-2/>,
+  <https://www.w3.org/TR/mse-byte-stream-format-mp2t/>.
+
+Engine prior art:
+- hls.js abandoning byte rewriting for `timestampOffset` —
+  <https://github.com/video-dev/hls.js/issues/5715>,
+  <https://github.com/video-dev/hls.js/issues/5710>.
+- Shaka per-segment empirical offset + `sequence` mode for HLS — Shaka
+  `media_source_engine.js` (`calculatedTimestampOffset = reference.startTime
+  − realTimestamp`); >150 ms audio compensation.
+- VHS sets offset only at discontinuity/rendition boundaries via a serialized
+  queue; removed per-segment offsetting for long-running-live —
+  <https://github.com/videojs/http-streaming/blob/main/docs/a-walk-through-vhs.md>.
+
+Browser behavior:
+- Negative-DTS-after-offset hard append failure on Chrome/Chromium, not
+  Firefox/legacy-Edge — <https://github.com/google/shaka-player/issues/1108>,
+  <https://github.com/Dash-Industry-Forum/dash.js/issues/2265>;
+  `bFrameAdjustment` workaround — <https://github.com/shaka-project/shaka-player/pull/731>.
+- **Chrome paces the audio clock from decoded sample counts, not muxed
+  timestamps** ("chrome used to trust the muxed timestamps for pacing the
+  media clock, but found that the numbers are often imprecise"); drift at
+  SSAI ad-splice discontinuities; classified app-bug / WontFix —
+  Chromium #41340529 (crbug 757799), hls.js #828. This is the dominant
+  A/V-sync constraint for live.
+- Edit-list (`edts`/`elst`) handling diverges by browser **and inverts by
+  API**: in MSE, Chrome applies `media_time` start-trim while Firefox/Edge
+  don't (nzhang227/gapless_audio_mse); in Web Audio `decodeAudioData`, Safari
+  trims AAC priming while Chrome/Firefox/Edge don't
+  (<https://github.com/WebAudio/web-audio-api/issues/1091>). The popular
+  "Chrome ignores edts, Safari applies" framing is **not** supported. Own
+  priming-trim explicitly via `appendWindow` + `timestampOffset`
+  (<https://developer.chrome.com/blog/media-source-extensions-for-audio>);
+  encoder priming counts aren't reliably emitted upstream
+  (<https://github.com/w3c/webcodecs/issues/626>).
+
+## Open follow-ups (verification, not blockers)
+
+- **Double-precision PTS drift is a non-issue at these magnitudes** — a JS
+  double holds microsecond resolution out past 10⁹ s (~31 yr), and Chromium
+  uses integer microseconds internally. The "~26.5 h / 33-bit rollover" figure
+  is the **MPEG-TS** 33-bit PTS field wrapping, *not* a float-precision bound:
+  it's a TS-container concern (a mid-stream wrap is a discontinuity to handle),
+  irrelevant to CMAF/fMP4 (64-bit `tfdt` `baseMediaDecodeTime`). So the
+  native-PTS default is precision-safe for CMAF; TS sources carry a wrap
+  caveat that pushes them toward normalization. No primary source confirmed any
+  double-precision degradation threshold — treat that framing as retired.
+- **Chrome audio sample-pacing on *current* Chrome.** The primary source is
+  Chrome 60 / 2017 (WontFix-Obsolete 2022). It's a deliberate design choice
+  corroborated by current hls.js audio-restamping, but verify on a current
+  Chrome against a discontinuity stream before hardening the audio-continuity
+  requirement.
+
+## See also
+
+- [non-zero-pts-support](../design/spf/features/non-zero-pts-support.md) —
+  the mechanism fork this decision resolves.
+- [live-presentation-modeling](../design/spf/live-presentation-modeling.md) —
+  open question [4] (PDT → `timestampOffset`, A/V sync).
+- [mse-mms-pipeline](../design/spf/features/mse-mms-pipeline.md) — the
+  SourceBuffer pipeline this offsetting plugs into.
diff --git a/internal/design/spf/features/edit-list-compensation.md b/internal/design/spf/features/edit-list-compensation.md
index a2eacd82..c2bf28a0 100644
--- a/internal/design/spf/features/edit-list-compensation.md
+++ b/internal/design/spf/features/edit-list-compensation.md
@@ -20,8 +20,9 @@ the **canonical "middle pattern" example** per
 Sister to [pseudo-ended-detection](./pseudo-ended-detection.md) (just
 landed) and `[buffer-stall-recovery]` in the Borderline sub-cluster.
 Builds on [non-zero-pts-support](./non-zero-pts-support.md)'s offset-
-application mechanism — both features face the same `timestampOffset`-
-vs-simulated-translation question.
+application mechanism, now resolved to `SourceBuffer.timestampOffset`
+relocation — this feature inherits it (the open part is how the two
+offsets *compose*, not which mechanism).
 
 A **Borderline feature** per
 [clusters.md § Feature classification axes](./clusters.md#media-src-vs-player-vs-borderline):
@@ -38,13 +39,13 @@ spec-clean way); this feature compensates client-side until then.
   lists. Result varies by browser (Safari tends to honor; Chrome /
   Firefox have known quirks).
 - **Definition depth:** coarse — scope from Notion + Borderline
-  framing + middle-pattern classification. Mechanism specifics open
-  (shares non-zero-pts-support's mechanism choice).
+  framing + middle-pattern classification. The application mechanism is
+  settled (inherited from non-zero-pts-support); composition specifics open.
 - **Foundation dependency:** [non-zero-pts-support](./non-zero-pts-support.md)
-  provides the offset-application mechanism this feature plugs into.
-  Either both features choose the same mechanism (timestampOffset OR
-  simulated translation) or they coordinate offset composition at the
-  application point.
+  provides the offset-application mechanism this feature plugs into —
+  resolved to `SourceBuffer.timestampOffset` relocation. This feature
+  inherits that mechanism; what remains is how its edit-list offset
+  *composes* with the non-zero-PTS offset at the application point.
 
 ## Phases of complexity
 
@@ -57,7 +58,7 @@ shifts.
 | Edit-list parsing | **Naive** | Don't parse. Rely on browser-native edit-list handling (variable per browser). The current state | Status quo; ≈ what most engines do without explicit edit-list awareness |
 | | **Full** | Parse `elst` box from MP4 init segments. Extract edit-list entries — each entry has `media_time` (where to start in the source media), `segment_duration` (how long this segment of presentation is), `media_rate` (playback rate, usually 1.0). Shares the targeted MP4 box parser with [non-zero-pts-support](./non-zero-pts-support.md)'s `tfdt` extraction | Init-segment parsing extension. The same small targeted MP4 box extractor handles both `tfdt` (non-zero-pts-support) and `elst` (this feature) |
 | Offset application | **Naive** | Rely on browser to interpret edit-list correctly. Some sources play correctly on some browsers; same source plays wrong on others | The variance is the problem this feature solves |
-| | **Full** | Engine-side compensation: compute the effective offset from edit-list entries (typically the first entry's `media_time` shift) and apply via the offset-application mechanism. Two open mechanism options (shared with non-zero-pts-support): (a) `SourceBuffer.timestampOffset`, (b) simulated translation via adapter + behavior math. Both face the same A/V sync trade-off documented in non-zero-pts-support | Same mechanism choice as non-zero-pts-support — these two features should converge on the same answer. Composition with non-zero-pts-support's offset is the load-bearing question (additive? multiplicative? at which layer?) |
+| | **Full** | Engine-side compensation: compute the effective offset from edit-list entries (typically the first entry's `media_time` shift) and apply via the inherited `SourceBuffer.timestampOffset` relocation (non-zero-pts-support resolved the mechanism) | Mechanism settled; composition with non-zero-pts-support's offset is the load-bearing open question (additive? multiplicative? at which layer?) |
 | Multi-entry edit lists | **Naive** (deferred default) | Handle only single-entry edit lists (just shifts source start time). Multi-entry edit lists ignored or fallback-to-browser | Most real-world Mux content has single-entry or no edit lists. Multi-entry support deferred unless customer demand surfaces |
 | | **Full** (deferred) | Handle multi-entry edit lists: multiple consecutive segments with different `media_time` / `segment_duration` / `media_rate` values. Can express loops, freeze-frames, speed changes, gap insertions | Real complexity. Browser support also varies for multi-entry. Defer until concrete customer use case emerges |
 
@@ -109,12 +110,12 @@ Things this feature probably forces decisions on, not just additions:
   vs single computed `effectiveOffset: number`). Lean: (a) additive,
   with the slot exposing both components for debugging / telemetry;
   consumer-facing engine state exposes only `effectiveOffset`.
-- **Shared mechanism choice with non-zero-pts-support.**
-  `SourceBuffer.timestampOffset` vs simulated translation. The two
-  features should converge on the same mechanism — split mechanism
-  would mean different code paths for different offset sources
-  composing into the same SourceBuffer, which is brittle. Open
-  question that resolves jointly across both features.
+- **Inherited application mechanism.** non-zero-pts-support resolved
+  the offset-application mechanism to `SourceBuffer.timestampOffset`
+  relocation; this feature inherits it (a split mechanism composing
+  into the same SourceBuffer would be brittle). What's left is *how*
+  the edit-list offset composes with the non-zero-PTS offset — see the
+  composition bullet above.
 - **Browser-variance gate.** Different browsers honor edit lists
   differently: Safari tends to honor faithfully; Chrome / Firefox
   may interpret the entry-by-entry edit list as samples-to-skip but
@@ -149,8 +150,10 @@ Things this feature probably forces decisions on, not just additions:
 
 - **Offset composition with non-zero-pts-support.** Additive vs
   sequential vs override. Lean: additive with debug exposure.
-- **Shared mechanism choice with non-zero-pts-support.** Resolves
-  jointly; this feature can't independently choose a mechanism.
+- ~~**Shared mechanism choice with non-zero-pts-support.**~~
+  *Resolved* — non-zero-pts-support chose `SourceBuffer.timestampOffset`
+  relocation; this feature inherits it. The open part is offset
+  *composition* (above), not the mechanism.
 - **Browser-variance gate.** Run compensation unconditionally
   (defensive, risk double-shift) vs detect browser behavior and
   gate (safer, more code). Empirical testing needed.
@@ -177,8 +180,9 @@ Things this feature probably forces decisions on, not just additions:
 
 - **[non-zero-pts-support](./non-zero-pts-support.md)** — cluster B
   foundation; the offset-application mechanism this feature plugs
-  into. Mechanism choice (timestampOffset vs simulated translation)
-  resolves jointly across both features.
+  into. non-zero-pts-support resolved the application mechanism to
+  `SourceBuffer.timestampOffset` relocation; this feature inherits it,
+  leaving only offset composition open.
 - **[pseudo-ended-detection](./pseudo-ended-detection.md)** — sister
   Borderline; edit-list offsets affect the perceived duration
   boundary that pseudo-ended-detection checks against. Cross-
diff --git a/internal/design/spf/features/non-zero-pts-support.md b/internal/design/spf/features/non-zero-pts-support.md
index 01460573..4d85ef71 100644
--- a/internal/design/spf/features/non-zero-pts-support.md
+++ b/internal/design/spf/features/non-zero-pts-support.md
@@ -1,7 +1,7 @@
 ---
-status: draft
-date: 2026-05-20
-definition: technical
+status: implemented
+date: 2026-07-16
+definition: sketched
 ---
 
 # Non-zero PTS support
@@ -15,14 +15,21 @@ The cluster B foundation; consumed by every cluster A feature
 ([live-stream-support](./live-stream-support.md),
 [dvr-event-stream-support](./dvr-event-stream-support.md),
 [ll-hls-support](./ll-hls-support.md)) for correct `currentTime` /
-`seekable` semantics. **Implementation mechanism is an open
-architectural question** — two viable approaches with different
-trade-offs (see Open questions): apply the offset to the SourceBuffer
-via `timestampOffset` (browser handles the translation; A/V sync risk
-from per-buffer offset divergence) vs simulate the offset via adapter
-+ math in behaviors/compositions (buffer holds original PTS;
-translation happens at every consumer boundary; no A/V drift risk
-but bigger translation surface).
+`seekable` semantics.
+
+**Mechanism: resolved and implemented for VOD** — `SourceBuffer.timestampOffset`
+relocation. The offset is applied per `SourceBuffer` (`timestampOffset =
+−startMediaTime`) so the buffer, the model's `Track.startTime`, and
+`currentTime` all stay 0-based and the adapter is untouched; text cues get the
+same shift as arithmetic. The A/V-sync risk from per-buffer offset divergence is
+handled by relocating every track by one shared `min` origin across the selected
+A/V tracks, which keeps every DTS ≥ 0 *and* preserves real skew. The coordinate
+model and the discover→derive→apply architecture are documented in full in
+[presentation-timeline-model.md](../presentation-timeline-model.md); the mechanism
+decision (native-PTS default, relocation for the 0-based cases) in
+[../../../decisions/mse-timestamp-offset.md](../../../decisions/mse-timestamp-offset.md).
+(The alternative — simulated translation in the adapter — was the parked approach
+on `feat/spf-non-zero-pts`.)
 
 A **Media-src feature** in the framing from
 [clusters.md § Feature classification axes](./clusters.md#feature-classification-axes):
@@ -37,268 +44,230 @@ distinct motivations.
 
 ## Status
 
-- **Composition:** not implemented in `createSimpleHlsEngine`. No
-  PTS-handling code in `packages/spf/src/` (no `timestampOffset`,
-  `initPTS`, or `EXT-X-DISCONTINUITY` references). Engine implicitly
-  assumes zero-based PTS — works for typical Mux Video VOD sources
-  (transcoded with PTS rebased to zero) but breaks for live + clips.
-- **Definition depth:** technical — scope and SPF touchpoints
-  articulated against MSE `timestampOffset` semantics + HLS spec;
-  implementation specifics open. Source material: [SPF Epics Working
-  Doc — epic #6 Non-zero PTS / Instant Clip Support](https://www.notion.so/35f97a7f89d08123a13fecab1ca1cac4)
-  (cluster B, Media-src, eng L, validation M).
+- **Composition:** implemented for **VOD** in `createSimpleHlsEngine` and
+  `createHlsAudioOnlyEngine` on `feat/spf-non-zero-pts-relocation` (draft
+  PR #1847). The `establishStartMediaTime` reactor + the `relocation-pipelines`
+  primitive discover each track's decode-time origin (`tfdt`/`mdhd`, matched by
+  `track_id`) and relocate via `SourceBuffer.timestampOffset = −startMediaTime`.
+  Relocation is **composition-time opt-in** — the always-present loader/buffer
+  actors carry no relocation vocabulary, and a zero-PTS composition imports none
+  of this code (see [presentation-timeline-model.md § Branch-free always-present
+  actors](../presentation-timeline-model.md)).
+- **Live is parked** on `feat/spf-non-zero-pts`; the live edge has its own
+  wall-clock anchor (`anchorPresentationTimeline`), the media↔wall-clock sibling
+  of this feature's media↔presentation relocation. Mid-stream PTS jumps remain
+  the sister `[discontinuity-handling]` feature's scope.
+- **Definition depth:** sketched — implemented and code-grounded for VOD. Source
+  material: [SPF Epics Working Doc — epic #6 Non-zero PTS / Instant Clip
+  Support](https://www.notion.so/35f97a7f89d08123a13fecab1ca1cac4) (cluster B,
+  Media-src, eng L, validation M).
 - **Foundational** for cluster B — first cluster B doc. Consumed by
   every cluster A feature (live, DVR, LL-HLS) for correct `currentTime`
-  semantics. Discontinuity-handling (mid-stream PTS jumps via
-  `EXT-X-DISCONTINUITY` or encoder restart) is carved out as a sister
-  candidate feature.
+  semantics.
 
 ## Phases of complexity
 
 Content phases by source-type. All three use the same underlying
-mechanism (first-segment-PTS detection + `timestampOffset`
-application); they differ in motivation, customer-data context, and
-composition with other cluster A features.
+mechanism (first-segment-PTS detection + `timestampOffset` relocation);
+they differ in motivation, customer-data context, and composition with
+other cluster A features.
 
-| Phase | Source type | What | Notes |
+| Phase | Source type | What | Status |
 |---|---|---|---|
-| Non-zero-PTS VOD | Re-mastered or processed VOD where the manifest retains original PTS rather than zero-rebasing the source. Source has stable, non-zero PTS throughout. Often the result of clipping / transcoding pipelines that preserve PTS | Detect first-segment baseMediaDecodeTime from init segment (MP4 `tfdt` box, timescale-aware). Compute `presentationTimeOffset = -baseMediaDecodeTime / timescale`. Apply the offset via the chosen mechanism (see Open questions on mechanism choice). User-visible `currentTime` resolves to zero at source start | The baseline non-zero PTS case. Offset is one-time setup (detected once at first segment, stable during source lifetime). Mechanism choice (timestampOffset vs simulated translation) affects everything downstream but doesn't change the per-phase user-visible semantics |
-| Instant clips (deliberate offset) | Sources where the consumer / Mux Video creates a clip by serving a manifest starting at a non-zero PTS (the clip's start position in the original media). User-visible `currentTime` should still start at zero | Same offset-detection mechanism as non-zero-PTS VOD. **Plus:** optionally surface the original PTS to the consumer for telemetry / "watch from minute N of source" use cases. Customer-data hooks: HLS `EXT-X-START` time-offset attribute (if present) or manifest-level clip metadata can hint at the offset | The deliberate-clip case. Engine treats it identically to non-zero-PTS VOD; the difference is that the offset is intentional and the value carries meaning customer-side (e.g., for Mux Data telemetry mapping the clipped-content currentTime back to original-media position) |
-| Live streams with non-zero PTS | Live encoder PTS counts from broadcast / encoder start. First segment loaded by the engine has a large PTS (potentially hours/days). Sliding-window updates roll segments off the start as live progresses; the *seekable range* slides forward but the offset itself is stable within an encoder run | Same first-segment-PTS-detection mechanism. **Composes with:** [live-stream-support](./live-stream-support.md)'s `setLiveSeekableRange` — the live window's start/end are user-visible-time values (offset-corrected, however the mechanism translates). **Composes with:** [dvr-event-stream-support](./dvr-event-stream-support.md)'s growing-window — start = user-visible time of first retained segment; end = user-visible time of live edge. **Composes with:** [ll-hls-support](./ll-hls-support.md)'s partial-segment edge tracking — same offset applies | The live-specific case. Encoder restart (new encoder run on the same source URL) is one of the discontinuity scenarios carved out to the sister feature |
+| Non-zero-PTS VOD | Re-mastered or processed VOD where the manifest retains original PTS rather than zero-rebasing the source. Stable, non-zero PTS throughout — often the output of clipping / transcoding pipelines that preserve PTS | Detect first-segment `baseMediaDecodeTime` (`tfdt`) + `timescale` (`mdhd`) from the init + first media segment, matched by `track_id`. Relocate via `SourceBuffer.timestampOffset = −startMediaTime`; `currentTime` resolves to zero at source start. Offset is one-time setup (established once per source, sticky) | **Implemented.** The baseline case |
+| Instant clips (deliberate offset) | Sources where Mux Video creates a clip by serving a manifest starting at a non-zero PTS (the clip's start position in the original media). `currentTime` should still start at zero | Engine treats it **identically** to non-zero-PTS VOD — same detect + relocate. The clip-specific extra (surfacing the original PTS for telemetry / "watch from minute N") is an adapter-layer concern, not engine | **Implemented** (relocation); original-PTS surfacing is out of scope (adapter layer) |
+| Live streams with non-zero PTS | Live encoder PTS counts from broadcast / encoder start; the first loaded segment has a large PTS. The sliding window rolls segments off the start; the *seekable range* slides forward but the origin is stable within an encoder run | Live uses the wall-clock `anchorPresentationTimeline` (media↔wall-clock edge) rather than the VOD media↔presentation relocation; composes with [live-stream-support](./live-stream-support.md)'s `setLiveSeekableRange`, [dvr-event-stream-support](./dvr-event-stream-support.md)'s growing-window, and [ll-hls-support](./ll-hls-support.md)'s partial-segment edge tracking | **Parked** on `feat/spf-non-zero-pts` |
 
-## What's in scope vs out of scope
+## What's not implemented
 
-**In scope:**
-- All three source-type phases for HLS content with non-zero PTS
-- Init-segment PTS extraction (MP4 `tfdt` parsing; HLS spec `EXT-X-PROGRAM-DATE-TIME` correlation when present)
-- `SourceBuffer.timestampOffset` application before initial segment
-  append
-- Engine-side `currentTime` / `seekable` mapping (engine reports
-  offset-corrected values throughout)
-- `EXT-X-START` HLS spec attribute parsing for clip-start offset hints
-- Composition with cluster A features (live, DVR, LL-HLS) — their
-  seekable-range writers consume the offset-corrected values
+Extension boundaries — each is a separate candidate feature or a parked phase:
 
-**Out of scope (separate Borderline-flavored candidate features):**
-- **`[discontinuity-handling]`** *(new candidate, sibling of this
-  feature)* — mid-stream PTS jumps via `EXT-X-DISCONTINUITY` tags,
-  encoder restarts on the same source URL, 33-bit PTS rollover
-  (~26 hours of 90kHz timestamps). The *initial offset* is stable;
-  this feature handles that. The *changes mid-stream* are the sister
-  feature's concern. Both consume the same time-mapping primitive
-  internally.
-- **Cluster B sub-cluster: Borderline content compensation** —
-  `[pseudo-ended-detection]`, `[edit-list-compensation]`,
-  `[buffer-stall-recovery]`. All build on this feature's primitive
-  but address different content-defect concerns.
+- **Live non-zero-PTS relocation** — parked on `feat/spf-non-zero-pts`. Live has
+  its own wall-clock anchor today; converging live and VOD onto one establishment
+  unit (both write per-track coordinate base values) is the flagged eventual
+  dedup — see [presentation-timeline-model.md § Consume](../presentation-timeline-model.md).
+- **`[discontinuity-handling]`** *(sister candidate)* — mid-stream PTS jumps via
+  `EXT-X-DISCONTINUITY`, encoder restart on the same source URL, 33-bit PTS
+  rollover (~26h of 90 kHz ticks). This feature handles a *single stable PTS
+  origin per source*; the sister handles the origin *changing mid-source*. Both
+  consume the same time-mapping primitive; the meta-per-append offset shape already
+  generalizes to per-period re-base (see [presentation-timeline-model.md § Offset
+  applied via append meta](../presentation-timeline-model.md)).
+- **`EXT-X-START` / `EXT-X-PROGRAM-DATE-TIME` consumption** — the HLS start-offset
+  and per-segment wall-clock attributes. Lean: parse + expose; let the consumer
+  decide initial `currentTime` / wall-clock display. PDT is already the live
+  anchor's input; VOD consumption of either is unbuilt.
+- **Cluster B Borderline content compensation** — `[pseudo-ended-detection]`,
+  `[edit-list-compensation]`, `[buffer-stall-recovery]`. All build on this
+  feature's primitive but address different content-defect concerns.
 
 **Out of scope (different architectural layer):**
-- Customer-facing display of original-media position (e.g., "watching
-  minute 3 of 60-minute source via 10-minute clip"). Engine surfaces
-  the offset; adapter/customer renders the UI.
-- Mux Data telemetry mapping of clipped currentTime → original-media
-  position. Service-side / adapter-side.
-- `EXT-X-PROGRAM-DATE-TIME` wall-clock display (synced to original
-  broadcast time). Engine exposes the value; consumer UI renders
-  "broadcast wall clock" if needed.
+- Customer-facing display of original-media position (e.g. "watching minute 3 of a
+  60-minute source via a 10-minute clip"). Engine relocates; adapter/consumer
+  renders the UI.
+- Mux Data telemetry mapping of clip `currentTime` → original-media position.
+  Service-side / adapter-side.
 
-## Likely cross-cutting impact
+## Implementation surface
 
-Things this feature probably forces decisions on, not just additions:
+**Composition:** `packages/spf/src/playback/engines/hls/engine.ts` (and
+`engine-audio-only.ts`) — the relocation wiring is comment-marked as one removable
+block (reactor + `deriveStartMediaTime` seam + the `video`/`audio`/`text`
+message-pipeline config), so it adds/drops as a unit for bundle / back-compat
+testing.
 
-- **PTS-detection location: parser vs MSE-side.** Two shapes for
-  extracting baseMediaDecodeTime: (a) parse the init segment in the
-  engine (MP4 box parsing for `tfdt` + timescale) before passing to
-  SourceBuffer; (b) attach a parser to the streaming `fetchStream`
-  chunks that emits a PTS-detected event. Option (a) is simpler but
-  adds MP4-box-parsing code; option (b) leverages the streaming
-  pipeline. Lean: (a) — init segments are small and already buffered
-  before the segment-stream begins; a one-shot parser at append time
-  is the cleanest insertion point.
-- **Mechanism choice: `timestampOffset` vs simulated translation
-  (load-bearing).** Two viable approaches with different trade-offs:
+**Behaviors:**
 
-  *(a) `SourceBuffer.timestampOffset`*: Set
-  `sourceBuffer.timestampOffset = -firstPTS` before appending the
-  first segment; browser shifts all timestamps; `currentTime` and
-  `seekable` are naturally offset-corrected. Sequences against
-  [mse-mms-pipeline](./mse-mms-pipeline.md)'s setup: setup →
-  setMediaKeys (if DRM) → addSourceBuffer →
-  detect-PTS-from-init-segment → set timestampOffset → append.
-  **Risks:** per-SourceBuffer write (video and audio buffers have
-  separate offset values); sub-millisecond detection-time precision
-  differences between video and audio init segments can cause A/V
-  drift that compounds. Mid-source offset changes (discontinuity)
-  require coordinated multi-buffer writes. Browser quirks during
-  append (Safari especially).
+| Behavior | File | Responsibility |
+|---|---|---|
+| `establishStartMediaTime` | `playback/behaviors/establish-start-media-time.ts` | Per-source reactor (`inactive`/`monitoring`/`established`). Owns the transient `mediaContainerData` slot (cleared per source); runs the injected `deriveStartMediaTime` seam and stamps the settled per-track `startMediaTime` onto the model — sole writer, establish-once sticky. VOD sibling of `anchorPresentationTimeline` |
+| `recoverEndStall` | `playback/behaviors/dom/recover-end-stall.ts` | Recovers the Chrome end-of-stream freeze on skewed A/V: on `waiting` with the MediaSource `ended` and the playhead within `endStallNudgeWindow` of the reachable buffered end, nudges `currentTime` to `duration` to force native `ended`. Needed because shared-`min` relocation preserves A/V skew |
 
-  *(b) Simulated translation*: Don't set `timestampOffset`; buffer
-  holds original PTS. The `<video>` element's `currentTime` reads in
-  original PTS (large for non-zero-PTS sources). Engine + adapter
-  translate at every consumer boundary: customer-reading `currentTime`
-  → subtract offset; customer seeking → add offset; `setLiveSeekableRange`
-  → write original-PTS values to MSE, expose user-visible-time values
-  through engine state. **Risks:** translation layer at every
-  boundary; consumer-facing APIs must consistently use translated
-  values (any leak of raw `<video>.currentTime` shows wrong time);
-  bigger code surface than mechanism (a). **Benefits:** no A/V drift
-  risk (no per-buffer offset divergence); MSE buffer stays "pure";
-  discontinuity handling can change the translation offset without
-  any MSE coordination.
+**Primitives** (`playback/primitives/`, DOM-free):
 
-  Both mechanisms preserve user-visible semantics; the choice is
-  engineering trade-off (browser quirks + A/V sync risk vs
-  translation surface area). Mechanism (b) is more SPF-natural —
-  behavior-driven translation at boundaries fits the composition
-  model; (a) is more browser-API-natural — uses what the spec
-  provides. See Open questions.
-- **State slot for the offset.** New slot:
-  `presentationTimeOffset: { [trackType: 'video' | 'audio']: number }`
-  or similar. Per-type (video and audio can have independent PTS
-  origins; usually correlated but not guaranteed). Read by:
-  `setLiveSeekableRange` writer (live + DVR + LL-HLS), engine-side
-  `currentTime` consumers (telemetry, customer hooks), and any
-  cluster B sister feature.
-- **`currentTime` and `seekable` semantics — depends on mechanism.**
-  Under (a) `timestampOffset`: browser does the translation; DOM-side
-  `currentTime` and `seekable` are naturally offset-corrected;
-  engine-side mirrors DOM-side. Under (b) simulated translation:
-  DOM-side reads original PTS; engine/adapter applies offset at
-  every read boundary; consumer-facing `state.currentTime` is the
-  offset-corrected value; `setLiveSeekableRange` writes original-PTS
-  values (so MSE knows what it's been fed) but engine state exposes
-  user-visible-time values. The mechanism choice is invisible to
-  consumers — both paths preserve user-visible-time semantics — but
-  the implementation surface differs substantially.
-- **Live + encoder-restart scenario.** When a live encoder restarts
-  on the same source URL, the new PTS series starts at a different
-  value than the previous one. Without `EXT-X-DISCONTINUITY` tags,
-  this looks identical to a malformed stream; with them, it's a
-  proper discontinuity. The sister `[discontinuity-handling]`
-  candidate covers this. Boundary: this feature handles "single
-  stable PTS origin per source"; discontinuity handles "PTS origin
-  changes mid-source."
-- **Init-segment PTS vs first-media-segment PTS.** The init segment
-  doesn't contain media samples (no `tfdt` per the spec strictly);
-  the first media segment carries the `tfdt`. PTS detection happens
-  on the **first media segment append**, not on init append. This
-  affects the offset-write sequencing: `timestampOffset` must be
-  set before the first media segment append, not before the init
-  segment append. Verify behavior.
+| Primitive | File | Role |
+|---|---|---|
+| `deriveStartMediaTime` seam + defaults | `derive-start-media-time.ts` (type/context), `establish-start-media-time.ts` (`deriveSharedMinStartMediaTime` default, `derivePerTypeStartMediaTime` opt-out) | The one coordination knob: `(mediaContainerData, ctx) => per-type startMediaTime`. Default reduces the `min` across selected A/V origins |
+| `relocationPipelinesFor(type, derive)` | `relocation-pipelines.ts` | The loader `messagePipelines` — discover (`track_id` + `mdhd` timescale, then that track's `tfdt` `baseMediaDecodeTime`) → stamp (`timestampOffset = −startMediaTime`, `awaitDefined` holdback, liveness-guarded) |
+| `relocatingTextPipelines()` | `relocation-pipelines.ts` | Text-loader pipeline: resolve metadata → shift cues by `mapCorrection − startMediaTime` (`mapCorrection = X-TIMESTAMP-MAP mpegts/90000 − local`) → dispatch. Origin is **awaited** — the primary selected A/V `startMediaTime`, so an early cue load can't resolve to `0` and shift every cue by the full `mapCorrection` (mirrors the A/V stamp step); a genuinely text-only source (no A/V tracks) relocates by `0` |
+
+**Media primitives (DOM-free, no `core/`):**
+
+- `media/mp4/timestamp-origin.ts` — two tree-shakeable box readers:
+  `readFirstMediaTimescale`/`readFirstBaseMediaDecodeTime` (presumptive, first box)
+  vs `findMediaTrack`/`readBaseMediaDecodeTime` (track-id-matched, for muxed
+  containers with an extra `clcp`/caption track). `media/mp4/box.ts` — the minimal
+  box parser.
+- `media/text/parse-vtt-timestamp-map.ts` — scrapes the WebVTT `X-TIMESTAMP-MAP`
+  header (the one line the native `<track>` parser discards); `resolve-vtt-metadata.ts`
+  — DOM-free cue metadata resolution.
+
+**State slots:**
+
+- `startMediaTime` — **per-track on the CMAF-HAM `Track`** (a peer of `startTime`
+  and `startDate`), not a parallel slot. Sole writer is the reactor's derive
+  effect. `timestampOffset` is **derived** (`startTime − startMediaTime`), never
+  stored. The write shares `presentation`'s existing multi-writer situation (#1746),
+  accepted rather than worked around.
+- `mediaContainerData` — transient, keyed by track type (`{ trackId?, timescale?,
+  baseMediaDecodeTime?, segmentStartTime? }`). Holds the partial per-append discover
+  churn so it never touches `presentation`; cleared per source by the reactor's
+  `inactive` entry.
+
+## Config surface
+
+```ts
+{
+  // Coordination seam (the one tier knob). Default deriveSharedMinStartMediaTime
+  // (min across selected A/V origins); derivePerTypeStartMediaTime is the
+  // barrier-free per-type opt-out for known-aligned A/V.
+  deriveStartMediaTime?: DeriveStartMediaTime;
+  // recoverEndStall proximity window (seconds); default 0.2. How close the
+  // playhead must sit to the reachable buffered end for a `waiting` to count as
+  // the end-of-stream freeze.
+  endStallNudgeWindow?: number;
+}
+```
+
+`NEAR_ZERO_ORIGIN_THRESHOLD` (1s, in `establish-start-media-time.ts`) is a fixed
+policy, not config: origins below it (incl. negatives) snap to `0`, leaving the
+source on its native ~0-based timeline (no `timestampOffset` set). Relocation
+targets intentional large origins (instant clips, bipbop @10s), not the small
+encode origin ordinary VOD carries (audio priming, first-frame CTS, edit lists).
+
+## Verification
+
+- **Unit tests:**
+  - `playback/behaviors/tests/establish-start-media-time.test.ts` — reactor
+    lifecycle, the derive seam (shared-`min` barrier, per-type opt-out, threshold
+    snapping).
+  - `playback/primitives/tests/relocation-pipelines.test.ts` — discover/stamp
+    steps; the track-id match resolves the media track's origin under a
+    caption-first muxing (10s, not the leading `clcp` traf's 50s); cue-origin
+    resolution (waits for the selected A/V origin instead of shifting cues by the
+    full map correction; text-only source relocates by 0).
+  - `media/mp4/tests/{timestamp-origin,box}.test.ts` — box parsing + both parser
+    variants.
+  - `media/text/tests/parse-vtt-timestamp-map.test.ts` — `X-TIMESTAMP-MAP` scrape.
+  - `media/dom/mse/tests/duration.test.ts`, `behaviors/dom/tests/recover-end-stall.test.ts`
+    — reachable buffered-end + the skewed-A/V EOS nudge.
+- **Cross-browser smoke** (chromium/firefox/webkit × Mux clip / Apple bipbop / Mux
+  full, incl. `?engine=audio`): 0-based `currentTime`/`seekable`/`buffered`,
+  per-SourceBuffer relocation with A/V skew **preserved** (Apple ~44ms, Mux clip
+  ~1ms), text-cue alignment, ended+loop. The `~0.043`-origin full-length source is
+  left un-relocated (below threshold). Sandbox harness is local/git-ignored, not
+  in-repo.
 
 ## Open questions
 
-- **Mechanism choice: `timestampOffset` vs simulated translation
-  (load-bearing).** Per the cross-cutting note. Both viable. (a)
-  uses the browser's MSE API directly but exposes A/V sync risk
-  from per-buffer offset divergence + browser-specific quirks.
-  (b) keeps the MSE buffer "pure" with original PTS and translates
-  at every consumer boundary; bigger translation surface but
-  eliminates the A/V drift risk and simplifies discontinuity
-  handling (sister feature). The choice constrains the entire
-  feature's implementation; resolving it requires empirical work
-  (test A/V sync drift on target browsers under mechanism (a)) and
-  scoping the translation surface under (b). No clear lean yet.
-- **PTS-detection implementation: parser depth.** Full MP4 box
-  parser inside SPF vs targeted `tfdt`-only extractor vs depend on
-  an external `mp4box.js`-style library. Lean: targeted extractor
-  (small surface, only what's needed). Independent of mechanism
-  choice.
-- **`EXT-X-PROGRAM-DATE-TIME` consumption.** HLS spec attribute
-  giving wall-clock time per segment. Useful for: (a) correlating
-  user-visible time with broadcast time; (b) cross-checking
-  PTS-detected offset (if `EXT-X-PROGRAM-DATE-TIME` is present,
-  verify the offset computation is consistent); (c) exposing to
-  consumer telemetry. Open whether to surface this through engine
-  state (new slot) or only via parser-output.
-- **`EXT-X-START` parsing.** HLS spec attribute giving a desired
-  playback-start offset (typically a few seconds before live edge
-  for live, or arbitrary for VOD). Should the engine respect this
-  by setting initial `currentTime`, or expose to consumer? Lean:
-  expose; let consumer decide.
-- **Per-type offset (video vs audio).** Theoretically independent;
-  usually correlated. Treat as `{ video: number, audio: number }`
-  or assume video offset applies to both? Empirical question;
-  start with per-type to be safe.
-- **Discontinuity boundary semantics.** The discontinuity sister
-  feature handles mid-stream offset changes. The boundary between
-  this feature (stable offset) and that one (offset changes) is
-  drawn at "single PTS origin per source." A stream with one
-  `EXT-X-DISCONTINUITY` after segment 100 sits in the sister
-  feature's territory.
-- **Telemetry / customer-data offset exposure.** Surface
-  `presentationTimeOffset` to consumers for telemetry (Mux Data,
-  custom analytics)? Lean: yes — read-only via the engine state
-  surface or a derived signal.
-- **`currentTime` near zero for non-zero-PTS VOD.** After offset
-  applied, `currentTime` starts at zero. Some browsers may behave
-  unexpectedly when `seekable.start(0)` is exactly 0 (vs floating-
-  point slightly above zero). Worth empirical verification on
-  Safari, especially.
-- **Composition with capability-probing.** When the browser doesn't
-  decode the codec, the engine fails before reaching this feature's
-  PTS handling. Boundary: capability-probing filters unsupported
-  variants upstream; this feature operates on the variants that
-  pass. No direct dependency.
+- ~~**Mechanism choice: `timestampOffset` vs simulated translation.**~~
+  *Resolved.* `timestampOffset` relocation for VOD; see the opening and
+  [../../../decisions/mse-timestamp-offset.md](../../../decisions/mse-timestamp-offset.md).
+- ~~**PTS-detection implementation: parser depth.**~~ *Resolved.* A targeted
+  extractor (`media/mp4/timestamp-origin.ts`), not a full `mp4box.js`-style
+  dependency — split into presumptive vs track-id readers for tree-shaking.
+- ~~**Per-type offset (video vs audio).**~~ *Resolved.* `mediaContainerData` is
+  keyed by track type; the default derive reduces the `min` across selected A/V
+  origins (preserves skew, keeps every DTS ≥ 0).
+- ~~**`currentTime` near zero for non-zero-PTS VOD.**~~ *Resolved.*
+  `NEAR_ZERO_ORIGIN_THRESHOLD` snaps sub-second and negative origins to `0`
+  (native timeline, no offset set); cross-browser smoke confirmed no exact-zero
+  `seekable.start(0)` misbehavior on the target browsers.
+- **Text-only sources.** No A/V `tfdt` to establish from — but the
+  `X-TIMESTAMP-MAP` `MPEGTS` *is* a media-timeline reference, so text could
+  self-establish. Deferrable special path.
+- **`EXT-X-START` / `EXT-X-PROGRAM-DATE-TIME` consumption for VOD.** Parse +
+  expose vs act on. Lean: expose, let the consumer decide.
+- **Telemetry / customer-data offset exposure.** Surface the origin (or derived
+  offset) to consumers for Mux Data / analytics? Lean: yes, read-only via engine
+  state.
+- **Discontinuity boundary semantics.** The boundary between this feature (stable
+  origin) and `[discontinuity-handling]` (origin changes mid-source) is drawn at
+  "single PTS origin per source."
+- **Mechanism-level questions** — the barrier-liveness bound (audio absent/errored
+  must not block the shared-`min` `awaitDefined` forever) and the first-segment
+  hold's interaction with preempt/replan are tracked in
+  [presentation-timeline-model.md § Open questions](../presentation-timeline-model.md#open-questions).
 
 ## Related features
 
-- **[live-stream-support](./live-stream-support.md)** *(consumer)* —
-  consumes this feature's offset for `setLiveSeekableRange` start /
-  end and for `currentTime` semantics during live playback. Cluster
-  A foundation that this feature is the cluster B foundation
-  prerequisite for.
-- **[dvr-event-stream-support](./dvr-event-stream-support.md)**
-  *(consumer)* — same as live-stream-support but with growing-window
-  semantics; the offset still applies, the seekable start is
-  offset-corrected from segment 0.
-- **[ll-hls-support](./ll-hls-support.md)** *(consumer)* — partial-
-  segment edge tracking + live-edge updates all use offset-corrected
-  values.
-- **[mse-mms-pipeline](./mse-mms-pipeline.md)** — under mechanism
-  (a), `SourceBuffer.timestampOffset` is the MSE API consumed; the
-  segment-append sequence gains a PTS-detection + offset-write
-  stage. Under mechanism (b), MSE-side is unchanged; translation
-  lives in adapter / behavior boundary instead.
-- **[buffer-management](./buffer-management.md)** — forward-buffer
-  planner operates on `currentTime` and segment time ranges; both
-  are offset-corrected naturally. Planner code doesn't change.
-- **[presentation-modeling](../presentation-modeling.md)** — parser
-  may surface PTS-related HLS attributes (`EXT-X-START`,
-  `EXT-X-PROGRAM-DATE-TIME`) on the resolved presentation. Parser
-  extension for HLS metadata.
-- **`[discontinuity-handling]`** *(new candidate, this session)* —
-  sister feature carved out of this one's scope. Mid-stream PTS
-  jumps via `EXT-X-DISCONTINUITY`, encoder restart, 33-bit PTS
-  rollover. Same underlying primitive (re-detect-and-apply offset),
-  different motivation (changes mid-source vs stable).
-- **Cluster B Borderline content compensation sub-cluster:**
+- **[live-stream-support](./live-stream-support.md)** *(consumer)* — the
+  media↔wall-clock sibling; consumes offset-corrected `currentTime`/`seekable`
+  during live. Cluster A foundation this feature is the cluster B prerequisite for.
+- **[dvr-event-stream-support](./dvr-event-stream-support.md)** *(consumer)* —
+  growing-window seekable start is offset-corrected from segment 0.
+- **[ll-hls-support](./ll-hls-support.md)** *(consumer)* — partial-segment edge
+  tracking uses offset-corrected values.
+- **[mse-mms-pipeline](./mse-mms-pipeline.md)** — `SourceBuffer.timestampOffset` is
+  the MSE API consumed; the segment-append sequence gains a discover + offset-write
+  stage (loader message-pipeline steps, applied by the `SourceBufferActor`).
+- **[buffer-management](./buffer-management.md)** — the forward-buffer planner
+  operates on `currentTime` and segment ranges; both stay 0-based, so the planner
+  is unchanged.
+- **[presentation-modeling](../presentation-modeling.md)** — the data model
+  `startMediaTime` extends (peer of `startTime`/`startDate`); the parser is where
+  `EXT-X-START`/`EXT-X-PROGRAM-DATE-TIME` would surface.
+- **`[discontinuity-handling]`** *(sister candidate)* — mid-stream PTS jumps; same
+  primitive, different motivation (changes mid-source vs stable).
+- **Cluster B Borderline content compensation:**
   [pseudo-ended-detection](./pseudo-ended-detection.md),
   [edit-list-compensation](./edit-list-compensation.md),
-  [buffer-stall-recovery](./buffer-stall-recovery.md) — all build on
-  this feature's time-mapping primitive but address different
-  content-defect concerns.
-  See [clusters.md § Time normalization](./clusters.md#time-normalization)'s
-  sub-cluster note.
+  [buffer-stall-recovery](./buffer-stall-recovery.md) — build on this feature's
+  primitive. See [clusters.md § Time normalization](./clusters.md#time-normalization).
 
 ## See also
 
+- [presentation-timeline-model.md](../presentation-timeline-model.md) —
+  **the architectural deep-dive**: the three-timeline coordinate model, the
+  discover→derive→apply reactor architecture, the capability axes, and the key
+  decisions. This feature doc frames; that doc explains the mechanism.
+- [../../../decisions/mse-timestamp-offset.md](../../../decisions/mse-timestamp-offset.md)
+  — the mechanism decision (native-PTS default; relocation for the 0-based cases).
 - [clusters.md § Time normalization](./clusters.md#time-normalization)
-  — cluster B description; this feature is the foundation
-- [clusters.md § Feature classification axes](./clusters.md#feature-classification-axes)
-  — Media-src feature framing
-- [live-stream-support.md](./live-stream-support.md) — primary
-  consumer; cluster A foundation
-- [mse-mms-pipeline.md](./mse-mms-pipeline.md) —
-  `SourceBuffer.timestampOffset` API surface
+  — cluster B description; this feature is the foundation.
+- [mse-mms-pipeline.md](./mse-mms-pipeline.md) — `SourceBuffer.timestampOffset` API surface.
 - [SPF Epics Working Doc](https://www.notion.so/35f97a7f89d08123a13fecab1ca1cac4)
-  — source material; epic #6 (Non-zero PTS / Instant Clip Support)
+  — source material; epic #6 (Non-zero PTS / Instant Clip Support).
 - [HLS Spec — `EXT-X-START`](https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis#section-4.4.5.2)
-  and [`EXT-X-PROGRAM-DATE-TIME`](https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis#section-4.4.4.6)
-  — HLS spec time-related metadata attributes
-- [MSE Spec — `SourceBuffer.timestampOffset`](https://w3c.github.io/media-source/#dom-sourcebuffer-timestampoffset)
-  — the MSE API for shifting appended segment timestamps; one of the
-  two candidate mechanisms (A/V sync risk from per-buffer offset
-  divergence)
-- [ISO BMFF — `tfdt` box (Track Fragment Decode Time)](https://www.iso.org/standard/68960.html)
-  — MP4 init/media segment PTS source
+  and [`EXT-X-PROGRAM-DATE-TIME`](https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis#section-4.4.4.6).
+- [ISO BMFF — `tfdt` box](https://www.iso.org/standard/68960.html) — MP4 media-segment decode-time origin.
diff --git a/internal/design/spf/presentation-timeline-model.md b/internal/design/spf/presentation-timeline-model.md
new file mode 100644
index 00000000..292fc7e4
--- /dev/null
+++ b/internal/design/spf/presentation-timeline-model.md
@@ -0,0 +1,402 @@
+---
+status: implemented
+date: 2026-07-07
+---
+
+# Presentation Timeline Coordinate Model
+
+The coordinate model that lets an SPF engine translate between the three
+timelines a streaming presentation lives on — **media**, **presentation**, and
+**wall-clock** — and the architecture for **non-zero-PTS `timestampOffset`
+relocation** built on it.
+
+This is the design for the `timestampOffset`-relocation approach to non-zero-PTS,
+implemented for **VOD** on branch `feat/spf-non-zero-pts-relocation` (live is parked on
+`feat/spf-non-zero-pts`). It is the
+"how it's modeled and where it lives" companion to the mechanism decision in
+[../../decisions/mse-timestamp-offset.md](../../decisions/mse-timestamp-offset.md)
+and the feature framing in
+[features/non-zero-pts-support.md](./features/non-zero-pts-support.md).
+
+---
+
+## Problem
+
+Zero-PTS VOD let one number do everything. The encoded media, the player's
+`currentTime`, and the model's `Track.startTime` were all 0-based and identical,
+so the loader could compare `currentTime` to `segment.startTime` directly and the
+buffer's native PTS matched what the player displayed.
+
+Non-zero-PTS breaks that identity. A Mux instant clip (`asset_start_time=60`)
+encodes its first frame at native PTS ≈ 60s; Apple's bipbop asset starts at 10s.
+Now the buffer's native timeline (60→…) and the player's desired 0-based timeline
+diverge. Live added a **third** timeline — wall-clock, via
+`EXT-X-PROGRAM-DATE-TIME` — and, in doing so, made `Track.startTime` mean
+*different things in different engines*: the live anchor rewrites `startTime` onto
+native PTS, while VOD keeps it 0-normalized. The same field straddles two
+timelines. That ambiguity is the coordinate confusion at the root of the
+"non-zero-PTS is hard" problem.
+
+We want (a) one coherent model of the three timelines, and (b) an architecture
+that adds relocation to the engine **without touching the simple case** — no
+complexity and no bundle cost for the zero-PTS VOD composition that got us this
+far.
+
+---
+
+## Three timelines, one instant
+
+A timeline is fixed by knowing one instant's coordinate in it. Pick the
+**presentation's origin instant** and record its value in each timeline:
+
+| Field | Timeline | Source |
+|---|---|---|
+| `startMediaTime` | **media** (encoded/decode) | `tfdt.baseMediaDecodeTime ÷ mdhd.timescale` |
+| `startTime` | **presentation** (`currentTime`) | 0 for 0-based product semantics (existing field) |
+| `startDate` | **wall-clock** | `EXT-X-PROGRAM-DATE-TIME` (existing field, live) |
+
+All three advance 1:1 in seconds, so **every translation is pure subtraction** —
+no scaling (timescale is already folded into `startMediaTime`):
+
+```text
+timestampOffset = startTime − startMediaTime          # presentation − media
+wallClock(t)    = startDate + (t − startTime)          # time-of-day at presentation time t
+```
+
+`startMediaTime` is the one genuinely new field. The relocation offset is
+**derived from the triple, not stored** — storing both would be two
+representations that drift (see [conventions/signals.md](./conventions/signals.md)).
+
+This model **unifies live anchoring and VOD relocation**: the live anchor is the
+`(media ↔ wall-clock)` edge; VOD relocation is the `(media ↔ presentation)` edge.
+They are two edges of one triangle, which is why the machinery converges (see
+[Open questions](#open-questions)).
+
+### Why `startTime` stays the presentation reference
+
+`startTime` remaining 0-based (not native media) is *why the relocation approach
+is simpler downstream than native-PTS*: with the buffer relocated to 0 via
+`timestampOffset`, `currentTime`, `seekable`, and the loader's
+`currentTime`-vs-`segment.startTime` window math all stay in one 0-based
+coordinate. `startMediaTime` (native) is consumed **only** to compute the offset
+at the buffer boundary — the loader never sees it. (The native-PTS branch made
+`startTime` native and paid for it with coordinate translation everywhere,
+including the initial-load stall.)
+
+The cost: because all tracks relocate by the shared *min*, a skewed non-primary
+track's 0-based `startTime` sits ~skew below its true buffer presentation time
+(Apple: ~44ms for video). Sub-frame, only affects coarse load-window planning —
+vastly better than native-PTS's full-origin (60s) mismatch.
+
+---
+
+## One offset, applied polymorphically
+
+Whatever `startMediaTime` a track is given (own in Tier 1, shared `min` in
+Tier 2), the relocation applies the same way — `presentation = native +
+timestampOffset`, `timestampOffset = startTime − startMediaTime` — only the
+*application* differs:
+
+```text
+buffer sample: presentation = sampleNativePTS + timestampOffset   # MSE sets sb.timestampOffset
+text cue:      cueFinal     = cueNative       + timestampOffset   # we compute it
+               cueNative = LOCAL + MPEGTS/90000 (X-TIMESTAMP-MAP) | absoluteCueTime (no map)
+```
+
+Text has no `SourceBuffer`, so it *effectively* has a `timestampOffset` applied
+as cue arithmetic. This is the live single-anchor rule
+([../../decisions/live-presentation-anchor.md](../../decisions/live-presentation-anchor.md))
+in VOD form: **established from the A/V tracks, applied to all tracks including
+text.**
+
+**Shared-`min` across A/V (Tier 2).** When A/V is skewed, the shared
+`startMediaTime` is `min` across the audio and video tracks' native origins
+(Tier 1 gives each track its own). `min` (not video-primary, not per-track-own):
+- keeps every track's earliest **DTS ≥ 0** (relocating by anything larger drives
+  the lower track negative → Chromium append failure);
+- **preserves real A/V skew** (Apple's 44ms audio-lead is retained; relocating
+  each track to its own 0 would flatten it).
+
+---
+
+## Capability axes (not a tier ladder)
+
+The "tiers" are really **three orthogonal opt-in axes** — a composition enables
+what its platform needs:
+
+| Axis | Off / simple | On / complex | Driven by |
+|---|---|---|---|
+| **Relocation** | no `startMediaTime`, offset 0 | read + apply | is the source non-zero-PTS? |
+| **Parser** | presumptive (first box) | track-id-matched | container packaging (muxed `clcp`/extra track?) |
+| **Coordination** | per-type own (opt-out) | `min`-reduce across A/V (default) | is A/V actually skewed? |
+
+They cross freely — muxed-captions-but-aligned (track-id + single), or
+separate-file-A/V-but-skewed (presumptive + `min`). The parser axis is already
+built as two tree-shakeable exports (`media/mp4/timestamp-origin.ts`,
+committed `cf8aaca45`): `readFirstMediaTimescale`/`readFirstBaseMediaDecodeTime`
+(presumptive) vs `findMediaTrack`/`readBaseMediaDecodeTime` (track-id).
+
+---
+
+## Architecture: discover → derive → apply, established by a reactor
+
+A per-source reactor, **`establishStartMediaTime`**, owns the coordinate
+establishment; the byte-level work rides **steps** in a plain config
+`messagePipelines` array (`relocationMessagePipelines`) woven into the segment
+loader's pipelines. The loader ships a Tier-0 `fetch → dispatch` pipeline and stays
+oblivious to relocation; the steps read composition `state` from their call-time
+`deps` (no closures, no context), so the reactor and the pipeline steps are
+decoupled — **the reactor never touches pipelines**. Enabling relocation = composing
+the reactor + supplying the steps as config (+ optionally a `deriveStartMediaTime`
+seam); a Tier-0 composition does neither.
+
+**The `establishStartMediaTime` reactor** has three states, driven by a `monitor`:
+`inactive` (no resolved presentation — clears the transient `mediaContainerData`
+slot on entry, so each source starts fresh) → `monitoring` (runs the **derive
+effect**) → `established` (the selected A/V tracks carry `startMediaTime`; disables
+the derive — establish-once, sticky per source, like the live anchor). Selection
+signals are **optional/defensive**, so the one reactor composes across video-only /
+audio-only / both. Per-source freshness is structural (the `inactive` transition
+clears the slot), not a hand-rolled reset.
+
+- **Discover** (per-type steps). Head-peek steps read the init (`mdhd` timescale)
+  and the first media segment (`tfdt` baseMediaDecodeTime, plus that segment's
+  0-based `startTime`) and write them into `mediaContainerData`, a
+  `Signal<Record<TrackType, { timescale?; baseMediaDecodeTime?; segmentStartTime? }>>`
+  **keyed by track type** (`'video'`/`'audio'`) — one init+media pair per type
+  suffices, and ABR rungs of a type share the entry. It's a **two-source** read
+  across two appends, but the slot *is* the shared state (init writes `timescale`,
+  the first media segment writes `baseMediaDecodeTime`+`segmentStartTime`), so the
+  steps are independent — no shared closure, no self-discrimination. Writes are
+  **synchronous** RMW of disjoint keys (the sync-merge invariant keeps this clear
+  of the #1746 hazard). Runs on the *fetched* stream, so transport stays pure
+  `fetchBytes`. `segmentStartTime` is recorded because the origin is
+  `baseMediaDecodeTime/timescale − segmentStartTime` — the first *loaded* segment
+  isn't necessarily the 0th (non-zero initial `currentTime`, live/DVR).
+- **Derive** (reactor effect). Watches `mediaContainerData` (+ selection) and, via
+  the injected **`deriveStartMediaTime`** seam, writes the settled per-type
+  `startMediaTime` onto the `Track`s (each type's value stamped on every track of that
+  type). The seam is **pure** —
+  `(mediaContainerData, ctx) => Record<TrackType, number | undefined>` — `undefined`
+  means "not ready yet"; the effect is the sole writer of the field. It's the
+  **one coordination knob**, and the default `deriveSharedMinStartMediaTime` collapses
+  what were "Tier 1" and "Tier 2" into a single reduce: relocate every track by the
+  `min` across the *selected* A/V origins. This subsumes per-type — aligned A/V →
+  `min` equals each origin, skewed A/V → `min` keeps every DTS ≥ 0 *and* preserves the
+  real skew (per-type would flatten it), single-type → its own origin. It returns
+  `undefined` until every selected type is discovered (the shared-`min` barrier). The
+  same value goes to the model here and to the buffer via the tier-agnostic apply. No
+  Presentation-level field is needed — the min is denormalized across the per-type
+  entries. `derivePerTypeStartMediaTime` remains as the barrier-free opt-out for a
+  composition that knows its A/V is aligned.
+- **Apply** (per-track step). A stamp step relocates via `timestampOffset =
+  −startMediaTime`, which the SourceBufferActor applies to
+  `SourceBuffer.timestampOffset`. The apply is **tier-agnostic**: it runs the *same*
+  `deriveStartMediaTime` seam the reactor uses, over the shared `mediaContainerData`
+  slot — so the buffer offset always equals the model's stamped `startMediaTime`, and
+  it's robust to `established` + late tracks (the slot persists and discover gates
+  per-type; the model value may not be re-stamped once the reactor goes sticky). It's
+  **async with an `awaitDefined` holdback**: per-type resolves at once (own origin
+  discovered earlier in the same pipeline); shared-`min` waits until every selected
+  A/V origin is in (the barrier), filled by the other type's discover step — no
+  deadlock, since discover precedes the awaiting stamp. A **liveness guard** short-
+  circuits first: if this type's own origin was never discovered (TS / containerless /
+  a mock/0-PTS-no-`tfdt` source) it leaves the append native and does not wait. A
+  derived `0` also leaves it native (setting `timestampOffset` at all can ripple).
+  Text-cue relocation reuses the model value the reactor stamped (see the text step).
+
+### Consume: `startMediaTime` lives on the model
+
+The settled `startMediaTime` lands per-track on the **CMAF-HAM `Track`**, a peer
+of `startTime` (presentation) and `startDate` (wall-clock). It's a coordinate base
+value that *defines the timeline relationships*, so it belongs on the model, not a
+parallel slot; `timestampOffset` stays derived (`startTime − startMediaTime`),
+never stored.
+
+The **churn** — partial per-track reads across appends — stays in the transient
+`mediaContainerData` slot and never touches `presentation`. Only the *settled*
+value reaches the model, written by the derive effect as **sole writer** of the
+field. That write does share `presentation`'s existing multi-writer situation
+(#1746, addressed at the presentation-ownership level); we accept that rather than
+distort the model to dodge it. This is also where relocation and the live anchor
+**converge** — both are "an establishment unit writing coordinate base values onto
+tracks" (the anchor writes `startTime`/`startDate`, relocation writes
+`startMediaTime`) — the flagged eventual dedup.
+
+### Branch-free always-present actors
+
+The pieces present in *every* composition carry **no relocation vocabulary at
+all** — not even a no-op'd seam. Relocation lives entirely in the reactor and its
+injected steps; the Tier-0 pipeline is literally `[fetch, dispatch]`:
+
+- **SegmentLoaderActor**: owns only the invariant skeleton (`fetchStep`,
+  `dispatchStep`, in-flight bookkeeping, between-step abort checks) and a
+  `messagePipelines` factory that defaults to `fetch → dispatch`. It does not
+  fetch-whole, parse, wait, or know what a `timestampOffset` is.
+- **SourceBufferActor**: sets `sb.timestampOffset` only when the append meta
+  carries one, idempotent-guarded (`meta.timestampOffset != null &&
+  sb.timestampOffset !== meta.timestampOffset`) so re-stamping the constant offset
+  on later appends is a no-op. Absent = untouched. Apply-only.
+
+All tier variation collapses to **the reactor and its injected steps + derive
+seam**; the loader and buffer actors are shared, and Tier 0 imports no relocation
+code.
+
+---
+
+## Key decisions
+
+Documented because they were debated.
+
+### `startTime` stays the presentation reference; add `startMediaTime` (media)
+
+**Decision:** `startTime` remains 0-based (presentation); add `startMediaTime`
+(native media origin) as the new field. `startDate` stays wall-clock.
+
+**Alternatives:**
+- *Make `startTime` honest (native media).* Clean three-field correspondence, but
+  ripples through the parser (stop 0-normalizing), the loader (translate every
+  `currentTime`-vs-`startTime` comparison), and live's `startDate` math — i.e. it
+  *is* the #1746 model cleanup.
+
+**Rationale:** Relocation keeps everything downstream 0-based, so presentation is
+the *correct* timeline for `startTime` here; the native origin is needed only to
+derive the offset. Keeps the loader coordinate-consistent and the simple case
+untouched. The honest-`startTime`-everywhere convergence (which would also
+reconcile live's native `startTime`) is a separate, named future effort.
+
+### Relocation is a per-source reactor; `startMediaTime` on the model via a pure derive seam
+
+**Decision:** relocation is the `establishStartMediaTime` reactor (per-source
+lifecycle), not a config bundle of loose signals. Discovery and apply are loader
+pipeline steps; **derive** is the reactor's effect, driven by a **pure injected
+`deriveStartMediaTime` seam** that maps `mediaContainerData` → per-track
+`startMediaTime`. The churn lives in the transient `mediaContainerData` slot; the
+settled value lands on `Track` (the effect is its sole writer).
+
+**Alternatives:** *a behavior with a hand-rolled reset effect* (the reactor's
+entry/exit gives per-source reset + teardown for free, structurally); *the reduce
+as a `computed`* (can't write the model — and putting `startMediaTime` on the
+model is the point, per the consume decision); *keeping the transient state
+module-local rather than on `state`* (it's coordinate state the model consumes, so
+it belongs on `state`, defined through the reactor).
+
+**Rationale:** the reactor matches the per-source lifecycle relocation actually
+has (and that `setupBufferActors` already models), makes stale-write races
+structural rather than guarded, and isolates the one tier difference into a pure,
+testable seam.
+
+### Shared-`min` origin (the Tier-2 `deriveStartMediaTime`)
+
+**Decision:** the coordination axis is entirely the `deriveStartMediaTime` seam.
+Tier 1 writes each track its own origin; Tier 2 writes the `min` across the
+selected A/V origins onto **every** track. `startMediaTime` stays per-track on
+`Track` in both tiers — Tier 2 denormalizes the min across the per-track slots, so
+no Presentation-level field is required and **apply is unchanged** across tiers.
+
+**Alternatives:** *per-track-own for skewed A/V* (flattens real A/V skew, lossy);
+*video-primary* (the field norm — VHS/hls.js — but they sidestep negative-DTS via
+transmux/offset math we don't have); *a Presentation-level shared value* (not
+needed — the seam denormalizing onto tracks keeps the read path uniform).
+
+**Rationale:** `min` is the only choice that keeps every DTS ≥ 0 *and* preserves
+real inter-track skew; expressing it as a swap of the derive seam means Tier 2 is
+one function change with no movement in discover, apply, or wiring.
+
+### Offset derived, not stored; two parsers split for tree-shaking
+
+`timestampOffset` is a `computed` from the model triple, never a stored field.
+The presumptive vs track-id parsers are separate exports (not one
+optional-selector function) so a caption-free platform tree-shakes the
+track-selection machinery (~37% smaller, verified). Application rides optional
+per-op append metadata so the always-present actors stay branch-free.
+
+### Offset applied via append meta, not a dedicated message (revisitable)
+
+**Decision:** the offset is carried on each media segment's append meta
+(`meta.timestampOffset`) and applied by the SourceBufferActor's
+`appendSegmentTask` (idempotent-guarded). A relocating composition's `stampOffset`
+pipeline step writes it onto the meta before `dispatch` (absent in Tier 0, whose
+pipeline has no such step; the step may be async — see
+["One offset, applied polymorphically"](#one-offset-applied-polymorphically)).
+Setting the offset is **not** its own SourceBuffer message today.
+
+**Alternative:** a dedicated `set-timestamp-offset` SourceBuffer message the
+loader schedules as its own task — cleaner separation of buffer configuration
+from append payload, and the natural shape once each actor's *messages* are
+decoupled from the concrete *Tasks* they translate into (segment-loader
+`planTasks`/`makeLoadTask`/`scheduleAll`; SourceBufferActor `messageTaskFactories`).
+
+**Rationale:** the offset is constant per source, so meta-carried + idempotent
+apply costs nothing and needs no new protocol. And meta-per-segment *generalizes*:
+HLS discontinuities and DASH multi-period re-base `timestampOffset` per period, and
+carrying it on each append gets correct in-order application for free via the
+`SerialRunner` — a standalone message would have to be interleaved into the append
+stream to match. "Set once" is the special case we happen to be in.
+
+**Left open:** promoting offset-setting to its own message remains a valid future
+move; the mid-stream offset-*change* case (discontinuities / multi-period) is the
+likely forcing function, though even then meta-per-segment may still win. Nothing
+in the current seam precludes the switch — this is a deliberate "not yet," not a
+closed door.
+
+---
+
+## Open questions
+
+- ~~**Generalize the live establishment behavior.**~~ *Resolved (mechanism).* VOD
+  relocation is a **sibling** of `anchor-presentation-timeline`, not literally it:
+  a per-source establishment unit (`establishStartMediaTime` reactor) writing a
+  coordinate base value onto tracks, with the tier logic in a pure derive seam
+  rather than a `computed`. The two share the "establish-once, apply-to-all"
+  *shape* (and both write per-track base values → the #1746 multi-writer surface).
+  Whether they should be **one unit** — the anchor writing `startDate`/`startTime`
+  and relocation writing `startMediaTime` folded into a single establisher — is
+  the remaining, larger dedup, still future. See
+  [../../decisions/live-presentation-anchor.md](../../decisions/live-presentation-anchor.md).
+- **Barrier liveness.** For Tier 2, `deriveStartMediaTime` returns `undefined`
+  until the selected A/V origins are all present, and the apply-side
+  `awaitDefined` holds each first append until then — so audio erroring, disabled,
+  or absent must not block forever. The holdback needs a bound (timeout /
+  audio-disabled short-circuit inside the seam's "when"); both VHS and hls.js
+  special-case this.
+- **Holding the first segment across the wait.** The first media segment is held
+  (buffered) while the offset resolves, then appended; steady-state streaming is
+  untouched. The first-chunk peek is validated to contain the `moof` with a
+  ~60–600× margin (first chunk ≥128KB, `moof` ≈0.2–2KB), so no streaming
+  box-peeker is needed — but the hold's interaction with preempt/replan needs
+  care.
+- ~~**`startMediaTime` storage granularity.**~~ *Resolved.* Per-track on `Track`
+  (the self-describing triple), in both tiers — Tier 2 denormalizes the shared
+  `min` across the per-track slots rather than introducing a presentation-level
+  field. Promotion to a `Presentation`-level base value is a possible future move
+  if a real de-dup need appears, but Tier 2 does not force it.
+- **Text-only sources.** No A/V `tfdt` to establish from — but the
+  `X-TIMESTAMP-MAP` `MPEGTS` *is* a media-timeline reference, so text could
+  self-establish. Deferrable special path.
+- ~~**Discovery doesn't belong in the fetch abstraction.**~~ *Resolved.* Discover
+  is now a head-peek discover step run on the *fetched* byte stream inside the
+  loader, not a fetch decorator — transport stays pure `fetchBytes`, and parsing
+  mp4 boxes / writing the raw values into `mediaContainerData` sits where it
+  belongs (a content concern). It keeps the per-track, byte-first, no-double-fetch
+  properties.
+- **Convergence to honest `startMediaTime` everywhere** (the "A" option above),
+  which would let live and VOD share one `startTime` semantic. Its own effort.
+
+---
+
+## See also
+
+- [presentation-modeling.md](./presentation-modeling.md),
+  [live-presentation-modeling.md](./live-presentation-modeling.md) — the data
+  model this extends; #1746 (the concurrently-RMW'd `presentation` hazard) is why
+  the churn stays in the transient `mediaContainerData` slot.
+- [../../decisions/mse-timestamp-offset.md](../../decisions/mse-timestamp-offset.md)
+  — the mechanism decision (native-PTS default; relocation for the 0-based cases).
+- [../../decisions/live-presentation-anchor.md](../../decisions/live-presentation-anchor.md),
+  [../../decisions/live-timeline-anchoring.md](../../decisions/live-timeline-anchoring.md)
+  — the live anchor this generalizes.
+- [features/non-zero-pts-support.md](./features/non-zero-pts-support.md) — the
+  feature framing.
+- `packages/spf/src/media/mp4/` — the committed box parser (presumptive +
+  track-selected).
diff --git a/packages/spf/src/media/buffer/forward-buffer.ts b/packages/spf/src/media/buffer/forward-buffer.ts
index a3ba8f8e..d45cf034 100644
--- a/packages/spf/src/media/buffer/forward-buffer.ts
+++ b/packages/spf/src/media/buffer/forward-buffer.ts
@@ -5,7 +5,46 @@
  * V1 uses simple fixed-duration strategy (buffer N seconds ahead).
  */
 
-import type { Segment } from '../types';
+import { SEGMENT_TIME_EPSILON, type Segment } from '../types';
+
+/** A half-open `[start, end)` interval on the presentation timeline. */
+export interface TimeRange {
+  start: number;
+  end: number;
+}
+
+/**
+ * Merge intervals into sorted, disjoint ranges; touching or overlapping ranges
+ * (gap ≤ `epsilon`) are joined. Empty/inverted ranges are dropped.
+ */
+export function mergeTimeRanges(ranges: readonly TimeRange[], epsilon = SEGMENT_TIME_EPSILON): TimeRange[] {
+  const sorted = ranges.filter((r) => r.end > r.start).sort((a, b) => a.start - b.start);
+  const merged: TimeRange[] = [];
+  for (const r of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && r.start <= last.end + epsilon) {
+      last.end = Math.max(last.end, r.end);
+    } else {
+      merged.push({ start: r.start, end: r.end });
+    }
+  }
+  return merged;
+}
+
+/**
+ * Whether `[start, end)` is fully covered by the union of `merged` ranges,
+ * tolerating `epsilon` of overhang at each edge. `merged` must be disjoint and
+ * sorted (as returned by `mergeTimeRanges`), so full coverage means a single
+ * merged range contains the interval.
+ */
+export function isTimeRangeCovered(
+  start: number,
+  end: number,
+  merged: readonly TimeRange[],
+  epsilon = SEGMENT_TIME_EPSILON
+): boolean {
+  return merged.some((r) => r.start <= start + epsilon && r.end >= end - epsilon);
+}
 
 /**
  * Forward buffer configuration.
diff --git a/packages/spf/src/media/buffer/tests/forward-buffer.test.ts b/packages/spf/src/media/buffer/tests/forward-buffer.test.ts
index ca357c34..74bb97db 100644
--- a/packages/spf/src/media/buffer/tests/forward-buffer.test.ts
+++ b/packages/spf/src/media/buffer/tests/forward-buffer.test.ts
@@ -1,6 +1,12 @@
 import { describe, expect, it } from 'vitest';
 import type { Segment } from '../../types';
-import { calculateForwardFlushPoint, DEFAULT_FORWARD_BUFFER_CONFIG, getSegmentsToLoad } from '../forward-buffer';
+import {
+  calculateForwardFlushPoint,
+  DEFAULT_FORWARD_BUFFER_CONFIG,
+  getSegmentsToLoad,
+  isTimeRangeCovered,
+  mergeTimeRanges,
+} from '../forward-buffer';
 
 // Helper to create test segments
 const createSegment = (startTime: number, duration: number): Segment => ({
@@ -10,6 +16,83 @@ const createSegment = (startTime: number, duration: number): Segment => ({
   duration,
 });
 
+describe('mergeTimeRanges', () => {
+  it('merges contiguous ranges into one', () => {
+    expect(
+      mergeTimeRanges([
+        { start: 0, end: 7.13333 },
+        { start: 7.13333, end: 15.13333 },
+      ])
+    ).toEqual([{ start: 0, end: 15.13333 }]);
+  });
+
+  it('merges overlapping ranges, taking the max end', () => {
+    // A misaligned switch leaves overlapping model entries (low 7.13..15.13, high 7.98..15.98).
+    expect(
+      mergeTimeRanges([
+        { start: 0, end: 7.13333 },
+        { start: 7.13333, end: 15.13333 },
+        { start: 7.98333, end: 15.98333 },
+      ])
+    ).toEqual([{ start: 0, end: 15.98333 }]);
+  });
+
+  it('keeps genuinely disjoint ranges separate (post-seek gap)', () => {
+    expect(
+      mergeTimeRanges([
+        { start: 0, end: 10 },
+        { start: 30, end: 40 },
+      ])
+    ).toEqual([
+      { start: 0, end: 10 },
+      { start: 30, end: 40 },
+    ]);
+  });
+
+  it('drops empty/inverted ranges and sorts', () => {
+    expect(
+      mergeTimeRanges([
+        { start: 20, end: 30 },
+        { start: 5, end: 5 },
+        { start: 0, end: 10 },
+      ])
+    ).toEqual([
+      { start: 0, end: 10 },
+      { start: 20, end: 30 },
+    ]);
+  });
+});
+
+describe('isTimeRangeCovered', () => {
+  const merged = [{ start: 0, end: 15.13333 }];
+
+  it('true when fully contained', () => {
+    expect(isTimeRangeCovered(0, 7.98333, merged)).toBe(true);
+  });
+
+  it('false when the tail extends past coverage (straddling segment)', () => {
+    // high segment-1 (7.98333..15.98333) against a buffer ending at 15.13333.
+    expect(isTimeRangeCovered(7.98333, 15.98333, merged)).toBe(false);
+  });
+
+  it('false when starting past coverage', () => {
+    expect(isTimeRangeCovered(15.98333, 23.98333, merged)).toBe(false);
+  });
+
+  it('tolerates sub-epsilon overhang at the edges', () => {
+    expect(isTimeRangeCovered(-0.00005, 15.13338, merged)).toBe(true);
+  });
+
+  it('requires a single range to contain it (not spanning a gap)', () => {
+    expect(
+      isTimeRangeCovered(5, 35, [
+        { start: 0, end: 10 },
+        { start: 30, end: 40 },
+      ])
+    ).toBe(false);
+  });
+});
+
 describe('calculateForwardFlushPoint', () => {
   it('returns Infinity when no segments are buffered', () => {
     expect(calculateForwardFlushPoint([], 0)).toBe(Infinity);
diff --git a/packages/spf/src/media/dom/mse/append-segment.ts b/packages/spf/src/media/dom/mse/append-segment.ts
index 6e774c2c..3fee8bec 100644
--- a/packages/spf/src/media/dom/mse/append-segment.ts
+++ b/packages/spf/src/media/dom/mse/append-segment.ts
@@ -6,8 +6,10 @@
  * process each append before the next one arrives.
  */
 
-/** Data accepted by appendSegment — a full buffer or an async chunk stream. */
-export type AppendData = ArrayBuffer | AsyncIterable<Uint8Array>;
+import type { SegmentData } from '../../types';
+
+/** Data accepted by appendSegment — the MSE-boundary alias of {@link SegmentData}. */
+export type AppendData = SegmentData;
 
 /**
  * Append media data to a SourceBuffer.
diff --git a/packages/spf/src/media/dom/mse/duration.ts b/packages/spf/src/media/dom/mse/duration.ts
index 8c446fb4..bf41db83 100644
--- a/packages/spf/src/media/dom/mse/duration.ts
+++ b/packages/spf/src/media/dom/mse/duration.ts
@@ -34,25 +34,46 @@ export function canUpdateDuration(
   return !!(mediaSource && presentation && hasPresentationDuration(presentation));
 }
 
+export function getBufferedEnd(
+  buffers: SourceBufferIterable,
+  isEndMatch: (next: number, current: number) => boolean
+): number {
+  return (
+    ([...buffers].reduce((endMatch: number | undefined, buffer) => {
+      const { buffered } = buffer;
+      if (!buffered.length) return endMatch;
+      const end = buffered.end(buffered.length - 1);
+      if (!endMatch) return end;
+      return isEndMatch(end, endMatch) ? end : endMatch;
+    }, undefined) as number) ?? 0
+  );
+}
+
+const isGreaterThan = (x: number, y: number) => x > y;
+const isLessThan = (x: number, y: number) => x < y;
+
 /**
  * Get the maximum buffered end time across an iterable of SourceBuffers
  * (typically `mediaSource.sourceBuffers`). Returns `0` when the collection is
  * empty or no buffer has any buffered ranges.
  */
 export function getMaxBufferedEnd(buffers: SourceBufferIterable): number {
-  let maxEnd = 0;
+  return getBufferedEnd(buffers, isGreaterThan);
+}
 
-  for (const buffer of buffers) {
-    const { buffered } = buffer;
-    if (buffered.length > 0) {
-      const end = buffered.end(buffered.length - 1);
-      if (end > maxEnd) {
-        maxEnd = end;
-      }
-    }
-  }
-
-  return maxEnd;
+/**
+ * Get the reachable buffered end across an iterable of SourceBuffers (typically
+ * `mediaSource.sourceBuffers`): the `min` of each buffer's last buffered-range end
+ * — the furthest point every track can play to (the intersection end). Buffers with
+ * no buffered ranges are skipped. Returns `0` when the collection is empty or no
+ * buffer has any buffered ranges.
+ *
+ * Counterpart to {@link getMaxBufferedEnd}: `max` bounds the overall presentation
+ * end (e.g. for setting `duration`), `min` bounds where playback can actually reach
+ * when tracks end at slightly different times (e.g. skewed A/V near end-of-stream).
+ */
+export function getMinBufferedEnd(buffers: SourceBufferIterable): number {
+  return getBufferedEnd(buffers, isLessThan);
 }
 
 /**
diff --git a/packages/spf/src/media/dom/mse/tests/duration.test.ts b/packages/spf/src/media/dom/mse/tests/duration.test.ts
index d4003ca9..04da4bbd 100644
--- a/packages/spf/src/media/dom/mse/tests/duration.test.ts
+++ b/packages/spf/src/media/dom/mse/tests/duration.test.ts
@@ -1,6 +1,12 @@
 import { describe, expect, it, vi } from 'vitest';
 import type { Presentation } from '../../../types';
-import { canUpdateDuration, getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady } from '../duration';
+import {
+  canUpdateDuration,
+  getMaxBufferedEnd,
+  getMinBufferedEnd,
+  shouldUpdateDuration,
+  waitForSourceBuffersReady,
+} from '../duration';
 
 function makeUpdatingSourceBuffer() {
   const updateEndListeners: Array<() => void> = [];
@@ -131,6 +137,51 @@ describe('getMaxBufferedEnd', () => {
   });
 });
 
+describe('getMinBufferedEnd', () => {
+  it('returns 0 when the buffer list is empty', () => {
+    expect(getMinBufferedEnd([])).toBe(0);
+  });
+
+  it('returns the min last-range end across buffers (the reachable/intersection end)', () => {
+    // Skewed A/V: video buffered slightly past audio; reachable end is the audio (min).
+    const video = {
+      buffered: { length: 1, start: () => 0, end: () => 600.044 } as TimeRanges,
+    } as unknown as SourceBuffer;
+    const audio = {
+      buffered: { length: 1, start: () => 0, end: () => 600.0 } as TimeRanges,
+    } as unknown as SourceBuffer;
+
+    expect(getMinBufferedEnd([video, audio])).toBe(600.0);
+  });
+
+  it('skips buffers with no ranges (min across the buffers that have ranges)', () => {
+    const empty = {
+      buffered: { length: 0, start: () => 0, end: () => 0 } as TimeRanges,
+    } as unknown as SourceBuffer;
+    const buffered = {
+      buffered: { length: 1, start: () => 0, end: () => 30 } as TimeRanges,
+    } as unknown as SourceBuffer;
+
+    expect(getMinBufferedEnd([empty, buffered])).toBe(30);
+  });
+
+  it('uses the last range end when a buffer has multiple (gapped) ranges', () => {
+    const gapped = {
+      buffered: { length: 2, start: (i: number) => (i === 0 ? 0 : 12), end: (i: number) => (i === 0 ? 10 : 30) },
+    } as unknown as SourceBuffer;
+
+    expect(getMinBufferedEnd([gapped])).toBe(30);
+  });
+
+  it('works against a single-buffer audio-only configuration', () => {
+    const audio = {
+      buffered: { length: 1, start: () => 0, end: () => 42 } as TimeRanges,
+    } as unknown as SourceBuffer;
+
+    expect(getMinBufferedEnd([audio])).toBe(42);
+  });
+});
+
 describe('waitForSourceBuffersReady', () => {
   it('resolves immediately when the buffer list is empty', async () => {
     const controller = new AbortController();
diff --git a/packages/spf/src/media/dom/text/resolve-vtt-segment.ts b/packages/spf/src/media/dom/text/resolve-vtt-segment.ts
index 980d591b..b6676a3d 100644
--- a/packages/spf/src/media/dom/text/resolve-vtt-segment.ts
+++ b/packages/spf/src/media/dom/text/resolve-vtt-segment.ts
@@ -5,6 +5,8 @@
  * the browser's optimized VTT parsing. Returns parsed VTTCue objects.
  */
 
+import { resolveVttSegmentMetadata, type TextSegmentMetadata } from '../../text/resolve-vtt-metadata';
+
 // Singleton dummy video (reused across all parsing)
 let dummyVideo: HTMLVideoElement | null = null;
 
@@ -23,7 +25,6 @@ export function resolveVttSegment(url: string): Promise<VTTCue[]> {
   const video = ensureDummyVideo();
   const track = document.createElement('track');
   track.kind = 'subtitles';
-  track.default = true;
 
   return new Promise((resolve, reject) => {
     const onLoad = (): void => {
@@ -57,6 +58,15 @@ export function resolveVttSegment(url: string): Promise<VTTCue[]> {
     track.addEventListener('load', onLoad);
     track.addEventListener('error', onError);
     video.appendChild(track);
+    // Force the browser to load and parse THIS track's resource by activating
+    // it explicitly. Relying on `default = true` only works for the first track
+    // appended to the reused dummy video: the media element's automatic
+    // text-track selection runs once, so on Firefox every subsequent `<track>`
+    // stays inactive, its resource is never fetched, and `load` never fires —
+    // stranding all cues past the first segment. Setting `mode = 'hidden'`
+    // (active but not rendered — this video is never shown) loads each segment
+    // on every browser.
+    track.track.mode = 'hidden';
     track.src = url;
   });
 }
@@ -64,3 +74,25 @@ export function resolveVttSegment(url: string): Promise<VTTCue[]> {
 export function destroyVttResolver(): void {
   dummyVideo = null;
 }
+
+/**
+ * A resolved VTT segment paired with its header metadata — the shape used when a
+ * caller needs the `X-TIMESTAMP-MAP` correlation (e.g. non-zero-PTS sources),
+ * not just the cues.
+ */
+export interface ResolvedVttSegment {
+  cues: VTTCue[];
+  metadata: TextSegmentMetadata;
+}
+
+/**
+ * Resolve a VTT segment's cues and header metadata together. Cues still come
+ * from the browser's native parser ({@link resolveVttSegment}); the header is
+ * scraped in parallel ({@link resolveVttSegmentMetadata}).
+ */
+export function resolveVttSegmentWithMetadata(url: string): Promise<ResolvedVttSegment> {
+  return Promise.all([resolveVttSegment(url), resolveVttSegmentMetadata(url)]).then(([cues, metadata]) => ({
+    cues,
+    metadata,
+  }));
+}
diff --git a/packages/spf/src/media/dom/text/tests/resolve-vtt-segment.test.ts b/packages/spf/src/media/dom/text/tests/resolve-vtt-segment.test.ts
index 41e45298..c3926148 100644
--- a/packages/spf/src/media/dom/text/tests/resolve-vtt-segment.test.ts
+++ b/packages/spf/src/media/dom/text/tests/resolve-vtt-segment.test.ts
@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it } from 'vitest';
-import { destroyVttResolver, resolveVttSegment } from '../resolve-vtt-segment';
+import { resolveVttSegmentMetadata } from '../../../text/resolve-vtt-metadata';
+import { destroyVttResolver, resolveVttSegment, resolveVttSegmentWithMetadata } from '../resolve-vtt-segment';
 
 describe('resolveVttSegment', () => {
   beforeEach(() => {
@@ -191,3 +192,53 @@ Test
     expect(cues).toHaveLength(1);
   });
 });
+
+describe('resolveVttSegmentMetadata', () => {
+  it('extracts the X-TIMESTAMP-MAP from the segment header', async () => {
+    const vttDataUrl =
+      'data:text/vtt,' +
+      encodeURIComponent(`WEBVTT
+X-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:00:00:00.000
+
+1
+00:00:00.008 --> 00:00:00.992
+Bip!
+`);
+
+    const metadata = await resolveVttSegmentMetadata(vttDataUrl);
+    expect(metadata.timestampMap).toEqual({ mpegts: 900000, local: 0 });
+  });
+
+  it('reports an undefined timestampMap when the segment has no map', async () => {
+    const vttDataUrl =
+      'data:text/vtt,' +
+      encodeURIComponent(`WEBVTT
+
+11
+00:00:46.320 --> 00:01:00.880
+The robot.
+`);
+
+    const metadata = await resolveVttSegmentMetadata(vttDataUrl);
+    expect(metadata.timestampMap).toBeUndefined();
+  });
+});
+
+describe('resolveVttSegmentWithMetadata', () => {
+  it('resolves cues and header metadata together', async () => {
+    const vttDataUrl =
+      'data:text/vtt,' +
+      encodeURIComponent(`WEBVTT
+X-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:00:00:00.000
+
+1
+00:00:00.008 --> 00:00:00.992
+Bip!
+`);
+
+    const { cues, metadata } = await resolveVttSegmentWithMetadata(vttDataUrl);
+    expect(cues).toHaveLength(1);
+    expect(cues[0]!.text).toBe('Bip!');
+    expect(metadata.timestampMap).toEqual({ mpegts: 900000, local: 0 });
+  });
+});
diff --git a/packages/spf/src/media/mp4/box.ts b/packages/spf/src/media/mp4/box.ts
new file mode 100644
index 00000000..4c2c7508
--- /dev/null
+++ b/packages/spf/src/media/mp4/box.ts
@@ -0,0 +1,88 @@
+/**
+ * Minimal ISO-BMFF (MP4/CMAF) box walker.
+ *
+ * Just enough to locate boxes by nested path — the framework needs a couple of
+ * leaf fields (`mdhd` timescale, `tfdt` baseMediaDecodeTime) to derive a
+ * segment's decode-time origin, not a full demuxer. DOM-free: operates on an
+ * `ArrayBuffer` / `Uint8Array` via `DataView`.
+ *
+ * Box layout: `[u32 size][u32 type][payload]`. `size === 1` means a `u64
+ * largesize` follows the type (payload after it); `size === 0` means the box
+ * runs to the end of its container.
+ */
+
+/** A located box: its 4-char type and byte offsets within the buffer. */
+export interface Box {
+  type: string;
+  /** Offset of the box's first byte (its size field). */
+  start: number;
+  /** Offset of the box's payload — after `size` + `type` (+ `largesize`). */
+  dataStart: number;
+  /** Offset one past the box's last byte. */
+  end: number;
+}
+
+export function toDataView(data: ArrayBuffer | Uint8Array): DataView {
+  return data instanceof Uint8Array ? new DataView(data.buffer, data.byteOffset, data.byteLength) : new DataView(data);
+}
+
+/** Read a 4-character box type / FourCC at `offset`. */
+export function readFourCC(view: DataView, offset: number): string {
+  return String.fromCharCode(
+    view.getUint8(offset),
+    view.getUint8(offset + 1),
+    view.getUint8(offset + 2),
+    view.getUint8(offset + 3)
+  );
+}
+
+/** Iterate the boxes directly contained in `[start, end)`. */
+export function* iterateBoxes(view: DataView, start = 0, end = view.byteLength): Generator<Box> {
+  let offset = start;
+  while (offset + 8 <= end) {
+    let size = view.getUint32(offset);
+    const type = readFourCC(view, offset + 4);
+    let dataStart = offset + 8;
+    if (size === 1) {
+      size = Number(view.getBigUint64(offset + 8));
+      dataStart = offset + 16;
+    } else if (size === 0) {
+      size = end - offset;
+    }
+    // A size smaller than its own header is malformed — stop rather than loop.
+    if (size < dataStart - offset) return;
+    yield { type, start: offset, dataStart, end: offset + size };
+    offset += size;
+  }
+}
+
+/** Iterate the direct child boxes of a given `type` within `[start, end)`. */
+export function* iterateBoxesOfType(view: DataView, type: string, start = 0, end = view.byteLength): Generator<Box> {
+  for (const box of iterateBoxes(view, start, end)) {
+    if (box.type === type) yield box;
+  }
+}
+
+/**
+ * Depth-first descent to the first box matching a nested path, e.g.
+ * `['moov', 'trak', 'mdia', 'mdhd']`. Returns `undefined` if any level is
+ * absent.
+ */
+export function findBox(view: DataView, path: readonly string[], start = 0, end = view.byteLength): Box | undefined {
+  const [head, ...rest] = path;
+  for (const box of iterateBoxes(view, start, end)) {
+    if (box.type !== head) continue;
+    if (rest.length === 0) return box;
+    const found = findBox(view, rest, box.dataStart, box.end);
+    if (found) return found;
+  }
+  return undefined;
+}
+
+/**
+ * Read the version byte of a FullBox — the `version(1) + flags(3)` header at the
+ * start of the payload of `mdhd` / `tkhd` / `tfdt` / `hdlr` / `elst` / etc.
+ */
+export function readFullBoxVersion(view: DataView, dataStart: number): number {
+  return view.getUint8(dataStart);
+}
diff --git a/packages/spf/src/media/mp4/tests/box.test.ts b/packages/spf/src/media/mp4/tests/box.test.ts
new file mode 100644
index 00000000..bed4cc78
--- /dev/null
+++ b/packages/spf/src/media/mp4/tests/box.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import { findBox, iterateBoxes, iterateBoxesOfType, readFullBoxVersion, toDataView } from '../box';
+import { box, concat, largeBox, u32 } from './synthetic-boxes';
+
+const view = (data: Uint8Array) => toDataView(data);
+
+describe('iterateBoxes', () => {
+  it('yields top-level boxes with correct type and offsets', () => {
+    const ftyp = box('ftyp', u32(0));
+    const moov = box('moov', u32(0));
+    const boxes = [...iterateBoxes(view(concat(ftyp, moov)))];
+    expect(boxes.map((b) => b.type)).toEqual(['ftyp', 'moov']);
+    expect(boxes[0]).toMatchObject({ start: 0, dataStart: 8, end: ftyp.length });
+    expect(boxes[1]).toMatchObject({ start: ftyp.length, dataStart: ftyp.length + 8 });
+  });
+
+  it('reads a 64-bit largesize box (size field === 1)', () => {
+    const big = largeBox('free', u32(0));
+    const [b] = [...iterateBoxes(view(big))];
+    expect(b).toMatchObject({ type: 'free', start: 0, dataStart: 16, end: big.length });
+  });
+
+  it('stops on a malformed size smaller than the header', () => {
+    const bad = new Uint8Array(8);
+    new DataView(bad.buffer).setUint32(0, 2); // size 2 < 8-byte header
+    expect([...iterateBoxes(view(bad))]).toEqual([]);
+  });
+});
+
+describe('iterateBoxesOfType', () => {
+  it('yields only direct children of the given type', () => {
+    const data = concat(box('trak', u32(1)), box('free', u32(0)), box('trak', u32(2)));
+    const traks = [...iterateBoxesOfType(view(data), 'trak')];
+    expect(traks).toHaveLength(2);
+    expect(traks.every((b) => b.type === 'trak')).toBe(true);
+  });
+});
+
+describe('readFullBoxVersion', () => {
+  it('reads the version byte at the payload start', () => {
+    for (const version of [0, 1] as const) {
+      const dv = view(box('mdhd', new Uint8Array([version, 0, 0, 0])));
+      const [b] = [...iterateBoxes(dv)];
+      expect(readFullBoxVersion(dv, b!.dataStart)).toBe(version);
+    }
+  });
+});
+
+describe('findBox', () => {
+  it('descends a nested path', () => {
+    const data = box('moov', box('trak', box('mdia', box('mdhd', u32(90000)))));
+    const found = findBox(view(data), ['moov', 'trak', 'mdia', 'mdhd']);
+    expect(found?.type).toBe('mdhd');
+  });
+
+  it('skips non-matching siblings at each level', () => {
+    const data = concat(box('free', u32(0)), box('moov', box('mvhd', u32(0)), box('trak', box('tkhd', u32(0)))));
+    expect(findBox(view(data), ['moov', 'trak'])?.type).toBe('trak');
+  });
+
+  it('returns undefined when any path level is absent', () => {
+    const data = box('moov', box('trak'));
+    expect(findBox(view(data), ['moov', 'trak', 'mdia'])).toBeUndefined();
+    expect(findBox(view(data), ['moof', 'traf'])).toBeUndefined();
+  });
+});
diff --git a/packages/spf/src/media/mp4/tests/synthetic-boxes.ts b/packages/spf/src/media/mp4/tests/synthetic-boxes.ts
new file mode 100644
index 00000000..5247a59d
--- /dev/null
+++ b/packages/spf/src/media/mp4/tests/synthetic-boxes.ts
@@ -0,0 +1,124 @@
+/**
+ * Hand-built ISO-BMFF boxes for unit tests — precise control over
+ * version/field layout and multi-track muxing without committing binary
+ * segment fixtures. Real-stream validation of the parsers lives in the
+ * non-zero-PTS spike probes, not here.
+ */
+
+export function concat(...parts: Uint8Array[]): Uint8Array {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
+export function u32(value: number): Uint8Array {
+  const out = new Uint8Array(4);
+  new DataView(out.buffer).setUint32(0, value);
+  return out;
+}
+
+export function u64(value: number | bigint): Uint8Array {
+  const out = new Uint8Array(8);
+  new DataView(out.buffer).setBigUint64(0, BigInt(value));
+  return out;
+}
+
+function fourcc(type: string): Uint8Array {
+  return new Uint8Array([type.charCodeAt(0), type.charCodeAt(1), type.charCodeAt(2), type.charCodeAt(3)]);
+}
+
+/** A standard box: `[u32 size][4-char type][payload]`. */
+export function box(type: string, ...children: Uint8Array[]): Uint8Array {
+  const payload = concat(...children);
+  const out = new Uint8Array(8 + payload.length);
+  new DataView(out.buffer).setUint32(0, out.length);
+  out.set(fourcc(type), 4);
+  out.set(payload, 8);
+  return out;
+}
+
+/** A 64-bit-`largesize` box (`size` field === 1). */
+export function largeBox(type: string, ...children: Uint8Array[]): Uint8Array {
+  const payload = concat(...children);
+  const out = new Uint8Array(16 + payload.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, 1);
+  out.set(fourcc(type), 4);
+  view.setBigUint64(8, BigInt(out.length));
+  out.set(payload, 16);
+  return out;
+}
+
+const flags = new Uint8Array(3);
+const versionFlags = (version: 0 | 1) => new Uint8Array([version, 0, 0, 0]);
+
+/** `mdhd` FullBox carrying `timescale`. v0 = 32-bit dates, v1 = 64-bit dates. */
+export function mdhd(timescale: number, version: 0 | 1 = 0): Uint8Array {
+  const dates = version === 1 ? concat(u64(0), u64(0)) : concat(u32(0), u32(0));
+  const duration = version === 1 ? u64(0) : u32(0);
+  return box('mdhd', new Uint8Array([version]), flags, dates, u32(timescale), duration);
+}
+
+/** `tkhd` FullBox carrying `track_id`. */
+export function tkhd(trackId: number, version: 0 | 1 = 0): Uint8Array {
+  const dates = version === 1 ? concat(u64(0), u64(0)) : concat(u32(0), u32(0));
+  return box('tkhd', versionFlags(version), dates, u32(trackId), u32(0) /* reserved */);
+}
+
+/** `hdlr` FullBox: version+flags, pre_defined, `handler_type`, reserved, name. */
+export function hdlr(handlerType: string): Uint8Array {
+  return box(
+    'hdlr',
+    versionFlags(0),
+    u32(0) /* pre_defined */,
+    fourcc(handlerType),
+    new Uint8Array(12),
+    new Uint8Array([0])
+  );
+}
+
+/** `tfdt` FullBox carrying `baseMediaDecodeTime`. v0 = 32-bit, v1 = 64-bit. */
+export function tfdt(baseMediaDecodeTime: number | bigint, version: 0 | 1 = 0): Uint8Array {
+  const value = version === 1 ? u64(baseMediaDecodeTime) : u32(Number(baseMediaDecodeTime));
+  return box('tfdt', versionFlags(version), value);
+}
+
+/** `tfhd` FullBox carrying `track_id` (right after version+flags). */
+export function tfhd(trackId: number): Uint8Array {
+  return box('tfhd', versionFlags(0), u32(trackId));
+}
+
+export interface TrakSpec {
+  handler: string;
+  trackId: number;
+  timescale: number;
+  mdhdVersion?: 0 | 1;
+  tkhdVersion?: 0 | 1;
+}
+
+/** A `trak`: `tkhd` + `mdia > (hdlr, mdhd)`. */
+export function trak({ handler, trackId, timescale, mdhdVersion = 0, tkhdVersion = 0 }: TrakSpec): Uint8Array {
+  return box('trak', tkhd(trackId, tkhdVersion), box('mdia', hdlr(handler), mdhd(timescale, mdhdVersion)));
+}
+
+/** An init segment: `ftyp` + `moov > (mvhd, ...traks)`. */
+export function initSegment(...traks: Uint8Array[]): Uint8Array {
+  return concat(box('ftyp', u32(0)), box('moov', box('mvhd', u32(0)), ...traks));
+}
+
+export interface TrafSpec {
+  trackId: number;
+  baseMediaDecodeTime: number | bigint;
+  version?: 0 | 1;
+}
+
+/** A media segment: `styp` + `moof > (mfhd, ...traf)`, each `traf` = `tfhd` + `tfdt`. */
+export function mediaSegment(...trafs: TrafSpec[]): Uint8Array {
+  const trafBoxes = trafs.map((t) => box('traf', tfhd(t.trackId), tfdt(t.baseMediaDecodeTime, t.version ?? 0)));
+  return concat(box('styp', u32(0)), box('moof', box('mfhd', u32(0)), ...trafBoxes));
+}
diff --git a/packages/spf/src/media/mp4/tests/timestamp-origin.test.ts b/packages/spf/src/media/mp4/tests/timestamp-origin.test.ts
new file mode 100644
index 00000000..de1db35c
--- /dev/null
+++ b/packages/spf/src/media/mp4/tests/timestamp-origin.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+import {
+  findMediaTrack,
+  readBaseMediaDecodeTime,
+  readFirstBaseMediaDecodeTime,
+  readFirstMediaTimescale,
+} from '../timestamp-origin';
+import { box, initSegment, mediaSegment, trak } from './synthetic-boxes';
+
+// Mirrors the Apple bipbop advanced example: a video init/segment that muxes a
+// closed-caption (`clcp`) track alongside the `vide` track, each with its own
+// timescale and baseMediaDecodeTime.
+const muxedVideoInit = initSegment(
+  trak({ handler: 'vide', trackId: 1, timescale: 6000 }),
+  trak({ handler: 'clcp', trackId: 2, timescale: 30000 })
+);
+const muxedVideoSegment = mediaSegment(
+  { trackId: 1, baseMediaDecodeTime: 60000 }, // video → 60000/6000 = 10.0s
+  { trackId: 2, baseMediaDecodeTime: 300000 } // captions → 300000/30000 = 10.0s
+);
+
+describe('readFirstMediaTimescale', () => {
+  it('reads the first mdhd timescale (single-track init)', () => {
+    const audioInit = initSegment(trak({ handler: 'soun', trackId: 1, timescale: 48000 }));
+    expect(readFirstMediaTimescale(audioInit)).toBe(48000);
+  });
+
+  it('reads the first trak on a muxed init — correct only by ordering', () => {
+    // Video happens to be first here; a clcp-first muxing would mis-read. That
+    // ordering fragility is exactly why the muxed case needs findMediaTrack.
+    expect(readFirstMediaTimescale(muxedVideoInit)).toBe(6000);
+  });
+
+  it('reads a v1 mdhd timescale (wider date fields)', () => {
+    const init = initSegment(trak({ handler: 'vide', trackId: 1, timescale: 90000, mdhdVersion: 1 }));
+    expect(readFirstMediaTimescale(init)).toBe(90000);
+  });
+
+  it('returns undefined when no mdhd exists', () => {
+    expect(readFirstMediaTimescale(box('moov', box('mvhd')))).toBeUndefined();
+  });
+});
+
+describe('findMediaTrack', () => {
+  it('selects the media track by handler, ignoring a muxed caption track', () => {
+    expect(findMediaTrack(muxedVideoInit, 'vide')).toEqual({ trackId: 1, timescale: 6000 });
+  });
+
+  it('selects an audio track by handler', () => {
+    const audioInit = initSegment(trak({ handler: 'soun', trackId: 1, timescale: 48000 }));
+    expect(findMediaTrack(audioInit, 'soun')).toEqual({ trackId: 1, timescale: 48000 });
+  });
+
+  it('handles v1 tkhd/mdhd (wider date fields)', () => {
+    const init = initSegment(trak({ handler: 'vide', trackId: 7, timescale: 90000, mdhdVersion: 1, tkhdVersion: 1 }));
+    expect(findMediaTrack(init, 'vide')).toEqual({ trackId: 7, timescale: 90000 });
+  });
+
+  it('returns undefined when no track matches the handler', () => {
+    expect(findMediaTrack(muxedVideoInit, 'soun')).toBeUndefined();
+  });
+});
+
+describe('readFirstBaseMediaDecodeTime', () => {
+  it('reads the first traf', () => {
+    expect(readFirstBaseMediaDecodeTime(muxedVideoSegment)).toBe(60000);
+  });
+
+  it('reads a 64-bit v1 baseMediaDecodeTime beyond the 32-bit range', () => {
+    const large = 2 ** 33 + 12345;
+    expect(readFirstBaseMediaDecodeTime(mediaSegment({ trackId: 1, baseMediaDecodeTime: large, version: 1 }))).toBe(
+      large
+    );
+  });
+
+  it('returns undefined when the traf or tfdt is absent', () => {
+    expect(readFirstBaseMediaDecodeTime(box('moof', box('traf')))).toBeUndefined();
+  });
+});
+
+describe('readBaseMediaDecodeTime', () => {
+  it('selects the traf matching track_id in a muxed segment', () => {
+    expect(readBaseMediaDecodeTime(muxedVideoSegment, 1)).toBe(60000);
+    expect(readBaseMediaDecodeTime(muxedVideoSegment, 2)).toBe(300000);
+  });
+
+  it('returns undefined when no traf matches track_id', () => {
+    expect(readBaseMediaDecodeTime(muxedVideoSegment, 99)).toBeUndefined();
+  });
+});
+
+describe('track-tied origin (cross-track mismatch guard)', () => {
+  it('pairs timescale and baseMediaDecodeTime from the same track', () => {
+    const track = findMediaTrack(muxedVideoInit, 'vide')!;
+    const bmdt = readBaseMediaDecodeTime(muxedVideoSegment, track.trackId)!;
+    // Correct, track-tied origin.
+    expect(bmdt / track.timescale).toBe(10);
+    // The bug track_id matching prevents: video timescale paired with the
+    // caption track's baseMediaDecodeTime would read 50s, not 10s.
+    const captionBmdt = readBaseMediaDecodeTime(muxedVideoSegment, 2)!;
+    expect(captionBmdt / track.timescale).toBe(50);
+  });
+});
diff --git a/packages/spf/src/media/mp4/timestamp-origin.ts b/packages/spf/src/media/mp4/timestamp-origin.ts
new file mode 100644
index 00000000..d39d0950
--- /dev/null
+++ b/packages/spf/src/media/mp4/timestamp-origin.ts
@@ -0,0 +1,155 @@
+/**
+ * Decode-time origin extraction from fMP4/CMAF segments.
+ *
+ * Non-zero-PTS sources encode media at a non-zero start time (an instant clip
+ * starting at asset second 60, an Apple bipbop asset starting at 10s, …). To
+ * relocate such a source onto a 0-based presentation timeline via
+ * `SourceBuffer.timestampOffset`, the engine needs that start time — the
+ * **decode-time origin** — read straight from the container:
+ *
+ * - `tfdt.baseMediaDecodeTime` (from a media segment's `moof`) — the decode
+ *   time of the segment's first sample, in the track's media timescale. This is
+ *   a DTS: relocating by `−(baseMediaDecodeTime / timescale)` lands the earliest
+ *   DTS at exactly 0, so a negative-DTS append failure on Chromium is impossible
+ *   by construction.
+ * - `mdhd.timescale` (from the init segment's `moov`) — ticks per second for
+ *   that track, needed to convert the raw tick count to seconds.
+ *
+ * ## Presumptive vs. track-selected reads
+ *
+ * The two variants share only the leaf field-readers (`mdhd` timescale, `tfdt`
+ * baseMediaDecodeTime) and the box walker. Everything else differs, and the
+ * split is deliberate so the presumptive pair is *proportionally* smaller under
+ * tree-shaking:
+ *
+ * - **Presumptive** — {@link readFirstMediaTimescale} / {@link readFirstBaseMediaDecodeTime}
+ *   read the first `mdhd` timescale and first `tfdt` baseMediaDecodeTime. There's
+ *   no `track_id` (nothing to match against) and no `trak`/`traf` iteration — a
+ *   direct `findBox` to the first leaf. Correct when the init/segment holds a
+ *   single media track (the common CMAF case). A caption-free platform imports
+ *   only this pair and tree-shakes away all the matching machinery below.
+ * - **Track-selected** — {@link findMediaTrack} / {@link readBaseMediaDecodeTime}.
+ *   `findMediaTrack` returns `{ trackId, timescale }` for the `trak` whose `hdlr`
+ *   handler matches; `readBaseMediaDecodeTime` takes that `trackId` and reads the
+ *   `traf` whose `tfhd.track_id` matches. The `track_id` is the join that ties one
+ *   track's timescale to the *same* track's baseMediaDecodeTime — required when a
+ *   source muxes CEA-608/708 captions (a `clcp` track shares the same `moov` and
+ *   `moof`, each track with its own timescale + baseMediaDecodeTime, so a
+ *   presumptive read there risks `300000 / 6000 = 50s` instead of
+ *   `60000 / 6000 = 10s`). This pair adds `trak`/`traf` iteration plus the handler
+ *   and `track_id` reads. We only ever ask for buffered media handlers
+ *   (`vide` / `soun`); the caption track is never selected — we read the origin,
+ *   not the captions (caption *rendering* is out of scope).
+ *
+ * Both raw values are returned un-divided to leave room for an edit-list (`elst`)
+ * presentation-time correction term if a source ever carries one — the validated
+ * streams do not.
+ */
+import { type Box, findBox, iterateBoxesOfType, readFourCC, readFullBoxVersion, toDataView } from './box';
+
+/** MSE-buffered media handler types (`mdhd`/`hdlr`). Captions/subtitles excluded. */
+export type MediaHandlerType = 'vide' | 'soun';
+
+export interface MediaTrackInfo {
+  /** `tkhd.track_id` — used to match the corresponding `traf` in media segments. */
+  trackId: number;
+  /** `mdhd.timescale` — ticks per second for this track. */
+  timescale: number;
+}
+
+// --- presumptive: first leaf, no track_id, no iteration -----------------------
+
+/**
+ * Presumptive: the `timescale` of the **first** `mdhd` in an init segment.
+ * Correct only for single-media-track inits — for muxed captions use
+ * {@link findMediaTrack}. `undefined` if no `mdhd` exists.
+ */
+export function readFirstMediaTimescale(initSegment: ArrayBuffer | Uint8Array): number | undefined {
+  const view = toDataView(initSegment);
+  const mdhd = findBox(view, ['moov', 'trak', 'mdia', 'mdhd']);
+  return mdhd ? readMdhdTimescale(view, mdhd) : undefined;
+}
+
+/**
+ * Presumptive: `baseMediaDecodeTime` from the **first** `tfdt` of a media
+ * segment. Correct only for single-`traf` segments — for muxed captions use
+ * {@link readBaseMediaDecodeTime}. `undefined` if no `tfdt` exists.
+ */
+export function readFirstBaseMediaDecodeTime(mediaSegment: ArrayBuffer | Uint8Array): number | undefined {
+  const view = toDataView(mediaSegment);
+  const tfdt = findBox(view, ['moof', 'traf', 'tfdt']);
+  return tfdt ? readTfdtBaseMediaDecodeTime(view, tfdt) : undefined;
+}
+
+// --- track-selected: iterate + match by handler / track_id --------------------
+
+/**
+ * The `track_ID` + timescale of the `trak` whose `mdhd` handler matches
+ * `handlerType`, skipping a muxed `clcp` caption track. `undefined` if no
+ * matching track exists.
+ */
+export function findMediaTrack(
+  initSegment: ArrayBuffer | Uint8Array,
+  handlerType: MediaHandlerType
+): MediaTrackInfo | undefined {
+  const view = toDataView(initSegment);
+  const moov = findBox(view, ['moov']);
+  if (!moov) return undefined;
+
+  for (const trak of iterateBoxesOfType(view, 'trak', moov.dataStart, moov.end)) {
+    if (readTrakHandler(view, trak) !== handlerType) continue;
+    const tkhd = findBox(view, ['tkhd'], trak.dataStart, trak.end);
+    const mdhd = findBox(view, ['mdia', 'mdhd'], trak.dataStart, trak.end);
+    if (!tkhd || !mdhd) return undefined;
+    // tkhd FullBox: version(1)+flags(3), creation/modification dates (v0: 4+4, v1:
+    // 8+8), then track_id.
+    const trackId = view.getUint32(tkhd.dataStart + 4 + (readFullBoxVersion(view, tkhd.dataStart) === 1 ? 16 : 8));
+    return { trackId, timescale: readMdhdTimescale(view, mdhd) };
+  }
+  return undefined;
+}
+
+/**
+ * `baseMediaDecodeTime` (in the track's media timescale) from the `traf` matching
+ * `trackId` (via `tfhd.track_id`) — required for muxed multi-`traf` segments.
+ * `undefined` if no matching `tfdt` exists.
+ */
+export function readBaseMediaDecodeTime(mediaSegment: ArrayBuffer | Uint8Array, trackId: number): number | undefined {
+  const view = toDataView(mediaSegment);
+  const moof = findBox(view, ['moof']);
+  if (!moof) return undefined;
+
+  for (const traf of iterateBoxesOfType(view, 'traf', moof.dataStart, moof.end)) {
+    if (readTrafTrackId(view, traf) !== trackId) continue;
+    const tfdt = findBox(view, ['tfdt'], traf.dataStart, traf.end);
+    return tfdt ? readTfdtBaseMediaDecodeTime(view, tfdt) : undefined;
+  }
+  return undefined;
+}
+
+// --- shared leaf field-readers ------------------------------------------------
+
+/** `mdhd.timescale`: FullBox version(1)+flags(3) + dates (v0: 4+4, v1: 8+8) + timescale. */
+function readMdhdTimescale(view: DataView, mdhd: Box): number {
+  return view.getUint32(mdhd.dataStart + 4 + (readFullBoxVersion(view, mdhd.dataStart) === 1 ? 16 : 8));
+}
+
+/** `tfdt.baseMediaDecodeTime`: FullBox, then the value — v0: (4), v1: (8). */
+function readTfdtBaseMediaDecodeTime(view: DataView, tfdt: Box): number {
+  const at = tfdt.dataStart + 4;
+  return readFullBoxVersion(view, tfdt.dataStart) === 1 ? Number(view.getBigUint64(at)) : view.getUint32(at);
+}
+
+// --- track-selection readers (referenced only by the track-selected variants) -
+
+/** `hdlr.handler_type` for a `trak`: FullBox version(1)+flags(3) + pre_defined(4) + handler_type(4). */
+function readTrakHandler(view: DataView, trak: Box): string | undefined {
+  const hdlr = findBox(view, ['mdia', 'hdlr'], trak.dataStart, trak.end);
+  return hdlr ? readFourCC(view, hdlr.dataStart + 8) : undefined;
+}
+
+/** `tfhd.track_id` for a `traf`: FullBox version(1)+flags(3) + track_id(4). */
+function readTrafTrackId(view: DataView, traf: Box): number | undefined {
+  const tfhd = findBox(view, ['tfhd'], traf.dataStart, traf.end);
+  return tfhd ? view.getUint32(tfhd.dataStart + 4) : undefined;
+}
diff --git a/packages/spf/src/media/text/parse-vtt-timestamp-map.ts b/packages/spf/src/media/text/parse-vtt-timestamp-map.ts
new file mode 100644
index 00000000..57e73891
--- /dev/null
+++ b/packages/spf/src/media/text/parse-vtt-timestamp-map.ts
@@ -0,0 +1,55 @@
+/**
+ * WebVTT-in-HLS `X-TIMESTAMP-MAP`: correlates a cue's LOCAL (in-file) time with
+ * an MPEG-2 presentation timestamp, so LOCAL-authored cues can be placed on the
+ * media presentation timeline. Stored raw — the LOCAL→native correction is
+ * `mpegts / 90000 - local` — so it stays independent of how (or whether) the
+ * presentation is later re-origined. See the HLS spec, RFC 8216bis §3.5.
+ */
+export interface TimestampMap {
+  /** The MPEG-2 presentation timestamp, in 90 kHz ticks, as authored. */
+  mpegts: number;
+  /** The LOCAL cue time the `mpegts` value maps to, in seconds. */
+  local: number;
+}
+
+const TIMESTAMP_MAP_PREFIX = 'X-TIMESTAMP-MAP=';
+
+/**
+ * Scrape a WebVTT segment's `X-TIMESTAMP-MAP` header into a {@link TimestampMap}
+ * — the only header line we need to correlate LOCAL cue times with the media
+ * presentation timeline. Deliberately *not* a WebVTT parser: cue parsing stays
+ * with the browser's native `<track>` parser (which drops this line); this reads
+ * just the one header field the native path discards.
+ *
+ * Returns `undefined` when the segment carries no map (e.g. cues already in
+ * absolute presentation time) — per the HLS spec that means LOCAL 0 maps to
+ * MPEGTS 0. Tolerant of attribute order and `[HH:]MM:SS.mmm` LOCAL forms.
+ */
+export function parseVttTimestampMap(text: string): TimestampMap | undefined {
+  const timestampMapLine = text.split(/\r\n|\r|\n/).find((line) => line.startsWith(TIMESTAMP_MAP_PREFIX));
+  return timestampMapLine ? parseTimestampMapBody(timestampMapLine.slice(TIMESTAMP_MAP_PREFIX.length)) : undefined;
+}
+
+const TimeStampMapParserMap = {
+  LOCAL: parseWebVttTimestamp,
+  MPEGTS: (v: string) => +v,
+} as const;
+
+type TimeStampMapParserMap = typeof TimeStampMapParserMap;
+
+function parseTimestampMapBody(body: string): TimestampMap | undefined {
+  return Object.fromEntries(
+    body.split(',').map((kvStr) => {
+      const [k, v] = kvStr.split(/:(.*)/).map((kOrV) => kOrV.trim());
+      return [k?.toLowerCase(), TimeStampMapParserMap[k as keyof TimeStampMapParserMap](v as string)];
+    })
+  ) as TimestampMap;
+}
+
+/** Seconds-per-unit for the `[HH:]MM:SS.mmm` parts, right-aligned so a missing HH just drops the leading weight. */
+const VTT_TIMESTAMP_WEIGHTS = [3600, 60, 1, 0.001];
+
+function parseWebVttTimestamp(value: string): number {
+  const parts = value.split(/[:.]/);
+  return parts.reduce((acc, val, i) => acc + +val * (VTT_TIMESTAMP_WEIGHTS[i + 4 - parts.length] ?? 0), 0);
+}
diff --git a/packages/spf/src/media/text/resolve-vtt-metadata.ts b/packages/spf/src/media/text/resolve-vtt-metadata.ts
new file mode 100644
index 00000000..c7a10a3c
--- /dev/null
+++ b/packages/spf/src/media/text/resolve-vtt-metadata.ts
@@ -0,0 +1,28 @@
+/**
+ * Header-level text-segment metadata — the `X-TIMESTAMP-MAP` correlation scraped from
+ * a VTT segment's raw bytes. DOM-free (a plain fetch + regex parse): the native
+ * `<track>` parser in `media/dom/text` (`resolveVttSegment`) discards this header, so a
+ * caller that needs it (e.g. non-zero-PTS relocation) fetches the bytes itself.
+ */
+import { parseVttTimestampMap, type TimestampMap } from './parse-vtt-timestamp-map';
+
+/**
+ * Header-level metadata for a text segment, surfaced alongside its cues. Each
+ * field is present only when the segment declared it.
+ */
+export interface TextSegmentMetadata {
+  timestampMap?: TimestampMap;
+}
+
+/**
+ * Fetch a VTT segment and scrape only its header metadata (no cue parsing).
+ *
+ * The native `<track>` parser (`media/dom/text`'s `resolveVttSegment`) discards
+ * `X-TIMESTAMP-MAP`, so reading it requires the raw bytes. This is a separate,
+ * caller-controlled fetch — the caller decides *when* metadata is needed (e.g.
+ * once per source) rather than paying for it on every segment.
+ */
+export async function resolveVttSegmentMetadata(url: string): Promise<TextSegmentMetadata> {
+  const text = await fetch(url).then((response) => response.text());
+  return { timestampMap: parseVttTimestampMap(text) };
+}
diff --git a/packages/spf/src/media/text/tests/parse-vtt-timestamp-map.test.ts b/packages/spf/src/media/text/tests/parse-vtt-timestamp-map.test.ts
new file mode 100644
index 00000000..4661d4de
--- /dev/null
+++ b/packages/spf/src/media/text/tests/parse-vtt-timestamp-map.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { parseVttTimestampMap } from '../parse-vtt-timestamp-map';
+
+describe('parseVttTimestampMap', () => {
+  it('parses an Apple-style header (MPEGTS:900000, LOCAL zero)', () => {
+    const text = 'WEBVTT\nX-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:00:00:00.000\n\n1\n00:00:00.008 --> 00:00:00.992\nBip!\n';
+    expect(parseVttTimestampMap(text)).toEqual({ mpegts: 900000, local: 0 });
+  });
+
+  it('parses a non-zero LOCAL value into seconds', () => {
+    const text = 'WEBVTT\nX-TIMESTAMP-MAP=MPEGTS:1351801,LOCAL:00:00:15.000\n';
+    expect(parseVttTimestampMap(text)).toEqual({ mpegts: 1351801, local: 15 });
+  });
+
+  it('is tolerant of attribute order (LOCAL before MPEGTS)', () => {
+    const text = 'WEBVTT\nX-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000\n';
+    expect(parseVttTimestampMap(text)).toEqual({ mpegts: 900000, local: 0 });
+  });
+
+  it('parses the MM:SS.mmm LOCAL form', () => {
+    const text = 'WEBVTT\nX-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:01:30.500\n';
+    expect(parseVttTimestampMap(text)).toEqual({ mpegts: 900000, local: 90.5 });
+  });
+
+  it('returns undefined when no map is present (Mux-style absolute cues)', () => {
+    const text = 'WEBVTT\n\n11\n00:00:46.320 --> 00:01:00.880\nThe robot.\n';
+    expect(parseVttTimestampMap(text)).toBeUndefined();
+  });
+
+  it('tolerates spaces around attributes and CRLF newlines', () => {
+    const text = 'WEBVTT\r\nX-TIMESTAMP-MAP=MPEGTS:900000, LOCAL:00:00:00.000\r\n';
+    expect(parseVttTimestampMap(text)).toEqual({ mpegts: 900000, local: 0 });
+  });
+});
diff --git a/packages/spf/src/media/types/index.ts b/packages/spf/src/media/types/index.ts
index 7aecbbf2..7617e3f8 100644
--- a/packages/spf/src/media/types/index.ts
+++ b/packages/spf/src/media/types/index.ts
@@ -131,8 +131,53 @@ export type Track = Ham &
     bandwidth: number;
     initialization?: AddressableObject;
     segments: Segment[];
+    /**
+     * Media-timeline (decode/encode) coordinate of the track's timeline origin
+     * (`startTime`) — the media-time base value of the coordinate model, peer to
+     * `startTime` (presentation). Derived from the container
+     * (`tfdt.baseMediaDecodeTime ÷ mdhd.timescale`); the relocation offset is
+     * `startTime − startMediaTime`, never stored.
+     *
+     * Optional: absent until established (0-PTS sources never set it — their
+     * origin is already 0). Established once per source by the
+     * `establishStartMediaTime` reactor. See
+     * `internal/design/spf/presentation-timeline-model.md`.
+     */
+    startMediaTime?: number;
   };
 
+/**
+ * Per-track-type origin-establishment data, accumulated across appends (the media
+ * track's `track_id` + `mdhd` timescale from the init, `tfdt` baseMediaDecodeTime of
+ * that same track from the first media segment) — hence optional. The transient input
+ * the `establishStartMediaTime` reactor reduces into `Track.startMediaTime`.
+ *
+ * `trackId` is the ISO-BMFF `track_ID` of the buffered media track (`vide`/`soun`),
+ * read from the init's `tkhd`; it ties the timescale to the *same* track's
+ * `baseMediaDecodeTime` (matched via `tfhd.track_id`) so a muxed segment carrying a
+ * second track (e.g. `clcp` captions) reads the right `tfdt` rather than the first one.
+ *
+ * `segmentStartTime` is the 0-based presentation start of the segment
+ * `baseMediaDecodeTime` was read from — *not* a container value (it's the playlist
+ * position), but co-located because the origin is `baseMediaDecodeTime/timescale −
+ * segmentStartTime`: the first *loaded* segment isn't necessarily the 0th (a
+ * non-zero initial `currentTime`, or live/DVR), so the decode time alone isn't the
+ * stream origin.
+ */
+export interface MediaContainerData {
+  trackId?: number;
+  timescale?: number;
+  baseMediaDecodeTime?: number;
+  segmentStartTime?: number;
+}
+
+/**
+ * Raw media-segment bytes — a complete buffer or a byte stream. The transport-neutral
+ * payload the loader pipeline carries; `AppendData` (the MSE `SourceBuffer` append
+ * input in `media/dom/mse`) is an alias of this at the DOM boundary.
+ */
+export type SegmentData = ArrayBuffer | AsyncIterable<Uint8Array>;
+
 /**
  * Resolved video track with segments.
  */
diff --git a/packages/spf/src/playback/actors/dom/segment-loader.ts b/packages/spf/src/playback/actors/dom/segment-loader.ts
index a69ffe1f..7c2364c9 100644
--- a/packages/spf/src/playback/actors/dom/segment-loader.ts
+++ b/packages/spf/src/playback/actors/dom/segment-loader.ts
@@ -1,5 +1,4 @@
 import { createMachineActor, type HandlerContext, type MessageActor } from '../../../core/actors/create-machine-actor';
-import { effect } from '../../../core/signals/effect';
 import { peek } from '../../../core/signals/primitives';
 import { SerialRunner, Task } from '../../../core/tasks/task';
 import {
@@ -12,15 +11,20 @@ import {
   DEFAULT_FORWARD_BUFFER_CONFIG,
   type ForwardBufferConfig,
   getSegmentsToLoad,
+  isTimeRangeCovered,
+  mergeTimeRanges,
 } from '../../../media/buffer/forward-buffer';
+import { type AudioTrack, SEGMENT_TIME_EPSILON, type Segment, type VideoTrack } from '../../../media/types';
 import {
-  type AddressableObject,
-  type AudioTrack,
-  SEGMENT_TIME_EPSILON,
-  type Segment,
-  type VideoTrack,
-} from '../../../media/types';
-import type { AppendInitMessage, AppendSegmentMessage, RemoveMessage, SourceBufferActor } from './source-buffer';
+  DEFAULT_MESSAGE_PIPELINES,
+  type FetchBytes,
+  type Frame,
+  type LoadStep,
+  type LoadTask,
+  type MessagePipelines,
+  type StepDeps,
+} from '../../primitives/segment-load-pipeline';
+import type { SourceBufferActor } from './source-buffer';
 
 // ============================================================================
 // BUFFER STATE TYPES
@@ -68,27 +72,6 @@ export type SegmentLoaderMessage = {
   range?: { start: number; end: number };
 };
 
-// ============================================================================
-// LOAD TASK
-// ============================================================================
-
-/**
- * A LoadTask is the intent to perform one unit of SegmentLoader work.
- * Unlike SourceBufferMessage, fetch-based tasks carry a URL rather than
- * pre-fetched data — the runner fetches and appends them in sequence.
- *
- * Derived from SourceBufferMessage types by removing `data` and adding
- * a fetch URL via AddressableObject.
- *
- * @todo Rename — "LoadTask" risks confusion with the `Task` class used for
- * SourceBufferActor scheduling. These are closer to operation descriptors or
- * messages than tasks in that sense.
- */
-export type LoadTask =
-  | (Omit<AppendInitMessage, 'data'> & AddressableObject)
-  | (Omit<AppendSegmentMessage, 'data'> & AddressableObject)
-  | RemoveMessage;
-
 // ============================================================================
 // ACTOR INTERFACE
 // ============================================================================
@@ -100,8 +83,15 @@ export type SegmentLoaderActorState = 'idle' | 'loading' | 'destroyed';
 export interface SegmentLoaderActorContext {
   /** Track ID of the init segment currently being fetched/appended, or null. */
   inFlightInitTrackId: string | null;
-  /** Segment ID currently being fetched/appended, or null. */
-  inFlightSegmentId: string | null;
+  /**
+   * Identity of the segment currently being fetched/appended, or null. Tracks
+   * the `trackId` alongside the positional `id` because renditions number
+   * segments independently (`segment-N`): an in-flight LOW `segment-0` must not
+   * be mistaken for a needed HIGH `segment-0` on a switch (see the loading
+   * handler's continue/preempt decision). Mirrors the text-track loader, which
+   * already matches its in-flight segment on `(inFlightTrackId, inFlightSegmentId)`.
+   */
+  inFlightSegment: { id: string; trackId: string } | null;
 }
 
 export type SegmentLoaderActor = MessageActor<SegmentLoaderActorState, SegmentLoaderActorContext, SegmentLoaderMessage>;
@@ -114,58 +104,8 @@ export type SegmentLoaderActor = MessageActor<SegmentLoaderActorState, SegmentLo
 export interface SegmentLoaderActorConfig {
   forwardBuffer?: Partial<ForwardBufferConfig>;
   backBuffer?: Partial<BackBufferConfig>;
-}
-
-// ============================================================================
-// HELPERS
-// ============================================================================
-
-type FetchBytes = (
-  addressable: AddressableObject,
-  options?: RequestInit & { minChunkSize?: number }
-) => Promise<AsyncIterable<Uint8Array>>;
-
-/**
- * Resolves when the SourceBufferActor snapshot reaches 'idle'.
- * Rejects if the signal is aborted or the actor is destroyed.
- *
- * Used to sequence SourceBufferActor operations without awaiting send()
- * directly — send() is fire-and-forget; callers observe completion via
- * state transition.
- */
-function waitForIdle(snapshot: SourceBufferActor['snapshot'], signal: AbortSignal): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (snapshot.get().value === 'idle') {
-      resolve();
-      return;
-    }
-    if (snapshot.get().value === 'destroyed') {
-      reject(new DOMException('Aborted', 'AbortError'));
-      return;
-    }
-    if (signal.aborted) {
-      reject(signal.reason);
-      return;
-    }
-
-    let stop: (() => void) | undefined;
-
-    const cleanup = (fn: () => void) => {
-      stop?.();
-      signal.removeEventListener('abort', onAbort);
-      fn();
-    };
-
-    const onAbort = () => cleanup(() => reject(signal.reason));
-
-    stop = effect(() => {
-      const value = snapshot.get().value;
-      if (value === 'idle') cleanup(resolve);
-      else if (value === 'destroyed') cleanup(() => reject(new DOMException('Aborted', 'AbortError')));
-    });
-
-    signal.addEventListener('abort', onAbort, { once: true });
-  });
+  /** Per-message-type step pipelines. Defaults to {@link DEFAULT_MESSAGE_PIPELINES} (`fetch → dispatch`). */
+  messagePipelines?: MessagePipelines;
 }
 
 // ============================================================================
@@ -175,57 +115,37 @@ function waitForIdle(snapshot: SourceBufferActor['snapshot'], signal: AbortSigna
 interface LoadTaskOptions {
   getContext: () => SegmentLoaderActorContext;
   setContext: (ctx: SegmentLoaderActorContext) => void;
-  fetchBytes: FetchBytes;
-  sourceBufferActor: SourceBufferActor;
+  pipelines: Record<LoadTask['type'], LoadStep[]>;
+  deps: StepDeps;
 }
 
 /**
- * Wraps a LoadTask descriptor into a Task that fetches (if needed) and
- * forwards to SourceBufferActor. Updates in-flight context around async
- * operations so the loading handler can make accurate continue/preempt
- * decisions at any point.
+ * Wraps a LoadTask descriptor into a Task that runs the op's message pipeline
+ * (fetch/discover/stamp/dispatch, per the composition's `messagePipelines`).
+ * Updates in-flight context around the async region so the loading handler can
+ * make accurate continue/preempt decisions at any point, and checks the abort
+ * signal before each step.
  */
-function makeLoadTask(
-  op: LoadTask,
-  { getContext, setContext, fetchBytes, sourceBufferActor }: LoadTaskOptions
-): Task<void> {
+function makeLoadTask(op: LoadTask, { getContext, setContext, pipelines, deps }: LoadTaskOptions): Task<void> {
   return new Task(async (taskSignal) => {
     if (taskSignal.aborted) return;
 
-    if (op.type === 'remove') {
-      sourceBufferActor.send(op);
-      await waitForIdle(sourceBufferActor.snapshot, taskSignal);
-      return;
-    }
+    const frame: Frame = op.type === 'append-segment' ? { op, meta: op.meta } : { op };
 
-    if (op.type === 'append-init') {
-      setContext({ ...getContext(), inFlightInitTrackId: op.meta.trackId });
-      try {
-        // Init segments are small and need the full body before appending.
-        // minChunkSize: Infinity accumulates all chunks into one before yielding.
-        const data = await fetchBytes(op, { signal: taskSignal, minChunkSize: Infinity });
-        if (!taskSignal.aborted) {
-          sourceBufferActor.send({ type: 'append-init', data, meta: op.meta });
-          await waitForIdle(sourceBufferActor.snapshot, taskSignal);
-        }
-      } finally {
-        setContext({ ...getContext(), inFlightInitTrackId: null });
-      }
-      return;
-    }
-
-    // append-segment: await headers eagerly (starts the HTTP connection and
-    // records the fetch in observers like tests), then pass the body stream
-    // directly to the actor so chunks are appended as they arrive.
-    setContext({ ...getContext(), inFlightSegmentId: op.meta.id });
+    // In-flight bookkeeping brackets the async region; the `finally` resets it
+    // even if a step aborts or throws mid-pipeline. Only append ops track it.
     try {
-      const stream = await fetchBytes(op, { signal: taskSignal });
-      if (!taskSignal.aborted) {
-        sourceBufferActor.send({ type: 'append-segment', data: stream, meta: op.meta });
-        await waitForIdle(sourceBufferActor.snapshot, taskSignal);
+      if (op.type === 'append-init') setContext({ ...getContext(), inFlightInitTrackId: op.meta.trackId });
+      else if (op.type === 'append-segment')
+        setContext({ ...getContext(), inFlightSegment: { id: op.meta.id, trackId: op.meta.trackId } });
+
+      for (const step of pipelines[op.type]) {
+        if (taskSignal.aborted) return;
+        await step(frame, taskSignal, deps);
       }
     } finally {
-      setContext({ ...getContext(), inFlightSegmentId: null });
+      if (op.type === 'append-init') setContext({ ...getContext(), inFlightInitTrackId: null });
+      else if (op.type === 'append-segment') setContext({ ...getContext(), inFlightSegment: null });
     }
   });
 }
@@ -252,21 +172,46 @@ function makeLoadTask(
  * @param fetchBytes - Tracked fetch closure (owns throughput sampling for segments).
  *   Accepts an optional `minChunkSize` in options; init segments pass `Infinity`
  *   so the entire body accumulates as one chunk before appending.
+ * @param compositionDeps - The composition's `state`/`context`/`config`, threaded
+ *   opaquely into each step's {@link StepDeps} (the loader never reads them). Lets
+ *   injected steps (relocation) read composition signals at call time. Defaults to
+ *   empty for standalone / base-pipeline use.
  */
 export function createSegmentLoaderActor(
   sourceBufferActor: SourceBufferActor,
   fetchBytes: FetchBytes,
-  config: SegmentLoaderActorConfig = {}
+  config: SegmentLoaderActorConfig = {},
+  compositionDeps: StepDeps = { state: {}, context: {}, config: {} }
 ): SegmentLoaderActor {
   type UserState = Exclude<SegmentLoaderActorState, 'destroyed'>;
   type Ctx = HandlerContext<UserState, SegmentLoaderActorContext, () => SerialRunner>;
 
   const forwardBufferConfig: ForwardBufferConfig = { ...DEFAULT_FORWARD_BUFFER_CONFIG, ...config.forwardBuffer };
   const backBufferConfig: BackBufferConfig = { ...DEFAULT_BACK_BUFFER_CONFIG, ...config.backBuffer };
+  // Fold the loader's own wiring into the passthrough `config` (see `stepWiring`) so
+  // base steps read it from the uniform `{state,context,config}` — present in both
+  // composition and standalone use.
+  const deps: StepDeps = {
+    state: compositionDeps.state,
+    context: compositionDeps.context,
+    config: { ...compositionDeps.config, sourceBufferActor, fetch: fetchBytes },
+  };
+  // Built once per actor (fresh stateful steps per source); default is `fetch → dispatch`.
+  const pipelines = (config.messagePipelines ?? DEFAULT_MESSAGE_PIPELINES)();
 
   const getBufferedSegments = (allSegments: readonly Segment[]): Segment[] => {
-    // Exclude partial segments — they are still being streamed and must not be
-    // treated as fully buffered for load planning or buffer window calculations.
+    // A candidate segment counts as "already buffered" only when its whole time
+    // span is covered by appended content — a TIME question, not a positional-id
+    // one. Renditions are numbered independently per playlist (`segment-N`), so
+    // matching by id assumes every rung shares the same segment grid. That fails
+    // for renditions whose boundaries don't align (e.g. a 30fps rung cuts its
+    // first GOP at 7.13s, a 60fps rung at 7.98s): the switched-to rung's segment
+    // reuses a buffered id but spans a *later*-ending range, so an id match would
+    // skip it and leave its uncovered tail as a gap. Covering by time refetches
+    // exactly that straddling segment (MSE overwrites the overlap on append).
+    //
+    // Exclude partial segments — they are still streaming and must not count as
+    // fully buffered for load planning or buffer window calculations.
     //
     // `peek` defensively: `load` handlers run synchronously inside `send()`,
     // which is called from inside the dispatcher reactor's `effects:` body.
@@ -274,12 +219,9 @@ export function createSegmentLoaderActor(
     // snapshot into the dispatcher's dep set, causing the dispatcher to re-
     // fire on every SourceBufferActor state change. Mirrors the fix applied
     // to the text-track loader in `b3f44efe`.
-    const bufferedIds = new Set(
-      peek(sourceBufferActor.snapshot)
-        .context.segments.filter((s) => !s.partial)
-        .map((s) => s.id)
-    );
-    return allSegments.filter((s) => bufferedIds.has(s.id));
+    const appended = peek(sourceBufferActor.snapshot).context.segments.filter((s) => !s.partial);
+    const merged = mergeTimeRanges(appended.map((s) => ({ start: s.startTime, end: s.startTime + s.duration })));
+    return allSegments.filter((s) => isTimeRangeCovered(s.startTime, s.startTime + s.duration, merged));
   };
 
   /**
@@ -440,22 +382,20 @@ export function createSegmentLoaderActor(
 
   const scheduleAll = (tasks: LoadTask[], { getContext, setContext, runner }: Ctx): void => {
     tasks.forEach((op) => {
-      runner
-        .schedule(makeLoadTask(op, { getContext, setContext, fetchBytes, sourceBufferActor }))
-        .then(undefined, (e: unknown) => {
-          if (e instanceof Error && e.name === 'AbortError') return;
-          // On unexpected fetch/append errors, abort remaining tasks so a failed
-          // init doesn't cause segment fetches to proceed with no init segment.
-          console.error('Unexpected error in segment loader:', e);
-          runner.abortPending();
-        });
+      runner.schedule(makeLoadTask(op, { getContext, setContext, pipelines, deps })).then(undefined, (e: unknown) => {
+        if (e instanceof Error && e.name === 'AbortError') return;
+        // On unexpected fetch/append errors, abort remaining tasks so a failed
+        // init doesn't cause segment fetches to proceed with no init segment.
+        console.error('Unexpected error in segment loader:', e);
+        runner.abortPending();
+      });
     });
   };
 
   return createMachineActor<UserState, SegmentLoaderActorContext, SegmentLoaderMessage, () => SerialRunner>({
     runner: () => new SerialRunner(),
     initial: 'idle',
-    context: { inFlightInitTrackId: null, inFlightSegmentId: null },
+    context: { inFlightInitTrackId: null, inFlightSegment: null },
     states: {
       idle: {
         on: {
@@ -474,10 +414,23 @@ export function createSegmentLoaderActor(
             const { context, runner } = ctx;
             const allTasks = planTasks(msg);
 
-            // Determine whether the in-flight operation is still needed.
+            // Determine whether the in-flight operation is still needed. The
+            // segment match requires BOTH the positional id AND the trackId:
+            // renditions number segments independently, so an in-flight LOW
+            // `segment-0` (spanning [0, 7.13]) must NOT be treated as covering a
+            // switched-to HIGH `segment-0` (spanning [0, 7.98]). Matching by id
+            // alone kept the LOW fetch, skipped HIGH's leading segment, and left
+            // its tail as a gap — intermittently, only when the switch beat the
+            // in-flight append. A track switch now always preempts (correct: the
+            // new rendition's same-slot segment must be (re)fetched).
+            const inFlight = context.inFlightSegment;
+            const segmentInFlightStillNeeded = (t: LoadTask): boolean =>
+              t.type === 'append-segment' &&
+              inFlight !== null &&
+              t.meta.id === inFlight.id &&
+              t.meta.trackId === inFlight.trackId;
             const inFlightStillNeeded =
-              (context.inFlightSegmentId !== null &&
-                allTasks.some((t) => t.type === 'append-segment' && t.meta.id === context.inFlightSegmentId)) ||
+              (inFlight !== null && allTasks.some(segmentInFlightStillNeeded)) ||
               (context.inFlightInitTrackId !== null &&
                 allTasks.some((t) => t.type === 'append-init' && t.meta.trackId === context.inFlightInitTrackId));
 
@@ -488,7 +441,7 @@ export function createSegmentLoaderActor(
               scheduleAll(
                 allTasks.filter(
                   (t) =>
-                    !(t.type === 'append-segment' && t.meta.id === context.inFlightSegmentId) &&
+                    !segmentInFlightStillNeeded(t) &&
                     !(t.type === 'append-init' && t.meta.trackId === context.inFlightInitTrackId)
                 ),
                 ctx
@@ -502,7 +455,7 @@ export function createSegmentLoaderActor(
               // signal is not aborted (abortAll was called on the runner, but the init
               // task already completed or will complete via its own signal path).
               const cancelSourceBuffer =
-                context.inFlightSegmentId !== null ||
+                context.inFlightSegment !== null ||
                 (context.inFlightInitTrackId !== null &&
                   allTasks.some((t) => t.type === 'append-init' && t.meta.trackId !== context.inFlightInitTrackId));
               if (cancelSourceBuffer) {
diff --git a/packages/spf/src/playback/actors/dom/source-buffer.ts b/packages/spf/src/playback/actors/dom/source-buffer.ts
index 59dcd976..f8290d08 100644
--- a/packages/spf/src/playback/actors/dom/source-buffer.ts
+++ b/packages/spf/src/playback/actors/dom/source-buffer.ts
@@ -3,6 +3,12 @@ import { SerialRunner, Task } from '../../../core/tasks/task';
 import { type AppendData, appendSegment } from '../../../media/dom/mse/append-segment';
 import { flushBuffer } from '../../../media/dom/mse/buffer-flusher';
 import { SEGMENT_TIME_EPSILON, type Segment, type Track } from '../../../media/types';
+import type {
+  AppendInitMessage,
+  AppendSegmentMessage,
+  IndividualSourceBufferMessage,
+  RemoveMessage,
+} from '../../primitives/source-buffer-messages';
 
 // =============================================================================
 // Types
@@ -13,29 +19,8 @@ export interface BufferedRange {
   end: number;
 }
 
-export type AppendSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & {
-  trackId: Track['id'];
-  /** Declared track bandwidth in bps (from playlist BANDWIDTH attribute). */
-  trackBandwidth?: number;
-};
-
 export type { AppendData };
 
-export type AppendInitMessage = {
-  type: 'append-init';
-  data: AppendData;
-  /**
-   * `language` is captured alongside `trackId` so downstream loaders can
-   * compare the buffered track's language to the newly-selected track's
-   * language and decide whether ahead-buffer flush is warranted on track
-   * switch (see `segment-loader`'s `planTasks`). Undefined for video and
-   * for audio without explicit `LANGUAGE` attribute.
-   */
-  meta: { trackId: Track['id']; language?: string };
-};
-export type AppendSegmentMessage = { type: 'append-segment'; data: AppendData; meta: AppendSegmentMeta };
-export type RemoveMessage = { type: 'remove'; start: number; end: number };
-export type IndividualSourceBufferMessage = AppendInitMessage | AppendSegmentMessage | RemoveMessage;
 export type BatchMessage = { type: 'batch'; messages: IndividualSourceBufferMessage[] };
 export type CancelMessage = { type: 'cancel' };
 
@@ -127,6 +112,12 @@ function appendSegmentTask(
     // across playlists. `SEGMENT_TIME_EPSILON` guards against floating-point
     // drift in parsed timestamps (shared with the segment-loader quality
     // filter — single source of truth).
+    //
+    // Misaligned renditions (e.g. 30fps vs 60fps rungs) break the same-slot
+    // assumption: the switched-to segment's differing startTime is kept as a
+    // separate overlapping entry rather than truncating the older one to the
+    // portion MSE didn't overwrite. Cosmetic today (see #1865 for the
+    // most-recent-append-wins model); coverage/flush stay correct.
     const filtered = ctx.segments.filter((s) => Math.abs(s.startTime - meta.startTime) >= SEGMENT_TIME_EPSILON);
 
     // For streaming data: emit partial state before the first chunk so
@@ -151,6 +142,12 @@ function appendSegmentTask(
       });
     }
 
+    // Relocation: set the offset before the coded frames are appended. The
+    // SerialRunner guarantees the buffer is idle here, so the assignment is safe.
+    // Guarded so re-stamping the (constant) offset on later appends is a no-op.
+    if (meta.timestampOffset != null && sourceBuffer.timestampOffset !== meta.timestampOffset) {
+      sourceBuffer.timestampOffset = meta.timestampOffset;
+    }
     await appendSegment(sourceBuffer, message.data, taskSignal);
     // No abort check here: the physical SourceBuffer has been modified, so
     // the model must be updated to match regardless of signal state.
diff --git a/packages/spf/src/playback/actors/dom/text-tracks.ts b/packages/spf/src/playback/actors/dom/text-tracks.ts
index e3d632e1..d057957a 100644
--- a/packages/spf/src/playback/actors/dom/text-tracks.ts
+++ b/packages/spf/src/playback/actors/dom/text-tracks.ts
@@ -1,13 +1,7 @@
 import { createTransitionActor } from '../../../core/actors/create-transition-actor';
 import type { Cue } from '../../../media/types';
-import type {
-  AddCuesMessage,
-  ClearMessage,
-  CueSegmentMeta,
-  TextTracksActor,
-  TextTracksActorContext,
-  TextTracksActorMessage,
-} from '../text-tracks';
+import type { AddCuesMessage, CueSegmentMeta } from '../../primitives/text-track-messages';
+import type { ClearMessage, TextTracksActor, TextTracksActorContext, TextTracksActorMessage } from '../text-tracks';
 
 // Re-export the host-agnostic types so existing dom-side consumers can keep
 // importing from this module.
diff --git a/packages/spf/src/playback/actors/dom/tsconfig.json b/packages/spf/src/playback/actors/dom/tsconfig.json
index a7004700..c2346db5 100644
--- a/packages/spf/src/playback/actors/dom/tsconfig.json
+++ b/packages/spf/src/playback/actors/dom/tsconfig.json
@@ -12,7 +12,8 @@
     { "path": "../../../network" },
     { "path": "../../../media" },
     { "path": "../../../media/dom" },
-    { "path": "../" }
+    { "path": "../" },
+    { "path": "../../primitives" }
   ],
   "include": ["./**/*.ts"]
 }
diff --git a/packages/spf/src/playback/actors/text-track-segment-loader.ts b/packages/spf/src/playback/actors/text-track-segment-loader.ts
index 592330b9..cf55d24e 100644
--- a/packages/spf/src/playback/actors/text-track-segment-loader.ts
+++ b/packages/spf/src/playback/actors/text-track-segment-loader.ts
@@ -6,7 +6,15 @@ import {
   type ForwardBufferConfig,
   getSegmentsToLoad,
 } from '../../media/buffer/forward-buffer';
-import type { Cue, Segment, TextTrack } from '../../media/types';
+import type { Cue, TextTrack } from '../../media/types';
+import {
+  DEFAULT_TEXT_MESSAGE_PIPELINES,
+  type TextFrame,
+  type TextLoadTask,
+  type TextMessagePipelines,
+  type TextStepDeps,
+  type TextTrackSegmentResolver,
+} from '../primitives/text-segment-load-pipeline';
 import type { TextTracksActor } from './text-tracks';
 
 // =============================================================================
@@ -51,16 +59,6 @@ export type TextTrackSegmentLoaderActor = MessageActor<
   TextTrackSegmentLoaderMessage
 >;
 
-/**
- * Resolves a text-track segment URL into the array of cues it contains.
- *
- * "Resolve" because the fn covers both network fetch and parse into the
- * domain model. Host-agnostic — the concrete resolver (e.g. the
- * browser's native VTT resolver) is supplied at engine-assembly time,
- * so this actor stays DOM-free.
- */
-export type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;
-
 /**
  * Configuration for `createTextTrackSegmentLoaderActor`. Spread over
  * `DEFAULT_FORWARD_BUFFER_CONFIG` to override individual forward-window
@@ -68,20 +66,16 @@ export type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Pro
  * concern — cues evict by their playhead-relative window at runtime —
  * so no `backBuffer` config field.
  */
-export interface TextTrackSegmentLoaderActorConfig {
+export interface TextTrackSegmentLoaderActorConfig<C extends Cue = Cue> {
   forwardBuffer?: Partial<ForwardBufferConfig>;
+  /** Ordered step pipeline. Defaults to {@link DEFAULT_TEXT_MESSAGE_PIPELINES} (`resolveCues → dispatchCues`). */
+  messagePipelines?: TextMessagePipelines<C>;
 }
 
 // =============================================================================
 // Implementation
 // =============================================================================
 
-/** Internal load-task descriptor — one segment fetch + dispatch unit. */
-interface TextLoadTask {
-  segment: Segment;
-  trackId: string;
-}
-
 /**
  * Loads text-track segments for a track and delegates cue management
  * to a TextTracksActor. Mirrors the v/a `SegmentLoaderActor` shape (FSM
@@ -112,12 +106,26 @@ interface TextLoadTask {
 export function createTextTrackSegmentLoaderActor<C extends Cue>(
   textTracksActor: TextTracksActor<C>,
   resolveSegment: TextTrackSegmentResolver<C>,
-  config: TextTrackSegmentLoaderActorConfig = {}
+  config: TextTrackSegmentLoaderActorConfig<C> = {},
+  // Composition deps threaded opaquely into each step's `TextStepDeps` (relocation
+  // reads composition state). The loader never reads them. Defaults empty for
+  // standalone / base-pipeline use.
+  compositionDeps: TextStepDeps = { state: {}, context: {}, config: {} }
 ): TextTrackSegmentLoaderActor {
   type UserState = Exclude<TextTrackSegmentLoaderActorState, 'destroyed'>;
   type Ctx = HandlerContext<UserState, TextTrackSegmentLoaderActorContext, () => SerialRunner>;
 
   const forwardBufferConfig: ForwardBufferConfig = { ...DEFAULT_FORWARD_BUFFER_CONFIG, ...config.forwardBuffer };
+  // Fold the loader's wiring into the passthrough `config` (see `textStepWiring`) so
+  // base steps read it from the uniform `{state,context,config}` — present in both
+  // composition and standalone use.
+  const deps: TextStepDeps = {
+    state: compositionDeps.state,
+    context: compositionDeps.context,
+    config: { ...compositionDeps.config, textTracksActor, resolveSegment },
+  };
+  // Built once per actor; default is `resolveCues → dispatchCues`.
+  const pipeline = (config.messagePipelines ?? DEFAULT_TEXT_MESSAGE_PIPELINES)();
 
   /**
    * Translate a load message into an ordered TextLoadTask list based on
@@ -148,27 +156,26 @@ export function createTextTrackSegmentLoaderActor<C extends Cue>(
   };
 
   /**
-   * Wraps a TextLoadTask into a Task that fetches + dispatches `add-cues`.
-   * Updates `inFlightSegmentId` around the fetch so the load handler can
-   * make accurate continue/preempt decisions.
+   * Wraps a TextLoadTask into a Task that runs the op's step pipeline
+   * (resolve/relocate/dispatch, per the composition's `messagePipelines`).
+   * Updates `inFlightSegmentId` around the async region so the load handler can
+   * make accurate continue/preempt decisions, and checks the abort signal before
+   * each step.
+   *
+   * Text degrades gracefully: a step throwing (e.g. a failed segment fetch) is
+   * logged and swallowed so the runner continues to the next segment — unlike the
+   * v/a loader, where a failed init must abort the remaining tasks.
    */
   const makeLoadTask = (op: TextLoadTask, { getContext, setContext }: Ctx): Task<void> => {
     return new Task(async (signal) => {
       if (signal.aborted) return;
+      const frame: TextFrame<C> = { op };
       setContext({ ...getContext(), inFlightTrackId: op.trackId, inFlightSegmentId: op.segment.id });
       try {
-        const cues = await resolveSegment(op.segment.url);
-        if (signal.aborted) return;
-        textTracksActor.send({
-          type: 'add-cues',
-          meta: {
-            trackId: op.trackId,
-            id: op.segment.id,
-            startTime: op.segment.startTime,
-            duration: op.segment.duration,
-          },
-          cues,
-        });
+        for (const step of pipeline) {
+          if (signal.aborted) return;
+          await step(frame, signal, deps);
+        }
       } catch (error) {
         // Graceful degradation: log and continue to the next segment.
         console.error('Failed to load text-track segment:', error);
diff --git a/packages/spf/src/playback/actors/text-tracks.ts b/packages/spf/src/playback/actors/text-tracks.ts
index f9670608..8d613990 100644
--- a/packages/spf/src/playback/actors/text-tracks.ts
+++ b/packages/spf/src/playback/actors/text-tracks.ts
@@ -1,13 +1,11 @@
 import type { TransitionActor } from '../../core/actors/create-transition-actor';
 import type { Cue, Segment } from '../../media/types';
+import type { AddCuesMessage } from '../primitives/text-track-messages';
 
 // =============================================================================
 // Message / context shapes
 // =============================================================================
 
-/** Segment identity and timing — mirrors AppendSegmentMeta without trackId (keyed separately). */
-export type CueSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & { trackId: string };
-
 /** Non-finite (extended) data managed by the actor — the XState "context". */
 export interface TextTracksActorContext {
   /** Cues added per track ID. Used for duplicate detection and snapshot observability. */
@@ -16,12 +14,6 @@ export interface TextTracksActorContext {
   segments: Record<string, Array<Pick<Segment, 'id' | 'startTime' | 'duration'>>>;
 }
 
-export interface AddCuesMessage<C extends Cue = Cue> {
-  type: 'add-cues';
-  meta: CueSegmentMeta;
-  cues: C[];
-}
-
 /**
  * Wipe the actor's `loaded` + `segments` context. Sent on source reset
  * (typically by `syncTextTracks` on state exit) so a subsequent
diff --git a/packages/spf/src/playback/actors/tsconfig.json b/packages/spf/src/playback/actors/tsconfig.json
index fe864a4e..7b74f588 100644
--- a/packages/spf/src/playback/actors/tsconfig.json
+++ b/packages/spf/src/playback/actors/tsconfig.json
@@ -6,7 +6,12 @@
     "exactOptionalPropertyTypes": false,
     "declarationDir": "../../../types/playback/actors"
   },
-  "references": [{ "path": "../../../../utils" }, { "path": "../../core" }, { "path": "../../media" }],
+  "references": [
+    { "path": "../../../../utils" },
+    { "path": "../../core" },
+    { "path": "../../media" },
+    { "path": "../primitives" }
+  ],
   "include": ["./*.ts", "./tests/**/*.ts"],
   "exclude": ["./dom/**"]
 }
diff --git a/packages/spf/src/playback/behaviors/dom/end-of-stream.ts b/packages/spf/src/playback/behaviors/dom/end-of-stream.ts
index 35e99ded..9d39adbf 100644
--- a/packages/spf/src/playback/behaviors/dom/end-of-stream.ts
+++ b/packages/spf/src/playback/behaviors/dom/end-of-stream.ts
@@ -58,11 +58,12 @@
  *
  * # currentTime gate
  *
- * `currentTime` must have reached at least one active track's last
- * segment startTime. Prevents `'eos-ready'` entry when a back-buffer
- * `remove()` / `appendBuffer()` briefly re-opens the MediaSource while
- * the user is mid-stream. HLS rendition time-alignment means any active
- * track works as the reference.
+ * `currentTime` must have reached (within {@link LAST_SEGMENT_REACHED_SLACK})
+ * at least one active track's last segment startTime. Prevents `'eos-ready'`
+ * entry when a back-buffer `remove()` / `appendBuffer()` briefly re-opens the
+ * MediaSource while the user is mid-stream. HLS rendition time-alignment means
+ * any active track works as the reference. The slack absorbs the near-end
+ * playhead freeze (see the constant) so a tiny final segment doesn't deadlock.
  *
  * # MS readyState — local subscription
  *
@@ -116,6 +117,18 @@ export interface EndOfStreamContext {
 
 type EndOfStreamFsmState = 'preconditions-unmet' | 'eos-ready';
 
+/**
+ * Slack (seconds) on the "playhead has reached the last segment" gate. A tiny final
+ * segment (e.g. Apple's ~44ms last segment) starts right at the buffered end, and the
+ * browser freezes the playhead ~50–70ms short of that end (its render horizon), so a
+ * strict `currentTime >= lastSegStart` would never open — deadlocking `endOfStream`
+ * (the MediaSource stays `'open'`, so the browser keeps the playhead frozen waiting for
+ * data/EOS that never comes). This slack lets a playhead stalled just short of the final
+ * segment still finalize. Firing slightly early is harmless: the last segment is already
+ * appended (the gate above), so no more data is expected.
+ */
+const LAST_SEGMENT_REACHED_SLACK = 0.5;
+
 function deriveState(
   presentation: MaybeResolvedPresentation | undefined,
   mediaSource: MediaSource | undefined,
@@ -152,7 +165,8 @@ function deriveState(
     }
   }
 
-  if (lastSegStart !== undefined && (currentTime ?? 0) < lastSegStart) {
+  // Slack absorbs the near-end playhead freeze so a tiny final segment doesn't deadlock.
+  if (lastSegStart !== undefined && (currentTime ?? 0) < lastSegStart - LAST_SEGMENT_REACHED_SLACK) {
     return 'preconditions-unmet';
   }
 
diff --git a/packages/spf/src/playback/behaviors/dom/recover-end-stall.ts b/packages/spf/src/playback/behaviors/dom/recover-end-stall.ts
new file mode 100644
index 00000000..d3890976
--- /dev/null
+++ b/packages/spf/src/playback/behaviors/dom/recover-end-stall.ts
@@ -0,0 +1,123 @@
+/**
+ * Recover the end-of-stream stall that Chrome exhibits on skewed A/V. After
+ * `endOfStream`, when the audio and video tracks end a few ms apart (e.g. a source
+ * with an A/V PTS skew), Chrome's audio-clock-paced playback freezes the playhead
+ * ~50–70ms short of the reachable buffered end and never fires `ended` — so playback
+ * hangs at the very end and loop never re-triggers. This behavior watches for the
+ * `waiting` event that fires at that freeze and, when the MediaSource is `ended` and
+ * the playhead sits at the reachable buffered end, nudges `currentTime` to `duration`
+ * to force the native `ended`.
+ *
+ * **Event-driven, no poll.** `waiting` fires at the instant the playhead stalls
+ * (measured ~0ms latency), so there's nothing to gain from polling — and polling would
+ * add its interval + a stall threshold before reacting.
+ *
+ * **Proximity to the *reachable* buffered end** is the discriminator. That end is
+ * `getMinBufferedEnd(mediaSource.sourceBuffers)` — the `min` of the per-track (video/audio)
+ * SourceBuffer ends, i.e. the furthest point playback can reach — read from the SourceBuffers
+ * directly rather than the `mediaElement.buffered` aggregate. Once `endOfStream` is signalled
+ * that's the true content end. Requiring the playhead within `endStallNudgeWindow` of it
+ * distinguishes the real end-of-stream freeze from a mid-stream buffer-hole stall (which sits
+ * far from the buffered end), so we never skip content. The window must exceed the freeze gap;
+ * too small would miss the stall (a permanent hang), so the default is generous relative to the
+ * measured gap and is config-tunable for empirical tuning.
+ *
+ * Inert where it shouldn't act: live (the MediaSource never reaches `ended` while the
+ * window grows; `duration` is `Infinity`) and streams that end cleanly (no `waiting`).
+ *
+ * See `internal/decisions/end-of-stream-av-skew-recovery.md`.
+ */
+import { listen } from '@videojs/utils/dom';
+import { defineBehavior } from '../../../core/composition/create-composition';
+import { effect } from '../../../core/signals/effect';
+import type { ReadonlySignal } from '../../../core/signals/primitives';
+import { getMinBufferedEnd } from '../../../media/dom/mse/duration';
+
+export interface RecoverEndStallContext {
+  mediaElement?: HTMLMediaElement | undefined;
+  mediaSource?: MediaSource | undefined;
+}
+
+export interface RecoverEndStallConfig {
+  /**
+   * How close (seconds) the playhead must be to the reachable buffered end for a
+   * `waiting` to count as the end-of-stream freeze. Must exceed the audio-clock freeze
+   * gap (~50–70ms measured on Chrome); too small risks missing the stall (a permanent
+   * hang), so keep a margin. Default {@link DEFAULT_END_STALL_NUDGE_WINDOW}.
+   */
+  endStallNudgeWindow?: number;
+}
+
+/** ~2.8× the measured max freeze gap (71ms) — tight, but with headroom against a miss. */
+export const DEFAULT_END_STALL_NUDGE_WINDOW = 0.2;
+
+/**
+ * Whether a `waiting` should be forced to `ended`: the MediaSource is `ended`, the
+ * stream is finite (not live), playback is active (not paused/seeking/already-ended),
+ * and the playhead sits within `nudgeWindow` of the reachable buffered end (so it's the
+ * true end, not a mid-stream buffer hole). Pure — the behavior supplies the live values.
+ */
+export function shouldForceEnded(
+  input: {
+    msEnded: boolean;
+    durationFinite: boolean;
+    paused: boolean;
+    seeking: boolean;
+    ended: boolean;
+    currentTime: number;
+    bufferedEnd: number | undefined;
+  },
+  nudgeWindow: number
+): boolean {
+  const { msEnded, durationFinite, paused, seeking, ended, currentTime, bufferedEnd } = input;
+  if (!msEnded || !durationFinite || paused || seeking || ended || bufferedEnd === undefined) {
+    return false;
+  }
+  const gap = bufferedEnd - currentTime;
+  return gap >= 0 && gap < nudgeWindow;
+}
+
+function recoverEndStallSetup({
+  context,
+  config,
+}: {
+  context: {
+    mediaElement: ReadonlySignal<RecoverEndStallContext['mediaElement']>;
+    mediaSource: ReadonlySignal<RecoverEndStallContext['mediaSource']>;
+  };
+  config?: RecoverEndStallConfig;
+}): () => void {
+  const nudgeWindow = config?.endStallNudgeWindow ?? DEFAULT_END_STALL_NUDGE_WINDOW;
+
+  return effect(() => {
+    const mediaElement = context.mediaElement.get();
+    if (!mediaElement) return;
+
+    const onWaiting = () => {
+      const mediaSource = context.mediaSource.get();
+      const forceEnded = shouldForceEnded(
+        {
+          msEnded: mediaSource?.readyState === 'ended',
+          durationFinite: Number.isFinite(mediaElement.duration),
+          paused: mediaElement.paused,
+          seeking: mediaElement.seeking,
+          ended: mediaElement.ended,
+          currentTime: mediaElement.currentTime,
+          bufferedEnd: mediaSource ? getMinBufferedEnd(mediaSource.sourceBuffers) : undefined,
+        },
+        nudgeWindow
+      );
+      // Nudge to `duration` → native `ended` (the seeking/ended guards above prevent a
+      // re-fire while the nudge-seek is in flight, so no latch is needed).
+      if (forceEnded) mediaElement.currentTime = mediaElement.duration;
+    };
+
+    return listen(mediaElement, 'waiting', onWaiting);
+  });
+}
+
+export const recoverEndStall = defineBehavior({
+  stateKeys: [] as const,
+  contextKeys: ['mediaElement', 'mediaSource'] as const,
+  setup: recoverEndStallSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/setup-buffer-actors.ts b/packages/spf/src/playback/behaviors/dom/setup-buffer-actors.ts
index c536d318..054aac42 100644
--- a/packages/spf/src/playback/behaviors/dom/setup-buffer-actors.ts
+++ b/packages/spf/src/playback/behaviors/dom/setup-buffer-actors.ts
@@ -77,6 +77,7 @@ import {
 } from '../../actors/dom/segment-loader';
 import { createSourceBufferActor, type SourceBufferActor } from '../../actors/dom/source-buffer';
 import { failoverFetch } from '../../primitives/failover-fetch';
+import type { MessagePipelines } from '../../primitives/segment-load-pipeline';
 import { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../../primitives/track-types';
 
 /**
@@ -146,7 +147,7 @@ function setupBufferActors<K extends SelectedTrackKey, A extends BufferActorKey,
     fetch: FetchBytes;
   } & SegmentLoaderActorConfig;
 }): Reactor<BufferActorsFsmState | 'destroying' | 'destroyed'> {
-  const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer } = config;
+  const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer, messagePipelines } = config;
   const derivedStateSignal = computed<BufferActorsFsmState>(() => {
     if (!context.mediaSource.get()) return 'preconditions-unmet';
     const selection: TrackSelectionState = {
@@ -172,7 +173,14 @@ function setupBufferActors<K extends SelectedTrackKey, A extends BufferActorKey,
           const track = getSelectedTrack(selection, type) as PartiallyResolvedTrack;
           const buffer = createSourceBuffer(mediaSource, buildMimeCodec(track));
           const bufferActor = createSourceBufferActor(buffer);
-          const segmentLoader = createSegmentLoaderActor(bufferActor, fetch, { forwardBuffer, backBuffer });
+          const segmentLoader = createSegmentLoaderActor(
+            bufferActor,
+            fetch,
+            { forwardBuffer, backBuffer, messagePipelines },
+            // Thread the composition deps opaquely to steps (relocation reads
+            // `state.mediaContainerData`); the loader/this behavior never read them.
+            { state, context, config }
+          );
 
           // Synchronous slot writes — load-bearing for the Firefox
           // `mozHasAudio` invariant (see file-level JSDoc). Both per-type
@@ -223,7 +231,11 @@ export const setupVideoBufferActors = defineBehavior({
       bandwidthState: Signal<BufferActorsState['bandwidthState']>;
     };
     context: BufferActorsContextMap<'videoBufferActor', 'videoSegmentLoaderActor'>;
-    config?: SegmentLoaderActorConfig & { getCdnId?: GetCdnId };
+    config?: SegmentLoaderActorConfig & {
+      getCdnId?: GetCdnId;
+      /** Optional non-zero-PTS relocation pipelines (Tier-1); the loader uses its Tier-0 default when absent. */
+      videoMessagePipelines?: MessagePipelines;
+    };
   }) => {
     // Bandwidth-sampling fetch. The factory accumulates EWMA state
     // internally; the callback bridges samples to engine state for ABR.
@@ -246,7 +258,11 @@ export const setupVideoBufferActors = defineBehavior({
     return setupBufferActors({
       state,
       context,
-      config: { ...typeConfig, fetch: failoverFetch(trackedFetch, state, typeConfig) },
+      config: {
+        ...typeConfig,
+        messagePipelines: config.videoMessagePipelines,
+        fetch: failoverFetch(trackedFetch, state, typeConfig),
+      },
     });
   },
 });
@@ -279,14 +295,22 @@ export const setupAudioBufferActors = defineBehavior({
   }: {
     state: BufferActorsStateMap<'selectedAudioTrackId'>;
     context: BufferActorsContextMap<'audioBufferActor', 'audioSegmentLoaderActor'>;
-    config?: SegmentLoaderActorConfig & { getCdnId?: GetCdnId };
+    config?: SegmentLoaderActorConfig & {
+      getCdnId?: GetCdnId;
+      /** Optional non-zero-PTS relocation pipelines (Tier-1); the loader uses its Tier-0 default when absent. */
+      audioMessagePipelines?: MessagePipelines;
+    };
   }) => {
     // Key order mirrors setupVideoBufferActors.
     const typeConfig = { ...AUDIO_TYPE_CONFIG, ...config };
     return setupBufferActors({
       state,
       context,
-      config: { ...typeConfig, fetch: failoverFetch(fetchStream, state, typeConfig) },
+      config: {
+        ...typeConfig,
+        messagePipelines: config.audioMessagePipelines,
+        fetch: failoverFetch(fetchStream, state, typeConfig),
+      },
     });
   },
 });
diff --git a/packages/spf/src/playback/behaviors/dom/setup-text-track-actors.ts b/packages/spf/src/playback/behaviors/dom/setup-text-track-actors.ts
index b56c1ed2..591f9267 100644
--- a/packages/spf/src/playback/behaviors/dom/setup-text-track-actors.ts
+++ b/packages/spf/src/playback/behaviors/dom/setup-text-track-actors.ts
@@ -18,7 +18,7 @@
  * `config` so this behavior owns the DOM-bound part of the text-track
  * pipeline.
  */
-import { defineBehavior } from '../../../core/composition/create-composition';
+import type { AnySlotMap, Behavior } from '../../../core/composition/create-composition';
 import { effect } from '../../../core/signals/effect';
 import type { ReadonlySignal, Signal } from '../../../core/signals/primitives';
 import { createTextTracksActor } from '../../actors/dom/text-tracks';
@@ -26,9 +26,9 @@ import {
   createTextTrackSegmentLoaderActor,
   type TextTrackSegmentLoaderActor,
   type TextTrackSegmentLoaderActorConfig,
-  type TextTrackSegmentResolver,
 } from '../../actors/text-track-segment-loader';
 import type { TextTracksActor } from '../../actors/text-tracks';
+import type { TextMessagePipelines, TextTrackSegmentResolver } from '../../primitives/text-segment-load-pipeline';
 
 export interface TextTrackActorsContext {
   mediaElement?: HTMLMediaElement | undefined;
@@ -36,14 +36,24 @@ export interface TextTrackActorsContext {
   textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;
 }
 
-export interface TextTrackActorsConfig extends TextTrackSegmentLoaderActorConfig {
+export interface TextTrackActorsConfig extends Pick<TextTrackSegmentLoaderActorConfig<VTTCue>, 'forwardBuffer'> {
   resolveTextTrackSegment: TextTrackSegmentResolver<VTTCue>;
+  /**
+   * Ordered text step pipeline, mapped to the loader's `messagePipelines`. Named
+   * with the `text` domain prefix to mirror the v/a `video`/`audioMessagePipelines`
+   * composition-config slots. Defaults (in the loader) to `resolveCues → dispatchCues`.
+   */
+  textMessagePipelines?: TextMessagePipelines<VTTCue>;
 }
 
 function setupTextTrackActorsSetup({
+  state,
   context,
   config,
 }: {
+  // Forwarded opaquely into the loader's steps (relocation reads composition state);
+  // this behavior owns no state of its own (stateKeys: []).
+  state: AnySlotMap;
   context: {
     mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;
     textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;
@@ -59,7 +69,9 @@ function setupTextTrackActorsSetup({
     const textTrackSegmentLoaderActor = createTextTrackSegmentLoaderActor(
       textTracksActor,
       config.resolveTextTrackSegment,
-      { forwardBuffer: config.forwardBuffer }
+      { forwardBuffer: config.forwardBuffer, messagePipelines: config.textMessagePipelines },
+      // Composition deps forwarded into each step (relocation reads the primary A/V origin).
+      { state, context, config }
     );
     context.textTracksActor.set(textTracksActor);
     context.textTrackSegmentLoaderActor.set(textTrackSegmentLoaderActor);
@@ -73,8 +85,20 @@ function setupTextTrackActorsSetup({
   });
 }
 
-export const setupTextTrackActors = defineBehavior({
+// Manual `Behavior` literal (like `end-of-stream`): no state of its own
+// (`stateKeys: []`), but the setup forwards the composition `state` to the resolver
+// opaquely. A literal (not `defineBehavior`) so `stateKeys: []` can coexist with a
+// setup that reads `state`.
+export const setupTextTrackActors: Behavior<
+  Record<never, never>,
+  {
+    mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;
+    textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;
+    textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;
+  },
+  TextTrackActorsConfig
+> = {
   stateKeys: [],
   contextKeys: ['mediaElement', 'textTracksActor', 'textTrackSegmentLoaderActor'],
   setup: setupTextTrackActorsSetup,
-});
+};
diff --git a/packages/spf/src/playback/behaviors/dom/tests/load-segments-track-switch.test.ts b/packages/spf/src/playback/behaviors/dom/tests/load-segments-track-switch.test.ts
index bfd14064..24b50520 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/load-segments-track-switch.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/load-segments-track-switch.test.ts
@@ -143,12 +143,16 @@ describe('loadSegments — track switch', () => {
     vi.clearAllMocks();
   });
 
-  it('does not flush SourceBuffer on track switch; new content overwrites old via deduplication', async () => {
+  it('does not flush or refetch already-buffered aligned positions on ABR switch', async () => {
     const { flushBuffer } = await import('../../../../media/dom/mse/buffer-flusher');
     const flushSpy = vi.mocked(flushBuffer);
 
-    const trackA = makeResolvedVideoTrack('track-a', [seg('a1', 0), seg('a2', 10)]);
-    const trackB = makeResolvedVideoTrack('track-b', [seg('b1', 0), seg('b2', 10)]);
+    // Real renditions number segments positionally per playlist (`segment-N`), so
+    // an ABR pair shares ids on an aligned grid. Switching quality when the forward
+    // buffer is already full at those positions should NOT re-download them (the
+    // content is identical; only the encode quality differs) — and must never flush.
+    const trackA = makeResolvedVideoTrack('track-a', [seg('segment-0', 0), seg('segment-1', 10)]);
+    const trackB = makeResolvedVideoTrack('track-b', [seg('segment-0', 0), seg('segment-1', 10)]);
     const presentation = makePresentation(trackA, trackB);
 
     const videoBuffer = makeMockSourceBuffer();
@@ -156,12 +160,19 @@ describe('loadSegments — track switch', () => {
     const videoBufferActor = createSourceBufferActor(videoBuffer, {
       initTrackId: 'track-a',
       segments: [
-        { id: 'a1', startTime: 0, duration: 10, trackId: 'track-a' },
-        { id: 'a2', startTime: 10, duration: 10, trackId: 'track-a' },
+        { id: 'segment-0', startTime: 0, duration: 10, trackId: 'track-a' },
+        { id: 'segment-1', startTime: 10, duration: 10, trackId: 'track-a' },
       ],
     });
     const videoLoader = createSegmentLoaderActor(videoBufferActor, fetchStream);
 
+    const fetchedUrls: string[] = [];
+    globalThis.fetch = vi.fn().mockImplementation((input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input instanceof URL ? input.href : (input as Request).url;
+      fetchedUrls.push(url);
+      return Promise.resolve(new Response(new ArrayBuffer(100), { status: 200 }));
+    });
+
     const state = makeState({
       presentation,
       selectedVideoTrackId: 'track-a',
@@ -175,21 +186,218 @@ describe('loadSegments — track switch', () => {
     const reactor = loadVideoSegments.setup({ state, context });
 
     await new Promise((r) => setTimeout(r, 20));
+    fetchedUrls.length = 0;
 
     state.selectedVideoTrackId.set('track-b');
 
     await new Promise((r) => setTimeout(r, 50));
 
+    // Never a full flush on an ABR switch.
     expect(flushSpy).not.toHaveBeenCalledWith(videoBuffer, 0, Infinity);
 
     const ctx = videoBufferActor.snapshot.get().context;
+    // Init switches to the new rendition...
     expect(ctx?.initTrackId).toBe('track-b');
+    expect(fetchedUrls).toContain('https://example.com/track-b-init.mp4');
+    // ...but the already-buffered, time-aligned positions are retained, not refetched.
+    expect(fetchedUrls.some((u) => u.endsWith('.m4s'))).toBe(false);
+    expect(ctx?.segments.map((s) => s.startTime).sort((a, b) => a - b)).toEqual([0, 10]);
 
-    const hasOldSegments = ctx?.segments.some((s) => ['a1', 'a2'].includes(s.id));
-    expect(hasOldSegments).toBeFalsy();
+    reactor.destroy();
+    videoLoader.destroy();
+  });
 
-    const hasNewSegments = ctx?.segments.some((s) => ['b1', 'b2'].includes(s.id));
-    expect(hasNewSegments).toBeTruthy();
+  it('loads the bridging segment when switching to a misaligned rendition (no gap)', async () => {
+    // Cross-rendition grid misalignment: a 30fps rung cuts its first GOP at 7.13333s,
+    // a 60fps rung at 7.98333s, so their `segment-1`s span different time ranges while
+    // sharing the positional id. Buffer holds LOW's segment-0/1 (covers 0..15.13333);
+    // switching to HIGH must fetch HIGH's segment-1 (7.98333..15.98333) to cover the
+    // 15.13333..15.98333 tail — matching by id alone would skip it and leave a gap.
+    const posSeg = (trackId: string, index: number, startTime: number, duration: number) => ({
+      id: `segment-${index}`,
+      url: `https://example.com/${trackId}/segment-${index}.m4s`,
+      startTime,
+      duration,
+    });
+    const low = {
+      ...makeResolvedVideoTrack('low', []),
+      segments: [posSeg('low', 0, 0, 7.13333), posSeg('low', 1, 7.13333, 8)],
+    };
+    const high = {
+      ...makeResolvedVideoTrack('high', []),
+      segments: [posSeg('high', 0, 0, 7.98333), posSeg('high', 1, 7.98333, 8), posSeg('high', 2, 15.98333, 8)],
+    };
+    const presentation = makePresentation(low, high);
+
+    const videoBuffer = makeMockSourceBuffer();
+    const videoBufferActor = createSourceBufferActor(videoBuffer, {
+      initTrackId: 'low',
+      segments: [
+        { id: 'segment-0', startTime: 0, duration: 7.13333, trackId: 'low' },
+        { id: 'segment-1', startTime: 7.13333, duration: 8, trackId: 'low' },
+      ],
+    });
+    const videoLoader = createSegmentLoaderActor(videoBufferActor, fetchStream);
+
+    const fetchedUrls: string[] = [];
+    globalThis.fetch = vi.fn().mockImplementation((input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input instanceof URL ? input.href : (input as Request).url;
+      fetchedUrls.push(url);
+      return Promise.resolve(new Response(new ArrayBuffer(100), { status: 200 }));
+    });
+
+    const state = makeState({
+      presentation,
+      selectedVideoTrackId: 'low',
+      preload: 'auto',
+      loadActivated: true,
+      currentTime: 5,
+    });
+    const context = makeContext({ videoBufferActor, videoSegmentLoaderActor: videoLoader });
+    const reactor = loadVideoSegments.setup({ state, context });
+
+    await new Promise((r) => setTimeout(r, 20));
+    fetchedUrls.length = 0;
+
+    state.selectedVideoTrackId.set('high');
+
+    await vi.waitFor(() => expect(fetchedUrls).toContain('https://example.com/high/segment-1.m4s'), { timeout: 3000 });
+    // The tail segment loads too; the fully-covered leading segment-0 is not refetched.
+    expect(fetchedUrls).toContain('https://example.com/high/segment-2.m4s');
+    expect(fetchedUrls).not.toContain('https://example.com/high/segment-0.m4s');
+
+    reactor.destroy();
+    videoLoader.destroy();
+  });
+
+  it('loads the leading bridge segment on a shallow-buffer misaligned switch (no gap)', async () => {
+    // Regression for a Firefox stall: ABR upshifts to a misaligned rung while
+    // only the LOW rung's segment-0 ([0, 7.13333]) is buffered. HIGH's
+    // segment-0 spans [0, 7.98333]; its [7.13333, 7.98333] tail is the gap.
+    // Because it reuses the positional id `segment-0`, an id match would treat
+    // it as already buffered and skip it, leaving the tail as a SourceBuffer
+    // gap that Firefox won't jump. Time-coverage must see it uncovered and
+    // fetch the leading segment — distinct from the deep-buffer case above,
+    // where segment-0 is legitimately covered and correctly NOT refetched.
+    const posSeg = (trackId: string, index: number, startTime: number, duration: number) => ({
+      id: `segment-${index}`,
+      url: `https://example.com/${trackId}/segment-${index}.m4s`,
+      startTime,
+      duration,
+    });
+    // LOW has only segment-0 so the warmup can't deepen the buffer past it —
+    // the switch fires while ONLY [0, 7.13333] is buffered (the observed
+    // Firefox state: LOW segment-0, no LOW segment-1).
+    const low = {
+      ...makeResolvedVideoTrack('low', []),
+      segments: [posSeg('low', 0, 0, 7.13333)],
+    };
+    const high = {
+      ...makeResolvedVideoTrack('high', []),
+      segments: [posSeg('high', 0, 0, 7.98333), posSeg('high', 1, 7.98333, 8), posSeg('high', 2, 15.98333, 8)],
+    };
+    const presentation = makePresentation(low, high);
+
+    const videoBuffer = makeMockSourceBuffer();
+    const videoBufferActor = createSourceBufferActor(videoBuffer, {
+      initTrackId: 'low',
+      // Shallow: only the first LOW segment is buffered when the switch fires.
+      segments: [{ id: 'segment-0', startTime: 0, duration: 7.13333, trackId: 'low' }],
+    });
+    const videoLoader = createSegmentLoaderActor(videoBufferActor, fetchStream);
+
+    const fetchedUrls: string[] = [];
+    globalThis.fetch = vi.fn().mockImplementation((input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input instanceof URL ? input.href : (input as Request).url;
+      fetchedUrls.push(url);
+      return Promise.resolve(new Response(new ArrayBuffer(100), { status: 200 }));
+    });
+
+    const state = makeState({
+      presentation,
+      selectedVideoTrackId: 'low',
+      preload: 'auto',
+      loadActivated: true,
+      currentTime: 5,
+    });
+    const context = makeContext({ videoBufferActor, videoSegmentLoaderActor: videoLoader });
+    const reactor = loadVideoSegments.setup({ state, context });
+
+    await new Promise((r) => setTimeout(r, 20));
+    fetchedUrls.length = 0;
+
+    state.selectedVideoTrackId.set('high');
+
+    // The leading bridge segment MUST load — its [7.13333, 7.98333] tail is the gap.
+    await vi.waitFor(() => expect(fetchedUrls).toContain('https://example.com/high/segment-0.m4s'), { timeout: 3000 });
+
+    reactor.destroy();
+    videoLoader.destroy();
+  });
+
+  it('loads HIGH bridge when the switch preempts an in-flight same-id LOW segment (misaligned)', async () => {
+    // Root cause of the intermittent Firefox stall. Renditions share positional
+    // ids (`segment-0`). If ABR switches LOW->HIGH while LOW's segment-0 is still
+    // IN-FLIGHT (not yet appended), `inFlightStillNeeded` matches HIGH's needed
+    // segment-0 against the in-flight LOW segment-0 BY ID, keeps the LOW fetch,
+    // and skips scheduling HIGH's segment-0. LOW seg-0 ([0, 7.13333]) then
+    // appends and HIGH seg-1+ ([7.98333, ...]) append, leaving the
+    // [7.13333, 7.98333] gap. Intermittent because it only triggers when the
+    // switch beats LOW segment-0's append.
+    const posSeg = (trackId: string, index: number, startTime: number, duration: number) => ({
+      id: `segment-${index}`,
+      url: `https://example.com/${trackId}/segment-${index}.m4s`,
+      startTime,
+      duration,
+    });
+    const low = {
+      ...makeResolvedVideoTrack('low', []),
+      bandwidth: 582820,
+      segments: [posSeg('low', 0, 0, 7.13333), posSeg('low', 1, 7.13333, 8)],
+    };
+    const high = {
+      ...makeResolvedVideoTrack('high', []),
+      bandwidth: 9873268,
+      segments: [posSeg('high', 0, 0, 7.98333), posSeg('high', 1, 7.98333, 8), posSeg('high', 2, 15.98333, 8)],
+    };
+    const presentation = makePresentation(low, high);
+
+    const videoBuffer = makeMockSourceBuffer();
+    // initTrackId 'low' committed, nothing appended yet — LOW segment-0 will be
+    // the first in-flight fetch.
+    const videoBufferActor = createSourceBufferActor(videoBuffer, { initTrackId: 'low', segments: [] });
+    const videoLoader = createSegmentLoaderActor(videoBufferActor, fetchStream);
+
+    const { fetch, fetchedUrls, resolveAll } = makeControllableFetch();
+    globalThis.fetch = fetch;
+
+    const state = makeState({
+      presentation,
+      selectedVideoTrackId: 'low',
+      preload: 'auto',
+      loadActivated: true,
+      currentTime: 0,
+    });
+    const context = makeContext({ videoBufferActor, videoSegmentLoaderActor: videoLoader });
+    const reactor = loadVideoSegments.setup({ state, context });
+
+    // LOW segment-0 goes in-flight (fetch hangs, unresolved).
+    await vi.waitFor(() => expect(fetchedUrls).toContain('https://example.com/low/segment-0.m4s'), { timeout: 3000 });
+
+    // Switch while LOW segment-0 is still in-flight (not appended).
+    state.selectedVideoTrackId.set('high');
+    await new Promise((r) => setTimeout(r, 30));
+
+    // Drain: resolve in-flight + newly-scheduled fetches until settled.
+    for (let i = 0; i < 5; i++) {
+      resolveAll();
+      await new Promise((r) => setTimeout(r, 20));
+    }
+
+    // The HIGH bridge segment-0 MUST be fetched — its [7.13333, 7.98333] tail
+    // is the gap. On the buggy code it is skipped (id collision with the
+    // in-flight LOW segment-0).
+    expect(fetchedUrls).toContain('https://example.com/high/segment-0.m4s');
 
     reactor.destroy();
     videoLoader.destroy();
diff --git a/packages/spf/src/playback/behaviors/dom/tests/load-text-track-segments.test.ts b/packages/spf/src/playback/behaviors/dom/tests/load-text-track-segments.test.ts
index 93e2c194..b2b7a755 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/load-text-track-segments.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/load-text-track-segments.test.ts
@@ -112,7 +112,11 @@ function setupLoadTextTrackCues(initialState: TextTrackSegmentLoadingState, init
   // targeting dormant / activation behavior override this explicitly.
   const state = makeState({ preload: 'auto', ...initialState });
   const context = makeContext(initialContext);
-  const setupCleanup = setupTextTrackActors.setup({ context, config: { resolveTextTrackSegment: resolveVttSegment } });
+  const setupCleanup = setupTextTrackActors.setup({
+    state,
+    context,
+    config: { resolveTextTrackSegment: resolveVttSegment },
+  }) as () => void;
   const reactor = loadTextTrackSegments.setup({ state, context });
   const cleanup = () => {
     reactor.destroy();
diff --git a/packages/spf/src/playback/behaviors/dom/tests/recover-end-stall.test.ts b/packages/spf/src/playback/behaviors/dom/tests/recover-end-stall.test.ts
new file mode 100644
index 00000000..474b335e
--- /dev/null
+++ b/packages/spf/src/playback/behaviors/dom/tests/recover-end-stall.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { shouldForceEnded } from '../recover-end-stall';
+
+// At the end-of-stream freeze: MediaSource ended, finite duration, actively playing,
+// and the playhead a few frames short of the reachable (intersection) buffered end.
+const atEndStall = {
+  msEnded: true,
+  durationFinite: true,
+  paused: false,
+  seeking: false,
+  ended: false,
+  currentTime: 599.95,
+  bufferedEnd: 600.0,
+} as const;
+
+const WINDOW = 0.2;
+
+describe('shouldForceEnded', () => {
+  it('fires at the end-of-stream freeze (playhead within the window of the buffered end)', () => {
+    expect(shouldForceEnded(atEndStall, WINDOW)).toBe(true); // gap 0.05 < 0.2
+  });
+
+  it('does not fire mid-content (playhead far from the buffered end)', () => {
+    expect(shouldForceEnded({ ...atEndStall, currentTime: 300, bufferedEnd: 600 }, WINDOW)).toBe(false);
+  });
+
+  it('does not fire until endOfStream is signalled', () => {
+    expect(shouldForceEnded({ ...atEndStall, msEnded: false }, WINDOW)).toBe(false);
+  });
+
+  it('does not fire for live (non-finite duration)', () => {
+    expect(shouldForceEnded({ ...atEndStall, durationFinite: false }, WINDOW)).toBe(false);
+  });
+
+  it('does not fire while paused, seeking, or already ended', () => {
+    expect(shouldForceEnded({ ...atEndStall, paused: true }, WINDOW)).toBe(false);
+    expect(shouldForceEnded({ ...atEndStall, seeking: true }, WINDOW)).toBe(false);
+    expect(shouldForceEnded({ ...atEndStall, ended: true }, WINDOW)).toBe(false);
+  });
+
+  it('does not fire with no buffered ranges', () => {
+    expect(shouldForceEnded({ ...atEndStall, bufferedEnd: undefined }, WINDOW)).toBe(false);
+  });
+
+  it('respects the configured window', () => {
+    const gap015 = { ...atEndStall, currentTime: 599.85, bufferedEnd: 600.0 }; // gap 0.15
+    expect(shouldForceEnded(gap015, 0.2)).toBe(true);
+    expect(shouldForceEnded(gap015, 0.1)).toBe(false);
+  });
+});
diff --git a/packages/spf/src/playback/behaviors/establish-start-media-time.ts b/packages/spf/src/playback/behaviors/establish-start-media-time.ts
new file mode 100644
index 00000000..763efc3f
--- /dev/null
+++ b/packages/spf/src/playback/behaviors/establish-start-media-time.ts
@@ -0,0 +1,233 @@
+/**
+ * Establish each track's `startMediaTime` (its media-timeline origin) once per
+ * source, so a non-zero-PTS source relocates onto a 0-based presentation timeline.
+ * The VOD sibling of `anchor-presentation-timeline`: both are per-source
+ * establishment units that write a coordinate base value onto every track (the
+ * anchor writes `startDate`/`startTime` from wall clock; this writes
+ * `startMediaTime` from the container's decode-time origin).
+ *
+ * This is the **DOM-free reactor half**: it owns the transient `mediaContainerData`
+ * slot lifecycle (`inactive` clears it per source), runs the injected
+ * {@link DeriveStartMediaTime} seam over it in `monitoring`, and stamps the settled
+ * `startMediaTime` onto the model — the coordinate *consume* — until `established`.
+ * The byte-level discover/stamp steps that fill the slot are a separate,
+ * config `messagePipelines` array (`primitives/relocation-pipelines`);
+ * the two coordinate only through the shared `state.mediaContainerData` slot, never
+ * by import. See `internal/design/spf/presentation-timeline-model.md`.
+ */
+import type { Behavior } from '../../core/composition/create-composition';
+import { createMachineReactor, type Reactor } from '../../core/reactors/create-machine-reactor';
+import { type ReadonlySignal, type Signal, update } from '../../core/signals/primitives';
+import {
+  isResolvedPresentation,
+  type MaybeResolvedPresentation,
+  type MediaContainerData,
+  type Presentation,
+} from '../../media/types';
+import { findTrackById } from '../../media/utils/tracks';
+import type { DeriveStartMediaTime, DeriveStartMediaTimeContext } from '../primitives/derive-start-media-time';
+
+export type { DeriveStartMediaTime, DeriveStartMediaTimeContext };
+
+// ============================================================================
+// STATE / CONFIG
+// ============================================================================
+
+export interface EstablishStartMediaTimeState {
+  presentation?: MaybeResolvedPresentation;
+  /**
+   * Transient origin-establishment data, keyed by **track type** (`'video'` /
+   * `'audio'`) — per spec one init+media pair per type suffices, and ABR rungs of
+   * a type share the origin. Filled by the discover steps across appends, reset
+   * per source. Never the model — the churn stays here; only the settled
+   * `startMediaTime` reaches `Track`.
+   */
+  mediaContainerData?: Record<string, MediaContainerData>;
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+}
+
+/**
+ * A single type's own media-timeline origin:
+ * `baseMediaDecodeTime/timescale − segmentStartTime` (the `segmentStartTime` term
+ * makes it the stream origin even when the first loaded segment isn't the 0th).
+ * `undefined` until timescale + baseMediaDecodeTime + segmentStartTime are all present.
+ */
+function ownOrigin(data: MediaContainerData | undefined): number | undefined {
+  const { timescale, baseMediaDecodeTime, segmentStartTime } = data ?? {};
+  return timescale != null && baseMediaDecodeTime != null && segmentStartTime != null
+    ? baseMediaDecodeTime / timescale - segmentStartTime
+    : undefined;
+}
+
+/**
+ * Origins below this magnitude (seconds) are treated as `0` — the derive returns `0`, so
+ * the presentation is left on its native (~0-based) timeline and no `timestampOffset` is
+ * set (the loader stamp no-ops on a derived `0`). Ordinary VOD carries a small nonzero
+ * encode origin (audio priming, first-frame CTS, edit lists); relocating by a sub-second
+ * amount is pointless, and setting `timestampOffset` at all can ripple edge segments.
+ * Relocation targets streams with an intentional large origin (instant clips, bipbop @10s).
+ *
+ * Absolute basis, not proportional: the DTS-below-zero / ripple risk scales with the
+ * origin's absolute size, not with the presentation's duration. Also snaps negatives to
+ * `0` — a negative origin would relocate *forward*, which is never the intent.
+ */
+export const NEAR_ZERO_ORIGIN_THRESHOLD = 1;
+
+/** Snap a below-threshold (incl. negative) origin to `0` so it isn't relocated. */
+function thresholdOrigin(origin: number): number {
+  return origin < NEAR_ZERO_ORIGIN_THRESHOLD ? 0 : origin;
+}
+
+/**
+ * The **default** — relocate the whole presentation by one shared origin: the `min`
+ * across the *selected* A/V tracks' own origins, denormalized onto every type. This
+ * single reduce subsumes the "per-type" and "shared" tiers:
+ * - **aligned A/V** — `min` equals each origin (they're equal), so it matches per-type;
+ * - **skewed A/V** (e.g. Apple's 44ms audio-lead) — `min` keeps every track's earliest
+ *   DTS ≥ 0 (relocating by ≤ each own origin never drives one negative) *and* preserves
+ *   the real skew (per-type would flatten it, desyncing A/V);
+ * - **single type / muxed** — `min` of the one origin is that origin.
+ *
+ * Returns `undefined` for every type until all *selected* types have a complete origin
+ * (the shared-`min` barrier). Which types must contribute is read from `ctx` (the
+ * selected v/a ids); with no selection context it coordinates across whatever types
+ * have data. A shared origin below {@link NEAR_ZERO_ORIGIN_THRESHOLD} is returned as `0`
+ * (native — ordinary ~0-PTS VOD isn't relocated).
+ */
+export const deriveSharedMinStartMediaTime: DeriveStartMediaTime = (containerData, ctx) => {
+  const contributingTypes: string[] = [];
+  if (ctx.selectedVideoTrackId != null) contributingTypes.push('video');
+  if (ctx.selectedAudioTrackId != null) contributingTypes.push('audio');
+  const types = contributingTypes.length > 0 ? contributingTypes : Object.keys(containerData);
+
+  const origins = types.map((type) => ownOrigin(containerData[type]));
+  // Barrier: not ready until every contributing type has a complete origin.
+  if (origins.length === 0 || origins.some((origin) => origin === undefined)) return {};
+
+  const shared = thresholdOrigin(Math.min(...(origins as number[])));
+  const out: Record<string, number | undefined> = {};
+  for (const type of Object.keys(containerData)) out[type] = shared;
+  return out;
+};
+
+/**
+ * Coordination-axis *off* — each type relocates by its own origin, independently. Not
+ * the default: it flattens real A/V skew (see {@link deriveSharedMinStartMediaTime}).
+ * Kept as an opt-in for compositions that know their A/V is aligned and want to skip
+ * the shared-`min` barrier (each type stamps as soon as its own origin is discovered).
+ */
+export const derivePerTypeStartMediaTime: DeriveStartMediaTime = (containerData) => {
+  const out: Record<string, number | undefined> = {};
+  for (const [type, data] of Object.entries(containerData)) {
+    const origin = ownOrigin(data);
+    out[type] = origin === undefined ? undefined : thresholdOrigin(origin);
+  }
+  return out;
+};
+
+export interface EstablishStartMediaTimeConfig {
+  /** The reduce seam (coordination knob). Defaults to {@link deriveSharedMinStartMediaTime}. */
+  deriveStartMediaTime?: DeriveStartMediaTime;
+}
+
+// ============================================================================
+// REACTOR (owns the transient slot; derives + consumes onto the model)
+// ============================================================================
+
+/** Stamp the derived per-track `startMediaTime` onto the model (idempotent — same reference when nothing moved). */
+function stampTracks(presentation: Presentation, startMediaTimes: Record<string, number | undefined>): Presentation {
+  let changed = false;
+  const selectionSets = presentation.selectionSets.map((selectionSet) => ({
+    ...selectionSet,
+    switchingSets: selectionSet.switchingSets.map((switchingSet) => ({
+      ...switchingSet,
+      tracks: switchingSet.tracks.map((track) => {
+        const startMediaTime = startMediaTimes[track.type];
+        if (startMediaTime === undefined || track.startMediaTime === startMediaTime) return track;
+        changed = true;
+        return { ...track, startMediaTime };
+      }),
+    })),
+  }));
+  return changed ? ({ ...presentation, selectionSets } as Presentation) : presentation;
+}
+
+type EstablishFsmState = 'inactive' | 'monitoring' | 'established';
+
+interface EstablishStartMediaTimeDeps {
+  state: {
+    presentation: Signal<EstablishStartMediaTimeState['presentation']>;
+    mediaContainerData: Signal<EstablishStartMediaTimeState['mediaContainerData']>;
+    // Optional so the one behavior composes across video-only / audio-only / both,
+    // like other cross-track-type behaviors (present at runtime iff a sibling owns it).
+    selectedVideoTrackId?: ReadonlySignal<EstablishStartMediaTimeState['selectedVideoTrackId']>;
+    selectedAudioTrackId?: ReadonlySignal<EstablishStartMediaTimeState['selectedAudioTrackId']>;
+  };
+  config?: EstablishStartMediaTimeConfig;
+}
+
+function establishStartMediaTimeSetup({
+  state,
+  config = {},
+}: EstablishStartMediaTimeDeps): Reactor<EstablishFsmState | 'destroying' | 'destroyed'> {
+  const derive = config.deriveStartMediaTime ?? deriveSharedMinStartMediaTime;
+
+  const selectionContext = (): DeriveStartMediaTimeContext => ({
+    selectedVideoTrackId: state.selectedVideoTrackId?.get(),
+    selectedAudioTrackId: state.selectedAudioTrackId?.get(),
+  });
+
+  /** Established once the selected A/V tracks (whichever exist) carry `startMediaTime`. */
+  const established = (): boolean => {
+    const presentation = state.presentation.get();
+    if (!isResolvedPresentation(presentation)) return false;
+    const ids = [state.selectedVideoTrackId?.get(), state.selectedAudioTrackId?.get()].filter(
+      (id): id is string => id !== undefined
+    );
+    return ids.length > 0 && ids.every((id) => findTrackById(presentation, id)?.startMediaTime !== undefined);
+  };
+
+  return createMachineReactor<EstablishFsmState>({
+    initial: 'inactive',
+    monitor: () => {
+      if (!isResolvedPresentation(state.presentation.get())) return 'inactive';
+      return established() ? 'established' : 'monitoring';
+    },
+    states: {
+      // Fresh per source: clear the transient slot so a new source re-discovers.
+      inactive: { entry: () => state.mediaContainerData.set(undefined) },
+      // Derive: reduce the accumulating container data into per-track startMediaTime
+      // and stamp it onto the model. Re-runs as discover fills the slot; the update
+      // reads presentation untracked, so no self-loop. Disabled on entry to
+      // `established` (establish-once, sticky per source).
+      monitoring: {
+        effects: () => {
+          const containerData = state.mediaContainerData.get();
+          if (!containerData) return;
+          const startMediaTimes = derive(containerData, selectionContext());
+          // `current` is always resolved here — the monitor gates `monitoring` on a
+          // resolved presentation and transitions before effects re-run — so we cast
+          // to `Presentation` rather than re-narrowing.
+          update(state.presentation as Signal<MaybeResolvedPresentation>, (current) =>
+            stampTracks(current as Presentation, startMediaTimes)
+          );
+        },
+      },
+      established: {},
+    },
+  });
+}
+
+export const establishStartMediaTime: Behavior<
+  {
+    presentation: Signal<EstablishStartMediaTimeState['presentation']>;
+    mediaContainerData: Signal<EstablishStartMediaTimeState['mediaContainerData']>;
+  },
+  Record<never, never>,
+  EstablishStartMediaTimeConfig
+> = {
+  stateKeys: ['presentation', 'mediaContainerData'],
+  contextKeys: [],
+  setup: establishStartMediaTimeSetup,
+};
diff --git a/packages/spf/src/playback/behaviors/tests/establish-start-media-time.test.ts b/packages/spf/src/playback/behaviors/tests/establish-start-media-time.test.ts
new file mode 100644
index 00000000..b0287c09
--- /dev/null
+++ b/packages/spf/src/playback/behaviors/tests/establish-start-media-time.test.ts
@@ -0,0 +1,159 @@
+import { describe, expect, it } from 'vitest';
+import {
+  derivePerTypeStartMediaTime,
+  deriveSharedMinStartMediaTime,
+  NEAR_ZERO_ORIGIN_THRESHOLD,
+} from '../establish-start-media-time';
+
+describe('deriveSharedMinStartMediaTime', () => {
+  const sel = { selectedVideoTrackId: 'v', selectedAudioTrackId: 'a' };
+
+  it('relocates every type by the shared min across selected A/V origins', () => {
+    // Apple bipbop: video origin 10.000 (ts 6000, tfdt 60000), audio origin 9.956
+    // (ts 48000, tfdt 477888). Audio leads by 44ms → shared min = 9.956 for BOTH,
+    // so relocating preserves the skew (video lands at +0.044, audio at 0).
+    expect(
+      deriveSharedMinStartMediaTime(
+        {
+          video: { timescale: 6000, baseMediaDecodeTime: 60000, segmentStartTime: 0 },
+          audio: { timescale: 48000, baseMediaDecodeTime: 477888, segmentStartTime: 0 },
+        },
+        sel
+      )
+    ).toEqual({ video: 9.956, audio: 9.956 });
+  });
+
+  it('matches per-type when A/V is aligned (min equals each equal origin)', () => {
+    expect(
+      deriveSharedMinStartMediaTime(
+        {
+          video: { timescale: 90000, baseMediaDecodeTime: 90000 * 60, segmentStartTime: 0 },
+          audio: { timescale: 48000, baseMediaDecodeTime: 48000 * 60, segmentStartTime: 0 },
+        },
+        sel
+      )
+    ).toEqual({ video: 60, audio: 60 });
+  });
+
+  it('barriers: returns nothing until every selected type has a complete origin', () => {
+    // Audio is selected but not yet discovered → hold back both (no partial relocation).
+    expect(
+      deriveSharedMinStartMediaTime(
+        { video: { timescale: 6000, baseMediaDecodeTime: 60000, segmentStartTime: 0 } },
+        sel
+      )
+    ).toEqual({});
+  });
+
+  it('subtracts a non-zero segmentStartTime so the origin is the stream origin, not the loaded segment', () => {
+    expect(
+      deriveSharedMinStartMediaTime(
+        {
+          video: { timescale: 90000, baseMediaDecodeTime: 90000 * 160, segmentStartTime: 100 },
+          audio: { timescale: 48000, baseMediaDecodeTime: 48000 * 160, segmentStartTime: 100 },
+        },
+        sel
+      )
+    ).toEqual({ video: 60, audio: 60 });
+  });
+
+  it('degenerates to the single type when only one is selected', () => {
+    expect(
+      deriveSharedMinStartMediaTime(
+        { video: { timescale: 6000, baseMediaDecodeTime: 60000, segmentStartTime: 0 } },
+        { selectedVideoTrackId: 'v' }
+      )
+    ).toEqual({ video: 10 });
+  });
+
+  it('coordinates across whatever types have data when there is no selection context', () => {
+    expect(
+      deriveSharedMinStartMediaTime(
+        {
+          video: { timescale: 6000, baseMediaDecodeTime: 60000, segmentStartTime: 0 },
+          audio: { timescale: 48000, baseMediaDecodeTime: 477888, segmentStartTime: 0 },
+        },
+        {}
+      )
+    ).toEqual({ video: 9.956, audio: 9.956 });
+  });
+
+  it('leaves ordinary ~0-PTS VOD native: a shared origin below the threshold returns 0', () => {
+    // Both types carry a sub-second (0.5s) encode offset → not relocated.
+    expect(
+      deriveSharedMinStartMediaTime(
+        {
+          video: { timescale: 90000, baseMediaDecodeTime: 45000, segmentStartTime: 0 },
+          audio: { timescale: 48000, baseMediaDecodeTime: 24000, segmentStartTime: 0 },
+        },
+        sel
+      )
+    ).toEqual({ video: 0, audio: 0 });
+  });
+
+  it('relocates at/above the threshold (the boundary is exclusive)', () => {
+    const atThreshold = {
+      video: { timescale: 90000, baseMediaDecodeTime: 90000 * NEAR_ZERO_ORIGIN_THRESHOLD, segmentStartTime: 0 },
+      audio: { timescale: 48000, baseMediaDecodeTime: 48000 * NEAR_ZERO_ORIGIN_THRESHOLD, segmentStartTime: 0 },
+    };
+    expect(deriveSharedMinStartMediaTime(atThreshold, sel)).toEqual({
+      video: NEAR_ZERO_ORIGIN_THRESHOLD,
+      audio: NEAR_ZERO_ORIGIN_THRESHOLD,
+    });
+  });
+
+  it('snaps a negative shared origin to 0 (never relocates forward)', () => {
+    // segmentStartTime > bmdt/ts → negative own origin.
+    expect(
+      deriveSharedMinStartMediaTime(
+        {
+          video: { timescale: 90000, baseMediaDecodeTime: 0, segmentStartTime: 5 },
+          audio: { timescale: 48000, baseMediaDecodeTime: 0, segmentStartTime: 5 },
+        },
+        sel
+      )
+    ).toEqual({ video: 0, audio: 0 });
+  });
+});
+
+describe('derivePerTypeStartMediaTime', () => {
+  it('resolves each track type by its own origin (bmdt/ts − segmentStartTime)', () => {
+    expect(
+      derivePerTypeStartMediaTime(
+        {
+          video: { timescale: 90000, baseMediaDecodeTime: 90000 * 60, segmentStartTime: 0 },
+          audio: { timescale: 48000, baseMediaDecodeTime: 48000 * 59.956, segmentStartTime: 0 },
+        },
+        {}
+      )
+    ).toEqual({ video: 60, audio: 59.956 });
+  });
+
+  it('subtracts a non-zero segmentStartTime so it yields the stream origin, not the loaded segment', () => {
+    expect(
+      derivePerTypeStartMediaTime(
+        { video: { timescale: 90000, baseMediaDecodeTime: 90000 * 160, segmentStartTime: 100 } },
+        {}
+      )
+    ).toEqual({ video: 60 });
+  });
+
+  it('is undefined for a type until timescale + baseMediaDecodeTime + segmentStartTime are all present', () => {
+    expect(derivePerTypeStartMediaTime({ video: { timescale: 90000 } }, {})).toEqual({ video: undefined });
+    expect(derivePerTypeStartMediaTime({ audio: { baseMediaDecodeTime: 100, segmentStartTime: 0 } }, {})).toEqual({
+      audio: undefined,
+    });
+  });
+
+  it('snaps a below-threshold origin to 0 independently per type', () => {
+    expect(
+      derivePerTypeStartMediaTime(
+        {
+          video: { timescale: 90000, baseMediaDecodeTime: 45000, segmentStartTime: 0 }, // 0.5s → 0
+          audio: { timescale: 48000, baseMediaDecodeTime: 48000 * 60, segmentStartTime: 0 }, // 60s → 60
+        },
+        {}
+      )
+    ).toEqual({ video: 0, audio: 60 });
+  });
+});
diff --git a/packages/spf/src/playback/engines/hls/engine-audio-only.ts b/packages/spf/src/playback/engines/hls/engine-audio-only.ts
index 210c73a1..29b212d1 100644
--- a/packages/spf/src/playback/engines/hls/engine-audio-only.ts
+++ b/packages/spf/src/playback/engines/hls/engine-audio-only.ts
@@ -9,7 +9,7 @@ import type { BackBufferConfig } from '../../../media/buffer/back-buffer';
 import type { ForwardBufferConfig } from '../../../media/buffer/forward-buffer';
 import { canPlayTrack } from '../../../media/dom/capabilities';
 import { parseMultivariantPlaylist } from '../../../media/hls/parse-multivariant';
-import type { AudioTrack, CanPlayTrack, MaybeResolvedPresentation } from '../../../media/types';
+import type { AudioTrack, CanPlayTrack, MaybeResolvedPresentation, MediaContainerData } from '../../../media/types';
 import type { GetCdnId } from '../../../media/utils/cdn';
 import { getResolvedSelectedTrackDuration } from '../../../media/utils/track-selection';
 import type { SegmentLoaderActor } from '../../actors/dom/segment-loader';
@@ -21,16 +21,26 @@ import {
 import { deriveCdnPriority } from '../../behaviors/derive-cdn-priority';
 import { endOfStream } from '../../behaviors/dom/end-of-stream';
 import { loadAudioSegments } from '../../behaviors/dom/load-segments';
+import { recoverEndStall } from '../../behaviors/dom/recover-end-stall';
 import { setupAudioBufferActors } from '../../behaviors/dom/setup-buffer-actors';
 import { setupMediaSource } from '../../behaviors/dom/setup-mediasource';
 import { trackCurrentTime } from '../../behaviors/dom/track-current-time';
 import { trackLoadTriggers } from '../../behaviors/dom/track-load-triggers';
 import { updateMediaSourceDuration } from '../../behaviors/dom/update-mediasource-duration';
+// Non-zero-PTS relocation (spike): remove this import, the composed reactor, the
+// `audioMessagePipelines` finalConfig entry, the `mediaContainerData` state slot,
+// and the `deriveStartMediaTime` config field to drop relocation from audio-only.
+import {
+  type DeriveStartMediaTime,
+  deriveSharedMinStartMediaTime,
+  establishStartMediaTime,
+} from '../../behaviors/establish-start-media-time';
 import { type ParsePresentation, resolvePresentation } from '../../behaviors/resolve-presentation';
 import { resolveAudioTrack } from '../../behaviors/resolve-track';
 import { type FailoverMonitorConfig, setupFailoverMonitor } from '../../behaviors/setup-failover-monitor';
 import { syncPreload } from '../../behaviors/sync-preload';
 import { switchAudioTrack } from '../../behaviors/track-switching';
+import { relocationPipelinesFor } from '../../primitives/relocation-pipelines';
 
 // ============================================================================
 // Audio-Only HLS Engine State & Context
@@ -47,6 +57,9 @@ export interface SimpleHlsAudioOnlyEngineState {
   presentation?: MaybeResolvedPresentation;
   preload?: 'auto' | 'metadata' | 'none';
   selectedAudioTrackId?: string;
+  // Non-zero-PTS relocation (spike): transient per-track container data owned by
+  // `establishStartMediaTime`. Remove with the composed reactor.
+  mediaContainerData?: Record<string, MediaContainerData>;
   /**
    * Consumer-driven constraint narrowing the audio candidate set. Sibling
    * of `userVideoTrackSelection` in the default engine. Partial-track
@@ -119,6 +132,8 @@ export interface SimpleHlsAudioOnlyEngineConfig
    * Defaults to the URL origin; override to key on e.g. Mux's `cdn=` param.
    */
   getCdnId?: GetCdnId;
+  /** Non-zero-PTS relocation (spike): the reduce seam (tier knob); defaults to per-track own. */
+  deriveStartMediaTime?: DeriveStartMediaTime;
 }
 
 // ============================================================================
@@ -166,11 +181,17 @@ const shareSignals = makeShareSignals<SimpleHlsAudioOnlyEngineState, SimpleHlsAu
 export function createHlsAudioOnlyEngine(
   config: SimpleHlsAudioOnlyEngineConfig = {}
 ): Composition<SimpleHlsAudioOnlyEngineState, SimpleHlsAudioOnlyEngineContext> {
+  const deriveStartMediaTime = config.deriveStartMediaTime ?? deriveSharedMinStartMediaTime;
   const finalConfig = {
     ...config,
+    deriveStartMediaTime,
     canPlayTrack: config.canPlayTrack ?? canPlayTrack,
     resolveDuration: config.resolveDuration ?? getResolvedSelectedTrackDuration,
     parsePresentation: config.parsePresentation ?? parseMultivariantPlaylist,
+    // Non-zero-PTS relocation (spike): pair the audio loader with the relocation steps
+    // `establishStartMediaTime` derives from; same `deriveStartMediaTime` seam. Remove
+    // with the reactor.
+    audioMessagePipelines: relocationPipelinesFor('audio', deriveStartMediaTime),
   };
 
   return createComposition(
@@ -210,6 +231,13 @@ export function createHlsAudioOnlyEngine(
       // so the Firefox `mozHasAudio` registration ordering is moot here.
       setupMediaSource,
       updateMediaSourceDuration,
+
+      // Non-zero-PTS relocation (spike): establishes per-track startMediaTime;
+      // MUST precede setupAudioBufferActors. Remove this line + the import + the
+      // finalConfig/state entries to drop relocation. (Selection is optional in the
+      // reactor, so it works with only audio in scope.)
+      establishStartMediaTime,
+
       setupAudioBufferActors,
 
       // Playback tracking
@@ -223,6 +251,9 @@ export function createHlsAudioOnlyEngine(
       // `mediaSource.sourceBuffers` aggregately — composes unchanged with
       // only audio in scope.
       endOfStream,
+      // Force native `ended` if Chrome freezes the playhead short of the buffered end
+      // after `endOfStream`. Inert for a clean-ending single-track source.
+      recoverEndStall,
 
       // Adapter signal callback.
       shareSignals,
diff --git a/packages/spf/src/playback/engines/hls/engine.ts b/packages/spf/src/playback/engines/hls/engine.ts
index 90da594f..5ced7dc3 100644
--- a/packages/spf/src/playback/engines/hls/engine.ts
+++ b/packages/spf/src/playback/engines/hls/engine.ts
@@ -16,14 +16,21 @@ import {
   removeAllSubtitlesTracksFromMedia,
 } from '../../../media/dom/text/text-track-slots';
 import { parseMultivariantPlaylist } from '../../../media/hls/parse-multivariant';
-import type { AudioTrack, CanPlayTrack, MaybeResolvedPresentation, TextTrack, VideoTrack } from '../../../media/types';
+import type {
+  AudioTrack,
+  CanPlayTrack,
+  MaybeResolvedPresentation,
+  MediaContainerData,
+  TextTrack,
+  VideoTrack,
+} from '../../../media/types';
 import type { GetCdnId } from '../../../media/utils/cdn';
 import { getResolvedSelectedTrackDuration } from '../../../media/utils/track-selection';
 import type { BandwidthConfig, BandwidthState } from '../../../network/bandwidth-estimator';
 import type { SegmentLoaderActor } from '../../actors/dom/segment-loader';
 import type { SourceBufferActor } from '../../actors/dom/source-buffer';
 import type { TextTracksActor } from '../../actors/dom/text-tracks';
-import type { TextTrackSegmentLoaderActor, TextTrackSegmentResolver } from '../../actors/text-track-segment-loader';
+import type { TextTrackSegmentLoaderActor } from '../../actors/text-track-segment-loader';
 import {
   calculatePresentationDuration,
   type PresentationDurationResolver,
@@ -31,6 +38,7 @@ import {
 import { deriveCdnPriority } from '../../behaviors/derive-cdn-priority';
 import { endOfStream } from '../../behaviors/dom/end-of-stream';
 import { loadAudioSegments, loadTextTrackSegments, loadVideoSegments } from '../../behaviors/dom/load-segments';
+import { recoverEndStall } from '../../behaviors/dom/recover-end-stall';
 import { setupAudioBufferActors, setupVideoBufferActors } from '../../behaviors/dom/setup-buffer-actors';
 import { setupMediaSource } from '../../behaviors/dom/setup-mediasource';
 import { setupTextTrackActors } from '../../behaviors/dom/setup-text-track-actors';
@@ -38,11 +46,22 @@ import { syncTextTracks } from '../../behaviors/dom/sync-text-tracks';
 import { trackCurrentTime } from '../../behaviors/dom/track-current-time';
 import { trackLoadTriggers } from '../../behaviors/dom/track-load-triggers';
 import { updateMediaSourceDuration } from '../../behaviors/dom/update-mediasource-duration';
+// Non-zero-PTS relocation (spike): remove this import, the composed reactor, the
+// `video/audio/textMessagePipelines` finalConfig entries, the `mediaContainerData`
+// state slot, and the `deriveStartMediaTime` config field to drop relocation entirely
+// (text then falls back to the plain `resolveVttSegment` resolver).
+import {
+  type DeriveStartMediaTime,
+  deriveSharedMinStartMediaTime,
+  establishStartMediaTime,
+} from '../../behaviors/establish-start-media-time';
 import { type ParsePresentation, resolvePresentation } from '../../behaviors/resolve-presentation';
 import { resolveAudioTrack, resolveTextTrack, resolveVideoTrack } from '../../behaviors/resolve-track';
 import { type FailoverMonitorConfig, setupFailoverMonitor } from '../../behaviors/setup-failover-monitor';
 import { syncPreload } from '../../behaviors/sync-preload';
 import { switchAudioTrack, switchTextTrack, switchVideoTrack } from '../../behaviors/track-switching';
+import { relocatingTextPipelines, relocationPipelinesFor } from '../../primitives/relocation-pipelines';
+import type { TextTrackSegmentResolver } from '../../primitives/text-segment-load-pipeline';
 
 // ============================================================================
 // HLS Engine State & Context
@@ -66,6 +85,9 @@ export interface SimpleHlsEngineState {
   selectedAudioTrackId?: string;
   selectedTextTrackId?: string;
   bandwidthState?: BandwidthState;
+  // Non-zero-PTS relocation (spike): transient per-track container data owned by
+  // `establishStartMediaTime`. Remove with the composed reactor.
+  mediaContainerData?: Record<string, MediaContainerData>;
   userVideoTrackSelection?: Partial<VideoTrack>;
   /**
    * Consumer-driven constraint narrowing the audio candidate set. Sibling
@@ -238,6 +260,22 @@ export interface SimpleHlsEngineConfig extends ShareSignalsConfig<SimpleHlsEngin
    * key on something else (e.g. Mux's `cdn=` query param).
    */
   getCdnId?: GetCdnId;
+  /**
+   * Non-zero-PTS relocation (spike): the reduce seam consumed by the
+   * `establishStartMediaTime` reactor. Defaults to per-track own origin (Tier 1);
+   * a Tier-2 variant returns the shared `min` across selected A/V. Relocation is
+   * composed into the standard engine below — see the marked block — so this only
+   * needs setting to swap the tier policy. See
+   * `internal/design/spf/presentation-timeline-model.md`.
+   */
+  deriveStartMediaTime?: DeriveStartMediaTime;
+  /**
+   * Proximity window (seconds) for the `recoverEndStall` behavior — how close the
+   * playhead must be to the reachable buffered end for a `waiting` to be treated as the
+   * end-of-stream freeze and nudged to `ended`. Defaults to `0.2`. See
+   * `behaviors/dom/recover-end-stall`.
+   */
+  endStallNudgeWindow?: number;
 }
 
 // ============================================================================
@@ -288,15 +326,28 @@ const shareSignals = makeShareSignals<SimpleHlsEngineState, SimpleHlsEngineConte
 export function createSimpleHlsEngine(
   config: SimpleHlsEngineConfig = {}
 ): Composition<SimpleHlsEngineState, SimpleHlsEngineContext> {
+  // Non-zero-PTS relocation (spike): resolve the coordination seam once so the reactor
+  // (model `startMediaTime`) and the loader stamps (buffer `timestampOffset`) apply the
+  // SAME derive. Default is shared-`min` across selected A/V (subsumes per-type).
+  const deriveStartMediaTime = config.deriveStartMediaTime ?? deriveSharedMinStartMediaTime;
   const finalConfig = {
     ...config,
+    deriveStartMediaTime,
     canPlayTrack: config.canPlayTrack ?? canPlayTrack,
     resolveTextTrackSegment: config.resolveTextTrackSegment ?? resolveVttSegment,
+    // Non-zero-PTS relocation (spike): the text pipeline rebases cues onto the
+    // relocated 0-based timeline. Remove `textMessagePipelines` to drop text relocation.
+    textMessagePipelines: relocatingTextPipelines,
     resolveDuration: config.resolveDuration ?? getResolvedSelectedTrackDuration,
     parsePresentation: config.parsePresentation ?? parseMultivariantPlaylist,
     addSubtitlesTracksToMedia: config.addSubtitlesTracksToMedia ?? addSubtitlesTracksToMedia,
     getShowingSubtitlesTrackFromMedia: config.getShowingSubtitlesTrackFromMedia ?? getShowingSubtitlesTrackFromMedia,
     removeAllSubtitlesTracksFromMedia: config.removeAllSubtitlesTracksFromMedia ?? removeAllSubtitlesTracksFromMedia,
+    // Non-zero-PTS relocation (spike): the discover/stamp steps `establishStartMediaTime`
+    // pairs with. They apply the same `deriveStartMediaTime` seam as the reactor. Remove
+    // these two lines with the reactor.
+    videoMessagePipelines: relocationPipelinesFor('video', deriveStartMediaTime),
+    audioMessagePipelines: relocationPipelinesFor('audio', deriveStartMediaTime),
   };
 
   return createComposition(
@@ -343,6 +394,17 @@ export function createSimpleHlsEngine(
       // in setup-buffer-actors.ts.
       setupMediaSource,
       updateMediaSourceDuration,
+
+      // ── Non-zero-PTS relocation (spike) ──────────────────────────────────
+      // Establishes per-track `startMediaTime` and publishes the relocating
+      // segment-loader pipelines to context. MUST precede `setup*BufferActors`
+      // so the pipelines are published before the loaders read them. Remove this
+      // one line (+ the import, the `mediaContainerData`/`*MessagePipelines`
+      // slots including `textMessagePipelines`, and the `deriveStartMediaTime`
+      // config) to drop relocation and test the Tier-0 baseline / bundle size.
+      establishStartMediaTime,
+      // ─────────────────────────────────────────────────────────────────────
+
       setupVideoBufferActors,
       setupAudioBufferActors,
 
@@ -366,6 +428,9 @@ export function createSimpleHlsEngine(
 
       // End of stream coordination
       endOfStream,
+      // Force native `ended` when Chrome freezes the playhead a few frames short of a
+      // skewed-A/V end after `endOfStream` (audio-clock stall). Inert otherwise.
+      recoverEndStall,
 
       // Text tracks
       syncTextTracks,
diff --git a/packages/spf/src/playback/engines/hls/index.ts b/packages/spf/src/playback/engines/hls/index.ts
index 2fe3c6c2..95f4ccc0 100644
--- a/packages/spf/src/playback/engines/hls/index.ts
+++ b/packages/spf/src/playback/engines/hls/index.ts
@@ -1,3 +1,11 @@
+// Non-zero-PTS relocation (spike): the coordination seam type + the shared-`min`
+// default and the per-type alternative, for a consumer swapping the policy via
+// `config.deriveStartMediaTime`.
+export {
+  type DeriveStartMediaTime,
+  derivePerTypeStartMediaTime,
+  deriveSharedMinStartMediaTime,
+} from '../../behaviors/establish-start-media-time';
 export type { SimpleHlsMediaAPI, SimpleHlsMediaProps } from './adapter';
 export { SimpleHlsMediaElement, SimpleHlsMediaMixin, simpleHlsMediaDefaultProps } from './adapter';
 export type { SimpleHlsAudioOnlyMediaAPI, SimpleHlsAudioOnlyMediaProps } from './adapter-audio-only';
diff --git a/packages/spf/src/playback/engines/hls/tsconfig.json b/packages/spf/src/playback/engines/hls/tsconfig.json
index acb1ab38..9e83eff2 100644
--- a/packages/spf/src/playback/engines/hls/tsconfig.json
+++ b/packages/spf/src/playback/engines/hls/tsconfig.json
@@ -12,6 +12,7 @@
     { "path": "../../../network" },
     { "path": "../../../media" },
     { "path": "../../../media/dom" },
+    { "path": "../../primitives" },
     { "path": "../../behaviors" },
     { "path": "../../behaviors/dom" },
     { "path": "../../actors" },
diff --git a/packages/spf/src/playback/primitives/derive-start-media-time.ts b/packages/spf/src/playback/primitives/derive-start-media-time.ts
new file mode 100644
index 00000000..bf290013
--- /dev/null
+++ b/packages/spf/src/playback/primitives/derive-start-media-time.ts
@@ -0,0 +1,25 @@
+/**
+ * The `startMediaTime` coordination seam — shared by the `establishStartMediaTime`
+ * reactor (which owns the lifecycle and holds one of these as config) and the DOM-free
+ * relocation pipelines that fill its state (`relocation-pipelines`). It lives here rather
+ * than with the behavior because the pipelines are a lower layer and can't import from
+ * `behaviors/`; a playback-domain contract (it names selected track ids), so not `media/`.
+ * See `internal/design/spf/presentation-timeline-model.md`.
+ */
+import type { MediaContainerData } from '../../media/types';
+
+/** The selected v/a track ids a {@link DeriveStartMediaTime} may coordinate across. */
+export interface DeriveStartMediaTimeContext {
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+}
+
+/**
+ * Reduce the discovered {@link MediaContainerData} (keyed by track type) into each type's
+ * `startMediaTime` origin; `undefined` means "not ready yet". Pure and injected — the single
+ * coordination seam the reactor and the loader stamp share.
+ */
+export type DeriveStartMediaTime = (
+  containerData: Record<string, MediaContainerData>,
+  ctx: DeriveStartMediaTimeContext
+) => Record<string, number | undefined>;
diff --git a/packages/spf/src/playback/primitives/head-peek.ts b/packages/spf/src/playback/primitives/head-peek.ts
new file mode 100644
index 00000000..3af7687e
--- /dev/null
+++ b/packages/spf/src/playback/primitives/head-peek.ts
@@ -0,0 +1,45 @@
+/**
+ * Eager head-of-stream peek. Pulls chunks from an async byte stream only until
+ * `tryParse` signals it has read what it needs (or the stream ends), then returns
+ * a stream that re-emits the pulled head followed by the untouched tail — so
+ * reading a head-of-stream mp4 box (`mdhd` / `tfdt`) doesn't break streaming of
+ * the append. Once the caller has what it wants, the rest streams as normal.
+ */
+
+function concat(chunks: Uint8Array[]): Uint8Array {
+  if (chunks.length === 1) return chunks[0]!;
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+
+/** Re-emit the eagerly-pulled head chunks, then stream the untouched tail. */
+async function* reassemble(head: Uint8Array[], tail: AsyncIterator<Uint8Array>): AsyncIterable<Uint8Array> {
+  yield* head;
+  for (let next = await tail.next(); !next.done; next = await tail.next()) yield next.value;
+}
+
+/**
+ * Pull chunks until `tryParse(accumulatedHead)` returns `true` — it found and read
+ * its box — or the stream ends, then return a stream re-emitting the pulled head
+ * followed by the untouched tail. `tryParse` is called with the growing head after
+ * each chunk; it performs the side effect (publishing the parsed value) and returns
+ * whether it's done.
+ */
+export async function peekHead(
+  data: AsyncIterable<Uint8Array>,
+  tryParse: (bytes: Uint8Array) => boolean
+): Promise<AsyncIterable<Uint8Array>> {
+  const iterator = data[Symbol.asyncIterator]();
+  const head: Uint8Array[] = [];
+  for (let next = await iterator.next(); !next.done; next = await iterator.next()) {
+    head.push(next.value);
+    if (tryParse(concat(head))) break;
+  }
+  return reassemble(head, iterator);
+}
diff --git a/packages/spf/src/playback/primitives/relocation-pipelines.ts b/packages/spf/src/playback/primitives/relocation-pipelines.ts
new file mode 100644
index 00000000..4ff6918a
--- /dev/null
+++ b/packages/spf/src/playback/primitives/relocation-pipelines.ts
@@ -0,0 +1,267 @@
+/**
+ * Non-zero-PTS relocation pipelines — the config-supplied, loader-facing half of the
+ * `establishStartMediaTime` behavior (`../behaviors/establish-start-media-time`). The
+ * reactor there owns the lifecycle and the `derive` coordination seam; this file supplies
+ * the `messagePipelines` the segment/text loaders run to *fill and act on* that behavior's
+ * state. It's the relocation analog of `track-switching`'s config-supplied constraint/rule
+ * chain — a pluggable strategy handed to the machinery via config, not applied inline —
+ * supplied to the loaders rather than applied by the behavior, so the two coordinate
+ * through the shared `mediaContainerData` / `startMediaTime` slots alone, never by import.
+ *
+ * DOM-free: it composes the loader vocabularies (`segment-load-pipeline`,
+ * `text-segment-load-pipeline`) through their structural sink seams and shifts cues via
+ * the structural `Cue` type, so it names no `SourceBuffer`, `TextTracksActor`, or
+ * `VTTCue`. The A/V pipeline is a plain `messagePipelines` array:
+ *   - `discover` — init `track_id` + `mdhd` timescale for the buffered media track, then
+ *     that same track's `tfdt` baseMediaDecodeTime, matched by `track_id` so a muxed
+ *     segment reads the media track's origin, not the first `traf` — writes
+ *     `state.mediaContainerData`.
+ *   - `stamp` — reads that track's derived origin back and relocates via
+ *     `timestampOffset = −startMediaTime`.
+ * Steps read composition `state` from their call-time `deps` (no closures, no context).
+ *
+ * The text half (`relocatingTextPipelines`) is the same idea for the text-segment loader:
+ * a `resolveWithMetadata → relocateCues → dispatchCues` pipeline that shifts cues onto the
+ * same 0-based timeline, reading the primary A/V track's `startMediaTime` (the reactor's
+ * consumed value) via `deps`.
+ */
+import type { StateSignals } from '../../core/composition/create-composition';
+import { effect } from '../../core/signals/effect';
+import { peek, type Signal, update } from '../../core/signals/primitives';
+import { findMediaTrack, type MediaHandlerType, readBaseMediaDecodeTime } from '../../media/mp4/timestamp-origin';
+import { resolveVttSegmentMetadata, type TextSegmentMetadata } from '../../media/text/resolve-vtt-metadata';
+import type { Cue, MaybeResolvedPresentation, MediaContainerData } from '../../media/types';
+import { findTrackById, getTracksByType } from '../../media/utils/tracks';
+import type { DeriveStartMediaTime } from './derive-start-media-time';
+import { peekHead } from './head-peek';
+import { dispatchStep, fetchStep, type LoadStep, type MessagePipelines, type StepDeps } from './segment-load-pipeline';
+import {
+  dispatchCuesStep,
+  type TextFrame,
+  type TextLoadStep,
+  type TextStepDeps,
+  textStepWiring,
+} from './text-segment-load-pipeline';
+
+/** The composition slots these steps read — the view asserted from the opaque `deps.state`. */
+interface RelocationSlots {
+  presentation?: MaybeResolvedPresentation;
+  mediaContainerData?: Record<string, MediaContainerData>;
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+}
+
+type ContainerSlot = Signal<Record<string, MediaContainerData> | undefined>;
+
+/** Assert the relocation state view from the opaque step deps — this module knows the slots the composition provides. */
+function relocationState(deps: StepDeps): StateSignals<RelocationSlots> {
+  return deps.state as unknown as StateSignals<RelocationSlots>;
+}
+
+function containerSlot(deps: StepDeps): ContainerSlot {
+  return relocationState(deps).mediaContainerData;
+}
+
+/** Synchronous RMW of the per-type entry — disjoint keys across producers, so no lost update. */
+function writeContainer(slot: ContainerSlot, trackType: string, patch: Partial<MediaContainerData>): void {
+  update(slot, (current) => ({ ...current, [trackType]: { ...current?.[trackType], ...patch } }));
+}
+
+/**
+ * Resolve once `read()` returns a number. Shared by the A/V stamp (waits for the
+ * `derive`d origin — immediate for per-type, the shared-`min` barrier for coordinated)
+ * and the text step (waits for the primary A/V origin). No bound: for fMP4 the origin
+ * always establishes.
+ */
+function awaitDefined(read: () => number | undefined): Promise<number> {
+  return new Promise((resolve) => {
+    let stop: (() => void) | undefined;
+    stop = effect(() => {
+      const value = read();
+      if (value !== undefined) {
+        stop?.();
+        resolve(value);
+      }
+    });
+  });
+}
+
+/**
+ * Relocation pipelines for one track type — a plain config `messagePipelines`.
+ * Keyed by **track type** (`'video'` / `'audio'`), so ABR rungs of a type share the
+ * origin (discover skips once the type's value is present). The steps read/write
+ * `state.mediaContainerData[trackType]` via their call-time `deps`; the stamp applies
+ * the same `derive` seam the reactor uses (pass the composition's resolved
+ * `deriveStartMediaTime` so the buffer offset and the model's `startMediaTime` agree).
+ */
+export function relocationPipelinesFor(trackType: 'video' | 'audio', derive: DeriveStartMediaTime): MessagePipelines {
+  const handlerType: MediaHandlerType = trackType === 'video' ? 'vide' : 'soun';
+
+  /**
+   * Init step: head-peek the buffered media track's `track_id` + `mdhd` timescale into
+   * `mediaContainerData[trackType]`. Matching by handler (`vide`/`soun`) skips a muxed
+   * `clcp` caption track, and the `track_id` lets `readSegmentOrigin` read *this*
+   * track's `tfdt` rather than the first `traf` in the segment.
+   */
+  const readInitTrackInfo: LoadStep = async (frame, _signal, deps) => {
+    const { op } = frame;
+    if (op.type !== 'append-init' || !frame.data) return;
+    const slot = containerSlot(deps);
+    if (peek(slot)?.[trackType]?.timescale !== undefined) return; // already have it (any rung of this type)
+    frame.data = await peekHead(frame.data, (bytes) => {
+      const track = findMediaTrack(bytes, handlerType);
+      if (track === undefined) return false;
+      writeContainer(slot, trackType, { trackId: track.trackId, timescale: track.timescale });
+      return true;
+    });
+  };
+
+  /**
+   * Media-segment step: head-peek the `tfdt` baseMediaDecodeTime of the media track's
+   * `traf` (matched by the `track_id` discovered from the init), recording the
+   * segment's 0-based `startTime` with it — the origin is `bmdt/ts − segmentStartTime`,
+   * so the first *loaded* segment need not be the 0th. Without a discovered `track_id`
+   * (non-fMP4 / mock init) there's no media track to relocate, so the step no-ops and
+   * the append stays native.
+   */
+  const readSegmentOrigin: LoadStep = async (frame, _signal, deps) => {
+    const { op } = frame;
+    if (op.type !== 'append-segment' || !frame.data) return;
+    const slot = containerSlot(deps);
+    const container = peek(slot)?.[trackType];
+    if (container?.baseMediaDecodeTime !== undefined) return; // established
+    const { trackId } = container ?? {};
+    if (trackId === undefined) return; // init didn't identify a media track — nothing to match
+    const segmentStartTime = op.meta.startTime;
+    frame.data = await peekHead(frame.data, (bytes) => {
+      const baseMediaDecodeTime = readBaseMediaDecodeTime(bytes, trackId);
+      if (baseMediaDecodeTime === undefined) return false;
+      writeContainer(slot, trackType, { baseMediaDecodeTime, segmentStartTime });
+      return true;
+    });
+  };
+
+  /**
+   * Stamp step — tier-agnostic apply. Relocate by the `derive`d `startMediaTime` for
+   * this type (`offset = −startMediaTime`). Applies the **same** `derive` the reactor
+   * uses, over the shared `mediaContainerData` slot — so the buffer offset matches the
+   * model's stamped `startMediaTime`, and it's robust to `established` + late tracks
+   * (the slot persists; the model value may not be re-stamped after the reactor goes
+   * sticky). Awaited: per-type resolves at once (own origin discovered earlier in this
+   * pipeline); shared-`min` waits until every selected A/V origin is in — the barrier,
+   * filled by the other type's discover step. A derived `0` (0-PTS / below threshold)
+   * leaves the append native — setting `timestampOffset` at all can ripple.
+   */
+  const stampStartMediaTime: LoadStep = async (frame, signal, deps) => {
+    if (frame.op.type !== 'append-segment') return;
+    const state = relocationState(deps);
+    // Liveness guard: if THIS type's own origin wasn't discovered — `readSegmentOrigin`
+    // ran earlier in this pipeline and found no `tfdt` (mock / TS / containerless) — the
+    // source isn't relocatable, so leave the append native and DON'T wait. Only a
+    // discoverable type awaits the derived origin (which for shared-`min` legitimately
+    // blocks on the other selected type — the barrier).
+    const own = peek(state.mediaContainerData)?.[trackType];
+    if (own?.timescale === undefined || own.baseMediaDecodeTime === undefined || own.segmentStartTime === undefined) {
+      return;
+    }
+    const startMediaTime = await awaitDefined(() => {
+      const containerData = state.mediaContainerData.get();
+      if (!containerData) return undefined;
+      return derive(containerData, {
+        selectedVideoTrackId: state.selectedVideoTrackId?.get(),
+        selectedAudioTrackId: state.selectedAudioTrackId?.get(),
+      })[trackType];
+    });
+    if (signal.aborted || startMediaTime === 0) return;
+    frame.meta = { ...(frame.meta ?? frame.op.meta), timestampOffset: -startMediaTime };
+  };
+
+  return () => ({
+    remove: [dispatchStep],
+    'append-init': [fetchStep, readInitTrackInfo, dispatchStep],
+    'append-segment': [fetchStep, readSegmentOrigin, stampStartMediaTime, dispatchStep],
+  });
+}
+
+// ============================================================================
+// TEXT (cue relocation)
+// ============================================================================
+
+/**
+ * Resolve step for the relocation text pipeline. Reuses the injected host resolver
+ * (the loader's folded `resolveSegment`, via `textStepWiring`) for cues and fetches
+ * the `X-TIMESTAMP-MAP` header in parallel, stashing it on `frame.metadata` for
+ * `relocateCuesStep`. Replaces the
+ * base `resolveCuesStep` (which fetches cues only) — text's native `<track>` parser
+ * discards the header, so the map needs its own raw-bytes fetch.
+ */
+const resolveWithMetadataStep = async <C extends Cue>(
+  frame: TextFrame<C>,
+  signal: AbortSignal,
+  deps: TextStepDeps
+): Promise<void> => {
+  const [cues, metadata] = await Promise.all([
+    textStepWiring<C>(deps).resolveSegment(frame.op.segment.url),
+    resolveVttSegmentMetadata(frame.op.segment.url),
+  ]);
+  if (signal.aborted) return;
+  frame.cues = cues;
+  frame.metadata = metadata;
+};
+
+/**
+ * Relocate step — shifts each cue onto the 0-based presentation timeline:
+ * `cueFinal = cueNative − startMediaTime`, where `startMediaTime` is the primary
+ * A/V track's origin (selected **video**, else **audio** — the single-anchor rule,
+ * and defensive like the reactor's optional selection) and `cueNative` folds in the
+ * `X-TIMESTAMP-MAP` correction (`mpegts/90000 − local`) for map-bearing VTT (Apple)
+ * or is the absolute cue time (no map, e.g. Mux). Text can resolve before A/V
+ * establishes, so the origin is awaited; fMP4 always establishes it (0-PTS → 0),
+ * and a text-only source (no A/V selected) simply gets offset 0.
+ */
+const relocateCuesStep = async <C extends Cue>(
+  frame: TextFrame<C>,
+  signal: AbortSignal,
+  deps: TextStepDeps
+): Promise<void> => {
+  if (!frame.cues?.length) return;
+  const state = deps.state as unknown as StateSignals<RelocationSlots>;
+  const startMediaTime = await awaitDefined(() => {
+    const presentation = state.presentation.get();
+    if (!presentation) return undefined;
+    const primaryId = state.selectedVideoTrackId.get() ?? state.selectedAudioTrackId.get();
+    if (primaryId !== undefined) {
+      // A/V selected: use its origin once stamped (undefined until then → keep waiting).
+      return findTrackById(presentation, primaryId)?.startMediaTime;
+    }
+    // No A/V selected. Distinguish "not selected YET" from "text-only source". If the
+    // presentation has A/V tracks, one WILL be selected and stamped — wait for it, or the
+    // cues get shifted by the full `mapCorrection` (e.g. +10s on Apple X-TIMESTAMP-MAP
+    // sources) when text relocation wins the race against A/V selection. Only a genuinely
+    // text-only source (no A/V origin ever coming) legitimately relocates by offset 0.
+    const hasAv =
+      getTracksByType(presentation, 'video').length > 0 || getTracksByType(presentation, 'audio').length > 0;
+    return hasAv ? undefined : 0;
+  });
+  if (signal.aborted) return;
+  const { timestampMap } = (frame.metadata as TextSegmentMetadata | undefined) ?? {};
+  const mapCorrection = timestampMap ? timestampMap.mpegts / 90000 - timestampMap.local : 0;
+  const delta = mapCorrection - startMediaTime;
+  if (delta !== 0) {
+    for (const cue of frame.cues) {
+      cue.startTime += delta;
+      cue.endTime += delta;
+    }
+  }
+};
+
+/**
+ * Relocation text pipeline — the text analog of `relocationPipelinesFor(type)`.
+ * `resolveWithMetadata` (cues + `X-TIMESTAMP-MAP`) → `relocateCues` (shift by the
+ * primary A/V origin) → `dispatchCues`.
+ */
+export const relocatingTextPipelines = <C extends Cue>(): TextLoadStep<C>[] => [
+  resolveWithMetadataStep,
+  relocateCuesStep,
+  dispatchCuesStep,
+];
diff --git a/packages/spf/src/playback/primitives/segment-load-pipeline.ts b/packages/spf/src/playback/primitives/segment-load-pipeline.ts
new file mode 100644
index 00000000..6651cf7f
--- /dev/null
+++ b/packages/spf/src/playback/primitives/segment-load-pipeline.ts
@@ -0,0 +1,210 @@
+/**
+ * The v/a segment **load pipeline** — the step vocabulary and base steps a segment
+ * loader runs, extracted from the loader actor so the "what" (the composable steps)
+ * is separable from the "how" (the actor's scheduling). A pipeline is a per-op list
+ * of {@link LoadStep}s the loader drains in order; the default is `fetch → dispatch`,
+ * and a composition can insert its own steps between them (e.g. non-zero-PTS
+ * relocation) without the loader knowing.
+ *
+ * The base steps reach their SourceBuffer sink through the structural {@link AppendSink}
+ * seam rather than the concrete actor type — the loader folds the real actor into
+ * `config` at construction, and it satisfies the seam by structure — so this module
+ * carries no dependency on the actor implementation, and no dependency on the DOM.
+ */
+import type { AnySlotMap } from '../../core/composition/create-composition';
+import { effect } from '../../core/signals/effect';
+import type { ReadonlySignal } from '../../core/signals/primitives';
+import type { AddressableObject } from '../../media/types';
+import type {
+  AppendInitMessage,
+  AppendSegmentMessage,
+  IndividualSourceBufferMessage,
+  RemoveMessage,
+} from './source-buffer-messages';
+
+// ============================================================================
+// SINK SEAM
+// ============================================================================
+
+/**
+ * The structural view of a SourceBuffer sink the base steps use — just the ops
+ * {@link dispatchStep} needs (`send` + a `snapshot` to await idle). The concrete
+ * `SourceBufferActor` satisfies it by structure, so the pipeline names no actor.
+ */
+export interface AppendSink {
+  send(message: IndividualSourceBufferMessage): void;
+  snapshot: ReadonlySignal<{ value: string }>;
+}
+
+// ============================================================================
+// STEP MODEL
+// ============================================================================
+
+/**
+ * A LoadTask is the intent to perform one unit of SegmentLoader work.
+ * Unlike SourceBufferMessage, fetch-based tasks carry a URL rather than
+ * pre-fetched data — the runner fetches and appends them in sequence.
+ *
+ * Derived from SourceBufferMessage types by removing `data` and adding
+ * a fetch URL via AddressableObject.
+ *
+ * @todo Rename — "LoadTask" risks confusion with the `Task` class used for
+ * SourceBufferActor scheduling. These are closer to operation descriptors or
+ * messages than tasks in that sense.
+ */
+export type LoadTask =
+  | (Omit<AppendInitMessage, 'data'> & AddressableObject)
+  | (Omit<AppendSegmentMessage, 'data'> & AddressableObject)
+  | RemoveMessage;
+
+/**
+ * A {@link LoadTask} mid-reassembly into its append message. `LoadTask` is a
+ * message with `data` omitted and a URL added; the pipeline reverses that —
+ * `fetchStep` produces `data`, `dispatchStep` reassembles the message. `data` is
+ * the omitted payload (kept as the fetched stream — the loader never produces the
+ * `ArrayBuffer` arm of `SegmentData` — widened back at dispatch). `meta` overrides
+ * `op.meta` for `append-segment` (e.g. a stamped `timestampOffset`); an
+ * `append-init` dispatches `op.meta` directly.
+ */
+export interface Frame {
+  readonly op: LoadTask;
+  data?: AsyncIterable<Uint8Array>;
+  meta?: AppendSegmentMessage['meta'];
+}
+
+/**
+ * One stage of a message pipeline. Mutates the {@link Frame} in place and may be
+ * async; the runner checks `signal.aborted` before each step and passes the
+ * actor's {@link StepDeps} on every call, so a stateless step (e.g.
+ * {@link fetchStep}) is a plain value, and a step that needs composition signals
+ * (relocation's discover/stamp) reads them from `deps` at call time.
+ */
+export type LoadStep = (frame: Frame, signal: AbortSignal, deps: StepDeps) => void | Promise<void>;
+
+/**
+ * The uniform passthrough handed to every {@link LoadStep} on every call — the
+ * composition triple, nothing more. `state`/`context` are the full composition signal
+ * maps; `config` is the threaded config with the loader's own wiring folded in (see
+ * {@link stepWiring} + `createSegmentLoaderActor`). All three are typed loose: the
+ * loader is a conduit and never reads them; a step asserts the slots it knows are
+ * present (composition steps read `state`; base steps read the folded wiring off
+ * `config`).
+ */
+export interface StepDeps {
+  state: AnySlotMap;
+  context: AnySlotMap;
+  config: object;
+}
+
+/**
+ * Base-step view of the loader's own wiring. `createSegmentLoaderActor` folds its
+ * `sourceBufferActor` + `fetch` into the threaded `config` so base steps read them
+ * from the uniform passthrough — present whether the loader runs inside a composition
+ * or standalone. `config` is loose (`object`), so assert the shape here (one cast, like
+ * relocation's `containerSlot`).
+ */
+function stepWiring(deps: StepDeps): { sourceBufferActor: AppendSink; fetch: FetchBytes } {
+  return deps.config as { sourceBufferActor: AppendSink; fetch: FetchBytes };
+}
+
+/**
+ * Builds the ordered step list for each message type. Called **once per actor**
+ * — its role is per-actor instantiation, so stateful steps (relocation's origin
+ * discoverer) get fresh state per source reset; deps arrive at step-call time,
+ * not here. The default ({@link DEFAULT_MESSAGE_PIPELINES}) is `fetch → dispatch`;
+ * a non-zero-PTS composition returns a map that inserts its own discover/stamp
+ * steps between them (see `establishStartMediaTime`), so the loader stays oblivious
+ * to relocation and the Tier 0 pipeline carries no relocation vocabulary at all.
+ */
+export type MessagePipelines = () => Record<LoadTask['type'], LoadStep[]>;
+
+// ============================================================================
+// BASE STEPS
+// ============================================================================
+
+export type FetchBytes = (
+  addressable: AddressableObject,
+  options?: RequestInit & { minChunkSize?: number }
+) => Promise<AsyncIterable<Uint8Array>>;
+
+/**
+ * Resolves when the SourceBufferActor snapshot reaches 'idle'.
+ * Rejects if the signal is aborted or the actor is destroyed.
+ *
+ * Used to sequence SourceBufferActor operations without awaiting send()
+ * directly — send() is fire-and-forget; callers observe completion via
+ * state transition.
+ */
+function waitForIdle(snapshot: AppendSink['snapshot'], signal: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (snapshot.get().value === 'idle') {
+      resolve();
+      return;
+    }
+    if (snapshot.get().value === 'destroyed') {
+      reject(new DOMException('Aborted', 'AbortError'));
+      return;
+    }
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+
+    let stop: (() => void) | undefined;
+
+    const cleanup = (fn: () => void) => {
+      stop?.();
+      signal.removeEventListener('abort', onAbort);
+      fn();
+    };
+
+    const onAbort = () => cleanup(() => reject(signal.reason));
+
+    stop = effect(() => {
+      const value = snapshot.get().value;
+      if (value === 'idle') cleanup(resolve);
+      else if (value === 'destroyed') cleanup(() => reject(new DOMException('Aborted', 'AbortError')));
+    });
+
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+/** Build the SourceBuffer message a completed frame dispatches. `fetchStep` always precedes `dispatchStep` in append pipelines, so `data` is set by now. */
+function toMessage({ op, data, meta }: Frame): IndividualSourceBufferMessage {
+  switch (op.type) {
+    case 'remove':
+      return op;
+    case 'append-init':
+      return { type: 'append-init', data: data!, meta: op.meta };
+    case 'append-segment':
+      return { type: 'append-segment', data: data!, meta: meta ?? op.meta };
+  }
+}
+
+/**
+ * Fetch this op's bytes into the frame. Init segments need the full body
+ * (`minChunkSize: Infinity`) before appending; media segments stream so chunks
+ * append as they arrive. Awaiting headers eagerly also starts the HTTP
+ * connection (and records the fetch in observers like tests).
+ */
+export const fetchStep: LoadStep = async (frame, signal, deps) => {
+  const { op } = frame;
+  if (op.type === 'remove') return; // fetchStep only appears in append pipelines
+  const { fetch } = stepWiring(deps);
+  frame.data = await fetch(op, op.type === 'append-init' ? { signal, minChunkSize: Infinity } : { signal });
+};
+
+/** Dispatch the frame's message to the SourceBufferActor and await its return to idle. */
+export const dispatchStep: LoadStep = async (frame, signal, deps) => {
+  const { sourceBufferActor } = stepWiring(deps);
+  sourceBufferActor.send(toMessage(frame));
+  await waitForIdle(sourceBufferActor.snapshot, signal);
+};
+
+/** Tier 0 default: fetch (for ops that carry bytes) then dispatch. No relocation vocabulary. */
+export const DEFAULT_MESSAGE_PIPELINES: MessagePipelines = () => ({
+  remove: [dispatchStep],
+  'append-init': [fetchStep, dispatchStep],
+  'append-segment': [fetchStep, dispatchStep],
+});
diff --git a/packages/spf/src/playback/primitives/source-buffer-messages.ts b/packages/spf/src/playback/primitives/source-buffer-messages.ts
new file mode 100644
index 00000000..8bac1a58
--- /dev/null
+++ b/packages/spf/src/playback/primitives/source-buffer-messages.ts
@@ -0,0 +1,38 @@
+/**
+ * SourceBuffer sink message protocol — the operations a source-buffer sink accepts
+ * (`append-init` / `append-segment` / `remove`). Plain, transport-neutral data: the
+ * load pipeline (`segment-load-pipeline`) produces them and the SourceBuffer actor
+ * consumes them, so they live at the primitives layer both depend on rather than in
+ * either. DOM-free — the segment bytes are the generic {@link SegmentData}, and only the
+ * actor that hands them to a real `SourceBuffer` is DOM-bound.
+ */
+import type { Segment, SegmentData, Track } from '../../media/types';
+
+export type AppendSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & {
+  trackId: Track['id'];
+  /** Declared track bandwidth in bps (from playlist BANDWIDTH attribute). */
+  trackBandwidth?: number;
+  /**
+   * Non-zero-PTS relocation: when present, applied as `SourceBuffer.timestampOffset`
+   * before this append so native PTS is relocated onto a 0-based presentation
+   * timeline. A relocating composition stamps it (constant per source) onto each
+   * media segment's meta; the apply is idempotent-guarded. Absent = no relocation.
+   */
+  timestampOffset?: number;
+};
+
+export type AppendInitMessage = {
+  type: 'append-init';
+  data: SegmentData;
+  /**
+   * `language` is captured alongside `trackId` so downstream loaders can
+   * compare the buffered track's language to the newly-selected track's
+   * language and decide whether ahead-buffer flush is warranted on track
+   * switch (see `segment-loader`'s `planTasks`). Undefined for video and
+   * for audio without explicit `LANGUAGE` attribute.
+   */
+  meta: { trackId: Track['id']; language?: string };
+};
+export type AppendSegmentMessage = { type: 'append-segment'; data: SegmentData; meta: AppendSegmentMeta };
+export type RemoveMessage = { type: 'remove'; start: number; end: number };
+export type IndividualSourceBufferMessage = AppendInitMessage | AppendSegmentMessage | RemoveMessage;
diff --git a/packages/spf/src/playback/primitives/tests/relocation-pipelines.test.ts b/packages/spf/src/playback/primitives/tests/relocation-pipelines.test.ts
new file mode 100644
index 00000000..529284f6
--- /dev/null
+++ b/packages/spf/src/playback/primitives/tests/relocation-pipelines.test.ts
@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest';
+import { signal } from '../../../core/signals/primitives';
+import { initSegment, mediaSegment, trak } from '../../../media/mp4/tests/synthetic-boxes';
+import type { Cue, MaybeResolvedPresentation, MediaContainerData } from '../../../media/types';
+import { relocatingTextPipelines, relocationPipelinesFor } from '../relocation-pipelines';
+import type { Frame, StepDeps } from '../segment-load-pipeline';
+import type { TextFrame, TextStepDeps } from '../text-segment-load-pipeline';
+
+// A caption-first muxing: the `clcp` traf precedes the media traf, so a
+// first-`traf` read would pair the media track's timescale with the caption
+// track's baseMediaDecodeTime (300000/6000 = 50s) instead of its own
+// (60000/6000 = 10s). Track-id matching is what keeps the origin honest here.
+const captionFirstInit = initSegment(
+  trak({ handler: 'clcp', trackId: 2, timescale: 30000 }),
+  trak({ handler: 'vide', trackId: 1, timescale: 6000 })
+);
+const captionFirstSegment = mediaSegment(
+  { trackId: 2, baseMediaDecodeTime: 300000 }, // captions first
+  { trackId: 1, baseMediaDecodeTime: 60000 } // media track second
+);
+
+async function* streamOf(bytes: Uint8Array): AsyncIterable<Uint8Array> {
+  yield bytes;
+}
+
+function makeDeps(): {
+  deps: StepDeps;
+  slot: ReturnType<typeof signal<Record<string, MediaContainerData> | undefined>>;
+} {
+  const slot = signal<Record<string, MediaContainerData> | undefined>(undefined);
+  return { deps: { state: { mediaContainerData: slot }, context: {}, config: {} }, slot };
+}
+
+/** The discover steps at their pipeline positions: `[fetch, discover, dispatch]`. The
+ * derive is irrelevant here (only the stamp step consumes it), so a no-op suffices. */
+function discoverSteps(trackType: 'video' | 'audio') {
+  const pipelines = relocationPipelinesFor(trackType, () => ({}))();
+  return { readInitTrackInfo: pipelines['append-init'][1]!, readSegmentOrigin: pipelines['append-segment'][1]! };
+}
+
+describe('relocationPipelinesFor', () => {
+  it('matches the media track by track_id across a muxed init and segment', async () => {
+    const { deps, slot } = makeDeps();
+    const { readInitTrackInfo, readSegmentOrigin } = discoverSteps('video');
+    const signalNotAborted = new AbortController().signal;
+
+    const initFrame = {
+      op: { type: 'append-init', meta: { trackId: 'v', language: undefined }, url: 'init.mp4' },
+      data: streamOf(captionFirstInit),
+    } as unknown as Frame;
+    await readInitTrackInfo(initFrame, signalNotAborted, deps);
+
+    // The `vide` track — id 1, timescale 6000 — not the caption track (id 2).
+    expect(slot.get()?.video).toEqual({ trackId: 1, timescale: 6000 });
+
+    const segmentFrame = {
+      op: { type: 'append-segment', meta: { id: 's0', startTime: 0, duration: 6, trackId: 'v' } },
+      data: streamOf(captionFirstSegment),
+    } as unknown as Frame;
+    await readSegmentOrigin(segmentFrame, signalNotAborted, deps);
+
+    // Track 1's tfdt (60000), never the caption track's (300000).
+    const video = slot.get()?.video;
+    expect(video?.baseMediaDecodeTime).toBe(60000);
+    expect(video!.baseMediaDecodeTime! / video!.timescale!).toBe(10);
+  });
+
+  it('leaves the append native when the init has no matching media track', async () => {
+    const { deps, slot } = makeDeps();
+    const { readInitTrackInfo, readSegmentOrigin } = discoverSteps('audio');
+    const signalNotAborted = new AbortController().signal;
+
+    // Video-only muxing: no `soun` track for the audio pipeline to match.
+    const initFrame = {
+      op: { type: 'append-init', meta: { trackId: 'a', language: undefined }, url: 'init.mp4' },
+      data: streamOf(captionFirstInit),
+    } as unknown as Frame;
+    await readInitTrackInfo(initFrame, signalNotAborted, deps);
+    expect(slot.get()?.audio).toBeUndefined();
+
+    // Without a discovered track_id, the segment step no-ops (no origin to relocate by).
+    const segmentFrame = {
+      op: { type: 'append-segment', meta: { id: 's0', startTime: 0, duration: 6, trackId: 'a' } },
+      data: streamOf(captionFirstSegment),
+    } as unknown as Frame;
+    await readSegmentOrigin(segmentFrame, signalNotAborted, deps);
+    expect(slot.get()?.audio?.baseMediaDecodeTime).toBeUndefined();
+  });
+});
+
+describe('relocatingTextPipelines — relocateCues origin resolution', () => {
+  // relocateCues is the middle step: [resolveWithMetadata, relocateCues, dispatchCues].
+  const relocateCues = relocatingTextPipelines<Cue>()[1]!;
+  const notAborted = new AbortController().signal;
+
+  // Apple-style map: local 0 → MPEGTS 900000 (10s) ⇒ mapCorrection = 10.
+  const appleMap = { timestampMap: { mpegts: 900000, local: 0 } };
+
+  const presWithVideo = (startMediaTime: number | undefined): MaybeResolvedPresentation =>
+    ({
+      selectionSets: [{ type: 'video', switchingSets: [{ tracks: [{ id: 'v', type: 'video', startMediaTime }] }] }],
+    }) as unknown as MaybeResolvedPresentation;
+
+  const presTextOnly = (): MaybeResolvedPresentation =>
+    ({
+      selectionSets: [{ type: 'text', switchingSets: [{ tracks: [{ id: 't', type: 'text' }] }] }],
+    }) as unknown as MaybeResolvedPresentation;
+
+  const makeState = (presentation: MaybeResolvedPresentation) => ({
+    presentation: signal<MaybeResolvedPresentation | undefined>(presentation),
+    selectedVideoTrackId: signal<string | undefined>(undefined),
+    selectedAudioTrackId: signal<string | undefined>(undefined),
+  });
+
+  const cue = (startTime: number, endTime: number): Cue => ({ startTime, endTime, text: 'x' }) as unknown as Cue;
+
+  it('waits for the selected A/V origin instead of shifting cues by the full map correction', async () => {
+    // A/V exists but nothing selected yet — the race. Must WAIT, not resolve with 0
+    // (which would shift every cue by the full +10s mapCorrection).
+    const state = makeState(presWithVideo(undefined));
+    const deps = { state, context: {}, config: {} } as unknown as TextStepDeps;
+    const c = cue(5, 6);
+    const frame = { cues: [c], metadata: appleMap } as unknown as TextFrame<Cue>;
+
+    const done = relocateCues(frame, notAborted, deps);
+    await Promise.resolve();
+    expect(c.startTime).toBe(5); // still waiting — NOT shifted to 15
+
+    // Select the video track, then stamp its origin (10s, matching the map).
+    state.selectedVideoTrackId.set('v');
+    state.presentation.set(presWithVideo(10));
+    await done;
+
+    // delta = mapCorrection(10) − startMediaTime(10) = 0 ⇒ cue unchanged.
+    expect(c.startTime).toBe(5);
+    expect(c.endTime).toBe(6);
+  });
+
+  it('relocates a genuinely text-only source by offset 0 without hanging', async () => {
+    // No A/V tracks ⇒ no origin will ever come; resolve immediately with startMediaTime 0.
+    const state = makeState(presTextOnly());
+    const deps = { state, context: {}, config: {} } as unknown as TextStepDeps;
+    const c = cue(5, 6);
+    const frame = { cues: [c], metadata: appleMap } as unknown as TextFrame<Cue>;
+
+    await relocateCues(frame, notAborted, deps);
+
+    // delta = mapCorrection(10) − 0 = 10.
+    expect(c.startTime).toBe(15);
+    expect(c.endTime).toBe(16);
+  });
+});
diff --git a/packages/spf/src/playback/primitives/text-segment-load-pipeline.ts b/packages/spf/src/playback/primitives/text-segment-load-pipeline.ts
new file mode 100644
index 00000000..c17ab7fd
--- /dev/null
+++ b/packages/spf/src/playback/primitives/text-segment-load-pipeline.ts
@@ -0,0 +1,161 @@
+/**
+ * The text-track **load pipeline** — the step vocabulary and base steps a text-segment
+ * loader runs, the text mirror of `segment-load-pipeline`. Extracted from the loader
+ * actor so the "what" (the composable steps) is separable from the "how" (scheduling).
+ * A pipeline is a flat, ordered list of {@link TextLoadStep}s (text has a single op
+ * type, so no per-type `Record`); the default is `resolveCues → dispatchCues`, and a
+ * composition can insert its own steps (e.g. non-zero-PTS cue rebase) without the
+ * loader knowing.
+ *
+ * The dispatch step reaches its cue sink through the structural {@link CueSink} seam
+ * rather than the concrete `TextTracksActor` type — the loader folds the real actor
+ * into `config`, and it satisfies the seam by structure — so this module names no
+ * actor and stays DOM-free (generic over the cue type `C`).
+ */
+import type { AnySlotMap } from '../../core/composition/create-composition';
+import type { Cue, Segment } from '../../media/types';
+import type { AddCuesMessage } from './text-track-messages';
+
+// ============================================================================
+// SINK SEAM
+// ============================================================================
+
+/**
+ * The structural view of a cue sink the base steps use — just the `send`
+ * {@link dispatchCuesStep} needs. The concrete `TextTracksActor` satisfies it by
+ * structure, so the pipeline names no actor.
+ */
+export interface CueSink<C extends Cue = Cue> {
+  send(message: AddCuesMessage<C>): void;
+}
+
+// ============================================================================
+// STEP MODEL
+// ============================================================================
+
+/**
+ * Resolves a text-track segment URL into the array of cues it contains.
+ *
+ * "Resolve" because the fn covers both network fetch and parse into the
+ * domain model. Host-agnostic — the concrete resolver (e.g. the
+ * browser's native VTT resolver) is supplied at engine-assembly time,
+ * so this stays DOM-free. A pure `url → cues` primitive (the text
+ * analog of the v/a loader's `fetchBytes`); composition-awareness lives in
+ * the injected {@link TextLoadStep}s, not here.
+ */
+export type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;
+
+/** Internal load-task descriptor — one segment fetch + dispatch unit. */
+export interface TextLoadTask {
+  segment: Segment;
+  trackId: string;
+}
+
+/**
+ * A text load in mid-pipeline — the text analog of the v/a loader's `Frame`.
+ * `resolveCuesStep` fills `cues`; `dispatchCuesStep` sends them. `metadata` is
+ * opaque header metadata a resolve step may attach for a later step to read
+ * (e.g. relocation stashes the `X-TIMESTAMP-MAP` correlation here for its rebase
+ * step). Typed `unknown` so the generic loader stays host-agnostic — the step
+ * that reads it knows its concrete shape (mirrors `StepDeps.state`).
+ */
+export interface TextFrame<C extends Cue = Cue> {
+  readonly op: TextLoadTask;
+  cues?: C[];
+  metadata?: unknown;
+}
+
+/**
+ * One stage of a text message pipeline — the text analog of the v/a loader's
+ * `LoadStep`. Mutates the {@link TextFrame} in place and may be async; the runner
+ * checks `signal.aborted` before each step and passes the actor's
+ * {@link TextStepDeps} on every call, so a stateless step (`resolveCuesStep`) is a
+ * plain value and a step that needs composition signals (relocation's cue rebase)
+ * reads them from `deps` at call time.
+ */
+export type TextLoadStep<C extends Cue = Cue> = (
+  frame: TextFrame<C>,
+  signal: AbortSignal,
+  deps: TextStepDeps
+) => void | Promise<void>;
+
+/**
+ * The uniform passthrough handed to each {@link TextLoadStep} — the composition triple,
+ * the text analog of `StepDeps`. `state`/`context` are the composition signal maps;
+ * `config` is the threaded config with the loader's wiring folded in (see
+ * {@link textStepWiring} + `createTextTrackSegmentLoaderActor`). Typed loose: composition
+ * steps read `state`; base steps read the folded wiring off `config`.
+ */
+export interface TextStepDeps {
+  state: AnySlotMap;
+  context: AnySlotMap;
+  config: object;
+}
+
+/**
+ * Base-step view of the loader's wiring, folded into `config` by
+ * `createTextTrackSegmentLoaderActor` so base steps read it from the uniform passthrough
+ * — present in both composition and standalone use. `config` is loose (`object`), so
+ * assert the shape here (mirrors the v/a loader's `stepWiring`). The sink is the
+ * structural {@link CueSink}, not the concrete actor.
+ */
+export function textStepWiring<C extends Cue>(
+  deps: TextStepDeps
+): { textTracksActor: CueSink<C>; resolveSegment: TextTrackSegmentResolver<C> } {
+  return deps.config as { textTracksActor: CueSink<C>; resolveSegment: TextTrackSegmentResolver<C> };
+}
+
+/**
+ * Builds the ordered step list, called **once per actor** (mirrors the v/a loader's
+ * `MessagePipelines`, but text has a single op type so it's a flat array, not a
+ * `Record`). The default ({@link DEFAULT_TEXT_MESSAGE_PIPELINES}) is
+ * `resolveCues → dispatchCues`; a non-zero-PTS composition returns a list that
+ * inserts a cue-rebase step (see `relocatingTextPipelines`), so the loader stays
+ * oblivious to relocation.
+ */
+export type TextMessagePipelines<C extends Cue = Cue> = () => TextLoadStep<C>[];
+
+// ============================================================================
+// BASE STEPS
+// ============================================================================
+
+// Base steps are generic over the cue type `C` (generic arrow consts, not
+// `TextLoadStep<Cue>` values): each touches `C` — `frame.cues: C[]` and the
+// `C`-typed `textStepWiring<C>` — so a `Cue`-typed const wouldn't slot into a
+// `VTTCue` pipeline. A generic function assigns to any `TextLoadStep<C>`.
+
+/** Resolve the op's cues (via the injected host primitive) into the frame. The text analog of `fetchStep`. */
+export const resolveCuesStep = async <C extends Cue>(
+  frame: TextFrame<C>,
+  signal: AbortSignal,
+  deps: TextStepDeps
+): Promise<void> => {
+  const cues = await textStepWiring<C>(deps).resolveSegment(frame.op.segment.url);
+  if (signal.aborted) return;
+  frame.cues = cues;
+};
+
+/** Dispatch the frame's cues to the TextTracksActor as `add-cues`. The text analog of `dispatchStep`. */
+export const dispatchCuesStep = <C extends Cue>(
+  frame: TextFrame<C>,
+  _signal: AbortSignal,
+  deps: TextStepDeps
+): void => {
+  const { op } = frame;
+  textStepWiring<C>(deps).textTracksActor.send({
+    type: 'add-cues',
+    meta: {
+      trackId: op.trackId,
+      id: op.segment.id,
+      startTime: op.segment.startTime,
+      duration: op.segment.duration,
+    },
+    cues: frame.cues ?? [],
+  });
+};
+
+/** Tier 0 default: resolve then dispatch. No relocation vocabulary. */
+export const DEFAULT_TEXT_MESSAGE_PIPELINES = <C extends Cue>(): TextLoadStep<C>[] => [
+  resolveCuesStep,
+  dispatchCuesStep,
+];
diff --git a/packages/spf/src/playback/primitives/text-track-messages.ts b/packages/spf/src/playback/primitives/text-track-messages.ts
new file mode 100644
index 00000000..6eecb329
--- /dev/null
+++ b/packages/spf/src/playback/primitives/text-track-messages.ts
@@ -0,0 +1,16 @@
+/**
+ * Cue-sink message protocol — the `add-cues` operation a text-track sink accepts.
+ * Plain, transport-neutral data: the text load pipeline (`text-segment-load-pipeline`)
+ * produces it and the TextTracksActor consumes it, so it lives at the primitives layer
+ * both depend on. The text mirror of `source-buffer-messages`.
+ */
+import type { Cue, Segment } from '../../media/types';
+
+/** Segment identity and timing — mirrors AppendSegmentMeta without trackId (keyed separately). */
+export type CueSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & { trackId: string };
+
+export interface AddCuesMessage<C extends Cue = Cue> {
+  type: 'add-cues';
+  meta: CueSegmentMeta;
+  cues: C[];
+}