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

package/dist/default/playback/actors/text-track-segment-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"text-track-segment-loader.js","names":[],"sources":["../../../../src/playback/actors/text-track-segment-loader.ts"],"sourcesContent":["import { createMachineActor, type HandlerContext, type MessageActor } from '../../core/actors/create-machine-actor';\nimport { peek } from '../../core/signals/primitives';\nimport { SerialRunner, Task } from '../../core/tasks/task';\nimport {\n  DEFAULT_FORWARD_BUFFER_CONFIG,\n  type ForwardBufferConfig,\n  getSegmentsToLoad,\n} from '../../media/buffer/forward-buffer';\nimport type { Cue, Segment, TextTrack } from '../../media/types';\nimport type { TextTracksActor } from './text-tracks';\n\n// =============================================================================\n// Message / actor types\n// =============================================================================\n\n/**\n * Mirrors the v/a `SegmentLoaderMessage` shape. `range` carries the\n * forward-window anchor (`range.start` is treated as the load anchor;\n * the actor computes its own forward window internally via\n * `getSegmentsToLoad`). When `range` is omitted (metadata mode), this\n * actor is a no-op — text tracks have no init-segment concept.\n */\nexport type TextTrackSegmentLoaderMessage = {\n  type: 'load';\n  track: TextTrack;\n  range?: { start: number; end: number };\n};\n\n/** Finite states of the actor. */\nexport type TextTrackSegmentLoaderActorState = 'idle' | 'loading' | 'destroyed';\n\n/** Non-finite (extended) data managed by the actor. */\nexport interface TextTrackSegmentLoaderActorContext {\n  /**\n   * Track ID of the segment currently being fetched, or null. Paired\n   * with `inFlightSegmentId` so the continue-vs-preempt check survives\n   * cross-track segment-id collisions (e.g. each track starts at\n   * `seg-0`).\n   */\n  inFlightTrackId: string | null;\n  /**\n   * Segment ID currently being fetched, or null. Used together with\n   * `inFlightTrackId` by the `loading` state's `load` handler.\n   */\n  inFlightSegmentId: string | null;\n}\n\nexport type TextTrackSegmentLoaderActor = MessageActor<\n  TextTrackSegmentLoaderActorState,\n  TextTrackSegmentLoaderActorContext,\n  TextTrackSegmentLoaderMessage\n>;\n\n/**\n * Resolves a text-track segment URL into the array of cues it contains.\n *\n * \"Resolve\" because the fn covers both network fetch and parse into the\n * domain model. Host-agnostic — the concrete resolver (e.g. the\n * browser's native VTT resolver) is supplied at engine-assembly time,\n * so this actor stays DOM-free.\n */\nexport type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;\n\n/**\n * Configuration for `createTextTrackSegmentLoaderActor`. Spread over\n * `DEFAULT_FORWARD_BUFFER_CONFIG` to override individual forward-window\n * fields (e.g. `bufferDuration`). Text tracks don't have a back-buffer\n * concern — cues evict by their playhead-relative window at runtime —\n * so no `backBuffer` config field.\n */\nexport interface TextTrackSegmentLoaderActorConfig {\n  forwardBuffer?: Partial<ForwardBufferConfig>;\n}\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/** Internal load-task descriptor — one segment fetch + dispatch unit. */\ninterface TextLoadTask {\n  segment: Segment;\n  trackId: string;\n}\n\n/**\n * Loads text-track segments for a track and delegates cue management\n * to a TextTracksActor. Mirrors the v/a `SegmentLoaderActor` shape (FSM\n * with `idle` / `loading` and `inFlight*` context for continue-vs-preempt),\n * adapted to text:\n *\n * - No init segment, no flush ops (text cues don't need eviction — they're\n *   small and the playhead-relative window is enforced by the runtime).\n * - Single in-flight identity (`inFlightSegmentId`) — text has only the\n *   media-segment path, no init-segment path.\n *\n * Planning is done in the load handler on every incoming message:\n * `getSegmentsToLoad` filters to the forward window, then the segments\n * not already in `TextTracksActor`'s context are scheduled. When a new\n * `load` arrives mid-run, the handler replans and either:\n *\n * - **Continues**: the in-flight segment is still in the new plan →\n *   `abortPending` only, schedule the rest of the plan (minus the\n *   in-flight item, which covers its slot).\n * - **Preempts**: in-flight segment is no longer wanted (track switch,\n *   large seek out of window) → `abortAll`, schedule the new plan\n *   from scratch.\n *\n * The cue parser is injected so this factory is host-agnostic. A DOM\n * host supplies a VTT parser backed by `<track>`/`TextTrack` APIs; a\n * non-DOM host (worker, test fake, alternate runtime) supplies its own.\n */\nexport function createTextTrackSegmentLoaderActor<C extends Cue>(\n  textTracksActor: TextTracksActor<C>,\n  resolveSegment: TextTrackSegmentResolver<C>,\n  config: TextTrackSegmentLoaderActorConfig = {}\n): TextTrackSegmentLoaderActor {\n  type UserState = Exclude<TextTrackSegmentLoaderActorState, 'destroyed'>;\n  type Ctx = HandlerContext<UserState, TextTrackSegmentLoaderActorContext, () => SerialRunner>;\n\n  const forwardBufferConfig: ForwardBufferConfig = { ...DEFAULT_FORWARD_BUFFER_CONFIG, ...config.forwardBuffer };\n\n  /**\n   * Translate a load message into an ordered TextLoadTask list based on\n   * committed actor state. In-flight awareness is handled separately in\n   * the `loading` state's load handler.\n   *\n   * Metadata mode (no `range`) is a no-op for text — text tracks have\n   * no init-segment concept, so there's nothing to load until a range\n   * arrives via `'full-range'` dispatch.\n   */\n  const planTasks = (message: TextTrackSegmentLoaderMessage): TextLoadTask[] => {\n    const { track, range } = message;\n    if (!range) return [];\n    const trackId = track.id;\n    // Peek (don't track) the snapshot: the loader's `send` is typically\n    // invoked from inside the dispatcher's effect body, so a tracked\n    // `.get()` here would leak the textTracksActor snapshot into the\n    // dispatcher's dep set — every `add-cues` would re-fire the dispatcher\n    // and schedule duplicate loads.\n    const bufferedSegments = peek(textTracksActor.snapshot).context.segments[trackId] ?? [];\n    // `getSegmentsToLoad` uses the actor's threaded `forwardBufferConfig`\n    // to compute its forward-window; only `range.start` is consulted\n    // here as the playhead anchor. `range.end` is informational — it\n    // carries the dispatcher's intended window upper bound but doesn't\n    // override the actor's planning.\n    const segmentsToLoad = getSegmentsToLoad(track.segments, bufferedSegments, range.start, forwardBufferConfig);\n    return segmentsToLoad.map((segment) => ({ segment, trackId }));\n  };\n\n  /**\n   * Wraps a TextLoadTask into a Task that fetches + dispatches `add-cues`.\n   * Updates `inFlightSegmentId` around the fetch so the load handler can\n   * make accurate continue/preempt decisions.\n   */\n  const makeLoadTask = (op: TextLoadTask, { getContext, setContext }: Ctx): Task<void> => {\n    return new Task(async (signal) => {\n      if (signal.aborted) return;\n      setContext({ ...getContext(), inFlightTrackId: op.trackId, inFlightSegmentId: op.segment.id });\n      try {\n        const cues = await resolveSegment(op.segment.url);\n        if (signal.aborted) return;\n        textTracksActor.send({\n          type: 'add-cues',\n          meta: {\n            trackId: op.trackId,\n            id: op.segment.id,\n            startTime: op.segment.startTime,\n            duration: op.segment.duration,\n          },\n          cues,\n        });\n      } catch (error) {\n        // Graceful degradation: log and continue to the next segment.\n        console.error('Failed to load text-track segment:', error);\n      } finally {\n        setContext({ ...getContext(), inFlightTrackId: null, inFlightSegmentId: null });\n      }\n    });\n  };\n\n  const scheduleAll = (tasks: TextLoadTask[], ctx: Ctx): void => {\n    for (const op of tasks) {\n      ctx.runner.schedule(makeLoadTask(op, ctx)).then(undefined, (e: unknown) => {\n        if (e instanceof Error && e.name === 'AbortError') return;\n        console.error('Unexpected error in text-track segment loader:', e);\n        ctx.runner.abortPending();\n      });\n    }\n  };\n\n  return createMachineActor<\n    UserState,\n    TextTrackSegmentLoaderActorContext,\n    TextTrackSegmentLoaderMessage,\n    () => SerialRunner\n  >({\n    runner: () => new SerialRunner(),\n    initial: 'idle',\n    context: { inFlightTrackId: null, inFlightSegmentId: null },\n    states: {\n      idle: {\n        on: {\n          load: (msg, ctx) => {\n            const tasks = planTasks(msg);\n            if (tasks.length === 0) return;\n            ctx.transition('loading');\n            scheduleAll(tasks, ctx);\n          },\n        },\n      },\n      loading: {\n        onSettled: 'idle',\n        on: {\n          load: (msg, ctx) => {\n            const { context, runner } = ctx;\n            const tasks = planTasks(msg);\n\n            const inFlightStillNeeded =\n              context.inFlightTrackId !== null &&\n              context.inFlightSegmentId !== null &&\n              tasks.some((t) => t.trackId === context.inFlightTrackId && t.segment.id === context.inFlightSegmentId);\n\n            if (inFlightStillNeeded) {\n              // Continue: keep the in-flight fetch, schedule the rest.\n              runner.abortPending();\n              scheduleAll(\n                tasks.filter(\n                  (t) => !(t.trackId === context.inFlightTrackId && t.segment.id === context.inFlightSegmentId)\n                ),\n                ctx\n              );\n            } else {\n              // Preempt: abort everything (including in-flight) and replan.\n              runner.abortAll();\n              scheduleAll(tasks, ctx);\n            }\n          },\n        },\n      },\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+GA,SAAgB,kCACd,iBACA,gBACA,SAA4C,EAAE,EACjB;CAI7B,MAAM,sBAA2C;EAAE,GAAG;EAA+B,GAAG,OAAO;EAAe;;;;;;;;;;CAW9G,MAAM,aAAa,YAA2D;EAC5E,MAAM,EAAE,OAAO,UAAU;AACzB,MAAI,CAAC,MAAO,QAAO,EAAE;EACrB,MAAM,UAAU,MAAM;EAMtB,MAAM,mBAAmB,KAAK,gBAAgB,SAAS,CAAC,QAAQ,SAAS,YAAY,EAAE;AAOvF,SADuB,kBAAkB,MAAM,UAAU,kBAAkB,MAAM,OAAO,oBAAoB,CACtF,KAAK,aAAa;GAAE;GAAS;GAAS,EAAE;;;;;;;CAQhE,MAAM,gBAAgB,IAAkB,EAAE,YAAY,iBAAkC;AACtF,SAAO,IAAI,KAAK,OAAO,WAAW;AAChC,OAAI,OAAO,QAAS;AACpB,cAAW;IAAE,GAAG,YAAY;IAAE,iBAAiB,GAAG;IAAS,mBAAmB,GAAG,QAAQ;IAAI,CAAC;AAC9F,OAAI;IACF,MAAM,OAAO,MAAM,eAAe,GAAG,QAAQ,IAAI;AACjD,QAAI,OAAO,QAAS;AACpB,oBAAgB,KAAK;KACnB,MAAM;KACN,MAAM;MACJ,SAAS,GAAG;MACZ,IAAI,GAAG,QAAQ;MACf,WAAW,GAAG,QAAQ;MACtB,UAAU,GAAG,QAAQ;MACtB;KACD;KACD,CAAC;YACK,OAAO;AAEd,YAAQ,MAAM,sCAAsC,MAAM;aAClD;AACR,eAAW;KAAE,GAAG,YAAY;KAAE,iBAAiB;KAAM,mBAAmB;KAAM,CAAC;;IAEjF;;CAGJ,MAAM,eAAe,OAAuB,QAAmB;AAC7D,OAAK,MAAM,MAAM,MACf,KAAI,OAAO,SAAS,aAAa,IAAI,IAAI,CAAC,CAAC,KAAK,KAAA,IAAY,MAAe;AACzE,OAAI,aAAa,SAAS,EAAE,SAAS,aAAc;AACnD,WAAQ,MAAM,kDAAkD,EAAE;AAClE,OAAI,OAAO,cAAc;IACzB;;AAIN,QAAO,mBAKL;EACA,cAAc,IAAI,cAAc;EAChC,SAAS;EACT,SAAS;GAAE,iBAAiB;GAAM,mBAAmB;GAAM;EAC3D,QAAQ;GACN,MAAM,EACJ,IAAI,EACF,OAAO,KAAK,QAAQ;IAClB,MAAM,QAAQ,UAAU,IAAI;AAC5B,QAAI,MAAM,WAAW,EAAG;AACxB,QAAI,WAAW,UAAU;AACzB,gBAAY,OAAO,IAAI;MAE1B,EACF;GACD,SAAS;IACP,WAAW;IACX,IAAI,EACF,OAAO,KAAK,QAAQ;KAClB,MAAM,EAAE,SAAS,WAAW;KAC5B,MAAM,QAAQ,UAAU,IAAI;AAO5B,SAJE,QAAQ,oBAAoB,QAC5B,QAAQ,sBAAsB,QAC9B,MAAM,MAAM,MAAM,EAAE,YAAY,QAAQ,mBAAmB,EAAE,QAAQ,OAAO,QAAQ,kBAAkB,EAE/E;AAEvB,aAAO,cAAc;AACrB,kBACE,MAAM,QACH,MAAM,EAAE,EAAE,YAAY,QAAQ,mBAAmB,EAAE,QAAQ,OAAO,QAAQ,mBAC5E,EACD,IACD;YACI;AAEL,aAAO,UAAU;AACjB,kBAAY,OAAO,IAAI;;OAG5B;IACF;GACF;EACF,CAAC"}
+{"version":3,"file":"text-track-segment-loader.js","names":[],"sources":["../../../../src/playback/actors/text-track-segment-loader.ts"],"sourcesContent":["import { createMachineActor, type HandlerContext, type MessageActor } from '../../core/actors/create-machine-actor';\nimport { peek } from '../../core/signals/primitives';\nimport { SerialRunner, Task } from '../../core/tasks/task';\nimport {\n  DEFAULT_FORWARD_BUFFER_CONFIG,\n  type ForwardBufferConfig,\n  getSegmentsToLoad,\n} from '../../media/buffer/forward-buffer';\nimport type { Cue, TextTrack } from '../../media/types';\nimport {\n  DEFAULT_TEXT_MESSAGE_PIPELINES,\n  type TextFrame,\n  type TextLoadTask,\n  type TextMessagePipelines,\n  type TextStepDeps,\n  type TextTrackSegmentResolver,\n} from '../primitives/text-segment-load-pipeline';\nimport type { TextTracksActor } from './text-tracks';\n\n// =============================================================================\n// Message / actor types\n// =============================================================================\n\n/**\n * Mirrors the v/a `SegmentLoaderMessage` shape. `range` carries the\n * forward-window anchor (`range.start` is treated as the load anchor;\n * the actor computes its own forward window internally via\n * `getSegmentsToLoad`). When `range` is omitted (metadata mode), this\n * actor is a no-op — text tracks have no init-segment concept.\n */\nexport type TextTrackSegmentLoaderMessage = {\n  type: 'load';\n  track: TextTrack;\n  range?: { start: number; end: number };\n};\n\n/** Finite states of the actor. */\nexport type TextTrackSegmentLoaderActorState = 'idle' | 'loading' | 'destroyed';\n\n/** Non-finite (extended) data managed by the actor. */\nexport interface TextTrackSegmentLoaderActorContext {\n  /**\n   * Track ID of the segment currently being fetched, or null. Paired\n   * with `inFlightSegmentId` so the continue-vs-preempt check survives\n   * cross-track segment-id collisions (e.g. each track starts at\n   * `seg-0`).\n   */\n  inFlightTrackId: string | null;\n  /**\n   * Segment ID currently being fetched, or null. Used together with\n   * `inFlightTrackId` by the `loading` state's `load` handler.\n   */\n  inFlightSegmentId: string | null;\n}\n\nexport type TextTrackSegmentLoaderActor = MessageActor<\n  TextTrackSegmentLoaderActorState,\n  TextTrackSegmentLoaderActorContext,\n  TextTrackSegmentLoaderMessage\n>;\n\n/**\n * Configuration for `createTextTrackSegmentLoaderActor`. Spread over\n * `DEFAULT_FORWARD_BUFFER_CONFIG` to override individual forward-window\n * fields (e.g. `bufferDuration`). Text tracks don't have a back-buffer\n * concern — cues evict by their playhead-relative window at runtime —\n * so no `backBuffer` config field.\n */\nexport interface TextTrackSegmentLoaderActorConfig<C extends Cue = Cue> {\n  forwardBuffer?: Partial<ForwardBufferConfig>;\n  /** Ordered step pipeline. Defaults to {@link DEFAULT_TEXT_MESSAGE_PIPELINES} (`resolveCues → dispatchCues`). */\n  messagePipelines?: TextMessagePipelines<C>;\n}\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/**\n * Loads text-track segments for a track and delegates cue management\n * to a TextTracksActor. Mirrors the v/a `SegmentLoaderActor` shape (FSM\n * with `idle` / `loading` and `inFlight*` context for continue-vs-preempt),\n * adapted to text:\n *\n * - No init segment, no flush ops (text cues don't need eviction — they're\n *   small and the playhead-relative window is enforced by the runtime).\n * - Single in-flight identity (`inFlightSegmentId`) — text has only the\n *   media-segment path, no init-segment path.\n *\n * Planning is done in the load handler on every incoming message:\n * `getSegmentsToLoad` filters to the forward window, then the segments\n * not already in `TextTracksActor`'s context are scheduled. When a new\n * `load` arrives mid-run, the handler replans and either:\n *\n * - **Continues**: the in-flight segment is still in the new plan →\n *   `abortPending` only, schedule the rest of the plan (minus the\n *   in-flight item, which covers its slot).\n * - **Preempts**: in-flight segment is no longer wanted (track switch,\n *   large seek out of window) → `abortAll`, schedule the new plan\n *   from scratch.\n *\n * The cue parser is injected so this factory is host-agnostic. A DOM\n * host supplies a VTT parser backed by `<track>`/`TextTrack` APIs; a\n * non-DOM host (worker, test fake, alternate runtime) supplies its own.\n */\nexport function createTextTrackSegmentLoaderActor<C extends Cue>(\n  textTracksActor: TextTracksActor<C>,\n  resolveSegment: TextTrackSegmentResolver<C>,\n  config: TextTrackSegmentLoaderActorConfig<C> = {},\n  // Composition deps threaded opaquely into each step's `TextStepDeps` (relocation\n  // reads composition state). The loader never reads them. Defaults empty for\n  // standalone / base-pipeline use.\n  compositionDeps: TextStepDeps = { state: {}, context: {}, config: {} }\n): TextTrackSegmentLoaderActor {\n  type UserState = Exclude<TextTrackSegmentLoaderActorState, 'destroyed'>;\n  type Ctx = HandlerContext<UserState, TextTrackSegmentLoaderActorContext, () => SerialRunner>;\n\n  const forwardBufferConfig: ForwardBufferConfig = { ...DEFAULT_FORWARD_BUFFER_CONFIG, ...config.forwardBuffer };\n  // Fold the loader's wiring into the passthrough `config` (see `textStepWiring`) so\n  // base steps read it from the uniform `{state,context,config}` — present in both\n  // composition and standalone use.\n  const deps: TextStepDeps = {\n    state: compositionDeps.state,\n    context: compositionDeps.context,\n    config: { ...compositionDeps.config, textTracksActor, resolveSegment },\n  };\n  // Built once per actor; default is `resolveCues → dispatchCues`.\n  const pipeline = (config.messagePipelines ?? DEFAULT_TEXT_MESSAGE_PIPELINES)();\n\n  /**\n   * Translate a load message into an ordered TextLoadTask list based on\n   * committed actor state. In-flight awareness is handled separately in\n   * the `loading` state's load handler.\n   *\n   * Metadata mode (no `range`) is a no-op for text — text tracks have\n   * no init-segment concept, so there's nothing to load until a range\n   * arrives via `'full-range'` dispatch.\n   */\n  const planTasks = (message: TextTrackSegmentLoaderMessage): TextLoadTask[] => {\n    const { track, range } = message;\n    if (!range) return [];\n    const trackId = track.id;\n    // Peek (don't track) the snapshot: the loader's `send` is typically\n    // invoked from inside the dispatcher's effect body, so a tracked\n    // `.get()` here would leak the textTracksActor snapshot into the\n    // dispatcher's dep set — every `add-cues` would re-fire the dispatcher\n    // and schedule duplicate loads.\n    const bufferedSegments = peek(textTracksActor.snapshot).context.segments[trackId] ?? [];\n    // `getSegmentsToLoad` uses the actor's threaded `forwardBufferConfig`\n    // to compute its forward-window; only `range.start` is consulted\n    // here as the playhead anchor. `range.end` is informational — it\n    // carries the dispatcher's intended window upper bound but doesn't\n    // override the actor's planning.\n    const segmentsToLoad = getSegmentsToLoad(track.segments, bufferedSegments, range.start, forwardBufferConfig);\n    return segmentsToLoad.map((segment) => ({ segment, trackId }));\n  };\n\n  /**\n   * Wraps a TextLoadTask into a Task that runs the op's step pipeline\n   * (resolve/relocate/dispatch, per the composition's `messagePipelines`).\n   * Updates `inFlightSegmentId` around the async region so the load handler can\n   * make accurate continue/preempt decisions, and checks the abort signal before\n   * each step.\n   *\n   * Text degrades gracefully: a step throwing (e.g. a failed segment fetch) is\n   * logged and swallowed so the runner continues to the next segment — unlike the\n   * v/a loader, where a failed init must abort the remaining tasks.\n   */\n  const makeLoadTask = (op: TextLoadTask, { getContext, setContext }: Ctx): Task<void> => {\n    return new Task(async (signal) => {\n      if (signal.aborted) return;\n      const frame: TextFrame<C> = { op };\n      setContext({ ...getContext(), inFlightTrackId: op.trackId, inFlightSegmentId: op.segment.id });\n      try {\n        for (const step of pipeline) {\n          if (signal.aborted) return;\n          await step(frame, signal, deps);\n        }\n      } catch (error) {\n        // Graceful degradation: log and continue to the next segment.\n        console.error('Failed to load text-track segment:', error);\n      } finally {\n        setContext({ ...getContext(), inFlightTrackId: null, inFlightSegmentId: null });\n      }\n    });\n  };\n\n  const scheduleAll = (tasks: TextLoadTask[], ctx: Ctx): void => {\n    for (const op of tasks) {\n      ctx.runner.schedule(makeLoadTask(op, ctx)).then(undefined, (e: unknown) => {\n        if (e instanceof Error && e.name === 'AbortError') return;\n        console.error('Unexpected error in text-track segment loader:', e);\n        ctx.runner.abortPending();\n      });\n    }\n  };\n\n  return createMachineActor<\n    UserState,\n    TextTrackSegmentLoaderActorContext,\n    TextTrackSegmentLoaderMessage,\n    () => SerialRunner\n  >({\n    runner: () => new SerialRunner(),\n    initial: 'idle',\n    context: { inFlightTrackId: null, inFlightSegmentId: null },\n    states: {\n      idle: {\n        on: {\n          load: (msg, ctx) => {\n            const tasks = planTasks(msg);\n            if (tasks.length === 0) return;\n            ctx.transition('loading');\n            scheduleAll(tasks, ctx);\n          },\n        },\n      },\n      loading: {\n        onSettled: 'idle',\n        on: {\n          load: (msg, ctx) => {\n            const { context, runner } = ctx;\n            const tasks = planTasks(msg);\n\n            const inFlightStillNeeded =\n              context.inFlightTrackId !== null &&\n              context.inFlightSegmentId !== null &&\n              tasks.some((t) => t.trackId === context.inFlightTrackId && t.segment.id === context.inFlightSegmentId);\n\n            if (inFlightStillNeeded) {\n              // Continue: keep the in-flight fetch, schedule the rest.\n              runner.abortPending();\n              scheduleAll(\n                tasks.filter(\n                  (t) => !(t.trackId === context.inFlightTrackId && t.segment.id === context.inFlightSegmentId)\n                ),\n                ctx\n              );\n            } else {\n              // Preempt: abort everything (including in-flight) and replan.\n              runner.abortAll();\n              scheduleAll(tasks, ctx);\n            }\n          },\n        },\n      },\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyGA,SAAgB,kCACd,iBACA,gBACA,SAA+C,CAAC,GAIhD,kBAAgC;CAAE,OAAO,CAAC;CAAG,SAAS,CAAC;CAAG,QAAQ,CAAC;AAAE,GACxC;CAI7B,MAAM,sBAA2C;EAAE,GAAG;EAA+B,GAAG,OAAO;CAAc;CAI7G,MAAM,OAAqB;EACzB,OAAO,gBAAgB;EACvB,SAAS,gBAAgB;EACzB,QAAQ;GAAE,GAAG,gBAAgB;GAAQ;GAAiB;EAAe;CACvE;CAEA,MAAM,YAAY,OAAO,oBAAoB,+BAAA,CAAgC;;;;;;;;;;CAW7E,MAAM,aAAa,YAA2D;EAC5E,MAAM,EAAE,OAAO,UAAU;EACzB,IAAI,CAAC,OAAO,OAAO,CAAC;EACpB,MAAM,UAAU,MAAM;EAMtB,MAAM,mBAAmB,KAAK,gBAAgB,QAAQ,CAAC,CAAC,QAAQ,SAAS,YAAY,CAAC;EAOtF,OADuB,kBAAkB,MAAM,UAAU,kBAAkB,MAAM,OAAO,mBACpE,CAAC,CAAC,KAAK,aAAa;GAAE;GAAS;EAAQ,EAAE;CAC/D;;;;;;;;;;;;CAaA,MAAM,gBAAgB,IAAkB,EAAE,YAAY,iBAAkC;EACtF,OAAO,IAAI,KAAK,OAAO,WAAW;GAChC,IAAI,OAAO,SAAS;GACpB,MAAM,QAAsB,EAAE,GAAG;GACjC,WAAW;IAAE,GAAG,WAAW;IAAG,iBAAiB,GAAG;IAAS,mBAAmB,GAAG,QAAQ;GAAG,CAAC;GAC7F,IAAI;IACF,KAAK,MAAM,QAAQ,UAAU;KAC3B,IAAI,OAAO,SAAS;KACpB,MAAM,KAAK,OAAO,QAAQ,IAAI;IAChC;GACF,SAAS,OAAO;IAEd,QAAQ,MAAM,sCAAsC,KAAK;GAC3D,UAAU;IACR,WAAW;KAAE,GAAG,WAAW;KAAG,iBAAiB;KAAM,mBAAmB;IAAK,CAAC;GAChF;EACF,CAAC;CACH;CAEA,MAAM,eAAe,OAAuB,QAAmB;EAC7D,KAAK,MAAM,MAAM,OACf,IAAI,OAAO,SAAS,aAAa,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,KAAA,IAAY,MAAe;GACzE,IAAI,aAAa,SAAS,EAAE,SAAS,cAAc;GACnD,QAAQ,MAAM,kDAAkD,CAAC;GACjE,IAAI,OAAO,aAAa;EAC1B,CAAC;CAEL;CAEA,OAAO,mBAKL;EACA,cAAc,IAAI,aAAa;EAC/B,SAAS;EACT,SAAS;GAAE,iBAAiB;GAAM,mBAAmB;EAAK;EAC1D,QAAQ;GACN,MAAM,EACJ,IAAI,EACF,OAAO,KAAK,QAAQ;IAClB,MAAM,QAAQ,UAAU,GAAG;IAC3B,IAAI,MAAM,WAAW,GAAG;IACxB,IAAI,WAAW,SAAS;IACxB,YAAY,OAAO,GAAG;GACxB,EACF,EACF;GACA,SAAS;IACP,WAAW;IACX,IAAI,EACF,OAAO,KAAK,QAAQ;KAClB,MAAM,EAAE,SAAS,WAAW;KAC5B,MAAM,QAAQ,UAAU,GAAG;KAO3B,IAJE,QAAQ,oBAAoB,QAC5B,QAAQ,sBAAsB,QAC9B,MAAM,MAAM,MAAM,EAAE,YAAY,QAAQ,mBAAmB,EAAE,QAAQ,OAAO,QAAQ,iBAAiB,GAE9E;MAEvB,OAAO,aAAa;MACpB,YACE,MAAM,QACH,MAAM,EAAE,EAAE,YAAY,QAAQ,mBAAmB,EAAE,QAAQ,OAAO,QAAQ,kBAC7E,GACA,GACF;KACF,OAAO;MAEL,OAAO,SAAS;MAChB,YAAY,OAAO,GAAG;KACxB;IACF,EACF;GACF;EACF;CACF,CAAC;AACH"}

package/dist/default/playback/adapters/hls-audio/adapter.js

@@ -0,0 +1,186 @@
+import { effect } from "../../../core/signals/effect.js";
+import { SVTA_NO_SUPPORTED_AUDIO_TRACK, SVTA_UNSUPPORTED_PLAYBACK_FEATURE } from "../../../media/errors.js";
+import { createHlsAudioEngine } from "../../engines/hls/engine-audio-only.js";
+import { UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE } from "../../primitives/error-messages.js";
+import { firstFatal, hasUnsupportedFeatureCause, withAlternativeMediaSuggestion } from "../hls-video/error-surface.js";
+//#region src/playback/adapters/hls-audio/adapter.ts
+const hlsAudioMediaDefaultProps = {
+	src: "",
+	preload: "",
+	disableRemotePlayback: false
+};
+/**
+* Which reported conditions this composition treats as fatal. Only the audio
+* verdict: an audio-only engine composes no video selection, so
+* `SVTA_NO_SUPPORTED_VIDEO_TRACK` is never reported and surfacing it would
+* describe a track type this media doesn't have.
+*/
+const FATAL_SVTA_CODES = /* @__PURE__ */ new Set([SVTA_NO_SUPPORTED_AUDIO_TRACK]);
+/**
+* Mixin that adds SPF audio-only HLS playback to any base class.
+*
+* @fires error - Fired when a fatal condition is reported. Read `error` for it.
+*
+* Parallel to `HlsVideoMediaMixin` with one substantive difference: the
+* underlying engine is the audio-only variant (`createHlsAudioEngine`),
+* which omits video and text-track behaviors. The src / preload /
+* disableRemotePlayback / play() contract per the WHATWG HTML spec is identical
+* to the default adapter.
+*
+* Selecting this adapter is the variant decision: instantiating
+* `HlsAudioMediaElement` opts the consumer into audio-only
+* delivery even when the source is a mixed-AV HLS manifest.
+*
+* @example
+* class HlsAudioMedia extends HlsAudioMediaMixin(HTMLVideoElementHost) {}
+*
+* const media = new HlsAudioMedia();
+* media.attach(document.querySelector('video'));
+* media.src = 'https://stream.mux.com/abc123.m3u8';
+*/
+function HlsAudioMediaMixin(BaseClass) {
+	class HlsAudioMediaImpl extends BaseClass {
+		/**
+		* A complete sentence naming the Media to reach for when this one can't play
+		* a source. Appended to the copy this adapter logs.
+		*
+		* Empty here, and overridden the same way as on the video adapter — see its
+		* note. `hls-audio` has no better-equipped sibling of its own; the
+		* Mux audio Media built on this engine does, and points at the hls.js-backed
+		* one.
+		*/
+		static get alternativeMediaSuggestion() {}
+		#engine;
+		#config;
+		#signals;
+		#preload = hlsAudioMediaDefaultProps.preload;
+		#disableRemotePlayback = hlsAudioMediaDefaultProps.disableRemotePlayback;
+		#error = null;
+		/** Reported condition currently surfaced — see the video adapter's note. */
+		#reportedCode = null;
+		#stopErrorSync;
+		/** Pending loadstart listener from a deferred play() retry, if any. */
+		#loadstartListener = null;
+		constructor(...args) {
+			super(...args);
+			const { config } = args?.[0] ?? {};
+			this.#config = config;
+			this.#engine = this.#createEngine();
+			this.#stopErrorSync = effect(() => {
+				const errors = this.#signals.state.errors.get();
+				this.#setError(firstFatal(errors, FATAL_SVTA_CODES), errors);
+			});
+		}
+		/**
+		* The current fatal error, or `null`. Only *fatal* conditions appear here —
+		* the engine reports non-fatal ones too, which stay in `engine.state.errors`.
+		* Resets per source. Fires `'error'` when set.
+		*/
+		get error() {
+			return this.#error;
+		}
+		#setError(reported, errors) {
+			if (!reported) {
+				this.#error = null;
+				this.#reportedCode = null;
+				return;
+			}
+			if (this.#reportedCode === reported.code) return;
+			this.#reportedCode = reported.code;
+			const unsupported = hasUnsupportedFeatureCause(errors);
+			if (unsupported) console.error(this.#withSuggestion(UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE), { conditions: errors });
+			this.#error = {
+				code: unsupported ? SVTA_UNSUPPORTED_PLAYBACK_FEATURE : reported.code,
+				message: reported.message ?? "",
+				...reported.data === void 0 ? {} : { data: reported.data }
+			};
+			this.dispatchEvent?.(new Event("error"));
+		}
+		/**
+		* Underlying playback engine — the low-level SPF reactive composition that
+		* drives playback. An advanced escape hatch for direct engine access;
+		* normal playback is driven through this element's own properties and
+		* methods.
+		*/
+		get engine() {
+			return this.#engine;
+		}
+		attach(mediaElement) {
+			super.attach?.(mediaElement);
+			this.#signals.context.mediaElement.set(mediaElement);
+		}
+		detach() {
+			this.#cancelPendingPlay();
+			this.#signals.context.mediaElement.set(void 0);
+			super.detach?.();
+		}
+		destroy() {
+			this.#cancelPendingPlay();
+			this.#stopErrorSync();
+			this.#engine.destroy();
+		}
+		/** Preload type (`'none'` / `'metadata'` / `'auto'`). */
+		get preload() {
+			return this.#preload;
+		}
+		set preload(value) {
+			this.#preload = value;
+			if (value) this.#signals.state.preload.set(value);
+		}
+		get disableRemotePlayback() {
+			return this.#disableRemotePlayback;
+		}
+		set disableRemotePlayback(value) {
+			this.#disableRemotePlayback = value;
+			this.#signals.state.disableRemotePlayback.set(value);
+		}
+		get src() {
+			return this.#signals.state.presentation.get()?.url ?? "";
+		}
+		set src(value) {
+			if (value === this.src) return;
+			this.#cancelPendingPlay();
+			this.#signals.state.presentation.set(value ? { url: value } : void 0);
+		}
+		play() {
+			const mediaElement = this.#signals.context.mediaElement.get();
+			if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("HlsAudioMediaElement: no media element attached"));
+			this.#signals.state.loadActivated.set(true);
+			return mediaElement.play().catch((err) => {
+				if (this.src) return new Promise((resolve, reject) => {
+					const listener = () => {
+						this.#loadstartListener = null;
+						mediaElement.play().then(resolve, reject);
+					};
+					this.#loadstartListener = listener;
+					mediaElement.addEventListener("loadstart", listener, { once: true });
+				});
+				throw err;
+			});
+		}
+		/** `message`, plus the alternative-Media sentence when this class names one. */
+		#withSuggestion(message) {
+			return withAlternativeMediaSuggestion(message, this);
+		}
+		#createEngine() {
+			return createHlsAudioEngine({
+				...this.#config,
+				onSignalsReady: (signals) => {
+					this.#signals = signals;
+				}
+			});
+		}
+		#cancelPendingPlay() {
+			if (!this.#loadstartListener) return;
+			this.#signals.context.mediaElement.get()?.removeEventListener("loadstart", this.#loadstartListener);
+			this.#loadstartListener = null;
+		}
+	}
+	return HlsAudioMediaImpl;
+}
+/** Standalone SPF audio-only media adapter with no base class. */
+var HlsAudioMediaElement = class extends HlsAudioMediaMixin(class {}) {};
+//#endregion
+export { HlsAudioMediaElement, HlsAudioMediaMixin, hlsAudioMediaDefaultProps };
+
+//# sourceMappingURL=adapter.js.map

package/dist/default/playback/adapters/hls-audio/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","names":["#engine","#config","#createEngine","#stopErrorSync","#signals","#setError","#error","#reportedCode","#withSuggestion","#cancelPendingPlay","#preload","#disableRemotePlayback","#loadstartListener"],"sources":["../../../../../src/playback/adapters/hls-audio/adapter.ts"],"sourcesContent":["import type { Constructor, MixinReturn } from '@videojs/utils/types';\nimport type { Composition } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport {\n  SVTA_NO_SUPPORTED_AUDIO_TRACK,\n  SVTA_UNSUPPORTED_PLAYBACK_FEATURE,\n  type SvtaError,\n} from '../../../media/errors';\nimport {\n  createHlsAudioEngine,\n  type HlsAudioEngineConfig,\n  type HlsAudioEngineContext,\n  type HlsAudioEngineSignals,\n  type HlsAudioEngineState,\n} from '../../engines/hls/engine-audio-only';\nimport { UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE } from '../../primitives/error-messages';\nimport {\n  firstFatal,\n  type HlsVideoMediaError,\n  hasUnsupportedFeatureCause,\n  withAlternativeMediaSuggestion,\n} from '../hls-video/error-surface';\n\nexport interface HlsAudioMediaProps {\n  src: string;\n  preload: '' | 'none' | 'metadata' | 'auto';\n  disableRemotePlayback: boolean;\n}\n\nexport const hlsAudioMediaDefaultProps: HlsAudioMediaProps = {\n  src: '',\n  preload: '',\n  disableRemotePlayback: false,\n};\n\nexport interface HlsAudioMediaAPI extends HlsAudioMediaProps {\n  readonly engine: Composition<HlsAudioEngineState, HlsAudioEngineContext>;\n  readonly error: HlsVideoMediaError | null;\n  attach(mediaElement: HTMLMediaElement): void;\n  detach(): void;\n  destroy(): void;\n  play(): Promise<void>;\n}\n\n/**\n * Which reported conditions this composition treats as fatal. Only the audio\n * verdict: an audio-only engine composes no video selection, so\n * `SVTA_NO_SUPPORTED_VIDEO_TRACK` is never reported and surfacing it would\n * describe a track type this media doesn't have.\n */\nconst FATAL_SVTA_CODES: ReadonlySet<number> = new Set<number>([SVTA_NO_SUPPORTED_AUDIO_TRACK]);\n\n/**\n * Mixin that adds SPF audio-only HLS playback to any base class.\n *\n * @fires error - Fired when a fatal condition is reported. Read `error` for it.\n *\n * Parallel to `HlsVideoMediaMixin` with one substantive difference: the\n * underlying engine is the audio-only variant (`createHlsAudioEngine`),\n * which omits video and text-track behaviors. The src / preload /\n * disableRemotePlayback / play() contract per the WHATWG HTML spec is identical\n * to the default adapter.\n *\n * Selecting this adapter is the variant decision: instantiating\n * `HlsAudioMediaElement` opts the consumer into audio-only\n * delivery even when the source is a mixed-AV HLS manifest.\n *\n * @example\n * class HlsAudioMedia extends HlsAudioMediaMixin(HTMLVideoElementHost) {}\n *\n * const media = new HlsAudioMedia();\n * media.attach(document.querySelector('video'));\n * media.src = 'https://stream.mux.com/abc123.m3u8';\n */\nexport function HlsAudioMediaMixin<Base extends Constructor<any>>(BaseClass: Base) {\n  class HlsAudioMediaImpl extends BaseClass {\n    /**\n     * A complete sentence naming the Media to reach for when this one can't play\n     * a source. Appended to the copy this adapter logs.\n     *\n     * Empty here, and overridden the same way as on the video adapter — see its\n     * note. `hls-audio` has no better-equipped sibling of its own; the\n     * Mux audio Media built on this engine does, and points at the hls.js-backed\n     * one.\n     */\n    static get alternativeMediaSuggestion(): string | undefined {\n      return undefined;\n    }\n\n    readonly #engine: Composition<HlsAudioEngineState, HlsAudioEngineContext>;\n    #config: HlsAudioEngineConfig;\n    #signals!: HlsAudioEngineSignals;\n    #preload: '' | 'none' | 'metadata' | 'auto' = hlsAudioMediaDefaultProps.preload;\n    #disableRemotePlayback: boolean = hlsAudioMediaDefaultProps.disableRemotePlayback;\n    #error: HlsVideoMediaError | null = null;\n    /** Reported condition currently surfaced — see the video adapter's note. */\n    #reportedCode: number | null = null;\n    #stopErrorSync: () => void;\n\n    /** Pending loadstart listener from a deferred play() retry, if any. */\n    #loadstartListener: (() => void) | null = null;\n\n    constructor(...args: any[]) {\n      super(...args);\n\n      const { config } = args?.[0] ?? {};\n      this.#config = config;\n      this.#engine = this.#createEngine();\n\n      // Promote the first fatal condition out of the engine's reported sequence\n      // onto the media surface. Clearing rides the same signal: `collectErrors`\n      // resets the slot per source, so a new source starts with no error without\n      // this needing its own source-change hook.\n      this.#stopErrorSync = effect(() => {\n        const errors = this.#signals.state.errors.get();\n        this.#setError(firstFatal(errors, FATAL_SVTA_CODES), errors);\n      });\n    }\n\n    /**\n     * The current fatal error, or `null`. Only *fatal* conditions appear here —\n     * the engine reports non-fatal ones too, which stay in `engine.state.errors`.\n     * Resets per source. Fires `'error'` when set.\n     */\n    get error(): HlsVideoMediaError | null {\n      return this.#error;\n    }\n\n    #setError(reported: SvtaError | undefined, errors: readonly SvtaError[] | undefined): void {\n      if (!reported) {\n        // Cleared (new source). No event: `'error'` announces a failure, and\n        // consumers reset their own copy on source change.\n        this.#error = null;\n        this.#reportedCode = null;\n        return;\n      }\n      // Keyed on the code, not the object: a later append re-runs this effect\n      // with an equal-but-new array, and re-firing `'error'` for a condition\n      // already surfaced would look like a second failure.\n      if (this.#reportedCode === reported.code) return;\n      this.#reportedCode = reported.code;\n\n      // See the video adapter: a cause this engine can't implement is what the\n      // consumer needs, so it replaces the verdict's code on the surface.\n      const unsupported = hasUnsupportedFeatureCause(errors);\n      if (unsupported) {\n        console.error(this.#withSuggestion(UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE), { conditions: errors });\n      }\n\n      this.#error = {\n        code: unsupported ? SVTA_UNSUPPORTED_PLAYBACK_FEATURE : reported.code,\n        message: reported.message ?? '',\n        ...(reported.data === undefined ? {} : { data: reported.data }),\n      };\n      this.dispatchEvent?.(new Event('error'));\n    }\n\n    /**\n     * Underlying playback engine — the low-level SPF reactive composition that\n     * drives playback. An advanced escape hatch for direct engine access;\n     * normal playback is driven through this element's own properties and\n     * methods.\n     */\n    get engine(): Composition<HlsAudioEngineState, HlsAudioEngineContext> {\n      return this.#engine;\n    }\n\n    // -------------------------------------------------------------------------\n    // Media element lifecycle\n    // -------------------------------------------------------------------------\n\n    attach(mediaElement: HTMLMediaElement): void {\n      super.attach?.(mediaElement);\n      this.#signals.context.mediaElement.set(mediaElement);\n    }\n\n    detach(): void {\n      this.#cancelPendingPlay();\n      this.#signals.context.mediaElement.set(undefined);\n      super.detach?.();\n    }\n\n    destroy(): void {\n      this.#cancelPendingPlay();\n      this.#stopErrorSync();\n      this.#engine.destroy();\n    }\n\n    // -------------------------------------------------------------------------\n    // preload — synchronous IDL attribute (WHATWG §4.8.11.2)\n    // -------------------------------------------------------------------------\n\n    /** Preload type (`'none'` / `'metadata'` / `'auto'`). */\n    get preload(): '' | 'none' | 'metadata' | 'auto' {\n      return this.#preload;\n    }\n\n    set preload(value: '' | 'none' | 'metadata' | 'auto') {\n      this.#preload = value;\n      if (value) {\n        this.#signals.state.preload.set(value);\n      }\n    }\n\n    // -------------------------------------------------------------------------\n    // disableRemotePlayback — synchronous IDL attribute (WHATWG Remote Playback)\n    // Author intent for whether the AirPlay/remote picker is offered. Mirrors\n    // the DOM attribute name; the value flows to `state.disableRemotePlayback`,\n    // which `setupAirPlay` reads to honor an explicit opt-out. The underlying\n    // media element's own `disableRemotePlayback` stays programmatically managed\n    // (ManagedMediaSource needs it `true` to open; AirPlay flips it `false` once\n    // the source is open), so author intent and the effective flag stay distinct.\n    // -------------------------------------------------------------------------\n\n    get disableRemotePlayback(): boolean {\n      return this.#disableRemotePlayback;\n    }\n\n    set disableRemotePlayback(value: boolean) {\n      this.#disableRemotePlayback = value;\n      this.#signals.state.disableRemotePlayback.set(value);\n    }\n\n    // -------------------------------------------------------------------------\n    // src — synchronous IDL attribute (WHATWG §4.8.11.2)\n    // Each assignment overwrites the engine's presentation state in place. The\n    // resolver FSM routes back through teardown → rebuild on the same engine,\n    // mirroring how the browser's load algorithm resets media state on src change\n    // — without recreating the engine or re-capturing its signals. Setting an\n    // empty src un-resolves the presentation, tearing the current source down to\n    // the engine's fresh-but-attached \"no source\" state.\n    // -------------------------------------------------------------------------\n\n    get src(): string {\n      return this.#signals.state.presentation.get()?.url ?? '';\n    }\n\n    set src(value: string) {\n      // Unchanged URL, no reload — see the video adapter's note.\n      if (value === this.src) return;\n\n      this.#cancelPendingPlay();\n      this.#signals.state.presentation.set(value ? { url: value } : undefined);\n    }\n\n    // -------------------------------------------------------------------------\n    // play() — WHATWG §4.8.11.8\n    // -------------------------------------------------------------------------\n\n    play(): Promise<void> {\n      const mediaElement = this.#signals.context.mediaElement.get();\n      if (!mediaElement) {\n        return Promise.reject(new Error('HlsAudioMediaElement: no media element attached'));\n      }\n\n      this.#signals.state.loadActivated.set(true);\n\n      return mediaElement.play().catch((err: unknown) => {\n        if (this.src) {\n          return new Promise<void>((resolve, reject) => {\n            const listener = () => {\n              this.#loadstartListener = null;\n              mediaElement.play().then(resolve, reject);\n            };\n            this.#loadstartListener = listener;\n            mediaElement.addEventListener('loadstart', listener, { once: true });\n          });\n        }\n        throw err;\n      });\n    }\n\n    // -------------------------------------------------------------------------\n    // Private\n    // -------------------------------------------------------------------------\n\n    /** `message`, plus the alternative-Media sentence when this class names one. */\n    #withSuggestion(message: string): string {\n      return withAlternativeMediaSuggestion(message, this);\n    }\n\n    #createEngine(): Composition<HlsAudioEngineState, HlsAudioEngineContext> {\n      return createHlsAudioEngine({\n        ...this.#config,\n        onSignalsReady: (signals) => {\n          this.#signals = signals;\n        },\n      });\n    }\n\n    #cancelPendingPlay(): void {\n      if (!this.#loadstartListener) return;\n      const mediaElement = this.#signals.context.mediaElement.get();\n      mediaElement?.removeEventListener('loadstart', this.#loadstartListener);\n      this.#loadstartListener = null;\n    }\n  }\n\n  // `MixinReturn` sources statics from `Base`, so the adapter's own static needs\n  // adding back to the type or callers can't read it.\n  return HlsAudioMediaImpl as unknown as MixinReturn<Base, HlsAudioMediaAPI> & {\n    readonly alternativeMediaSuggestion: string | undefined;\n  };\n}\n\n/** Standalone SPF audio-only media adapter with no base class. */\nexport class HlsAudioMediaElement extends HlsAudioMediaMixin(class {}) {}\n"],"mappings":";;;;;;AA6BA,MAAa,4BAAgD;CAC3D,KAAK;CACL,SAAS;CACT,uBAAuB;AACzB;;;;;;;AAiBA,MAAM,mCAAwC,IAAI,IAAY,CAAC,6BAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwB7F,SAAgB,mBAAkD,WAAiB;CACjF,MAAM,0BAA0B,UAAU;;;;;;;;;;EAUxC,WAAW,6BAAiD,CAE5D;EAEA;EACA;EACA;EACA,WAA8C,0BAA0B;EACxE,yBAAkC,0BAA0B;EAC5D,SAAoC;;EAEpC,gBAA+B;EAC/B;;EAGA,qBAA0C;EAE1C,YAAY,GAAG,MAAa;GAC1B,MAAM,GAAG,IAAI;GAEb,MAAM,EAAE,WAAW,OAAO,MAAM,CAAC;GACjC,KAAKC,UAAU;GACf,KAAKD,UAAU,KAAKE,cAAc;GAMlC,KAAKC,iBAAiB,aAAa;IACjC,MAAM,SAAS,KAAKC,SAAS,MAAM,OAAO,IAAI;IAC9C,KAAKC,UAAU,WAAW,QAAQ,gBAAgB,GAAG,MAAM;GAC7D,CAAC;EACH;;;;;;EAOA,IAAI,QAAmC;GACrC,OAAO,KAAKC;EACd;EAEA,UAAU,UAAiC,QAAgD;GACzF,IAAI,CAAC,UAAU;IAGb,KAAKA,SAAS;IACd,KAAKC,gBAAgB;IACrB;GACF;GAIA,IAAI,KAAKA,kBAAkB,SAAS,MAAM;GAC1C,KAAKA,gBAAgB,SAAS;GAI9B,MAAM,cAAc,2BAA2B,MAAM;GACrD,IAAI,aACF,QAAQ,MAAM,KAAKC,gBAAgB,oCAAoC,GAAG,EAAE,YAAY,OAAO,CAAC;GAGlG,KAAKF,SAAS;IACZ,MAAM,cAAc,oCAAoC,SAAS;IACjE,SAAS,SAAS,WAAW;IAC7B,GAAI,SAAS,SAAS,KAAA,IAAY,CAAC,IAAI,EAAE,MAAM,SAAS,KAAK;GAC/D;GACA,KAAK,gBAAgB,IAAI,MAAM,OAAO,CAAC;EACzC;;;;;;;EAQA,IAAI,SAAkE;GACpE,OAAO,KAAKN;EACd;EAMA,OAAO,cAAsC;GAC3C,MAAM,SAAS,YAAY;GAC3B,KAAKI,SAAS,QAAQ,aAAa,IAAI,YAAY;EACrD;EAEA,SAAe;GACb,KAAKK,mBAAmB;GACxB,KAAKL,SAAS,QAAQ,aAAa,IAAI,KAAA,CAAS;GAChD,MAAM,SAAS;EACjB;EAEA,UAAgB;GACd,KAAKK,mBAAmB;GACxB,KAAKN,eAAe;GACpB,KAAKH,QAAQ,QAAQ;EACvB;;EAOA,IAAI,UAA6C;GAC/C,OAAO,KAAKU;EACd;EAEA,IAAI,QAAQ,OAA0C;GACpD,KAAKA,WAAW;GAChB,IAAI,OACF,KAAKN,SAAS,MAAM,QAAQ,IAAI,KAAK;EAEzC;EAYA,IAAI,wBAAiC;GACnC,OAAO,KAAKO;EACd;EAEA,IAAI,sBAAsB,OAAgB;GACxC,KAAKA,yBAAyB;GAC9B,KAAKP,SAAS,MAAM,sBAAsB,IAAI,KAAK;EACrD;EAYA,IAAI,MAAc;GAChB,OAAO,KAAKA,SAAS,MAAM,aAAa,IAAI,CAAC,EAAE,OAAO;EACxD;EAEA,IAAI,IAAI,OAAe;GAErB,IAAI,UAAU,KAAK,KAAK;GAExB,KAAKK,mBAAmB;GACxB,KAAKL,SAAS,MAAM,aAAa,IAAI,QAAQ,EAAE,KAAK,MAAM,IAAI,KAAA,CAAS;EACzE;EAMA,OAAsB;GACpB,MAAM,eAAe,KAAKA,SAAS,QAAQ,aAAa,IAAI;GAC5D,IAAI,CAAC,cACH,OAAO,QAAQ,uBAAO,IAAI,MAAM,iDAAiD,CAAC;GAGpF,KAAKA,SAAS,MAAM,cAAc,IAAI,IAAI;GAE1C,OAAO,aAAa,KAAK,CAAC,CAAC,OAAO,QAAiB;IACjD,IAAI,KAAK,KACP,OAAO,IAAI,SAAe,SAAS,WAAW;KAC5C,MAAM,iBAAiB;MACrB,KAAKQ,qBAAqB;MAC1B,aAAa,KAAK,CAAC,CAAC,KAAK,SAAS,MAAM;KAC1C;KACA,KAAKA,qBAAqB;KAC1B,aAAa,iBAAiB,aAAa,UAAU,EAAE,MAAM,KAAK,CAAC;IACrE,CAAC;IAEH,MAAM;GACR,CAAC;EACH;;EAOA,gBAAgB,SAAyB;GACvC,OAAO,+BAA+B,SAAS,IAAI;EACrD;EAEA,gBAAyE;GACvE,OAAO,qBAAqB;IAC1B,GAAG,KAAKX;IACR,iBAAiB,YAAY;KAC3B,KAAKG,WAAW;IAClB;GACF,CAAC;EACH;EAEA,qBAA2B;GACzB,IAAI,CAAC,KAAKQ,oBAAoB;GAE9B,KAD0BR,SAAS,QAAQ,aAAa,IAC7C,CAAC,EAAE,oBAAoB,aAAa,KAAKQ,kBAAkB;GACtE,KAAKA,qBAAqB;EAC5B;CACF;CAIA,OAAO;AAGT;;AAGA,IAAa,uBAAb,cAA0C,mBAAmB,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/default/playback/adapters/hls-audio/media.js

@@ -0,0 +1,9 @@
+import { HlsAudioMediaMixin } from "./adapter.js";
+import { HTMLAudioElementHost } from "@videojs/media/dom/audio-host";
+//#region src/playback/adapters/hls-audio/media.ts
+const HlsAudioMediaBase = HlsAudioMediaMixin(HTMLAudioElementHost);
+var HlsAudioMedia = class extends HlsAudioMediaBase {};
+//#endregion
+export { HlsAudioMedia };
+
+//# sourceMappingURL=media.js.map

package/dist/default/playback/adapters/hls-audio/media.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.js","names":[],"sources":["../../../../../src/playback/adapters/hls-audio/media.ts"],"sourcesContent":["import { HTMLAudioElementHost } from '@videojs/media/dom/audio-host';\nimport { HlsAudioMediaMixin } from './adapter';\n\nconst HlsAudioMediaBase = HlsAudioMediaMixin(HTMLAudioElementHost);\n\nexport class HlsAudioMedia extends HlsAudioMediaBase {}\n"],"mappings":";;;AAGA,MAAM,oBAAoB,mBAAmB,oBAAoB;AAEjE,IAAa,gBAAb,cAAmC,kBAAkB,CAAC"}

package/dist/default/playback/adapters/hls-background-video/adapter.js

@@ -0,0 +1,123 @@
+import { pickTrackUnderPixelArea } from "../../../media/primitives/select-tracks.js";
+import { createBackgroundVideoEngine } from "../../engines/hls/engine-background-video.js";
+//#region src/playback/adapters/hls-background-video/adapter.ts
+const hlsBackgroundVideoMediaDefaultProps = { src: "" };
+/**
+* Mixin that adds the background-video SPF playback engine to any base class,
+* for an HLS URL.
+*
+* `src` is the whole surface, and the picker always pins the top rendition on
+* offer. There is no cap of its own because the manifest is the better place to
+* narrow one: a delivery param — `?max_resolution=720p` on a Mux stream URL, for
+* one — keeps the renditions it excludes out of the manifest entirely, rather
+* than fetched-then-unpicked. Deriving a cap from the screen instead is on the
+* roadmap, and lands here when it does.
+*
+* `@videojs/spf/mux-background-video` is this same Media under a Mux-flavored
+* name — an alias, not a variant. Nothing about the surface changes with the
+* import path.
+*
+* Everything else the use case fixes rather than exposes: video-only, looping,
+* muted, autoplaying, loading as soon as there is a source. `attach` writes that
+* onto the element and nothing here declares `loop` / `muted` / `autoplay` /
+* `preload` of its own — a host-bound Media inherits all four from the host
+* already, and shadowing them with fixed values would only make reads describe
+* an intention rather than what the element is doing.
+*
+* A new src re-resolves the presentation, tearing down the state, SourceBuffers,
+* and in-flight requests the previous one built before the next begins. The
+* engine instance and the attached media element are both kept, so neither has to
+* be rewired.
+*
+* @example
+* class HlsBackgroundVideoMedia extends HlsBackgroundVideoMediaMixin(BackgroundVideoHost) {}
+*
+* const media = new HlsBackgroundVideoMedia();
+* media.attach(document.querySelector('video'));
+* media.src = 'https://stream.mux.com/PLAYBACK_ID.m3u8?max_resolution=720p';
+* media.play();
+*/
+function HlsBackgroundVideoMediaMixin(BaseClass) {
+	class HlsBackgroundVideoMediaImpl extends BaseClass {
+		#engine;
+		#config;
+		#signals;
+		/** Pending loadstart listener from a deferred play() retry, if any. */
+		#loadstartListener = null;
+		constructor(...args) {
+			super(...args);
+			const { config } = args?.[0] ?? {};
+			this.#config = config;
+			this.#engine = this.#createEngine();
+		}
+		get engine() {
+			return this.#engine;
+		}
+		attach(mediaElement) {
+			super.attach?.(mediaElement);
+			mediaElement.loop = true;
+			mediaElement.muted = true;
+			mediaElement.autoplay = true;
+			mediaElement.preload = "auto";
+			this.#signals.context.mediaElement.set(mediaElement);
+		}
+		detach() {
+			this.#cancelPendingPlay();
+			this.#signals.context.mediaElement.set(void 0);
+			super.detach?.();
+		}
+		destroy() {
+			this.#cancelPendingPlay();
+			this.#engine.destroy();
+		}
+		get src() {
+			return this.#signals.state.presentation.get()?.url ?? "";
+		}
+		set src(value) {
+			if (value === this.src) return;
+			this.#cancelPendingPlay();
+			this.#signals.state.presentation.set(value ? { url: value } : void 0);
+		}
+		async play() {
+			const mediaElement = this.#signals.context.mediaElement.get();
+			if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("HlsBackgroundVideoMediaElement: no media element attached"));
+			try {
+				return await mediaElement.play();
+			} catch (err) {
+				if (this.src) return new Promise((resolve, reject) => {
+					const listener = () => {
+						this.#loadstartListener = null;
+						mediaElement.play().then(resolve, reject);
+					};
+					this.#loadstartListener = listener;
+					mediaElement.addEventListener("loadstart", listener, { once: true });
+				});
+				throw err;
+			}
+		}
+		#createEngine() {
+			const adapterPicker = (presentation) => {
+				return pickTrackUnderPixelArea((presentation.selectionSets?.find((s) => s.type === "video"))?.switchingSets[0]?.tracks ?? [])?.id;
+			};
+			return createBackgroundVideoEngine({
+				picker: adapterPicker,
+				...this.#config,
+				onSignalsReady: (signals) => {
+					this.#signals = signals;
+				}
+			});
+		}
+		#cancelPendingPlay() {
+			if (!this.#loadstartListener) return;
+			this.#signals.context.mediaElement.get()?.removeEventListener("loadstart", this.#loadstartListener);
+			this.#loadstartListener = null;
+		}
+	}
+	return HlsBackgroundVideoMediaImpl;
+}
+/** Standalone SPF background-video adapter with no base class. */
+var HlsBackgroundVideoMediaElement = class extends HlsBackgroundVideoMediaMixin(class {}) {};
+//#endregion
+export { HlsBackgroundVideoMediaElement, HlsBackgroundVideoMediaMixin, hlsBackgroundVideoMediaDefaultProps };
+
+//# sourceMappingURL=adapter.js.map

package/dist/default/playback/adapters/hls-background-video/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","names":["#config","#engine","#createEngine","#signals","#cancelPendingPlay","#loadstartListener"],"sources":["../../../../../src/playback/adapters/hls-background-video/adapter.ts"],"sourcesContent":["import type { Constructor, MixinReturn } from '@videojs/utils/types';\nimport type { Composition } from '../../../core/composition/create-composition';\nimport { pickTrackUnderPixelArea, type TrackPicker } from '../../../media/primitives/select-tracks';\nimport type { VideoSelectionSet } from '../../../media/types';\nimport {\n  type BackgroundVideoEngineConfig,\n  type BackgroundVideoEngineContext,\n  type BackgroundVideoEngineSignals,\n  type BackgroundVideoEngineState,\n  createBackgroundVideoEngine,\n} from '../../engines/hls/engine-background-video';\n\nexport interface HlsBackgroundVideoMediaProps {\n  src: string;\n}\n\nexport const hlsBackgroundVideoMediaDefaultProps: HlsBackgroundVideoMediaProps = {\n  src: '',\n};\n\nexport interface HlsBackgroundVideoMediaAPI extends HlsBackgroundVideoMediaProps {\n  readonly engine: Composition<BackgroundVideoEngineState, BackgroundVideoEngineContext>;\n  attach(mediaElement: HTMLMediaElement): void;\n  detach(): void;\n  destroy(): void;\n  play(): Promise<void>;\n}\n\n/**\n * Mixin that adds the background-video SPF playback engine to any base class,\n * for an HLS URL.\n *\n * `src` is the whole surface, and the picker always pins the top rendition on\n * offer. There is no cap of its own because the manifest is the better place to\n * narrow one: a delivery param — `?max_resolution=720p` on a Mux stream URL, for\n * one — keeps the renditions it excludes out of the manifest entirely, rather\n * than fetched-then-unpicked. Deriving a cap from the screen instead is on the\n * roadmap, and lands here when it does.\n *\n * `@videojs/spf/mux-background-video` is this same Media under a Mux-flavored\n * name — an alias, not a variant. Nothing about the surface changes with the\n * import path.\n *\n * Everything else the use case fixes rather than exposes: video-only, looping,\n * muted, autoplaying, loading as soon as there is a source. `attach` writes that\n * onto the element and nothing here declares `loop` / `muted` / `autoplay` /\n * `preload` of its own — a host-bound Media inherits all four from the host\n * already, and shadowing them with fixed values would only make reads describe\n * an intention rather than what the element is doing.\n *\n * A new src re-resolves the presentation, tearing down the state, SourceBuffers,\n * and in-flight requests the previous one built before the next begins. The\n * engine instance and the attached media element are both kept, so neither has to\n * be rewired.\n *\n * @example\n * class HlsBackgroundVideoMedia extends HlsBackgroundVideoMediaMixin(BackgroundVideoHost) {}\n *\n * const media = new HlsBackgroundVideoMedia();\n * media.attach(document.querySelector('video'));\n * media.src = 'https://stream.mux.com/PLAYBACK_ID.m3u8?max_resolution=720p';\n * media.play();\n */\nexport function HlsBackgroundVideoMediaMixin<Base extends Constructor<any>>(BaseClass: Base) {\n  class HlsBackgroundVideoMediaImpl extends BaseClass {\n    #engine: Composition<BackgroundVideoEngineState, BackgroundVideoEngineContext>;\n    #config: BackgroundVideoEngineConfig;\n    #signals!: BackgroundVideoEngineSignals;\n\n    /** Pending loadstart listener from a deferred play() retry, if any. */\n    #loadstartListener: (() => void) | null = null;\n\n    constructor(...args: any[]) {\n      super(...args);\n\n      const { config } = args?.[0] ?? {};\n      this.#config = config;\n      this.#engine = this.#createEngine();\n    }\n\n    get engine(): Composition<BackgroundVideoEngineState, BackgroundVideoEngineContext> {\n      return this.#engine;\n    }\n\n    // -------------------------------------------------------------------------\n    // Media element lifecycle\n    // -------------------------------------------------------------------------\n\n    attach(mediaElement: HTMLMediaElement): void {\n      super.attach?.(mediaElement);\n      // The one place the fixed behavior is stated. Muted and autoplay are what\n      // let it start without a gesture, loop is the defining behavior, and\n      // `preload` says out loud what the engine does regardless — it subtracts\n      // preload monitoring and loads from the moment it has a source.\n      mediaElement.loop = true;\n      mediaElement.muted = true;\n      mediaElement.autoplay = true;\n      mediaElement.preload = 'auto';\n\n      this.#signals.context.mediaElement.set(mediaElement);\n    }\n\n    detach(): void {\n      this.#cancelPendingPlay();\n      this.#signals.context.mediaElement.set(undefined);\n      super.detach?.();\n    }\n\n    destroy(): void {\n      this.#cancelPendingPlay();\n      this.#engine.destroy();\n    }\n\n    // -------------------------------------------------------------------------\n    // src — synchronous IDL attribute (WHATWG §4.8.11.2)\n    // -------------------------------------------------------------------------\n\n    get src(): string {\n      return this.#signals.state.presentation.get()?.url ?? '';\n    }\n\n    set src(value: string) {\n      // Same line the HLS Medias draw: the presentation is set from a fresh\n      // object every time, so re-resolving a URL already playing would restart\n      // it for no reason.\n      if (value === this.src) return;\n\n      this.#cancelPendingPlay();\n      this.#signals.state.presentation.set(value ? { url: value } : undefined);\n    }\n\n    // -------------------------------------------------------------------------\n    // play() — WHATWG §4.8.11.8\n    // Delegates to the attached media element's native play().\n    // -------------------------------------------------------------------------\n\n    async play(): Promise<void> {\n      const mediaElement = this.#signals.context.mediaElement.get();\n      if (!mediaElement) {\n        return Promise.reject(new Error('HlsBackgroundVideoMediaElement: no media element attached'));\n      }\n\n      try {\n        return await mediaElement.play();\n      } catch (err) {\n        // If we have a pending HLS source, the rejection may be because MSE\n        // hasn't attached a blob URL yet. Wait for loadstart (src assigned by\n        // MSE setup) and retry once.\n        if (this.src) {\n          return new Promise<void>((resolve, reject) => {\n            const listener = () => {\n              this.#loadstartListener = null;\n              mediaElement.play().then(resolve, reject);\n            };\n            this.#loadstartListener = listener;\n            mediaElement.addEventListener('loadstart', listener, { once: true });\n          });\n        }\n        throw err;\n      }\n    }\n\n    // -------------------------------------------------------------------------\n    // Private\n    // -------------------------------------------------------------------------\n\n    #createEngine(): Composition<BackgroundVideoEngineState, BackgroundVideoEngineContext> {\n      // No cap to apply, so the pick is whichever rendition is largest. Passing\n      // no maximum is what makes that the answer, rather than a rule of its own.\n      const adapterPicker: TrackPicker = (presentation) => {\n        const videoSet = presentation.selectionSets?.find((s) => s.type === 'video') as VideoSelectionSet | undefined;\n        const tracks = videoSet?.switchingSets[0]?.tracks ?? [];\n        return pickTrackUnderPixelArea(tracks)?.id;\n      };\n\n      return createBackgroundVideoEngine({\n        picker: adapterPicker,\n        ...this.#config,\n        onSignalsReady: (signals) => {\n          this.#signals = signals;\n        },\n      });\n    }\n\n    #cancelPendingPlay(): void {\n      if (!this.#loadstartListener) return;\n      const mediaElement = this.#signals.context.mediaElement.get();\n      mediaElement?.removeEventListener('loadstart', this.#loadstartListener);\n      this.#loadstartListener = null;\n    }\n  }\n\n  return HlsBackgroundVideoMediaImpl as unknown as MixinReturn<Base, HlsBackgroundVideoMediaAPI>;\n}\n\n/** Standalone SPF background-video adapter with no base class. */\nexport class HlsBackgroundVideoMediaElement extends HlsBackgroundVideoMediaMixin(class {}) {}\n"],"mappings":";;;AAgBA,MAAa,sCAAoE,EAC/E,KAAK,GACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,6BAA4D,WAAiB;CAC3F,MAAM,oCAAoC,UAAU;EAClD;EACA;EACA;;EAGA,qBAA0C;EAE1C,YAAY,GAAG,MAAa;GAC1B,MAAM,GAAG,IAAI;GAEb,MAAM,EAAE,WAAW,OAAO,MAAM,CAAC;GACjC,KAAKA,UAAU;GACf,KAAKC,UAAU,KAAKC,cAAc;EACpC;EAEA,IAAI,SAAgF;GAClF,OAAO,KAAKD;EACd;EAMA,OAAO,cAAsC;GAC3C,MAAM,SAAS,YAAY;GAK3B,aAAa,OAAO;GACpB,aAAa,QAAQ;GACrB,aAAa,WAAW;GACxB,aAAa,UAAU;GAEvB,KAAKE,SAAS,QAAQ,aAAa,IAAI,YAAY;EACrD;EAEA,SAAe;GACb,KAAKC,mBAAmB;GACxB,KAAKD,SAAS,QAAQ,aAAa,IAAI,KAAA,CAAS;GAChD,MAAM,SAAS;EACjB;EAEA,UAAgB;GACd,KAAKC,mBAAmB;GACxB,KAAKH,QAAQ,QAAQ;EACvB;EAMA,IAAI,MAAc;GAChB,OAAO,KAAKE,SAAS,MAAM,aAAa,IAAI,CAAC,EAAE,OAAO;EACxD;EAEA,IAAI,IAAI,OAAe;GAIrB,IAAI,UAAU,KAAK,KAAK;GAExB,KAAKC,mBAAmB;GACxB,KAAKD,SAAS,MAAM,aAAa,IAAI,QAAQ,EAAE,KAAK,MAAM,IAAI,KAAA,CAAS;EACzE;EAOA,MAAM,OAAsB;GAC1B,MAAM,eAAe,KAAKA,SAAS,QAAQ,aAAa,IAAI;GAC5D,IAAI,CAAC,cACH,OAAO,QAAQ,uBAAO,IAAI,MAAM,2DAA2D,CAAC;GAG9F,IAAI;IACF,OAAO,MAAM,aAAa,KAAK;GACjC,SAAS,KAAK;IAIZ,IAAI,KAAK,KACP,OAAO,IAAI,SAAe,SAAS,WAAW;KAC5C,MAAM,iBAAiB;MACrB,KAAKE,qBAAqB;MAC1B,aAAa,KAAK,CAAC,CAAC,KAAK,SAAS,MAAM;KAC1C;KACA,KAAKA,qBAAqB;KAC1B,aAAa,iBAAiB,aAAa,UAAU,EAAE,MAAM,KAAK,CAAC;IACrE,CAAC;IAEH,MAAM;GACR;EACF;EAMA,gBAAuF;GAGrF,MAAM,iBAA8B,iBAAiB;IAGnD,OAAO,yBAFU,aAAa,eAAe,MAAM,MAAM,EAAE,SAAS,OAAO,EAAA,EAClD,cAAc,EAAE,EAAE,UAAU,CAAC,CACjB,CAAC,EAAE;GAC1C;GAEA,OAAO,4BAA4B;IACjC,QAAQ;IACR,GAAG,KAAKL;IACR,iBAAiB,YAAY;KAC3B,KAAKG,WAAW;IAClB;GACF,CAAC;EACH;EAEA,qBAA2B;GACzB,IAAI,CAAC,KAAKE,oBAAoB;GAE9B,KAD0BF,SAAS,QAAQ,aAAa,IAC7C,CAAC,EAAE,oBAAoB,aAAa,KAAKE,kBAAkB;GACtE,KAAKA,qBAAqB;EAC5B;CACF;CAEA,OAAO;AACT;;AAGA,IAAa,iCAAb,cAAoD,6BAA6B,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/default/playback/adapters/hls-background-video/host.js

@@ -0,0 +1,60 @@
+//#region src/playback/adapters/hls-background-video/host.ts
+/**
+* The `<video>` binding a background video uses: somewhere to keep the attached
+* element, and the four properties the Media fixes on it.
+*
+* That is the whole surface anything here reaches. The engine drives playback,
+* the element exposes `src` and nothing else, and the background player
+* subscribes to no store features, so nothing asks a background video for
+* `currentTime`, `play()`, picture-in-picture, fullscreen, forwarded events, or
+* media components. Holding the host to what is reachable is what keeps this
+* entry free of `@videojs/media`, and small enough to suit a component whose
+* whole pitch is its size.
+*
+* An `EventTarget`, because a Media is one: the store and the element layers
+* take anything they attach as an event source, and inheriting the three methods
+* satisfies that for free rather than by stubbing them.
+*
+* ⚠️ It still implements too little to carry the rest of the media surface, which
+* bounds what may consume it: a store feature reading a property outside this set
+* gets `undefined` rather than an error. A Media needing more of that surface
+* belongs on a host that provides it.
+*/
+var BackgroundVideoHost = class extends EventTarget {
+	#target = null;
+	attach(target) {
+		if (!target || this.#target === target) return;
+		this.#target = target;
+	}
+	detach() {
+		this.#target = null;
+	}
+	get loop() {
+		return this.#target?.loop ?? false;
+	}
+	set loop(value) {
+		if (this.#target) this.#target.loop = value;
+	}
+	get muted() {
+		return this.#target?.muted ?? false;
+	}
+	set muted(value) {
+		if (this.#target) this.#target.muted = value;
+	}
+	get autoplay() {
+		return this.#target?.autoplay ?? false;
+	}
+	set autoplay(value) {
+		if (this.#target) this.#target.autoplay = value;
+	}
+	get preload() {
+		return this.#target?.preload ?? "metadata";
+	}
+	set preload(value) {
+		if (this.#target) this.#target.preload = value;
+	}
+};
+//#endregion
+export { BackgroundVideoHost };
+
+//# sourceMappingURL=host.js.map

package/dist/default/playback/adapters/hls-background-video/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","names":["#target"],"sources":["../../../../../src/playback/adapters/hls-background-video/host.ts"],"sourcesContent":["/**\n * The `<video>` binding a background video uses: somewhere to keep the attached\n * element, and the four properties the Media fixes on it.\n *\n * That is the whole surface anything here reaches. The engine drives playback,\n * the element exposes `src` and nothing else, and the background player\n * subscribes to no store features, so nothing asks a background video for\n * `currentTime`, `play()`, picture-in-picture, fullscreen, forwarded events, or\n * media components. Holding the host to what is reachable is what keeps this\n * entry free of `@videojs/media`, and small enough to suit a component whose\n * whole pitch is its size.\n *\n * An `EventTarget`, because a Media is one: the store and the element layers\n * take anything they attach as an event source, and inheriting the three methods\n * satisfies that for free rather than by stubbing them.\n *\n * ⚠️ It still implements too little to carry the rest of the media surface, which\n * bounds what may consume it: a store feature reading a property outside this set\n * gets `undefined` rather than an error. A Media needing more of that surface\n * belongs on a host that provides it.\n */\nexport class BackgroundVideoHost extends EventTarget {\n  #target: HTMLVideoElement | null = null;\n\n  attach(target: HTMLVideoElement): void {\n    if (!target || this.#target === target) return;\n    this.#target = target;\n  }\n\n  detach(): void {\n    this.#target = null;\n  }\n\n  // Read back off the element rather than stored, so they describe what is\n  // playing instead of what was asked for — see the adapter's note on why the\n  // Media declares none of these itself.\n  get loop(): boolean {\n    return this.#target?.loop ?? false;\n  }\n\n  set loop(value: boolean) {\n    if (this.#target) this.#target.loop = value;\n  }\n\n  get muted(): boolean {\n    return this.#target?.muted ?? false;\n  }\n\n  set muted(value: boolean) {\n    if (this.#target) this.#target.muted = value;\n  }\n\n  get autoplay(): boolean {\n    return this.#target?.autoplay ?? false;\n  }\n\n  set autoplay(value: boolean) {\n    if (this.#target) this.#target.autoplay = value;\n  }\n\n  get preload(): HTMLVideoElement['preload'] {\n    return this.#target?.preload ?? 'metadata';\n  }\n\n  set preload(value: HTMLVideoElement['preload']) {\n    if (this.#target) this.#target.preload = value;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,sBAAb,cAAyC,YAAY;CACnD,UAAmC;CAEnC,OAAO,QAAgC;EACrC,IAAI,CAAC,UAAU,KAAKA,YAAY,QAAQ;EACxC,KAAKA,UAAU;CACjB;CAEA,SAAe;EACb,KAAKA,UAAU;CACjB;CAKA,IAAI,OAAgB;EAClB,OAAO,KAAKA,SAAS,QAAQ;CAC/B;CAEA,IAAI,KAAK,OAAgB;EACvB,IAAI,KAAKA,SAAS,KAAKA,QAAQ,OAAO;CACxC;CAEA,IAAI,QAAiB;EACnB,OAAO,KAAKA,SAAS,SAAS;CAChC;CAEA,IAAI,MAAM,OAAgB;EACxB,IAAI,KAAKA,SAAS,KAAKA,QAAQ,QAAQ;CACzC;CAEA,IAAI,WAAoB;EACtB,OAAO,KAAKA,SAAS,YAAY;CACnC;CAEA,IAAI,SAAS,OAAgB;EAC3B,IAAI,KAAKA,SAAS,KAAKA,QAAQ,WAAW;CAC5C;CAEA,IAAI,UAAuC;EACzC,OAAO,KAAKA,SAAS,WAAW;CAClC;CAEA,IAAI,QAAQ,OAAoC;EAC9C,IAAI,KAAKA,SAAS,KAAKA,QAAQ,UAAU;CAC3C;AACF"}

package/dist/default/playback/adapters/hls-background-video/media.js

@@ -0,0 +1,21 @@
+import { HlsBackgroundVideoMediaMixin } from "./adapter.js";
+import { BackgroundVideoHost } from "./host.js";
+//#region src/playback/adapters/hls-background-video/media.ts
+const HlsBackgroundVideoMediaBase = HlsBackgroundVideoMediaMixin(BackgroundVideoHost);
+/**
+* The background-video Media, bound to a `<video>` through
+* {@link BackgroundVideoHost}.
+*
+* That host carries the attached element and the four properties `attach` fixes,
+* which is all this Media's surface needs, and it is local — so this entry has
+* no `@videojs/media` dependency.
+*
+* No `MediaTracksMixin`, unlike `HlsVideoMedia`: the engine subtracts audio and
+* text entirely and pins one video rendition for the session, so there are no
+* track lists for a consumer to project or switch between.
+*/
+var HlsBackgroundVideoMedia = class extends HlsBackgroundVideoMediaBase {};
+//#endregion
+export { HlsBackgroundVideoMedia };
+
+//# sourceMappingURL=media.js.map

package/dist/default/playback/adapters/hls-background-video/media.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.js","names":[],"sources":["../../../../../src/playback/adapters/hls-background-video/media.ts"],"sourcesContent":["import { HlsBackgroundVideoMediaMixin } from './adapter';\nimport { BackgroundVideoHost } from './host';\n\nconst HlsBackgroundVideoMediaBase = HlsBackgroundVideoMediaMixin(BackgroundVideoHost);\n\n/**\n * The background-video Media, bound to a `<video>` through\n * {@link BackgroundVideoHost}.\n *\n * That host carries the attached element and the four properties `attach` fixes,\n * which is all this Media's surface needs, and it is local — so this entry has\n * no `@videojs/media` dependency.\n *\n * No `MediaTracksMixin`, unlike `HlsVideoMedia`: the engine subtracts audio and\n * text entirely and pins one video rendition for the session, so there are no\n * track lists for a consumer to project or switch between.\n */\nexport class HlsBackgroundVideoMedia extends HlsBackgroundVideoMediaBase {}\n"],"mappings":";;;AAGA,MAAM,8BAA8B,6BAA6B,mBAAmB;;;;;;;;;;;;;AAcpF,IAAa,0BAAb,cAA6C,4BAA4B,CAAC"}