@videojs/spf 10.0.0-beta.23 → 10.0.0-beta.25

package/dist/dev/dom.js

@@ -1,10 +1,9 @@
-import { loadSegments } from "./dom/features/load-segments.js";
-import { destroyVttParser, parseVttSegment } from "./dom/text/parse-vtt-segment.js";
-import { loadTextTrackCues } from "./dom/features/load-text-track-cues.js";
-import { trackCurrentTime } from "./dom/features/track-current-time.js";
-import { trackPlaybackInitiated } from "./dom/features/track-playback-initiated.js";
-import { trackPlaybackRate } from "./dom/features/track-playback-rate.js";
-import { appendSegment } from "./dom/media/append-segment.js";
-import { flushBuffer } from "./dom/media/buffer-flusher.js";
-import { SpfMedia, SpfMediaMixin, spfMediaDefaultProps } from "./dom/playback-engine/adapter.js";
-export { SpfMedia, SpfMediaMixin, appendSegment, destroyVttParser, flushBuffer, loadSegments, loadTextTrackCues, parseVttSegment, spfMediaDefaultProps, trackCurrentTime, trackPlaybackInitiated, trackPlaybackRate };
+import { appendSegment } from "./media/dom/mse/append-segment.js";
+import { flushBuffer } from "./media/dom/mse/buffer-flusher.js";
+import { destroyVttResolver, resolveVttSegment } from "./media/dom/text/resolve-vtt-segment.js";
+import { loadAudioSegments, loadVideoSegments } from "./playback/behaviors/dom/load-segments.js";
+import { setupTextTrackActors } from "./playback/behaviors/dom/setup-text-track-actors.js";
+import { trackCurrentTime } from "./playback/behaviors/dom/track-current-time.js";
+import { trackLoadTriggers } from "./playback/behaviors/dom/track-load-triggers.js";
+import { trackPlaybackRate } from "./playback/behaviors/dom/track-playback-rate.js";
+export { appendSegment, destroyVttResolver, flushBuffer, loadAudioSegments, loadVideoSegments, resolveVttSegment, setupTextTrackActors, trackCurrentTime, trackLoadTriggers, trackPlaybackRate };

package/dist/dev/hls.d.ts

@@ -0,0 +1,5 @@
+import { SimpleHlsEngineConfig, SimpleHlsEngineContext, SimpleHlsEngineSignals, SimpleHlsEngineState, createSimpleHlsEngine } from "./playback/engines/hls/engine.js";
+import { SimpleHlsMediaAPI, SimpleHlsMediaElement, SimpleHlsMediaMixin, SimpleHlsMediaProps, simpleHlsMediaDefaultProps } from "./playback/engines/hls/adapter.js";
+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 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, simpleHlsAudioOnlyMediaDefaultProps, simpleHlsMediaDefaultProps };

package/dist/dev/hls.js

@@ -0,0 +1,5 @@
+import { createSimpleHlsEngine } from "./playback/engines/hls/engine.js";
+import { SimpleHlsMediaElement, SimpleHlsMediaMixin, simpleHlsMediaDefaultProps } from "./playback/engines/hls/adapter.js";
+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, simpleHlsAudioOnlyMediaDefaultProps, simpleHlsMediaDefaultProps };

package/dist/dev/index.d.ts

@@ -1,13 +1,25 @@
+import { Computed, ReadonlySignal, Signal, SignalOptions, computed, signal, snapshot, untrack, update } from "./core/signals/primitives.js";
+import { Behavior, BehaviorCleanup, BehaviorDeps, Composition, CompositionOptions, ContextSignals, InferBehaviorConfig, InferBehaviorContext, InferBehaviorState, ResolveBehaviorConfig, ResolveBehaviorContext, ResolveBehaviorState, StateSignals, createComposition, defineBehavior } from "./core/composition/create-composition.js";
+import { ShareSignalsConfig, makeShareSignals } from "./core/composition/share-signals.js";
+import { effect } from "./core/signals/effect.js";
+import { ConcurrentRunner, SerialRunner, Task, TaskConfig, TaskLike, TaskStatus } from "./core/tasks/task.js";
+import { ActorSnapshot, CallbackActor, SignalActor } from "./core/actors/actor.js";
+import { ActorDefinition, ActorStateDefinition, HandlerContext, MessageActor, RunnerLike, createMachineActor } from "./core/actors/create-machine-actor.js";
+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
  *
- * Bundle size target: < 20KB (minified + gzipped)
- * Primary use case: CMAF HLS playback with Video.js v10
+ * The compositional primitives: createComposition, signals, tasks, actors,
+ * reactors. Media-domain helpers and the HLS playback engine live behind
+ * the `./dom` and `./hls` subpaths.
  *
  * @packageDocumentation
  */
 declare const VERSION = "0.1.0";
 //#endregion
-export { VERSION };
+export { type ActorDefinition, type ActorSnapshot, type ActorStateDefinition, type Behavior, type BehaviorCleanup, type BehaviorDeps, type CallbackActor, type Composition, type CompositionOptions, type Computed, ConcurrentRunner, type ContextSignals, type HandlerContext, type InferBehaviorConfig, type InferBehaviorContext, type InferBehaviorState, type Machine, type MachineSnapshot, type MessageActor, type Reactor, type ReactorDefinition, type ReactorDeriveFn, type ReactorEffectFn, type ReactorStateDefinition, type ReadonlySignal, type ResolveBehaviorConfig, type ResolveBehaviorContext, type ResolveBehaviorState, type RunnerLike, SerialRunner, type ShareSignalsConfig, type Signal, type SignalActor, type SignalOptions, type StateSignals, Task, type TaskConfig, type TaskLike, type TaskStatus, type TransitionActor, VERSION, computed, createComposition, createMachineActor, createMachineReactor, createTransitionActor, defineBehavior, effect, makeShareSignals, signal, snapshot, untrack, update };
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/dev/index.js

@@ -1,14 +1,23 @@
+import { computed, signal, snapshot, untrack, update } from "./core/signals/primitives.js";
+import { createComposition, defineBehavior } from "./core/composition/create-composition.js";
+import { makeShareSignals } from "./core/composition/share-signals.js";
+import { effect } from "./core/signals/effect.js";
+import { ConcurrentRunner, SerialRunner, Task } from "./core/tasks/task.js";
+import { createMachineActor } from "./core/actors/create-machine-actor.js";
+import { createTransitionActor } from "./core/actors/create-transition-actor.js";
+import { createMachineReactor } from "./core/reactors/create-machine-reactor.js";
 //#region src/index.ts
 /**
 * Stream Processing Framework (SPF) for Video.js 10
 *
-* Bundle size target: < 20KB (minified + gzipped)
-* Primary use case: CMAF HLS playback with Video.js v10
+* The compositional primitives: createComposition, signals, tasks, actors,
+* reactors. Media-domain helpers and the HLS playback engine live behind
+* the `./dom` and `./hls` subpaths.
 *
 * @packageDocumentation
 */
 const VERSION = "0.1.0";
 //#endregion
-export { VERSION };
+export { ConcurrentRunner, SerialRunner, Task, VERSION, computed, createComposition, createMachineActor, createMachineReactor, createTransitionActor, defineBehavior, effect, makeShareSignals, signal, snapshot, untrack, update };
 
 //# sourceMappingURL=index.js.map

package/dist/dev/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/**\n * Stream Processing Framework (SPF) for Video.js 10\n *\n * Bundle size target: < 20KB (minified + gzipped)\n * Primary use case: CMAF HLS playback with Video.js v10\n *\n * @packageDocumentation\n */\n\n// Public API exports will be added here as features are implemented\n\nexport const VERSION = '0.1.0';\n"],"mappings":";;;;;;;;;AAWA,MAAa,UAAU"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/**\n * Stream Processing Framework (SPF) for Video.js 10\n *\n * The compositional primitives: createComposition, signals, tasks, actors,\n * reactors. Media-domain helpers and the HLS playback engine live behind\n * the `./dom` and `./hls` subpaths.\n *\n * @packageDocumentation\n */\n\nexport const VERSION = '0.1.0';\n\n// =============================================================================\n// Composition\n// =============================================================================\n\nexport type {\n  Behavior,\n  BehaviorCleanup,\n  BehaviorDeps,\n  Composition,\n  CompositionOptions,\n  ContextSignals,\n  InferBehaviorConfig,\n  InferBehaviorContext,\n  InferBehaviorState,\n  ResolveBehaviorConfig,\n  ResolveBehaviorContext,\n  ResolveBehaviorState,\n  StateSignals,\n} from './core/composition/create-composition';\nexport { createComposition, defineBehavior } from './core/composition/create-composition';\nexport type { ShareSignalsConfig } from './core/composition/share-signals';\nexport { makeShareSignals } from './core/composition/share-signals';\n\n// =============================================================================\n// Signals\n// =============================================================================\n\nexport { effect } from './core/signals/effect';\nexport type { Computed, ReadonlySignal, Signal, SignalOptions } from './core/signals/primitives';\nexport { computed, signal, snapshot, untrack, update } from './core/signals/primitives';\n\n// =============================================================================\n// Tasks\n// =============================================================================\n\nexport type { TaskConfig, TaskLike, TaskStatus } from './core/tasks/task';\nexport { ConcurrentRunner, SerialRunner, Task } from './core/tasks/task';\n\n// =============================================================================\n// Machine (shared by actors and reactors)\n// =============================================================================\n\nexport type { Machine, MachineSnapshot } from './core/machine';\n\n// =============================================================================\n// Actors\n// =============================================================================\n\nexport type { ActorSnapshot, CallbackActor, SignalActor } from './core/actors/actor';\nexport type {\n  ActorDefinition,\n  ActorStateDefinition,\n  HandlerContext,\n  MessageActor,\n  RunnerLike,\n} from './core/actors/create-machine-actor';\nexport { createMachineActor } from './core/actors/create-machine-actor';\nexport type { TransitionActor } from './core/actors/create-transition-actor';\nexport { createTransitionActor } from './core/actors/create-transition-actor';\n\n// =============================================================================\n// Reactors\n// =============================================================================\n\nexport type {\n  Reactor,\n  ReactorDefinition,\n  ReactorDeriveFn,\n  ReactorEffectFn,\n  ReactorStateDefinition,\n} from './core/reactors/create-machine-reactor';\nexport { createMachineReactor } from './core/reactors/create-machine-reactor';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAUA,MAAa,UAAU"}

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

@@ -0,0 +1,22 @@
+//#region src/media/abr/quality-selection.d.ts
+/**
+ * Quality selection configuration.
+ */
+interface QualityConfig {
+  /**
+   * Safety margin (0-1).
+   * To select a track, need: currentBandwidth >= track.bandwidth / safetyMargin.
+   * Default 0.85 means track must use ≤85% of available bandwidth (15% headroom).
+   */
+  safetyMargin: number;
+  /**
+   * Upgrade hysteresis ratio (>= 1). When `currentTrack` is supplied, an
+   * upgrade is applied only if `optimal.bandwidth >= currentTrack.bandwidth * upgradeMargin`.
+   * Downgrades are always applied. Default 1.15 means optimal must clear
+   * the current bandwidth by at least 15% to trigger an upgrade.
+   */
+  upgradeMargin: number;
+}
+//#endregion
+export { QualityConfig };
+//# sourceMappingURL=quality-selection.d.ts.map

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

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

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

@@ -0,0 +1,21 @@
+//#region src/media/abr/quality-selection.ts
+/**
+* Default quality selection configuration.
+* Values match Shaka Player upgrade threshold (0.85 = 15% headroom).
+*/
+const DEFAULT_QUALITY_CONFIG = {
+	safetyMargin: .85,
+	upgradeMargin: 1.15
+};
+/**
+* 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 resolutionArea(track) {
+	return (track.width ?? 0) * (track.height ?? 0);
+}
+//#endregion
+export { DEFAULT_QUALITY_CONFIG, resolutionArea };
+
+//# sourceMappingURL=quality-selection.js.map

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

@@ -0,0 +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 * 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;CAChB;;;;;;AAwHD,SAAgB,eAAe,OAAoD;AACjF,SAAQ,MAAM,SAAS,MAAM,MAAM,UAAU"}

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

@@ -0,0 +1,14 @@
+//#region src/media/buffer/back-buffer.d.ts
+/**
+ * Back buffer configuration.
+ */
+interface BackBufferConfig {
+  /**
+   * Number of segments to keep behind current playback position.
+   * Default: 2 segments.
+   */
+  keepSegments: number;
+}
+//#endregion
+export { BackBufferConfig };
+//# sourceMappingURL=back-buffer.d.ts.map

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

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

package/dist/dev/{core → media}/buffer/back-buffer.js

@@ -1,4 +1,4 @@
-//#region src/core/buffer/back-buffer.ts
+//#region src/media/buffer/back-buffer.ts
 /**
 * Default back buffer configuration.
 */
@@ -41,6 +41,6 @@ function calculateBackBufferFlushPoint(segments, currentTime, config = DEFAULT_B
 	return segmentsBefore[segmentsToFlush].startTime;
 }
 //#endregion
-export { calculateBackBufferFlushPoint };
+export { DEFAULT_BACK_BUFFER_CONFIG, calculateBackBufferFlushPoint };
 
 //# sourceMappingURL=back-buffer.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,14 @@
+//#region src/media/buffer/forward-buffer.d.ts
+/**
+ * Forward buffer configuration.
+ */
+interface ForwardBufferConfig {
+  /**
+   * Duration in seconds to buffer ahead of current playback position.
+   * Default: 30 seconds.
+   */
+  bufferDuration: number;
+}
+//#endregion
+export { ForwardBufferConfig };
+//# sourceMappingURL=forward-buffer.d.ts.map

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

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

package/dist/{default/core → dev/media}/buffer/forward-buffer.js

@@ -1,4 +1,4 @@
-//#region src/core/buffer/forward-buffer.ts
+//#region src/media/buffer/forward-buffer.ts
 /**
 * Default forward buffer configuration.
 */
@@ -56,6 +56,18 @@ function calculateForwardFlushPoint(bufferedSegments, currentTime, config = DEFA
 	if (beyond.length === 0) return Infinity;
 	return Math.min(...beyond.map((seg) => seg.startTime));
 }
+/**
+* Find the start time of the segment containing `currentTime` (or the last
+* segment if `currentTime` is past the end). Returns `undefined` when
+* `currentTime` is undefined or when no segment matches.
+*
+* Used to detect "meaningful currentTime change" — two times that map to the
+* same segment start aren't a load-trigger; crossing a segment boundary is.
+*/
+function segmentStartForTime(currentTime, segments) {
+	if (currentTime == null) return void 0;
+	return segments?.find(({ startTime, duration }, i, all) => currentTime >= startTime && (currentTime < startTime + duration || i === all.length - 1))?.startTime;
+}
 function getSegmentsToLoad(segments, bufferedSegments, currentTime, config = DEFAULT_FORWARD_BUFFER_CONFIG) {
 	if (segments.length === 0) return [];
 	const targetTime = currentTime + config.bufferDuration;
@@ -68,6 +80,6 @@ function getSegmentsToLoad(segments, bufferedSegments, currentTime, config = DEF
 	});
 }
 //#endregion
-export { DEFAULT_FORWARD_BUFFER_CONFIG, calculateForwardFlushPoint, getSegmentsToLoad };
+export { DEFAULT_FORWARD_BUFFER_CONFIG, calculateForwardFlushPoint, getSegmentsToLoad, segmentStartForTime };
 
 //# sourceMappingURL=forward-buffer.js.map

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

@@ -0,0 +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"}

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,KAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BpD,MAAa,gBAA8B,UAAU;AACnD,KAAI,MAAM,YAAY,yBAAyB,IAAI,MAAM,SAAS,CAAE,QAAO;AAC3E,KAAI,CAAC,MAAM,YAAY,CAAC,MAAM,QAAQ,OAAQ,QAAO;CACrD,MAAM,YAAY,eAAe;EAAE,UAAU,MAAM;EAAU,QAAQ,MAAM;EAAQ,CAAC;CACpF,MAAM,SAAS,kBAAkB,IAAI,UAAU;AAC/C,KAAI,WAAW,KAAA,EAAW,QAAO;CACjC,MAAM,YAAY,iBAAiB,UAAU;AAC7C,mBAAkB,IAAI,WAAW,UAAU;AAC3C,QAAO"}

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

@@ -1,4 +1,4 @@
-//#region src/dom/media/append-segment.d.ts
+//#region src/media/dom/mse/append-segment.d.ts
 /**
  * Segment appender helper.
  *

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

@@ -0,0 +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"}

package/dist/{default/dom/media → dev/media/dom/mse}/append-segment.js

@@ -1,4 +1,4 @@
-//#region src/dom/media/append-segment.ts
+//#region src/media/dom/mse/append-segment.ts
 /**
 * Append media data to a SourceBuffer.
 *

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

@@ -0,0 +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"}

package/dist/dev/{dom/media → media/dom/mse}/buffer-flusher.d.ts

@@ -1,4 +1,4 @@
-//#region src/dom/media/buffer-flusher.d.ts
+//#region src/media/dom/mse/buffer-flusher.d.ts
 /**
  * Buffer flusher helper (P12)
  *

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

@@ -0,0 +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"}

package/dist/dev/{dom/media → media/dom/mse}/buffer-flusher.js

@@ -1,4 +1,4 @@
-//#region src/dom/media/buffer-flusher.ts
+//#region src/media/dom/mse/buffer-flusher.ts
 /**
 * Buffer flusher helper (P12)
 *

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

@@ -0,0 +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"}

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

@@ -0,0 +1,78 @@
+import { hasPresentationDuration } from "../../types/index.js";
+//#region src/media/dom/mse/duration.ts
+/**
+* Check if we have the basics to update MediaSource duration:
+* a `mediaSource` and a `presentation` with a numeric duration.
+*/
+function canUpdateDuration(presentation, mediaSource) {
+	return !!(mediaSource && presentation && hasPresentationDuration(presentation));
+}
+/**
+* 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;
+}
+/**
+* Check if the preconditions are met to *attempt* a `mediaSource.duration`
+* write: a `mediaSource` is in scope and the presentation has a valid
+* positive duration (or `Infinity` for live).
+*
+* Does **not** check `mediaSource.readyState` or `mediaSource.duration` —
+* those are DOM properties the caller resolves at write time (e.g., by
+* `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after,
+* and guarding on the existing `mediaSource.duration` for idempotency).
+* Keeping these off the signal-driven predicate lets callers use this
+* inside reactor state derivation without smuggling non-reactive DOM
+* reads into `computed(...)`.
+*
+* `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity`
+* is how live playback signals an indefinite duration.
+*/
+function shouldUpdateDuration(presentation, mediaSource) {
+	if (!canUpdateDuration(presentation, mediaSource)) return false;
+	const duration = presentation.duration;
+	if (Number.isNaN(duration) || duration <= 0) return false;
+	return true;
+}
+/**
+* Wait for all currently-updating SourceBuffers in `buffers` to finish, or
+* until `signal` aborts — whichever fires first.
+*
+* The MSE spec forbids setting `MediaSource.duration` while any attached
+* SourceBuffer has `updating === true`. This defers until all are idle.
+* Listeners are registered with `{ signal }` so an abort tears them down
+* up-front rather than leaving them dangling until the next `updateend`.
+*/
+function waitForSourceBuffersReady(buffers, signal) {
+	if (signal.aborted) return Promise.resolve();
+	const updating = [];
+	for (const buf of buffers) if (buf.updating) updating.push(buf);
+	if (updating.length === 0) return Promise.resolve();
+	return new Promise((resolve) => {
+		let remaining = updating.length;
+		const onUpdateEnd = () => {
+			remaining--;
+			if (remaining === 0) resolve();
+		};
+		for (const buf of updating) buf.addEventListener("updateend", onUpdateEnd, {
+			once: true,
+			signal
+		});
+		signal.addEventListener("abort", () => resolve(), { once: true });
+	});
+}
+//#endregion
+export { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady };
+
+//# sourceMappingURL=duration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duration.js","names":[],"sources":["../../../../../src/media/dom/mse/duration.ts"],"sourcesContent":["/**\n * MediaSource duration helpers.\n *\n * Predicates and async primitives for propagating a presentation's duration\n * to `mediaSource.duration` under the MSE spec's constraints:\n *\n * - `duration` cannot be set while any attached SourceBuffer is `updating`.\n * - `duration` cannot be less than any buffered range's end time.\n *\n * The buffer-set helpers take a `SourceBufferList` (or any iterable of\n * `SourceBuffer`) — they operate uniformly across whatever buffers are\n * attached, so callers in audio-only, video-only, and mixed configurations\n * compose them without per-type plumbing. `mediaSource.sourceBuffers` is the\n * canonical aggregate.\n *\n * Consumed by `updateMediaSourceDuration` (DOM behavior) — kept here so the layering\n * stays clean: the predicates and wait helper are pure DOM/MSE primitives\n * with no `core/` reactivity.\n */\n\nimport type { MaybeResolvedPresentation } from '../../types';\nimport { hasPresentationDuration } from '../../types';\n\ntype SourceBufferIterable = SourceBufferList | Iterable<SourceBuffer>;\n\n/**\n * Check if we have the basics to update MediaSource duration:\n * a `mediaSource` and a `presentation` with a numeric duration.\n */\nexport function canUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  return !!(mediaSource && presentation && hasPresentationDuration(presentation));\n}\n\n/**\n * Get the maximum buffered end time across an iterable of SourceBuffers\n * (typically `mediaSource.sourceBuffers`). Returns `0` when the collection is\n * empty or no buffer has any buffered ranges.\n */\nexport function getMaxBufferedEnd(buffers: SourceBufferIterable): number {\n  let maxEnd = 0;\n\n  for (const buffer of buffers) {\n    const { buffered } = buffer;\n    if (buffered.length > 0) {\n      const end = buffered.end(buffered.length - 1);\n      if (end > maxEnd) {\n        maxEnd = end;\n      }\n    }\n  }\n\n  return maxEnd;\n}\n\n/**\n * Check if the preconditions are met to *attempt* a `mediaSource.duration`\n * write: a `mediaSource` is in scope and the presentation has a valid\n * positive duration (or `Infinity` for live).\n *\n * Does **not** check `mediaSource.readyState` or `mediaSource.duration` —\n * those are DOM properties the caller resolves at write time (e.g., by\n * `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after,\n * and guarding on the existing `mediaSource.duration` for idempotency).\n * Keeping these off the signal-driven predicate lets callers use this\n * inside reactor state derivation without smuggling non-reactive DOM\n * reads into `computed(...)`.\n *\n * `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity`\n * is how live playback signals an indefinite duration.\n */\nexport function shouldUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  if (!canUpdateDuration(presentation, mediaSource)) return false;\n\n  const duration = presentation!.duration!;\n\n  if (Number.isNaN(duration) || duration <= 0) return false;\n\n  return true;\n}\n\n/**\n * Wait for all currently-updating SourceBuffers in `buffers` to finish, or\n * until `signal` aborts — whichever fires first.\n *\n * The MSE spec forbids setting `MediaSource.duration` while any attached\n * SourceBuffer has `updating === true`. This defers until all are idle.\n * Listeners are registered with `{ signal }` so an abort tears them down\n * up-front rather than leaving them dangling until the next `updateend`.\n */\nexport function waitForSourceBuffersReady(buffers: SourceBufferIterable, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n\n  const updating: SourceBuffer[] = [];\n  for (const buf of buffers) {\n    if (buf.updating) updating.push(buf);\n  }\n\n  if (updating.length === 0) return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    let remaining = updating.length;\n    const onUpdateEnd = () => {\n      remaining--;\n      if (remaining === 0) resolve();\n    };\n\n    for (const buf of updating) {\n      buf.addEventListener('updateend', onUpdateEnd, { once: true, signal });\n    }\n\n    signal.addEventListener('abort', () => resolve(), { once: true });\n  });\n}\n"],"mappings":";;;;;;AA6BA,SAAgB,kBACd,cACA,aACS;AACT,QAAO,CAAC,EAAE,eAAe,gBAAgB,wBAAwB,aAAa;;;;;;;AAQhF,SAAgB,kBAAkB,SAAuC;CACvE,IAAI,SAAS;AAEb,MAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,EAAE,aAAa;AACrB,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,MAAM,SAAS,IAAI,SAAS,SAAS,EAAE;AAC7C,OAAI,MAAM,OACR,UAAS;;;AAKf,QAAO;;;;;;;;;;;;;;;;;;AAmBT,SAAgB,qBACd,cACA,aACS;AACT,KAAI,CAAC,kBAAkB,cAAc,YAAY,CAAE,QAAO;CAE1D,MAAM,WAAW,aAAc;AAE/B,KAAI,OAAO,MAAM,SAAS,IAAI,YAAY,EAAG,QAAO;AAEpD,QAAO;;;;;;;;;;;AAYT,SAAgB,0BAA0B,SAA+B,QAAoC;AAC3G,KAAI,OAAO,QAAS,QAAO,QAAQ,SAAS;CAE5C,MAAM,WAA2B,EAAE;AACnC,MAAK,MAAM,OAAO,QAChB,KAAI,IAAI,SAAU,UAAS,KAAK,IAAI;AAGtC,KAAI,SAAS,WAAW,EAAG,QAAO,QAAQ,SAAS;AAEnD,QAAO,IAAI,SAAe,YAAY;EACpC,IAAI,YAAY,SAAS;EACzB,MAAM,oBAAoB;AACxB;AACA,OAAI,cAAc,EAAG,UAAS;;AAGhC,OAAK,MAAM,OAAO,SAChB,KAAI,iBAAiB,aAAa,aAAa;GAAE,MAAM;GAAM;GAAQ,CAAC;AAGxE,SAAO,iBAAiB,eAAe,SAAS,EAAE,EAAE,MAAM,MAAM,CAAC;GACjE"}

package/dist/dev/media/dom/mse/end-of-stream.js

@@ -0,0 +1,20 @@
+//#region src/media/dom/mse/end-of-stream.ts
+/**
+* Check if the temporally last segment of `expectedSegments` is present in
+* `appendedSegments` and not marked partial.
+*
+* Compares by segment ID rather than by a pipeline flag, so the result
+* stays correct across quality switches (different tracks have different
+* segment IDs) and back-buffer flushes (flushed segment IDs are removed
+* from the appended list).
+*/
+function isLastSegmentAppended(expectedSegments, appendedSegments) {
+	if (expectedSegments.length === 0) return true;
+	const lastSeg = expectedSegments[expectedSegments.length - 1];
+	if (!lastSeg) return false;
+	return appendedSegments?.some((s) => s.id === lastSeg.id && !s.partial) ?? false;
+}
+//#endregion
+export { isLastSegmentAppended };
+
+//# sourceMappingURL=end-of-stream.js.map

package/dist/dev/media/dom/mse/end-of-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/media/dom/mse/end-of-stream.ts"],"sourcesContent":["/**\n * End-of-stream detection helpers.\n *\n * Pure predicate that compares a track's expected segment list against the\n * appended-segment list from an MSE SourceBufferActor's snapshot. Consumed\n * by the `endOfStream` playback behavior to decide when to call\n * `MediaSource.endOfStream()`.\n *\n * Kept here so the layering stays clean: predicate has no `core/`\n * reactivity and operates on plain segment lists extracted by the caller.\n */\n\n/**\n * Minimum information about an appended segment needed to decide whether\n * it counts toward end-of-stream readiness.\n *\n * Matches the shape of `SourceBufferActor`'s context segments — callers\n * typically pass `actor.snapshot.get().context.segments` directly.\n */\nexport interface AppendedSegment {\n  id: string;\n  /**\n   * True while a streaming append is in progress for this segment. A\n   * partial segment is still streaming — it does not count as the last\n   * segment being ready.\n   */\n  partial?: boolean;\n}\n\n/**\n * Check if the temporally last segment of `expectedSegments` is present in\n * `appendedSegments` and not marked partial.\n *\n * Compares by segment ID rather than by a pipeline flag, so the result\n * stays correct across quality switches (different tracks have different\n * segment IDs) and back-buffer flushes (flushed segment IDs are removed\n * from the appended list).\n */\nexport function isLastSegmentAppended(\n  expectedSegments: readonly { id: string }[],\n  appendedSegments: readonly AppendedSegment[] | undefined\n): boolean {\n  if (expectedSegments.length === 0) return true;\n  const lastSeg = expectedSegments[expectedSegments.length - 1];\n  if (!lastSeg) return false;\n  return appendedSegments?.some((s) => s.id === lastSeg.id && !s.partial) ?? false;\n}\n"],"mappings":";;;;;;;;;;AAsCA,SAAgB,sBACd,kBACA,kBACS;AACT,KAAI,iBAAiB,WAAW,EAAG,QAAO;CAC1C,MAAM,UAAU,iBAAiB,iBAAiB,SAAS;AAC3D,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO,kBAAkB,MAAM,MAAM,EAAE,OAAO,QAAQ,MAAM,CAAC,EAAE,QAAQ,IAAI"}