@videojs/spf 10.0.0-beta.30 → 10.0.0-beta.32

package/dist/dev/playback/behaviors/dom/track-playback-rate.d.ts

@@ -8,8 +8,8 @@ interface PlaybackRateContext {
 }
 interface TrackPlaybackRateConfig {
   /**
-   * Value written to `state.playbackRate` when no media element is attached.
-   * Defaults to `1` — the HTMLMediaElement spec default.
+   * Value written to `state.playbackRate` when no media element is attached. Defaults to `1` — the HTMLMediaElement
+   * spec default.
    */
   defaultPlaybackRate?: number;
 }

package/dist/dev/playback/behaviors/dom/track-playback-rate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"track-playback-rate.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-playback-rate.ts"],"mappings":";;UAgBiB;EACf;;UAGe;EACf,eAAe;;UAGA;;;;;EAKf;;cA2BW;;;;;MAnBY,cAAA,OAAO;;;;MACL,cAAA,eAAe"}
+{"version":3,"file":"track-playback-rate.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-playback-rate.ts"],"mappings":";;UAeiB;EACf;;UAGe;EACf,eAAe;;UAGA;;;;;EAKf;;cA8BW;;;;;MAtBY,cAAA,OAAO;;;;MACL,cAAA,eAAe"}

package/dist/dev/playback/behaviors/dom/track-playback-rate.js

@@ -3,15 +3,13 @@ import { effect } from "../../../core/signals/effect.js";
 import { listen } from "@videojs/utils/dom";
 //#region src/playback/behaviors/dom/track-playback-rate.ts
 /**
-* Mirror `mediaElement.playbackRate` into reactive state. On each `ratechange`
-* event, write the new value to `state.playbackRate`. Also syncs immediately
-* when a media element becomes available so consumers don't wait for the first
-* event.
+* Mirror `mediaElement.playbackRate` into reactive state. On each `ratechange` event, write the new value to
+* `state.playbackRate`. Also syncs immediately when a media element becomes available so consumers don't wait for the
+* first event.
 *
-* When no media element is attached, writes `config.defaultPlaybackRate`
-* (default-default `1`, matching the HTMLMediaElement spec) so consumers
-* always see the rate a freshly attached element would have. Read-only mirror;
-* does not push `state.playbackRate` back to the element.
+* When no media element is attached, writes `config.defaultPlaybackRate` (default-default `1`, matching the
+* HTMLMediaElement spec) so consumers always see the rate a freshly attached element would have. Read-only mirror; does
+* not push `state.playbackRate` back to the element.
 */
 function trackPlaybackRateSetup({ state, context, config }) {
 	const defaultPlaybackRate = config?.defaultPlaybackRate ?? 1;

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

@@ -1 +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`\n * event, write the new value to `state.playbackRate`. Also syncs immediately\n * when a media element becomes available so consumers don't wait for the first\n * event.\n *\n * When no media element is attached, writes `config.defaultPlaybackRate`\n * (default-default `1`, matching the HTMLMediaElement spec) so consumers\n * always see the rate a freshly attached element would have. Read-only mirror;\n * does not push `state.playbackRate` back to the element.\n */\nimport { listen } from '@videojs/utils/dom';\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.\n   * Defaults to `1` — the HTMLMediaElement 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    if (!mediaElement) {\n      state.playbackRate.set(defaultPlaybackRate);\n      return;\n    }\n\n    const sync = () => state.playbackRate.set(mediaElement.playbackRate);\n    sync();\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":";;;;;;;;;;;;;;;AAgCA,SAAS,uBAAuB,EAC9B,OACA,SACA,UAKa;CACb,MAAM,sBAAsB,QAAQ,uBAAuB;CAE3D,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAC9C,IAAI,CAAC,cAAc;GACjB,MAAM,aAAa,IAAI,mBAAmB;GAC1C;EACF;EAEA,MAAM,aAAa,MAAM,aAAa,IAAI,aAAa,YAAY;EACnE,KAAK;EACL,OAAO,OAAO,cAAc,cAAc,IAAI;CAChD,CAAC;AACH;AAEA,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT,CAAC"}
+{"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/dev/playback/behaviors/dom/track-player-resolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"track-player-resolution.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-player-resolution.ts"],"mappings":";;;;KA6BY,mBAAmB"}
+{"version":3,"file":"track-player-resolution.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-player-resolution.ts"],"mappings":";;;;KA0BY,mBAAmB"}

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

@@ -5,24 +5,20 @@ 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
+* 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`).
+* 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
+* 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".
+* `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;
@@ -44,7 +40,7 @@ function trackPlayerResolutionSetup({ state, context, config = {} }) {
 * Track the player element's rendered resolution in `state.playerResolution`.
 *
 * @example
-* const cleanup = trackPlayerResolution.setup({ state, context });
+*   const cleanup = trackPlayerResolution.setup({ state, context });
 */
 const trackPlayerResolution = defineBehavior({
 	stateKeys: ["playerResolution"],

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

@@ -1 +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\n * a rendition cap can narrow candidates to what the element can actually show\n * 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\n * `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\n * the screen behind it (`trackScreenResolution`).\n *\n * Reported as a width and a height in device pixels — the same units, and for the\n * same reason, as `media/dom/screen`'s reading: the cap compares against real\n * 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\n * that isn't being rendered (detached, `display: none`, not yet laid out) — which\n * 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';\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`\n   * measures nothing, which leaves `state.playerResolution` unset and the cap\n   * inert. Defaults to `true`.\n   *\n   * Named for the policy rather than the measurement because it is the public\n   * switch for the feature — the same one hls.js spells `capLevelToPlayerSize`\n   * 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`,\n   * including its note on page zoom being 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    state.playerResolution.set(current);\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":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,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;EACJ,MAAM,iBAAiB,IAAI,OAAO;EAClC,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"}
+{"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/dev/playback/behaviors/dom/track-screen-resolution.js

@@ -2,21 +2,20 @@ 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
+* 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
+* 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.
+* 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 }) {
-	return watchScreenResolution((resolution) => state.screenResolution.set(resolution), { useDevicePixelRatio: config?.useDevicePixelRatio ?? true });
+	const useDevicePixelRatio = config?.useDevicePixelRatio ?? true;
+	return watchScreenResolution((resolution) => state.screenResolution.set(resolution), { useDevicePixelRatio });
 }
 const trackScreenResolution = defineBehavior({
 	stateKeys: ["screenResolution"],

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

@@ -1 +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\n * can narrow candidates to what the screen can actually show without reading the\n * 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`\n * reports its starting value, so nothing downstream waits on a screen that may\n * 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\n * independent of the presentation, so a new `src` 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\n   * zoom being folded into the ratio outside 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":";;;;;;;;;;;;;;;;;AA+BA,SAAS,2BAA2B,EAClC,OACA,UAIa;CAMb,OAAO,uBAAuB,eAAe,MAAM,iBAAiB,IAAI,UAAU,GAAG,EAAE,qBAL3D,QAAQ,uBAAuB,KAKgD,CAAC;AAC9G;AAEA,MAAa,wBAAwB,eAAe;CAClD,WAAW,CAAC,kBAAkB;CAC9B,aAAa,CAAC;CACd,OAAO;AACT,CAAC"}
+{"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/dev/playback/behaviors/dom/update-mediasource-duration.js

@@ -5,58 +5,43 @@ import { waitForMediaSourceOpen } from "../../../media/dom/mse/mediasource-setup
 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.**
+* **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.
+* - **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).
+* 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.
+* 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.
+* 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).
+* 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";

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

@@ -1 +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\n * once per MediaSource.**\n *\n * Two paths, by whether the presentation is live:\n *\n * - **Live** (`presentation.duration === Infinity`): write `Infinity` once the\n *   MediaSource is open and no SourceBuffer is mid-append. No buffered clamp is\n *   needed (`Infinity` ≥ any range) and — unlike the finite case — it needn't\n *   precede the first append: `Infinity` overrides whatever finite live-edge\n *   value an append may have pinned (a finite duration would otherwise stall\n *   the stream once the window slides past it). The wait-for-idle is required\n *   because the MSE spec forbids setting `duration` while a buffer is\n *   `updating`; both waits resolve immediately when already open / idle.\n *\n * - **VoD** (finite): the value is written once, after `mediaSource` is open and\n *   all SourceBuffers are idle, clamped to be ≥ the highest buffered range (MSE\n *   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\n *   buffered end), the property is left alone — re-syncing would race\n *   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\n *    `sourceopen` event (or any readyState transition, since `'ended'` /\n *    `'closed'` mean we've missed the window and should bail).\n * 2. **All SourceBuffers idle** — `waitForSourceBuffersReady` defers per\n *    the MSE-spec rule that `duration` cannot be set while any buffer has\n *    `updating === true`.\n * 3. **Buffered-range clamp** — `getMaxBufferedEnd` ensures the written\n *    duration is at least the highest buffered end (MSE spec disallows\n *    a smaller `duration` than any buffered range).\n *\n * The buffer-set helpers operate across `mediaSource.sourceBuffers` (the\n * canonical aggregate), so the behavior composes uniformly across\n * audio-only, video-only, and mixed configurations.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'duration-writable'`):\n * state derivation is purely signal-driven (presentation validity +\n * mediaSource existence). MediaSource lifecycle state (`readyState`) and\n * the `duration` itself are non-signal DOM properties resolved inside the\n * entry's async sequence. The state-exit cleanup aborts the in-flight\n * wait, so source resets and behavior destroy structurally cancel the\n * pending write. A post-await re-check of `mediaSource.readyState ===\n * 'open'` covers the narrow race where `endOfStream()` synchronously\n * transitions readyState to `'ended'` between our `waitForMediaSourceOpen`\n * resolution and the `mediaSource.duration` write.\n *\n * Downstream of `calculatePresentationDuration` (which writes\n * `presentation.duration`); concurrent with `endOfStream` (which may later\n * write `mediaSource.duration` — the \"exactly once\" contract keeps us out\n * 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            const controller = new AbortController();\n            void (async () => {\n              await waitForMediaSourceOpen(mediaSource, controller.signal);\n              if (controller.signal.aborted || mediaSource.readyState !== 'open') return;\n              await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n              if (controller.signal.aborted || mediaSource.readyState !== 'open') return;\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            if (controller.signal.aborted) return;\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            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            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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,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;KACvD,MAAM,aAAa,IAAI,gBAAgB;KACvC,CAAM,YAAY;MAChB,MAAM,uBAAuB,aAAa,WAAW,MAAM;MAC3D,IAAI,WAAW,OAAO,WAAW,YAAY,eAAe,QAAQ;MACpE,MAAM,0BAA0B,YAAY,eAAe,WAAW,MAAM;MAC5E,IAAI,WAAW,OAAO,WAAW,YAAY,eAAe,QAAQ;MACpE,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;KAC3D,IAAI,WAAW,OAAO,SAAS;KAI/B,IAAI,YAAY,eAAe,QAAQ;KAEvC,MAAM,0BAA0B,YAAY,eAAe,WAAW,MAAM;KAC5E,IAAI,WAAW,OAAO,SAAS;KAM/B,IAAI,YAAY,eAAe,QAAQ;KAKvC,MAAM,iBAAiB,kBAAkB,YAAY,aAAa;KAClE,MAAM,WAAW,iBAAiB,aAAa,WAAY,iBAAiB,aAAa;KACzF,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"}
+{"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/dev/playback/behaviors/establish-start-media-time.d.ts

@@ -3,32 +3,28 @@ import "../../core/composition/create-composition.js";
 import { DeriveStartMediaTime, DeriveStartMediaTimeContext } from "../primitives/derive-start-media-time.js";
 //#region src/playback/behaviors/establish-start-media-time.d.ts
 /**
- * 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:
+ * 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);
+ * - **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).
+ * 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).
  */
 declare const deriveSharedMinStartMediaTime: DeriveStartMediaTime;
 /**
- * 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).
+ * 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).
+ * 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).
  */
 declare const derivePerTypeStartMediaTime: DeriveStartMediaTime;
 //#endregion

package/dist/dev/playback/behaviors/establish-start-media-time.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"establish-start-media-time.d.ts","names":[],"sources":["../../../../src/playback/behaviors/establish-start-media-time.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cA+Ga,+BAA+B;;;;;;;;;;;;cA2B/B,6BAA6B"}
+{"version":3,"file":"establish-start-media-time.d.ts","names":[],"sources":["../../../../src/playback/behaviors/establish-start-media-time.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAmGa,+BAA+B;;;;;;;;;;cA8B/B,6BAA6B"}

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

@@ -4,10 +4,9 @@ import { isResolvedPresentation, isResolvedTrack } from "../../media/types/index
 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.
+* 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 ?? {};
@@ -18,20 +17,18 @@ 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:
+* 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);
+* - **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).
+* 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 = [];
@@ -45,15 +42,13 @@ const deriveSharedMinStartMediaTime = (containerData, ctx) => {
 	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).
+* 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).
+* 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 = {};
@@ -64,25 +59,22 @@ const derivePerTypeStartMediaTime = (containerData) => {
 	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.
+* 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.
+* 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.
+* 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);
@@ -95,12 +87,10 @@ const gateFirstParseOnAnchor = (presentation, ctx, trackId) => {
 	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.
+* 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;