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

package/dist/dev/media/hls/resolve-url.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-url.js","names":[],"sources":["../../../../src/media/hls/resolve-url.ts"],"sourcesContent":["/**\n * Resolve a potentially relative URL against a base URL using native URL API.\n */\nexport function resolveUrl(url: string, baseUrl: string): string {\n  return new URL(url, baseUrl).href;\n}\n"],"mappings":";;;;AAGA,SAAgB,WAAW,KAAa,SAAyB;CAC/D,OAAO,IAAI,IAAI,KAAK,OAAO,CAAC,CAAC;AAC/B"}
+{"version":3,"file":"resolve-url.js","names":[],"sources":["../../../../src/media/hls/resolve-url.ts"],"sourcesContent":["/** Resolve a potentially relative URL against a base URL using native URL API. */\nexport function resolveUrl(url: string, baseUrl: string): string {\n  return new URL(url, baseUrl).href;\n}\n"],"mappings":";;AACA,SAAgB,WAAW,KAAa,SAAyB;CAC/D,OAAO,IAAI,IAAI,KAAK,OAAO,CAAC,CAAC;AAC/B"}

package/dist/dev/media/live-window.js

@@ -2,21 +2,17 @@ import { isResolvedPresentation, isResolvedTrack } from "./types/index.js";
 import { findTrackById } from "./utils/tracks.js";
 //#region src/media/live-window.ts
 /**
-* Derive the live window of the track with the given id — the single source of
-* truth for "where is live," consumed (via `liveWindowFromState`) by the
-* seek-to-live-edge and live-seekable-range behaviors so neither re-derives (or
-* re-presumes) the window shape. Type-agnostic: the caller decides which track
-* bears the timeline (video when present, else audio).
+* Derive the live window of the track with the given id — the single source of truth for "where is live," consumed (via
+* `liveWindowFromState`) by the seek-to-live-edge and live-seekable-range behaviors so neither re-derives (or
+* re-presumes) the window shape. Type-agnostic: the caller decides which track bears the timeline (video when present,
+* else audio).
 *
-* The window is a **live read** over the current `segments` array — never
-* stored on the track. The anchor triple is frozen per source; per-segment
-* `startTime` values are re-derived against it on every reload, so the edge
-* here slides while the origin stays fixed (see
-* `internal/design/spf/live-presentation-timeline-model.md`).
+* The window is a **live read** over the current `segments` array — never stored on the track. The anchor triple is
+* frozen per source; per-segment `startTime` values are re-derived against it on every reload, so the edge here slides
+* while the origin stays fixed (see `internal/design/spf/live-presentation-timeline-model.md`).
 *
-* Returns `null` when there is no live edge to track: an unresolved
-* presentation or track, a track with no segments, or a **complete** playlist
-* (VoD, or live that has ended — a finite `Track.duration`).
+* Returns `null` when there is no live edge to track: an unresolved presentation or track, a track with no segments, or
+* a **complete** playlist (VoD, or live that has ended — a finite `Track.duration`).
 */
 function liveWindowFor(presentation, trackId) {
 	if (!isResolvedPresentation(presentation) || !trackId) return null;

package/dist/dev/media/live-window.js.map

@@ -1 +1 @@
-{"version":3,"file":"live-window.js","names":[],"sources":["../../../src/media/live-window.ts"],"sourcesContent":["/**\n * Derive the live window of the track with the given id — the single source of\n * truth for \"where is live,\" consumed (via `liveWindowFromState`) by the\n * seek-to-live-edge and live-seekable-range behaviors so neither re-derives (or\n * re-presumes) the window shape. Type-agnostic: the caller decides which track\n * bears the timeline (video when present, else audio).\n *\n * The window is a **live read** over the current `segments` array — never\n * stored on the track. The anchor triple is frozen per source; per-segment\n * `startTime` values are re-derived against it on every reload, so the edge\n * here slides while the origin stays fixed (see\n * `internal/design/spf/live-presentation-timeline-model.md`).\n *\n * Returns `null` when there is no live edge to track: an unresolved\n * presentation or track, a track with no segments, or a **complete** playlist\n * (VoD, or live that has ended — a finite `Track.duration`).\n */\nimport { isResolvedPresentation, isResolvedTrack, type MaybeResolvedPresentation } from './types';\nimport { findTrackById } from './utils/tracks';\n\nexport interface LiveWindow {\n  /** Earliest time still in the window (seconds, presentation timeline). */\n  start: number;\n  /** The live edge — latest time in the window (seconds). */\n  end: number;\n}\n\nexport function liveWindowFor(\n  presentation: MaybeResolvedPresentation | undefined,\n  trackId: string | undefined\n): LiveWindow | null {\n  if (!isResolvedPresentation(presentation) || !trackId) return null;\n\n  const track = findTrackById(presentation, trackId);\n  if (!track || !isResolvedTrack(track) || track.segments.length === 0) return null;\n\n  // Complete playlist (VoD, or live that has ended) → no live edge. `Track.duration`\n  // is the parser's completeness signal (finite = complete, Infinity = still growing).\n  if (Number.isFinite(track.duration)) return null;\n\n  const { segments } = track;\n  const last = segments[segments.length - 1]!;\n  return {\n    start: segments[0]!.startTime,\n    end: last.startTime + last.duration,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,cACd,cACA,SACmB;CACnB,IAAI,CAAC,uBAAuB,YAAY,KAAK,CAAC,SAAS,OAAO;CAE9D,MAAM,QAAQ,cAAc,cAAc,OAAO;CACjD,IAAI,CAAC,SAAS,CAAC,gBAAgB,KAAK,KAAK,MAAM,SAAS,WAAW,GAAG,OAAO;CAI7E,IAAI,OAAO,SAAS,MAAM,QAAQ,GAAG,OAAO;CAE5C,MAAM,EAAE,aAAa;CACrB,MAAM,OAAO,SAAS,SAAS,SAAS;CACxC,OAAO;EACL,OAAO,SAAS,EAAE,CAAE;EACpB,KAAK,KAAK,YAAY,KAAK;CAC7B;AACF"}
+{"version":3,"file":"live-window.js","names":[],"sources":["../../../src/media/live-window.ts"],"sourcesContent":["/**\n * Derive the live window of the track with the given id — the single source of truth for \"where is live,\" consumed (via\n * `liveWindowFromState`) by the seek-to-live-edge and live-seekable-range behaviors so neither re-derives (or\n * re-presumes) the window shape. Type-agnostic: the caller decides which track bears the timeline (video when present,\n * else audio).\n *\n * The window is a **live read** over the current `segments` array — never stored on the track. The anchor triple is\n * frozen per source; per-segment `startTime` values are re-derived against it on every reload, so the edge here slides\n * while the origin stays fixed (see `internal/design/spf/live-presentation-timeline-model.md`).\n *\n * Returns `null` when there is no live edge to track: an unresolved presentation or track, a track with no segments, or\n * a **complete** playlist (VoD, or live that has ended — a finite `Track.duration`).\n */\nimport { isResolvedPresentation, isResolvedTrack, type MaybeResolvedPresentation } from './types';\nimport { findTrackById } from './utils/tracks';\n\nexport interface LiveWindow {\n  /** Earliest time still in the window (seconds, presentation timeline). */\n  start: number;\n  /** The live edge — latest time in the window (seconds). */\n  end: number;\n}\n\nexport function liveWindowFor(\n  presentation: MaybeResolvedPresentation | undefined,\n  trackId: string | undefined\n): LiveWindow | null {\n  if (!isResolvedPresentation(presentation) || !trackId) return null;\n\n  const track = findTrackById(presentation, trackId);\n  if (!track || !isResolvedTrack(track) || track.segments.length === 0) return null;\n\n  // Complete playlist (VoD, or live that has ended) → no live edge. `Track.duration`\n  // is the parser's completeness signal (finite = complete, Infinity = still growing).\n  if (Number.isFinite(track.duration)) return null;\n\n  const { segments } = track;\n  const last = segments[segments.length - 1]!;\n\n  return {\n    start: segments[0]!.startTime,\n    end: last.startTime + last.duration,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAuBA,SAAgB,cACd,cACA,SACmB;CACnB,IAAI,CAAC,uBAAuB,YAAY,KAAK,CAAC,SAAS,OAAO;CAE9D,MAAM,QAAQ,cAAc,cAAc,OAAO;CACjD,IAAI,CAAC,SAAS,CAAC,gBAAgB,KAAK,KAAK,MAAM,SAAS,WAAW,GAAG,OAAO;CAI7E,IAAI,OAAO,SAAS,MAAM,QAAQ,GAAG,OAAO;CAE5C,MAAM,EAAE,aAAa;CACrB,MAAM,OAAO,SAAS,SAAS,SAAS;CAExC,OAAO;EACL,OAAO,SAAS,EAAE,CAAE;EACpB,KAAK,KAAK,YAAY,KAAK;CAC7B;AACF"}

package/dist/dev/media/media-tracks/media-tracks.d.ts

@@ -18,27 +18,22 @@ interface AudioDedupeKey {
  */
 declare function dedupedVideoTracks(presentation: MaybeResolvedPresentation | undefined): VideoTrack[];
 /**
- * The distinct audio tracks of a presentation, deduped by `language` + `name`
- * (first occurrence wins). Returns `[]` when the presentation is unresolved or has no audio tracks.
+ * The distinct audio tracks of a presentation, deduped by `language` + `name` (first occurrence wins). Returns `[]`
+ * when the presentation is unresolved or has no audio tracks.
  */
 declare function dedupedAudioTracks(presentation: MaybeResolvedPresentation | undefined): AudioTrack[];
 /**
- * Find a video track by id, searching the same candidate set the engine resolves
- * against ({@link dedupedVideoTracks}'s pre-dedupe source). Returns `undefined`
- * when absent. Maps the engine's resolved `selectedVideoTrackId` back to its
- * properties for `active` reflection — the resolved id may be a per-CDN copy that
- * isn't the representative {@link dedupedVideoTracks} kept.
+ * Find a video track by id, searching the same candidate set the engine resolves against ({@link dedupedVideoTracks}'s
+ * pre-dedupe source). Returns `undefined` when absent. Maps the engine's resolved `selectedVideoTrackId` back to its
+ * properties for `active` reflection — the resolved id may be a per-CDN copy that isn't the representative
+ * {@link dedupedVideoTracks} kept.
  */
 declare function findVideoTrackById(presentation: MaybeResolvedPresentation | undefined, id: string | undefined): VideoTrack | undefined;
 /** Audio counterpart of {@link findVideoTrackById}, for `enabled` reflection. */
 declare function findAudioTrackById(presentation: MaybeResolvedPresentation | undefined, id: string | undefined): AudioTrack | undefined;
-/**
- * Build a partial video track that can be used as `userVideoTrackSelection`.
- */
+/** Build a partial video track that can be used as `userVideoTrackSelection`. */
 declare function toUserVideoTrackSelection<T extends VideoDedupeKey>(rendition?: T): Partial<VideoTrack> | undefined;
-/**
- * Build a partial audio track that can be used as a `userAudioTrackSelection`.
- */
+/** Build a partial audio track that can be used as a `userAudioTrackSelection`. */
 declare function toUserAudioTrackSelection<T extends AudioDedupeKey>(track?: T): Partial<AudioTrack> | undefined;
 /** Whether two video tracks are the same by dedupe key */
 declare function isSameVideoTrack(a: VideoDedupeKey, b: VideoDedupeKey | undefined): boolean;

package/dist/dev/media/media-tracks/media-tracks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"media-tracks.d.ts","names":[],"sources":["../../../../src/media/media-tracks/media-tracks.ts"],"mappings":";;;UA0BiB;EACf,QAAQ;EACR,SAAS;EACT,YAAY;;;UAIG;EACf,WAAW;EACX,OAAO;;;;;;;iBAQO,mBAAmB,cAAc,wCAAwC;;;;;iBAazE,mBAAmB,cAAc,wCAAwC;;;;;;;;iBAgBzE,mBACd,cAAc,uCACd,yBACC;;iBAOa,mBACd,cAAc,uCACd,yBACC;;;;iBA2Ca,0BAA0B,UAAU,gBAAgB,YAAY,IAAI,QAAQ;;;;iBAO5E,0BAA0B,UAAU,gBAAgB,QAAQ,IAAI,QAAQ;;iBAKxE,iBAAiB,GAAG,gBAAgB,GAAG;;iBAKvC,iBAAiB,GAAG,gBAAgB,GAAG;;cAK1C,oBAAiB,WAAe"}
+{"version":3,"file":"media-tracks.d.ts","names":[],"sources":["../../../../src/media/media-tracks/media-tracks.ts"],"mappings":";;;UAuBiB;EACf,QAAQ;EACR,SAAS;EACT,YAAY;;;UAIG;EACf,WAAW;EACX,OAAO;;;;;;;iBAQO,mBAAmB,cAAc,wCAAwC;;;;;iBAazE,mBAAmB,cAAc,wCAAwC;;;;;;;iBAezE,mBACd,cAAc,uCACd,yBACC;;iBASa,mBACd,cAAc,uCACd,yBACC;;iBA8Ca,0BAA0B,UAAU,gBAAgB,YAAY,IAAI,QAAQ;;iBAK5E,0BAA0B,UAAU,gBAAgB,QAAQ,IAAI,QAAQ;;iBAKxE,iBAAiB,GAAG,gBAAgB,GAAG;;iBAKvC,iBAAiB,GAAG,gBAAgB,GAAG;;cAK1C,oBAAiB,WAAe"}

package/dist/dev/media/media-tracks/media-tracks.js

@@ -13,8 +13,8 @@ function dedupedVideoTracks(presentation) {
 	});
 }
 /**
-* The distinct audio tracks of a presentation, deduped by `language` + `name`
-* (first occurrence wins). Returns `[]` when the presentation is unresolved or has no audio tracks.
+* The distinct audio tracks of a presentation, deduped by `language` + `name` (first occurrence wins). Returns `[]`
+* when the presentation is unresolved or has no audio tracks.
 */
 function dedupedAudioTracks(presentation) {
 	if (!presentation) return [];
@@ -24,11 +24,10 @@ function dedupedAudioTracks(presentation) {
 	});
 }
 /**
-* Find a video track by id, searching the same candidate set the engine resolves
-* against ({@link dedupedVideoTracks}'s pre-dedupe source). Returns `undefined`
-* when absent. Maps the engine's resolved `selectedVideoTrackId` back to its
-* properties for `active` reflection — the resolved id may be a per-CDN copy that
-* isn't the representative {@link dedupedVideoTracks} kept.
+* Find a video track by id, searching the same candidate set the engine resolves against ({@link dedupedVideoTracks}'s
+* pre-dedupe source). Returns `undefined` when absent. Maps the engine's resolved `selectedVideoTrackId` back to its
+* properties for `active` reflection — the resolved id may be a per-CDN copy that isn't the representative
+* {@link dedupedVideoTracks} kept.
 */
 function findVideoTrackById(presentation, id) {
 	if (!presentation || !id) return void 0;
@@ -42,16 +41,16 @@ function findAudioTrackById(presentation, id) {
 	return track?.type === "audio" ? track : void 0;
 }
 /**
-* Shallow-equal two key objects by their own properties. Both come from the same
-* key builder, so they carry the same keys — a one-directional scan suffices.
+* Shallow-equal two key objects by their own properties. Both come from the same key builder, so they carry the same
+* keys — a one-directional scan suffices.
 */
 function sameKey(a, b) {
 	for (const attr in a) if (a[attr] !== b[attr]) return false;
 	return true;
 }
 /**
-* Dedupe tracks by a key function, keeping the first occurrence of each key.
-* Keys are compared field-by-field ({@link sameKey}).
+* Dedupe tracks by a key function, keeping the first occurrence of each key. Keys are compared field-by-field ({@link
+* sameKey}).
 */
 function dedupe({ tracks, keyFn }) {
 	const seen = [];
@@ -64,9 +63,7 @@ function dedupe({ tracks, keyFn }) {
 	}
 	return kept;
 }
-/**
-* Build a partial video track that can be used as `userVideoTrackSelection`.
-*/
+/** Build a partial video track that can be used as `userVideoTrackSelection`. */
 function toUserVideoTrackSelection(rendition) {
 	return rendition ? {
 		width: rendition.width,
@@ -74,9 +71,7 @@ function toUserVideoTrackSelection(rendition) {
 		bandwidth: rendition.bandwidth
 	} : void 0;
 }
-/**
-* Build a partial audio track that can be used as a `userAudioTrackSelection`.
-*/
+/** Build a partial audio track that can be used as a `userAudioTrackSelection`. */
 function toUserAudioTrackSelection(track) {
 	return track ? {
 		language: track.language,

package/dist/dev/media/media-tracks/media-tracks.js.map

@@ -1 +1 @@
-{"version":3,"file":"media-tracks.js","names":[],"sources":["../../../../src/media/media-tracks/media-tracks.ts"],"sourcesContent":["/**\n * Media-track translation utilities.\n *\n * Pure, DOM-free transforms from SPF's CMAF-HAM track model onto the deduped\n * lists a media-element adapter exposes (video renditions, audio tracks), plus\n * the selection-criteria builders that turn a chosen rendition/track back into a\n * `user*TrackSelection` partial the engine's track-switching reads.\n *\n * These return SPF *model vocabulary* (`bandwidth`, `codecs: string[]`,\n * `frameRate` as a rational `FrameRate`); the consuming adapter owns the\n * mapping (e.g. for DOM `bandwidth` -> `bitrate`, `codecs.join(',')` -> `codec`,\n * `name` -> `label`).\n *\n * Deduplication is by *properties*, never URL, so a multi-CDN source that lists\n * the same rendition on several hosts collapses to one entry: video renditions\n * by `width` + `height` + `bandwidth`, audio tracks by `language` + `name`.\n * The selection builders emit those same properties as the match criteria, so\n * selecting a collapsed entry re-selects, for example, every underlying per-CDN track.\n */\n\nimport type { AudioTrack, FrameRate, MaybeResolvedPresentation, VideoTrack } from '../types';\nimport { findTrackById, getTracksByType } from '../utils/tracks';\n\nexport type { AudioTrack, VideoTrack };\n\n/** Properties that identify a distinct video rendition (multi-CDN copies share them). */\nexport interface VideoDedupeKey {\n  width?: VideoTrack['width'];\n  height?: VideoTrack['height'];\n  bandwidth?: VideoTrack['bandwidth'];\n}\n\n/** Properties that identify a distinct audio track (multi-CDN copies share them). */\nexport interface AudioDedupeKey {\n  language?: AudioTrack['language'];\n  name?: AudioTrack['name'];\n}\n\n/**\n * The distinct video tracks of a presentation, deduped by {@link VideoDedupeKey} (first occurrence wins).\n *\n * Returns `[]` when the presentation is unresolved or has no video tracks.\n */\nexport function dedupedVideoTracks(presentation: MaybeResolvedPresentation | undefined): VideoTrack[] {\n  if (!presentation) return [];\n\n  return dedupe({\n    tracks: getTracksByType(presentation, 'video') as readonly VideoTrack[],\n    keyFn: toUserVideoTrackSelection,\n  });\n}\n\n/**\n * The distinct audio tracks of a presentation, deduped by `language` + `name`\n * (first occurrence wins). Returns `[]` when the presentation is unresolved or has no audio tracks.\n */\nexport function dedupedAudioTracks(presentation: MaybeResolvedPresentation | undefined): AudioTrack[] {\n  if (!presentation) return [];\n\n  return dedupe({\n    tracks: getTracksByType(presentation, 'audio') as readonly AudioTrack[],\n    keyFn: toUserAudioTrackSelection,\n  });\n}\n\n/**\n * Find a video track by id, searching the same candidate set the engine resolves\n * against ({@link dedupedVideoTracks}'s pre-dedupe source). Returns `undefined`\n * when absent. Maps the engine's resolved `selectedVideoTrackId` back to its\n * properties for `active` reflection — the resolved id may be a per-CDN copy that\n * isn't the representative {@link dedupedVideoTracks} kept.\n */\nexport function findVideoTrackById(\n  presentation: MaybeResolvedPresentation | undefined,\n  id: string | undefined\n): VideoTrack | undefined {\n  if (!presentation || !id) return undefined;\n  const track = findTrackById(presentation, id);\n  return track?.type === 'video' ? (track as VideoTrack) : undefined;\n}\n\n/** Audio counterpart of {@link findVideoTrackById}, for `enabled` reflection. */\nexport function findAudioTrackById(\n  presentation: MaybeResolvedPresentation | undefined,\n  id: string | undefined\n): AudioTrack | undefined {\n  if (!presentation || !id) return undefined;\n  const track = findTrackById(presentation, id);\n  return track?.type === 'audio' ? (track as AudioTrack) : undefined;\n}\n\n/**\n * Shallow-equal two key objects by their own properties. Both come from the same\n * key builder, so they carry the same keys — a one-directional scan suffices.\n */\nfunction sameKey<K extends object>(a: K, b: K): boolean {\n  for (const attr in a) {\n    if (a[attr] !== b[attr]) return false;\n  }\n  return true;\n}\n\n/**\n * Dedupe tracks by a key function, keeping the first occurrence of each key.\n * Keys are compared field-by-field ({@link sameKey}).\n */\nfunction dedupe<T, K extends object>({\n  tracks,\n  keyFn,\n}: {\n  tracks: readonly T[];\n  keyFn: (track: T) => K | undefined;\n}): T[] {\n  const seen: K[] = [];\n  const kept: T[] = [];\n  for (const track of tracks) {\n    const key = keyFn(track);\n    if (!key || seen.some((other) => sameKey(other, key))) continue;\n    seen.push(key);\n    kept.push(track);\n  }\n\n  return kept;\n}\n\n/**\n * Build a partial video track that can be used as `userVideoTrackSelection`.\n */\nexport function toUserVideoTrackSelection<T extends VideoDedupeKey>(rendition?: T): Partial<VideoTrack> | undefined {\n  return rendition ? { width: rendition.width, height: rendition.height, bandwidth: rendition.bandwidth } : undefined;\n}\n\n/**\n * Build a partial audio track that can be used as a `userAudioTrackSelection`.\n */\nexport function toUserAudioTrackSelection<T extends AudioDedupeKey>(track?: T): Partial<AudioTrack> | undefined {\n  return track ? { language: track.language, name: track.name } : undefined;\n}\n\n/** Whether two video tracks are the same by dedupe key */\nexport function isSameVideoTrack(a: VideoDedupeKey, b: VideoDedupeKey | undefined): boolean {\n  return !!b && a.width === b.width && a.height === b.height && a.bandwidth === b.bandwidth;\n}\n\n/** Whether two audio tracks are the same by dedupe key */\nexport function isSameAudioTrack(a: AudioDedupeKey, b: AudioDedupeKey | undefined): boolean {\n  return !!b && (a.language ?? '') === (b.language ?? '') && a.name === b.name;\n}\n\n/** Collapse a rational frame rate (numerator/denominator) to frames per second. */\nexport const frameRateToNumber = (frameRate: FrameRate) => {\n  return frameRate.frameRateNumerator / (frameRate.frameRateDenominator ?? 1);\n};\n"],"mappings":";;;;;;;AA2CA,SAAgB,mBAAmB,cAAmE;CACpG,IAAI,CAAC,cAAc,OAAO,CAAC;CAE3B,OAAO,OAAO;EACZ,QAAQ,gBAAgB,cAAc,OAAO;EAC7C,OAAO;CACT,CAAC;AACH;;;;;AAMA,SAAgB,mBAAmB,cAAmE;CACpG,IAAI,CAAC,cAAc,OAAO,CAAC;CAE3B,OAAO,OAAO;EACZ,QAAQ,gBAAgB,cAAc,OAAO;EAC7C,OAAO;CACT,CAAC;AACH;;;;;;;;AASA,SAAgB,mBACd,cACA,IACwB;CACxB,IAAI,CAAC,gBAAgB,CAAC,IAAI,OAAO,KAAA;CACjC,MAAM,QAAQ,cAAc,cAAc,EAAE;CAC5C,OAAO,OAAO,SAAS,UAAW,QAAuB,KAAA;AAC3D;;AAGA,SAAgB,mBACd,cACA,IACwB;CACxB,IAAI,CAAC,gBAAgB,CAAC,IAAI,OAAO,KAAA;CACjC,MAAM,QAAQ,cAAc,cAAc,EAAE;CAC5C,OAAO,OAAO,SAAS,UAAW,QAAuB,KAAA;AAC3D;;;;;AAMA,SAAS,QAA0B,GAAM,GAAe;CACtD,KAAK,MAAM,QAAQ,GACjB,IAAI,EAAE,UAAU,EAAE,OAAO,OAAO;CAElC,OAAO;AACT;;;;;AAMA,SAAS,OAA4B,EACnC,QACA,SAIM;CACN,MAAM,OAAY,CAAC;CACnB,MAAM,OAAY,CAAC;CACnB,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM,KAAK;EACvB,IAAI,CAAC,OAAO,KAAK,MAAM,UAAU,QAAQ,OAAO,GAAG,CAAC,GAAG;EACvD,KAAK,KAAK,GAAG;EACb,KAAK,KAAK,KAAK;CACjB;CAEA,OAAO;AACT;;;;AAKA,SAAgB,0BAAoD,WAAgD;CAClH,OAAO,YAAY;EAAE,OAAO,UAAU;EAAO,QAAQ,UAAU;EAAQ,WAAW,UAAU;CAAU,IAAI,KAAA;AAC5G;;;;AAKA,SAAgB,0BAAoD,OAA4C;CAC9G,OAAO,QAAQ;EAAE,UAAU,MAAM;EAAU,MAAM,MAAM;CAAK,IAAI,KAAA;AAClE;;AAGA,SAAgB,iBAAiB,GAAmB,GAAwC;CAC1F,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE;AAClF;;AAGA,SAAgB,iBAAiB,GAAmB,GAAwC;CAC1F,OAAO,CAAC,CAAC,MAAM,EAAE,YAAY,SAAS,EAAE,YAAY,OAAO,EAAE,SAAS,EAAE;AAC1E;;AAGA,MAAa,qBAAqB,cAAyB;CACzD,OAAO,UAAU,sBAAsB,UAAU,wBAAwB;AAC3E"}
+{"version":3,"file":"media-tracks.js","names":[],"sources":["../../../../src/media/media-tracks/media-tracks.ts"],"sourcesContent":["/**\n * Media-track translation utilities.\n *\n * Pure, DOM-free transforms from SPF's CMAF-HAM track model onto the deduped lists a media-element adapter exposes\n * (video renditions, audio tracks), plus the selection-criteria builders that turn a chosen rendition/track back into a\n * `user*TrackSelection` partial the engine's track-switching reads.\n *\n * These return SPF _model vocabulary_ (`bandwidth`, `codecs: string[]`, `frameRate` as a rational `FrameRate`); the\n * consuming adapter owns the mapping (e.g. for DOM `bandwidth` -> `bitrate`, `codecs.join(',')` -> `codec`, `name` ->\n * `label`).\n *\n * Deduplication is by _properties_, never URL, so a multi-CDN source that lists the same rendition on several hosts\n * collapses to one entry: video renditions by `width` + `height` + `bandwidth`, audio tracks by `language` + `name`.\n * The selection builders emit those same properties as the match criteria, so selecting a collapsed entry re-selects,\n * for example, every underlying per-CDN track.\n */\n\nimport type { AudioTrack, FrameRate, MaybeResolvedPresentation, VideoTrack } from '../types';\nimport { findTrackById, getTracksByType } from '../utils/tracks';\n\nexport type { AudioTrack, VideoTrack };\n\n/** Properties that identify a distinct video rendition (multi-CDN copies share them). */\nexport interface VideoDedupeKey {\n  width?: VideoTrack['width'];\n  height?: VideoTrack['height'];\n  bandwidth?: VideoTrack['bandwidth'];\n}\n\n/** Properties that identify a distinct audio track (multi-CDN copies share them). */\nexport interface AudioDedupeKey {\n  language?: AudioTrack['language'];\n  name?: AudioTrack['name'];\n}\n\n/**\n * The distinct video tracks of a presentation, deduped by {@link VideoDedupeKey} (first occurrence wins).\n *\n * Returns `[]` when the presentation is unresolved or has no video tracks.\n */\nexport function dedupedVideoTracks(presentation: MaybeResolvedPresentation | undefined): VideoTrack[] {\n  if (!presentation) return [];\n\n  return dedupe({\n    tracks: getTracksByType(presentation, 'video') as readonly VideoTrack[],\n    keyFn: toUserVideoTrackSelection,\n  });\n}\n\n/**\n * The distinct audio tracks of a presentation, deduped by `language` + `name` (first occurrence wins). Returns `[]`\n * when the presentation is unresolved or has no audio tracks.\n */\nexport function dedupedAudioTracks(presentation: MaybeResolvedPresentation | undefined): AudioTrack[] {\n  if (!presentation) return [];\n\n  return dedupe({\n    tracks: getTracksByType(presentation, 'audio') as readonly AudioTrack[],\n    keyFn: toUserAudioTrackSelection,\n  });\n}\n\n/**\n * Find a video track by id, searching the same candidate set the engine resolves against ({@link dedupedVideoTracks}'s\n * pre-dedupe source). Returns `undefined` when absent. Maps the engine's resolved `selectedVideoTrackId` back to its\n * properties for `active` reflection — the resolved id may be a per-CDN copy that isn't the representative\n * {@link dedupedVideoTracks} kept.\n */\nexport function findVideoTrackById(\n  presentation: MaybeResolvedPresentation | undefined,\n  id: string | undefined\n): VideoTrack | undefined {\n  if (!presentation || !id) return undefined;\n\n  const track = findTrackById(presentation, id);\n\n  return track?.type === 'video' ? (track as VideoTrack) : undefined;\n}\n\n/** Audio counterpart of {@link findVideoTrackById}, for `enabled` reflection. */\nexport function findAudioTrackById(\n  presentation: MaybeResolvedPresentation | undefined,\n  id: string | undefined\n): AudioTrack | undefined {\n  if (!presentation || !id) return undefined;\n\n  const track = findTrackById(presentation, id);\n\n  return track?.type === 'audio' ? (track as AudioTrack) : undefined;\n}\n\n/**\n * Shallow-equal two key objects by their own properties. Both come from the same key builder, so they carry the same\n * keys — a one-directional scan suffices.\n */\nfunction sameKey<K extends object>(a: K, b: K): boolean {\n  for (const attr in a) {\n    if (a[attr] !== b[attr]) return false;\n  }\n\n  return true;\n}\n\n/**\n * Dedupe tracks by a key function, keeping the first occurrence of each key. Keys are compared field-by-field ({@link\n * sameKey}).\n */\nfunction dedupe<T, K extends object>({\n  tracks,\n  keyFn,\n}: {\n  tracks: readonly T[];\n  keyFn: (track: T) => K | undefined;\n}): T[] {\n  const seen: K[] = [];\n  const kept: T[] = [];\n\n  for (const track of tracks) {\n    const key = keyFn(track);\n    if (!key || seen.some((other) => sameKey(other, key))) continue;\n\n    seen.push(key);\n    kept.push(track);\n  }\n\n  return kept;\n}\n\n/** Build a partial video track that can be used as `userVideoTrackSelection`. */\nexport function toUserVideoTrackSelection<T extends VideoDedupeKey>(rendition?: T): Partial<VideoTrack> | undefined {\n  return rendition ? { width: rendition.width, height: rendition.height, bandwidth: rendition.bandwidth } : undefined;\n}\n\n/** Build a partial audio track that can be used as a `userAudioTrackSelection`. */\nexport function toUserAudioTrackSelection<T extends AudioDedupeKey>(track?: T): Partial<AudioTrack> | undefined {\n  return track ? { language: track.language, name: track.name } : undefined;\n}\n\n/** Whether two video tracks are the same by dedupe key */\nexport function isSameVideoTrack(a: VideoDedupeKey, b: VideoDedupeKey | undefined): boolean {\n  return !!b && a.width === b.width && a.height === b.height && a.bandwidth === b.bandwidth;\n}\n\n/** Whether two audio tracks are the same by dedupe key */\nexport function isSameAudioTrack(a: AudioDedupeKey, b: AudioDedupeKey | undefined): boolean {\n  return !!b && (a.language ?? '') === (b.language ?? '') && a.name === b.name;\n}\n\n/** Collapse a rational frame rate (numerator/denominator) to frames per second. */\nexport const frameRateToNumber = (frameRate: FrameRate) => {\n  return frameRate.frameRateNumerator / (frameRate.frameRateDenominator ?? 1);\n};\n"],"mappings":";;;;;;;AAwCA,SAAgB,mBAAmB,cAAmE;CACpG,IAAI,CAAC,cAAc,OAAO,CAAC;CAE3B,OAAO,OAAO;EACZ,QAAQ,gBAAgB,cAAc,OAAO;EAC7C,OAAO;CACT,CAAC;AACH;;;;;AAMA,SAAgB,mBAAmB,cAAmE;CACpG,IAAI,CAAC,cAAc,OAAO,CAAC;CAE3B,OAAO,OAAO;EACZ,QAAQ,gBAAgB,cAAc,OAAO;EAC7C,OAAO;CACT,CAAC;AACH;;;;;;;AAQA,SAAgB,mBACd,cACA,IACwB;CACxB,IAAI,CAAC,gBAAgB,CAAC,IAAI,OAAO,KAAA;CAEjC,MAAM,QAAQ,cAAc,cAAc,EAAE;CAE5C,OAAO,OAAO,SAAS,UAAW,QAAuB,KAAA;AAC3D;;AAGA,SAAgB,mBACd,cACA,IACwB;CACxB,IAAI,CAAC,gBAAgB,CAAC,IAAI,OAAO,KAAA;CAEjC,MAAM,QAAQ,cAAc,cAAc,EAAE;CAE5C,OAAO,OAAO,SAAS,UAAW,QAAuB,KAAA;AAC3D;;;;;AAMA,SAAS,QAA0B,GAAM,GAAe;CACtD,KAAK,MAAM,QAAQ,GACjB,IAAI,EAAE,UAAU,EAAE,OAAO,OAAO;CAGlC,OAAO;AACT;;;;;AAMA,SAAS,OAA4B,EACnC,QACA,SAIM;CACN,MAAM,OAAY,CAAC;CACnB,MAAM,OAAY,CAAC;CAEnB,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM,KAAK;EACvB,IAAI,CAAC,OAAO,KAAK,MAAM,UAAU,QAAQ,OAAO,GAAG,CAAC,GAAG;EAEvD,KAAK,KAAK,GAAG;EACb,KAAK,KAAK,KAAK;CACjB;CAEA,OAAO;AACT;;AAGA,SAAgB,0BAAoD,WAAgD;CAClH,OAAO,YAAY;EAAE,OAAO,UAAU;EAAO,QAAQ,UAAU;EAAQ,WAAW,UAAU;CAAU,IAAI,KAAA;AAC5G;;AAGA,SAAgB,0BAAoD,OAA4C;CAC9G,OAAO,QAAQ;EAAE,UAAU,MAAM;EAAU,MAAM,MAAM;CAAK,IAAI,KAAA;AAClE;;AAGA,SAAgB,iBAAiB,GAAmB,GAAwC;CAC1F,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE;AAClF;;AAGA,SAAgB,iBAAiB,GAAmB,GAAwC;CAC1F,OAAO,CAAC,CAAC,MAAM,EAAE,YAAY,SAAS,EAAE,YAAY,OAAO,EAAE,SAAS,EAAE;AAC1E;;AAGA,MAAa,qBAAqB,cAAyB;CACzD,OAAO,UAAU,sBAAsB,UAAU,wBAAwB;AAC3E"}

package/dist/dev/media/mp4/box.js

@@ -32,9 +32,8 @@ function* iterateBoxesOfType(view, type, start = 0, end = view.byteLength) {
 	for (const box of iterateBoxes(view, start, end)) if (box.type === type) yield box;
 }
 /**
-* Depth-first descent to the first box matching a nested path, e.g.
-* `['moov', 'trak', 'mdia', 'mdhd']`. Returns `undefined` if any level is
-* absent.
+* Depth-first descent to the first box matching a nested path, e.g. `['moov', 'trak', 'mdia', 'mdhd']`. Returns
+* `undefined` if any level is absent.
 */
 function findBox(view, path, start = 0, end = view.byteLength) {
 	const [head, ...rest] = path;
@@ -46,8 +45,8 @@ function findBox(view, path, start = 0, end = view.byteLength) {
 	}
 }
 /**
-* Read the version byte of a FullBox — the `version(1) + flags(3)` header at the
-* start of the payload of `mdhd` / `tkhd` / `tfdt` / `hdlr` / `elst` / etc.
+* Read the version byte of a FullBox — the `version(1) + flags(3)` header at the start of the payload of `mdhd` /
+* `tkhd` / `tfdt` / `hdlr` / `elst` / etc.
 */
 function readFullBoxVersion(view, dataStart) {
 	return view.getUint8(dataStart);

package/dist/dev/media/mp4/box.js.map

@@ -1 +1 @@
-{"version":3,"file":"box.js","names":[],"sources":["../../../../src/media/mp4/box.ts"],"sourcesContent":["/**\n * Minimal ISO-BMFF (MP4/CMAF) box walker.\n *\n * Just enough to locate boxes by nested path — the framework needs a couple of\n * leaf fields (`mdhd` timescale, `tfdt` baseMediaDecodeTime) to derive a\n * segment's decode-time origin, not a full demuxer. DOM-free: operates on an\n * `ArrayBuffer` / `Uint8Array` via `DataView`.\n *\n * Box layout: `[u32 size][u32 type][payload]`. `size === 1` means a `u64\n * largesize` follows the type (payload after it); `size === 0` means the box\n * runs to the end of its container.\n */\n\n/** A located box: its 4-char type and byte offsets within the buffer. */\nexport interface Box {\n  type: string;\n  /** Offset of the box's first byte (its size field). */\n  start: number;\n  /** Offset of the box's payload — after `size` + `type` (+ `largesize`). */\n  dataStart: number;\n  /** Offset one past the box's last byte. */\n  end: number;\n}\n\nexport function toDataView(data: ArrayBuffer | Uint8Array): DataView {\n  return data instanceof Uint8Array ? new DataView(data.buffer, data.byteOffset, data.byteLength) : new DataView(data);\n}\n\n/** Read a 4-character box type / FourCC at `offset`. */\nexport function readFourCC(view: DataView, offset: number): string {\n  return String.fromCharCode(\n    view.getUint8(offset),\n    view.getUint8(offset + 1),\n    view.getUint8(offset + 2),\n    view.getUint8(offset + 3)\n  );\n}\n\n/** Iterate the boxes directly contained in `[start, end)`. */\nexport function* iterateBoxes(view: DataView, start = 0, end = view.byteLength): Generator<Box> {\n  let offset = start;\n  while (offset + 8 <= end) {\n    let size = view.getUint32(offset);\n    const type = readFourCC(view, offset + 4);\n    let dataStart = offset + 8;\n    if (size === 1) {\n      size = Number(view.getBigUint64(offset + 8));\n      dataStart = offset + 16;\n    } else if (size === 0) {\n      size = end - offset;\n    }\n    // A size smaller than its own header is malformed — stop rather than loop.\n    if (size < dataStart - offset) return;\n    yield { type, start: offset, dataStart, end: offset + size };\n    offset += size;\n  }\n}\n\n/** Iterate the direct child boxes of a given `type` within `[start, end)`. */\nexport function* iterateBoxesOfType(view: DataView, type: string, start = 0, end = view.byteLength): Generator<Box> {\n  for (const box of iterateBoxes(view, start, end)) {\n    if (box.type === type) yield box;\n  }\n}\n\n/**\n * Depth-first descent to the first box matching a nested path, e.g.\n * `['moov', 'trak', 'mdia', 'mdhd']`. Returns `undefined` if any level is\n * absent.\n */\nexport function findBox(view: DataView, path: readonly string[], start = 0, end = view.byteLength): Box | undefined {\n  const [head, ...rest] = path;\n  for (const box of iterateBoxes(view, start, end)) {\n    if (box.type !== head) continue;\n    if (rest.length === 0) return box;\n    const found = findBox(view, rest, box.dataStart, box.end);\n    if (found) return found;\n  }\n  return undefined;\n}\n\n/**\n * Read the version byte of a FullBox — the `version(1) + flags(3)` header at the\n * start of the payload of `mdhd` / `tkhd` / `tfdt` / `hdlr` / `elst` / etc.\n */\nexport function readFullBoxVersion(view: DataView, dataStart: number): number {\n  return view.getUint8(dataStart);\n}\n"],"mappings":";AAwBA,SAAgB,WAAW,MAA0C;CACnE,OAAO,gBAAgB,aAAa,IAAI,SAAS,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU,IAAI,IAAI,SAAS,IAAI;AACrH;;AAGA,SAAgB,WAAW,MAAgB,QAAwB;CACjE,OAAO,OAAO,aACZ,KAAK,SAAS,MAAM,GACpB,KAAK,SAAS,SAAS,CAAC,GACxB,KAAK,SAAS,SAAS,CAAC,GACxB,KAAK,SAAS,SAAS,CAAC,CAC1B;AACF;;AAGA,UAAiB,aAAa,MAAgB,QAAQ,GAAG,MAAM,KAAK,YAA4B;CAC9F,IAAI,SAAS;CACb,OAAO,SAAS,KAAK,KAAK;EACxB,IAAI,OAAO,KAAK,UAAU,MAAM;EAChC,MAAM,OAAO,WAAW,MAAM,SAAS,CAAC;EACxC,IAAI,YAAY,SAAS;EACzB,IAAI,SAAS,GAAG;GACd,OAAO,OAAO,KAAK,aAAa,SAAS,CAAC,CAAC;GAC3C,YAAY,SAAS;EACvB,OAAO,IAAI,SAAS,GAClB,OAAO,MAAM;EAGf,IAAI,OAAO,YAAY,QAAQ;EAC/B,MAAM;GAAE;GAAM,OAAO;GAAQ;GAAW,KAAK,SAAS;EAAK;EAC3D,UAAU;CACZ;AACF;;AAGA,UAAiB,mBAAmB,MAAgB,MAAc,QAAQ,GAAG,MAAM,KAAK,YAA4B;CAClH,KAAK,MAAM,OAAO,aAAa,MAAM,OAAO,GAAG,GAC7C,IAAI,IAAI,SAAS,MAAM,MAAM;AAEjC;;;;;;AAOA,SAAgB,QAAQ,MAAgB,MAAyB,QAAQ,GAAG,MAAM,KAAK,YAA6B;CAClH,MAAM,CAAC,MAAM,GAAG,QAAQ;CACxB,KAAK,MAAM,OAAO,aAAa,MAAM,OAAO,GAAG,GAAG;EAChD,IAAI,IAAI,SAAS,MAAM;EACvB,IAAI,KAAK,WAAW,GAAG,OAAO;EAC9B,MAAM,QAAQ,QAAQ,MAAM,MAAM,IAAI,WAAW,IAAI,GAAG;EACxD,IAAI,OAAO,OAAO;CACpB;AAEF;;;;;AAMA,SAAgB,mBAAmB,MAAgB,WAA2B;CAC5E,OAAO,KAAK,SAAS,SAAS;AAChC"}
+{"version":3,"file":"box.js","names":[],"sources":["../../../../src/media/mp4/box.ts"],"sourcesContent":["/**\n * Minimal ISO-BMFF (MP4/CMAF) box walker.\n *\n * Just enough to locate boxes by nested path — the framework needs a couple of leaf fields (`mdhd` timescale, `tfdt`\n * baseMediaDecodeTime) to derive a segment's decode-time origin, not a full demuxer. DOM-free: operates on an\n * `ArrayBuffer` / `Uint8Array` via `DataView`.\n *\n * Box layout: `[u32 size][u32 type][payload]`. `size === 1` means a `u64 largesize` follows the type (payload after\n * it); `size === 0` means the box runs to the end of its container.\n */\n\n/** A located box: its 4-char type and byte offsets within the buffer. */\nexport interface Box {\n  type: string;\n  /** Offset of the box's first byte (its size field). */\n  start: number;\n  /** Offset of the box's payload — after `size` + `type` (+ `largesize`). */\n  dataStart: number;\n  /** Offset one past the box's last byte. */\n  end: number;\n}\n\nexport function toDataView(data: ArrayBuffer | Uint8Array): DataView {\n  return data instanceof Uint8Array ? new DataView(data.buffer, data.byteOffset, data.byteLength) : new DataView(data);\n}\n\n/** Read a 4-character box type / FourCC at `offset`. */\nexport function readFourCC(view: DataView, offset: number): string {\n  return String.fromCharCode(\n    view.getUint8(offset),\n    view.getUint8(offset + 1),\n    view.getUint8(offset + 2),\n    view.getUint8(offset + 3)\n  );\n}\n\n/** Iterate the boxes directly contained in `[start, end)`. */\nexport function* iterateBoxes(view: DataView, start = 0, end = view.byteLength): Generator<Box> {\n  let offset = start;\n\n  while (offset + 8 <= end) {\n    let size = view.getUint32(offset);\n    const type = readFourCC(view, offset + 4);\n    let dataStart = offset + 8;\n\n    if (size === 1) {\n      size = Number(view.getBigUint64(offset + 8));\n      dataStart = offset + 16;\n    } else if (size === 0) {\n      size = end - offset;\n    }\n\n    // A size smaller than its own header is malformed — stop rather than loop.\n    if (size < dataStart - offset) return;\n\n    yield { type, start: offset, dataStart, end: offset + size };\n    offset += size;\n  }\n}\n\n/** Iterate the direct child boxes of a given `type` within `[start, end)`. */\nexport function* iterateBoxesOfType(view: DataView, type: string, start = 0, end = view.byteLength): Generator<Box> {\n  for (const box of iterateBoxes(view, start, end)) {\n    if (box.type === type) yield box;\n  }\n}\n\n/**\n * Depth-first descent to the first box matching a nested path, e.g. `['moov', 'trak', 'mdia', 'mdhd']`. Returns\n * `undefined` if any level is absent.\n */\nexport function findBox(view: DataView, path: readonly string[], start = 0, end = view.byteLength): Box | undefined {\n  const [head, ...rest] = path;\n\n  for (const box of iterateBoxes(view, start, end)) {\n    if (box.type !== head) continue;\n\n    if (rest.length === 0) return box;\n\n    const found = findBox(view, rest, box.dataStart, box.end);\n    if (found) return found;\n  }\n\n  return undefined;\n}\n\n/**\n * Read the version byte of a FullBox — the `version(1) + flags(3)` header at the start of the payload of `mdhd` /\n * `tkhd` / `tfdt` / `hdlr` / `elst` / etc.\n */\nexport function readFullBoxVersion(view: DataView, dataStart: number): number {\n  return view.getUint8(dataStart);\n}\n"],"mappings":";AAsBA,SAAgB,WAAW,MAA0C;CACnE,OAAO,gBAAgB,aAAa,IAAI,SAAS,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU,IAAI,IAAI,SAAS,IAAI;AACrH;;AAGA,SAAgB,WAAW,MAAgB,QAAwB;CACjE,OAAO,OAAO,aACZ,KAAK,SAAS,MAAM,GACpB,KAAK,SAAS,SAAS,CAAC,GACxB,KAAK,SAAS,SAAS,CAAC,GACxB,KAAK,SAAS,SAAS,CAAC,CAC1B;AACF;;AAGA,UAAiB,aAAa,MAAgB,QAAQ,GAAG,MAAM,KAAK,YAA4B;CAC9F,IAAI,SAAS;CAEb,OAAO,SAAS,KAAK,KAAK;EACxB,IAAI,OAAO,KAAK,UAAU,MAAM;EAChC,MAAM,OAAO,WAAW,MAAM,SAAS,CAAC;EACxC,IAAI,YAAY,SAAS;EAEzB,IAAI,SAAS,GAAG;GACd,OAAO,OAAO,KAAK,aAAa,SAAS,CAAC,CAAC;GAC3C,YAAY,SAAS;EACvB,OAAO,IAAI,SAAS,GAClB,OAAO,MAAM;EAIf,IAAI,OAAO,YAAY,QAAQ;EAE/B,MAAM;GAAE;GAAM,OAAO;GAAQ;GAAW,KAAK,SAAS;EAAK;EAC3D,UAAU;CACZ;AACF;;AAGA,UAAiB,mBAAmB,MAAgB,MAAc,QAAQ,GAAG,MAAM,KAAK,YAA4B;CAClH,KAAK,MAAM,OAAO,aAAa,MAAM,OAAO,GAAG,GAC7C,IAAI,IAAI,SAAS,MAAM,MAAM;AAEjC;;;;;AAMA,SAAgB,QAAQ,MAAgB,MAAyB,QAAQ,GAAG,MAAM,KAAK,YAA6B;CAClH,MAAM,CAAC,MAAM,GAAG,QAAQ;CAExB,KAAK,MAAM,OAAO,aAAa,MAAM,OAAO,GAAG,GAAG;EAChD,IAAI,IAAI,SAAS,MAAM;EAEvB,IAAI,KAAK,WAAW,GAAG,OAAO;EAE9B,MAAM,QAAQ,QAAQ,MAAM,MAAM,IAAI,WAAW,IAAI,GAAG;EACxD,IAAI,OAAO,OAAO;CACpB;AAGF;;;;;AAMA,SAAgB,mBAAmB,MAAgB,WAA2B;CAC5E,OAAO,KAAK,SAAS,SAAS;AAChC"}

package/dist/dev/media/mp4/timestamp-origin.js

@@ -3,54 +3,43 @@ import { findBox, iterateBoxesOfType, readFourCC, readFullBoxVersion, toDataView
 /**
 * Decode-time origin extraction from fMP4/CMAF segments.
 *
-* Non-zero-PTS sources encode media at a non-zero start time (an instant clip
-* starting at asset second 60, an Apple bipbop asset starting at 10s, …). To
-* relocate such a source onto a 0-based presentation timeline via
-* `SourceBuffer.timestampOffset`, the engine needs that start time — the
-* **decode-time origin** — read straight from the container:
+* Non-zero-PTS sources encode media at a non-zero start time (an instant clip starting at asset second 60, an Apple
+* bipbop asset starting at 10s, …). To relocate such a source onto a 0-based presentation timeline via
+* `SourceBuffer.timestampOffset`, the engine needs that start time — the **decode-time origin** — read straight from
+* the container:
 *
-* - `tfdt.baseMediaDecodeTime` (from a media segment's `moof`) — the decode
-*   time of the segment's first sample, in the track's media timescale. This is
-*   a DTS: relocating by `−(baseMediaDecodeTime / timescale)` lands the earliest
-*   DTS at exactly 0, so a negative-DTS append failure on Chromium is impossible
-*   by construction.
-* - `mdhd.timescale` (from the init segment's `moov`) — ticks per second for
-*   that track, needed to convert the raw tick count to seconds.
+* - `tfdt.baseMediaDecodeTime` (from a media segment's `moof`) — the decode time of the segment's first sample, in the
+*   track's media timescale. This is a DTS: relocating by `−(baseMediaDecodeTime / timescale)` lands the earliest DTS
+*   at exactly 0, so a negative-DTS append failure on Chromium is impossible by construction.
+* - `mdhd.timescale` (from the init segment's `moov`) — ticks per second for that track, needed to convert the raw tick
+*   count to seconds.
 *
 * ## Presumptive vs. track-selected reads
 *
-* The two variants share only the leaf field-readers (`mdhd` timescale, `tfdt`
-* baseMediaDecodeTime) and the box walker. Everything else differs, and the
-* split is deliberate so the presumptive pair is *proportionally* smaller under
+* The two variants share only the leaf field-readers (`mdhd` timescale, `tfdt` baseMediaDecodeTime) and the box walker.
+* Everything else differs, and the split is deliberate so the presumptive pair is _proportionally_ smaller under
 * tree-shaking:
 *
-* - **Presumptive** — {@link readFirstMediaTimescale} / {@link readFirstBaseMediaDecodeTime}
-*   read the first `mdhd` timescale and first `tfdt` baseMediaDecodeTime. There's
-*   no `track_id` (nothing to match against) and no `trak`/`traf` iteration — a
-*   direct `findBox` to the first leaf. Correct when the init/segment holds a
-*   single media track (the common CMAF case). A caption-free platform imports
-*   only this pair and tree-shakes away all the matching machinery below.
-* - **Track-selected** — {@link findMediaTrack} / {@link readBaseMediaDecodeTime}.
-*   `findMediaTrack` returns `{ trackId, timescale }` for the `trak` whose `hdlr`
-*   handler matches; `readBaseMediaDecodeTime` takes that `trackId` and reads the
-*   `traf` whose `tfhd.track_id` matches. The `track_id` is the join that ties one
-*   track's timescale to the *same* track's baseMediaDecodeTime — required when a
-*   source muxes CEA-608/708 captions (a `clcp` track shares the same `moov` and
-*   `moof`, each track with its own timescale + baseMediaDecodeTime, so a
-*   presumptive read there risks `300000 / 6000 = 50s` instead of
-*   `60000 / 6000 = 10s`). This pair adds `trak`/`traf` iteration plus the handler
-*   and `track_id` reads. We only ever ask for buffered media handlers
-*   (`vide` / `soun`); the caption track is never selected — we read the origin,
-*   not the captions (caption *rendering* is out of scope).
+* - **Presumptive** — {@link readFirstMediaTimescale} / {@link readFirstBaseMediaDecodeTime} read the first `mdhd`
+*   timescale and first `tfdt` baseMediaDecodeTime. There's no `track_id` (nothing to match against) and no
+*   `trak`/`traf` iteration — a direct `findBox` to the first leaf. Correct when the init/segment holds a single media
+*   track (the common CMAF case). A caption-free platform imports only this pair and tree-shakes away all the matching
+*   machinery below.
+* - **Track-selected** — {@link findMediaTrack} / {@link readBaseMediaDecodeTime}. `findMediaTrack` returns `{ trackId,
+*   timescale }` for the `trak` whose `hdlr` handler matches; `readBaseMediaDecodeTime` takes that `trackId` and reads
+*   the `traf` whose `tfhd.track_id` matches. The `track_id` is the join that ties one track's timescale to the _same_
+*   track's baseMediaDecodeTime — required when a source muxes CEA-608/708 captions (a `clcp` track shares the same
+*   `moov` and `moof`, each track with its own timescale + baseMediaDecodeTime, so a presumptive read there risks
+*   `300000 / 6000 = 50s` instead of `60000 / 6000 = 10s`). This pair adds `trak`/`traf` iteration plus the handler and
+*   `track_id` reads. We only ever ask for buffered media handlers (`vide` / `soun`); the caption track is never
+*   selected — we read the origin, not the captions (caption _rendering_ is out of scope).
 *
-* Both raw values are returned un-divided to leave room for an edit-list (`elst`)
-* presentation-time correction term if a source ever carries one — the validated
-* streams do not.
+* Both raw values are returned un-divided to leave room for an edit-list (`elst`) presentation-time correction term if
+* a source ever carries one — the validated streams do not.
 */
 /**
-* The `track_ID` + timescale of the `trak` whose `mdhd` handler matches
-* `handlerType`, skipping a muxed `clcp` caption track. `undefined` if no
-* matching track exists.
+* The `track_ID` + timescale of the `trak` whose `mdhd` handler matches `handlerType`, skipping a muxed `clcp` caption
+* track. `undefined` if no matching track exists.
 */
 function findMediaTrack(initSegment, handlerType) {
 	const view = toDataView(initSegment);
@@ -68,9 +57,8 @@ function findMediaTrack(initSegment, handlerType) {
 	}
 }
 /**
-* `baseMediaDecodeTime` (in the track's media timescale) from the `traf` matching
-* `trackId` (via `tfhd.track_id`) — required for muxed multi-`traf` segments.
-* `undefined` if no matching `tfdt` exists.
+* `baseMediaDecodeTime` (in the track's media timescale) from the `traf` matching `trackId` (via `tfhd.track_id`) —
+* required for muxed multi-`traf` segments. `undefined` if no matching `tfdt` exists.
 */
 function readBaseMediaDecodeTime(mediaSegment, trackId) {
 	const view = toDataView(mediaSegment);

package/dist/dev/media/mp4/timestamp-origin.js.map

@@ -1 +1 @@
-{"version":3,"file":"timestamp-origin.js","names":[],"sources":["../../../../src/media/mp4/timestamp-origin.ts"],"sourcesContent":["/**\n * Decode-time origin extraction from fMP4/CMAF segments.\n *\n * Non-zero-PTS sources encode media at a non-zero start time (an instant clip\n * starting at asset second 60, an Apple bipbop asset starting at 10s, …). To\n * relocate such a source onto a 0-based presentation timeline via\n * `SourceBuffer.timestampOffset`, the engine needs that start time — the\n * **decode-time origin** — read straight from the container:\n *\n * - `tfdt.baseMediaDecodeTime` (from a media segment's `moof`) — the decode\n *   time of the segment's first sample, in the track's media timescale. This is\n *   a DTS: relocating by `−(baseMediaDecodeTime / timescale)` lands the earliest\n *   DTS at exactly 0, so a negative-DTS append failure on Chromium is impossible\n *   by construction.\n * - `mdhd.timescale` (from the init segment's `moov`) — ticks per second for\n *   that track, needed to convert the raw tick count to seconds.\n *\n * ## Presumptive vs. track-selected reads\n *\n * The two variants share only the leaf field-readers (`mdhd` timescale, `tfdt`\n * baseMediaDecodeTime) and the box walker. Everything else differs, and the\n * split is deliberate so the presumptive pair is *proportionally* smaller under\n * tree-shaking:\n *\n * - **Presumptive** — {@link readFirstMediaTimescale} / {@link readFirstBaseMediaDecodeTime}\n *   read the first `mdhd` timescale and first `tfdt` baseMediaDecodeTime. There's\n *   no `track_id` (nothing to match against) and no `trak`/`traf` iteration — a\n *   direct `findBox` to the first leaf. Correct when the init/segment holds a\n *   single media track (the common CMAF case). A caption-free platform imports\n *   only this pair and tree-shakes away all the matching machinery below.\n * - **Track-selected** — {@link findMediaTrack} / {@link readBaseMediaDecodeTime}.\n *   `findMediaTrack` returns `{ trackId, timescale }` for the `trak` whose `hdlr`\n *   handler matches; `readBaseMediaDecodeTime` takes that `trackId` and reads the\n *   `traf` whose `tfhd.track_id` matches. The `track_id` is the join that ties one\n *   track's timescale to the *same* track's baseMediaDecodeTime — required when a\n *   source muxes CEA-608/708 captions (a `clcp` track shares the same `moov` and\n *   `moof`, each track with its own timescale + baseMediaDecodeTime, so a\n *   presumptive read there risks `300000 / 6000 = 50s` instead of\n *   `60000 / 6000 = 10s`). This pair adds `trak`/`traf` iteration plus the handler\n *   and `track_id` reads. We only ever ask for buffered media handlers\n *   (`vide` / `soun`); the caption track is never selected — we read the origin,\n *   not the captions (caption *rendering* is out of scope).\n *\n * Both raw values are returned un-divided to leave room for an edit-list (`elst`)\n * presentation-time correction term if a source ever carries one — the validated\n * streams do not.\n */\nimport { type Box, findBox, iterateBoxesOfType, readFourCC, readFullBoxVersion, toDataView } from './box';\n\n/** MSE-buffered media handler types (`mdhd`/`hdlr`). Captions/subtitles excluded. */\nexport type MediaHandlerType = 'vide' | 'soun';\n\nexport interface MediaTrackInfo {\n  /** `tkhd.track_id` — used to match the corresponding `traf` in media segments. */\n  trackId: number;\n  /** `mdhd.timescale` — ticks per second for this track. */\n  timescale: number;\n}\n\n// --- presumptive: first leaf, no track_id, no iteration -----------------------\n\n/**\n * Presumptive: the `timescale` of the **first** `mdhd` in an init segment.\n * Correct only for single-media-track inits — for muxed captions use\n * {@link findMediaTrack}. `undefined` if no `mdhd` exists.\n */\nexport function readFirstMediaTimescale(initSegment: ArrayBuffer | Uint8Array): number | undefined {\n  const view = toDataView(initSegment);\n  const mdhd = findBox(view, ['moov', 'trak', 'mdia', 'mdhd']);\n  return mdhd ? readMdhdTimescale(view, mdhd) : undefined;\n}\n\n/**\n * Presumptive: `baseMediaDecodeTime` from the **first** `tfdt` of a media\n * segment. Correct only for single-`traf` segments — for muxed captions use\n * {@link readBaseMediaDecodeTime}. `undefined` if no `tfdt` exists.\n */\nexport function readFirstBaseMediaDecodeTime(mediaSegment: ArrayBuffer | Uint8Array): number | undefined {\n  const view = toDataView(mediaSegment);\n  const tfdt = findBox(view, ['moof', 'traf', 'tfdt']);\n  return tfdt ? readTfdtBaseMediaDecodeTime(view, tfdt) : undefined;\n}\n\n// --- track-selected: iterate + match by handler / track_id --------------------\n\n/**\n * The `track_ID` + timescale of the `trak` whose `mdhd` handler matches\n * `handlerType`, skipping a muxed `clcp` caption track. `undefined` if no\n * matching track exists.\n */\nexport function findMediaTrack(\n  initSegment: ArrayBuffer | Uint8Array,\n  handlerType: MediaHandlerType\n): MediaTrackInfo | undefined {\n  const view = toDataView(initSegment);\n  const moov = findBox(view, ['moov']);\n  if (!moov) return undefined;\n\n  for (const trak of iterateBoxesOfType(view, 'trak', moov.dataStart, moov.end)) {\n    if (readTrakHandler(view, trak) !== handlerType) continue;\n    const tkhd = findBox(view, ['tkhd'], trak.dataStart, trak.end);\n    const mdhd = findBox(view, ['mdia', 'mdhd'], trak.dataStart, trak.end);\n    if (!tkhd || !mdhd) return undefined;\n    // tkhd FullBox: version(1)+flags(3), creation/modification dates (v0: 4+4, v1:\n    // 8+8), then track_id.\n    const trackId = view.getUint32(tkhd.dataStart + 4 + (readFullBoxVersion(view, tkhd.dataStart) === 1 ? 16 : 8));\n    return { trackId, timescale: readMdhdTimescale(view, mdhd) };\n  }\n  return undefined;\n}\n\n/**\n * `baseMediaDecodeTime` (in the track's media timescale) from the `traf` matching\n * `trackId` (via `tfhd.track_id`) — required for muxed multi-`traf` segments.\n * `undefined` if no matching `tfdt` exists.\n */\nexport function readBaseMediaDecodeTime(mediaSegment: ArrayBuffer | Uint8Array, trackId: number): number | undefined {\n  const view = toDataView(mediaSegment);\n  const moof = findBox(view, ['moof']);\n  if (!moof) return undefined;\n\n  for (const traf of iterateBoxesOfType(view, 'traf', moof.dataStart, moof.end)) {\n    if (readTrafTrackId(view, traf) !== trackId) continue;\n    const tfdt = findBox(view, ['tfdt'], traf.dataStart, traf.end);\n    return tfdt ? readTfdtBaseMediaDecodeTime(view, tfdt) : undefined;\n  }\n  return undefined;\n}\n\n// --- shared leaf field-readers ------------------------------------------------\n\n/** `mdhd.timescale`: FullBox version(1)+flags(3) + dates (v0: 4+4, v1: 8+8) + timescale. */\nfunction readMdhdTimescale(view: DataView, mdhd: Box): number {\n  return view.getUint32(mdhd.dataStart + 4 + (readFullBoxVersion(view, mdhd.dataStart) === 1 ? 16 : 8));\n}\n\n/** `tfdt.baseMediaDecodeTime`: FullBox, then the value — v0: (4), v1: (8). */\nfunction readTfdtBaseMediaDecodeTime(view: DataView, tfdt: Box): number {\n  const at = tfdt.dataStart + 4;\n  return readFullBoxVersion(view, tfdt.dataStart) === 1 ? Number(view.getBigUint64(at)) : view.getUint32(at);\n}\n\n// --- track-selection readers (referenced only by the track-selected variants) -\n\n/** `hdlr.handler_type` for a `trak`: FullBox version(1)+flags(3) + pre_defined(4) + handler_type(4). */\nfunction readTrakHandler(view: DataView, trak: Box): string | undefined {\n  const hdlr = findBox(view, ['mdia', 'hdlr'], trak.dataStart, trak.end);\n  return hdlr ? readFourCC(view, hdlr.dataStart + 8) : undefined;\n}\n\n/** `tfhd.track_id` for a `traf`: FullBox version(1)+flags(3) + track_id(4). */\nfunction readTrafTrackId(view: DataView, traf: Box): number | undefined {\n  const tfhd = findBox(view, ['tfhd'], traf.dataStart, traf.end);\n  return tfhd ? view.getUint32(tfhd.dataStart + 4) : undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,eACd,aACA,aAC4B;CAC5B,MAAM,OAAO,WAAW,WAAW;CACnC,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,CAAC;CACnC,IAAI,CAAC,MAAM,OAAO,KAAA;CAElB,KAAK,MAAM,QAAQ,mBAAmB,MAAM,QAAQ,KAAK,WAAW,KAAK,GAAG,GAAG;EAC7E,IAAI,gBAAgB,MAAM,IAAI,MAAM,aAAa;EACjD,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;EAC7D,MAAM,OAAO,QAAQ,MAAM,CAAC,QAAQ,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;EACrE,IAAI,CAAC,QAAQ,CAAC,MAAM,OAAO,KAAA;EAI3B,OAAO;GAAE,SADO,KAAK,UAAU,KAAK,YAAY,KAAK,mBAAmB,MAAM,KAAK,SAAS,MAAM,IAAI,KAAK,EAC5F;GAAG,WAAW,kBAAkB,MAAM,IAAI;EAAE;CAC7D;AAEF;;;;;;AAOA,SAAgB,wBAAwB,cAAwC,SAAqC;CACnH,MAAM,OAAO,WAAW,YAAY;CACpC,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,CAAC;CACnC,IAAI,CAAC,MAAM,OAAO,KAAA;CAElB,KAAK,MAAM,QAAQ,mBAAmB,MAAM,QAAQ,KAAK,WAAW,KAAK,GAAG,GAAG;EAC7E,IAAI,gBAAgB,MAAM,IAAI,MAAM,SAAS;EAC7C,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;EAC7D,OAAO,OAAO,4BAA4B,MAAM,IAAI,IAAI,KAAA;CAC1D;AAEF;;AAKA,SAAS,kBAAkB,MAAgB,MAAmB;CAC5D,OAAO,KAAK,UAAU,KAAK,YAAY,KAAK,mBAAmB,MAAM,KAAK,SAAS,MAAM,IAAI,KAAK,EAAE;AACtG;;AAGA,SAAS,4BAA4B,MAAgB,MAAmB;CACtE,MAAM,KAAK,KAAK,YAAY;CAC5B,OAAO,mBAAmB,MAAM,KAAK,SAAS,MAAM,IAAI,OAAO,KAAK,aAAa,EAAE,CAAC,IAAI,KAAK,UAAU,EAAE;AAC3G;;AAKA,SAAS,gBAAgB,MAAgB,MAA+B;CACtE,MAAM,OAAO,QAAQ,MAAM,CAAC,QAAQ,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;CACrE,OAAO,OAAO,WAAW,MAAM,KAAK,YAAY,CAAC,IAAI,KAAA;AACvD;;AAGA,SAAS,gBAAgB,MAAgB,MAA+B;CACtE,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;CAC7D,OAAO,OAAO,KAAK,UAAU,KAAK,YAAY,CAAC,IAAI,KAAA;AACrD"}
+{"version":3,"file":"timestamp-origin.js","names":[],"sources":["../../../../src/media/mp4/timestamp-origin.ts"],"sourcesContent":["/**\n * Decode-time origin extraction from fMP4/CMAF segments.\n *\n * Non-zero-PTS sources encode media at a non-zero start time (an instant clip starting at asset second 60, an Apple\n * bipbop asset starting at 10s, …). To relocate such a source onto a 0-based presentation timeline via\n * `SourceBuffer.timestampOffset`, the engine needs that start time — the **decode-time origin** — read straight from\n * the container:\n *\n * - `tfdt.baseMediaDecodeTime` (from a media segment's `moof`) — the decode time of the segment's first sample, in the\n *   track's media timescale. This is a DTS: relocating by `−(baseMediaDecodeTime / timescale)` lands the earliest DTS\n *   at exactly 0, so a negative-DTS append failure on Chromium is impossible by construction.\n * - `mdhd.timescale` (from the init segment's `moov`) — ticks per second for that track, needed to convert the raw tick\n *   count to seconds.\n *\n * ## Presumptive vs. track-selected reads\n *\n * The two variants share only the leaf field-readers (`mdhd` timescale, `tfdt` baseMediaDecodeTime) and the box walker.\n * Everything else differs, and the split is deliberate so the presumptive pair is _proportionally_ smaller under\n * tree-shaking:\n *\n * - **Presumptive** — {@link readFirstMediaTimescale} / {@link readFirstBaseMediaDecodeTime} read the first `mdhd`\n *   timescale and first `tfdt` baseMediaDecodeTime. There's no `track_id` (nothing to match against) and no\n *   `trak`/`traf` iteration — a direct `findBox` to the first leaf. Correct when the init/segment holds a single media\n *   track (the common CMAF case). A caption-free platform imports only this pair and tree-shakes away all the matching\n *   machinery below.\n * - **Track-selected** — {@link findMediaTrack} / {@link readBaseMediaDecodeTime}. `findMediaTrack` returns `{ trackId,\n *   timescale }` for the `trak` whose `hdlr` handler matches; `readBaseMediaDecodeTime` takes that `trackId` and reads\n *   the `traf` whose `tfhd.track_id` matches. The `track_id` is the join that ties one track's timescale to the _same_\n *   track's baseMediaDecodeTime — required when a source muxes CEA-608/708 captions (a `clcp` track shares the same\n *   `moov` and `moof`, each track with its own timescale + baseMediaDecodeTime, so a presumptive read there risks\n *   `300000 / 6000 = 50s` instead of `60000 / 6000 = 10s`). This pair adds `trak`/`traf` iteration plus the handler and\n *   `track_id` reads. We only ever ask for buffered media handlers (`vide` / `soun`); the caption track is never\n *   selected — we read the origin, not the captions (caption _rendering_ is out of scope).\n *\n * Both raw values are returned un-divided to leave room for an edit-list (`elst`) presentation-time correction term if\n * a source ever carries one — the validated streams do not.\n */\nimport { type Box, findBox, iterateBoxesOfType, readFourCC, readFullBoxVersion, toDataView } from './box';\n\n/** MSE-buffered media handler types (`mdhd`/`hdlr`). Captions/subtitles excluded. */\nexport type MediaHandlerType = 'vide' | 'soun';\n\nexport interface MediaTrackInfo {\n  /** `tkhd.track_id` — used to match the corresponding `traf` in media segments. */\n  trackId: number;\n  /** `mdhd.timescale` — ticks per second for this track. */\n  timescale: number;\n}\n\n// --- presumptive: first leaf, no track_id, no iteration -----------------------\n\n/**\n * Presumptive: the `timescale` of the **first** `mdhd` in an init segment. Correct only for single-media-track inits —\n * for muxed captions use {@link findMediaTrack}. `undefined` if no `mdhd` exists.\n */\nexport function readFirstMediaTimescale(initSegment: ArrayBuffer | Uint8Array): number | undefined {\n  const view = toDataView(initSegment);\n  const mdhd = findBox(view, ['moov', 'trak', 'mdia', 'mdhd']);\n\n  return mdhd ? readMdhdTimescale(view, mdhd) : undefined;\n}\n\n/**\n * Presumptive: `baseMediaDecodeTime` from the **first** `tfdt` of a media segment. Correct only for single-`traf`\n * segments — for muxed captions use {@link readBaseMediaDecodeTime}. `undefined` if no `tfdt` exists.\n */\nexport function readFirstBaseMediaDecodeTime(mediaSegment: ArrayBuffer | Uint8Array): number | undefined {\n  const view = toDataView(mediaSegment);\n  const tfdt = findBox(view, ['moof', 'traf', 'tfdt']);\n\n  return tfdt ? readTfdtBaseMediaDecodeTime(view, tfdt) : undefined;\n}\n\n// --- track-selected: iterate + match by handler / track_id --------------------\n\n/**\n * The `track_ID` + timescale of the `trak` whose `mdhd` handler matches `handlerType`, skipping a muxed `clcp` caption\n * track. `undefined` if no matching track exists.\n */\nexport function findMediaTrack(\n  initSegment: ArrayBuffer | Uint8Array,\n  handlerType: MediaHandlerType\n): MediaTrackInfo | undefined {\n  const view = toDataView(initSegment);\n  const moov = findBox(view, ['moov']);\n  if (!moov) return undefined;\n\n  for (const trak of iterateBoxesOfType(view, 'trak', moov.dataStart, moov.end)) {\n    if (readTrakHandler(view, trak) !== handlerType) continue;\n\n    const tkhd = findBox(view, ['tkhd'], trak.dataStart, trak.end);\n    const mdhd = findBox(view, ['mdia', 'mdhd'], trak.dataStart, trak.end);\n    if (!tkhd || !mdhd) return undefined;\n\n    // tkhd FullBox: version(1)+flags(3), creation/modification dates (v0: 4+4, v1:\n    // 8+8), then track_id.\n    const trackId = view.getUint32(tkhd.dataStart + 4 + (readFullBoxVersion(view, tkhd.dataStart) === 1 ? 16 : 8));\n\n    return { trackId, timescale: readMdhdTimescale(view, mdhd) };\n  }\n\n  return undefined;\n}\n\n/**\n * `baseMediaDecodeTime` (in the track's media timescale) from the `traf` matching `trackId` (via `tfhd.track_id`) —\n * required for muxed multi-`traf` segments. `undefined` if no matching `tfdt` exists.\n */\nexport function readBaseMediaDecodeTime(mediaSegment: ArrayBuffer | Uint8Array, trackId: number): number | undefined {\n  const view = toDataView(mediaSegment);\n  const moof = findBox(view, ['moof']);\n  if (!moof) return undefined;\n\n  for (const traf of iterateBoxesOfType(view, 'traf', moof.dataStart, moof.end)) {\n    if (readTrafTrackId(view, traf) !== trackId) continue;\n\n    const tfdt = findBox(view, ['tfdt'], traf.dataStart, traf.end);\n\n    return tfdt ? readTfdtBaseMediaDecodeTime(view, tfdt) : undefined;\n  }\n\n  return undefined;\n}\n\n// --- shared leaf field-readers ------------------------------------------------\n\n/** `mdhd.timescale`: FullBox version(1)+flags(3) + dates (v0: 4+4, v1: 8+8) + timescale. */\nfunction readMdhdTimescale(view: DataView, mdhd: Box): number {\n  return view.getUint32(mdhd.dataStart + 4 + (readFullBoxVersion(view, mdhd.dataStart) === 1 ? 16 : 8));\n}\n\n/** `tfdt.baseMediaDecodeTime`: FullBox, then the value — v0: (4), v1: (8). */\nfunction readTfdtBaseMediaDecodeTime(view: DataView, tfdt: Box): number {\n  const at = tfdt.dataStart + 4;\n\n  return readFullBoxVersion(view, tfdt.dataStart) === 1 ? Number(view.getBigUint64(at)) : view.getUint32(at);\n}\n\n// --- track-selection readers (referenced only by the track-selected variants) -\n\n/** `hdlr.handler_type` for a `trak`: FullBox version(1)+flags(3) + pre_defined(4) + handler_type(4). */\nfunction readTrakHandler(view: DataView, trak: Box): string | undefined {\n  const hdlr = findBox(view, ['mdia', 'hdlr'], trak.dataStart, trak.end);\n\n  return hdlr ? readFourCC(view, hdlr.dataStart + 8) : undefined;\n}\n\n/** `tfhd.track_id` for a `traf`: FullBox version(1)+flags(3) + track_id(4). */\nfunction readTrafTrackId(view: DataView, traf: Box): number | undefined {\n  const tfhd = findBox(view, ['tfhd'], traf.dataStart, traf.end);\n\n  return tfhd ? view.getUint32(tfhd.dataStart + 4) : undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+EA,SAAgB,eACd,aACA,aAC4B;CAC5B,MAAM,OAAO,WAAW,WAAW;CACnC,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,CAAC;CACnC,IAAI,CAAC,MAAM,OAAO,KAAA;CAElB,KAAK,MAAM,QAAQ,mBAAmB,MAAM,QAAQ,KAAK,WAAW,KAAK,GAAG,GAAG;EAC7E,IAAI,gBAAgB,MAAM,IAAI,MAAM,aAAa;EAEjD,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;EAC7D,MAAM,OAAO,QAAQ,MAAM,CAAC,QAAQ,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;EACrE,IAAI,CAAC,QAAQ,CAAC,MAAM,OAAO,KAAA;EAM3B,OAAO;GAAE,SAFO,KAAK,UAAU,KAAK,YAAY,KAAK,mBAAmB,MAAM,KAAK,SAAS,MAAM,IAAI,KAAK,EAE5F;GAAG,WAAW,kBAAkB,MAAM,IAAI;EAAE;CAC7D;AAGF;;;;;AAMA,SAAgB,wBAAwB,cAAwC,SAAqC;CACnH,MAAM,OAAO,WAAW,YAAY;CACpC,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,CAAC;CACnC,IAAI,CAAC,MAAM,OAAO,KAAA;CAElB,KAAK,MAAM,QAAQ,mBAAmB,MAAM,QAAQ,KAAK,WAAW,KAAK,GAAG,GAAG;EAC7E,IAAI,gBAAgB,MAAM,IAAI,MAAM,SAAS;EAE7C,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;EAE7D,OAAO,OAAO,4BAA4B,MAAM,IAAI,IAAI,KAAA;CAC1D;AAGF;;AAKA,SAAS,kBAAkB,MAAgB,MAAmB;CAC5D,OAAO,KAAK,UAAU,KAAK,YAAY,KAAK,mBAAmB,MAAM,KAAK,SAAS,MAAM,IAAI,KAAK,EAAE;AACtG;;AAGA,SAAS,4BAA4B,MAAgB,MAAmB;CACtE,MAAM,KAAK,KAAK,YAAY;CAE5B,OAAO,mBAAmB,MAAM,KAAK,SAAS,MAAM,IAAI,OAAO,KAAK,aAAa,EAAE,CAAC,IAAI,KAAK,UAAU,EAAE;AAC3G;;AAKA,SAAS,gBAAgB,MAAgB,MAA+B;CACtE,MAAM,OAAO,QAAQ,MAAM,CAAC,QAAQ,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;CAErE,OAAO,OAAO,WAAW,MAAM,KAAK,YAAY,CAAC,IAAI,KAAA;AACvD;;AAGA,SAAS,gBAAgB,MAAgB,MAA+B;CACtE,MAAM,OAAO,QAAQ,MAAM,CAAC,MAAM,GAAG,KAAK,WAAW,KAAK,GAAG;CAE7D,OAAO,OAAO,KAAK,UAAU,KAAK,YAAY,CAAC,IAAI,KAAA;AACrD"}

package/dist/dev/media/primitives/resolution.d.ts

@@ -2,18 +2,16 @@
 /**
  * Pixel dimensions, and the one projection every reader of them needs.
  *
- * Shared by the surfaces a rendition cap measures — a screen (`media/dom/screen`),
- * a player element (`behaviors/dom/track-player-resolution`) — and by the caps
- * that compare renditions against them. Lives outside the DOM layer because
- * scaling and rounding two numbers needs no DOM, which is also what lets the
- * DOM-free selection rules name the type they read instead of restating its shape.
+ * Shared by the surfaces a rendition cap measures — a screen (`media/dom/screen`), a player element
+ * (`behaviors/dom/track-player-resolution`) — and by the caps that compare renditions against them. Lives outside the
+ * DOM layer because scaling and rounding two numbers needs no DOM, which is also what lets the DOM-free selection rules
+ * name the type they read instead of restating its shape.
  */
 /**
  * A surface's pixel dimensions.
  *
- * A width and a height rather than a `"720p"`-style tier, because a tier only
- * describes a surface once you assume its aspect ratio — the assumption that
- * mis-measures an anamorphic or otherwise non-16:9 rendition.
+ * A width and a height rather than a `"720p"`-style tier, because a tier only describes a surface once you assume its
+ * aspect ratio — the assumption that mis-measures an anamorphic or otherwise non-16:9 rendition.
  */
 interface Resolution {
   readonly width: number;

package/dist/dev/media/primitives/resolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolution.d.ts","names":[],"sources":["../../../../src/media/primitives/resolution.ts"],"mappings":";;;;;;;;;;;;;;;;;UAiBiB;WACN;WACA"}
+{"version":3,"file":"resolution.d.ts","names":[],"sources":["../../../../src/media/primitives/resolution.ts"],"mappings":";;;;;;;;;;;;;;;UAeiB;WACN;WACA"}

package/dist/dev/media/primitives/resolution.js

@@ -1,14 +1,11 @@
 //#region src/media/primitives/resolution.ts
 /**
-* Apply `scale` to a size and normalize it to whole pixels, or `undefined` where
-* that leaves nothing to describe.
+* Apply `scale` to a size and normalize it to whole pixels, or `undefined` where that leaves nothing to describe.
 *
-* Rounded because pixels are whole and a fractional scale doesn't divide a
-* surface evenly. A non-positive or non-finite axis yields `undefined` rather
-* than a zero-area reading: an element that isn't being rendered reports `0 × 0`
-* and a nonsense dimension reports `NaN`, and the caps consuming this read
-* absence as "unknown, don't cap" while an area of zero would read as a cap of
-* zero — pinning every source to its smallest rendition.
+* Rounded because pixels are whole and a fractional scale doesn't divide a surface evenly. A non-positive or non-finite
+* axis yields `undefined` rather than a zero-area reading: an element that isn't being rendered reports `0 × 0` and a
+* nonsense dimension reports `NaN`, and the caps consuming this read absence as "unknown, don't cap" while an area of
+* zero would read as a cap of zero — pinning every source to its smallest rendition.
 *
 * @param size - Dimensions to project, in the units `scale` converts from
 * @param scale - Multiplier for both axes, e.g. `devicePixelRatio`; defaults to 1

package/dist/dev/media/primitives/resolution.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolution.js","names":[],"sources":["../../../../src/media/primitives/resolution.ts"],"sourcesContent":["/**\n * Pixel dimensions, and the one projection every reader of them needs.\n *\n * Shared by the surfaces a rendition cap measures — a screen (`media/dom/screen`),\n * a player element (`behaviors/dom/track-player-resolution`) — and by the caps\n * that compare renditions against them. Lives outside the DOM layer because\n * scaling and rounding two numbers needs no DOM, which is also what lets the\n * DOM-free selection rules name the type they read instead of restating its shape.\n */\n\n/**\n * A surface's pixel dimensions.\n *\n * A width and a height rather than a `\"720p\"`-style tier, because a tier only\n * describes a surface once you assume its aspect ratio — the assumption that\n * mis-measures an anamorphic or otherwise non-16:9 rendition.\n */\nexport interface Resolution {\n  readonly width: number;\n  readonly height: number;\n}\n\n/**\n * Apply `scale` to a size and normalize it to whole pixels, or `undefined` where\n * that leaves nothing to describe.\n *\n * Rounded because pixels are whole and a fractional scale doesn't divide a\n * surface evenly. A non-positive or non-finite axis yields `undefined` rather\n * than a zero-area reading: an element that isn't being rendered reports `0 × 0`\n * and a nonsense dimension reports `NaN`, and the caps consuming this read\n * absence as \"unknown, don't cap\" while an area of zero would read as a cap of\n * zero — pinning every source to its smallest rendition.\n *\n * @param size - Dimensions to project, in the units `scale` converts from\n * @param scale - Multiplier for both axes, e.g. `devicePixelRatio`; defaults to 1\n * @returns The scaled, whole-pixel resolution, or `undefined` when either axis\n * doesn't survive it\n */\nexport function scaleResolution(size: Resolution, scale = 1): Resolution | undefined {\n  const width = Math.round(size.width * scale);\n  const height = Math.round(size.height * scale);\n\n  return width > 0 && height > 0 ? { width, height } : undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAsCA,SAAgB,gBAAgB,MAAkB,QAAQ,GAA2B;CACnF,MAAM,QAAQ,KAAK,MAAM,KAAK,QAAQ,KAAK;CAC3C,MAAM,SAAS,KAAK,MAAM,KAAK,SAAS,KAAK;CAE7C,OAAO,QAAQ,KAAK,SAAS,IAAI;EAAE;EAAO;CAAO,IAAI,KAAA;AACvD"}
+{"version":3,"file":"resolution.js","names":[],"sources":["../../../../src/media/primitives/resolution.ts"],"sourcesContent":["/**\n * Pixel dimensions, and the one projection every reader of them needs.\n *\n * Shared by the surfaces a rendition cap measures — a screen (`media/dom/screen`), a player element\n * (`behaviors/dom/track-player-resolution`) — and by the caps that compare renditions against them. Lives outside the\n * DOM layer because scaling and rounding two numbers needs no DOM, which is also what lets the DOM-free selection rules\n * name the type they read instead of restating its shape.\n */\n\n/**\n * A surface's pixel dimensions.\n *\n * A width and a height rather than a `\"720p\"`-style tier, because a tier only describes a surface once you assume its\n * aspect ratio — the assumption that mis-measures an anamorphic or otherwise non-16:9 rendition.\n */\nexport interface Resolution {\n  readonly width: number;\n  readonly height: number;\n}\n\n/**\n * Apply `scale` to a size and normalize it to whole pixels, or `undefined` where that leaves nothing to describe.\n *\n * Rounded because pixels are whole and a fractional scale doesn't divide a surface evenly. A non-positive or non-finite\n * axis yields `undefined` rather than a zero-area reading: an element that isn't being rendered reports `0 × 0` and a\n * nonsense dimension reports `NaN`, and the caps consuming this read absence as \"unknown, don't cap\" while an area of\n * zero would read as a cap of zero — pinning every source to its smallest rendition.\n *\n * @param size - Dimensions to project, in the units `scale` converts from\n * @param scale - Multiplier for both axes, e.g. `devicePixelRatio`; defaults to 1\n * @returns The scaled, whole-pixel resolution, or `undefined` when either axis\n * doesn't survive it\n */\nexport function scaleResolution(size: Resolution, scale = 1): Resolution | undefined {\n  const width = Math.round(size.width * scale);\n  const height = Math.round(size.height * scale);\n\n  return width > 0 && height > 0 ? { width, height } : undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;AAiCA,SAAgB,gBAAgB,MAAkB,QAAQ,GAA2B;CACnF,MAAM,QAAQ,KAAK,MAAM,KAAK,QAAQ,KAAK;CAC3C,MAAM,SAAS,KAAK,MAAM,KAAK,SAAS,KAAK;CAE7C,OAAO,QAAQ,KAAK,SAAS,IAAI;EAAE;EAAO;CAAO,IAAI,KAAA;AACvD"}

package/dist/dev/media/primitives/select-tracks.js

@@ -1,9 +1,8 @@
 //#region src/media/primitives/select-tracks.ts
 /**
-* Test whether a track matches a partial-track description: every present,
-* defined field of `filter` equals the track's. Absent or `undefined` filter
-* fields don't constrain. Used to narrow candidates by a user selection
-* (`{ id }`, `{ language }`, `{ height }`, …).
+* Test whether a track matches a partial-track description: every present, defined field of `filter` equals the
+* track's. Absent or `undefined` filter fields don't constrain. Used to narrow candidates by a user selection (`{ id
+* }`, `{ language }`, `{ height }`, …).
 *
 * @param track - The track to test
 * @param filter - Partial-track description; only present, defined fields constrain
@@ -21,51 +20,44 @@ function pixelArea(track) {
 	return (track.width ?? 0) * (track.height ?? 0);
 }
 /**
-* Narrow to the tracks at or below `maxPixelArea`, and nothing else: no ordering,
-* no fallback. Survivors keep their incoming order, and an empty result is a real
-* answer — "none of these fit".
+* Narrow to the tracks at or below `maxPixelArea`, and nothing else: no ordering, no fallback. Survivors keep their
+* incoming order, and an empty result is a real answer — "none of these fit".
 *
-* Deliberately only the filter, because as a selection rule this composes under
-* `applyRules`, which already owns both halves a caller might expect here: an empty
-* result is skipped, so a preference can never narrow the candidate set to nothing;
-* and ordering the survivors is a separate rule's job
-* ({@link byDescendingResolution}, bandwidth ABR). Doing either here would duplicate
-* the composer and give one rule two responsibilities.
+* Deliberately only the filter, because as a selection rule this composes under `applyRules`, which already owns both
+* halves a caller might expect here: an empty result is skipped, so a preference can never narrow the candidate set to
+* nothing; and ordering the survivors is a separate rule's job ({@link byDescendingResolution}, bandwidth ABR). Doing
+* either here would duplicate the composer and give one rule two responsibilities.
 */
 function tracksUnderPixelArea(tracks, maxPixelArea = Number.POSITIVE_INFINITY) {
 	return tracks.filter((track) => pixelArea(track) <= maxPixelArea);
 }
 /**
-* The smallest track area that still covers `minPixelArea`, or `undefined` when
-* no track reaches it.
+* The smallest track area that still covers `minPixelArea`, or `undefined` when no track reaches it.
 *
-* The cap a surface-size rule wants when it should round *up* to the ladder: a
-* surface between two tiers is covered by the upper one, and capping at the
-* surface's own area instead would serve a picture smaller than the surface and
+* The cap a surface-size rule wants when it should round _up_ to the ladder: a surface between two tiers is covered by
+* the upper one, and capping at the surface's own area instead would serve a picture smaller than the surface and
 * upscale it.
 *
-* Tracks declaring no dimensions compare as area `0` and so never cover anything,
-* which keeps them out of the cap rather than pinning it to zero.
+* Tracks declaring no dimensions compare as area `0` and so never cover anything, which keeps them out of the cap
+* rather than pinning it to zero.
 */
 function smallestCoveringPixelArea(tracks, minPixelArea) {
 	const covering = tracks.map(pixelArea).filter((area) => area >= minPixelArea);
 	return covering.length ? Math.min(...covering) : void 0;
 }
 /**
-* Compare two tracks by resolution, largest first, with bandwidth as the tiebreak
-* for renditions of identical dimensions. Missing dimensions are treated as area
-* `0`, so a track without them sorts last.
+* Compare two tracks by resolution, largest first, with bandwidth as the tiebreak for renditions of identical
+* dimensions. Missing dimensions are treated as area `0`, so a track without them sorts last.
 *
-* A comparator rather than a "highest track" function: the selection-rule chain
-* takes the head of the list it produces, so ranking never has to collapse to a
-* single track. `preferHighestResolution` is `sort` over this and nothing more.
+* A comparator rather than a "highest track" function: the selection-rule chain takes the head of the list it produces,
+* so ranking never has to collapse to a single track. `preferHighestResolution` is `sort` over this and nothing more.
 */
 function byDescendingResolution(a, b) {
 	return pixelArea(b) - pixelArea(a) || (b.bandwidth ?? 0) - (a.bandwidth ?? 0);
 }
 /**
-* Default audio policy over a candidate list: the three-tier pick a selection-rule
-* chain applies once it has narrowed the candidates.
+* Default audio policy over a candidate list: the three-tier pick a selection-rule chain applies once it has narrowed
+* the candidates.
 *
 * Priority: `preferredAudioLanguage` match → `DEFAULT=YES` → first track.
 */
@@ -79,13 +71,11 @@ function pickAudioTrackFromTracks(tracks, config) {
 	return tracks[0]?.id;
 }
 /**
-* Default text-track policy over a candidate list: the opt-in three-tier pick
-* `switchTextTrack`'s terminal applies once it has narrowed the renditions to the
-* constrained, CDN-scoped set.
+* Default text-track policy over a candidate list: the opt-in three-tier pick `switchTextTrack`'s terminal applies once
+* it has narrowed the renditions to the constrained, CDN-scoped set.
 *
-* Priority: `preferredSubtitleLanguage` match → `DEFAULT=YES + AUTOSELECT=YES`
-* (only when `enableDefaultTrack`) → `undefined` (opt-in). FORCED tracks are
-* excluded unless `includeForcedTracks` (Apple-spec: a regular track must carry
+* Priority: `preferredSubtitleLanguage` match → `DEFAULT=YES + AUTOSELECT=YES` (only when `enableDefaultTrack`) →
+* `undefined` (opt-in). FORCED tracks are excluded unless `includeForcedTracks` (Apple-spec: a regular track must carry
 * forced content when both exist, so a forced-only track is redundant).
 */
 function pickTextTrackFromTracks(tracks, config) {