@rixl/media-core 1.0.2 → 1.1.0

package/dist/lib/environment-effects.js

@@ -1,139 +0,0 @@
-import { getRestoredVolume, shouldBeMuted } from "./volume-utils.js";
-import { isDocumentFullscreen } from "./fullscreen-utils.js";
-import { isVideoPictureInPicture } from "./pip-utils.js";
-
-// src/lib/environment-effects.ts
-/**
-* Pure helpers for video-element environment effects.
-*
-* "Environment effects" = things the player has to keep in sync with the
-* surrounding document/window: fullscreen state, picture-in-picture state,
-* tab visibility, viewport size, and the volume/mute state derived from
-* player + user-interaction inputs.
-*
-* Everything in this module is framework-agnostic. React/Lit/Vue wrappers
-* supply the DOM listeners and the store-update callbacks; this module
-* supplies the predicates, the state derivations, and the listener factories.
-*/
-/**
-* Bind the `document` `fullscreenchange` event to a callback that receives the
-* current fullscreen state.
-*
-* Returns a teardown function that removes the listener.
-*/
-function bindFullscreenChangeListener(onChange) {
-	const handler = () => onChange(isDocumentFullscreen());
-	document.addEventListener("fullscreenchange", handler);
-	return () => document.removeEventListener("fullscreenchange", handler);
-}
-/**
-* Bind `enterpictureinpicture` and `leavepictureinpicture` events on a
-* video element to a callback that receives the current PiP state.
-*
-* Returns a teardown function.
-*/
-function bindPictureInPictureChangeListener(videoElement, onChange) {
-	if (!videoElement) return () => void 0;
-	const handler = () => onChange(isVideoPictureInPicture(videoElement));
-	videoElement.addEventListener("enterpictureinpicture", handler);
-	videoElement.addEventListener("leavepictureinpicture", handler);
-	return () => {
-		videoElement.removeEventListener("enterpictureinpicture", handler);
-		videoElement.removeEventListener("leavepictureinpicture", handler);
-	};
-}
-/**
-* Decide whether to re-request PiP when the document becomes hidden.
-*
-* Returns `true` when the caller should re-enter PiP on the supplied
-* video element. The actual `requestPictureInPicture()` call is left to the
-* caller (since it returns a promise and the caller chooses how to handle
-* errors).
-*/
-function shouldReenterPictureInPicture({ videoElement, isCurrentlyInPip }) {
-	if (typeof document === "undefined") return false;
-	if (document.visibilityState !== "hidden") return false;
-	if (!isCurrentlyInPip) return false;
-	if (!videoElement) return false;
-	if (isVideoPictureInPicture(videoElement)) return false;
-	return true;
-}
-/**
-* Bind a `visibilitychange` handler that re-enters PiP whenever the document
-* becomes hidden and the player believes itself to be in PiP but the browser
-* has dropped out.
-*
-* Returns a teardown function.
-*/
-function bindPipVisibilityReentry(getOptions, onError = (err) => console.error("Error maintaining PIP mode:", err)) {
-	const handler = () => {
-		const options = getOptions();
-		if (!shouldReenterPictureInPicture(options)) return;
-		options.videoElement.requestPictureInPicture().catch(onError);
-	};
-	document.addEventListener("visibilitychange", handler);
-	return () => document.removeEventListener("visibilitychange", handler);
-}
-/**
-* Pure derivation of the values that should be written to the video element
-* (and back to the store) given the current player state.
-*
-* Mirrors the behaviour previously implemented inside `useVolumeEffect`:
-*
-* 1. When the caller forces mute, nothing else is touched.
-* 2. Otherwise, `shouldBeMuted` decides the effective mute state.
-* 3. When unmuted, `getRestoredVolume` resolves the volume to assign, and the
-*    store is updated only when the current persisted volume is `0`.
-*/
-function deriveVolumeSync({ forcedMuted, playerMuted, playerInteracted, playerVolume, playerPreviousVolume }) {
-	if (forcedMuted) return null;
-	if (shouldBeMuted({
-		playerMuted,
-		playerInteracted
-	})) return {
-		muted: true,
-		volume: null,
-		storeVolumeUpdate: null
-	};
-	const volumeToSet = getRestoredVolume(playerVolume, playerPreviousVolume);
-	return {
-		muted: false,
-		volume: volumeToSet,
-		storeVolumeUpdate: playerVolume === 0 ? volumeToSet : null
-	};
-}
-/**
-* Observe a container element's viewport size, invoking the callback with the
-* current `{width, height}` whenever it changes (via `ResizeObserver`) or
-* the window resizes.
-*
-* Returns a teardown function.
-*/
-function observeViewport(container, onChange) {
-	if (!container) return () => void 0;
-	const emit = () => {
-		onChange({
-			width: container.clientWidth,
-			height: container.clientHeight
-		});
-	};
-	emit();
-	const resizeObserver = new ResizeObserver(emit);
-	resizeObserver.observe(container);
-	let rafHandle = null;
-	const onWindowResize = () => {
-		if (rafHandle !== null) return;
-		rafHandle = requestAnimationFrame(() => {
-			rafHandle = null;
-			emit();
-		});
-	};
-	window.addEventListener("resize", onWindowResize);
-	return () => {
-		resizeObserver.disconnect();
-		window.removeEventListener("resize", onWindowResize);
-		if (rafHandle !== null) cancelAnimationFrame(rafHandle);
-	};
-}
-
-export { bindFullscreenChangeListener, bindPictureInPictureChangeListener, bindPipVisibilityReentry, deriveVolumeSync, observeViewport, shouldReenterPictureInPicture };

package/dist/lib/feed-autoscroll.d.ts

@@ -1,10 +0,0 @@
-export declare function gateVideoEnded(isCurrent: boolean, autoscroll: boolean): boolean;
-export interface AutoAdvanceInput {
-  isCurrent: boolean;
-  autoscroll: boolean;
-  loop: boolean;
-  currentIndex: number;
-  postsLength: number;
-  total: number;
-}
-export declare function shouldAutoAdvance({ isCurrent, autoscroll, loop, currentIndex, postsLength, total }: AutoAdvanceInput): boolean;

package/dist/lib/feed-autoscroll.js

@@ -1,13 +0,0 @@
-import { isAtEndOfFeed, isFeedExhausted } from "./feed-scroll.js";
-
-// src/lib/feed-autoscroll.ts
-function gateVideoEnded(isCurrent, autoscroll) {
-	return isCurrent && autoscroll;
-}
-function shouldAutoAdvance({ isCurrent, autoscroll, loop, currentIndex, postsLength, total }) {
-	if (!isCurrent || !autoscroll) return false;
-	if (isAtEndOfFeed(currentIndex, postsLength) && !loop && isFeedExhausted(postsLength, total)) return false;
-	return true;
-}
-
-export { gateVideoEnded, shouldAutoAdvance };

package/dist/lib/feed-container-height.d.ts

@@ -1,7 +0,0 @@
-export declare function getViewportFallbackHeight(safeAreaTabBar: number): number;
-export interface ContainerHeightInput {
-  measuredHeight: number;
-  scrollContainerHeight: number;
-  safeAreaTabBar: number;
-}
-export declare function resolveContainerHeight({ measuredHeight, scrollContainerHeight, safeAreaTabBar }: ContainerHeightInput): number;

package/dist/lib/feed-container-height.js

@@ -1,11 +0,0 @@
-// src/lib/feed-container-height.ts
-function getViewportFallbackHeight(safeAreaTabBar) {
-	return Math.max(window.innerHeight - safeAreaTabBar, 1);
-}
-function resolveContainerHeight({ measuredHeight, scrollContainerHeight, safeAreaTabBar }) {
-	if (scrollContainerHeight > 0) return scrollContainerHeight;
-	if (measuredHeight > 0) return measuredHeight;
-	return getViewportFallbackHeight(safeAreaTabBar);
-}
-
-export { getViewportFallbackHeight, resolveContainerHeight };

package/dist/lib/feed-description-overflow.d.ts

@@ -1 +0,0 @@
-export declare function checkIsCut(el: HTMLElement | null): boolean;

package/dist/lib/feed-description-overflow.js

@@ -1,9 +0,0 @@
-// src/lib/feed-description-overflow.ts
-function checkIsCut(el) {
-	if (!el) return false;
-	const isOverflowingHeight = el.scrollHeight - el.clientHeight > 1;
-	const isOverflowingWidth = el.scrollWidth - el.clientWidth > 1;
-	return isOverflowingHeight || isOverflowingWidth;
-}
-
-export { checkIsCut };

package/dist/lib/feed-dwell.d.ts

@@ -1,2 +0,0 @@
-export declare const IMAGE_DWELL_MS = 5e3;
-export declare function shouldDwellAdvance(autoscroll: boolean, isCurrent: boolean, isImage: boolean): boolean;

package/dist/lib/feed-dwell.js

@@ -1,8 +0,0 @@
-// src/lib/feed-dwell.ts
-const IMAGE_DWELL_MS = 5e3;
-function shouldDwellAdvance(autoscroll, isCurrent, isImage) {
-	if (!autoscroll || !isCurrent) return false;
-	return isImage;
-}
-
-export { IMAGE_DWELL_MS, shouldDwellAdvance };

package/dist/lib/feed-loop.d.ts

@@ -1,10 +0,0 @@
-export declare function resolvePostIndex(transform: number, postsLength: number, loop: boolean): number;
-export declare function getLoopRebaseThreshold(postsLength: number): number;
-export interface LoopRebaseInput {
-  currentIndex: number;
-  postsLength: number;
-  loop: boolean;
-  total: number;
-}
-export declare function shouldRebaseLoopIndex({ currentIndex, postsLength, loop, total }: LoopRebaseInput): boolean;
-export declare function getRebasedLoopIndex(currentIndex: number, postsLength: number): number;

package/dist/lib/feed-loop.js

@@ -1,21 +0,0 @@
-import { FEED_COMPONENTS_COUNT } from "../store/feed-interaction-store.js";
-import { isFeedExhausted } from "./feed-scroll.js";
-import { LOOP_REBASE_BASE_MULTIPLIER, LOOP_REBASE_THRESHOLD_MULTIPLIER } from "./feed-transforms.js";
-
-// src/lib/feed-loop.ts
-function resolvePostIndex(transform, postsLength, loop) {
-	if (!loop || postsLength === 0) return transform;
-	return (transform % postsLength + postsLength) % postsLength;
-}
-function getLoopRebaseThreshold(postsLength) {
-	return Math.max(5 * 50, postsLength * 50);
-}
-function shouldRebaseLoopIndex({ currentIndex, postsLength, loop, total }) {
-	return loop && postsLength > 0 && isFeedExhausted(postsLength, total) && currentIndex >= getLoopRebaseThreshold(postsLength);
-}
-function getRebasedLoopIndex(currentIndex, postsLength) {
-	const normalizedOffset = (currentIndex % postsLength + postsLength) % postsLength;
-	return postsLength * 2 + normalizedOffset;
-}
-
-export { getLoopRebaseThreshold, getRebasedLoopIndex, resolvePostIndex, shouldRebaseLoopIndex };

package/dist/lib/feed-scroll.d.ts

@@ -1,11 +0,0 @@
-export declare function computeScrollIndex(scrollTop: number, containerHeight: number, gap?: number): number;
-export declare function isAtEndOfFeed(currentIndex: number, postsLength: number): boolean;
-export declare function isFeedExhausted(postsLength: number, total: number): boolean;
-export interface ShouldFetchMoreInput {
-  currentIndex: number;
-  postsLength: number;
-  total: number;
-  isFetching: boolean;
-  isLoaded: boolean;
-}
-export declare function shouldFetchMore({ currentIndex, postsLength, total, isFetching, isLoaded }: ShouldFetchMoreInput): boolean;

package/dist/lib/feed-scroll.js

@@ -1,19 +0,0 @@
-// src/lib/feed-scroll.ts
-const DEFAULT_GAP = .3;
-function computeScrollIndex(scrollTop, containerHeight, gap = DEFAULT_GAP) {
-	if (containerHeight <= 0 || scrollTop <= 0) return 0;
-	return Math.ceil(scrollTop / containerHeight - gap);
-}
-function isAtEndOfFeed(currentIndex, postsLength) {
-	return currentIndex >= postsLength - 1;
-}
-function isFeedExhausted(postsLength, total) {
-	return total > 0 && postsLength >= total;
-}
-function shouldFetchMore({ currentIndex, postsLength, total, isFetching, isLoaded }) {
-	if (isFetching || !isLoaded) return false;
-	if (isFeedExhausted(postsLength, total)) return false;
-	return currentIndex >= postsLength - 3;
-}
-
-export { computeScrollIndex, isAtEndOfFeed, isFeedExhausted, shouldFetchMore };

package/dist/lib/feed-transforms.d.ts

@@ -1,5 +0,0 @@
-export declare const LOOP_REBASE_BASE_MULTIPLIER = 2;
-export declare const LOOP_REBASE_THRESHOLD_MULTIPLIER = 50;
-export declare function shiftArray(arr: number[], shiftBy: number): number[];
-export declare function calcShiftCountArray(index: number, arraySize: number): number[];
-export declare function buildTransforms(currentIndex: number, originalPositions: number[]): number[];

package/dist/lib/feed-transforms.js

@@ -1,30 +0,0 @@
-import { FEED_COMPONENTS_COUNT, FEED_TRANSITION_THRESHOLD } from "../store/feed-interaction-store.js";
-
-// src/lib/feed-transforms.ts
-const LOOP_REBASE_BASE_MULTIPLIER = 2;
-const LOOP_REBASE_THRESHOLD_MULTIPLIER = 50;
-function shiftArray(arr, shiftBy) {
-	const length = arr.length;
-	shiftBy = shiftBy % length;
-	if (shiftBy < 0) shiftBy = length + shiftBy;
-	return [...arr.slice(shiftBy), ...arr.slice(0, shiftBy)];
-}
-function calcShiftCountArray(index, arraySize) {
-	const count = Math.floor(index / arraySize);
-	const remainder = index % arraySize;
-	const output = [];
-	for (let i = 0; i < arraySize; i++) if (i < arraySize - remainder) output.push(count);
-	else output.push(count + 1);
-	return output;
-}
-function buildTransforms(currentIndex, originalPositions) {
-	if (currentIndex <= 2) return originalPositions;
-	const shiftCount = calcShiftCountArray(currentIndex - 2, 5);
-	const shiftedArray = shiftArray(originalPositions, currentIndex - 2);
-	shiftCount.forEach((shift, index) => {
-		shiftedArray[index] += shift * 5;
-	});
-	return shiftedArray;
-}
-
-export { LOOP_REBASE_BASE_MULTIPLIER, LOOP_REBASE_THRESHOLD_MULTIPLIER, buildTransforms, calcShiftCountArray, shiftArray };

package/dist/lib/filter-undefined.js

@@ -1,11 +0,0 @@
-// src/lib/filter-undefined.ts
-/**
-* Returns a copy of `obj` with all `undefined` values removed.
-* A type assertion is required because `Object.fromEntries` cannot infer
-* `Partial<T>` from filtered entries.
-*/
-function filterUndefined(obj) {
-	return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
-}
-
-export { filterUndefined };

package/dist/lib/fullscreen-utils.d.ts

@@ -1 +0,0 @@
-export declare function isDocumentFullscreen(): boolean;

package/dist/lib/fullscreen-utils.js

@@ -1,7 +0,0 @@
-// src/lib/fullscreen-utils.ts
-function isDocumentFullscreen() {
-	const doc = document;
-	return !!(doc.fullscreenElement || doc.webkitFullscreenElement || doc.mozFullScreenElement || doc.msFullscreenElement);
-}
-
-export { isDocumentFullscreen };

package/dist/lib/hls-buffer-flush.js

@@ -1,46 +0,0 @@
-// src/lib/hls-buffer-flush.ts
-/**
-* Buffer-flush-on-far-seek heuristic for HLS playback.
-*
-* When the user seeks more than `NEARBY_BUFFER_SECONDS` outside the currently
-* buffered ranges, HLS.js often stalls because it tries to reuse stale buffer
-* data. We flush any buffer ranges further than `DISTANT_BUFFER_SECONDS` from
-* the new playhead so HLS can fetch fresh segments.
-*/
-const NEARBY_BUFFER_SECONDS = 5;
-const DISTANT_BUFFER_SECONDS = 30;
-function flushDistantBuffers({ hlsInstance, events, videoElement }, currentTime) {
-	for (let i = 0; i < videoElement.buffered.length; i++) {
-		const start = videoElement.buffered.start(i);
-		const end = videoElement.buffered.end(i);
-		if (start < currentTime - 30 || end > currentTime + 30) hlsInstance.trigger(events.BUFFER_FLUSHING, {
-			startOffset: start,
-			endOffset: end,
-			type: "video"
-		});
-	}
-}
-function hasNearbyBuffer(videoElement, currentTime) {
-	for (let i = 0; i < videoElement.buffered.length; i++) {
-		const start = videoElement.buffered.start(i);
-		const end = videoElement.buffered.end(i);
-		if (currentTime >= start - 5 && currentTime <= end + 5) return true;
-	}
-	return false;
-}
-/**
-* Build a `seeking` event handler that flushes distant buffers and resets
-* `maxBufferLength` when the seek lands far from any buffered range.
-*/
-function createSeekingHandler(opts) {
-	const { hlsInstance, videoElement } = opts;
-	return () => {
-		const currentTime = videoElement.currentTime;
-		if (!hasNearbyBuffer(videoElement, currentTime)) {
-			hlsInstance.config.maxBufferLength = 30;
-			flushDistantBuffers(opts, currentTime);
-		}
-	};
-}
-
-export { createSeekingHandler, hasNearbyBuffer };

package/dist/lib/hls-error-recovery.d.ts

@@ -1,35 +0,0 @@
-export declare const MAX_NETWORK_RETRIES = 3;
-export declare const MAX_MEDIA_RECOVERIES = 1;
-export interface HlsErrorPayload {
-  /** The hls.js error type, e.g. `"networkError"`, `"mediaError"`. */
-  error: string;
-  /** Specific hls.js error details (e.g. `"manifestLoadError"`) or undefined. */
-  code?: string;
-}
-export interface HlsErrorRecoveryState {
-  networkRetries: number;
-  mediaRecoveries: number;
-}
-export declare function createHlsErrorRecoveryState(): HlsErrorRecoveryState;
-export type HlsErrorAction = {
-  kind: "retry-network";
-  attempt: number;
-} | {
-  kind: "recover-media";
-  attempt: number;
-} | {
-  kind: "give-up";
-  payload: HlsErrorPayload;
-};
-export interface HlsErrorInput {
-  type: string;
-  details?: string;
-  fatal: boolean;
-}
-/**
- * Decide what to do given an HLS error and the current recovery counters.
- *
- * Mutates `state` to advance the appropriate counter when retry/recover is
- * selected. Non-fatal errors return `null` (the caller should ignore them).
- */
-export declare function decideHlsErrorAction(error: HlsErrorInput, state: HlsErrorRecoveryState): HlsErrorAction | null;

package/dist/lib/hls-error-recovery.js

@@ -1,75 +0,0 @@
-// src/lib/hls-error-recovery.ts
-/**
-* Pure HLS error-recovery state machine.
-*
-* Policy (per `hls-streaming.md` migration spec):
-*  - Network errors (fatal): retry manifest load via `hls.startLoad()` up to
-*    `MAX_NETWORK_RETRIES` attempts. After that, give up.
-*  - Media errors   (fatal): attempt `hls.recoverMediaError()` up to
-*    `MAX_MEDIA_RECOVERIES` times. After that, give up.
-*  - Anything else  (fatal): give up immediately.
-*  - Non-fatal errors: ignore (return null).
-*
-* The state machine itself is framework-agnostic and side-effect-free.
-* Callers wire it to actual HLS instances in `hls-setup.ts`.
-*/
-const NETWORK_ERROR = "networkError";
-const MEDIA_ERROR = "mediaError";
-const MAX_NETWORK_RETRIES = 3;
-const MAX_MEDIA_RECOVERIES = 1;
-function createHlsErrorRecoveryState() {
-	return {
-		networkRetries: 0,
-		mediaRecoveries: 0
-	};
-}
-/**
-* Decide what to do given an HLS error and the current recovery counters.
-*
-* Mutates `state` to advance the appropriate counter when retry/recover is
-* selected. Non-fatal errors return `null` (the caller should ignore them).
-*/
-function decideHlsErrorAction(error, state) {
-	if (!error.fatal) return null;
-	if (error.type === NETWORK_ERROR) {
-		if (state.networkRetries < 3) {
-			state.networkRetries += 1;
-			return {
-				kind: "retry-network",
-				attempt: state.networkRetries
-			};
-		}
-		return {
-			kind: "give-up",
-			payload: {
-				error: error.type,
-				code: error.details
-			}
-		};
-	}
-	if (error.type === MEDIA_ERROR) {
-		if (state.mediaRecoveries < 1) {
-			state.mediaRecoveries += 1;
-			return {
-				kind: "recover-media",
-				attempt: state.mediaRecoveries
-			};
-		}
-		return {
-			kind: "give-up",
-			payload: {
-				error: error.type,
-				code: error.details
-			}
-		};
-	}
-	return {
-		kind: "give-up",
-		payload: {
-			error: error.type,
-			code: error.details
-		}
-	};
-}
-
-export { MAX_MEDIA_RECOVERIES, MAX_NETWORK_RETRIES, createHlsErrorRecoveryState, decideHlsErrorAction };

package/dist/lib/hls-event-handlers.js

@@ -1,61 +0,0 @@
-import { generateLevelName } from "./hls-utils.js";
-import { persistAudioTrack } from "./track-persistence.js";
-import { playerStateStore } from "../store/player-store.js";
-
-// src/lib/hls-event-handlers.ts
-function setupAudioTracksHandler(playerId) {
-	return (_event, data) => {
-		if (!data.audioTracks || data.audioTracks.length <= 1) return;
-		const audioTracks = data.audioTracks.map((track, index) => ({
-			index,
-			label: track.name || track.lang || `Audio Track ${index + 1}`,
-			language: track.lang || "unknown",
-			kind: "main",
-			track
-		}));
-		playerStateStore.setAvailableAudioTracks(playerId, audioTracks);
-	};
-}
-function handleAudioTrackSwitch(playerId, _event, data) {
-	const player = playerStateStore.get(playerId).get();
-	if (player.audioTrack !== data.id) {
-		playerStateStore.get(playerId).set({
-			...player,
-			audioTrack: data.id
-		});
-		persistAudioTrack(data.id);
-	}
-}
-function updateQualityLevels(hlsInstance, onLevelsChange) {
-	onLevelsChange(hlsInstance.levels.map((level, index) => ({
-		height: level.height,
-		width: level.width,
-		bitrate: level.bitrate,
-		name: generateLevelName(level),
-		index
-	})));
-}
-/**
-* Register all HLS event handlers needed by the SDK on the given instance.
-*
-* Wires media-attached → loadSource, audio-tracks-updated → store, audio-track
-* switched → store + persistence, levels-updated/manifest-parsed → onLevelsChange,
-* level-switched → onLevelSwitch.
-*/
-function setupHlsEventHandlers(opts) {
-	const { hlsInstance, events, playerId, videoUrl, onLevelsChange, onLevelSwitch } = opts;
-	const onAudioTracks = setupAudioTracksHandler(playerId);
-	const onAudioSwitch = (_event, data) => handleAudioTrackSwitch(playerId, _event, data);
-	const onLevels = () => updateQualityLevels(hlsInstance, onLevelsChange);
-	const onSwitch = (_event, data) => onLevelSwitch(data.level);
-	hlsInstance.on(events.MEDIA_ATTACHED, () => {
-		hlsInstance.loadSource(videoUrl);
-	});
-	hlsInstance.on(events.AUDIO_TRACKS_UPDATED, onAudioTracks);
-	hlsInstance.on(events.AUDIO_TRACK_SWITCHED, onAudioSwitch);
-	hlsInstance.on(events.LEVELS_UPDATED, onLevels);
-	hlsInstance.on(events.MANIFEST_PARSED, onLevels);
-	hlsInstance.on(events.LEVEL_SWITCHED, onSwitch);
-}
-
-export { setupHlsEventHandlers };

package/dist/lib/hls-loader.js

@@ -1,23 +0,0 @@
-// src/lib/hls-loader.ts
-/**
-* Loads hls.js on first use.
-*
-* hls.js is ~560 KB minified, larger than the rest of the SDK combined. A
-* static import puts it on every page that imports `@rixl/media`, including
-* ones that only show images or never start a video. Loading it here, when a
-* player first attaches an HLS stream, lets the app's bundler split it into a
-* chunk that only video playback downloads.
-*
-* The promise is shared, so concurrent players trigger one download. A failed
-* load is not cached: the next player retries.
-*/
-let hlsModule = null;
-function loadHls() {
-	hlsModule ??= import("hls.js").then((module) => module.default, (error) => {
-		hlsModule = null;
-		throw error;
-	});
-	return hlsModule;
-}
-
-export { loadHls };

package/dist/lib/hls-setup.d.ts

@@ -1,72 +0,0 @@
-import { QualityLevel } from "./hls-utils.js";
-import { UUID } from "../types/uuid.js";
-import { HlsErrorAction, HlsErrorInput, HlsErrorPayload, HlsErrorRecoveryState, MAX_MEDIA_RECOVERIES, MAX_NETWORK_RETRIES, createHlsErrorRecoveryState, decideHlsErrorAction } from "./hls-error-recovery.js";
-import Hls from "hls.js";
-/**
- * Framework-agnostic HLS setup.
- *
- * Owns:
- *  - HLS.js configuration tuned for the SDK's playback profile.
- *  - Media-attached / manifest-parsed / level-switched / audio-track-switched
- *    event handlers.
- *  - Buffer-flush-on-far-seek heuristic (see `createSeekingHandler`).
- *  - Error recovery policy (see Error recovery section below).
- *  - Safari native HLS fallback.
- *
- * hls.js itself is loaded on first use (see `loadHls`), so `setupHls` is
- * async and pages that never attach an HLS stream never download it.
- *
- * Resolves to a `HlsController` whose lifetime the caller manages via `destroy()`.
- * Caller responsibilities:
- *  - Provide the `<video>` element and a `playerId`.
- *  - Subscribe to quality/level/audio changes via the controller's getters or
- *    by reading `playerStateStore`.
- *  - Surface errors to UI via the `onError` callback.
- */
-export type HlsInstance = Hls;
-export interface HlsController {
-  hls: Hls | null;
-  levels: QualityLevel[];
-  currentLevel: number;
-  isAuto: boolean;
-  destroy: () => void;
-  setQuality: (index: number) => void;
-}
-export interface SetupHlsOptions {
-  videoElement: HTMLVideoElement;
-  videoUrl: string;
-  playerId: UUID;
-  isPreloading?: boolean;
-  /**
-   * Invoked when an HLS error is given up on (after retries are exhausted, or
-   * for non-recoverable error types). Callers typically dispatch a custom event
-   * and/or show an error overlay.
-   */
-  onError?: (payload: HlsErrorPayload) => void;
-  /**
-   * Invoked whenever HLS reports updated quality levels (after manifest parse
-   * or level update). Useful for framework wrappers that mirror controller
-   * state into reactive store/state (e.g. React `useState`).
-   */
-  onLevelsChange?: (levels: QualityLevel[]) => void;
-  /**
-   * Invoked whenever HLS switches to a different quality level.
-   */
-  onLevelSwitch?: (level: number) => void;
-}
-export declare function createHlsConfig(isPreloading?: boolean): Partial<Hls["config"]>;
-/**
- * Set up HLS streaming on a video element, resolving to a controller for
- * quality/audio switching and teardown.
- *
- * - For non-HLS URLs: sets `videoElement.src` directly and resolves to `null`
- *   without loading hls.js.
- * - For HLS URLs on Safari (no `Hls.isSupported()` but native canPlayType):
- *   sets `videoElement.src` and returns `null` (UI features that depend on
- *   the HLS controller — quality switching, audio tracks — won't be available
- *   in native mode).
- * - Otherwise: instantiates HLS.js, attaches the media, wires events
- *   (including error recovery), and returns the controller.
- */
-export declare function setupHls(opts: SetupHlsOptions): Promise<HlsController | null>;
-export { type HlsErrorAction, type HlsErrorInput, type HlsErrorPayload, type HlsErrorRecoveryState, MAX_MEDIA_RECOVERIES, MAX_NETWORK_RETRIES, createHlsErrorRecoveryState, decideHlsErrorAction };