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

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

@@ -1 +1 @@
-{"version":3,"file":"task.js","names":["#runFn","#abortController","#signal","#status","#value","#error","#pending","#destroyed","#settled","#resolveSettled","#chain","#current"],"sources":["../../../../src/core/tasks/task.ts"],"sourcesContent":["import { anyAbortSignal } from '@videojs/utils/events';\nimport { generateId } from '@videojs/utils/string';\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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"}
+{"version":3,"file":"task.js","names":["#runFn","#abortController","#signal","#status","#value","#error","#pending","#destroyed","#settled","#resolveSettled","#chain","#current"],"sources":["../../../../src/core/tasks/task.ts"],"sourcesContent":["import { anyAbortSignal } from '@videojs/utils/events';\nimport { generateId } from '@videojs/utils/string';\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/hls.d.ts

@@ -1,3 +1,7 @@
+import { DeriveStartMediaTime } from "./playback/primitives/derive-start-media-time.js";
+import { derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime } from "./playback/behaviors/establish-start-media-time.js";
 import { SimpleHlsEngineConfig, SimpleHlsEngineContext, SimpleHlsEngineSignals, SimpleHlsEngineState, createSimpleHlsEngine } from "./playback/engines/hls/engine.js";
 import { SimpleHlsMediaAPI, SimpleHlsMediaElement, SimpleHlsMediaMixin, SimpleHlsMediaProps, simpleHlsMediaDefaultProps } from "./playback/engines/hls/adapter.js";
-export { type SimpleHlsEngineConfig, type SimpleHlsEngineContext, type SimpleHlsEngineSignals, type SimpleHlsEngineState, type SimpleHlsMediaAPI, SimpleHlsMediaElement, SimpleHlsMediaMixin, type SimpleHlsMediaProps, createSimpleHlsEngine, simpleHlsMediaDefaultProps };
+import { SimpleHlsAudioOnlyEngineConfig, SimpleHlsAudioOnlyEngineContext, SimpleHlsAudioOnlyEngineSignals, SimpleHlsAudioOnlyEngineState, createHlsAudioOnlyEngine } from "./playback/engines/hls/engine-audio-only.js";
+import { SimpleHlsAudioOnlyMediaAPI, SimpleHlsAudioOnlyMediaElement, SimpleHlsAudioOnlyMediaMixin, SimpleHlsAudioOnlyMediaProps, simpleHlsAudioOnlyMediaDefaultProps } from "./playback/engines/hls/adapter-audio-only.js";
+export { type DeriveStartMediaTime, type SimpleHlsAudioOnlyEngineConfig, type SimpleHlsAudioOnlyEngineContext, type SimpleHlsAudioOnlyEngineSignals, type SimpleHlsAudioOnlyEngineState, type SimpleHlsAudioOnlyMediaAPI, SimpleHlsAudioOnlyMediaElement, SimpleHlsAudioOnlyMediaMixin, type SimpleHlsAudioOnlyMediaProps, type SimpleHlsEngineConfig, type SimpleHlsEngineContext, type SimpleHlsEngineSignals, type SimpleHlsEngineState, type SimpleHlsMediaAPI, SimpleHlsMediaElement, SimpleHlsMediaMixin, type SimpleHlsMediaProps, createHlsAudioOnlyEngine, createSimpleHlsEngine, derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime, simpleHlsAudioOnlyMediaDefaultProps, simpleHlsMediaDefaultProps };

package/dist/dev/hls.js

@@ -1,3 +1,6 @@
+import { derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime } from "./playback/behaviors/establish-start-media-time.js";
 import { createSimpleHlsEngine } from "./playback/engines/hls/engine.js";
 import { SimpleHlsMediaElement, SimpleHlsMediaMixin, simpleHlsMediaDefaultProps } from "./playback/engines/hls/adapter.js";
-export { SimpleHlsMediaElement, SimpleHlsMediaMixin, createSimpleHlsEngine, simpleHlsMediaDefaultProps };
+import { createHlsAudioOnlyEngine } from "./playback/engines/hls/engine-audio-only.js";
+import { SimpleHlsAudioOnlyMediaElement, SimpleHlsAudioOnlyMediaMixin, simpleHlsAudioOnlyMediaDefaultProps } from "./playback/engines/hls/adapter-audio-only.js";
+export { SimpleHlsAudioOnlyMediaElement, SimpleHlsAudioOnlyMediaMixin, SimpleHlsMediaElement, SimpleHlsMediaMixin, createHlsAudioOnlyEngine, createSimpleHlsEngine, derivePerTypeStartMediaTime, deriveSharedMinStartMediaTime, simpleHlsAudioOnlyMediaDefaultProps, simpleHlsMediaDefaultProps };

package/dist/dev/index.d.ts

@@ -8,7 +8,6 @@ import { ActorDefinition, ActorStateDefinition, HandlerContext, MessageActor, Ru
 import { TransitionActor, createTransitionActor } from "./core/actors/create-transition-actor.js";
 import { Machine, MachineSnapshot } from "./core/machine.js";
 import { Reactor, ReactorDefinition, ReactorDeriveFn, ReactorEffectFn, ReactorStateDefinition, createMachineReactor } from "./core/reactors/create-machine-reactor.js";
-
 //#region src/index.d.ts
 /**
  * Stream Processing Framework (SPF) for Video.js 10

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;cAUa,OAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAUa"}

package/dist/dev/media/abr/quality-selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quality-selection.d.ts","names":[],"sources":["../../../../src/media/abr/quality-selection.ts"],"mappings":";;;;UAiBiB,aAAA;;;;;;EAMf,YAAA;;;;;;;EAOA,aAAA;AAAA"}
+{"version":3,"file":"quality-selection.d.ts","names":[],"sources":["../../../../src/media/abr/quality-selection.ts"],"mappings":";;;;UAiBiB;;;;;;EAMf;;;;;;;EAOA"}

package/dist/dev/media/abr/quality-selection.js

@@ -8,76 +8,14 @@ const DEFAULT_QUALITY_CONFIG = {
 	upgradeMargin: 1.15
 };
 /**
-* Select the track to apply now, given current bandwidth, a current
-* selection (optional), and tuning. Returns:
-*
-* - The bandwidth-fitting optimal when no `currentTrack` is supplied.
-* - The optimal when it's a downgrade vs. `currentTrack` (downgrades
-*   apply immediately — no hysteresis).
-* - The optimal when it clears `currentTrack.bandwidth * upgradeMargin`
-*   (upgrade clears hysteresis).
-* - `currentTrack` itself when an upgrade doesn't clear the margin
-*   (stay put — caller checks identity to no-op).
-*
-* "Optimal" is the highest-bandwidth track where the available bandwidth
-* meets the safety requirement (`currentBandwidth >= track.bandwidth / safetyMargin`).
-* Falls back to the lowest-bandwidth track when nothing fits the safety
-* margin (preserves a definitive pick under under-bandwidth conditions).
-*
-* @example
-* const tracks = [low, mid, high];
-* selectQuality(tracks, 5_000_000, { currentTrack: low });
-* // Returns `high` if 5 Mbps clears safety AND high.bandwidth >= low.bandwidth * upgradeMargin.
-* // Returns `low` (no-op signal) otherwise.
+* Resolution as a total pixel count (`width × height`), the basis for
+* comparing two tracks at the same bitrate. Missing dimensions count as 0, so
+* tracks without resolution metadata (e.g. audio) area-compare equal.
 */
-function selectQuality(tracks, currentBandwidth, opts = {}) {
-	if (tracks.length === 0) return;
-	const safetyMargin = opts.safetyMargin ?? DEFAULT_QUALITY_CONFIG.safetyMargin;
-	const upgradeMargin = opts.upgradeMargin ?? DEFAULT_QUALITY_CONFIG.upgradeMargin;
-	const { currentTrack } = opts;
-	const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);
-	let chosen;
-	for (const track of sortedTracks) if (currentBandwidth >= track.bandwidth / safetyMargin) {
-		if (!chosen || track.bandwidth > chosen.bandwidth || track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen)) chosen = track;
-	}
-	const optimal = chosen ?? sortedTracks[0];
-	if (!optimal) return void 0;
-	if (!currentTrack) return optimal;
-	if (optimal.bandwidth < currentTrack.bandwidth) return optimal;
-	if (optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin) return optimal;
-	return currentTrack;
-}
-/**
-* Select the lowest-bandwidth track from the candidate set.
-*
-* Used as a safety-net fallback by callers that need a definitive pick when
-* a primary selection algorithm declines to choose. Pairs naturally with
-* `selectQuality` — when ABR has no good answer (e.g., all candidates
-* exceed available bandwidth and the algorithm doesn't fall back
-* internally), the lowest bitrate is the safest default.
-*
-* @param tracks - Candidate tracks (can be unsorted)
-* @returns The lowest-bandwidth track, or `undefined` if `tracks` is empty
-*
-* @example
-* const fallback = selectLowestQuality(tracks);
-*/
-function selectLowestQuality(tracks) {
-	if (tracks.length === 0) return void 0;
-	return tracks.reduce((min, t) => t.bandwidth < min.bandwidth ? t : min);
-}
-/**
-* Check if track A has higher resolution than track B.
-* Compares by total pixel count (width × height).
-*
-* @param trackA - First track to compare
-* @param trackB - Second track to compare
-* @returns True if trackA has more pixels than trackB
-*/
-function hasHigherResolution(trackA, trackB) {
-	return (trackA.width ?? 0) * (trackA.height ?? 0) > (trackB.width ?? 0) * (trackB.height ?? 0);
+function resolutionArea(track) {
+	return (track.width ?? 0) * (track.height ?? 0);
 }
 //#endregion
-export { DEFAULT_QUALITY_CONFIG, selectLowestQuality, selectQuality };
+export { DEFAULT_QUALITY_CONFIG, resolutionArea };
 
 //# sourceMappingURL=quality-selection.js.map

package/dist/dev/media/abr/quality-selection.js.map

@@ -1 +1 @@
-{"version":3,"file":"quality-selection.js","names":[],"sources":["../../../../src/media/abr/quality-selection.ts"],"sourcesContent":["/**\n * Quality Selection Algorithm\n *\n * Selects optimal video track based on bandwidth estimate with safety margin.\n * Stateless selection - picks highest quality that fits bandwidth.\n *\n * Key concepts:\n * - **Safety margin** (0.85): Pick track where bandwidth >= track.bandwidth / 0.85\n * - This ensures 15% headroom to avoid buffering\n * - At same bandwidth, prefer higher resolution\n */\n\nimport type { PartiallyResolvedVideoTrack, VideoTrack } from '../types';\n\n/**\n * Quality selection configuration.\n */\nexport interface QualityConfig {\n  /**\n   * Safety margin (0-1).\n   * To select a track, need: currentBandwidth >= track.bandwidth / safetyMargin.\n   * Default 0.85 means track must use ≤85% of available bandwidth (15% headroom).\n   */\n  safetyMargin: number;\n  /**\n   * Upgrade hysteresis ratio (>= 1). When `currentTrack` is supplied, an\n   * upgrade is applied only if `optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin`.\n   * Downgrades are always applied. Default 1.15 means optimal must clear\n   * the current bandwidth by at least 15% to trigger an upgrade.\n   */\n  upgradeMargin: number;\n}\n\n/**\n * Default quality selection configuration.\n * Values match Shaka Player upgrade threshold (0.85 = 15% headroom).\n */\nexport const DEFAULT_QUALITY_CONFIG: QualityConfig = {\n  safetyMargin: 0.85,\n  upgradeMargin: 1.15,\n};\n\n/**\n * Options for `selectQuality`. Spread of `Partial<QualityConfig>` plus a\n * runtime-supplied `currentTrack` for upgrade-vs-downgrade decisions.\n */\nexport interface SelectQualityOpts extends Partial<QualityConfig> {\n  /**\n   * Track currently selected. When supplied, `selectQuality` returns\n   * `currentTrack` (no change) for upgrades that don't clear the\n   * `upgradeMargin`. When omitted, no hysteresis is applied — the\n   * computed optimal is returned regardless.\n   */\n  currentTrack?: PartiallyResolvedVideoTrack | VideoTrack;\n}\n\n/**\n * Select the track to apply now, given current bandwidth, a current\n * selection (optional), and tuning. Returns:\n *\n * - The bandwidth-fitting optimal when no `currentTrack` is supplied.\n * - The optimal when it's a downgrade vs. `currentTrack` (downgrades\n *   apply immediately — no hysteresis).\n * - The optimal when it clears `currentTrack.bandwidth * upgradeMargin`\n *   (upgrade clears hysteresis).\n * - `currentTrack` itself when an upgrade doesn't clear the margin\n *   (stay put — caller checks identity to no-op).\n *\n * \"Optimal\" is the highest-bandwidth track where the available bandwidth\n * meets the safety requirement (`currentBandwidth >= track.bandwidth / safetyMargin`).\n * Falls back to the lowest-bandwidth track when nothing fits the safety\n * margin (preserves a definitive pick under under-bandwidth conditions).\n *\n * @example\n * const tracks = [low, mid, high];\n * selectQuality(tracks, 5_000_000, { currentTrack: low });\n * // Returns `high` if 5 Mbps clears safety AND high.bandwidth >= low.bandwidth * upgradeMargin.\n * // Returns `low` (no-op signal) otherwise.\n */\nexport function selectQuality(\n  tracks: readonly (PartiallyResolvedVideoTrack | VideoTrack)[],\n  currentBandwidth: number,\n  opts: SelectQualityOpts = {}\n): PartiallyResolvedVideoTrack | VideoTrack | undefined {\n  if (tracks.length === 0) {\n    return undefined;\n  }\n\n  const safetyMargin = opts.safetyMargin ?? DEFAULT_QUALITY_CONFIG.safetyMargin;\n  const upgradeMargin = opts.upgradeMargin ?? DEFAULT_QUALITY_CONFIG.upgradeMargin;\n  const { currentTrack } = opts;\n\n  // Sort tracks by bandwidth (lowest first)\n  const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);\n\n  // Start with no selection\n  let chosen: PartiallyResolvedVideoTrack | VideoTrack | undefined;\n\n  for (const track of sortedTracks) {\n    // Check if we have enough bandwidth for this track with safety margin\n    // Required bandwidth = track.bandwidth / safetyMargin\n    const requiredBandwidth = track.bandwidth / safetyMargin;\n\n    if (currentBandwidth >= requiredBandwidth) {\n      // We can support this track - prefer it if better than current choice\n      if (\n        !chosen ||\n        track.bandwidth > chosen.bandwidth ||\n        (track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen))\n      ) {\n        chosen = track;\n      }\n    }\n  }\n\n  // If no track fits with safety margin, fall back to lowest quality\n  const optimal = chosen ?? sortedTracks[0];\n  if (!optimal) return undefined;\n\n  // Apply upgrade hysteresis. No currentTrack → no hysteresis, return\n  // optimal. Downgrade (optimal.bandwidth < current) → always apply.\n  // Upgrade → only when `optimal.bandwidth >= current * upgradeMargin`,\n  // else stay put (return currentTrack so caller's id-compare no-ops).\n  if (!currentTrack) return optimal;\n  if (optimal.bandwidth < currentTrack.bandwidth) return optimal;\n  if (optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin) return optimal;\n  return currentTrack;\n}\n\n/**\n * Select the lowest-bandwidth track from the candidate set.\n *\n * Used as a safety-net fallback by callers that need a definitive pick when\n * a primary selection algorithm declines to choose. Pairs naturally with\n * `selectQuality` — when ABR has no good answer (e.g., all candidates\n * exceed available bandwidth and the algorithm doesn't fall back\n * internally), the lowest bitrate is the safest default.\n *\n * @param tracks - Candidate tracks (can be unsorted)\n * @returns The lowest-bandwidth track, or `undefined` if `tracks` is empty\n *\n * @example\n * const fallback = selectLowestQuality(tracks);\n */\nexport function selectLowestQuality<T extends { bandwidth: number }>(tracks: readonly T[]): T | undefined {\n  if (tracks.length === 0) return undefined;\n  return tracks.reduce((min, t) => (t.bandwidth < min.bandwidth ? t : min));\n}\n\n/**\n * Check if track A has higher resolution than track B.\n * Compares by total pixel count (width × height).\n *\n * @param trackA - First track to compare\n * @param trackB - Second track to compare\n * @returns True if trackA has more pixels than trackB\n */\nfunction hasHigherResolution(\n  trackA: PartiallyResolvedVideoTrack | VideoTrack,\n  trackB: PartiallyResolvedVideoTrack | VideoTrack\n): boolean {\n  const pixelsA = (trackA.width ?? 0) * (trackA.height ?? 0);\n  const pixelsB = (trackB.width ?? 0) * (trackB.height ?? 0);\n  return pixelsA > pixelsB;\n}\n"],"mappings":";;;;;AAqCA,MAAa,yBAAwC;CACnD,cAAc;CACd,eAAe;CAChB;;;;;;;;;;;;;;;;;;;;;;;;AAuCD,SAAgB,cACd,QACA,kBACA,OAA0B,EAAE,EAC0B;AACtD,KAAI,OAAO,WAAW,EACpB;CAGF,MAAM,eAAe,KAAK,gBAAgB,uBAAuB;CACjE,MAAM,gBAAgB,KAAK,iBAAiB,uBAAuB;CACnE,MAAM,EAAE,iBAAiB;CAGzB,MAAM,eAAe,OAAO,OAAO,CAAC,MAAM,GAAG,MAAM,EAAE,YAAY,EAAE,UAAU;CAG7E,IAAI;AAEJ,MAAK,MAAM,SAAS,aAKlB,KAAI,oBAFsB,MAAM,YAAY;MAKxC,CAAC,UACD,MAAM,YAAY,OAAO,aACxB,MAAM,cAAc,OAAO,aAAa,oBAAoB,OAAO,OAAO,CAE3E,UAAS;;CAMf,MAAM,UAAU,UAAU,aAAa;AACvC,KAAI,CAAC,QAAS,QAAO,KAAA;AAMrB,KAAI,CAAC,aAAc,QAAO;AAC1B,KAAI,QAAQ,YAAY,aAAa,UAAW,QAAO;AACvD,KAAI,QAAQ,aAAa,aAAa,YAAY,cAAe,QAAO;AACxE,QAAO;;;;;;;;;;;;;;;;;AAkBT,SAAgB,oBAAqD,QAAqC;AACxG,KAAI,OAAO,WAAW,EAAG,QAAO,KAAA;AAChC,QAAO,OAAO,QAAQ,KAAK,MAAO,EAAE,YAAY,IAAI,YAAY,IAAI,IAAK;;;;;;;;;;AAW3E,SAAS,oBACP,QACA,QACS;AAGT,SAFiB,OAAO,SAAS,MAAM,OAAO,UAAU,MACvC,OAAO,SAAS,MAAM,OAAO,UAAU"}
+{"version":3,"file":"quality-selection.js","names":[],"sources":["../../../../src/media/abr/quality-selection.ts"],"sourcesContent":["/**\n * Quality Selection Algorithm\n *\n * Selects optimal video track based on bandwidth estimate with safety margin.\n * Stateless selection - picks highest quality that fits bandwidth.\n *\n * Key concepts:\n * - **Safety margin** (0.85): Pick track where bandwidth >= track.bandwidth / 0.85\n * - This ensures 15% headroom to avoid buffering\n * - At same bandwidth, prefer higher resolution\n */\n\nimport type { PartiallyResolvedVideoTrack, VideoTrack } from '../types';\n\n/**\n * Quality selection configuration.\n */\nexport interface QualityConfig {\n  /**\n   * Safety margin (0-1).\n   * To select a track, need: currentBandwidth >= track.bandwidth / safetyMargin.\n   * Default 0.85 means track must use ≤85% of available bandwidth (15% headroom).\n   */\n  safetyMargin: number;\n  /**\n   * Upgrade hysteresis ratio (>= 1). When `currentTrack` is supplied, an\n   * upgrade is applied only if `optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin`.\n   * Downgrades are always applied. Default 1.15 means optimal must clear\n   * the current bandwidth by at least 15% to trigger an upgrade.\n   */\n  upgradeMargin: number;\n}\n\n/**\n * Default quality selection configuration.\n * Values match Shaka Player upgrade threshold (0.85 = 15% headroom).\n */\nexport const DEFAULT_QUALITY_CONFIG: QualityConfig = {\n  safetyMargin: 0.85,\n  upgradeMargin: 1.15,\n};\n\n/**\n * Selection context for `selectQuality`. The `bandwidth` field carries the\n * current network estimate; `safetyMargin` / `upgradeMargin` override the\n * defaults; `currentTrack` enables upgrade-vs-downgrade hysteresis.\n *\n * Shape matches the unified `selectOptimal` contract of\n * `setupTrackSwitching` (`playback/behaviors/track-switching.ts`) so the\n * function can be passed directly as a variant's `selectOptimal`.\n */\nexport interface SelectQualityCtx<T extends { bandwidth: number } = PartiallyResolvedVideoTrack | VideoTrack>\n  extends Partial<QualityConfig> {\n  bandwidth: number;\n  /**\n   * Track currently selected. When supplied, `selectQuality` returns\n   * `currentTrack` (no change) for upgrades that don't clear the\n   * `upgradeMargin`. When omitted, no hysteresis is applied — the\n   * computed optimal is returned regardless.\n   */\n  currentTrack?: T;\n}\n\n/**\n * Select the track to apply now, given a context that carries current\n * bandwidth, an optional `currentTrack`, and tuning overrides. Returns:\n *\n * - The bandwidth-fitting optimal when no `currentTrack` is supplied.\n * - The optimal when it's a downgrade vs. `currentTrack` (downgrades\n *   apply immediately — no hysteresis).\n * - The optimal when it clears `currentTrack.bandwidth * upgradeMargin`\n *   (upgrade clears hysteresis).\n * - `currentTrack` itself when an upgrade doesn't clear the margin\n *   (stay put — caller checks identity to no-op).\n *\n * \"Optimal\" is the highest-bandwidth track where the available bandwidth\n * meets the safety requirement (`bandwidth >= track.bandwidth / safetyMargin`).\n * Falls back to the lowest-bandwidth track when nothing fits the safety\n * margin (preserves a definitive pick under under-bandwidth conditions).\n *\n * @example\n * const tracks = [low, mid, high];\n * selectQuality(tracks, { bandwidth: 5_000_000, currentTrack: low });\n * // Returns `high` if 5 Mbps clears safety AND high.bandwidth >= low.bandwidth * upgradeMargin.\n * // Returns `low` (no-op signal) otherwise.\n */\nexport function selectQuality(\n  tracks: readonly (PartiallyResolvedVideoTrack | VideoTrack)[],\n  ctx: SelectQualityCtx\n): PartiallyResolvedVideoTrack | VideoTrack | undefined {\n  if (tracks.length === 0) {\n    return undefined;\n  }\n\n  const safetyMargin = ctx.safetyMargin ?? DEFAULT_QUALITY_CONFIG.safetyMargin;\n  const upgradeMargin = ctx.upgradeMargin ?? DEFAULT_QUALITY_CONFIG.upgradeMargin;\n  const { bandwidth: currentBandwidth, currentTrack } = ctx;\n\n  // Sort tracks by bandwidth (lowest first)\n  const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);\n\n  // Start with no selection\n  let chosen: PartiallyResolvedVideoTrack | VideoTrack | undefined;\n\n  for (const track of sortedTracks) {\n    // Check if we have enough bandwidth for this track with safety margin\n    // Required bandwidth = track.bandwidth / safetyMargin\n    const requiredBandwidth = track.bandwidth / safetyMargin;\n\n    if (currentBandwidth >= requiredBandwidth) {\n      // We can support this track - prefer it if better than current choice\n      if (\n        !chosen ||\n        track.bandwidth > chosen.bandwidth ||\n        (track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen))\n      ) {\n        chosen = track;\n      }\n    }\n  }\n\n  // If no track fits with safety margin, fall back to lowest quality\n  const optimal = chosen ?? sortedTracks[0];\n  if (!optimal) return undefined;\n\n  // Apply upgrade hysteresis. No currentTrack → no hysteresis, return\n  // optimal. Downgrade (optimal.bandwidth < current) → always apply.\n  // Upgrade → only when `optimal.bandwidth >= current * upgradeMargin`,\n  // else stay put (return currentTrack so caller's id-compare no-ops).\n  if (!currentTrack) return optimal;\n  if (optimal.bandwidth < currentTrack.bandwidth) return optimal;\n  if (optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin) return optimal;\n  return currentTrack;\n}\n\n/**\n * Select the lowest-bandwidth track from the candidate set.\n *\n * Used as a safety-net fallback by callers that need a definitive pick when\n * a primary selection algorithm declines to choose. Pairs naturally with\n * `selectQuality` — when ABR has no good answer (e.g., all candidates\n * exceed available bandwidth and the algorithm doesn't fall back\n * internally), the lowest bitrate is the safest default.\n *\n * @param tracks - Candidate tracks (can be unsorted)\n * @returns The lowest-bandwidth track, or `undefined` if `tracks` is empty\n *\n * @example\n * const fallback = selectLowestQuality(tracks);\n */\nexport function selectLowestQuality<T extends { bandwidth: number }>(tracks: readonly T[]): T | undefined {\n  if (tracks.length === 0) return undefined;\n  return tracks.reduce((min, t) => (t.bandwidth < min.bandwidth ? t : min));\n}\n\n/**\n * Resolution as a total pixel count (`width × height`), the basis for\n * comparing two tracks at the same bitrate. Missing dimensions count as 0, so\n * tracks without resolution metadata (e.g. audio) area-compare equal.\n */\nexport function resolutionArea(track: { width?: number; height?: number }): number {\n  return (track.width ?? 0) * (track.height ?? 0);\n}\n\n/**\n * Check if track A has higher resolution than track B.\n * Compares by total pixel count (width × height).\n *\n * @param trackA - First track to compare\n * @param trackB - Second track to compare\n * @returns True if trackA has more pixels than trackB\n */\nfunction hasHigherResolution(\n  trackA: PartiallyResolvedVideoTrack | VideoTrack,\n  trackB: PartiallyResolvedVideoTrack | VideoTrack\n): boolean {\n  return resolutionArea(trackA) > resolutionArea(trackB);\n}\n"],"mappings":";;;;;AAqCA,MAAa,yBAAwC;CACnD,cAAc;CACd,eAAe;AACjB;;;;;;AAwHA,SAAgB,eAAe,OAAoD;CACjF,QAAQ,MAAM,SAAS,MAAM,MAAM,UAAU;AAC/C"}

package/dist/dev/media/buffer/back-buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"back-buffer.d.ts","names":[],"sources":["../../../../src/media/buffer/back-buffer.ts"],"mappings":";;;;UAYiB,gBAAA;;;;;EAKf,YAAA;AAAA"}
+{"version":3,"file":"back-buffer.d.ts","names":[],"sources":["../../../../src/media/buffer/back-buffer.ts"],"mappings":";;;;UAYiB;;;;;EAKf"}

package/dist/dev/media/buffer/back-buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"back-buffer.js","names":[],"sources":["../../../../src/media/buffer/back-buffer.ts"],"sourcesContent":["/**\n * Back Buffer Strategy (Simple)\n *\n * Calculates flush points for back buffer management.\n * V1 uses simple \"keep N segments\" strategy.\n */\n\nimport type { Segment } from '../types';\n\n/**\n * Back buffer configuration.\n */\nexport interface BackBufferConfig {\n  /**\n   * Number of segments to keep behind current playback position.\n   * Default: 2 segments.\n   */\n  keepSegments: number;\n}\n\n/**\n * Default back buffer configuration.\n */\nexport const DEFAULT_BACK_BUFFER_CONFIG: BackBufferConfig = {\n  keepSegments: 2,\n};\n\n/**\n * Calculate back buffer flush point.\n *\n * Determines where to flush old segments from the back buffer.\n * Keeps a fixed number of segments behind the current playback position.\n *\n * Algorithm:\n * 1. Find segments before currentTime\n * 2. Count back N segments (keepSegments)\n * 3. Return startTime of segment N+1 back (flush everything before this)\n *\n * @param segments - Available segments (should be sorted by startTime)\n * @param currentTime - Current playback position in seconds\n * @param config - Optional back buffer configuration\n * @returns Time in seconds to flush up to (flush range: [0, flushEnd))\n *\n * @example\n * const segments = [\n *   { startTime: 0, duration: 6, ... },\n *   { startTime: 6, duration: 6, ... },\n *   { startTime: 12, duration: 6, ... },\n *   { startTime: 18, duration: 6, ... },\n * ];\n *\n * // Playing at 18s, keep 2 segments\n * const flushEnd = calculateBackBufferFlushPoint(segments, 18);\n * // Returns 6 (flush [0, 6), keep [6-18))\n */\nexport function calculateBackBufferFlushPoint(\n  segments: Segment[],\n  currentTime: number,\n  config: BackBufferConfig = DEFAULT_BACK_BUFFER_CONFIG\n): number {\n  if (segments.length === 0) {\n    return 0;\n  }\n\n  // Find all segments before current time (not including current segment)\n  const segmentsBefore = segments.filter((seg) => seg.startTime < currentTime);\n\n  // If no segments before current time, nothing to flush\n  if (segmentsBefore.length === 0) {\n    return 0;\n  }\n\n  // Calculate how many segments to flush\n  // Keep last N segments, flush the rest\n  const segmentsToFlush = segmentsBefore.length - config.keepSegments;\n\n  // If we don't have enough segments to flush, keep everything\n  if (segmentsToFlush <= 0) {\n    return 0;\n  }\n\n  // If we want to flush all segments, return currentTime\n  // (flush everything before current playback position)\n  if (segmentsToFlush >= segmentsBefore.length) {\n    return currentTime;\n  }\n\n  // Return the startTime of the first segment we want to keep\n  // Everything before this will be flushed\n  return segmentsBefore[segmentsToFlush]!.startTime;\n}\n"],"mappings":";;;;AAuBA,MAAa,6BAA+C,EAC1D,cAAc,GACf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BD,SAAgB,8BACd,UACA,aACA,SAA2B,4BACnB;AACR,KAAI,SAAS,WAAW,EACtB,QAAO;CAIT,MAAM,iBAAiB,SAAS,QAAQ,QAAQ,IAAI,YAAY,YAAY;AAG5E,KAAI,eAAe,WAAW,EAC5B,QAAO;CAKT,MAAM,kBAAkB,eAAe,SAAS,OAAO;AAGvD,KAAI,mBAAmB,EACrB,QAAO;AAKT,KAAI,mBAAmB,eAAe,OACpC,QAAO;AAKT,QAAO,eAAe,iBAAkB"}
+{"version":3,"file":"back-buffer.js","names":[],"sources":["../../../../src/media/buffer/back-buffer.ts"],"sourcesContent":["/**\n * Back Buffer Strategy (Simple)\n *\n * Calculates flush points for back buffer management.\n * V1 uses simple \"keep N segments\" strategy.\n */\n\nimport type { Segment } from '../types';\n\n/**\n * Back buffer configuration.\n */\nexport interface BackBufferConfig {\n  /**\n   * Number of segments to keep behind current playback position.\n   * Default: 2 segments.\n   */\n  keepSegments: number;\n}\n\n/**\n * Default back buffer configuration.\n */\nexport const DEFAULT_BACK_BUFFER_CONFIG: BackBufferConfig = {\n  keepSegments: 2,\n};\n\n/**\n * Calculate back buffer flush point.\n *\n * Determines where to flush old segments from the back buffer.\n * Keeps a fixed number of segments behind the current playback position.\n *\n * Algorithm:\n * 1. Find segments before currentTime\n * 2. Count back N segments (keepSegments)\n * 3. Return startTime of segment N+1 back (flush everything before this)\n *\n * @param segments - Available segments (should be sorted by startTime)\n * @param currentTime - Current playback position in seconds\n * @param config - Optional back buffer configuration\n * @returns Time in seconds to flush up to (flush range: [0, flushEnd))\n *\n * @example\n * const segments = [\n *   { startTime: 0, duration: 6, ... },\n *   { startTime: 6, duration: 6, ... },\n *   { startTime: 12, duration: 6, ... },\n *   { startTime: 18, duration: 6, ... },\n * ];\n *\n * // Playing at 18s, keep 2 segments\n * const flushEnd = calculateBackBufferFlushPoint(segments, 18);\n * // Returns 6 (flush [0, 6), keep [6-18))\n */\nexport function calculateBackBufferFlushPoint(\n  segments: Segment[],\n  currentTime: number,\n  config: BackBufferConfig = DEFAULT_BACK_BUFFER_CONFIG\n): number {\n  if (segments.length === 0) {\n    return 0;\n  }\n\n  // Find all segments before current time (not including current segment)\n  const segmentsBefore = segments.filter((seg) => seg.startTime < currentTime);\n\n  // If no segments before current time, nothing to flush\n  if (segmentsBefore.length === 0) {\n    return 0;\n  }\n\n  // Calculate how many segments to flush\n  // Keep last N segments, flush the rest\n  const segmentsToFlush = segmentsBefore.length - config.keepSegments;\n\n  // If we don't have enough segments to flush, keep everything\n  if (segmentsToFlush <= 0) {\n    return 0;\n  }\n\n  // If we want to flush all segments, return currentTime\n  // (flush everything before current playback position)\n  if (segmentsToFlush >= segmentsBefore.length) {\n    return currentTime;\n  }\n\n  // Return the startTime of the first segment we want to keep\n  // Everything before this will be flushed\n  return segmentsBefore[segmentsToFlush]!.startTime;\n}\n"],"mappings":";;;;AAuBA,MAAa,6BAA+C,EAC1D,cAAc,EAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,8BACd,UACA,aACA,SAA2B,4BACnB;CACR,IAAI,SAAS,WAAW,GACtB,OAAO;CAIT,MAAM,iBAAiB,SAAS,QAAQ,QAAQ,IAAI,YAAY,WAAW;CAG3E,IAAI,eAAe,WAAW,GAC5B,OAAO;CAKT,MAAM,kBAAkB,eAAe,SAAS,OAAO;CAGvD,IAAI,mBAAmB,GACrB,OAAO;CAKT,IAAI,mBAAmB,eAAe,QACpC,OAAO;CAKT,OAAO,eAAe,gBAAgB,CAAE;AAC1C"}

package/dist/dev/media/buffer/forward-buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"forward-buffer.d.ts","names":[],"sources":["../../../../src/media/buffer/forward-buffer.ts"],"mappings":";;;;UAYiB,mBAAA;;;;;EAKf,cAAA;AAAA"}
+{"version":3,"file":"forward-buffer.d.ts","names":[],"sources":["../../../../src/media/buffer/forward-buffer.ts"],"mappings":";;;;UAmDiB;;;;;EAKf"}

package/dist/dev/media/buffer/forward-buffer.js

@@ -1,5 +1,38 @@
+import { SEGMENT_TIME_EPSILON } from "../types/index.js";
 //#region src/media/buffer/forward-buffer.ts
 /**
+* Forward Buffer Strategy (Simple)
+*
+* Determines which segments to load for forward buffer management.
+* V1 uses simple fixed-duration strategy (buffer N seconds ahead).
+*/
+/**
+* Merge intervals into sorted, disjoint ranges; touching or overlapping ranges
+* (gap ≤ `epsilon`) are joined. Empty/inverted ranges are dropped.
+*/
+function mergeTimeRanges(ranges, epsilon = SEGMENT_TIME_EPSILON) {
+	const sorted = ranges.filter((r) => r.end > r.start).sort((a, b) => a.start - b.start);
+	const merged = [];
+	for (const r of sorted) {
+		const last = merged[merged.length - 1];
+		if (last && r.start <= last.end + epsilon) last.end = Math.max(last.end, r.end);
+		else merged.push({
+			start: r.start,
+			end: r.end
+		});
+	}
+	return merged;
+}
+/**
+* Whether `[start, end)` is fully covered by the union of `merged` ranges,
+* tolerating `epsilon` of overhang at each edge. `merged` must be disjoint and
+* sorted (as returned by `mergeTimeRanges`), so full coverage means a single
+* merged range contains the interval.
+*/
+function isTimeRangeCovered(start, end, merged, epsilon = SEGMENT_TIME_EPSILON) {
+	return merged.some((r) => r.start <= start + epsilon && r.end >= end - epsilon);
+}
+/**
 * Default forward buffer configuration.
 */
 const DEFAULT_FORWARD_BUFFER_CONFIG = { bufferDuration: 30 };
@@ -72,14 +105,15 @@ function getSegmentsToLoad(segments, bufferedSegments, currentTime, config = DEF
 	if (segments.length === 0) return [];
 	const targetTime = currentTime + config.bufferDuration;
 	const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));
-	return segments.filter((seg) => {
+	return segments.filter((seg, i) => {
 		const segmentEnd = seg.startTime + seg.duration;
-		const isInRange = seg.startTime < targetTime && segmentEnd > currentTime;
+		const overlapsPlayhead = i === segments.length - 1 || segmentEnd > currentTime;
+		const isInRange = seg.startTime < targetTime && overlapsPlayhead;
 		const isNotBuffered = !bufferedStartTimes.has(seg.startTime);
 		return isInRange && isNotBuffered;
 	});
 }
 //#endregion
-export { DEFAULT_FORWARD_BUFFER_CONFIG, calculateForwardFlushPoint, getSegmentsToLoad, segmentStartForTime };
+export { DEFAULT_FORWARD_BUFFER_CONFIG, calculateForwardFlushPoint, getSegmentsToLoad, isTimeRangeCovered, mergeTimeRanges, segmentStartForTime };
 
 //# sourceMappingURL=forward-buffer.js.map

package/dist/dev/media/buffer/forward-buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"forward-buffer.js","names":[],"sources":["../../../../src/media/buffer/forward-buffer.ts"],"sourcesContent":["/**\n * Forward Buffer Strategy (Simple)\n *\n * Determines which segments to load for forward buffer management.\n * V1 uses simple fixed-duration strategy (buffer N seconds ahead).\n */\n\nimport type { Segment } from '../types';\n\n/**\n * Forward buffer configuration.\n */\nexport interface ForwardBufferConfig {\n  /**\n   * Duration in seconds to buffer ahead of current playback position.\n   * Default: 30 seconds.\n   */\n  bufferDuration: number;\n}\n\n/**\n * Default forward buffer configuration.\n */\nexport const DEFAULT_FORWARD_BUFFER_CONFIG: ForwardBufferConfig = {\n  bufferDuration: 30,\n};\n\n/**\n * Get segments that need to be loaded for forward buffer.\n *\n * Determines which segments to load to maintain target buffer duration.\n * Handles discontiguous buffering (gaps after seeks).\n *\n * Algorithm:\n * 1. Calculate target time: currentTime + bufferDuration\n * 2. Find all segments in range [currentTime, targetTime)\n * 3. Filter out segments already buffered at that time position\n * 4. Return segments to load (fills gaps + extends to target)\n *\n * @param segments - All available segments from playlist\n * @param bufferedSegments - Segments already buffered (ordered by startTime)\n * @param currentTime - Current playback position in seconds\n * @param config - Optional forward buffer configuration\n * @returns Array of segments to load (empty if buffer is sufficient)\n *\n * @example\n * // After seek: buffered [0-12, 18-30], playing at 7s\n * const toLoad = getSegmentsToLoad(segments, buffered, 7, { bufferDuration: 24 });\n * // Returns [seg-12, seg-30] (fills gap, extends to target 31s)\n */\n/**\n * Calculate the start time from which to flush forward buffer content.\n *\n * Content that starts at or beyond `currentTime + bufferDuration` is no\n * longer needed for the current playback position and should be removed\n * from the SourceBuffer. This prevents unbounded accumulation of scattered\n * SourceBuffer content after seeks, which can cause QuotaExceededError on\n * long-form content.\n *\n * Returns `Infinity` when nothing needs flushing (no buffered segments\n * exist beyond the threshold).\n *\n * @param bufferedSegments - Segments currently tracked in the buffer model\n * @param currentTime - Current playback position in seconds\n * @param config - Optional forward buffer configuration\n * @returns Start time to flush from (flush range: [flushStart, Infinity)),\n *          or Infinity if no flush is needed\n *\n * @example\n * // Playing at 0s, buffered [0,6,12,18,24,30,36], bufferDuration=30\n * const flushStart = calculateForwardFlushPoint(segments, 0);\n * // Returns 30 — flush [30, Infinity), keep [0, 30)\n */\nexport function calculateForwardFlushPoint(\n  bufferedSegments: readonly Segment[],\n  currentTime: number,\n  config: ForwardBufferConfig = DEFAULT_FORWARD_BUFFER_CONFIG\n): number {\n  if (bufferedSegments.length === 0) return Infinity;\n\n  const threshold = currentTime + config.bufferDuration;\n\n  // Find segments that start at or beyond the threshold\n  const beyond = bufferedSegments.filter((seg) => seg.startTime >= threshold);\n\n  if (beyond.length === 0) return Infinity;\n\n  // Flush from the earliest such segment onward\n  return Math.min(...beyond.map((seg) => seg.startTime));\n}\n\n/**\n * Find the start time of the segment containing `currentTime` (or the last\n * segment if `currentTime` is past the end). Returns `undefined` when\n * `currentTime` is undefined or when no segment matches.\n *\n * Used to detect \"meaningful currentTime change\" — two times that map to the\n * same segment start aren't a load-trigger; crossing a segment boundary is.\n */\nexport function segmentStartForTime(\n  currentTime: number | undefined,\n  segments: readonly Pick<Segment, 'startTime' | 'duration'>[] | undefined\n): number | undefined {\n  if (currentTime == null) return undefined;\n  return segments?.find(\n    ({ startTime, duration }, i, all) =>\n      currentTime >= startTime && (currentTime < startTime + duration || i === all.length - 1)\n  )?.startTime;\n}\n\nexport function getSegmentsToLoad(\n  segments: readonly Segment[],\n  bufferedSegments: readonly Pick<Segment, 'startTime' | 'duration'>[],\n  currentTime: number,\n  config: ForwardBufferConfig = DEFAULT_FORWARD_BUFFER_CONFIG\n): Segment[] {\n  if (segments.length === 0) {\n    return [];\n  }\n\n  // Calculate target buffer end time\n  const targetTime = currentTime + config.bufferDuration;\n\n  // Create set of buffered segment start times for fast lookup\n  // V1 simple: if ANY segment is buffered at a given time, don't load for that time\n  // V2 (future): would compare by startTime + bitrate/track for quality switching\n  const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));\n\n  // Find segments to load:\n  // - Overlaps buffer window [currentTime, targetTime)\n  // - Not already buffered at that time position\n  const toLoad = segments.filter((seg) => {\n    // Segment must overlap the buffer window\n    const segmentEnd = seg.startTime + seg.duration;\n    const isInRange = seg.startTime < targetTime && segmentEnd > currentTime;\n\n    // Must not have a segment buffered at this time position\n    const isNotBuffered = !bufferedStartTimes.has(seg.startTime);\n\n    return isInRange && isNotBuffered;\n  });\n\n  return toLoad;\n}\n"],"mappings":";;;;AAuBA,MAAa,gCAAqD,EAChE,gBAAgB,IACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDD,SAAgB,2BACd,kBACA,aACA,SAA8B,+BACtB;AACR,KAAI,iBAAiB,WAAW,EAAG,QAAO;CAE1C,MAAM,YAAY,cAAc,OAAO;CAGvC,MAAM,SAAS,iBAAiB,QAAQ,QAAQ,IAAI,aAAa,UAAU;AAE3E,KAAI,OAAO,WAAW,EAAG,QAAO;AAGhC,QAAO,KAAK,IAAI,GAAG,OAAO,KAAK,QAAQ,IAAI,UAAU,CAAC;;;;;;;;;;AAWxD,SAAgB,oBACd,aACA,UACoB;AACpB,KAAI,eAAe,KAAM,QAAO,KAAA;AAChC,QAAO,UAAU,MACd,EAAE,WAAW,YAAY,GAAG,QAC3B,eAAe,cAAc,cAAc,YAAY,YAAY,MAAM,IAAI,SAAS,GACzF,EAAE;;AAGL,SAAgB,kBACd,UACA,kBACA,aACA,SAA8B,+BACnB;AACX,KAAI,SAAS,WAAW,EACtB,QAAO,EAAE;CAIX,MAAM,aAAa,cAAc,OAAO;CAKxC,MAAM,qBAAqB,IAAI,IAAI,iBAAiB,KAAK,QAAQ,IAAI,UAAU,CAAC;AAgBhF,QAXe,SAAS,QAAQ,QAAQ;EAEtC,MAAM,aAAa,IAAI,YAAY,IAAI;EACvC,MAAM,YAAY,IAAI,YAAY,cAAc,aAAa;EAG7D,MAAM,gBAAgB,CAAC,mBAAmB,IAAI,IAAI,UAAU;AAE5D,SAAO,aAAa;GACpB"}
+{"version":3,"file":"forward-buffer.js","names":[],"sources":["../../../../src/media/buffer/forward-buffer.ts"],"sourcesContent":["/**\n * Forward Buffer Strategy (Simple)\n *\n * Determines which segments to load for forward buffer management.\n * V1 uses simple fixed-duration strategy (buffer N seconds ahead).\n */\n\nimport { SEGMENT_TIME_EPSILON, type Segment } from '../types';\n\n/** A half-open `[start, end)` interval on the presentation timeline. */\nexport interface TimeRange {\n  start: number;\n  end: number;\n}\n\n/**\n * Merge intervals into sorted, disjoint ranges; touching or overlapping ranges\n * (gap ≤ `epsilon`) are joined. Empty/inverted ranges are dropped.\n */\nexport function mergeTimeRanges(ranges: readonly TimeRange[], epsilon = SEGMENT_TIME_EPSILON): TimeRange[] {\n  const sorted = ranges.filter((r) => r.end > r.start).sort((a, b) => a.start - b.start);\n  const merged: TimeRange[] = [];\n  for (const r of sorted) {\n    const last = merged[merged.length - 1];\n    if (last && r.start <= last.end + epsilon) {\n      last.end = Math.max(last.end, r.end);\n    } else {\n      merged.push({ start: r.start, end: r.end });\n    }\n  }\n  return merged;\n}\n\n/**\n * Whether `[start, end)` is fully covered by the union of `merged` ranges,\n * tolerating `epsilon` of overhang at each edge. `merged` must be disjoint and\n * sorted (as returned by `mergeTimeRanges`), so full coverage means a single\n * merged range contains the interval.\n */\nexport function isTimeRangeCovered(\n  start: number,\n  end: number,\n  merged: readonly TimeRange[],\n  epsilon = SEGMENT_TIME_EPSILON\n): boolean {\n  return merged.some((r) => r.start <= start + epsilon && r.end >= end - epsilon);\n}\n\n/**\n * Forward buffer configuration.\n */\nexport interface ForwardBufferConfig {\n  /**\n   * Duration in seconds to buffer ahead of current playback position.\n   * Default: 30 seconds.\n   */\n  bufferDuration: number;\n}\n\n/**\n * Default forward buffer configuration.\n */\nexport const DEFAULT_FORWARD_BUFFER_CONFIG: ForwardBufferConfig = {\n  bufferDuration: 30,\n};\n\n/**\n * Get segments that need to be loaded for forward buffer.\n *\n * Determines which segments to load to maintain target buffer duration.\n * Handles discontiguous buffering (gaps after seeks).\n *\n * Algorithm:\n * 1. Calculate target time: currentTime + bufferDuration\n * 2. Find all segments in range [currentTime, targetTime)\n * 3. Filter out segments already buffered at that time position\n * 4. Return segments to load (fills gaps + extends to target)\n *\n * @param segments - All available segments from playlist\n * @param bufferedSegments - Segments already buffered (ordered by startTime)\n * @param currentTime - Current playback position in seconds\n * @param config - Optional forward buffer configuration\n * @returns Array of segments to load (empty if buffer is sufficient)\n *\n * @example\n * // After seek: buffered [0-12, 18-30], playing at 7s\n * const toLoad = getSegmentsToLoad(segments, buffered, 7, { bufferDuration: 24 });\n * // Returns [seg-12, seg-30] (fills gap, extends to target 31s)\n */\n/**\n * Calculate the start time from which to flush forward buffer content.\n *\n * Content that starts at or beyond `currentTime + bufferDuration` is no\n * longer needed for the current playback position and should be removed\n * from the SourceBuffer. This prevents unbounded accumulation of scattered\n * SourceBuffer content after seeks, which can cause QuotaExceededError on\n * long-form content.\n *\n * Returns `Infinity` when nothing needs flushing (no buffered segments\n * exist beyond the threshold).\n *\n * @param bufferedSegments - Segments currently tracked in the buffer model\n * @param currentTime - Current playback position in seconds\n * @param config - Optional forward buffer configuration\n * @returns Start time to flush from (flush range: [flushStart, Infinity)),\n *          or Infinity if no flush is needed\n *\n * @example\n * // Playing at 0s, buffered [0,6,12,18,24,30,36], bufferDuration=30\n * const flushStart = calculateForwardFlushPoint(segments, 0);\n * // Returns 30 — flush [30, Infinity), keep [0, 30)\n */\nexport function calculateForwardFlushPoint(\n  bufferedSegments: readonly Segment[],\n  currentTime: number,\n  config: ForwardBufferConfig = DEFAULT_FORWARD_BUFFER_CONFIG\n): number {\n  if (bufferedSegments.length === 0) return Infinity;\n\n  const threshold = currentTime + config.bufferDuration;\n\n  // Find segments that start at or beyond the threshold\n  const beyond = bufferedSegments.filter((seg) => seg.startTime >= threshold);\n\n  if (beyond.length === 0) return Infinity;\n\n  // Flush from the earliest such segment onward\n  return Math.min(...beyond.map((seg) => seg.startTime));\n}\n\n/**\n * Find the start time of the segment containing `currentTime` (or the last\n * segment if `currentTime` is past the end). Returns `undefined` when\n * `currentTime` is undefined or when no segment matches.\n *\n * Used to detect \"meaningful currentTime change\" — two times that map to the\n * same segment start aren't a load-trigger; crossing a segment boundary is.\n */\nexport function segmentStartForTime(\n  currentTime: number | undefined,\n  segments: readonly Pick<Segment, 'startTime' | 'duration'>[] | undefined\n): number | undefined {\n  if (currentTime == null) return undefined;\n  return segments?.find(\n    ({ startTime, duration }, i, all) =>\n      currentTime >= startTime && (currentTime < startTime + duration || i === all.length - 1)\n  )?.startTime;\n}\n\nexport function getSegmentsToLoad(\n  segments: readonly Segment[],\n  bufferedSegments: readonly Pick<Segment, 'startTime' | 'duration'>[],\n  currentTime: number,\n  config: ForwardBufferConfig = DEFAULT_FORWARD_BUFFER_CONFIG\n): Segment[] {\n  if (segments.length === 0) {\n    return [];\n  }\n\n  // Calculate target buffer end time\n  const targetTime = currentTime + config.bufferDuration;\n\n  // Create set of buffered segment start times for fast lookup\n  // V1 simple: if ANY segment is buffered at a given time, don't load for that time\n  // V2 (future): would compare by startTime + bitrate/track for quality switching\n  const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));\n\n  // Find segments to load:\n  // - Overlaps buffer window [currentTime, targetTime)\n  // - Not already buffered at that time position\n  const toLoad = segments.filter((seg, i) => {\n    const segmentEnd = seg.startTime + seg.duration;\n    const isLast = i === segments.length - 1;\n    // Interior segments use strict `>` so a segment the playhead just finished\n    // (endTime === currentTime at a boundary) isn't reloaded. The terminal\n    // segment has no successor and no reachable position past it — the playhead\n    // is clamped to the presentation's range — so it needs no upper bound: it's\n    // loadable whenever the forward window reaches it. That resolves the\n    // exact-end seek (#1828) and the post-loop re-seek — where\n    // `MediaSource.duration`, clamped by `endOfStream()` to the true buffered\n    // end, has grown a hair past the model's EXTINF-derived end — with no\n    // dependency on any duration value.\n    //\n    // LIVE: for an un-ended live/DVR presentation `isLast` is the sliding edge\n    // segment; loading it eagerly here is benign today (forward-window-bounded,\n    // deduped by the buffered check), but the live effort should confirm the\n    // edge / end-of-stream interaction when it lands.\n    const overlapsPlayhead = isLast || segmentEnd > currentTime;\n    const isInRange = seg.startTime < targetTime && overlapsPlayhead;\n\n    // Must not have a segment buffered at this time position\n    const isNotBuffered = !bufferedStartTimes.has(seg.startTime);\n\n    return isInRange && isNotBuffered;\n  });\n\n  return toLoad;\n}\n"],"mappings":";;;;;;;;;;;;AAmBA,SAAgB,gBAAgB,QAA8B,UAAU,sBAAmC;CACzG,MAAM,SAAS,OAAO,QAAQ,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;CACrF,MAAM,SAAsB,CAAC;CAC7B,KAAK,MAAM,KAAK,QAAQ;EACtB,MAAM,OAAO,OAAO,OAAO,SAAS;EACpC,IAAI,QAAQ,EAAE,SAAS,KAAK,MAAM,SAChC,KAAK,MAAM,KAAK,IAAI,KAAK,KAAK,EAAE,GAAG;OAEnC,OAAO,KAAK;GAAE,OAAO,EAAE;GAAO,KAAK,EAAE;EAAI,CAAC;CAE9C;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,mBACd,OACA,KACA,QACA,UAAU,sBACD;CACT,OAAO,OAAO,MAAM,MAAM,EAAE,SAAS,QAAQ,WAAW,EAAE,OAAO,MAAM,OAAO;AAChF;;;;AAgBA,MAAa,gCAAqD,EAChE,gBAAgB,GAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,2BACd,kBACA,aACA,SAA8B,+BACtB;CACR,IAAI,iBAAiB,WAAW,GAAG,OAAO;CAE1C,MAAM,YAAY,cAAc,OAAO;CAGvC,MAAM,SAAS,iBAAiB,QAAQ,QAAQ,IAAI,aAAa,SAAS;CAE1E,IAAI,OAAO,WAAW,GAAG,OAAO;CAGhC,OAAO,KAAK,IAAI,GAAG,OAAO,KAAK,QAAQ,IAAI,SAAS,CAAC;AACvD;;;;;;;;;AAUA,SAAgB,oBACd,aACA,UACoB;CACpB,IAAI,eAAe,MAAM,OAAO,KAAA;CAChC,OAAO,UAAU,MACd,EAAE,WAAW,YAAY,GAAG,QAC3B,eAAe,cAAc,cAAc,YAAY,YAAY,MAAM,IAAI,SAAS,EAC1F,CAAC,EAAE;AACL;AAEA,SAAgB,kBACd,UACA,kBACA,aACA,SAA8B,+BACnB;CACX,IAAI,SAAS,WAAW,GACtB,OAAO,CAAC;CAIV,MAAM,aAAa,cAAc,OAAO;CAKxC,MAAM,qBAAqB,IAAI,IAAI,iBAAiB,KAAK,QAAQ,IAAI,SAAS,CAAC;CA+B/E,OA1Be,SAAS,QAAQ,KAAK,MAAM;EACzC,MAAM,aAAa,IAAI,YAAY,IAAI;EAgBvC,MAAM,mBAfS,MAAM,SAAS,SAAS,KAeJ,aAAa;EAChD,MAAM,YAAY,IAAI,YAAY,cAAc;EAGhD,MAAM,gBAAgB,CAAC,mBAAmB,IAAI,IAAI,SAAS;EAE3D,OAAO,aAAa;CACtB,CAEY;AACd"}

package/dist/dev/media/dom/capabilities.js

@@ -0,0 +1,70 @@
+import { NON_FMP4_CONTAINER_MIMES } from "../hls/parse-media-playlist.js";
+import { buildMimeCodec, isCodecSupported } from "./mse/mediasource-setup.js";
+//#region src/media/dom/capabilities.ts
+/**
+* Capability probing — the engine's foundation for asking the browser what it
+* can actually decode before committing a rendition to the pipeline.
+*
+* Today this is the synchronous codec half: `canPlayTrack` answers "can this
+* environment play this track?" by building the track's MIME codec string and
+* passing it to `MediaSource.isTypeSupported` (via `isCodecSupported`). It's the
+* DOM implementation of the DOM-free `CanPlayTrack` predicate the
+* track-switching hard-constraint pre-pass consumes — injected through engine
+* config so the (DOM-free) behavior never imports a DOM API directly.
+*
+* Results are memoized by built MIME string: codec support is a pure function
+* of (codec, environment) and never changes after load, so probing is lazy
+* (per candidate, at constraint-apply time) but each unique MIME is asked once.
+*
+* Future cluster-D phases (async `requestMediaKeySystemAccess` key-system
+* probing, `SourceBuffer.changeType()` availability) extend this surface; the
+* async ones land as a state-slot writer behavior rather than a config
+* predicate, since their verdict resolves asynchronously.
+*/
+const codecSupportCache = /* @__PURE__ */ new Map();
+/**
+* Whether the environment can decode `track`, by codec. Builds the track's
+* MIME codec string and checks `MediaSource.isTypeSupported`, memoized by MIME.
+* A track without enough to probe — no `mimeType`, or no declared `codecs`
+* (CODECS is optional per the HLS spec) — is unprobeable and passes through as
+* playable (`true`) rather than being dropped; the late `createSourceBuffer`
+* check stays as the backstop for those.
+*
+* Detected non-fMP4 containers (`video/mp2t`, `audio/aac`) are asserted
+* unsupported regardless of the probe, so they're pruned before selection
+* (the type makes no pick) instead of failing/stalling deep in the pipeline.
+* Two different reasons, neither UA-based:
+*
+* - **MPEG-TS** can't be played at all here: `isTypeSupported('video/mp2t…')` is
+*   a genuine false positive on Chromium (reports `true` but appends produce no
+*   buffered range), and this engine has no TS transmux pipeline.
+* - **Raw ADTS AAC** is a *temporary* limitation. The browser genuinely
+*   supports it (Chrome/Safari decode `audio/aac`; Firefox doesn't), so it could
+*   be made playable — but our segment actors / loading behaviors / append
+*   pipeline assume every rendition has an `EXT-X-MAP` init segment (e.g. an
+*   `append-init` task with an empty URL, fMP4-shaped append handling). Until
+*   that init-segment assumption is removed, ADTS would fetch but never buffer
+*   (a silent stall), so we assert it unplayable for now. FOLLOW-UP: drop the
+*   init-required assumption in the pipeline and switch this to a bare-MIME
+*   probe (`buildMimeCodec` would project `audio/aac` with no codecs) so it
+*   plays where the browser supports it.
+*
+* Override via the engine's `canPlayTrack` config when those pipelines land.
+*/
+const canPlayTrack = (track) => {
+	if (track.mimeType && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) return false;
+	if (!track.mimeType || !track.codecs?.length) return true;
+	const mimeCodec = buildMimeCodec({
+		mimeType: track.mimeType,
+		codecs: track.codecs
+	});
+	const cached = codecSupportCache.get(mimeCodec);
+	if (cached !== void 0) return cached;
+	const supported = isCodecSupported(mimeCodec);
+	codecSupportCache.set(mimeCodec, supported);
+	return supported;
+};
+//#endregion
+export { canPlayTrack };
+
+//# sourceMappingURL=capabilities.js.map

package/dist/dev/media/dom/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","names":[],"sources":["../../../../src/media/dom/capabilities.ts"],"sourcesContent":["/**\n * Capability probing — the engine's foundation for asking the browser what it\n * can actually decode before committing a rendition to the pipeline.\n *\n * Today this is the synchronous codec half: `canPlayTrack` answers \"can this\n * environment play this track?\" by building the track's MIME codec string and\n * passing it to `MediaSource.isTypeSupported` (via `isCodecSupported`). It's the\n * DOM implementation of the DOM-free `CanPlayTrack` predicate the\n * track-switching hard-constraint pre-pass consumes — injected through engine\n * config so the (DOM-free) behavior never imports a DOM API directly.\n *\n * Results are memoized by built MIME string: codec support is a pure function\n * of (codec, environment) and never changes after load, so probing is lazy\n * (per candidate, at constraint-apply time) but each unique MIME is asked once.\n *\n * Future cluster-D phases (async `requestMediaKeySystemAccess` key-system\n * probing, `SourceBuffer.changeType()` availability) extend this surface; the\n * async ones land as a state-slot writer behavior rather than a config\n * predicate, since their verdict resolves asynchronously.\n */\n\nimport { NON_FMP4_CONTAINER_MIMES } from '../hls/parse-media-playlist';\nimport type { CanPlayTrack } from '../types';\nimport { buildMimeCodec, isCodecSupported } from './mse/mediasource-setup';\n\nconst codecSupportCache = new Map<string, boolean>();\n\n/**\n * Whether the environment can decode `track`, by codec. Builds the track's\n * MIME codec string and checks `MediaSource.isTypeSupported`, memoized by MIME.\n * A track without enough to probe — no `mimeType`, or no declared `codecs`\n * (CODECS is optional per the HLS spec) — is unprobeable and passes through as\n * playable (`true`) rather than being dropped; the late `createSourceBuffer`\n * check stays as the backstop for those.\n *\n * Detected non-fMP4 containers (`video/mp2t`, `audio/aac`) are asserted\n * unsupported regardless of the probe, so they're pruned before selection\n * (the type makes no pick) instead of failing/stalling deep in the pipeline.\n * Two different reasons, neither UA-based:\n *\n * - **MPEG-TS** can't be played at all here: `isTypeSupported('video/mp2t…')` is\n *   a genuine false positive on Chromium (reports `true` but appends produce no\n *   buffered range), and this engine has no TS transmux pipeline.\n * - **Raw ADTS AAC** is a *temporary* limitation. The browser genuinely\n *   supports it (Chrome/Safari decode `audio/aac`; Firefox doesn't), so it could\n *   be made playable — but our segment actors / loading behaviors / append\n *   pipeline assume every rendition has an `EXT-X-MAP` init segment (e.g. an\n *   `append-init` task with an empty URL, fMP4-shaped append handling). Until\n *   that init-segment assumption is removed, ADTS would fetch but never buffer\n *   (a silent stall), so we assert it unplayable for now. FOLLOW-UP: drop the\n *   init-required assumption in the pipeline and switch this to a bare-MIME\n *   probe (`buildMimeCodec` would project `audio/aac` with no codecs) so it\n *   plays where the browser supports it.\n *\n * Override via the engine's `canPlayTrack` config when those pipelines land.\n */\nexport const canPlayTrack: CanPlayTrack = (track) => {\n  if (track.mimeType && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) return false;\n  if (!track.mimeType || !track.codecs?.length) return true;\n  const mimeCodec = buildMimeCodec({ mimeType: track.mimeType, codecs: track.codecs });\n  const cached = codecSupportCache.get(mimeCodec);\n  if (cached !== undefined) return cached;\n  const supported = isCodecSupported(mimeCodec);\n  codecSupportCache.set(mimeCodec, supported);\n  return supported;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAM,oCAAoB,IAAI,IAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BnD,MAAa,gBAA8B,UAAU;CACnD,IAAI,MAAM,YAAY,yBAAyB,IAAI,MAAM,QAAQ,GAAG,OAAO;CAC3E,IAAI,CAAC,MAAM,YAAY,CAAC,MAAM,QAAQ,QAAQ,OAAO;CACrD,MAAM,YAAY,eAAe;EAAE,UAAU,MAAM;EAAU,QAAQ,MAAM;CAAO,CAAC;CACnF,MAAM,SAAS,kBAAkB,IAAI,SAAS;CAC9C,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,MAAM,YAAY,iBAAiB,SAAS;CAC5C,kBAAkB,IAAI,WAAW,SAAS;CAC1C,OAAO;AACT"}

package/dist/dev/media/dom/mse/append-segment.d.ts

@@ -1,13 +1,7 @@
+import { SegmentData } from "../../types/index.js";
 //#region src/media/dom/mse/append-segment.d.ts
-/**
- * Segment appender helper.
- *
- * Appends media data (ArrayBuffer or AsyncIterable<Uint8Array> stream) to a
- * SourceBuffer, waiting for `updateend` between calls so the browser can
- * process each append before the next one arrives.
- */
-/** Data accepted by appendSegment — a full buffer or an async chunk stream. */
-type AppendData = ArrayBuffer | AsyncIterable<Uint8Array>;
+/** Data accepted by appendSegment — the MSE-boundary alias of {@link SegmentData}. */
+type AppendData = SegmentData;
 /**
  * Append media data to a SourceBuffer.
  *

package/dist/dev/media/dom/mse/append-segment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"append-segment.d.ts","names":[],"sources":["../../../../../src/media/dom/mse/append-segment.ts"],"mappings":";;AASA;;;;;;;KAAY,UAAA,GAAa,WAAA,GAAc,aAAA,CAAc,UAAA;;;;;;AAYrD;;;;;iBAAsB,aAAA,CAAc,YAAA,EAAc,YAAA,EAAc,IAAA,EAAM,UAAA,EAAY,MAAA,GAAS,WAAA,GAAc,OAAA"}
+{"version":3,"file":"append-segment.d.ts","names":[],"sources":["../../../../../src/media/dom/mse/append-segment.ts"],"mappings":";;;KAWY,aAAa;;;;;;;;;;;iBAYH,cAAc,cAAc,cAAc,MAAM,YAAY,SAAS,cAAc"}

package/dist/dev/media/dom/mse/append-segment.js.map

@@ -1 +1 @@
-{"version":3,"file":"append-segment.js","names":[],"sources":["../../../../../src/media/dom/mse/append-segment.ts"],"sourcesContent":["/**\n * Segment appender helper.\n *\n * Appends media data (ArrayBuffer or AsyncIterable<Uint8Array> stream) to a\n * SourceBuffer, waiting for `updateend` between calls so the browser can\n * process each append before the next one arrives.\n */\n\n/** Data accepted by appendSegment — a full buffer or an async chunk stream. */\nexport type AppendData = ArrayBuffer | AsyncIterable<Uint8Array>;\n\n/**\n * Append media data to a SourceBuffer.\n *\n * Accepts either a full ArrayBuffer (single append) or an AsyncIterable of\n * Uint8Array chunks (one append per chunk, in order). Waits for `updateend`\n * between each call so appends are serialized correctly.\n *\n * Errors from the SourceBuffer (`error` event) or from the iterable are\n * propagated as rejections.\n */\nexport async function appendSegment(sourceBuffer: SourceBuffer, data: AppendData, signal?: AbortSignal): Promise<void> {\n  if (data instanceof ArrayBuffer) {\n    await appendChunk(sourceBuffer, data);\n  } else {\n    try {\n      for await (const chunk of data) {\n        // Check between chunks so an abort can stop streaming before the next\n        // appendBuffer call. The current chunk (if any) has already landed in the\n        // SourceBuffer; the partial: true flag in the actor model reflects this.\n        if (signal?.aborted) throw signal.reason ?? new DOMException('Aborted', 'AbortError');\n        await appendChunk(sourceBuffer, chunk);\n      }\n    } catch (e) {\n      // Reset the MSE segment parser on any abort to discard partial fMP4 box\n      // data from the SourceBuffer's internal byte buffer. Two paths reach here:\n      //\n      // 1. Explicit abort check above (signal.aborted between chunks) — the\n      //    last appended chunk may have left the parser mid-fragment.\n      //\n      // 2. The fetch was cancelled (signal fired), causing the underlying\n      //    ReadableStream to error and the for-await loop to throw directly\n      //    without ever passing through the signal check above. Same cleanup\n      //    is needed: partial box data must be cleared before the next append.\n      //\n      // Without this, the next appendBuffer call sees stale partial data and\n      // Chrome throws CHUNK_DEMUXER_ERROR_APPEND_FAILED.\n      if (e instanceof DOMException && e.name === 'AbortError' && !sourceBuffer.updating) {\n        try {\n          sourceBuffer.abort();\n        } catch {\n          // Thrown if the MediaSource is not \"open\" (e.g. during teardown).\n        }\n      }\n      throw e;\n    }\n  }\n}\n\nasync function appendChunk(sourceBuffer: SourceBuffer, data: ArrayBuffer | Uint8Array<ArrayBufferLike>): Promise<void> {\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer append error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.appendBuffer(data as ArrayBuffer);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;AAqBA,eAAsB,cAAc,cAA4B,MAAkB,QAAqC;AACrH,KAAI,gBAAgB,YAClB,OAAM,YAAY,cAAc,KAAK;KAErC,KAAI;AACF,aAAW,MAAM,SAAS,MAAM;AAI9B,OAAI,QAAQ,QAAS,OAAM,OAAO,UAAU,IAAI,aAAa,WAAW,aAAa;AACrF,SAAM,YAAY,cAAc,MAAM;;UAEjC,GAAG;AAcV,MAAI,aAAa,gBAAgB,EAAE,SAAS,gBAAgB,CAAC,aAAa,SACxE,KAAI;AACF,gBAAa,OAAO;UACd;AAIV,QAAM;;;AAKZ,eAAe,YAAY,cAA4B,MAAgE;AACrH,KAAI,aAAa,SACf,OAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;AACxB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,YAAS;;AAEX,eAAa,iBAAiB,aAAa,YAAY;GACvD;AAGJ,QAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;AACxB,YAAS;AACT,YAAS;;EAGX,MAAM,WAAW,UAAiB;AAChC,YAAS;AACT,0BAAO,IAAI,MAAM,8BAA8B,MAAM,OAAO,CAAC;;EAG/D,MAAM,gBAAgB;AACpB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,gBAAa,oBAAoB,SAAS,QAAQ;;AAGpD,eAAa,iBAAiB,aAAa,YAAY;AACvD,eAAa,iBAAiB,SAAS,QAAQ;AAE/C,MAAI;AACF,gBAAa,aAAa,KAAoB;WACvC,OAAO;AACd,YAAS;AACT,UAAO,MAAM;;GAEf"}
+{"version":3,"file":"append-segment.js","names":[],"sources":["../../../../../src/media/dom/mse/append-segment.ts"],"sourcesContent":["/**\n * Segment appender helper.\n *\n * Appends media data (ArrayBuffer or AsyncIterable<Uint8Array> stream) to a\n * SourceBuffer, waiting for `updateend` between calls so the browser can\n * process each append before the next one arrives.\n */\n\nimport type { SegmentData } from '../../types';\n\n/** Data accepted by appendSegment — the MSE-boundary alias of {@link SegmentData}. */\nexport type AppendData = SegmentData;\n\n/**\n * Append media data to a SourceBuffer.\n *\n * Accepts either a full ArrayBuffer (single append) or an AsyncIterable of\n * Uint8Array chunks (one append per chunk, in order). Waits for `updateend`\n * between each call so appends are serialized correctly.\n *\n * Errors from the SourceBuffer (`error` event) or from the iterable are\n * propagated as rejections.\n */\nexport async function appendSegment(sourceBuffer: SourceBuffer, data: AppendData, signal?: AbortSignal): Promise<void> {\n  if (data instanceof ArrayBuffer) {\n    await appendChunk(sourceBuffer, data);\n  } else {\n    try {\n      for await (const chunk of data) {\n        // Check between chunks so an abort can stop streaming before the next\n        // appendBuffer call. The current chunk (if any) has already landed in the\n        // SourceBuffer; the partial: true flag in the actor model reflects this.\n        if (signal?.aborted) throw signal.reason ?? new DOMException('Aborted', 'AbortError');\n        await appendChunk(sourceBuffer, chunk);\n      }\n    } catch (e) {\n      // Reset the MSE segment parser on any abort to discard partial fMP4 box\n      // data from the SourceBuffer's internal byte buffer. Two paths reach here:\n      //\n      // 1. Explicit abort check above (signal.aborted between chunks) — the\n      //    last appended chunk may have left the parser mid-fragment.\n      //\n      // 2. The fetch was cancelled (signal fired), causing the underlying\n      //    ReadableStream to error and the for-await loop to throw directly\n      //    without ever passing through the signal check above. Same cleanup\n      //    is needed: partial box data must be cleared before the next append.\n      //\n      // Without this, the next appendBuffer call sees stale partial data and\n      // Chrome throws CHUNK_DEMUXER_ERROR_APPEND_FAILED.\n      if (e instanceof DOMException && e.name === 'AbortError' && !sourceBuffer.updating) {\n        try {\n          sourceBuffer.abort();\n        } catch {\n          // Thrown if the MediaSource is not \"open\" (e.g. during teardown).\n        }\n      }\n      throw e;\n    }\n  }\n}\n\nasync function appendChunk(sourceBuffer: SourceBuffer, data: ArrayBuffer | Uint8Array<ArrayBufferLike>): Promise<void> {\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer append error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.appendBuffer(data as ArrayBuffer);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;AAuBA,eAAsB,cAAc,cAA4B,MAAkB,QAAqC;CACrH,IAAI,gBAAgB,aAClB,MAAM,YAAY,cAAc,IAAI;MAEpC,IAAI;EACF,WAAW,MAAM,SAAS,MAAM;GAI9B,IAAI,QAAQ,SAAS,MAAM,OAAO,UAAU,IAAI,aAAa,WAAW,YAAY;GACpF,MAAM,YAAY,cAAc,KAAK;EACvC;CACF,SAAS,GAAG;EAcV,IAAI,aAAa,gBAAgB,EAAE,SAAS,gBAAgB,CAAC,aAAa,UACxE,IAAI;GACF,aAAa,MAAM;EACrB,QAAQ,CAER;EAEF,MAAM;CACR;AAEJ;AAEA,eAAe,YAAY,cAA4B,MAAgE;CACrH,IAAI,aAAa,UACf,MAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;GACxB,aAAa,oBAAoB,aAAa,WAAW;GACzD,QAAQ;EACV;EACA,aAAa,iBAAiB,aAAa,WAAW;CACxD,CAAC;CAGH,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;GACxB,QAAQ;GACR,QAAQ;EACV;EAEA,MAAM,WAAW,UAAiB;GAChC,QAAQ;GACR,uBAAO,IAAI,MAAM,8BAA8B,MAAM,MAAM,CAAC;EAC9D;EAEA,MAAM,gBAAgB;GACpB,aAAa,oBAAoB,aAAa,WAAW;GACzD,aAAa,oBAAoB,SAAS,OAAO;EACnD;EAEA,aAAa,iBAAiB,aAAa,WAAW;EACtD,aAAa,iBAAiB,SAAS,OAAO;EAE9C,IAAI;GACF,aAAa,aAAa,IAAmB;EAC/C,SAAS,OAAO;GACd,QAAQ;GACR,OAAO,KAAK;EACd;CACF,CAAC;AACH"}

package/dist/dev/media/dom/mse/buffer-flusher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-flusher.d.ts","names":[],"sources":["../../../../../src/media/dom/mse/buffer-flusher.ts"],"mappings":";;AAoBA;;;;;;;;;;;;;;;;;;iBAAsB,WAAA,CAAY,YAAA,EAAc,YAAA,EAAc,KAAA,UAAe,GAAA,WAAc,OAAA"}
+{"version":3,"file":"buffer-flusher.d.ts","names":[],"sources":["../../../../../src/media/dom/mse/buffer-flusher.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAoBsB,YAAY,cAAc,cAAc,eAAe,cAAc"}

package/dist/dev/media/dom/mse/buffer-flusher.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-flusher.js","names":[],"sources":["../../../../../src/media/dom/mse/buffer-flusher.ts"],"sourcesContent":["/**\n * Buffer flusher helper (P12)\n *\n * Removes a time range from a SourceBuffer to manage memory.\n */\n\n/**\n * Remove a time range from a SourceBuffer.\n *\n * Waits for the SourceBuffer to be ready (not updating), then removes\n * the specified range. Returns a promise that resolves when removal completes.\n *\n * @param sourceBuffer - The SourceBuffer to remove data from\n * @param start - Start of the time range to remove (seconds)\n * @param end - End of the time range to remove (seconds)\n * @returns Promise that resolves when removal completes\n *\n * @example\n * await flushBuffer(videoSourceBuffer, 0, 30);\n */\nexport async function flushBuffer(sourceBuffer: SourceBuffer, start: number, end: number): Promise<void> {\n  // Wait for SourceBuffer to be ready (not currently updating)\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer remove error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.remove(start, end);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,eAAsB,YAAY,cAA4B,OAAe,KAA4B;AAEvG,KAAI,aAAa,SACf,OAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;AACxB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,YAAS;;AAEX,eAAa,iBAAiB,aAAa,YAAY;GACvD;AAGJ,QAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;AACxB,YAAS;AACT,YAAS;;EAGX,MAAM,WAAW,UAAiB;AAChC,YAAS;AACT,0BAAO,IAAI,MAAM,8BAA8B,MAAM,OAAO,CAAC;;EAG/D,MAAM,gBAAgB;AACpB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,gBAAa,oBAAoB,SAAS,QAAQ;;AAGpD,eAAa,iBAAiB,aAAa,YAAY;AACvD,eAAa,iBAAiB,SAAS,QAAQ;AAE/C,MAAI;AACF,gBAAa,OAAO,OAAO,IAAI;WACxB,OAAO;AACd,YAAS;AACT,UAAO,MAAM;;GAEf"}
+{"version":3,"file":"buffer-flusher.js","names":[],"sources":["../../../../../src/media/dom/mse/buffer-flusher.ts"],"sourcesContent":["/**\n * Buffer flusher helper (P12)\n *\n * Removes a time range from a SourceBuffer to manage memory.\n */\n\n/**\n * Remove a time range from a SourceBuffer.\n *\n * Waits for the SourceBuffer to be ready (not updating), then removes\n * the specified range. Returns a promise that resolves when removal completes.\n *\n * @param sourceBuffer - The SourceBuffer to remove data from\n * @param start - Start of the time range to remove (seconds)\n * @param end - End of the time range to remove (seconds)\n * @returns Promise that resolves when removal completes\n *\n * @example\n * await flushBuffer(videoSourceBuffer, 0, 30);\n */\nexport async function flushBuffer(sourceBuffer: SourceBuffer, start: number, end: number): Promise<void> {\n  // Wait for SourceBuffer to be ready (not currently updating)\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer remove error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.remove(start, end);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,eAAsB,YAAY,cAA4B,OAAe,KAA4B;CAEvG,IAAI,aAAa,UACf,MAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;GACxB,aAAa,oBAAoB,aAAa,WAAW;GACzD,QAAQ;EACV;EACA,aAAa,iBAAiB,aAAa,WAAW;CACxD,CAAC;CAGH,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;GACxB,QAAQ;GACR,QAAQ;EACV;EAEA,MAAM,WAAW,UAAiB;GAChC,QAAQ;GACR,uBAAO,IAAI,MAAM,8BAA8B,MAAM,MAAM,CAAC;EAC9D;EAEA,MAAM,gBAAgB;GACpB,aAAa,oBAAoB,aAAa,WAAW;GACzD,aAAa,oBAAoB,SAAS,OAAO;EACnD;EAEA,aAAa,iBAAiB,aAAa,WAAW;EACtD,aAAa,iBAAiB,SAAS,OAAO;EAE9C,IAAI;GACF,aAAa,OAAO,OAAO,GAAG;EAChC,SAAS,OAAO;GACd,QAAQ;GACR,OAAO,KAAK;EACd;CACF,CAAC;AACH"}

package/dist/dev/media/dom/mse/duration.js

@@ -7,21 +7,38 @@ import { hasPresentationDuration } from "../../types/index.js";
 function canUpdateDuration(presentation, mediaSource) {
 	return !!(mediaSource && presentation && hasPresentationDuration(presentation));
 }
+function getBufferedEnd(buffers, isEndMatch) {
+	return [...buffers].reduce((endMatch, buffer) => {
+		const { buffered } = buffer;
+		if (!buffered.length) return endMatch;
+		const end = buffered.end(buffered.length - 1);
+		if (!endMatch) return end;
+		return isEndMatch(end, endMatch) ? end : endMatch;
+	}, void 0) ?? 0;
+}
+const isGreaterThan = (x, y) => x > y;
+const isLessThan = (x, y) => x < y;
 /**
 * Get the maximum buffered end time across an iterable of SourceBuffers
 * (typically `mediaSource.sourceBuffers`). Returns `0` when the collection is
 * empty or no buffer has any buffered ranges.
 */
 function getMaxBufferedEnd(buffers) {
-	let maxEnd = 0;
-	for (const buffer of buffers) {
-		const { buffered } = buffer;
-		if (buffered.length > 0) {
-			const end = buffered.end(buffered.length - 1);
-			if (end > maxEnd) maxEnd = end;
-		}
-	}
-	return maxEnd;
+	return getBufferedEnd(buffers, isGreaterThan);
+}
+/**
+* Get the reachable buffered end across an iterable of SourceBuffers (typically
+* `mediaSource.sourceBuffers`): the `min` of each buffer's last buffered-range end
+* — the furthest point every track can play to (the intersection end). Buffers with
+* no buffered ranges are skipped. Returns `0` when the collection is empty or no
+* buffer has any buffered ranges.
+*
+* Counterpart to {@link getMaxBufferedEnd}: `max` bounds the overall presentation
+* end (e.g. for setting `duration`), `min` bounds where playback can actually reach
+* when tracks end at slightly different times (e.g. skewed A/V near end-of-stream).
+*/
+function getMinBufferedEnd(buffers) {
+	return getBufferedEnd(buffers, isLessThan);
 }
 /**
 * Check if the preconditions are met to *attempt* a `mediaSource.duration`
@@ -73,6 +90,6 @@ function waitForSourceBuffersReady(buffers, signal) {
 	});
 }
 //#endregion
-export { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady };
+export { canUpdateDuration, getBufferedEnd, getMaxBufferedEnd, getMinBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady };
 
 //# sourceMappingURL=duration.js.map