@videojs/spf 10.0.0-beta.9 → 10.0.0-rc.2

package/dist/default/playback/behaviors/dom/track-playback-rate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-playback-rate.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-playback-rate.ts"],"sourcesContent":["/**\n * Mirror `mediaElement.playbackRate` into reactive state. On each `ratechange` event, write the new value to\n * `state.playbackRate`. Also syncs immediately when a media element becomes available so consumers don't wait for the\n * first event.\n *\n * When no media element is attached, writes `config.defaultPlaybackRate` (default-default `1`, matching the\n * HTMLMediaElement spec) so consumers always see the rate a freshly attached element would have. Read-only mirror; does\n * not push `state.playbackRate` back to the element.\n */\nimport { listen } from '@videojs/utils/dom';\n\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\n\nexport interface PlaybackRateState {\n  playbackRate?: number;\n}\n\nexport interface PlaybackRateContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface TrackPlaybackRateConfig {\n  /**\n   * Value written to `state.playbackRate` when no media element is attached. Defaults to `1` — the HTMLMediaElement\n   * spec default.\n   */\n  defaultPlaybackRate?: number;\n}\n\nfunction trackPlaybackRateSetup({\n  state,\n  context,\n  config,\n}: {\n  state: { playbackRate: Signal<PlaybackRateState['playbackRate']> };\n  context: { mediaElement: ReadonlySignal<PlaybackRateContext['mediaElement']> };\n  config?: TrackPlaybackRateConfig;\n}): () => void {\n  const defaultPlaybackRate = config?.defaultPlaybackRate ?? 1;\n\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n\n    if (!mediaElement) {\n      state.playbackRate.set(defaultPlaybackRate);\n      return;\n    }\n\n    const sync = () => state.playbackRate.set(mediaElement.playbackRate);\n\n    sync();\n\n    return listen(mediaElement, 'ratechange', sync);\n  });\n}\n\nexport const trackPlaybackRate = defineBehavior({\n  stateKeys: ['playbackRate'],\n  contextKeys: ['mediaElement'],\n  setup: trackPlaybackRateSetup,\n});\n"],"mappings":";;;;;;;;;;;;;AA+BA,SAAS,uBAAuB,EAC9B,OACA,SACA,UAKa;CACb,MAAM,sBAAsB,QAAQ,uBAAuB;CAE3D,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAE9C,IAAI,CAAC,cAAc;GACjB,MAAM,aAAa,IAAI,mBAAmB;GAC1C;EACF;EAEA,MAAM,aAAa,MAAM,aAAa,IAAI,aAAa,YAAY;EAEnE,KAAK;EAEL,OAAO,OAAO,cAAc,cAAc,IAAI;CAChD,CAAC;AACH;AAEA,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/dom/track-player-resolution.js

@@ -0,0 +1,53 @@
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+import { scaleResolution } from "../../../media/primitives/resolution.js";
+import { observeElementSize, observeRenderedSize } from "@videojs/utils/dom";
+import { shallowEqual } from "@videojs/utils/object";
+//#region src/playback/behaviors/dom/track-player-resolution.ts
+/**
+* Mirror the player element's rendered pixel dimensions into reactive state, so a rendition cap can narrow candidates
+* to what the element can actually show without reading the DOM at pick time — which would make the picker impure, and
+* would never re-pick when the element resized.
+*
+* The player-element half of the caps in `internal/design/spf/features/rendition-selection-caps.md`, and the tighter
+* half: a small embed on a large display is capped by its own box rather than by the screen behind it
+* (`trackScreenResolution`).
+*
+* Reported as a width and a height in device pixels — the same units, and for the same reason, as `media/dom/screen`'s
+* reading: the cap compares against real track dimensions, and a `"720p"`-style tier only describes a track once you
+* assume its aspect ratio.
+*
+* `undefined` where there is nothing to measure — no element attached, or one that isn't being rendered (detached,
+* `display: none`, not yet laid out) — which is the value the cap reads as "don't cap".
+*/
+function trackPlayerResolutionSetup({ state, context, config = {} }) {
+	const { capRenditionToPlayerSize = true, useDevicePixelRatio = true } = config;
+	return effect(() => {
+		const mediaElement = context.mediaElement.get();
+		let current;
+		state.playerResolution.set(current);
+		if (!capRenditionToPlayerSize || !mediaElement) return;
+		const write = (size) => {
+			const next = scaleResolution(size, size.scale);
+			if (shallowEqual(current, next)) return;
+			current = next;
+			state.playerResolution.set(next);
+		};
+		return useDevicePixelRatio ? observeRenderedSize(mediaElement, write) : observeElementSize(mediaElement, write);
+	});
+}
+/**
+* Track the player element's rendered resolution in `state.playerResolution`.
+*
+* @example
+*   const cleanup = trackPlayerResolution.setup({ state, context });
+*/
+const trackPlayerResolution = defineBehavior({
+	stateKeys: ["playerResolution"],
+	contextKeys: ["mediaElement"],
+	setup: trackPlayerResolutionSetup
+});
+//#endregion
+export { trackPlayerResolution };
+
+//# sourceMappingURL=track-player-resolution.js.map

package/dist/default/playback/behaviors/dom/track-player-resolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-player-resolution.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-player-resolution.ts"],"sourcesContent":["/**\n * Mirror the player element's rendered pixel dimensions into reactive state, so a rendition cap can narrow candidates\n * to what the element can actually show without reading the DOM at pick time — which would make the picker impure, and\n * would never re-pick when the element resized.\n *\n * The player-element half of the caps in `internal/design/spf/features/rendition-selection-caps.md`, and the tighter\n * half: a small embed on a large display is capped by its own box rather than by the screen behind it\n * (`trackScreenResolution`).\n *\n * Reported as a width and a height in device pixels — the same units, and for the same reason, as `media/dom/screen`'s\n * reading: the cap compares against real track dimensions, and a `\"720p\"`-style tier only describes a track once you\n * assume its aspect ratio.\n *\n * `undefined` where there is nothing to measure — no element attached, or one that isn't being rendered (detached,\n * `display: none`, not yet laid out) — which is the value the cap reads as \"don't cap\".\n */\n\nimport { type ElementSize, observeElementSize, observeRenderedSize } from '@videojs/utils/dom';\nimport { shallowEqual } from '@videojs/utils/object';\n\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\nimport { type Resolution, scaleResolution } from '../../../media/primitives/resolution';\n\n/** A player element's rendered pixel dimensions. */\nexport type PlayerResolution = Resolution;\n\nexport interface PlayerResolutionState {\n  playerResolution?: PlayerResolution;\n}\n\nexport interface PlayerResolutionContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface TrackPlayerResolutionConfig {\n  /**\n   * Whether to cap renditions to the player's rendered size at all. `false` measures nothing, which leaves\n   * `state.playerResolution` unset and the cap inert. Defaults to `true`.\n   *\n   * Named for the policy rather than the measurement because it is the public switch for the feature — the same one\n   * hls.js spells `capLevelToPlayerSize` and the Mux Video element spells `cap-rendition-to-player-size`.\n   */\n  capRenditionToPlayerSize?: boolean;\n  /**\n   * Whether the reading is scaled into device pixels. Defaults to `true` — see\n   * `ScreenResolutionOptions.useDevicePixelRatio` in `media/dom/screen.ts`, including its note on page zoom being\n   * folded into the ratio outside WebKit.\n   */\n  useDevicePixelRatio?: boolean;\n}\n\nfunction trackPlayerResolutionSetup({\n  state,\n  context,\n  config = {},\n}: {\n  state: { playerResolution: Signal<PlayerResolutionState['playerResolution']> };\n  context: { mediaElement: ReadonlySignal<PlayerResolutionContext['mediaElement']> };\n  config?: TrackPlayerResolutionConfig;\n}): () => void {\n  const { capRenditionToPlayerSize = true, useDevicePixelRatio = true } = config;\n\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    // Clear before (re-)observing so the previous element's measurement can't\n    // stand while the new one's first observation is in flight.\n    let current: PlayerResolution | undefined;\n\n    state.playerResolution.set(current);\n\n    if (!capRenditionToPlayerSize || !mediaElement) return;\n\n    // Compared rather than written straight through, since the slot holds an\n    // object and would otherwise notify on identity alone: a resize that rounds\n    // to the same device pixels is not a change worth re-running selection for.\n    // Same reason `watchScreenResolution` compares its readings.\n    const write = (size: ElementSize & { scale?: number }) => {\n      const next = scaleResolution(size, size.scale);\n      if (shallowEqual(current, next)) return;\n\n      current = next;\n      state.playerResolution.set(next);\n    };\n\n    return useDevicePixelRatio ? observeRenderedSize(mediaElement, write) : observeElementSize(mediaElement, write);\n  });\n}\n\n/**\n * Track the player element's rendered resolution in `state.playerResolution`.\n *\n * @example\n *   const cleanup = trackPlayerResolution.setup({ state, context });\n */\nexport const trackPlayerResolution = defineBehavior({\n  stateKeys: ['playerResolution'],\n  contextKeys: ['mediaElement'],\n  setup: trackPlayerResolutionSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqDA,SAAS,2BAA2B,EAClC,OACA,SACA,SAAS,CAAC,KAKG;CACb,MAAM,EAAE,2BAA2B,MAAM,sBAAsB,SAAS;CAExE,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAG9C,IAAI;EAEJ,MAAM,iBAAiB,IAAI,OAAO;EAElC,IAAI,CAAC,4BAA4B,CAAC,cAAc;EAMhD,MAAM,SAAS,SAA2C;GACxD,MAAM,OAAO,gBAAgB,MAAM,KAAK,KAAK;GAC7C,IAAI,aAAa,SAAS,IAAI,GAAG;GAEjC,UAAU;GACV,MAAM,iBAAiB,IAAI,IAAI;EACjC;EAEA,OAAO,sBAAsB,oBAAoB,cAAc,KAAK,IAAI,mBAAmB,cAAc,KAAK;CAChH,CAAC;AACH;;;;;;;AAQA,MAAa,wBAAwB,eAAe;CAClD,WAAW,CAAC,kBAAkB;CAC9B,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/dom/track-screen-resolution.js

@@ -0,0 +1,28 @@
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { watchScreenResolution } from "../../../media/dom/screen.js";
+//#region src/playback/behaviors/dom/track-screen-resolution.ts
+/**
+* Mirror the screen's pixel dimensions into reactive state, so a rendition cap can narrow candidates to what the screen
+* can actually show without reading the environment at pick time — which would make the picker impure, and would never
+* re-pick when the screen changed.
+*
+* Populated at setup rather than on the first change: `watchScreenResolution` reports its starting value, so nothing
+* downstream waits on a screen that may never move. `undefined` where there is no screen to read, which is the value a
+* cap reads as "no cap" — see `getScreenResolution` on why that beats a zero.
+*
+* Reads no other slot, and has no source-identity reset: the screen is independent of the presentation, so a new `src`
+* doesn't invalidate the reading.
+*/
+function trackScreenResolutionSetup({ state, config }) {
+	const useDevicePixelRatio = config?.useDevicePixelRatio ?? true;
+	return watchScreenResolution((resolution) => state.screenResolution.set(resolution), { useDevicePixelRatio });
+}
+const trackScreenResolution = defineBehavior({
+	stateKeys: ["screenResolution"],
+	contextKeys: [],
+	setup: trackScreenResolutionSetup
+});
+//#endregion
+export { trackScreenResolution };
+
+//# sourceMappingURL=track-screen-resolution.js.map

package/dist/default/playback/behaviors/dom/track-screen-resolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-screen-resolution.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-screen-resolution.ts"],"sourcesContent":["/**\n * Mirror the screen's pixel dimensions into reactive state, so a rendition cap can narrow candidates to what the screen\n * can actually show without reading the environment at pick time — which would make the picker impure, and would never\n * re-pick when the screen changed.\n *\n * Populated at setup rather than on the first change: `watchScreenResolution` reports its starting value, so nothing\n * downstream waits on a screen that may never move. `undefined` where there is no screen to read, which is the value a\n * cap reads as \"no cap\" — see `getScreenResolution` on why that beats a zero.\n *\n * Reads no other slot, and has no source-identity reset: the screen is independent of the presentation, so a new `src`\n * doesn't invalidate the reading.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Signal } from '../../../core/signals/primitives';\nimport { type ScreenResolution, watchScreenResolution } from '../../../media/dom/screen';\n\nexport interface ScreenResolutionState {\n  screenResolution?: ScreenResolution;\n}\n\nexport interface TrackScreenResolutionConfig {\n  /**\n   * Whether the reading is scaled into device pixels. Defaults to `true` — see\n   * `ScreenResolutionOptions.useDevicePixelRatio`, including its note on page zoom being folded into the ratio outside\n   * WebKit.\n   */\n  useDevicePixelRatio?: boolean;\n}\n\nfunction trackScreenResolutionSetup({\n  state,\n  config,\n}: {\n  state: { screenResolution: Signal<ScreenResolutionState['screenResolution']> };\n  config?: TrackScreenResolutionConfig;\n}): () => void {\n  const useDevicePixelRatio = config?.useDevicePixelRatio ?? true;\n\n  // No `effect` wrapper, unlike its `track*` siblings: they re-subscribe when\n  // `context.mediaElement` changes, and this behavior has no reactive dependency\n  // to re-run on. The watcher's own teardown is the whole cleanup.\n  return watchScreenResolution((resolution) => state.screenResolution.set(resolution), { useDevicePixelRatio });\n}\n\nexport const trackScreenResolution = defineBehavior({\n  stateKeys: ['screenResolution'],\n  contextKeys: [],\n  setup: trackScreenResolutionSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;AA6BA,SAAS,2BAA2B,EAClC,OACA,UAIa;CACb,MAAM,sBAAsB,QAAQ,uBAAuB;CAK3D,OAAO,uBAAuB,eAAe,MAAM,iBAAiB,IAAI,UAAU,GAAG,EAAE,oBAAoB,CAAC;AAC9G;AAEA,MAAa,wBAAwB,eAAe;CAClD,WAAW,CAAC,kBAAkB;CAC9B,aAAa,CAAC;CACd,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/dom/update-mediasource-duration.js

@@ -0,0 +1,98 @@
+import { computed } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { waitForMediaSourceOpen } from "../../../media/dom/mse/mediasource-setup.js";
+import { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady } from "../../../media/dom/mse/duration.js";
+//#region src/playback/behaviors/dom/update-mediasource-duration.ts
+/**
+* **Propagate `presentation.duration` to `mediaSource.duration` — exactly once per MediaSource.**
+*
+* Two paths, by whether the presentation is live:
+*
+* - **Live** (`presentation.duration === Infinity`): write `Infinity` once the MediaSource is open and no SourceBuffer is
+*   mid-append. No buffered clamp is needed (`Infinity` ≥ any range) and — unlike the finite case — it needn't precede
+*   the first append: `Infinity` overrides whatever finite live-edge value an append may have pinned (a finite duration
+*   would otherwise stall the stream once the window slides past it). The wait-for-idle is required because the MSE
+*   spec forbids setting `duration` while a buffer is `updating`; both waits resolve immediately when already open /
+*   idle.
+* - **VoD** (finite): the value is written once, after `mediaSource` is open and all SourceBuffers are idle, clamped to
+*   be ≥ the highest buffered range (MSE spec). Written only while `mediaSource.duration` is still `NaN`; once any
+*   non-NaN value is present (us on a prior entry, or `endOfStream` from the buffered end), the property is left alone
+*   — re-syncing would race concurrent `appendBuffer()` calls.
+*
+* The entry resolves three async preconditions in order before writing:
+*
+* 1. **MediaSource open** — `waitForMediaSourceOpen` defers until the first `sourceopen` event (or any readyState
+*    transition, since `'ended'` / `'closed'` mean we've missed the window and should bail).
+* 2. **All SourceBuffers idle** — `waitForSourceBuffersReady` defers per the MSE-spec rule that `duration` cannot be set
+*    while any buffer has `updating === true`.
+* 3. **Buffered-range clamp** — `getMaxBufferedEnd` ensures the written duration is at least the highest buffered end (MSE
+*    spec disallows a smaller `duration` than any buffered range).
+*
+* The buffer-set helpers operate across `mediaSource.sourceBuffers` (the canonical aggregate), so the behavior composes
+* uniformly across audio-only, video-only, and mixed configurations.
+*
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'duration-writable'`): state derivation is purely
+* signal-driven (presentation validity + mediaSource existence). MediaSource lifecycle state (`readyState`) and the
+* `duration` itself are non-signal DOM properties resolved inside the entry's async sequence. The state-exit cleanup
+* aborts the in-flight wait, so source resets and behavior destroy structurally cancel the pending write. A post-await
+* re-check of `mediaSource.readyState === 'open'` covers the narrow race where `endOfStream()` synchronously
+* transitions readyState to `'ended'` between our `waitForMediaSourceOpen` resolution and the `mediaSource.duration`
+* write.
+*
+* Downstream of `calculatePresentationDuration` (which writes `presentation.duration`); concurrent with `endOfStream`
+* (which may later write `mediaSource.duration` — the "exactly once" contract keeps us out of that path).
+*/
+function deriveState(presentation, mediaSource) {
+	return shouldUpdateDuration(presentation, mediaSource) ? "duration-writable" : "preconditions-unmet";
+}
+function updateMediaSourceDurationSetup({ state, context }) {
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaSource.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"duration-writable": { entry: () => {
+				const presentation = state.presentation.get();
+				const mediaSource = context.mediaSource.get();
+				if (presentation.duration === Number.POSITIVE_INFINITY) {
+					if (mediaSource.duration === Number.POSITIVE_INFINITY) return;
+					const controller = new AbortController();
+					(async () => {
+						await waitForMediaSourceOpen(mediaSource, controller.signal);
+						if (controller.signal.aborted || mediaSource.readyState !== "open") return;
+						await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);
+						if (controller.signal.aborted || mediaSource.readyState !== "open") return;
+						if (mediaSource.duration !== Number.POSITIVE_INFINITY) mediaSource.duration = Number.POSITIVE_INFINITY;
+					})();
+					return () => controller.abort();
+				}
+				if (!Number.isNaN(mediaSource.duration)) return;
+				const controller = new AbortController();
+				const writeWhenReady = async () => {
+					await waitForMediaSourceOpen(mediaSource, controller.signal);
+					if (controller.signal.aborted) return;
+					if (mediaSource.readyState !== "open") return;
+					await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);
+					if (controller.signal.aborted) return;
+					if (mediaSource.readyState !== "open") return;
+					const maxBufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);
+					const duration = maxBufferedEnd > presentation.duration ? maxBufferedEnd : presentation.duration;
+					mediaSource.duration = duration;
+				};
+				writeWhenReady();
+				return () => controller.abort();
+			} }
+		}
+	});
+}
+const updateMediaSourceDuration = defineBehavior({
+	stateKeys: ["presentation"],
+	contextKeys: ["mediaSource"],
+	setup: updateMediaSourceDurationSetup
+});
+//#endregion
+export { updateMediaSourceDuration };
+
+//# sourceMappingURL=update-mediasource-duration.js.map

package/dist/default/playback/behaviors/dom/update-mediasource-duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-mediasource-duration.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/update-mediasource-duration.ts"],"sourcesContent":["/**\n * **Propagate `presentation.duration` to `mediaSource.duration` — exactly once per MediaSource.**\n *\n * Two paths, by whether the presentation is live:\n *\n * - **Live** (`presentation.duration === Infinity`): write `Infinity` once the MediaSource is open and no SourceBuffer is\n *   mid-append. No buffered clamp is needed (`Infinity` ≥ any range) and — unlike the finite case — it needn't precede\n *   the first append: `Infinity` overrides whatever finite live-edge value an append may have pinned (a finite duration\n *   would otherwise stall the stream once the window slides past it). The wait-for-idle is required because the MSE\n *   spec forbids setting `duration` while a buffer is `updating`; both waits resolve immediately when already open /\n *   idle.\n * - **VoD** (finite): the value is written once, after `mediaSource` is open and all SourceBuffers are idle, clamped to\n *   be ≥ the highest buffered range (MSE spec). Written only while `mediaSource.duration` is still `NaN`; once any\n *   non-NaN value is present (us on a prior entry, or `endOfStream` from the buffered end), the property is left alone\n *   — re-syncing would race concurrent `appendBuffer()` calls.\n *\n * The entry resolves three async preconditions in order before writing:\n *\n * 1. **MediaSource open** — `waitForMediaSourceOpen` defers until the first `sourceopen` event (or any readyState\n *    transition, since `'ended'` / `'closed'` mean we've missed the window and should bail).\n * 2. **All SourceBuffers idle** — `waitForSourceBuffersReady` defers per the MSE-spec rule that `duration` cannot be set\n *    while any buffer has `updating === true`.\n * 3. **Buffered-range clamp** — `getMaxBufferedEnd` ensures the written duration is at least the highest buffered end (MSE\n *    spec disallows a smaller `duration` than any buffered range).\n *\n * The buffer-set helpers operate across `mediaSource.sourceBuffers` (the canonical aggregate), so the behavior composes\n * uniformly across audio-only, video-only, and mixed configurations.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'duration-writable'`): state derivation is purely\n * signal-driven (presentation validity + mediaSource existence). MediaSource lifecycle state (`readyState`) and the\n * `duration` itself are non-signal DOM properties resolved inside the entry's async sequence. The state-exit cleanup\n * aborts the in-flight wait, so source resets and behavior destroy structurally cancel the pending write. A post-await\n * re-check of `mediaSource.readyState === 'open'` covers the narrow race where `endOfStream()` synchronously\n * transitions readyState to `'ended'` between our `waitForMediaSourceOpen` resolution and the `mediaSource.duration`\n * write.\n *\n * Downstream of `calculatePresentationDuration` (which writes `presentation.duration`); concurrent with `endOfStream`\n * (which may later write `mediaSource.duration` — the \"exactly once\" contract keeps us out of that path).\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal } from '../../../core/signals/primitives';\nimport { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady } from '../../../media/dom/mse/duration';\nimport { waitForMediaSourceOpen } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\n\ntype DurationFsmState = 'preconditions-unmet' | 'duration-writable';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): DurationFsmState {\n  return shouldUpdateDuration(presentation, mediaSource) ? 'duration-writable' : 'preconditions-unmet';\n}\n\nfunction updateMediaSourceDurationSetup({\n  state,\n  context,\n}: {\n  state: { presentation: ReadonlySignal<MaybeResolvedPresentation | undefined> };\n  context: { mediaSource: ReadonlySignal<MediaSource | undefined> };\n}): Reactor<DurationFsmState | 'destroying' | 'destroyed'> {\n  // Purely signal-driven derivation: only `presentation` validity and\n  // `mediaSource` existence. MediaSource lifecycle (`readyState`),\n  // its attached `sourceBuffers`, and `mediaSource.duration` itself are\n  // non-signal DOM properties consumed inside the entry — none of them\n  // sneak into `computed(...)`.\n  const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaSource.get()));\n\n  return createMachineReactor<DurationFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'duration-writable': {\n        // entry body is auto-untracked. The state machine handles source\n        // resets via deriveState; this entry resolves the MediaSource\n        // lifecycle preconditions in sequence and binds its cleanup\n        // (abort) to state exit + destroy.\n        entry: () => {\n          const presentation = state.presentation.get()!;\n          const mediaSource = context.mediaSource.get()!;\n\n          // Live: write Infinity once the MediaSource is open and no buffer is\n          // mid-append (the MSE spec forbids setting `duration` while a\n          // SourceBuffer is `updating`, and racing an in-flight append throws).\n          // No `NaN` guard, unlike the VoD path below — Infinity must override\n          // whatever finite live-edge value an append may have pinned.\n          if (presentation.duration === Number.POSITIVE_INFINITY) {\n            if (mediaSource.duration === Number.POSITIVE_INFINITY) return;\n\n            const controller = new AbortController();\n\n            void (async () => {\n              await waitForMediaSourceOpen(mediaSource, controller.signal);\n\n              if (controller.signal.aborted || mediaSource.readyState !== 'open') return;\n\n              await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n\n              if (controller.signal.aborted || mediaSource.readyState !== 'open') return;\n\n              if (mediaSource.duration !== Number.POSITIVE_INFINITY) {\n                mediaSource.duration = Number.POSITIVE_INFINITY;\n              }\n            })();\n            return () => controller.abort();\n          }\n\n          // VoD idempotency: someone (us on a prior entry, or concurrent\n          // `endOfStream`) has already written. No-op and leave the state\n          // alone — the next source-reset transition will produce a fresh\n          // entry against the new MediaSource (whose `duration` starts at\n          // `NaN` again).\n          if (!Number.isNaN(mediaSource.duration)) return;\n\n          const controller = new AbortController();\n\n          const writeWhenReady = async () => {\n            await waitForMediaSourceOpen(mediaSource, controller.signal);\n\n            if (controller.signal.aborted) return;\n\n            // `waitForMediaSourceOpen` resolves on any readyState transition\n            // out of 'closed'; if we landed in 'ended' / 'closed' instead of\n            // 'open', the write window is gone.\n            if (mediaSource.readyState !== 'open') return;\n\n            await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n\n            if (controller.signal.aborted) return;\n\n            // Narrow race: `endOfStream()` synchronously transitions\n            // readyState to 'ended' AND writes `mediaSource.duration`\n            // between our `waitForMediaSourceOpen` resolution and here.\n            // Re-read the DOM property to catch this window.\n            if (mediaSource.readyState !== 'open') return;\n\n            // MSE spec: duration cannot be less than any buffered range.\n            // Re-read sourceBuffers after the await so any buffer added\n            // during the wait is included in the clamp.\n            const maxBufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);\n            const duration = maxBufferedEnd > presentation.duration! ? maxBufferedEnd : presentation.duration!;\n\n            mediaSource.duration = duration;\n          };\n\n          writeWhenReady();\n\n          return () => controller.abort();\n        },\n      },\n    },\n  });\n}\n\nexport const updateMediaSourceDuration = defineBehavior({\n  stateKeys: ['presentation'],\n  contextKeys: ['mediaSource'],\n  setup: updateMediaSourceDurationSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,SAAS,YACP,cACA,aACkB;CAClB,OAAO,qBAAqB,cAAc,WAAW,IAAI,sBAAsB;AACjF;AAEA,SAAS,+BAA+B,EACtC,OACA,WAIyD;CAMzD,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,YAAY,IAAI,CAAC,CAAC;CAE1G,OAAO,qBAAuC;EAC5C,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,qBAAqB,EAKnB,aAAa;IACX,MAAM,eAAe,MAAM,aAAa,IAAI;IAC5C,MAAM,cAAc,QAAQ,YAAY,IAAI;IAO5C,IAAI,aAAa,aAAa,OAAO,mBAAmB;KACtD,IAAI,YAAY,aAAa,OAAO,mBAAmB;KAEvD,MAAM,aAAa,IAAI,gBAAgB;KAEvC,CAAM,YAAY;MAChB,MAAM,uBAAuB,aAAa,WAAW,MAAM;MAE3D,IAAI,WAAW,OAAO,WAAW,YAAY,eAAe,QAAQ;MAEpE,MAAM,0BAA0B,YAAY,eAAe,WAAW,MAAM;MAE5E,IAAI,WAAW,OAAO,WAAW,YAAY,eAAe,QAAQ;MAEpE,IAAI,YAAY,aAAa,OAAO,mBAClC,YAAY,WAAW,OAAO;KAElC,EAAA,CAAG;KACH,aAAa,WAAW,MAAM;IAChC;IAOA,IAAI,CAAC,OAAO,MAAM,YAAY,QAAQ,GAAG;IAEzC,MAAM,aAAa,IAAI,gBAAgB;IAEvC,MAAM,iBAAiB,YAAY;KACjC,MAAM,uBAAuB,aAAa,WAAW,MAAM;KAE3D,IAAI,WAAW,OAAO,SAAS;KAK/B,IAAI,YAAY,eAAe,QAAQ;KAEvC,MAAM,0BAA0B,YAAY,eAAe,WAAW,MAAM;KAE5E,IAAI,WAAW,OAAO,SAAS;KAM/B,IAAI,YAAY,eAAe,QAAQ;KAKvC,MAAM,iBAAiB,kBAAkB,YAAY,aAAa;KAClE,MAAM,WAAW,iBAAiB,aAAa,WAAY,iBAAiB,aAAa;KAEzF,YAAY,WAAW;IACzB;IAEA,eAAe;IAEf,aAAa,WAAW,MAAM;GAChC,EACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,4BAA4B,eAAe;CACtD,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,aAAa;CAC3B,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/establish-start-media-time.js

@@ -0,0 +1,187 @@
+import { update } from "../../core/signals/primitives.js";
+import { createMachineReactor } from "../../core/reactors/create-machine-reactor.js";
+import { isResolvedPresentation, isResolvedTrack } from "../../media/types/index.js";
+import { findTrackById } from "../../media/utils/tracks.js";
+//#region src/playback/behaviors/establish-start-media-time.ts
+/**
+* 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) {
+	const { timescale, baseMediaDecodeTime, segmentStartTime } = data ?? {};
+	return timescale != null && baseMediaDecodeTime != null && segmentStartTime != null ? baseMediaDecodeTime / timescale - segmentStartTime : void 0;
+}
+/** Snap a below-threshold (incl. negative) origin to `0` so it isn't relocated. */
+function thresholdOrigin(origin) {
+	return origin < 1 ? 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).
+*/
+const deriveSharedMinStartMediaTime = (containerData, ctx) => {
+	const contributingTypes = [];
+	if (ctx.selectedVideoTrackId != null) contributingTypes.push("video");
+	if (ctx.selectedAudioTrackId != null) contributingTypes.push("audio");
+	const origins = (contributingTypes.length > 0 ? contributingTypes : Object.keys(containerData)).map((type) => ownOrigin(containerData[type]));
+	if (origins.length === 0 || origins.some((origin) => origin === void 0)) return {};
+	const shared = thresholdOrigin(Math.min(...origins));
+	const out = {};
+	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).
+*
+* Caution: {@link NEAR_ZERO_ORIGIN_THRESHOLD} applies independently per type here — if two types' origins straddle it,
+* one snaps to `0` and the other doesn't, injecting up to a threshold's worth of A/V offset. Safe for the intended
+* aligned-A/V opt-in; see `internal/design/spf/live-presentation-timeline-model.md` (collision 5).
+*/
+const derivePerTypeStartMediaTime = (containerData) => {
+	const out = {};
+	for (const [type, data] of Object.entries(containerData)) {
+		const origin = ownOrigin(data);
+		out[type] = origin === void 0 ? void 0 : thresholdOrigin(origin);
+	}
+	return out;
+};
+/**
+* The anchor-source track: the selected video track, falling back to audio (audio-only). Deterministic — never "first
+* resolved", which is race-dependent under concurrent resolves.
+*/
+function referenceTrackId(ctx) {
+	return ctx.selectedVideoTrackId ?? ctx.selectedAudioTrackId;
+}
+/**
+* The live-anchor first-parse gate (the "parses align" step of the establishment order). Open for the reference track
+* itself — its local-from-0 placement _is_ the presentation timeline (presentation-0 = the join point). Every other
+* track holds until the reference's first parse settles the anchor question: no PDT → local placement is already
+* correct, proceed; PDT anchor → hold until the establishment reactor stamps it onto this track, so the parse takes the
+* `placeOnAnchor` path. Establishment is sticky-once, so an unanchored first parse would be permanently misaligned —
+* that's the race this gate closes.
+*
+* Pairs with the {@link establishStartMediaTime} reactor (the stamp that opens the anchored branch); wire both or
+* neither.
+*/
+const gateFirstParseOnAnchor = (presentation, ctx, trackId) => {
+	const referenceId = referenceTrackId(ctx);
+	if (referenceId === void 0 || referenceId === trackId) return true;
+	if (!isResolvedPresentation(presentation)) return false;
+	const reference = findTrackById(presentation, referenceId);
+	if (!reference) return true;
+	if (!isResolvedTrack(reference)) return false;
+	if (reference.startDate === void 0) return true;
+	return findTrackById(presentation, trackId)?.startDate !== void 0;
+};
+/**
+* Stamp the frozen wall-clock anchor as `startDate` onto every track that lacks one (idempotent — same reference when
+* nothing moved). Unresolved shells pick it up as the `placeOnAnchor` preset; covering _all_ tracks in one pass means
+* any track selected later — an ABR rung, another audio language, late captions — resolves already anchored. The
+* reference track's own parser-computed `startDate` reads back as the anchor, so it's naturally left untouched.
+*/
+function stampStartDates(presentation, anchor) {
+	let changed = false;
+	const selectionSets = presentation.selectionSets.map((selectionSet) => ({
+		...selectionSet,
+		switchingSets: selectionSet.switchingSets.map((switchingSet) => ({
+			...switchingSet,
+			tracks: switchingSet.tracks.map((track) => {
+				if (track.startDate !== void 0) return track;
+				changed = true;
+				return {
+					...track,
+					startDate: anchor
+				};
+			})
+		}))
+	}));
+	return changed ? {
+		...presentation,
+		selectionSets
+	} : presentation;
+}
+/** Stamp the derived per-track `startMediaTime` onto the model (idempotent — same reference when nothing moved). */
+function stampTracks(presentation, startMediaTimes) {
+	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 === void 0 || track.startMediaTime === startMediaTime) return track;
+				changed = true;
+				return {
+					...track,
+					startMediaTime
+				};
+			})
+		}))
+	}));
+	return changed ? {
+		...presentation,
+		selectionSets
+	} : presentation;
+}
+function establishStartMediaTimeSetup({ state, config = {} }) {
+	const derive = config.deriveStartMediaTime ?? deriveSharedMinStartMediaTime;
+	const selectionContext = () => ({
+		selectedVideoTrackId: state.selectedVideoTrackId?.get(),
+		selectedAudioTrackId: state.selectedAudioTrackId?.get()
+	});
+	/** Established once the selected A/V tracks (whichever exist) carry `startMediaTime`. */
+	const established = () => {
+		const presentation = state.presentation.get();
+		if (!isResolvedPresentation(presentation)) return false;
+		const ids = [state.selectedVideoTrackId?.get(), state.selectedAudioTrackId?.get()].filter((id) => id !== void 0);
+		return ids.length > 0 && ids.every((id) => findTrackById(presentation, id)?.startMediaTime !== void 0);
+	};
+	return createMachineReactor({
+		initial: "inactive",
+		monitor: () => {
+			if (!isResolvedPresentation(state.presentation.get())) return "inactive";
+			return established() ? "established" : "monitoring";
+		},
+		states: {
+			inactive: { entry: () => state.mediaContainerData.set(void 0) },
+			monitoring: { effects: [() => {
+				const presentation = state.presentation.get();
+				if (!isResolvedPresentation(presentation)) return;
+				const referenceId = referenceTrackId(selectionContext());
+				const reference = referenceId === void 0 ? void 0 : findTrackById(presentation, referenceId);
+				if (!reference || !isResolvedTrack(reference)) return;
+				const anchor = reference.startDate;
+				if (anchor === void 0) return;
+				update(state.presentation, (current) => stampStartDates(current, anchor));
+			}, () => {
+				const containerData = state.mediaContainerData.get();
+				if (!containerData) return;
+				const startMediaTimes = derive(containerData, selectionContext());
+				update(state.presentation, (current) => stampTracks(current, startMediaTimes));
+			}] },
+			established: {}
+		}
+	});
+}
+const establishStartMediaTime = {
+	stateKeys: ["presentation", "mediaContainerData"],
+	contextKeys: [],
+	setup: establishStartMediaTimeSetup
+};
+//#endregion
+export { derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime, establishStartMediaTime, gateFirstParseOnAnchor };
+
+//# sourceMappingURL=establish-start-media-time.js.map

package/dist/default/playback/behaviors/establish-start-media-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"establish-start-media-time.js","names":[],"sources":["../../../../src/playback/behaviors/establish-start-media-time.ts"],"sourcesContent":["/**\n * Establish the presentation's coordinate origin — the `startTime` / `startMediaTime` / `startDate` triple — once per\n * source, so every track lands on one 0-based presentation timeline. One establishment unit with an internal order: the\n * wall-clock **anchor** settles (live PDT sources), gated parses align to it, then `startMediaTime` latches — see\n * `internal/design/spf/live-presentation-timeline-model.md`.\n *\n * The two coordinate stamps it owns:\n *\n * - **`startDate` (wall-clock anchor).** The designated _reference track_ (selected video, else audio) resolves first;\n *   its parser-computed `startDate` — PDT at presentation-0 — is frozen as the anchor and stamped onto every other\n *   track that lacks one, so their first parses place via `placeOnAnchor` (the pre-applied-anchor path in\n *   `parse-media-playlist`) and later-selected renditions resolve already aligned. Ordering is enforced by\n *   {@link gateFirstParseOnAnchor}, which `resolve-track` awaits through its injected gate seam. Absent PDT (ordinary\n *   VOD), no anchor is stamped and local-from-0 placement is already correct.\n * - **`startMediaTime` (decode origin).** Runs the injected {@link DeriveStartMediaTime} seam over the transient\n *   `mediaContainerData` slot (owned here; `inactive` clears it per source) and stamps the settled value onto the model\n *   until `established`. The byte-level discover/stamp steps that fill the slot are a separate, config\n *   `messagePipelines` array (`primitives/relocation-pipelines`); the two coordinate only through the shared\n *   `state.mediaContainerData` slot, never by import. See `internal/design/spf/presentation-timeline-model.md`.\n *\n * DOM-free reactor; sticky per source (`inactive → monitoring → established`).\n */\nimport type { Behavior } from '../../core/composition/create-composition';\nimport { createMachineReactor, type Reactor } from '../../core/reactors/create-machine-reactor';\nimport { type ReadonlySignal, type Signal, update } from '../../core/signals/primitives';\nimport {\n  isResolvedPresentation,\n  isResolvedTrack,\n  type MaybeResolvedPresentation,\n  type MediaContainerData,\n  type Presentation,\n} from '../../media/types';\nimport { findTrackById } from '../../media/utils/tracks';\nimport type { DeriveStartMediaTime, DeriveStartMediaTimeContext } from '../primitives/derive-start-media-time';\nimport type { GateFirstParse, GateFirstParseContext } from '../primitives/gate-first-parse';\n\nexport type { DeriveStartMediaTime, DeriveStartMediaTimeContext, GateFirstParse, GateFirstParseContext };\n\n// ============================================================================\n// STATE / CONFIG\n// ============================================================================\n\nexport interface EstablishStartMediaTimeState {\n  presentation?: MaybeResolvedPresentation;\n  /**\n   * Transient origin-establishment data, keyed by **track type** (`'video'` / `'audio'`) — per spec one init+media pair\n   * per type suffices, and ABR rungs of a type share the origin. Filled by the discover steps across appends, reset per\n   * source. Never the model — the churn stays here; only the settled `startMediaTime` reaches `Track`.\n   */\n  mediaContainerData?: Record<string, MediaContainerData>;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\n/**\n * A single type's own media-timeline origin: `baseMediaDecodeTime/timescale − segmentStartTime` (the `segmentStartTime`\n * term makes it the stream origin even when the first loaded segment isn't the 0th). `undefined` until timescale +\n * baseMediaDecodeTime + segmentStartTime are all present.\n */\nfunction ownOrigin(data: MediaContainerData | undefined): number | undefined {\n  const { timescale, baseMediaDecodeTime, segmentStartTime } = data ?? {};\n\n  return timescale != null && baseMediaDecodeTime != null && segmentStartTime != null\n    ? baseMediaDecodeTime / timescale - segmentStartTime\n    : undefined;\n}\n\n/**\n * Origins below this magnitude (seconds) are treated as `0` — the derive returns `0`, so the presentation is left on\n * its native (~0-based) timeline and no `timestampOffset` is set (the loader stamp no-ops on a derived `0`). Ordinary\n * VOD carries a small nonzero encode origin (audio priming, first-frame CTS, edit lists); relocating by a sub-second\n * amount is pointless, and setting `timestampOffset` at all can ripple edge segments. Relocation targets streams with\n * an intentional large origin (instant clips, bipbop @10s).\n *\n * Absolute basis, not proportional: the DTS-below-zero / ripple risk scales with the origin's absolute size, not with\n * the presentation's duration. Also snaps negatives to `0` — a negative origin would relocate _forward_, which is never\n * the intent.\n */\nexport const NEAR_ZERO_ORIGIN_THRESHOLD = 1;\n\n/** Snap a below-threshold (incl. negative) origin to `0` so it isn't relocated. */\nfunction thresholdOrigin(origin: number): number {\n  return origin < NEAR_ZERO_ORIGIN_THRESHOLD ? 0 : origin;\n}\n\n/**\n * The **default** — relocate the whole presentation by one shared origin: the `min` across the _selected_ A/V tracks'\n * own origins, denormalized onto every type. This single reduce subsumes the \"per-type\" and \"shared\" tiers:\n *\n * - **aligned A/V** — `min` equals each origin (they're equal), so it matches per-type;\n * - **skewed A/V** (e.g. Apple's 44ms audio-lead) — `min` keeps every track's earliest DTS ≥ 0 (relocating by ≤ each own\n *   origin never drives one negative) _and_ preserves the real skew (per-type would flatten it, desyncing A/V);\n * - **single type / muxed** — `min` of the one origin is that origin.\n *\n * Returns `undefined` for every type until all _selected_ types have a complete origin (the shared-`min` barrier).\n * Which types must contribute is read from `ctx` (the selected v/a ids); with no selection context it coordinates\n * across whatever types have data. A shared origin below {@link NEAR_ZERO_ORIGIN_THRESHOLD} is returned as `0` (native\n * — ordinary ~0-PTS VOD isn't relocated).\n */\nexport const deriveSharedMinStartMediaTime: DeriveStartMediaTime = (containerData, ctx) => {\n  const contributingTypes: string[] = [];\n\n  if (ctx.selectedVideoTrackId != null) contributingTypes.push('video');\n\n  if (ctx.selectedAudioTrackId != null) contributingTypes.push('audio');\n\n  const types = contributingTypes.length > 0 ? contributingTypes : Object.keys(containerData);\n\n  const origins = types.map((type) => ownOrigin(containerData[type]));\n  // Barrier: not ready until every contributing type has a complete origin.\n  if (origins.length === 0 || origins.some((origin) => origin === undefined)) return {};\n\n  const shared = thresholdOrigin(Math.min(...(origins as number[])));\n  const out: Record<string, number | undefined> = {};\n\n  for (const type of Object.keys(containerData)) out[type] = shared;\n\n  return out;\n};\n\n/**\n * Coordination-axis _off_ — each type relocates by its own origin, independently. Not the default: it flattens real A/V\n * skew (see {@link deriveSharedMinStartMediaTime}). Kept as an opt-in for compositions that know their A/V is aligned\n * and want to skip the shared-`min` barrier (each type stamps as soon as its own origin is discovered).\n *\n * Caution: {@link NEAR_ZERO_ORIGIN_THRESHOLD} applies independently per type here — if two types' origins straddle it,\n * one snaps to `0` and the other doesn't, injecting up to a threshold's worth of A/V offset. Safe for the intended\n * aligned-A/V opt-in; see `internal/design/spf/live-presentation-timeline-model.md` (collision 5).\n */\nexport const derivePerTypeStartMediaTime: DeriveStartMediaTime = (containerData) => {\n  const out: Record<string, number | undefined> = {};\n\n  for (const [type, data] of Object.entries(containerData)) {\n    const origin = ownOrigin(data);\n\n    out[type] = origin === undefined ? undefined : thresholdOrigin(origin);\n  }\n\n  return out;\n};\n\n/**\n * The anchor-source track: the selected video track, falling back to audio (audio-only). Deterministic — never \"first\n * resolved\", which is race-dependent under concurrent resolves.\n */\nfunction referenceTrackId(ctx: GateFirstParseContext): string | undefined {\n  return ctx.selectedVideoTrackId ?? ctx.selectedAudioTrackId;\n}\n\n/**\n * The live-anchor first-parse gate (the \"parses align\" step of the establishment order). Open for the reference track\n * itself — its local-from-0 placement _is_ the presentation timeline (presentation-0 = the join point). Every other\n * track holds until the reference's first parse settles the anchor question: no PDT → local placement is already\n * correct, proceed; PDT anchor → hold until the establishment reactor stamps it onto this track, so the parse takes the\n * `placeOnAnchor` path. Establishment is sticky-once, so an unanchored first parse would be permanently misaligned —\n * that's the race this gate closes.\n *\n * Pairs with the {@link establishStartMediaTime} reactor (the stamp that opens the anchored branch); wire both or\n * neither.\n */\nexport const gateFirstParseOnAnchor: GateFirstParse = (presentation, ctx, trackId) => {\n  const referenceId = referenceTrackId(ctx);\n  if (referenceId === undefined || referenceId === trackId) return true;\n\n  if (!isResolvedPresentation(presentation)) return false;\n\n  const reference = findTrackById(presentation, referenceId);\n  // A dangling reference id can never anchor — don't deadlock on it.\n  if (!reference) return true;\n\n  if (!isResolvedTrack(reference)) return false;\n\n  if (reference.startDate === undefined) return true;\n\n  return findTrackById(presentation, trackId)?.startDate !== undefined;\n};\n\nexport interface EstablishStartMediaTimeConfig {\n  /** The reduce seam (coordination knob). Defaults to {@link deriveSharedMinStartMediaTime}. */\n  deriveStartMediaTime?: DeriveStartMediaTime;\n}\n\n// ============================================================================\n// REACTOR (owns the transient slot; derives + consumes onto the model)\n// ============================================================================\n\n/**\n * Stamp the frozen wall-clock anchor as `startDate` onto every track that lacks one (idempotent — same reference when\n * nothing moved). Unresolved shells pick it up as the `placeOnAnchor` preset; covering _all_ tracks in one pass means\n * any track selected later — an ABR rung, another audio language, late captions — resolves already anchored. The\n * reference track's own parser-computed `startDate` reads back as the anchor, so it's naturally left untouched.\n */\nfunction stampStartDates(presentation: Presentation, anchor: number): Presentation {\n  let changed = false;\n  const selectionSets = presentation.selectionSets.map((selectionSet) => ({\n    ...selectionSet,\n    switchingSets: selectionSet.switchingSets.map((switchingSet) => ({\n      ...switchingSet,\n      tracks: switchingSet.tracks.map((track) => {\n        if (track.startDate !== undefined) return track;\n\n        changed = true;\n        return { ...track, startDate: anchor };\n      }),\n    })),\n  }));\n\n  return changed ? ({ ...presentation, selectionSets } as Presentation) : presentation;\n}\n\n/** Stamp the derived per-track `startMediaTime` onto the model (idempotent — same reference when nothing moved). */\nfunction stampTracks(presentation: Presentation, startMediaTimes: Record<string, number | undefined>): Presentation {\n  let changed = false;\n  const selectionSets = presentation.selectionSets.map((selectionSet) => ({\n    ...selectionSet,\n    switchingSets: selectionSet.switchingSets.map((switchingSet) => ({\n      ...switchingSet,\n      tracks: switchingSet.tracks.map((track) => {\n        const startMediaTime = startMediaTimes[track.type];\n        if (startMediaTime === undefined || track.startMediaTime === startMediaTime) return track;\n\n        changed = true;\n        return { ...track, startMediaTime };\n      }),\n    })),\n  }));\n\n  return changed ? ({ ...presentation, selectionSets } as Presentation) : presentation;\n}\n\ntype EstablishFsmState = 'inactive' | 'monitoring' | 'established';\n\ninterface EstablishStartMediaTimeDeps {\n  state: {\n    presentation: Signal<EstablishStartMediaTimeState['presentation']>;\n    mediaContainerData: Signal<EstablishStartMediaTimeState['mediaContainerData']>;\n    // Optional so the one behavior composes across video-only / audio-only / both,\n    // like other cross-track-type behaviors (present at runtime iff a sibling owns it).\n    selectedVideoTrackId?: ReadonlySignal<EstablishStartMediaTimeState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<EstablishStartMediaTimeState['selectedAudioTrackId']>;\n  };\n  config?: EstablishStartMediaTimeConfig;\n}\n\nfunction establishStartMediaTimeSetup({\n  state,\n  config = {},\n}: EstablishStartMediaTimeDeps): Reactor<EstablishFsmState | 'destroying' | 'destroyed'> {\n  const derive = config.deriveStartMediaTime ?? deriveSharedMinStartMediaTime;\n\n  const selectionContext = (): DeriveStartMediaTimeContext => ({\n    selectedVideoTrackId: state.selectedVideoTrackId?.get(),\n    selectedAudioTrackId: state.selectedAudioTrackId?.get(),\n  });\n\n  /** Established once the selected A/V tracks (whichever exist) carry `startMediaTime`. */\n  const established = (): boolean => {\n    const presentation = state.presentation.get();\n    if (!isResolvedPresentation(presentation)) return false;\n\n    const ids = [state.selectedVideoTrackId?.get(), state.selectedAudioTrackId?.get()].filter(\n      (id): id is string => id !== undefined\n    );\n\n    return ids.length > 0 && ids.every((id) => findTrackById(presentation, id)?.startMediaTime !== undefined);\n  };\n\n  return createMachineReactor<EstablishFsmState>({\n    initial: 'inactive',\n    monitor: () => {\n      if (!isResolvedPresentation(state.presentation.get())) return 'inactive';\n\n      return established() ? 'established' : 'monitoring';\n    },\n    states: {\n      // Fresh per source: clear the transient slot so a new source re-discovers.\n      inactive: { entry: () => state.mediaContainerData.set(undefined) },\n      // The establishment order, as two effects: anchor first, derive second.\n      // Both stamps are sticky per source — disabled on entry to `established`,\n      // and a new source re-enters through `inactive`.\n      monitoring: {\n        effects: [\n          // Anchor: freeze the wall-clock origin from the reference track's\n          // first parse and stamp it onto every other track (the gate's open\n          // condition + the `placeOnAnchor` preset for shells). Reads the\n          // presentation tracked — it must see the reference resolve — and its\n          // own write converges immediately (the stamp is idempotent, so the\n          // re-run sets an identical value and stops).\n          () => {\n            const presentation = state.presentation.get();\n            if (!isResolvedPresentation(presentation)) return;\n\n            const referenceId = referenceTrackId(selectionContext());\n            const reference = referenceId === undefined ? undefined : findTrackById(presentation, referenceId);\n            if (!reference || !isResolvedTrack(reference)) return;\n\n            const anchor = reference.startDate;\n            if (anchor === undefined) return;\n\n            update(state.presentation as Signal<MaybeResolvedPresentation>, (current) =>\n              stampStartDates(current as Presentation, anchor)\n            );\n          },\n          // Derive: reduce the accumulating container data into per-track startMediaTime\n          // and stamp it onto the model. Re-runs as discover fills the slot; the update\n          // reads presentation untracked, so no self-loop.\n          () => {\n            const containerData = state.mediaContainerData.get();\n            if (!containerData) return;\n\n            const startMediaTimes = derive(containerData, selectionContext());\n\n            // `current` is always resolved here — the monitor gates `monitoring` on a\n            // resolved presentation and transitions before effects re-run — so we cast\n            // to `Presentation` rather than re-narrowing.\n            update(state.presentation as Signal<MaybeResolvedPresentation>, (current) =>\n              stampTracks(current as Presentation, startMediaTimes)\n            );\n          },\n        ],\n      },\n      established: {},\n    },\n  });\n}\n\nexport const establishStartMediaTime: Behavior<\n  {\n    presentation: Signal<EstablishStartMediaTimeState['presentation']>;\n    mediaContainerData: Signal<EstablishStartMediaTimeState['mediaContainerData']>;\n  },\n  Record<never, never>,\n  EstablishStartMediaTimeConfig\n> = {\n  stateKeys: ['presentation', 'mediaContainerData'],\n  contextKeys: [],\n  setup: establishStartMediaTimeSetup,\n};\n"],"mappings":"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"}

package/dist/default/playback/behaviors/resolve-presentation.js

@@ -0,0 +1,76 @@
+import { computed } from "../../core/signals/primitives.js";
+import { defineBehavior } from "../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../core/reactors/create-machine-reactor.js";
+import { isResolvedPresentation } from "../../media/types/index.js";
+import { fetchResolvable, getResponseText } from "../../network/fetch.js";
+import { isBlockingPreload } from "../../media/utils/preload.js";
+//#region src/playback/behaviors/resolve-presentation.ts
+/**
+* **Resolve an unresolved presentation by fetching and parsing its manifest.**
+*
+* Reads `state.presentation`; when it holds `{ url }` (unresolved) and the preload / load-activation gate is met,
+* fetches the manifest, parses it via the **required** `config.parsePresentation`, and writes the resolved
+* `Presentation` back to the same slot. The behavior is format-neutral: the composing engine wires in its parser (e.g.
+* the HLS engine supplies the multivariant-playlist parser).
+*
+* Source-identity-driven, expressed as a 4-state machine:
+*
+*     'preconditions-unmet' → 'idle' → 'resolving' → 'resolved'
+*
+* - `'preconditions-unmet'`: no presentation, or presentation has no URL.
+* - `'idle'`: URL present, unresolved, gate unmet (blocking preload + no load-activation). Waits for the gate to open.
+* - `'resolving'`: URL present, unresolved, gate met. Entry starts the fetch and returns the AbortController — the
+*   reactor calls `.abort()` on state exit, so source change / gate-close / destroy all cancel cleanly.
+* - `'resolved'`: `state.presentation` holds a resolved `Presentation`.
+*
+* Gate semantics: `state.preload` (or `config.defaultPreload`, default `'metadata'`, when state.preload is unset)
+* blocks resolution when its value is `'none'` (see `isBlockingPreload` in `media/utils/preload`).
+* `state.loadActivated` is an override — true bypasses the preload gate entirely.
+*
+* Multi-writer with the engine adapter, which writes the initial unresolved `{ url }` to `state.presentation` from src
+* input. Different domains (config-input vs. derived state via fetch) — legitimate multi-writer.
+*/
+function deriveState(presentation, preload, loadActivated, defaultPreload) {
+	if (!presentation?.url) return "preconditions-unmet";
+	if (isResolvedPresentation(presentation)) return "resolved";
+	return !!loadActivated || !isBlockingPreload(preload, defaultPreload) ? "resolving" : "idle";
+}
+function resolvePresentationSetup({ state, config }) {
+	const { parsePresentation } = config;
+	const defaultPreload = config.defaultPreload ?? "metadata";
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), state.preload.get(), state.loadActivated.get(), defaultPreload));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			idle: {},
+			resolving: { entry: () => {
+				const presentation = state.presentation.get();
+				const ac = new AbortController();
+				fetchResolvable(presentation, { signal: ac.signal }).then((response) => getResponseText(response)).then((text) => {
+					const parsed = parsePresentation(text, presentation);
+					state.presentation.set(parsed);
+				}).catch((error) => {
+					if (error instanceof Error && error.name === "AbortError") return;
+					console.error("[resolvePresentation] manifest fetch/parse failed:", error);
+				});
+				return ac;
+			} },
+			resolved: {}
+		}
+	});
+}
+const resolvePresentation = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"preload",
+		"loadActivated"
+	],
+	contextKeys: [],
+	setup: resolvePresentationSetup
+});
+//#endregion
+export { resolvePresentation };
+
+//# sourceMappingURL=resolve-presentation.js.map

package/dist/default/playback/behaviors/resolve-presentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-presentation.js","names":[],"sources":["../../../../src/playback/behaviors/resolve-presentation.ts"],"sourcesContent":["/**\n * **Resolve an unresolved presentation by fetching and parsing its manifest.**\n *\n * Reads `state.presentation`; when it holds `{ url }` (unresolved) and the preload / load-activation gate is met,\n * fetches the manifest, parses it via the **required** `config.parsePresentation`, and writes the resolved\n * `Presentation` back to the same slot. The behavior is format-neutral: the composing engine wires in its parser (e.g.\n * the HLS engine supplies the multivariant-playlist parser).\n *\n * Source-identity-driven, expressed as a 4-state machine:\n *\n *     'preconditions-unmet' → 'idle' → 'resolving' → 'resolved'\n *\n * - `'preconditions-unmet'`: no presentation, or presentation has no URL.\n * - `'idle'`: URL present, unresolved, gate unmet (blocking preload + no load-activation). Waits for the gate to open.\n * - `'resolving'`: URL present, unresolved, gate met. Entry starts the fetch and returns the AbortController — the\n *   reactor calls `.abort()` on state exit, so source change / gate-close / destroy all cancel cleanly.\n * - `'resolved'`: `state.presentation` holds a resolved `Presentation`.\n *\n * Gate semantics: `state.preload` (or `config.defaultPreload`, default `'metadata'`, when state.preload is unset)\n * blocks resolution when its value is `'none'` (see `isBlockingPreload` in `media/utils/preload`).\n * `state.loadActivated` is an override — true bypasses the preload gate entirely.\n *\n * Multi-writer with the engine adapter, which writes the initial unresolved `{ url }` to `state.presentation` from src\n * input. Different domains (config-input vs. derived state via fetch) — legitimate multi-writer.\n */\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport type { Reactor } from '../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal } from '../../core/signals/primitives';\nimport { isResolvedPresentation, type MaybeResolvedPresentation, type Presentation } from '../../media/types';\nimport { DEFAULT_PRELOAD, isBlockingPreload, type StandardPreload } from '../../media/utils/preload';\nimport { fetchResolvable, getResponseText } from '../../network/fetch';\n\nexport interface PresentationState {\n  presentation?: MaybeResolvedPresentation;\n  preload?: 'auto' | 'metadata' | 'none' | undefined;\n  /** True once a preload-overriding event has fired for the current source — enables resolution regardless of preload. */\n  loadActivated?: boolean;\n}\n\nexport type ParsePresentation = (text: string, presentation: MaybeResolvedPresentation) => Presentation;\n\nexport interface ResolvePresentationConfig {\n  /**\n   * Parses a manifest body into a resolved `Presentation`. **Required** — the behavior is format-neutral and the\n   * composing engine supplies its own parser (HLS, DASH, etc.).\n   */\n  parsePresentation: ParsePresentation;\n  /**\n   * Fallback used when `state.preload` is unset (undefined / empty) for the resolution-gate decision. Defaults to\n   * `'metadata'`, matching `syncPreload`'s own `defaultPreload`.\n   */\n  defaultPreload?: StandardPreload;\n}\n\nexport type ResolvePresentationState = 'preconditions-unmet' | 'idle' | 'resolving' | 'resolved';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  preload: PresentationState['preload'],\n  loadActivated: boolean | undefined,\n  defaultPreload: StandardPreload\n): ResolvePresentationState {\n  if (!presentation?.url) return 'preconditions-unmet';\n\n  if (isResolvedPresentation(presentation)) return 'resolved';\n\n  const gateOpen = !!loadActivated || !isBlockingPreload(preload, defaultPreload);\n\n  return gateOpen ? 'resolving' : 'idle';\n}\n\nfunction resolvePresentationSetup({\n  state,\n  config,\n}: {\n  state: {\n    presentation: Signal<PresentationState['presentation']>;\n    preload: ReadonlySignal<PresentationState['preload']>;\n    loadActivated: ReadonlySignal<PresentationState['loadActivated']>;\n  };\n  config: ResolvePresentationConfig;\n}): Reactor<ResolvePresentationState | 'destroying' | 'destroyed'> {\n  const { parsePresentation } = config;\n  const defaultPreload: StandardPreload = config.defaultPreload ?? DEFAULT_PRELOAD;\n\n  const derivedStateSignal = computed(() =>\n    deriveState(state.presentation.get(), state.preload.get(), state.loadActivated.get(), defaultPreload)\n  );\n\n  return createMachineReactor<ResolvePresentationState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n      idle: {},\n      resolving: {\n        entry: () => {\n          const presentation = state.presentation.get()!;\n          const ac = new AbortController();\n\n          fetchResolvable(presentation, { signal: ac.signal })\n            .then((response) => getResponseText(response))\n            .then((text) => {\n              const parsed = parsePresentation(text, presentation);\n\n              state.presentation.set(parsed);\n            })\n            .catch((error) => {\n              if (error instanceof Error && error.name === 'AbortError') return;\n\n              // TODO(error-management): route to a state-error slot once one exists.\n              console.error('[resolvePresentation] manifest fetch/parse failed:', error);\n            });\n\n          return ac;\n        },\n      },\n      resolved: {},\n    },\n  });\n}\n\nexport const resolvePresentation = defineBehavior({\n  stateKeys: ['presentation', 'preload', 'loadActivated'],\n  contextKeys: [],\n  setup: resolvePresentationSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAS,YACP,cACA,SACA,eACA,gBAC0B;CAC1B,IAAI,CAAC,cAAc,KAAK,OAAO;CAE/B,IAAI,uBAAuB,YAAY,GAAG,OAAO;CAIjD,OAFiB,CAAC,CAAC,iBAAiB,CAAC,kBAAkB,SAAS,cAAc,IAE5D,cAAc;AAClC;AAEA,SAAS,yBAAyB,EAChC,OACA,UAQiE;CACjE,MAAM,EAAE,sBAAsB;CAC9B,MAAM,iBAAkC,OAAO,kBAAA;CAE/C,MAAM,qBAAqB,eACzB,YAAY,MAAM,aAAa,IAAI,GAAG,MAAM,QAAQ,IAAI,GAAG,MAAM,cAAc,IAAI,GAAG,cAAc,CACtG;CAEA,OAAO,qBAA+C;EACpD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GACxB,MAAM,CAAC;GACP,WAAW,EACT,aAAa;IACX,MAAM,eAAe,MAAM,aAAa,IAAI;IAC5C,MAAM,KAAK,IAAI,gBAAgB;IAE/B,gBAAgB,cAAc,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,CACjD,MAAM,aAAa,gBAAgB,QAAQ,CAAC,CAAC,CAC7C,MAAM,SAAS;KACd,MAAM,SAAS,kBAAkB,MAAM,YAAY;KAEnD,MAAM,aAAa,IAAI,MAAM;IAC/B,CAAC,CAAC,CACD,OAAO,UAAU;KAChB,IAAI,iBAAiB,SAAS,MAAM,SAAS,cAAc;KAG3D,QAAQ,MAAM,sDAAsD,KAAK;IAC3E,CAAC;IAEH,OAAO;GACT,EACF;GACA,UAAU,CAAC;EACb;CACF,CAAC;AACH;AAEA,MAAa,sBAAsB,eAAe;CAChD,WAAW;EAAC;EAAgB;EAAW;CAAe;CACtD,aAAa,CAAC;CACd,OAAO;AACT,CAAC"}