@videojs/spf 10.0.0-beta.22 → 10.0.0-beta.24

package/dist/dev/core/features/select-tracks.js

@@ -1,130 +0,0 @@
-import { effect } from "../signals/effect.js";
-import { update } from "../signals/primitives.js";
-import { SelectedTrackIdKeyByType } from "../utils/track-selection.js";
-//#region src/core/features/select-tracks.ts
-/**
-* Pick text track to activate.
-*
-* Selection priority (if enabled):
-* 1. User preference (preferredSubtitleLanguage)
-* 2. DEFAULT track (if enableDefaultTrack is true and track has DEFAULT=YES + AUTOSELECT=YES)
-* 3. No auto-selection (user opt-in)
-*
-* By default, FORCED tracks are excluded per Apple's HLS spec.
-*
-* @param presentation - Presentation with text tracks
-* @param config - Selection configuration
-* @returns Track ID or undefined (no auto-selection)
-*/
-function pickTextTrack(presentation, config) {
-	const textSet = presentation.selectionSets.find((set) => set.type === "text");
-	if (!textSet?.switchingSets?.[0]?.tracks.length) return void 0;
-	const tracks = textSet.switchingSets[0].tracks;
-	const availableTracks = config.includeForcedTracks ? tracks : tracks.filter((track) => !track.forced);
-	if (availableTracks.length === 0) return void 0;
-	const { preferredSubtitleLanguage, enableDefaultTrack = false } = config;
-	if (preferredSubtitleLanguage) {
-		const languageMatch = availableTracks.find((track) => track.language === preferredSubtitleLanguage);
-		if (languageMatch) return languageMatch.id;
-	}
-	if (enableDefaultTrack) {
-		const defaultTrack = availableTracks.find((track) => track.default === true);
-		if (defaultTrack) return defaultTrack.id;
-	}
-}
-/**
-* Check if we can select a track of the given type.
-*
-* Returns true when:
-* - Presentation exists
-* - Has tracks of the specified type
-*
-* Generic over track type - works for video, audio, or text.
-*/
-function canSelectTrack(state, config) {
-	return !!state?.presentation?.selectionSets?.find(({ type }) => type === config.type)?.switchingSets?.[0]?.tracks.length;
-}
-/**
-* Check if we should select a track of the given type.
-*
-* Returns true when:
-* - Track of this type is not already selected
-*
-* Generic over track type - works for video, audio, or text.
-*
-* @TODO figure out reactive model for ABR cases - right now we're only selecting
-* if we have nothing selected (CJP)
-*/
-function shouldSelectTrack(state, config) {
-	return !state[SelectedTrackIdKeyByType[config.type]];
-}
-/**
-* Select video track orchestration.
-*
-* Selects video track when:
-* - Presentation exists
-* - No video track is selected yet
-*
-* Uses bandwidth-based quality selection algorithm.
-*
-* @example
-* const cleanup = selectVideoTrack(
-*   { state, owners, events },
-*   { initialBandwidth: 2_000_000 }
-* );
-*/
-function selectVideoTrack({ state }, config = { type: "video" }) {
-	return effect(() => {
-		const currentState = state.get();
-		if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;
-		const selectedTrackId = currentState.presentation?.selectionSets.find(({ type }) => type === config.type)?.switchingSets[0]?.tracks[0]?.id;
-		if (selectedTrackId) update(state, { [SelectedTrackIdKeyByType[config.type]]: selectedTrackId });
-	});
-}
-/**
-* Select audio track orchestration.
-*
-* Selects audio track when:
-* - Presentation exists
-* - No audio track is selected yet
-*
-* Uses language and preference-based selection.
-*
-* @example
-* const cleanup = selectAudioTrack(
-*   { state, owners, events },
-*   { preferredAudioLanguage: 'en' }
-* );
-*/
-function selectAudioTrack({ state }, config = { type: "audio" }) {
-	return effect(() => {
-		const currentState = state.get();
-		if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;
-		const selectedTrackId = currentState.presentation?.selectionSets.find(({ type }) => type === "audio")?.switchingSets[0]?.tracks[0]?.id;
-		if (selectedTrackId) update(state, { selectedAudioTrackId: selectedTrackId });
-	});
-}
-/**
-* Select text track orchestration.
-*
-* Selects text track when:
-* - Presentation exists
-* - No text track is selected yet
-*
-* Note: Currently does not auto-select (user opt-in).
-*
-* @example
-* const cleanup = selectTextTrack({ state, owners, events }, {});
-*/
-function selectTextTrack({ state }, config = { type: "text" }) {
-	return effect(() => {
-		const currentState = state.get();
-		if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;
-		const selectedTextTrackId = pickTextTrack(currentState.presentation, config);
-		if (selectedTextTrackId) update(state, { selectedTextTrackId });
-	});
-}
-//#endregion
-export { selectAudioTrack, selectTextTrack, selectVideoTrack };
-
-//# sourceMappingURL=select-tracks.js.map

package/dist/dev/core/features/select-tracks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"select-tracks.js","names":[],"sources":["../../../../src/core/features/select-tracks.ts"],"sourcesContent":["import { DEFAULT_QUALITY_CONFIG, selectQuality } from '../abr/quality-selection';\nimport { effect } from '../signals/effect';\nimport { type Signal, update } from '../signals/primitives';\nimport type { AudioSelectionSet, Presentation, TrackType, VideoSelectionSet } from '../types';\nimport { SelectedTrackIdKeyByType } from '../utils/track-selection';\n\n/**\n * Default initial bandwidth estimate for cold start (bits per second).\n * Conservative 1 Mbps to avoid over-selecting on slow connections.\n */\nexport const DEFAULT_INITIAL_BANDWIDTH = 1_000_000;\n\n/**\n * State shape for track selection.\n */\nexport interface TrackSelectionState {\n  presentation?: Presentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  selectedTextTrackId?: string;\n}\n\n/**\n * Owners shape for track selection.\n * Currently empty - reserved for future use (e.g., bandwidth estimator).\n */\nexport type TrackSelectionOwners = Record<string, never>;\n\n/**\n * Action types for track selection.\n * Reserved for future event-driven selection triggers.\n */\nexport type TrackSelectionAction = { type: 'presentation-loaded' };\n\n/**\n * Base configuration for track selection.\n * Generic over track type with discriminant `type` field.\n */\nexport interface TrackSelectionConfig<T extends TrackType = TrackType> {\n  type: T;\n}\n\n/**\n * Configuration for video track selection.\n * Generic with default to 'video' for convenience.\n */\nexport interface VideoSelectionConfig<T extends TrackType = 'video'> extends TrackSelectionConfig<T> {\n  /**\n   * Initial bandwidth estimate for cold start (bits per second).\n   * Used to select video quality before we have real measurements.\n   * Default: 1 Mbps (conservative).\n   */\n  initialBandwidth?: number;\n\n  /**\n   * Safety margin for quality selection (0-1).\n   * Default: 0.85 (15% headroom).\n   */\n  safetyMargin?: number;\n}\n\n/**\n * Configuration for audio track selection.\n * Generic with default to 'audio' for convenience.\n */\nexport interface AudioSelectionConfig<T extends TrackType = 'audio'> extends TrackSelectionConfig<T> {\n  /**\n   * Preferred audio language (ISO 639 code, e.g., \"en\", \"es\").\n   * If not specified, selects first audio track.\n   */\n  preferredAudioLanguage?: string;\n}\n\n/**\n * Configuration for text track selection.\n * Generic with default to 'text' for convenience.\n */\nexport interface TextSelectionConfig<T extends TrackType = 'text'> extends TrackSelectionConfig<T> {\n  /**\n   * Preferred subtitle language (ISO 639 code, e.g., \"en\", \"es\").\n   * If specified, selects matching track if available.\n   */\n  preferredSubtitleLanguage?: string;\n\n  /**\n   * Include FORCED subtitle tracks in selection.\n   * Default: false (follows hls.js/http-streaming pattern)\n   *\n   * Note: Per Apple's HLS spec, if content has forced and regular subtitles\n   * in the same language, the regular track MUST contain both forced and\n   * regular content. Therefore, forced-only tracks are redundant and excluded\n   * by default.\n   */\n  includeForcedTracks?: boolean;\n\n  /**\n   * Auto-select DEFAULT track (requires DEFAULT=YES + AUTOSELECT=YES in HLS).\n   * Default: false (user opt-in, matches hls.js/http-streaming)\n   *\n   * When enabled, tracks marked with both DEFAULT=YES and AUTOSELECT=YES\n   * will be automatically selected if no user preference matches.\n   */\n  enableDefaultTrack?: boolean;\n}\n\n// =============================================================================\n// Helper Functions (Pure Selection Logic)\n// =============================================================================\n\n/**\n * Pick video track using quality selection algorithm.\n *\n * Uses bandwidth-based selection with safety margin to pick\n * the highest quality track that fits available bandwidth.\n *\n * @param presentation - Presentation with video tracks\n * @param config - Selection configuration (bandwidth, safety margin)\n * @returns Selected video track ID, or undefined if no video tracks\n */\nexport function pickVideoTrack(presentation: Presentation, config: VideoSelectionConfig): string | undefined {\n  const videoSet = presentation.selectionSets.find((set) => set.type === 'video') as VideoSelectionSet | undefined;\n\n  if (!videoSet || videoSet.switchingSets.length === 0) {\n    return undefined;\n  }\n\n  // Get first switching set's tracks (HLS typically has one switching set per type)\n  const switchingSet = videoSet.switchingSets[0];\n  if (!switchingSet || switchingSet.tracks.length === 0) {\n    return undefined;\n  }\n\n  const initialBandwidth = config.initialBandwidth ?? DEFAULT_INITIAL_BANDWIDTH;\n  const safetyMargin = config.safetyMargin ?? DEFAULT_QUALITY_CONFIG.safetyMargin;\n\n  // selectQuality works with both partially resolved and resolved tracks\n  const selected = selectQuality(switchingSet.tracks as any, initialBandwidth, { safetyMargin });\n\n  return selected?.id;\n}\n\n/**\n * Pick audio track.\n *\n * Selection priority:\n * 1. First track matching preferred language (if specified)\n * 2. First default track\n * 3. First audio track\n *\n * @param presentation - Presentation with audio tracks\n * @param config - Selection configuration (preferred language)\n * @returns Selected audio track ID, or undefined if no audio tracks\n */\nexport function pickAudioTrack(presentation: Presentation, config: AudioSelectionConfig): string | undefined {\n  const audioSet = presentation.selectionSets.find((set) => set.type === 'audio') as AudioSelectionSet | undefined;\n\n  if (!audioSet || audioSet.switchingSets.length === 0) {\n    return undefined;\n  }\n\n  // Get first switching set's tracks\n  const switchingSet = audioSet.switchingSets[0];\n  if (!switchingSet || switchingSet.tracks.length === 0) {\n    return undefined;\n  }\n\n  const tracks = switchingSet.tracks;\n\n  // Try preferred language first\n  if (config.preferredAudioLanguage) {\n    const languageMatch = tracks.find((track) => track.language === config.preferredAudioLanguage);\n    if (languageMatch) {\n      return languageMatch.id;\n    }\n  }\n\n  // Try default track\n  const defaultTrack = tracks.find((track) => track.default === true);\n  if (defaultTrack) {\n    return defaultTrack.id;\n  }\n\n  // Fall back to first track\n  return tracks[0]?.id;\n}\n\n/**\n * Pick text track to activate.\n *\n * Selection priority (if enabled):\n * 1. User preference (preferredSubtitleLanguage)\n * 2. DEFAULT track (if enableDefaultTrack is true and track has DEFAULT=YES + AUTOSELECT=YES)\n * 3. No auto-selection (user opt-in)\n *\n * By default, FORCED tracks are excluded per Apple's HLS spec.\n *\n * @param presentation - Presentation with text tracks\n * @param config - Selection configuration\n * @returns Track ID or undefined (no auto-selection)\n */\nexport function pickTextTrack(presentation: Presentation, config: TextSelectionConfig): string | undefined {\n  const textSet = presentation.selectionSets.find((set) => set.type === 'text');\n  if (!textSet?.switchingSets?.[0]?.tracks.length) return undefined;\n\n  const tracks = textSet.switchingSets[0].tracks;\n\n  // Filter out FORCED tracks by default (following hls.js/http-streaming pattern)\n  // Per Apple spec: regular tracks MUST contain forced content when both exist\n  const availableTracks = config.includeForcedTracks ? tracks : tracks.filter((track) => !track.forced);\n\n  if (availableTracks.length === 0) return undefined;\n\n  const { preferredSubtitleLanguage, enableDefaultTrack = false } = config;\n\n  // 1. Preferred language match (if specified)\n  if (preferredSubtitleLanguage) {\n    const languageMatch = availableTracks.find((track) => track.language === preferredSubtitleLanguage);\n    if (languageMatch) return languageMatch.id;\n  }\n\n  // 2. DEFAULT track (if enabled AND track has both DEFAULT=YES + AUTOSELECT=YES)\n  //    Note: Parser only sets default=true when BOTH attributes present\n  if (enableDefaultTrack) {\n    const defaultTrack = availableTracks.find((track) => track.default === true);\n    if (defaultTrack) return defaultTrack.id;\n  }\n\n  // 3. User opt-in (no auto-selection)\n  return undefined;\n}\n\n/**\n * Check if we can select a track of the given type.\n *\n * Returns true when:\n * - Presentation exists\n * - Has tracks of the specified type\n *\n * Generic over track type - works for video, audio, or text.\n */\nexport function canSelectTrack<T extends TrackType>(\n  state: TrackSelectionState,\n  config: TrackSelectionConfig<T>\n): boolean {\n  return !!state?.presentation?.selectionSets?.find(({ type }) => type === config.type)?.switchingSets?.[0]?.tracks\n    .length;\n}\n\n/**\n * Check if we should select a track of the given type.\n *\n * Returns true when:\n * - Track of this type is not already selected\n *\n * Generic over track type - works for video, audio, or text.\n *\n * @TODO figure out reactive model for ABR cases - right now we're only selecting\n * if we have nothing selected (CJP)\n */\nexport function shouldSelectTrack<T extends TrackType>(\n  state: TrackSelectionState,\n  config: TrackSelectionConfig<T>\n): boolean {\n  return !state[SelectedTrackIdKeyByType[config.type]];\n}\n\n// =============================================================================\n// Orchestrations\n// =============================================================================\n\n/**\n * Select video track orchestration.\n *\n * Selects video track when:\n * - Presentation exists\n * - No video track is selected yet\n *\n * Uses bandwidth-based quality selection algorithm.\n *\n * @example\n * const cleanup = selectVideoTrack(\n *   { state, owners, events },\n *   { initialBandwidth: 2_000_000 }\n * );\n */\nexport function selectVideoTrack<S extends TrackSelectionState>(\n  { state }: { state: Signal<S> },\n  config: VideoSelectionConfig = { type: 'video' }\n): () => void {\n  return effect(() => {\n    const currentState = state.get();\n    if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;\n\n    // Just to have basic functionality/POC, simply selecting the first track\n    const selectedTrackId = currentState.presentation?.selectionSets.find(({ type }) => type === config.type)\n      ?.switchingSets[0]?.tracks[0]?.id;\n\n    if (selectedTrackId) {\n      const selectedTrackKey = SelectedTrackIdKeyByType[config.type];\n      const patch: Partial<TrackSelectionState> = { [selectedTrackKey]: selectedTrackId };\n      update(state, patch);\n    }\n  });\n}\n\n/**\n * Select audio track orchestration.\n *\n * Selects audio track when:\n * - Presentation exists\n * - No audio track is selected yet\n *\n * Uses language and preference-based selection.\n *\n * @example\n * const cleanup = selectAudioTrack(\n *   { state, owners, events },\n *   { preferredAudioLanguage: 'en' }\n * );\n */\nexport function selectAudioTrack<S extends TrackSelectionState>(\n  { state }: { state: Signal<S> },\n  config: AudioSelectionConfig = { type: 'audio' }\n): () => void {\n  return effect(() => {\n    const currentState = state.get();\n    if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;\n\n    // Just to have basic functionality/POC, simply selecting the first track\n    const selectedTrackId = currentState.presentation?.selectionSets.find(({ type }) => type === 'audio')\n      ?.switchingSets[0]?.tracks[0]?.id;\n\n    if (selectedTrackId) {\n      const patch: Partial<TrackSelectionState> = { selectedAudioTrackId: selectedTrackId };\n      update(state, patch);\n    }\n  });\n}\n\n/**\n * Select text track orchestration.\n *\n * Selects text track when:\n * - Presentation exists\n * - No text track is selected yet\n *\n * Note: Currently does not auto-select (user opt-in).\n *\n * @example\n * const cleanup = selectTextTrack({ state, owners, events }, {});\n */\nexport function selectTextTrack<S extends TrackSelectionState>(\n  { state }: { state: Signal<S> },\n  config: TextSelectionConfig = { type: 'text' }\n): () => void {\n  return effect(() => {\n    const currentState = state.get();\n    if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;\n\n    // Text tracks are user opt-in - don't auto-select\n    const selectedTextTrackId = pickTextTrack(currentState.presentation!, config);\n\n    if (selectedTextTrackId) {\n      const patch: Partial<TrackSelectionState> = { selectedTextTrackId };\n      update(state, patch);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwMA,SAAgB,cAAc,cAA4B,QAAiD;CACzG,MAAM,UAAU,aAAa,cAAc,MAAM,QAAQ,IAAI,SAAS,OAAO;AAC7E,KAAI,CAAC,SAAS,gBAAgB,IAAI,OAAO,OAAQ,QAAO,KAAA;CAExD,MAAM,SAAS,QAAQ,cAAc,GAAG;CAIxC,MAAM,kBAAkB,OAAO,sBAAsB,SAAS,OAAO,QAAQ,UAAU,CAAC,MAAM,OAAO;AAErG,KAAI,gBAAgB,WAAW,EAAG,QAAO,KAAA;CAEzC,MAAM,EAAE,2BAA2B,qBAAqB,UAAU;AAGlE,KAAI,2BAA2B;EAC7B,MAAM,gBAAgB,gBAAgB,MAAM,UAAU,MAAM,aAAa,0BAA0B;AACnG,MAAI,cAAe,QAAO,cAAc;;AAK1C,KAAI,oBAAoB;EACtB,MAAM,eAAe,gBAAgB,MAAM,UAAU,MAAM,YAAY,KAAK;AAC5E,MAAI,aAAc,QAAO,aAAa;;;;;;;;;;;;AAgB1C,SAAgB,eACd,OACA,QACS;AACT,QAAO,CAAC,CAAC,OAAO,cAAc,eAAe,MAAM,EAAE,WAAW,SAAS,OAAO,KAAK,EAAE,gBAAgB,IAAI,OACxG;;;;;;;;;;;;;AAcL,SAAgB,kBACd,OACA,QACS;AACT,QAAO,CAAC,MAAM,yBAAyB,OAAO;;;;;;;;;;;;;;;;;AAsBhD,SAAgB,iBACd,EAAE,SACF,SAA+B,EAAE,MAAM,SAAS,EACpC;AACZ,QAAO,aAAa;EAClB,MAAM,eAAe,MAAM,KAAK;AAChC,MAAI,CAAC,eAAe,cAAc,OAAO,IAAI,CAAC,kBAAkB,cAAc,OAAO,CAAE;EAGvF,MAAM,kBAAkB,aAAa,cAAc,cAAc,MAAM,EAAE,WAAW,SAAS,OAAO,KAAK,EACrG,cAAc,IAAI,OAAO,IAAI;AAEjC,MAAI,gBAGF,QAAO,OADqC,GADnB,yBAAyB,OAAO,QACS,iBAAiB,CAC/D;GAEtB;;;;;;;;;;;;;;;;;AAkBJ,SAAgB,iBACd,EAAE,SACF,SAA+B,EAAE,MAAM,SAAS,EACpC;AACZ,QAAO,aAAa;EAClB,MAAM,eAAe,MAAM,KAAK;AAChC,MAAI,CAAC,eAAe,cAAc,OAAO,IAAI,CAAC,kBAAkB,cAAc,OAAO,CAAE;EAGvF,MAAM,kBAAkB,aAAa,cAAc,cAAc,MAAM,EAAE,WAAW,SAAS,QAAQ,EACjG,cAAc,IAAI,OAAO,IAAI;AAEjC,MAAI,gBAEF,QAAO,OADqC,EAAE,sBAAsB,iBAAiB,CACjE;GAEtB;;;;;;;;;;;;;;AAeJ,SAAgB,gBACd,EAAE,SACF,SAA8B,EAAE,MAAM,QAAQ,EAClC;AACZ,QAAO,aAAa;EAClB,MAAM,eAAe,MAAM,KAAK;AAChC,MAAI,CAAC,eAAe,cAAc,OAAO,IAAI,CAAC,kBAAkB,cAAc,OAAO,CAAE;EAGvF,MAAM,sBAAsB,cAAc,aAAa,cAAe,OAAO;AAE7E,MAAI,oBAEF,QAAO,OADqC,EAAE,qBAAqB,CAC/C;GAEtB"}

package/dist/dev/core/features/sync-preload-attribute.js

@@ -1,26 +0,0 @@
-import { effect } from "../signals/effect.js";
-import { computed, update } from "../signals/primitives.js";
-//#region src/core/features/sync-preload-attribute.ts
-/**
-* Syncs preload attribute from mediaElement to state.
-*
-* Watches the owners signal for mediaElement changes and copies the
-* preload attribute to state when no explicit value has been set.
-* An explicit value (set via SpfMedia.preload) always wins.
-*
-* @example
-* const cleanup = syncPreloadAttribute({ state, owners });
-*/
-function syncPreloadAttribute({ state, owners }) {
-	const mediaElement = computed(() => owners.get().mediaElement);
-	return effect(() => {
-		if (state.get().preload !== void 0) return;
-		const preload = mediaElement.get()?.preload || void 0;
-		if (preload === void 0) return;
-		update(state, { preload });
-	});
-}
-//#endregion
-export { syncPreloadAttribute };
-
-//# sourceMappingURL=sync-preload-attribute.js.map

package/dist/dev/core/features/sync-preload-attribute.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync-preload-attribute.js","names":[],"sources":["../../../../src/core/features/sync-preload-attribute.ts"],"sourcesContent":["import { effect } from '../signals/effect';\nimport { computed, type Signal, update } from '../signals/primitives';\nimport type { MediaElementLike } from '../types';\nimport type { PresentationState } from './resolve-presentation';\n\n/**\n * Owners shape for preload attribute sync.\n */\nexport interface PlatformOwners {\n  mediaElement?: MediaElementLike | undefined;\n}\n\n/**\n * Syncs preload attribute from mediaElement to state.\n *\n * Watches the owners signal for mediaElement changes and copies the\n * preload attribute to state when no explicit value has been set.\n * An explicit value (set via SpfMedia.preload) always wins.\n *\n * @example\n * const cleanup = syncPreloadAttribute({ state, owners });\n */\nexport function syncPreloadAttribute<S extends PresentationState, O extends PlatformOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): () => void {\n  const mediaElement = computed(() => owners.get().mediaElement);\n  return effect(() => {\n    if (state.get().preload !== undefined) return;\n    const preload = mediaElement.get()?.preload || undefined;\n    if (preload === undefined) return;\n    const patch: Partial<PresentationState> = { preload: preload as 'auto' | 'metadata' | 'none' };\n    update(state, patch);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAsBA,SAAgB,qBAA4E,EAC1F,OACA,UAIa;CACb,MAAM,eAAe,eAAe,OAAO,KAAK,CAAC,aAAa;AAC9D,QAAO,aAAa;AAClB,MAAI,MAAM,KAAK,CAAC,YAAY,KAAA,EAAW;EACvC,MAAM,UAAU,aAAa,KAAK,EAAE,WAAW,KAAA;AAC/C,MAAI,YAAY,KAAA,EAAW;AAE3B,SAAO,OADmC,EAAW,SAAyC,CAC1E;GACpB"}

package/dist/dev/core/hls/parse-attributes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-attributes.js","names":[],"sources":["../../../../src/core/hls/parse-attributes.ts"],"sourcesContent":["import type { FrameRate } from '../types';\n\n/**\n * Parse HLS attribute list from a tag line.\n * Handles both quoted and unquoted values.\n */\nexport function parseAttributeList(line: string): Map<string, string> {\n  const attributes = new Map<string, string>();\n  const regex = /([A-Z0-9-]+)=(?:\"([^\"]*)\"|([^,]*))/g;\n\n  for (const match of line.matchAll(regex)) {\n    const key = match[1];\n    const value = match[2] ?? match[3] ?? '';\n    if (key) {\n      attributes.set(key, value);\n    }\n  }\n\n  return attributes;\n}\n\n/**\n * Parse RESOLUTION attribute value (WIDTHxHEIGHT).\n */\nexport function parseResolution(value: string): { width: number; height: number } | null {\n  const match = /^(\\d+)x(\\d+)$/.exec(value);\n  if (!match) return null;\n\n  const width = Number.parseInt(match[1]!, 10);\n  const height = Number.parseInt(match[2]!, 10);\n\n  return { width, height };\n}\n\n/**\n * Parse FRAME-RATE attribute to rational frame rate.\n */\nexport function parseFrameRate(value: string): FrameRate | undefined {\n  const fps = Number.parseFloat(value);\n  if (Number.isNaN(fps) || fps <= 0) return undefined;\n\n  // Common frame rates with tolerance for floating point precision\n  if (Math.abs(fps - 23.976) < 0.01) {\n    return { frameRateNumerator: 24000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 29.97) < 0.01) {\n    return { frameRateNumerator: 30000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 59.94) < 0.01) {\n    return { frameRateNumerator: 60000, frameRateDenominator: 1001 };\n  }\n\n  // Integer frame rates\n  if (fps % 1 === 0) {\n    return { frameRateNumerator: Math.round(fps) };\n  }\n\n  // Default: use rounded value\n  return { frameRateNumerator: Math.round(fps) };\n}\n\n/**\n * Parse CODECS attribute into separate video and audio codecs.\n */\nexport function parseCodecs(codecs: string): { video?: string; audio?: string } {\n  const parts = codecs.split(',').map((s) => s.trim());\n  const result: { video?: string; audio?: string } = {};\n\n  for (const codec of parts) {\n    if (codec.startsWith('avc1.') || codec.startsWith('hvc1.') || codec.startsWith('hev1.')) {\n      result.video = codec;\n    } else if (codec.startsWith('mp4a.')) {\n      result.audio = codec;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse #EXTINF duration value.\n */\nexport function parseExtInfDuration(value: string): number {\n  const durationPart = value.split(',')[0] ?? value;\n  const duration = Number.parseFloat(durationPart);\n  return Number.isNaN(duration) ? 0 : duration;\n}\n\n/**\n * Parse BYTERANGE attribute value.\n * Format: \"length[@offset]\"\n * If offset is omitted, it continues from the previous byte range end.\n */\nexport function parseByteRange(value: string, previousEnd?: number): { start: number; end: number } | null {\n  const match = /^(\\d+)(?:@(\\d+))?$/.exec(value);\n  if (!match) return null;\n\n  const length = Number.parseInt(match[1]!, 10);\n  if (Number.isNaN(length)) return null;\n\n  let start: number;\n  if (match[2] !== undefined) {\n    start = Number.parseInt(match[2], 10);\n    if (Number.isNaN(start)) return null;\n  } else if (previousEnd !== undefined) {\n    start = previousEnd;\n  } else {\n    return null;\n  }\n\n  return { start, end: start + length - 1 };\n}\n\n/**\n * AttributeList - Typed attribute access wrapper.\n */\nexport interface AttributeList {\n  get: (key: string) => string | undefined;\n  getInt: (key: string, defaultValue?: number) => number | undefined;\n  getFloat: (key: string, defaultValue?: number) => number | undefined;\n  getBool: (key: string) => boolean;\n  getResolution: (key: string) => { width: number; height: number } | undefined;\n  getFrameRate: (key: string) => FrameRate | undefined;\n}\n\n/**\n * Create AttributeList from raw attribute string.\n */\nexport function createAttributeList(line: string): AttributeList {\n  const map = parseAttributeList(line);\n\n  return {\n    get(key: string): string | undefined {\n      return map.get(key);\n    },\n\n    getInt(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseInt(value, 10);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getFloat(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseFloat(value);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getBool(key: string): boolean {\n      return map.get(key) === 'YES';\n    },\n\n    getResolution(key: string): { width: number; height: number } | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseResolution(value) ?? undefined;\n    },\n\n    getFrameRate(key: string): FrameRate | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseFrameRate(value);\n    },\n  };\n}\n\n/**\n * Match a tag and extract its attributes.\n * Returns null if the line doesn't match the tag.\n */\nexport function matchTag(line: string, tag: string): AttributeList | null {\n  const prefix = `#${tag}:`;\n  if (!line.startsWith(prefix)) return null;\n  return createAttributeList(line.slice(prefix.length));\n}\n"],"mappings":"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"}

package/dist/dev/core/hls/parse-media-playlist.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-media-playlist.js","names":[],"sources":["../../../../src/core/hls/parse-media-playlist.ts"],"sourcesContent":["import type {\n  AudioTrack,\n  PartiallyResolvedAudioTrack,\n  PartiallyResolvedTextTrack,\n  PartiallyResolvedTrack,\n  PartiallyResolvedVideoTrack,\n  Segment,\n  TextTrack,\n  VideoTrack,\n} from '../types';\nimport { matchTag, parseByteRange, parseExtInfDuration } from './parse-attributes';\nimport { resolveUrl } from './resolve-url';\n\n/**\n * Resolve unresolved track type to its resolved equivalent.\n */\ntype ResolveTrack<T> = T extends PartiallyResolvedVideoTrack\n  ? VideoTrack\n  : T extends PartiallyResolvedAudioTrack\n    ? AudioTrack\n    : T extends PartiallyResolvedTextTrack\n      ? TextTrack\n      : never;\n\n/**\n * Parse HLS media playlist and resolve track with segments.\n *\n * Takes an unresolved track (from multivariant playlist) and media playlist text,\n * returns a HAM-compliant resolved track with segments.\n *\n * @param text - Media playlist text content\n * @param unresolved - Unresolved track from parseMultivariantPlaylist\n * @returns Resolved track with segments (type inferred from input)\n */\nexport function parseMediaPlaylist<T extends PartiallyResolvedTrack>(\n  text: string,\n  unresolved: T | ResolveTrack<T>\n): ResolveTrack<T> {\n  const lines = text.split(/\\r?\\n/);\n\n  // Segments and resources resolve relative to media playlist URL (per HLS spec)\n  const baseUrl = unresolved.url;\n\n  // Parse playlist\n  const segments: Segment[] = [];\n  let initSegmentUrl: string | undefined;\n  let initSegmentByteRange: { start: number; end: number } | undefined;\n\n  let currentDuration = 0;\n  let currentByteRange: { start: number; end: number } | undefined;\n  let currentTime = 0;\n  let segmentIndex = 0;\n  let previousByteRangeEnd: number | undefined;\n\n  for (const line of lines) {\n    const trimmed = line.trim();\n\n    if (!trimmed || (trimmed.startsWith('#') && !trimmed.startsWith('#EXT'))) {\n      continue;\n    }\n\n    if (\n      trimmed === '#EXTM3U' ||\n      trimmed.startsWith('#EXT-X-VERSION:') ||\n      trimmed.startsWith('#EXT-X-TARGETDURATION:') ||\n      trimmed.startsWith('#EXT-X-PLAYLIST-TYPE:') ||\n      trimmed.startsWith('#EXT-X-INDEPENDENT-SEGMENTS')\n    ) {\n      continue;\n    }\n\n    // #EXT-X-MAP - Init segment\n    const mapAttrs = matchTag(trimmed, 'EXT-X-MAP');\n    if (mapAttrs) {\n      const uri = mapAttrs.get('URI');\n      if (uri) {\n        initSegmentUrl = resolveUrl(uri, baseUrl);\n        const byteRangeStr = mapAttrs.get('BYTERANGE');\n        if (byteRangeStr) {\n          initSegmentByteRange = parseByteRange(byteRangeStr, 0) ?? undefined;\n        }\n      }\n      continue;\n    }\n\n    // #EXTINF - Segment duration\n    if (trimmed.startsWith('#EXTINF:')) {\n      currentDuration = parseExtInfDuration(trimmed.slice(8));\n      continue;\n    }\n\n    // #EXT-X-BYTERANGE - Segment byte range\n    if (trimmed.startsWith('#EXT-X-BYTERANGE:')) {\n      currentByteRange = parseByteRange(trimmed.slice(17), previousByteRangeEnd) ?? undefined;\n      continue;\n    }\n\n    if (trimmed === '#EXT-X-ENDLIST') {\n      continue;\n    }\n\n    // Segment URI\n    if (!trimmed.startsWith('#') && currentDuration > 0) {\n      const segment: Segment = {\n        id: `segment-${segmentIndex}`,\n        url: resolveUrl(trimmed, baseUrl),\n        duration: currentDuration,\n        startTime: currentTime,\n      };\n\n      if (currentByteRange) {\n        segment.byteRange = currentByteRange;\n        previousByteRangeEnd = currentByteRange.end + 1;\n      } else {\n        previousByteRangeEnd = undefined;\n      }\n\n      segments.push(segment);\n      currentTime += currentDuration;\n      segmentIndex++;\n\n      currentDuration = 0;\n      currentByteRange = undefined;\n    }\n  }\n\n  const totalDuration = currentTime;\n\n  // Build initialization (VTT may not have init segment)\n  const initialization =\n    unresolved.type === 'text' && !initSegmentUrl\n      ? undefined\n      : initSegmentUrl\n        ? { url: initSegmentUrl, ...(initSegmentByteRange ? { byteRange: initSegmentByteRange } : {}) }\n        : { url: '' };\n\n  // Generic resolution: All type-specific fields already on unresolved track from P1\n  // Just add parsed properties (startTime, duration, segments, initialization)\n  return {\n    ...unresolved,\n    startTime: 0,\n    duration: totalDuration,\n    segments,\n    initialization,\n  } as unknown as ResolveTrack<T>;\n}\n"],"mappings":";;;;;;;;;;;;;AAkCA,SAAgB,mBACd,MACA,YACiB;CACjB,MAAM,QAAQ,KAAK,MAAM,QAAQ;CAGjC,MAAM,UAAU,WAAW;CAG3B,MAAM,WAAsB,EAAE;CAC9B,IAAI;CACJ,IAAI;CAEJ,IAAI,kBAAkB;CACtB,IAAI;CACJ,IAAI,cAAc;CAClB,IAAI,eAAe;CACnB,IAAI;AAEJ,MAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,UAAU,KAAK,MAAM;AAE3B,MAAI,CAAC,WAAY,QAAQ,WAAW,IAAI,IAAI,CAAC,QAAQ,WAAW,OAAO,CACrE;AAGF,MACE,YAAY,aACZ,QAAQ,WAAW,kBAAkB,IACrC,QAAQ,WAAW,yBAAyB,IAC5C,QAAQ,WAAW,wBAAwB,IAC3C,QAAQ,WAAW,8BAA8B,CAEjD;EAIF,MAAM,WAAW,SAAS,SAAS,YAAY;AAC/C,MAAI,UAAU;GACZ,MAAM,MAAM,SAAS,IAAI,MAAM;AAC/B,OAAI,KAAK;AACP,qBAAiB,WAAW,KAAK,QAAQ;IACzC,MAAM,eAAe,SAAS,IAAI,YAAY;AAC9C,QAAI,aACF,wBAAuB,eAAe,cAAc,EAAE,IAAI,KAAA;;AAG9D;;AAIF,MAAI,QAAQ,WAAW,WAAW,EAAE;AAClC,qBAAkB,oBAAoB,QAAQ,MAAM,EAAE,CAAC;AACvD;;AAIF,MAAI,QAAQ,WAAW,oBAAoB,EAAE;AAC3C,sBAAmB,eAAe,QAAQ,MAAM,GAAG,EAAE,qBAAqB,IAAI,KAAA;AAC9E;;AAGF,MAAI,YAAY,iBACd;AAIF,MAAI,CAAC,QAAQ,WAAW,IAAI,IAAI,kBAAkB,GAAG;GACnD,MAAM,UAAmB;IACvB,IAAI,WAAW;IACf,KAAK,WAAW,SAAS,QAAQ;IACjC,UAAU;IACV,WAAW;IACZ;AAED,OAAI,kBAAkB;AACpB,YAAQ,YAAY;AACpB,2BAAuB,iBAAiB,MAAM;SAE9C,wBAAuB,KAAA;AAGzB,YAAS,KAAK,QAAQ;AACtB,kBAAe;AACf;AAEA,qBAAkB;AAClB,sBAAmB,KAAA;;;CAIvB,MAAM,gBAAgB;CAGtB,MAAM,iBACJ,WAAW,SAAS,UAAU,CAAC,iBAC3B,KAAA,IACA,iBACE;EAAE,KAAK;EAAgB,GAAI,uBAAuB,EAAE,WAAW,sBAAsB,GAAG,EAAE;EAAG,GAC7F,EAAE,KAAK,IAAI;AAInB,QAAO;EACL,GAAG;EACH,WAAW;EACX,UAAU;EACV;EACA;EACD"}

package/dist/dev/core/hls/parse-multivariant.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-multivariant.js","names":[],"sources":["../../../../src/core/hls/parse-multivariant.ts"],"sourcesContent":["import type {\n  AddressableObject,\n  AudioSelectionSet,\n  AudioSwitchingSet,\n  FrameRate,\n  PartiallyResolvedAudioTrack,\n  PartiallyResolvedTextTrack,\n  PartiallyResolvedVideoTrack,\n  Presentation,\n  SelectionSet,\n  TextSelectionSet,\n  TextSwitchingSet,\n  VideoSelectionSet,\n  VideoSwitchingSet,\n} from '../types';\nimport { generateId } from '../utils/generate-id';\nimport { matchTag, parseCodecs } from './parse-attributes';\nimport { resolveUrl } from './resolve-url';\n\n/**\n * Parse HLS multivariant playlist into a Presentation.\n *\n * Returns Presentation with partially resolved tracks (no segment information).\n * Tracks contain metadata from multivariant playlist (bandwidth, resolution, codecs)\n * but segment information is added when media playlists are fetched.\n *\n * @param text - Raw playlist text content\n * @param unresolved - Unresolved presentation (contains URL for base URL resolution)\n * @returns Presentation with partially resolved tracks (duration is undefined)\n */\nexport function parseMultivariantPlaylist(text: string, unresolved: AddressableObject): Presentation {\n  const baseUrl = unresolved.url;\n  const lines = text.split(/\\r?\\n/);\n\n  // Intermediate parsing structures\n  interface StreamInfo {\n    uri: string;\n    bandwidth: number;\n    resolution?: { width: number; height: number } | undefined;\n    codecs?: string | undefined;\n    frameRate?: FrameRate | undefined;\n    audioGroupId?: string | undefined;\n  }\n\n  interface AudioRenditionInfo {\n    groupId: string;\n    name: string;\n    language?: string | undefined;\n    uri?: string | undefined;\n    default?: boolean | undefined;\n    autoselect?: boolean | undefined;\n  }\n\n  interface SubtitleRenditionInfo {\n    groupId: string;\n    name: string;\n    language?: string | undefined;\n    uri: string;\n    default?: boolean | undefined;\n    autoselect?: boolean | undefined;\n    forced?: boolean | undefined;\n  }\n\n  const streams: StreamInfo[] = [];\n  const audioRenditions: AudioRenditionInfo[] = [];\n  const subtitleRenditions: SubtitleRenditionInfo[] = [];\n\n  // State for STREAM-INF parsing (URI follows on next line)\n  let pendingStreamInfo: Omit<StreamInfo, 'uri'> | null = null;\n\n  for (const line of lines) {\n    const trimmed = line.trim();\n\n    // Skip empty lines and comments\n    if (!trimmed || (trimmed.startsWith('#') && !trimmed.startsWith('#EXT'))) {\n      continue;\n    }\n\n    // Skip tags not used in Presentation model\n    if (\n      trimmed === '#EXTM3U' ||\n      trimmed.startsWith('#EXT-X-VERSION:') ||\n      trimmed.startsWith('#EXT-X-INDEPENDENT-SEGMENTS')\n    ) {\n      continue;\n    }\n\n    // #EXT-X-MEDIA:TYPE=AUDIO/SUBTITLES\n    const mediaAttrs = matchTag(trimmed, 'EXT-X-MEDIA');\n    if (mediaAttrs) {\n      const type = mediaAttrs.get('TYPE');\n      const groupId = mediaAttrs.get('GROUP-ID');\n      const name = mediaAttrs.get('NAME');\n\n      if (type === 'AUDIO' && groupId && name) {\n        const uri = mediaAttrs.get('URI');\n        audioRenditions.push({\n          groupId,\n          name,\n          language: mediaAttrs.get('LANGUAGE'),\n          uri: uri ? resolveUrl(uri, baseUrl) : undefined,\n          default: mediaAttrs.getBool('DEFAULT'),\n          autoselect: mediaAttrs.getBool('AUTOSELECT'),\n        });\n      }\n\n      if (type === 'SUBTITLES' && groupId && name) {\n        const uri = mediaAttrs.get('URI');\n        // URI is required for subtitle tracks\n        if (uri) {\n          subtitleRenditions.push({\n            groupId,\n            name,\n            language: mediaAttrs.get('LANGUAGE'),\n            uri: resolveUrl(uri, baseUrl),\n            default: mediaAttrs.getBool('DEFAULT'),\n            autoselect: mediaAttrs.getBool('AUTOSELECT'),\n            forced: mediaAttrs.getBool('FORCED'),\n          });\n        }\n      }\n      continue;\n    }\n\n    // #EXT-X-STREAM-INF:BANDWIDTH=...\n    const streamInfAttrs = matchTag(trimmed, 'EXT-X-STREAM-INF');\n    if (streamInfAttrs) {\n      pendingStreamInfo = {\n        bandwidth: streamInfAttrs.getInt('BANDWIDTH', 0)!,\n        resolution: streamInfAttrs.getResolution('RESOLUTION'),\n        codecs: streamInfAttrs.get('CODECS'),\n        frameRate: streamInfAttrs.getFrameRate('FRAME-RATE'),\n        audioGroupId: streamInfAttrs.get('AUDIO'),\n      };\n      continue;\n    }\n\n    // URI line following STREAM-INF\n    if (!trimmed.startsWith('#') && pendingStreamInfo) {\n      streams.push({\n        ...pendingStreamInfo,\n        uri: resolveUrl(trimmed, baseUrl),\n      });\n      pendingStreamInfo = null;\n    }\n  }\n\n  // Separate streams into video and audio based on codecs\n  // If CODECS has single codec, use parseCodecs to determine type\n  const videoStreams: typeof streams = [];\n  const audioOnlyStreams: typeof streams = [];\n\n  for (const stream of streams) {\n    if (!stream.codecs) {\n      // No codecs - assume video (default behavior)\n      videoStreams.push(stream);\n      continue;\n    }\n\n    const parsedCodecs = parseCodecs(stream.codecs);\n    const codecCount = stream.codecs.split(',').length;\n\n    // Single codec - determine type from parseCodecs result\n    if (codecCount === 1) {\n      if (parsedCodecs.audio && !parsedCodecs.video) {\n        // Audio-only stream\n        audioOnlyStreams.push(stream);\n      } else {\n        // Video stream (or unknown - default to video)\n        videoStreams.push(stream);\n      }\n    } else {\n      // Multiple codecs - video stream with muxed audio\n      videoStreams.push(stream);\n    }\n  }\n\n  // Build PartiallyResolvedVideoTracks from video streams\n  const videoTracks: PartiallyResolvedVideoTrack[] = videoStreams.map((stream) => {\n    const codecs = stream.codecs ? parseCodecs(stream.codecs) : undefined;\n\n    const track: PartiallyResolvedVideoTrack = {\n      type: 'video' as const,\n      id: generateId(),\n      url: stream.uri,\n      bandwidth: stream.bandwidth,\n      // Type-specific defaults (CMAF video)\n      mimeType: 'video/mp4',\n      codecs: [],\n    };\n\n    if (stream.resolution?.width !== undefined) {\n      track.width = stream.resolution.width;\n    }\n    if (stream.resolution?.height !== undefined) {\n      track.height = stream.resolution.height;\n    }\n    if (codecs?.video) {\n      track.codecs = [codecs.video];\n    }\n    if (stream.frameRate) {\n      track.frameRate = stream.frameRate;\n    }\n    if (stream.audioGroupId) {\n      track.audioGroupId = stream.audioGroupId;\n    }\n\n    return track;\n  });\n\n  // Build PartiallyResolvedAudioTracks from audio-only streams\n  const audioOnlyTracks: PartiallyResolvedAudioTrack[] = audioOnlyStreams.map((stream) => {\n    const codecs = stream.codecs ? parseCodecs(stream.codecs) : undefined;\n\n    const track: PartiallyResolvedAudioTrack = {\n      type: 'audio' as const,\n      id: generateId(),\n      url: stream.uri,\n      bandwidth: stream.bandwidth,\n      mimeType: 'audio/mp4',\n      codecs: codecs?.audio ? [codecs.audio] : [],\n      groupId: stream.audioGroupId || 'default',\n      name: 'Default',\n      sampleRate: 48000, // Default - will be in media playlist if available\n      channels: 2, // Default - will be in media playlist if available\n    };\n\n    return track;\n  });\n\n  // Build PartiallyResolvedAudioTracks from audio renditions (EXT-X-MEDIA)\n  // Extract audio codecs from referencing streams\n  const audioRenditionTracks: PartiallyResolvedAudioTrack[] = audioRenditions.map((rendition) => {\n    let audioCodecs: string[] | undefined;\n    for (const stream of streams) {\n      if (stream.audioGroupId === rendition.groupId && stream.codecs) {\n        const codecs = parseCodecs(stream.codecs);\n        if (codecs.audio) {\n          audioCodecs = [codecs.audio];\n          break;\n        }\n      }\n    }\n\n    const track: PartiallyResolvedAudioTrack = {\n      type: 'audio' as const,\n      id: generateId(),\n      url: rendition.uri ?? '',\n      groupId: rendition.groupId,\n      name: rendition.name,\n      // Type-specific defaults (CMAF audio)\n      mimeType: 'audio/mp4',\n      bandwidth: 0, // Not available in multivariant for demuxed audio\n      sampleRate: 48000, // CMAF default\n      channels: 2, // Stereo default\n      codecs: [],\n    };\n\n    if (rendition.language) {\n      track.language = rendition.language;\n    }\n    if (audioCodecs) {\n      track.codecs = audioCodecs;\n    }\n    if (rendition.default) {\n      track.default = rendition.default;\n    }\n    if (rendition.autoselect) {\n      track.autoselect = rendition.autoselect;\n    }\n\n    return track;\n  });\n\n  // Combine audio tracks from both EXT-X-MEDIA renditions and audio-only STREAM-INF\n  const audioTracks = [...audioRenditionTracks, ...audioOnlyTracks];\n\n  // Build PartiallyResolvedTextTracks from subtitle renditions\n  const textTracks: PartiallyResolvedTextTrack[] = subtitleRenditions.map((rendition) => {\n    const track: PartiallyResolvedTextTrack = {\n      type: 'text' as const,\n      id: generateId(),\n      url: rendition.uri,\n      groupId: rendition.groupId,\n      label: rendition.name,\n      kind: 'subtitles' as const,\n      // Type-specific defaults (VTT)\n      mimeType: 'text/vtt',\n      bandwidth: 0, // Text tracks don't consume bandwidth\n    };\n\n    if (rendition.language) {\n      track.language = rendition.language;\n    }\n    // Match hls.js/http-streaming: only set default=true when BOTH DEFAULT=YES AND AUTOSELECT=YES\n    if (rendition.default && rendition.autoselect) {\n      track.default = true;\n    }\n    if (rendition.autoselect) {\n      track.autoselect = rendition.autoselect;\n    }\n    if (rendition.forced) {\n      track.forced = rendition.forced;\n    }\n\n    return track;\n  });\n\n  // Build selection sets\n  const selectionSets: SelectionSet[] = [];\n\n  if (videoTracks.length > 0) {\n    const videoSwitchingSet: VideoSwitchingSet = {\n      id: generateId(),\n      type: 'video',\n      tracks: videoTracks,\n    };\n\n    const videoSelectionSet: VideoSelectionSet = {\n      id: generateId(),\n      type: 'video',\n      switchingSets: [videoSwitchingSet],\n    };\n\n    selectionSets.push(videoSelectionSet);\n  }\n\n  if (audioTracks.length > 0) {\n    const audioSwitchingSet: AudioSwitchingSet = {\n      id: generateId(),\n      type: 'audio',\n      tracks: audioTracks,\n    };\n\n    const audioSelectionSet: AudioSelectionSet = {\n      id: generateId(),\n      type: 'audio',\n      switchingSets: [audioSwitchingSet],\n    };\n\n    selectionSets.push(audioSelectionSet);\n  }\n\n  if (textTracks.length > 0) {\n    const textSwitchingSet: TextSwitchingSet = {\n      id: generateId(),\n      type: 'text',\n      tracks: textTracks,\n    };\n\n    const textSelectionSet: TextSelectionSet = {\n      id: generateId(),\n      type: 'text',\n      switchingSets: [textSwitchingSet],\n    };\n\n    selectionSets.push(textSelectionSet);\n  }\n\n  // Build presentation (duration is undefined until tracks are resolved)\n  return {\n    id: generateId(),\n    url: unresolved.url,\n    startTime: 0,\n    // duration: undefined, // Won't be known until after at least one media playlist is fetched + parsed\n    selectionSets,\n  };\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-url.js","names":[],"sources":["../../../../src/core/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;AAC/D,QAAO,IAAI,IAAI,KAAK,QAAQ,CAAC"}

package/dist/dev/core/task.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"task.js","names":["#runFn","#abortController","#signal","#status","#value","#error","#pending","#destroyed","#settled","#resolveSettled","#chain","#current"],"sources":["../../../src/core/task.ts"],"sourcesContent":["import { anyAbortSignal } from '@videojs/utils/events';\nimport { generateId } from './utils/generate-id';\n\n// =============================================================================\n// DeepReadonly\n// =============================================================================\n\n/** Recursively marks all properties as readonly. */\nexport type DeepReadonly<T> = T extends (infer U)[]\n  ? ReadonlyArray<DeepReadonly<U>>\n  : T extends object\n    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }\n    : T;\n\n// =============================================================================\n// Task\n// =============================================================================\n\nexport type TaskStatus = 'pending' | 'running' | 'done' | 'error';\n\n/**\n * Configuration for a Task.\n */\nexport interface TaskConfig {\n  /**\n   * Identifier for this task.\n   * - string: used as-is\n   * - () => string: called once at construction time\n   * - undefined: a unique ID is generated via generateId()\n   */\n  id?: string | (() => string);\n\n  /**\n   * Optional external AbortSignal to compose with the task's internal one.\n   * The task's work is aborted when either the internal controller (via abort())\n   * or this external signal fires — whichever comes first.\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Minimal contract for a schedulable unit of async work.\n */\nexport interface TaskLike<TValue = void, TError = unknown> {\n  readonly id: string;\n  readonly status: TaskStatus;\n  readonly value: DeepReadonly<TValue> | undefined;\n  readonly error: DeepReadonly<TError> | undefined;\n  run(): Promise<TValue>;\n  abort(): void;\n}\n\n/**\n * Generic reusable task that wraps an async run function.\n *\n * Owns its own AbortController so it can always be aborted independently.\n * Optionally composes an external AbortSignal so that a parent's cancellation\n * propagates into the task's work without requiring the caller to track the\n * task separately.\n *\n * Ordering guarantee: `value` is written before `status` transitions to `'done'`;\n * `error` is written before `status` transitions to `'error'`. Any reader\n * observing `status === 'done'` is guaranteed `value` is already present.\n */\nexport class Task<TValue = void, TError = unknown> implements TaskLike<TValue, TError> {\n  readonly id: string;\n  readonly #runFn: (signal: AbortSignal) => Promise<TValue>;\n  readonly #abortController = new AbortController();\n  readonly #signal: AbortSignal;\n\n  #status: TaskStatus = 'pending';\n  #value: TValue | undefined = undefined;\n  #error: TError | undefined = undefined;\n\n  constructor(runFn: (signal: AbortSignal) => Promise<TValue>, config?: TaskConfig) {\n    this.#runFn = runFn;\n    const rawId = config?.id;\n    this.id = typeof rawId === 'function' ? rawId() : (rawId ?? generateId());\n    this.#signal = config?.signal\n      ? anyAbortSignal([this.#abortController.signal, config.signal])\n      : this.#abortController.signal;\n  }\n\n  get status(): TaskStatus {\n    return this.#status;\n  }\n\n  get value(): DeepReadonly<TValue> | undefined {\n    return this.#value as DeepReadonly<TValue> | undefined;\n  }\n\n  get error(): DeepReadonly<TError> | undefined {\n    return this.#error as DeepReadonly<TError> | undefined;\n  }\n\n  async run(): Promise<TValue> {\n    this.#status = 'running';\n    try {\n      const result = await this.#runFn(this.#signal);\n      this.#value = result; // value before status — ordering guarantee\n      this.#status = 'done';\n      return result;\n    } catch (e) {\n      this.#error = e as TError; // error before status — ordering guarantee\n      this.#status = 'error';\n      throw e;\n    }\n  }\n\n  abort(): void {\n    this.#abortController.abort();\n  }\n}\n\n// =============================================================================\n// ConcurrentRunner\n// =============================================================================\n\n/**\n * Runs tasks concurrently, deduplicated by task id.\n *\n * If a task with a given id is already in flight, subsequent schedule() calls\n * for that id are silently ignored until the first completes. Tasks are stored\n * so abortAll() can cancel any in-flight work (e.g. on engine cleanup).\n */\nexport class ConcurrentRunner {\n  readonly #pending = new Map<string, { task: TaskLike<unknown, unknown>; promise: Promise<unknown> }>();\n  #settled: Promise<void> = Promise.resolve();\n  #resolveSettled: (() => void) | null = null;\n  #destroyed = false;\n\n  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue> {\n    if (this.#destroyed) return Promise.resolve() as Promise<TValue>;\n    const existing = this.#pending.get(task.id);\n    if (existing) return existing.promise as Promise<TValue>;\n\n    if (this.#pending.size === 0) {\n      this.#settled = new Promise((resolve) => {\n        this.#resolveSettled = resolve;\n      });\n    }\n\n    const promise = task.run();\n    // Suppress unhandled rejection for callers that ignore the return value.\n    promise.catch(() => {});\n    // Cleanup: update pending and resolve settled regardless of outcome.\n    const cleanup = () => {\n      this.#pending.delete(task.id);\n      if (this.#pending.size === 0) {\n        this.#resolveSettled?.();\n        this.#resolveSettled = null;\n      }\n    };\n    promise.then(cleanup, cleanup);\n\n    this.#pending.set(task.id, { task: task as TaskLike<unknown, unknown>, promise: promise as Promise<unknown> });\n    return promise;\n  }\n\n  /**\n   * Registers a callback to fire when all currently in-flight tasks settle.\n   * If the runner is already idle, the callback is never called. If abortAll()\n   * is called before the batch settles, the callback is superseded and silently\n   * dropped — no stale callbacks, no generation token required by the caller.\n   */\n  whenSettled(callback: () => void): void {\n    if (this.#pending.size === 0) return;\n    const captured = this.#settled;\n    captured.then(\n      () => {\n        if (this.#settled !== captured) return;\n        callback();\n      },\n      () => {}\n    );\n  }\n\n  abortAll(): void {\n    for (const { task } of this.#pending.values()) task.abort();\n    this.#pending.clear();\n    // Resolve the current settled promise so any .then() handlers are queued,\n    // then replace the reference — whenSettled callbacks that captured the old\n    // reference will see the identity mismatch and be dropped.\n    this.#resolveSettled?.();\n    this.#resolveSettled = null;\n    this.#settled = Promise.resolve();\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.abortAll();\n  }\n}\n\n// =============================================================================\n// SerialRunner\n// =============================================================================\n\n/**\n * Runs tasks one at a time in submission order.\n *\n * Each schedule() call returns a Promise that resolves or rejects with the\n * task's result when it is eventually executed. Tasks wait in queue until the\n * prior task completes.\n *\n * Serialization is achieved by chaining each task's run() onto the tail of a\n * shared promise chain — no explicit queue or drain loop needed.\n *\n * abortAll() aborts all pending (not yet started) tasks and the currently\n * in-flight task. Pending tasks still run briefly but receive an aborted\n * signal and are expected to exit early.\n */\nexport class SerialRunner {\n  #chain: Promise<unknown> = Promise.resolve();\n  readonly #pending = new Set<TaskLike<unknown, unknown>>();\n  #current: TaskLike<unknown, unknown> | null = null;\n  #destroyed = false;\n\n  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue> {\n    if (this.#destroyed) return Promise.resolve() as Promise<TValue>;\n    const t = task as TaskLike<unknown, unknown>;\n    this.#pending.add(t);\n\n    const result = this.#chain\n      .then(() => {\n        this.#pending.delete(t);\n        this.#current = t;\n        return task.run();\n      })\n      .finally(() => {\n        this.#current = null;\n      });\n\n    // Advance the chain regardless of whether this task succeeds or fails.\n    this.#chain = result.then(\n      () => {},\n      () => {}\n    );\n\n    return result as Promise<TValue>;\n  }\n\n  /**\n   * A promise that resolves when all currently-scheduled tasks have settled.\n   * Use the reference as a generation token: capture it after scheduling a\n   * batch, then check identity in the resolution callback to detect whether\n   * a subsequent abortAll() + new batch has superseded this one.\n   */\n  get settled(): Promise<void> {\n    return this.#chain as Promise<void>;\n  }\n\n  /**\n   * Registers a callback to fire when all currently-pending tasks settle.\n   * If the runner is already idle (no pending or running tasks), the callback\n   * is never called. If new tasks are scheduled before the current batch\n   * settles, the callback is superseded and silently dropped — no stale\n   * callbacks, no generation token required by the caller.\n   */\n  whenSettled(callback: () => void): void {\n    if (this.#pending.size === 0 && this.#current === null) return;\n    const currentChain = this.#chain;\n    currentChain.then(\n      () => {\n        if (this.#chain !== currentChain) return;\n        callback();\n      },\n      () => {}\n    );\n  }\n\n  /** Aborts and clears queued tasks without touching the in-flight task. */\n  abortPending(): void {\n    for (const task of this.#pending) task.abort();\n    this.#pending.clear();\n  }\n\n  abortAll(): void {\n    this.abortPending();\n    this.#current?.abort();\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.abortAll();\n  }\n}\n"],"mappings":"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"}

package/dist/dev/core/types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/core/types/index.ts"],"mappings":";;AAgBA;;;;;AAOA;;;;;UAPiB,GAAA;EACf,EAAA;AAAA;;;AAmCF;UA7BiB,iBAAA;EACf,GAAA;EACA,SAAA;IACE,KAAA;IACA,GAAA;EAAA;AAAA;;;;;UAyBa,QAAA;EACf,SAAA;EACA,QAAA;AAAA;;;;KAUU,SAAA;;;;;;;;UAaK,SAAA;EACf,kBAAA;EACA,oBAAA;AAAA;;;;;;;KAaU,iBAAA,WAA4B,KAAA,GAAQ,KAAA,IAAS,IAAA,CAAK,CAAA,wCAAyC,QAAA;EACrG,QAAA;EACA,QAAA;EACA,SAAA;EACA,cAAA;AAAA;;;AA0CF;;;;;;KAfY,KAAA,GAAQ,GAAA,GAClB,iBAAA,GACA,QAAA;EACE,IAAA,EAAM,SAAA;EACN,MAAA;EACA,QAAA;EACA,QAAA;EACA,SAAA;EACA,cAAA,GAAiB,iBAAA;EACjB,QAAA,EAAU,OAAA;AAAA;;;;KAMF,UAAA,GAAa,KAAA,GACvB,QAAA,CAAS,IAAA,CAAK,KAAA;EACZ,IAAA;EAGA,KAAA;EACA,MAAA;EACA,SAAA,GAAY,SAAA;EACZ,YAAA;AAAA;;;;KAMQ,UAAA,GAAa,KAAA,GACvB,QAAA,CAAS,IAAA,CAAK,KAAA;EACZ,IAAA;EACA,OAAA;EACA,IAAA;EACA,UAAA;EACA,QAAA;EACA,OAAA;EACA,UAAA;AAAA;;;;KAMQ,SAAA,GAAY,KAAA;EACtB,IAAA;EACA,OAAA;EACA,KAAA;EACA,IAAA;EACA,OAAA;EACA,UAAA;EACA,MAAA;AAAA;;;;;;;KAgCU,cAAA,WAAyB,KAAA,GAAQ,KAAA,IAAS,GAAA;EACpD,IAAA,EAAM,CAAA;EACN,MAAA,GAAS,iBAAA,CAAkB,CAAA,IAAK,CAAA;AAAA;;;;;;;KA8BtB,cAAA,WAAyB,KAAA,GAAQ,KAAA,IAAS,GAAA;EACpD,IAAA,EAAM,CAAA;EACN,aAAA,EAAe,cAAA,CAAe,CAAA;AAAA;;;;KAMpB,iBAAA,GAAoB,cAAA,CAAe,UAAA;;AAA/C;;KAKY,iBAAA,GAAoB,cAAA,CAAe,UAAA;;;AAA/C;KAKY,gBAAA,GAAmB,cAAA,CAAe,SAAA;;;;AAA9C;KAMY,YAAA,GAAe,iBAAA,GAAoB,iBAAA,GAAoB,gBAAA;;;;AAAnE;KAUY,OAAA,GAAU,GAAA,GAAM,iBAAA,GAAoB,QAAA;;;;;;;;KA+BpC,YAAA,GAAe,GAAA,GACzB,iBAAA,GACA,OAAA,CAAQ,QAAA;EACN,aAAA,EAAe,YAAA;AAAA"}

package/dist/dev/core/types/index.js

@@ -1,15 +0,0 @@
-//#region src/core/types/index.ts
-function isResolvedTrack(track) {
-	return "segments" in track;
-}
-/**
-* Check if a presentation has duration (at least one track resolved).
-* Narrows type to include required duration.
-*/
-function hasPresentationDuration(presentation) {
-	return presentation.duration !== void 0;
-}
-//#endregion
-export { hasPresentationDuration, isResolvedTrack };
-
-//# sourceMappingURL=index.js.map

package/dist/dev/core/types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../src/core/types/index.ts"],"sourcesContent":["/**\n * Core SPF Types\n *\n * Based on CMAF-HAM (Common Media Application Format - Hypothetical Application Model)\n * Protocol-agnostic representation of streaming media content.\n *\n * @see https://github.com/AcademySoftwareFoundation/common-media-library\n */\n\n// =============================================================================\n// Base Types\n// =============================================================================\n\n/**\n * Base identifier type for all HAM objects.\n */\nexport interface Ham {\n  id: string;\n}\n\n/**\n * Addressable resource with optional byte range.\n */\nexport interface AddressableObject {\n  url: string;\n  byteRange?: {\n    start: number;\n    end: number;\n  };\n}\n\n// =============================================================================\n// Platform-agnostic Media Element\n// =============================================================================\n\n/**\n * Platform-agnostic media element interface.\n * Captures minimal shape needed for orchestration without DOM dependencies.\n * HTMLMediaElement satisfies this interface.\n */\nexport interface MediaElementLike {\n  preload: string;\n}\n\n// =============================================================================\n// Time and Duration\n// =============================================================================\n\n/**\n * Time span with start time and duration.\n * Used for segments and other timed ranges.\n */\nexport interface TimeSpan {\n  startTime: number;\n  duration: number;\n}\n\n// =============================================================================\n// Enums\n// =============================================================================\n\n/**\n * Track content type.\n */\nexport type TrackType = 'video' | 'audio' | 'text';\n\n// =============================================================================\n// Frame Rate\n// =============================================================================\n\n/**\n * Video frame rate expressed as numerator/denominator.\n *\n * Examples:\n * - 30 fps: { frameRateNumerator: 30 }\n * - 29.97 fps: { frameRateNumerator: 30000, frameRateDenominator: 1001 }\n */\nexport interface FrameRate {\n  frameRateNumerator: number;\n  frameRateDenominator?: number;\n}\n\n// =============================================================================\n// Partially Resolved Tracks (before media playlist is fetched)\n// =============================================================================\n\n/**\n * Generic type for partially resolved tracks.\n * Removes fields that come from media playlist parsing.\n *\n * @param T - Track type to make partially resolved (must extend Track)\n */\nexport type PartiallyResolved<T extends Track = Track> = Omit<T, 'segments' | 'initialization' | keyof TimeSpan> & {\n  segments?: never;\n  duration?: never;\n  startTime?: never;\n  initialization?: never;\n};\n\n/**\n * Partially resolved video track from multivariant playlist.\n * Has metadata but no segments or initialization yet (media playlist not fetched).\n */\nexport type PartiallyResolvedVideoTrack = PartiallyResolved<VideoTrack>;\n\n/**\n * Partially resolved audio track from multivariant playlist.\n * Has metadata but no segments or initialization yet (media playlist not fetched).\n */\nexport type PartiallyResolvedAudioTrack = PartiallyResolved<AudioTrack>;\n\n// =============================================================================\n// Resolved Track Types (with segments from media playlist)\n// =============================================================================\n\n/**\n * Base track type containing common properties for all resolved tracks.\n * A resolved track has segments, duration, and initialization data.\n * All URLs are fully qualified (parsers resolve relative URLs).\n */\n/**\n * Track startTime is always 0 (for future multi-period support).\n */\nexport type Track = Ham &\n  AddressableObject &\n  TimeSpan & {\n    type: TrackType;\n    codecs?: string[]; // Optional per HLS spec\n    mimeType: string;\n    language?: string | undefined;\n    bandwidth: number;\n    initialization?: AddressableObject;\n    segments: Segment[];\n  };\n\n/**\n * Resolved video track with segments.\n */\nexport type VideoTrack = Track &\n  Required<Pick<Track, 'initialization' | 'codecs'>> & {\n    type: 'video';\n\n    // Optional metadata from multivariant (per HLS spec)\n    width?: number;\n    height?: number;\n    frameRate?: FrameRate;\n    audioGroupId?: string;\n  };\n\n/**\n * Resolved audio track with segments.\n */\nexport type AudioTrack = Track &\n  Required<Pick<Track, 'initialization' | 'codecs'>> & {\n    type: 'audio';\n    groupId: string;\n    name: string;\n    sampleRate: number;\n    channels: number;\n    default?: boolean;\n    autoselect?: boolean;\n  };\n\n/**\n * Resolved text track with segments.\n */\nexport type TextTrack = Track & {\n  type: 'text';\n  groupId: string;\n  label: string;\n  kind: 'subtitles' | 'captions';\n  default?: boolean;\n  autoselect?: boolean;\n  forced?: boolean;\n};\n\n/**\n * Partially resolved text track from multivariant playlist.\n * Has metadata but no segments or initialization yet (media playlist not fetched).\n */\nexport type PartiallyResolvedTextTrack = PartiallyResolved<TextTrack>;\n\n/**\n * Union of all resolved track types.\n */\nexport type ResolvedTrack = VideoTrack | AudioTrack | TextTrack;\n\n/**\n * Union of all partially resolved track types.\n */\nexport type PartiallyResolvedTrack =\n  | PartiallyResolvedVideoTrack\n  | PartiallyResolvedAudioTrack\n  | PartiallyResolvedTextTrack;\n\n// =============================================================================\n// Switching and Selection Sets\n// =============================================================================\n\n/**\n * Generic switching set type.\n * A group of tracks that can be switched between seamlessly.\n *\n * @param T - Track type (VideoTrack, AudioTrack, or TextTrack)\n */\nexport type SwitchingSetOf<T extends Track = Track> = Ham & {\n  type: T['type'];\n  tracks: (PartiallyResolved<T> | T)[];\n};\n\n/**\n * Video switching set - contains only video tracks (partially resolved or fully resolved).\n */\nexport type VideoSwitchingSet = SwitchingSetOf<VideoTrack>;\n\n/**\n * Audio switching set - contains only audio tracks (partially resolved or fully resolved).\n */\nexport type AudioSwitchingSet = SwitchingSetOf<AudioTrack>;\n\n/**\n * Text switching set - contains only text tracks (partially resolved or fully resolved).\n */\nexport type TextSwitchingSet = SwitchingSetOf<TextTrack>;\n\n/**\n * Switching set - a group of tracks that can be switched between seamlessly.\n * Discriminated by track type.\n */\nexport type SwitchingSet = VideoSwitchingSet | AudioSwitchingSet | TextSwitchingSet;\n\n/**\n * Generic selection set type.\n * Groups switching sets by track type.\n *\n * @param T - Track type (VideoTrack, AudioTrack, or TextTrack)\n */\nexport type SelectionSetOf<T extends Track = Track> = Ham & {\n  type: T['type'];\n  switchingSets: SwitchingSetOf<T>[];\n};\n\n/**\n * Video selection set - contains only video switching sets.\n */\nexport type VideoSelectionSet = SelectionSetOf<VideoTrack>;\n\n/**\n * Audio selection set - contains only audio switching sets.\n */\nexport type AudioSelectionSet = SelectionSetOf<AudioTrack>;\n\n/**\n * Text selection set - contains only text switching sets.\n */\nexport type TextSelectionSet = SelectionSetOf<TextTrack>;\n\n/**\n * Selection set - groups switching sets by track type.\n * Discriminated union ensures type-safe track access.\n */\nexport type SelectionSet = VideoSelectionSet | AudioSelectionSet | TextSelectionSet;\n\n// =============================================================================\n// Segment\n// =============================================================================\n\n/**\n * Media segment with timing information.\n * Follows CMAF-HAM composition pattern.\n */\nexport type Segment = Ham & AddressableObject & TimeSpan;\n\n// =============================================================================\n// Media Playlist Info\n// =============================================================================\n\n/**\n * Intermediate representation of a parsed media playlist.\n * Used internally before assembling into full Track structure.\n */\nexport interface MediaPlaylistInfo {\n  version: number;\n  targetDuration: number;\n  playlistType: 'VOD' | 'EVENT' | undefined;\n  initSegment: AddressableObject | null;\n  segments: Segment[];\n  duration: number;\n  endList: boolean;\n}\n\n// =============================================================================\n// Presentation\n// =============================================================================\n\n/**\n * Presentation - a single playable period of content.\n * Uses TimeSpan fields (startTime always 0, duration optional until track resolved).\n *\n * Extends AddressableObject so `url` contains the original manifest URL.\n * All URLs are fully qualified (parsers resolve relative URLs).\n */\nexport type Presentation = Ham &\n  AddressableObject &\n  Partial<TimeSpan> & {\n    selectionSets: SelectionSet[];\n  };\n\n// =============================================================================\n// Type Guards\n// =============================================================================\n\n/**\n * Check if a track is resolved (has segments).\n * Works for all track types with overloaded signatures for type narrowing.\n */\nexport function isResolvedTrack(track: PartiallyResolvedVideoTrack | VideoTrack): track is VideoTrack;\nexport function isResolvedTrack(track: PartiallyResolvedAudioTrack | AudioTrack): track is AudioTrack;\nexport function isResolvedTrack(track: PartiallyResolvedTextTrack | TextTrack): track is TextTrack;\nexport function isResolvedTrack(track: PartiallyResolvedTrack | ResolvedTrack): track is ResolvedTrack;\nexport function isResolvedTrack(track: PartiallyResolvedTrack | ResolvedTrack): track is ResolvedTrack {\n  return 'segments' in track;\n}\n\n/**\n * Check if a presentation has duration (at least one track resolved).\n * Narrows type to include required duration.\n */\nexport function hasPresentationDuration(\n  presentation: Presentation\n): presentation is Presentation & { duration: number } {\n  return presentation.duration !== undefined;\n}\n"],"mappings":";AAgUA,SAAgB,gBAAgB,OAAuE;AACrG,QAAO,cAAc;;;;;;AAOvB,SAAgB,wBACd,cACqD;AACrD,QAAO,aAAa,aAAa,KAAA"}

package/dist/dev/core/utils/generate-id.js

@@ -1,21 +0,0 @@
-//#region src/core/utils/generate-id.ts
-/**
-* Generate unique ID for HAM objects.
-*
-* Uses timestamp + random number for sufficient uniqueness.
-* IDs are strings without decimals.
-*
-* @returns Unique string ID in format: timestamp-random
-*
-* @example
-* ```ts
-* const id = generateId();  // "1738423156789-542891"
-* ```
-*/
-function generateId() {
-	return `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
-}
-//#endregion
-export { generateId };
-
-//# sourceMappingURL=generate-id.js.map

package/dist/dev/core/utils/generate-id.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-id.js","names":[],"sources":["../../../../src/core/utils/generate-id.ts"],"sourcesContent":["/**\n * Generate unique ID for HAM objects.\n *\n * Uses timestamp + random number for sufficient uniqueness.\n * IDs are strings without decimals.\n *\n * @returns Unique string ID in format: timestamp-random\n *\n * @example\n * ```ts\n * const id = generateId();  // \"1738423156789-542891\"\n * ```\n */\nexport function generateId(): string {\n  return `${Date.now()}-${Math.floor(Math.random() * 1000000)}`;\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,aAAqB;AACnC,QAAO,GAAG,KAAK,KAAK,CAAC,GAAG,KAAK,MAAM,KAAK,QAAQ,GAAG,IAAQ"}

package/dist/dev/core/utils/track-selection.d.ts

@@ -1,16 +0,0 @@
-import { AddressableObject, Presentation } from "../types/index.js";
-
-//#region src/core/utils/track-selection.d.ts
-/**
- * State shape for track selection.
- * Minimal shape containing presentation and selected track IDs.
- */
-interface TrackSelectionState {
-  presentation?: AddressableObject | Presentation | undefined;
-  selectedVideoTrackId?: string | undefined;
-  selectedAudioTrackId?: string | undefined;
-  selectedTextTrackId?: string | undefined;
-}
-//#endregion
-export { TrackSelectionState };
-//# sourceMappingURL=track-selection.d.ts.map

package/dist/dev/core/utils/track-selection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"track-selection.d.ts","names":[],"sources":["../../../../src/core/utils/track-selection.ts"],"mappings":";;;;;AAgBA;;UAAiB,mBAAA;EACf,YAAA,GAAe,iBAAA,GAAoB,YAAA;EACnC,oBAAA;EACA,oBAAA;EACA,mBAAA;AAAA"}

package/dist/dev/core/utils/track-selection.js

@@ -1,39 +0,0 @@
-//#region src/core/utils/track-selection.ts
-/**
-* Map track type to selected track ID property key in state.
-*/
-const SelectedTrackIdKeyByType = {
-	video: "selectedVideoTrackId",
-	audio: "selectedAudioTrackId",
-	text: "selectedTextTrackId"
-};
-/**
-* Map track type to buffer owner property key.
-* Used for SourceBuffer references in owners.
-*/
-const BufferKeyByType = {
-	video: "videoBuffer",
-	audio: "audioBuffer"
-};
-/**
-* Get selected track from state by type.
-* Returns properly typed track (partially or fully resolved) or undefined.
-* Type parameter T is inferred from the type argument.
-*
-* @example
-* const videoTrack = getSelectedTrack(state, 'video');
-* if (videoTrack && isResolvedTrack(videoTrack)) {
-*   // videoTrack is VideoTrack
-* }
-*/
-function getSelectedTrack(state, type) {
-	const { presentation } = state;
-	/** @TODO Consider moving and reusing isUnresolved(presentation) (CJP) */
-	if (!presentation || !("id" in presentation)) return void 0;
-	const trackId = state[SelectedTrackIdKeyByType[type]];
-	return presentation.selectionSets.find(({ type: selectionSetType }) => selectionSetType === type)?.switchingSets[0]?.tracks.find(({ id }) => id === trackId);
-}
-//#endregion
-export { BufferKeyByType, SelectedTrackIdKeyByType, getSelectedTrack };
-
-//# sourceMappingURL=track-selection.js.map

package/dist/dev/core/utils/track-selection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"track-selection.js","names":[],"sources":["../../../../src/core/utils/track-selection.ts"],"sourcesContent":["import type {\n  AddressableObject,\n  AudioTrack,\n  PartiallyResolvedAudioTrack,\n  PartiallyResolvedTextTrack,\n  PartiallyResolvedVideoTrack,\n  Presentation,\n  TextTrack,\n  TrackType,\n  VideoTrack,\n} from '../types';\n\n/**\n * State shape for track selection.\n * Minimal shape containing presentation and selected track IDs.\n */\nexport interface TrackSelectionState {\n  presentation?: AddressableObject | Presentation | undefined;\n  selectedVideoTrackId?: string | undefined;\n  selectedAudioTrackId?: string | undefined;\n  selectedTextTrackId?: string | undefined;\n}\n\n/**\n * Map track type to selected track ID property key in state.\n */\nexport const SelectedTrackIdKeyByType = {\n  video: 'selectedVideoTrackId',\n  audio: 'selectedAudioTrackId',\n  text: 'selectedTextTrackId',\n} as const;\n\n/**\n * Map track type to buffer owner property key.\n * Used for SourceBuffer references in owners.\n */\nexport const BufferKeyByType = {\n  video: 'videoBuffer',\n  audio: 'audioBuffer',\n} as const;\n\n/**\n * Get selected track from state by type.\n * Returns properly typed track (partially or fully resolved) or undefined.\n * Type parameter T is inferred from the type argument.\n *\n * @example\n * const videoTrack = getSelectedTrack(state, 'video');\n * if (videoTrack && isResolvedTrack(videoTrack)) {\n *   // videoTrack is VideoTrack\n * }\n */\nexport function getSelectedTrack<T extends TrackType>(\n  state: TrackSelectionState,\n  type: T\n): T extends 'video'\n  ? PartiallyResolvedVideoTrack | VideoTrack | undefined\n  : T extends 'audio'\n    ? PartiallyResolvedAudioTrack | AudioTrack | undefined\n    : T extends 'text'\n      ? PartiallyResolvedTextTrack | TextTrack | undefined\n      : never {\n  const { presentation } = state;\n\n  /** @TODO Consider moving and reusing isUnresolved(presentation) (CJP) */\n  if (!presentation || !('id' in presentation)) return undefined as any;\n\n  // Get track ID based on type\n  const trackIdKey = SelectedTrackIdKeyByType[type];\n  const trackId = state[trackIdKey];\n  return presentation.selectionSets\n    .find(({ type: selectionSetType }) => selectionSetType === type)\n    ?.switchingSets[0]?.tracks.find(({ id }) => id === trackId) as any;\n}\n"],"mappings":";;;;AA0BA,MAAa,2BAA2B;CACtC,OAAO;CACP,OAAO;CACP,MAAM;CACP;;;;;AAMD,MAAa,kBAAkB;CAC7B,OAAO;CACP,OAAO;CACR;;;;;;;;;;;;AAaD,SAAgB,iBACd,OACA,MAOY;CACZ,MAAM,EAAE,iBAAiB;;AAGzB,KAAI,CAAC,gBAAgB,EAAE,QAAQ,cAAe,QAAO,KAAA;CAIrD,MAAM,UAAU,MADG,yBAAyB;AAE5C,QAAO,aAAa,cACjB,MAAM,EAAE,MAAM,uBAAuB,qBAAqB,KAAK,EAC9D,cAAc,IAAI,OAAO,MAAM,EAAE,SAAS,OAAO,QAAQ"}

package/dist/dev/dom/features/end-of-stream.js

@@ -1,145 +0,0 @@
-import { effect } from "../../core/signals/effect.js";
-import { computed } from "../../core/signals/primitives.js";
-import { isResolvedTrack } from "../../core/types/index.js";
-import { getSelectedTrack } from "../../core/utils/track-selection.js";
-//#region src/dom/features/end-of-stream.ts
-/**
-* Check if the last segment of a track has been appended to a SourceBuffer.
-*
-* Checks by segment ID rather than a pipeline flag, so it is robust across
-* quality switches (different tracks have different segment IDs) and
-* back-buffer flushes (flushed segment IDs are removed from the model).
-*/
-function isLastSegmentAppended(segments, actor) {
-	if (segments.length === 0) return true;
-	const lastSeg = segments[segments.length - 1];
-	if (!lastSeg) return false;
-	return actor?.snapshot.get().context.segments.some((s) => s.id === lastSeg.id && !s.partial) ?? false;
-}
-/**
-* Check if the last segment has been appended for each selected track.
-*
-* Handles video-only, audio-only, and video+audio scenarios.
-* A track with no segments (e.g. unresolved) is considered not ready.
-*/
-function hasLastSegmentLoaded(state, owners) {
-	const videoTrack = state.selectedVideoTrackId ? getSelectedTrack(state, "video") : void 0;
-	const audioTrack = state.selectedAudioTrackId ? getSelectedTrack(state, "audio") : void 0;
-	if (videoTrack && !isResolvedTrack(videoTrack)) return false;
-	if (audioTrack && !isResolvedTrack(audioTrack)) return false;
-	if (videoTrack && isResolvedTrack(videoTrack)) {
-		if (!isLastSegmentAppended(videoTrack.segments, owners.videoBufferActor)) return false;
-	}
-	if (audioTrack && isResolvedTrack(audioTrack)) {
-		if (!isLastSegmentAppended(audioTrack.segments, owners.audioBufferActor)) return false;
-	}
-	return true;
-}
-/**
-* Check if we can call endOfStream.
-*/
-function canEndStream(state, owners) {
-	return !!(owners.mediaSource && state.presentation);
-}
-/**
-* Check if we should call endOfStream.
-*/
-function shouldEndStream(state, owners) {
-	if (!canEndStream(state, owners)) return false;
-	const { mediaElement } = owners;
-	if ((owners.mediaSourceReadyState?.get() ?? owners.mediaSource?.readyState) !== "open") return false;
-	if (mediaElement && mediaElement.readyState < HTMLMediaElement.HAVE_METADATA) return false;
-	const hasVideoTrack = !!state.selectedVideoTrackId;
-	const hasAudioTrack = !!state.selectedAudioTrackId;
-	if (hasVideoTrack && !owners.videoBuffer) return false;
-	if (hasAudioTrack && !owners.audioBuffer) return false;
-	if (owners.videoBufferActor?.snapshot.get().value === "updating") return false;
-	if (owners.audioBufferActor?.snapshot.get().value === "updating") return false;
-	if (!hasLastSegmentLoaded(state, owners)) return false;
-	if (mediaElement) {
-		const videoTrack = hasVideoTrack ? getSelectedTrack(state, "video") : void 0;
-		const audioTrack = hasAudioTrack ? getSelectedTrack(state, "audio") : void 0;
-		const refTrack = videoTrack && isResolvedTrack(videoTrack) ? videoTrack : audioTrack && isResolvedTrack(audioTrack) ? audioTrack : void 0;
-		if (refTrack && refTrack.segments.length > 0) {
-			const lastSeg = refTrack.segments[refTrack.segments.length - 1];
-			if (mediaElement.currentTime < lastSeg.startTime) return false;
-		}
-	}
-	return true;
-}
-/**
-* Wait for all currently-updating SourceBufferActors to finish.
-* Uses actor state rather than raw SourceBuffer.updating so the wait is
-* aligned with the same abstraction that owns all buffer operations.
-*/
-function waitForSourceBuffersReady(owners) {
-	const updatingActors = [owners.videoBufferActor, owners.audioBufferActor].filter((actor) => actor !== void 0 && actor.snapshot.get().value === "updating");
-	if (updatingActors.length === 0) return Promise.resolve();
-	return Promise.all(updatingActors.map((actor) => new Promise((resolve) => {
-		let cleanup;
-		let resolved = false;
-		cleanup = effect(() => {
-			if (actor.snapshot.get().value !== "updating") {
-				if (!resolved) {
-					resolved = true;
-					resolve();
-				}
-				queueMicrotask(() => cleanup?.());
-			}
-		});
-	}))).then(() => void 0);
-}
-/**
-* Get the highest buffered end time across all active SourceBuffers.
-* Used to set the final duration from actual container timestamps rather
-* than playlist metadata, which handles both shorter and longer cases.
-*/
-function getMaxBufferedEnd(owners) {
-	let max = 0;
-	for (const buf of [owners.videoBuffer, owners.audioBuffer]) if (buf && buf.buffered.length > 0) {
-		const end = buf.buffered.end(buf.buffered.length - 1);
-		if (end > max) max = end;
-	}
-	return max;
-}
-/**
-* End of stream task (module-level, pure).
-* Sets the final duration from actual buffered end time, then calls endOfStream().
-*/
-const endOfStreamTask = async ({ currentOwners }, _context) => {
-	const { mediaSource } = currentOwners;
-	if (mediaSource.readyState === "ended") return;
-	await waitForSourceBuffersReady(currentOwners);
-	if (mediaSource.readyState !== "open") return;
-	const bufferedEnd = getMaxBufferedEnd(currentOwners);
-	if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;
-	mediaSource.endOfStream();
-	await new Promise((resolve) => requestAnimationFrame(resolve));
-};
-/**
-* Call endOfStream when the last segment has been appended.
-* This signals to the browser that the stream is complete.
-*
-* Per the MSE spec, appendBuffer() remains valid after endOfStream() —
-* seeks that require re-appending earlier segments will still work.
-* What becomes blocked is calling endOfStream() again, addSourceBuffer(),
-* and MediaSource.duration updates.
-*/
-function endOfStream({ state, owners }) {
-	const shouldEnd = computed(() => shouldEndStream(state.get(), owners.get()));
-	let hasEnded = false;
-	return effect(() => {
-		if (!shouldEnd.get()) return;
-		const currentOwners = owners.get();
-		if (hasEnded) {
-			if ((currentOwners.mediaSourceReadyState?.get() ?? currentOwners.mediaSource?.readyState) !== "open") return;
-			hasEnded = false;
-		}
-		hasEnded = true;
-		endOfStreamTask({ currentOwners }, {}).catch((error) => console.error("Failed to call endOfStream:", error));
-	});
-}
-//#endregion
-export { endOfStream };
-
-//# sourceMappingURL=end-of-stream.js.map