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

package/dist/default/background-video.js

@@ -0,0 +1,3 @@
+import { createBackgroundVideoEngine } from "./playback/engines/background-video/engine.js";
+import { BackgroundVideoMediaElement, BackgroundVideoMediaMixin, backgroundVideoMediaDefaultProps } from "./playback/engines/background-video/adapter.js";
+export { BackgroundVideoMediaElement, BackgroundVideoMediaMixin, backgroundVideoMediaDefaultProps, createBackgroundVideoEngine };

package/dist/default/core/composition/create-composition.js

@@ -15,7 +15,7 @@ import { signal } from "../signals/primitives.js";
 *
 * @example
 * ```ts
-* const composition = createComposition([resolvePresentation, switchVideoQuality], {
+* const composition = createComposition([resolvePresentation, switchVideoTrack], {
 *   config: { parsePresentation: parseMultivariantPlaylist, initialBandwidth: 2_000_000 },
 *   initialState: { bandwidthState: { fastEstimate: 0, ... } },
 * });

package/dist/default/core/composition/create-composition.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-composition.js","names":[],"sources":["../../../../src/core/composition/create-composition.ts"],"sourcesContent":["import { type ReadonlySignal, type Signal, signal } from '../signals/primitives';\n\n/**\n * Cleanup returned by a behavior. Behaviors may return:\n * - `void` / `undefined` — no cleanup needed\n * - A function — called on destroy (may return a Promise)\n * - An object with `destroy()` — called on destroy (may return a Promise)\n */\nexport type BehaviorCleanup = void | (() => void | Promise<void>) | { destroy(): void | Promise<void> };\n\n/**\n * A signal map keyed by the fields of `S`. Each field is a writable signal.\n *\n * Optional fields on `S` map to required signal slots whose value type\n * includes `undefined`, ensuring every key has a signal even when the\n * underlying value is absent.\n *\n * Used in two roles:\n * - Engine-side **construction**: `Composition<S, C>` exposes its public\n *   surface as `StateSignals<S>` (everything writable) so external code\n *   can read or write any slot.\n * - Behavior **input convenience**: a behavior that writes to every slot\n *   can type its setup state param as `StateSignals<{ ... }>` rather than\n *   spelling out per-slot `Signal<T>` types.\n *\n * Behaviors that mix read-only and writable slots type the setup param\n * directly as a slot map (`{ x: Signal<T>; y: ReadonlySignal<U> }`)\n * instead of going through `StateSignals<>`.\n */\nexport type StateSignals<S extends object> = { [K in keyof S]-?: Signal<S[K]> };\n\n/**\n * A signal map keyed by the fields of `C`. Each field is a writable signal\n * for a platform object or actor reference. Same dual role as\n * `StateSignals<S>` — see its docblock.\n */\nexport type ContextSignals<C extends object> = { [K in keyof C]-?: Signal<C[K]> };\n\n/**\n * Slot-map shape — a record where each value is at least a `ReadonlySignal`.\n * `Signal<T>` is structurally a subtype of `ReadonlySignal<T>` (it adds\n * `.set()`), so a writable slot satisfies this bound too.\n *\n * This is the bound used for behavior `state` / `context` slot maps. It\n * lets a single behavior declare a *heterogeneous* slot map where some\n * slots are `Signal<T>` (writable) and others are `ReadonlySignal<T>`\n * (read-only) — making read/write intent explicit at the call site and\n * giving body-level enforcement (TS rejects `.set()` on a read-only slot).\n */\nexport type AnySlotMap = Record<PropertyKey, ReadonlySignal<unknown>>;\n\n/**\n * The deps object passed to each behavior by the composition.\n *\n * - `state` — slot map for state fields (reactive data). Per-slot read/\n *   write intent expressed via `Signal<T>` vs `ReadonlySignal<T>`.\n * - `context` — slot map for platform objects and actor references.\n * - `config` — static configuration, passed once at composition creation.\n */\nexport interface BehaviorDeps<StateMap extends AnySlotMap, ContextMap extends AnySlotMap, Cfg extends object> {\n  state: StateMap;\n  context: ContextMap;\n  config: Cfg;\n}\n\n/**\n * A behavior announces the state and context keys it needs alongside a\n * `setup` function that receives deps (state, context, config) and\n * returns an optional cleanup handle.\n *\n * The `stateKeys` / `contextKeys` declarations are the runtime expression\n * of the behavior's contract — the caller (e.g. `createComposition`) uses\n * them to know which signals to provide. The setup parameter type\n * declares the *slot map* (per-slot `Signal<T>` vs `ReadonlySignal<T>`);\n * together they form a complete contract.\n *\n * Manual `Behavior<>` literals (e.g. engine wrappers that forward keys\n * from a wrapped behavior, or pass-through behaviors like `shareSignals`)\n * opt out of exhaustiveness — the type alias is permissive (subset).\n * Source behaviors should use `defineBehavior` to get exhaustiveness\n * enforcement at the call site.\n */\nexport interface Behavior<\n  StateMap extends AnySlotMap = Empty,\n  ContextMap extends AnySlotMap = Empty,\n  Cfg extends object = Empty,\n> {\n  /** State keys this behavior reads/writes. Subset of `keyof StateMap`. */\n  stateKeys: readonly (keyof StateMap)[];\n  /** Context keys this behavior reads/writes. Subset of `keyof ContextMap`. */\n  contextKeys: readonly (keyof ContextMap)[];\n  setup: (deps: BehaviorDeps<StateMap, ContextMap, Cfg>) => BehaviorCleanup;\n}\n\n// =============================================================================\n// Behavior type inference\n// =============================================================================\n\n/** A behavior with an unconstrained setup — used as a generic bound. */\ntype AnyBehavior = {\n  stateKeys: readonly PropertyKey[];\n  contextKeys: readonly PropertyKey[];\n  setup: (deps: any) => BehaviorCleanup;\n};\n\n/** Extract the deps type from a behavior's setup function. */\ntype DepsOf<B> = B extends { setup: (deps: infer D, ...args: any[]) => any } ? D : never;\n\n/**\n * Empty-object fallback used when a behavior omits state, context, or config.\n *\n * Using `{}` rather than `object` is deliberate — `object & {x: T}` collapses\n * to `{x: never}` under TS's union-to-intersection conversion in some inference\n * contexts (likely a TS quirk around the `object` upper bound), whereas\n * `{} & {x: T}` simplifies cleanly to `{x: T}`.\n */\n// biome-ignore lint/complexity/noBannedTypes: see comment above\ntype Empty = {};\n\n/**\n * Unwrap a signal map back to its state/context shape.\n *\n * Inferring through `{ get(): infer V }` rather than `Signal<infer V>`\n * sidesteps `Signal`'s nominal/invariance behaviour — the conditional\n * matches structurally on the read side, and `V` is inferred covariantly.\n */\ntype UnwrapSignals<M> = M extends object ? { [K in keyof M]: M[K] extends { get(): infer V } ? V : never } : Empty;\n\n/** Infer the state shape a behavior requires from its deps parameter. */\nexport type InferBehaviorState<F> = DepsOf<F> extends { state: infer M } ? UnwrapSignals<M> : Empty;\n\n/** Infer the context shape a behavior requires from its deps parameter. */\nexport type InferBehaviorContext<F> = DepsOf<F> extends { context: infer M } ? UnwrapSignals<M> : Empty;\n\n/** Infer the config shape a behavior requires from its deps parameter. */\nexport type InferBehaviorConfig<F> = DepsOf<F> extends { config: infer C extends object } ? C : Empty;\n\n/**\n * Recursively intersect a per-behavior projection across the tuple.\n *\n * Iterating over the tuple directly avoids `UnionToIntersection`'s\n * function-contravariance trick, which produces unstable intersections\n * (collapsing concrete fields to `never` or unrelated types) when one of the\n * union members is the empty `{}` fallback.\n */\ntype IntersectBehaviors<Behaviors extends readonly AnyBehavior[], Project extends object> = Behaviors extends readonly [\n  infer First extends AnyBehavior,\n  ...infer Rest extends readonly AnyBehavior[],\n]\n  ? Apply<Project, First> & IntersectBehaviors<Rest, Project>\n  : Empty;\n\n/**\n * Apply a projection (one of the marker types below) to a single behavior.\n * Encoded as a discriminated dispatch so the recursion above can stay generic\n * and we don't have to write three near-identical recursive types.\n */\ntype Apply<Project extends object, F> = Project extends { kind: 'state' }\n  ? InferBehaviorState<F>\n  : Project extends { kind: 'context' }\n    ? InferBehaviorContext<F>\n    : Project extends { kind: 'config' }\n      ? InferBehaviorConfig<F>\n      : never;\n\ntype StateProjection = { kind: 'state' };\ntype ContextProjection = { kind: 'context' };\ntype ConfigProjection = { kind: 'config' };\n\n/** Resolve the combined state shape from an array of behaviors (intersection of all requirements). */\nexport type ResolveBehaviorState<Behaviors extends readonly AnyBehavior[]> =\n  IntersectBehaviors<Behaviors, StateProjection> extends infer R extends object ? R : Empty;\n\n/** Resolve the combined context shape from an array of behaviors (intersection of all requirements). */\nexport type ResolveBehaviorContext<Behaviors extends readonly AnyBehavior[]> =\n  IntersectBehaviors<Behaviors, ContextProjection> extends infer R extends object ? R : Empty;\n\n/** Resolve the combined config shape from an array of behaviors (intersection of all requirements). */\nexport type ResolveBehaviorConfig<Behaviors extends readonly AnyBehavior[]> =\n  IntersectBehaviors<Behaviors, ConfigProjection> extends infer R extends object ? R : Empty;\n\n/**\n * True if any property in `T` collapsed to `undefined` or `never` — indicating\n * a type conflict from intersecting incompatible behavior requirements.\n *\n * - Required conflicts: `{ v: number } & { v: string }` → `{ v: never }` — caught via `[never] extends [undefined]`\n * - Optional conflicts: `{ v?: number } & { v?: string }` → `{ v?: undefined }` — caught directly\n */\ntype HasConflict<T extends object> = true extends {\n  [K in keyof T]: [T[K]] extends [undefined] ? true : never;\n}[keyof T]\n  ? true\n  : false;\n\n// =============================================================================\n// Composition validation\n// =============================================================================\n\n/**\n * Validate that a behavior composition has no type conflicts.\n * Returns the behaviors tuple if valid, or an error message type if conflicts are detected.\n *\n * State, context, and config are all checked the same way — by intersecting\n * each behavior's requirement and looking for collapsed fields. The\n * intersection-based check applies the same rule to context as to state, so\n * two behaviors that disagree on a context field's type (e.g. `Surface` vs\n * `VideoSurface`) surface a conflict at compose time. The prior subtype-based\n * approach for owners is gone — the unified rule is simpler and catches the\n * cases where two behaviors silently agreed on a wider supertype.\n */\ntype ValidateComposition<Behaviors extends readonly AnyBehavior[]> =\n  HasConflict<ResolveBehaviorState<Behaviors>> extends true\n    ? 'Error: behaviors have conflicting state types'\n    : HasConflict<ResolveBehaviorContext<Behaviors>> extends true\n      ? 'Error: behaviors have conflicting context types'\n      : HasConflict<ResolveBehaviorConfig<Behaviors>> extends true\n        ? 'Error: behaviors have conflicting config types'\n        : [...Behaviors];\n\n// =============================================================================\n// Composition\n// =============================================================================\n\n/**\n * A composition of behaviors with shared state and context signal maps.\n */\nexport interface Composition<S extends object, C extends object> {\n  state: StateSignals<S>;\n  context: ContextSignals<C>;\n  destroy(): Promise<void>;\n}\n\n/**\n * Options for `createComposition`.\n *\n * Composition derives the state and context signal maps from each\n * behavior's declared `stateKeys` / `contextKeys`; `initialState` and\n * `initialContext` seed those signals at creation time. Any unseeded\n * signal starts as `undefined`.\n */\nexport interface CompositionOptions<S extends object, C extends object, Cfg extends object> {\n  /** Static configuration passed to every behavior. */\n  config?: Cfg;\n  /** Initial values for state signals — any subset of `keyof S`. */\n  initialState?: Partial<S>;\n  /** Initial values for context signals — any subset of `keyof C`. */\n  initialContext?: Partial<C>;\n}\n\n/**\n * Create a composition from a set of behaviors.\n *\n * Composition unions the behaviors' declared `stateKeys` / `contextKeys`\n * to know which signals to create. Each signal is seeded from\n * `initialState` / `initialContext` when supplied, defaulting to\n * `undefined`. Behaviors are responsible for writing their own slots\n * once their preconditions are met.\n *\n * Cross-behavior type conflicts (e.g. two behaviors disagreeing on a\n * field's type) surface as a compose-time type error via\n * `ValidateComposition`.\n *\n * @example\n * ```ts\n * const composition = createComposition([resolvePresentation, switchVideoQuality], {\n *   config: { parsePresentation: parseMultivariantPlaylist, initialBandwidth: 2_000_000 },\n *   initialState: { bandwidthState: { fastEstimate: 0, ... } },\n * });\n * ```\n */\n/**\n * Create a typed signal map for a given set of keys, seeded from an\n * optional partial initial value.\n *\n * Pipeline: `Set` dedupes the iterable (insertion order preserved, so\n * first occurrence wins) → `Object.fromEntries` materializes one\n * `signal()` per unique key, seeded from `initial[key]` or `undefined`.\n *\n * Per-key value types live in TypeScript only — at runtime every signal\n * is `Signal<unknown>`. The boundary cast at the return narrows the wide\n * `Record<PropertyKey, Signal<unknown>>` shape to the caller's expected\n * per-key types from `S`.\n *\n * Used by `createComposition` to derive engine state/context maps from\n * the union of behaviors' declared `stateKeys` / `contextKeys`.\n *\n * @example\n * ```ts\n * interface State { count?: number; label?: string }\n * const state = buildSignalMap<State>(['count', 'label'], { count: 5 });\n * state.count.get(); // 5\n * state.label.get(); // undefined\n * ```\n */\nexport function buildSignalMap<S extends object>(\n  keys: Iterable<PropertyKey>,\n  initial: Partial<S>\n): { [K in keyof S]-?: Signal<S[K]> } {\n  const init = initial as Record<PropertyKey, unknown>;\n  const uniqueKeys = new Set(keys);\n  return Object.fromEntries([...uniqueKeys].map((key) => [key, signal(init[key])])) as {\n    [K in keyof S]-?: Signal<S[K]>;\n  };\n}\n\nexport function createComposition<const Behaviors extends readonly AnyBehavior[]>(\n  behaviors: ValidateComposition<Behaviors>,\n  options?: CompositionOptions<\n    ResolveBehaviorState<Behaviors>,\n    ResolveBehaviorContext<Behaviors>,\n    ResolveBehaviorConfig<Behaviors>\n  >\n): Composition<ResolveBehaviorState<Behaviors>, ResolveBehaviorContext<Behaviors>> {\n  type S = ResolveBehaviorState<Behaviors>;\n  type C = ResolveBehaviorContext<Behaviors>;\n  type Cfg = ResolveBehaviorConfig<Behaviors>;\n\n  // ValidateComposition<Behaviors> is `[...Behaviors]` on success, an error\n  // string on conflict. The function body only runs when the call typechecks\n  // (i.e. the success case), so iterating as the behavior tuple is sound.\n  const validBehaviors = behaviors as unknown as readonly AnyBehavior[];\n\n  const state = buildSignalMap<S>(\n    validBehaviors.flatMap((b) => b.stateKeys),\n    options?.initialState ?? {}\n  );\n  const context = buildSignalMap<C>(\n    validBehaviors.flatMap((b) => b.contextKeys),\n    options?.initialContext ?? {}\n  );\n\n  const deps: BehaviorDeps<StateSignals<S>, ContextSignals<C>, Cfg> = {\n    state,\n    context,\n    config: (options?.config ?? {}) as Cfg,\n  };\n  const cleanups = validBehaviors.map((behavior) => behavior.setup(deps));\n\n  return {\n    state,\n    context,\n    async destroy() {\n      const results: (void | Promise<void>)[] = [];\n      for (const cleanup of cleanups) {\n        if (cleanup == null) continue;\n        if (typeof cleanup === 'function') {\n          results.push(cleanup());\n        } else if ('destroy' in cleanup) {\n          results.push(cleanup.destroy());\n        }\n      }\n      await Promise.all(results);\n      // Reset every signal to undefined as a final cleanup, matching the\n      // prior post-destroy `owners.set({})` semantics. A later stage will\n      // move per-signal cleanup into the behaviors that own the writes.\n      for (const sig of Object.values(state) as Signal<unknown>[]) sig.set(undefined);\n      for (const sig of Object.values(context) as Signal<unknown>[]) sig.set(undefined);\n    },\n  };\n}\n\n// =============================================================================\n// defineBehavior — typed factory with key/param consistency enforcement\n// =============================================================================\n\n/**\n * Compose-time exhaustiveness check.\n *\n * Adds a phantom error tag to the parameter shape when `Keys` does not\n * cover every key in `Slot`. The user's value won't satisfy the phantom\n * field requirement, so TS surfaces the failure at the call site with a\n * descriptive message. When exhaustive, the tag is `Empty` and adds no\n * constraint.\n */\ntype ExhaustiveKeys<Keys extends readonly PropertyKey[], Slot extends object, Name extends string> = [\n  keyof Slot,\n] extends [Keys[number]]\n  ? Empty\n  : { [K in `Error: ${Name}Keys must list every key in the typed slice`]: Exclude<keyof Slot, Keys[number]> };\n\n/**\n * Typed factory for behaviors that enforces single-behavior key/param\n * consistency: declared `stateKeys` must equal `keyof S` (where `S` is\n * inferred from the setup's `state` parameter type), and same for\n * `contextKeys` / `C`.\n *\n * The `const` modifier on `SK` / `CK` captures literal tuples so e.g.\n * `stateKeys: ['preload']` infers as `readonly ['preload']`, no `as\n * const` needed at the call site.\n *\n * Cross-behavior consistency at `createComposition` is unchanged — the\n * existing `IntersectBehaviors` machinery still runs over each\n * behavior's setup param type.\n *\n * @example\n * ```ts\n * export const syncPreload = defineBehavior({\n *   stateKeys: ['preload'],\n *   contextKeys: ['mediaElement'],\n *   setup: ({ state, context }: {\n *     state: StateSignals<{ preload?: 'auto' | 'metadata' | 'none' }>;\n *     context: ContextSignals<{ mediaElement?: HTMLMediaElement | undefined }>;\n *   }) => { ... },\n * });\n * ```\n */\n/**\n * Deps shape for a behavior whose deps slot is empty (no keys). When a\n * slot is empty, the corresponding deps field is optional — callers\n * (typically tests) can omit it, and it defaults to `{}` at runtime via\n * `createComposition`.\n *\n * When a slot has at least one key, the behavior reads `state.foo` /\n * `context.bar` / `config.baz` and we need the field to be required so\n * the access is type-safe.\n */\ntype RequireIfNonEmpty<Key extends string, T extends object> = keyof T extends never\n  ? { [K in Key]?: T }\n  : { [K in Key]: T };\n\ntype DepsForCfg<StateMap extends AnySlotMap, ContextMap extends AnySlotMap, Cfg extends object> = RequireIfNonEmpty<\n  'state',\n  StateMap\n> &\n  RequireIfNonEmpty<'context', ContextMap> &\n  RequireIfNonEmpty<'config', Cfg>;\n\nexport function defineBehavior<\n  StateMap extends AnySlotMap = Empty,\n  ContextMap extends AnySlotMap = Empty,\n  Cfg extends object = Empty,\n  const SK extends readonly (keyof StateMap)[] = readonly [],\n  const CK extends readonly (keyof ContextMap)[] = readonly [],\n  R extends BehaviorCleanup = BehaviorCleanup,\n>(\n  behavior: {\n    stateKeys: SK;\n    contextKeys: CK;\n    setup: (deps: { state: StateMap; context: ContextMap; config: Cfg }) => R;\n  } & ExhaustiveKeys<SK, StateMap, 'state'> &\n    ExhaustiveKeys<CK, ContextMap, 'context'>\n): {\n  stateKeys: SK;\n  contextKeys: CK;\n  setup: (deps: DepsForCfg<StateMap, ContextMap, Cfg>) => R;\n} {\n  // The runtime shape is identical; the cast bridges TS's view of the\n  // parameter (config required) to the return view (config optional when\n  // Cfg has no keys).\n  return behavior as unknown as {\n    stateKeys: SK;\n    contextKeys: CK;\n    setup: (deps: DepsForCfg<StateMap, ContextMap, Cfg>) => R;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsSA,SAAgB,eACd,MACA,SACoC;CACpC,MAAM,OAAO;CACb,MAAM,aAAa,IAAI,IAAI,KAAK;AAChC,QAAO,OAAO,YAAY,CAAC,GAAG,WAAW,CAAC,KAAK,QAAQ,CAAC,KAAK,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC;;AAKnF,SAAgB,kBACd,WACA,SAKiF;CAQjF,MAAM,iBAAiB;CAEvB,MAAM,QAAQ,eACZ,eAAe,SAAS,MAAM,EAAE,UAAU,EAC1C,SAAS,gBAAgB,EAAE,CAC5B;CACD,MAAM,UAAU,eACd,eAAe,SAAS,MAAM,EAAE,YAAY,EAC5C,SAAS,kBAAkB,EAAE,CAC9B;CAED,MAAM,OAA8D;EAClE;EACA;EACA,QAAS,SAAS,UAAU,EAAE;EAC/B;CACD,MAAM,WAAW,eAAe,KAAK,aAAa,SAAS,MAAM,KAAK,CAAC;AAEvE,QAAO;EACL;EACA;EACA,MAAM,UAAU;GACd,MAAM,UAAoC,EAAE;AAC5C,QAAK,MAAM,WAAW,UAAU;AAC9B,QAAI,WAAW,KAAM;AACrB,QAAI,OAAO,YAAY,WACrB,SAAQ,KAAK,SAAS,CAAC;aACd,aAAa,QACtB,SAAQ,KAAK,QAAQ,SAAS,CAAC;;AAGnC,SAAM,QAAQ,IAAI,QAAQ;AAI1B,QAAK,MAAM,OAAO,OAAO,OAAO,MAAM,CAAuB,KAAI,IAAI,KAAA,EAAU;AAC/E,QAAK,MAAM,OAAO,OAAO,OAAO,QAAQ,CAAuB,KAAI,IAAI,KAAA,EAAU;;EAEpF;;AAqEH,SAAgB,eAQd,UAUA;AAIA,QAAO"}
+{"version":3,"file":"create-composition.js","names":[],"sources":["../../../../src/core/composition/create-composition.ts"],"sourcesContent":["import { type ReadonlySignal, type Signal, signal } from '../signals/primitives';\n\n/**\n * Cleanup returned by a behavior. Behaviors may return:\n * - `void` / `undefined` — no cleanup needed\n * - A function — called on destroy (may return a Promise)\n * - An object with `destroy()` — called on destroy (may return a Promise)\n */\nexport type BehaviorCleanup = void | (() => void | Promise<void>) | { destroy(): void | Promise<void> };\n\n/**\n * A signal map keyed by the fields of `S`. Each field is a writable signal.\n *\n * Optional fields on `S` map to required signal slots whose value type\n * includes `undefined`, ensuring every key has a signal even when the\n * underlying value is absent.\n *\n * Used in two roles:\n * - Engine-side **construction**: `Composition<S, C>` exposes its public\n *   surface as `StateSignals<S>` (everything writable) so external code\n *   can read or write any slot.\n * - Behavior **input convenience**: a behavior that writes to every slot\n *   can type its setup state param as `StateSignals<{ ... }>` rather than\n *   spelling out per-slot `Signal<T>` types.\n *\n * Behaviors that mix read-only and writable slots type the setup param\n * directly as a slot map (`{ x: Signal<T>; y: ReadonlySignal<U> }`)\n * instead of going through `StateSignals<>`.\n */\nexport type StateSignals<S extends object> = { [K in keyof S]-?: Signal<S[K]> };\n\n/**\n * A signal map keyed by the fields of `C`. Each field is a writable signal\n * for a platform object or actor reference. Same dual role as\n * `StateSignals<S>` — see its docblock.\n */\nexport type ContextSignals<C extends object> = { [K in keyof C]-?: Signal<C[K]> };\n\n/**\n * Slot-map shape — a record where each value is at least a `ReadonlySignal`.\n * `Signal<T>` is structurally a subtype of `ReadonlySignal<T>` (it adds\n * `.set()`), so a writable slot satisfies this bound too.\n *\n * This is the bound used for behavior `state` / `context` slot maps. It\n * lets a single behavior declare a *heterogeneous* slot map where some\n * slots are `Signal<T>` (writable) and others are `ReadonlySignal<T>`\n * (read-only) — making read/write intent explicit at the call site and\n * giving body-level enforcement (TS rejects `.set()` on a read-only slot).\n */\nexport type AnySlotMap = Record<PropertyKey, ReadonlySignal<unknown>>;\n\n/**\n * The deps object passed to each behavior by the composition.\n *\n * - `state` — slot map for state fields (reactive data). Per-slot read/\n *   write intent expressed via `Signal<T>` vs `ReadonlySignal<T>`.\n * - `context` — slot map for platform objects and actor references.\n * - `config` — static configuration, passed once at composition creation.\n */\nexport interface BehaviorDeps<StateMap extends AnySlotMap, ContextMap extends AnySlotMap, Cfg extends object> {\n  state: StateMap;\n  context: ContextMap;\n  config: Cfg;\n}\n\n/**\n * A behavior announces the state and context keys it needs alongside a\n * `setup` function that receives deps (state, context, config) and\n * returns an optional cleanup handle.\n *\n * The `stateKeys` / `contextKeys` declarations are the runtime expression\n * of the behavior's contract — the caller (e.g. `createComposition`) uses\n * them to know which signals to provide. The setup parameter type\n * declares the *slot map* (per-slot `Signal<T>` vs `ReadonlySignal<T>`);\n * together they form a complete contract.\n *\n * Manual `Behavior<>` literals (e.g. engine wrappers that forward keys\n * from a wrapped behavior, or pass-through behaviors like `shareSignals`)\n * opt out of exhaustiveness — the type alias is permissive (subset).\n * Source behaviors should use `defineBehavior` to get exhaustiveness\n * enforcement at the call site.\n */\nexport interface Behavior<\n  StateMap extends AnySlotMap = Empty,\n  ContextMap extends AnySlotMap = Empty,\n  Cfg extends object = Empty,\n> {\n  /** State keys this behavior reads/writes. Subset of `keyof StateMap`. */\n  stateKeys: readonly (keyof StateMap)[];\n  /** Context keys this behavior reads/writes. Subset of `keyof ContextMap`. */\n  contextKeys: readonly (keyof ContextMap)[];\n  setup: (deps: BehaviorDeps<StateMap, ContextMap, Cfg>) => BehaviorCleanup;\n}\n\n// =============================================================================\n// Behavior type inference\n// =============================================================================\n\n/** A behavior with an unconstrained setup — used as a generic bound. */\ntype AnyBehavior = {\n  stateKeys: readonly PropertyKey[];\n  contextKeys: readonly PropertyKey[];\n  setup: (deps: any) => BehaviorCleanup;\n};\n\n/** Extract the deps type from a behavior's setup function. */\ntype DepsOf<B> = B extends { setup: (deps: infer D, ...args: any[]) => any } ? D : never;\n\n/**\n * Empty-object fallback used when a behavior omits state, context, or config.\n *\n * Using `{}` rather than `object` is deliberate — `object & {x: T}` collapses\n * to `{x: never}` under TS's union-to-intersection conversion in some inference\n * contexts (likely a TS quirk around the `object` upper bound), whereas\n * `{} & {x: T}` simplifies cleanly to `{x: T}`.\n */\n// biome-ignore lint/complexity/noBannedTypes: see comment above\ntype Empty = {};\n\n/**\n * Unwrap a signal map back to its state/context shape.\n *\n * Inferring through `{ get(): infer V }` rather than `Signal<infer V>`\n * sidesteps `Signal`'s nominal/invariance behaviour — the conditional\n * matches structurally on the read side, and `V` is inferred covariantly.\n */\ntype UnwrapSignals<M> = M extends object ? { [K in keyof M]: M[K] extends { get(): infer V } ? V : never } : Empty;\n\n/** Infer the state shape a behavior requires from its deps parameter. */\nexport type InferBehaviorState<F> = DepsOf<F> extends { state: infer M } ? UnwrapSignals<M> : Empty;\n\n/** Infer the context shape a behavior requires from its deps parameter. */\nexport type InferBehaviorContext<F> = DepsOf<F> extends { context: infer M } ? UnwrapSignals<M> : Empty;\n\n/** Infer the config shape a behavior requires from its deps parameter. */\nexport type InferBehaviorConfig<F> = DepsOf<F> extends { config: infer C extends object } ? C : Empty;\n\n/**\n * Recursively intersect a per-behavior projection across the tuple.\n *\n * Iterating over the tuple directly avoids `UnionToIntersection`'s\n * function-contravariance trick, which produces unstable intersections\n * (collapsing concrete fields to `never` or unrelated types) when one of the\n * union members is the empty `{}` fallback.\n */\ntype IntersectBehaviors<Behaviors extends readonly AnyBehavior[], Project extends object> = Behaviors extends readonly [\n  infer First extends AnyBehavior,\n  ...infer Rest extends readonly AnyBehavior[],\n]\n  ? Apply<Project, First> & IntersectBehaviors<Rest, Project>\n  : Empty;\n\n/**\n * Apply a projection (one of the marker types below) to a single behavior.\n * Encoded as a discriminated dispatch so the recursion above can stay generic\n * and we don't have to write three near-identical recursive types.\n */\ntype Apply<Project extends object, F> = Project extends { kind: 'state' }\n  ? InferBehaviorState<F>\n  : Project extends { kind: 'context' }\n    ? InferBehaviorContext<F>\n    : Project extends { kind: 'config' }\n      ? InferBehaviorConfig<F>\n      : never;\n\ntype StateProjection = { kind: 'state' };\ntype ContextProjection = { kind: 'context' };\ntype ConfigProjection = { kind: 'config' };\n\n/** Resolve the combined state shape from an array of behaviors (intersection of all requirements). */\nexport type ResolveBehaviorState<Behaviors extends readonly AnyBehavior[]> =\n  IntersectBehaviors<Behaviors, StateProjection> extends infer R extends object ? R : Empty;\n\n/** Resolve the combined context shape from an array of behaviors (intersection of all requirements). */\nexport type ResolveBehaviorContext<Behaviors extends readonly AnyBehavior[]> =\n  IntersectBehaviors<Behaviors, ContextProjection> extends infer R extends object ? R : Empty;\n\n/** Resolve the combined config shape from an array of behaviors (intersection of all requirements). */\nexport type ResolveBehaviorConfig<Behaviors extends readonly AnyBehavior[]> =\n  IntersectBehaviors<Behaviors, ConfigProjection> extends infer R extends object ? R : Empty;\n\n/**\n * True if any property in `T` collapsed to `undefined` or `never` — indicating\n * a type conflict from intersecting incompatible behavior requirements.\n *\n * - Required conflicts: `{ v: number } & { v: string }` → `{ v: never }` — caught via `[never] extends [undefined]`\n * - Optional conflicts: `{ v?: number } & { v?: string }` → `{ v?: undefined }` — caught directly\n */\ntype HasConflict<T extends object> = true extends {\n  [K in keyof T]: [T[K]] extends [undefined] ? true : never;\n}[keyof T]\n  ? true\n  : false;\n\n// =============================================================================\n// Composition validation\n// =============================================================================\n\n/**\n * Validate that a behavior composition has no type conflicts.\n * Returns the behaviors tuple if valid, or an error message type if conflicts are detected.\n *\n * State, context, and config are all checked the same way — by intersecting\n * each behavior's requirement and looking for collapsed fields. The\n * intersection-based check applies the same rule to context as to state, so\n * two behaviors that disagree on a context field's type (e.g. `Surface` vs\n * `VideoSurface`) surface a conflict at compose time. The prior subtype-based\n * approach for owners is gone — the unified rule is simpler and catches the\n * cases where two behaviors silently agreed on a wider supertype.\n */\ntype ValidateComposition<Behaviors extends readonly AnyBehavior[]> =\n  HasConflict<ResolveBehaviorState<Behaviors>> extends true\n    ? 'Error: behaviors have conflicting state types'\n    : HasConflict<ResolveBehaviorContext<Behaviors>> extends true\n      ? 'Error: behaviors have conflicting context types'\n      : HasConflict<ResolveBehaviorConfig<Behaviors>> extends true\n        ? 'Error: behaviors have conflicting config types'\n        : [...Behaviors];\n\n// =============================================================================\n// Composition\n// =============================================================================\n\n/**\n * A composition of behaviors with shared state and context signal maps.\n */\nexport interface Composition<S extends object, C extends object> {\n  state: StateSignals<S>;\n  context: ContextSignals<C>;\n  destroy(): Promise<void>;\n}\n\n/**\n * Options for `createComposition`.\n *\n * Composition derives the state and context signal maps from each\n * behavior's declared `stateKeys` / `contextKeys`; `initialState` and\n * `initialContext` seed those signals at creation time. Any unseeded\n * signal starts as `undefined`.\n */\nexport interface CompositionOptions<S extends object, C extends object, Cfg extends object> {\n  /** Static configuration passed to every behavior. */\n  config?: Cfg;\n  /** Initial values for state signals — any subset of `keyof S`. */\n  initialState?: Partial<S>;\n  /** Initial values for context signals — any subset of `keyof C`. */\n  initialContext?: Partial<C>;\n}\n\n/**\n * Create a composition from a set of behaviors.\n *\n * Composition unions the behaviors' declared `stateKeys` / `contextKeys`\n * to know which signals to create. Each signal is seeded from\n * `initialState` / `initialContext` when supplied, defaulting to\n * `undefined`. Behaviors are responsible for writing their own slots\n * once their preconditions are met.\n *\n * Cross-behavior type conflicts (e.g. two behaviors disagreeing on a\n * field's type) surface as a compose-time type error via\n * `ValidateComposition`.\n *\n * @example\n * ```ts\n * const composition = createComposition([resolvePresentation, switchVideoTrack], {\n *   config: { parsePresentation: parseMultivariantPlaylist, initialBandwidth: 2_000_000 },\n *   initialState: { bandwidthState: { fastEstimate: 0, ... } },\n * });\n * ```\n */\n/**\n * Create a typed signal map for a given set of keys, seeded from an\n * optional partial initial value.\n *\n * Pipeline: `Set` dedupes the iterable (insertion order preserved, so\n * first occurrence wins) → `Object.fromEntries` materializes one\n * `signal()` per unique key, seeded from `initial[key]` or `undefined`.\n *\n * Per-key value types live in TypeScript only — at runtime every signal\n * is `Signal<unknown>`. The boundary cast at the return narrows the wide\n * `Record<PropertyKey, Signal<unknown>>` shape to the caller's expected\n * per-key types from `S`.\n *\n * Used by `createComposition` to derive engine state/context maps from\n * the union of behaviors' declared `stateKeys` / `contextKeys`.\n *\n * @example\n * ```ts\n * interface State { count?: number; label?: string }\n * const state = buildSignalMap<State>(['count', 'label'], { count: 5 });\n * state.count.get(); // 5\n * state.label.get(); // undefined\n * ```\n */\nexport function buildSignalMap<S extends object>(\n  keys: Iterable<PropertyKey>,\n  initial: Partial<S>\n): { [K in keyof S]-?: Signal<S[K]> } {\n  const init = initial as Record<PropertyKey, unknown>;\n  const uniqueKeys = new Set(keys);\n  return Object.fromEntries([...uniqueKeys].map((key) => [key, signal(init[key])])) as {\n    [K in keyof S]-?: Signal<S[K]>;\n  };\n}\n\nexport function createComposition<const Behaviors extends readonly AnyBehavior[]>(\n  behaviors: ValidateComposition<Behaviors>,\n  options?: CompositionOptions<\n    ResolveBehaviorState<Behaviors>,\n    ResolveBehaviorContext<Behaviors>,\n    ResolveBehaviorConfig<Behaviors>\n  >\n): Composition<ResolveBehaviorState<Behaviors>, ResolveBehaviorContext<Behaviors>> {\n  type S = ResolveBehaviorState<Behaviors>;\n  type C = ResolveBehaviorContext<Behaviors>;\n  type Cfg = ResolveBehaviorConfig<Behaviors>;\n\n  // ValidateComposition<Behaviors> is `[...Behaviors]` on success, an error\n  // string on conflict. The function body only runs when the call typechecks\n  // (i.e. the success case), so iterating as the behavior tuple is sound.\n  const validBehaviors = behaviors as unknown as readonly AnyBehavior[];\n\n  const state = buildSignalMap<S>(\n    validBehaviors.flatMap((b) => b.stateKeys),\n    options?.initialState ?? {}\n  );\n  const context = buildSignalMap<C>(\n    validBehaviors.flatMap((b) => b.contextKeys),\n    options?.initialContext ?? {}\n  );\n\n  const deps: BehaviorDeps<StateSignals<S>, ContextSignals<C>, Cfg> = {\n    state,\n    context,\n    config: (options?.config ?? {}) as Cfg,\n  };\n  const cleanups = validBehaviors.map((behavior) => behavior.setup(deps));\n\n  return {\n    state,\n    context,\n    async destroy() {\n      const results: (void | Promise<void>)[] = [];\n      for (const cleanup of cleanups) {\n        if (cleanup == null) continue;\n        if (typeof cleanup === 'function') {\n          results.push(cleanup());\n        } else if ('destroy' in cleanup) {\n          results.push(cleanup.destroy());\n        }\n      }\n      await Promise.all(results);\n      // Reset every signal to undefined as a final cleanup, matching the\n      // prior post-destroy `owners.set({})` semantics. A later stage will\n      // move per-signal cleanup into the behaviors that own the writes.\n      for (const sig of Object.values(state) as Signal<unknown>[]) sig.set(undefined);\n      for (const sig of Object.values(context) as Signal<unknown>[]) sig.set(undefined);\n    },\n  };\n}\n\n// =============================================================================\n// defineBehavior — typed factory with key/param consistency enforcement\n// =============================================================================\n\n/**\n * Compose-time exhaustiveness check.\n *\n * Adds a phantom error tag to the parameter shape when `Keys` does not\n * cover every key in `Slot`. The user's value won't satisfy the phantom\n * field requirement, so TS surfaces the failure at the call site with a\n * descriptive message. When exhaustive, the tag is `Empty` and adds no\n * constraint.\n */\ntype ExhaustiveKeys<Keys extends readonly PropertyKey[], Slot extends object, Name extends string> = [\n  keyof Slot,\n] extends [Keys[number]]\n  ? Empty\n  : { [K in `Error: ${Name}Keys must list every key in the typed slice`]: Exclude<keyof Slot, Keys[number]> };\n\n/**\n * Typed factory for behaviors that enforces single-behavior key/param\n * consistency: declared `stateKeys` must equal `keyof S` (where `S` is\n * inferred from the setup's `state` parameter type), and same for\n * `contextKeys` / `C`.\n *\n * The `const` modifier on `SK` / `CK` captures literal tuples so e.g.\n * `stateKeys: ['preload']` infers as `readonly ['preload']`, no `as\n * const` needed at the call site.\n *\n * Cross-behavior consistency at `createComposition` is unchanged — the\n * existing `IntersectBehaviors` machinery still runs over each\n * behavior's setup param type.\n *\n * @example\n * ```ts\n * export const syncPreload = defineBehavior({\n *   stateKeys: ['preload'],\n *   contextKeys: ['mediaElement'],\n *   setup: ({ state, context }: {\n *     state: StateSignals<{ preload?: 'auto' | 'metadata' | 'none' }>;\n *     context: ContextSignals<{ mediaElement?: HTMLMediaElement | undefined }>;\n *   }) => { ... },\n * });\n * ```\n */\n/**\n * Deps shape for a behavior whose deps slot is empty (no keys). When a\n * slot is empty, the corresponding deps field is optional — callers\n * (typically tests) can omit it, and it defaults to `{}` at runtime via\n * `createComposition`.\n *\n * When a slot has at least one key, the behavior reads `state.foo` /\n * `context.bar` / `config.baz` and we need the field to be required so\n * the access is type-safe.\n */\ntype RequireIfNonEmpty<Key extends string, T extends object> = keyof T extends never\n  ? { [K in Key]?: T }\n  : { [K in Key]: T };\n\ntype DepsForCfg<StateMap extends AnySlotMap, ContextMap extends AnySlotMap, Cfg extends object> = RequireIfNonEmpty<\n  'state',\n  StateMap\n> &\n  RequireIfNonEmpty<'context', ContextMap> &\n  RequireIfNonEmpty<'config', Cfg>;\n\nexport function defineBehavior<\n  StateMap extends AnySlotMap = Empty,\n  ContextMap extends AnySlotMap = Empty,\n  Cfg extends object = Empty,\n  const SK extends readonly (keyof StateMap)[] = readonly [],\n  const CK extends readonly (keyof ContextMap)[] = readonly [],\n  R extends BehaviorCleanup = BehaviorCleanup,\n>(\n  behavior: {\n    stateKeys: SK;\n    contextKeys: CK;\n    setup: (deps: { state: StateMap; context: ContextMap; config: Cfg }) => R;\n  } & ExhaustiveKeys<SK, StateMap, 'state'> &\n    ExhaustiveKeys<CK, ContextMap, 'context'>\n): {\n  stateKeys: SK;\n  contextKeys: CK;\n  setup: (deps: DepsForCfg<StateMap, ContextMap, Cfg>) => R;\n} {\n  // The runtime shape is identical; the cast bridges TS's view of the\n  // parameter (config required) to the return view (config optional when\n  // Cfg has no keys).\n  return behavior as unknown as {\n    stateKeys: SK;\n    contextKeys: CK;\n    setup: (deps: DepsForCfg<StateMap, ContextMap, Cfg>) => R;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsSA,SAAgB,eACd,MACA,SACoC;CACpC,MAAM,OAAO;CACb,MAAM,aAAa,IAAI,IAAI,KAAK;AAChC,QAAO,OAAO,YAAY,CAAC,GAAG,WAAW,CAAC,KAAK,QAAQ,CAAC,KAAK,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC;;AAKnF,SAAgB,kBACd,WACA,SAKiF;CAQjF,MAAM,iBAAiB;CAEvB,MAAM,QAAQ,eACZ,eAAe,SAAS,MAAM,EAAE,UAAU,EAC1C,SAAS,gBAAgB,EAAE,CAC5B;CACD,MAAM,UAAU,eACd,eAAe,SAAS,MAAM,EAAE,YAAY,EAC5C,SAAS,kBAAkB,EAAE,CAC9B;CAED,MAAM,OAA8D;EAClE;EACA;EACA,QAAS,SAAS,UAAU,EAAE;EAC/B;CACD,MAAM,WAAW,eAAe,KAAK,aAAa,SAAS,MAAM,KAAK,CAAC;AAEvE,QAAO;EACL;EACA;EACA,MAAM,UAAU;GACd,MAAM,UAAoC,EAAE;AAC5C,QAAK,MAAM,WAAW,UAAU;AAC9B,QAAI,WAAW,KAAM;AACrB,QAAI,OAAO,YAAY,WACrB,SAAQ,KAAK,SAAS,CAAC;aACd,aAAa,QACtB,SAAQ,KAAK,QAAQ,SAAS,CAAC;;AAGnC,SAAM,QAAQ,IAAI,QAAQ;AAI1B,QAAK,MAAM,OAAO,OAAO,OAAO,MAAM,CAAuB,KAAI,IAAI,KAAA,EAAU;AAC/E,QAAK,MAAM,OAAO,OAAO,OAAO,QAAQ,CAAuB,KAAI,IAAI,KAAA,EAAU;;EAEpF;;AAqEH,SAAgB,eAQd,UAUA;AAIA,QAAO"}

package/dist/default/core/composition/share-signals.js

@@ -9,20 +9,22 @@
 * intent can be expressed by typing captured refs as `Signal<T>` or
 * `ReadonlySignal<T>` at the call site).
 *
-* Declares no keys of its own (`stateKeys: []`, `contextKeys: []`); the
-* composition's state/context maps come from other behaviors' key
-* declarations. This behavior just observes/forwards whatever signals
-* the composition built.
+* By default declares no keys; the composition's state/context maps come from
+* other behaviors. Pass `inputStateKeys` / `inputContextKeys` to *materialize*
+* consumer-input slots that no other behavior produces — a slot the consumer
+* writes (e.g. `userAudioTrackSelection`) but only a rule reads. shareSignals
+* is the consumer boundary, so it's the natural place to bring those slots into
+* existence; readers then treat them as optional.
 *
-* Uses a `Behavior<>` literal (not `defineBehavior`) so the empty key
-* arrays don't trip the exhaustiveness check — the setup-param state/
-* context shapes here describe what the consumer's callback receives,
-* not keys this behavior needs created.
+* Uses a `Behavior<>` literal (not `defineBehavior`) so its (possibly empty,
+* possibly partial) key arrays don't trip the exhaustiveness check — the
+* setup-param state/context shapes describe what the callback receives (the
+* full `S` / `C`), not the subset this behavior materializes.
 */
-function makeShareSignals() {
+function makeShareSignals(inputStateKeys = [], inputContextKeys = []) {
 	return {
-		stateKeys: [],
-		contextKeys: [],
+		stateKeys: inputStateKeys,
+		contextKeys: inputContextKeys,
 		setup: ({ state, context, config }) => {
 			config.onSignalsReady?.({
 				state,

package/dist/default/core/composition/share-signals.js.map

@@ -1 +1 @@
-{"version":3,"file":"share-signals.js","names":[],"sources":["../../../../src/core/composition/share-signals.ts"],"sourcesContent":["import type { Behavior, ContextSignals, StateSignals } from './create-composition';\n\n/**\n * Config consumed by the `shareSignals` behavior.\n *\n * The callback fires once during composition setup with the composition's\n * state and context signal refs. Capture them to drive the composition\n * externally (writes) or observe its state (reads).\n *\n * The callback runs while other behaviors are still in their setup phase —\n * for the typical \"capture refs, use later\" pattern this is fine (signal\n * refs are stable identities), but reading inside the callback may yield\n * only initial-seed values rather than what later behaviors write.\n */\nexport interface ShareSignalsConfig<S extends object, C extends object> {\n  onSignalsReady?: (signals: { state: StateSignals<S>; context: ContextSignals<C> }) => void;\n}\n\n/**\n * Behavior factory that hands the composition's signal refs to a\n * consumer-supplied callback (`config.onSignalsReady`) at setup time.\n *\n * Generic over `S` and `C` — the caller instantiates with their own\n * state/context types, and the callback's parameter shape is fully\n * type-driven from those. Suitable for both reads and writes (per-slot\n * intent can be expressed by typing captured refs as `Signal<T>` or\n * `ReadonlySignal<T>` at the call site).\n *\n * Declares no keys of its own (`stateKeys: []`, `contextKeys: []`); the\n * composition's state/context maps come from other behaviors' key\n * declarations. This behavior just observes/forwards whatever signals\n * the composition built.\n *\n * Uses a `Behavior<>` literal (not `defineBehavior`) so the empty key\n * arrays don't trip the exhaustiveness check — the setup-param state/\n * context shapes here describe what the consumer's callback receives,\n * not keys this behavior needs created.\n */\nexport function makeShareSignals<S extends object, C extends object>(): Behavior<\n  StateSignals<S>,\n  ContextSignals<C>,\n  ShareSignalsConfig<S, C>\n> {\n  return {\n    stateKeys: [],\n    contextKeys: [],\n    setup: ({ state, context, config }) => {\n      config.onSignalsReady?.({ state, context });\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,mBAId;AACA,QAAO;EACL,WAAW,EAAE;EACb,aAAa,EAAE;EACf,QAAQ,EAAE,OAAO,SAAS,aAAa;AACrC,UAAO,iBAAiB;IAAE;IAAO;IAAS,CAAC;;EAE9C"}
+{"version":3,"file":"share-signals.js","names":[],"sources":["../../../../src/core/composition/share-signals.ts"],"sourcesContent":["import type { Behavior, ContextSignals, StateSignals } from './create-composition';\n\n/**\n * Config consumed by the `shareSignals` behavior.\n *\n * The callback fires once during composition setup with the composition's\n * state and context signal refs. Capture them to drive the composition\n * externally (writes) or observe its state (reads).\n *\n * The callback runs while other behaviors are still in their setup phase —\n * for the typical \"capture refs, use later\" pattern this is fine (signal\n * refs are stable identities), but reading inside the callback may yield\n * only initial-seed values rather than what later behaviors write.\n */\nexport interface ShareSignalsConfig<S extends object, C extends object> {\n  onSignalsReady?: (signals: { state: StateSignals<S>; context: ContextSignals<C> }) => void;\n}\n\n/**\n * Behavior factory that hands the composition's signal refs to a\n * consumer-supplied callback (`config.onSignalsReady`) at setup time.\n *\n * Generic over `S` and `C` — the caller instantiates with their own\n * state/context types, and the callback's parameter shape is fully\n * type-driven from those. Suitable for both reads and writes (per-slot\n * intent can be expressed by typing captured refs as `Signal<T>` or\n * `ReadonlySignal<T>` at the call site).\n *\n * By default declares no keys; the composition's state/context maps come from\n * other behaviors. Pass `inputStateKeys` / `inputContextKeys` to *materialize*\n * consumer-input slots that no other behavior produces — a slot the consumer\n * writes (e.g. `userAudioTrackSelection`) but only a rule reads. shareSignals\n * is the consumer boundary, so it's the natural place to bring those slots into\n * existence; readers then treat them as optional.\n *\n * Uses a `Behavior<>` literal (not `defineBehavior`) so its (possibly empty,\n * possibly partial) key arrays don't trip the exhaustiveness check — the\n * setup-param state/context shapes describe what the callback receives (the\n * full `S` / `C`), not the subset this behavior materializes.\n */\nexport function makeShareSignals<S extends object, C extends object>(\n  inputStateKeys: readonly (keyof S)[] = [],\n  inputContextKeys: readonly (keyof C)[] = []\n): Behavior<StateSignals<S>, ContextSignals<C>, ShareSignalsConfig<S, C>> {\n  return {\n    stateKeys: inputStateKeys,\n    contextKeys: inputContextKeys,\n    setup: ({ state, context, config }) => {\n      config.onSignalsReady?.({ state, context });\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,iBACd,iBAAuC,EAAE,EACzC,mBAAyC,EAAE,EAC6B;AACxE,QAAO;EACL,WAAW;EACX,aAAa;EACb,QAAQ,EAAE,OAAO,SAAS,aAAa;AACrC,UAAO,iBAAiB;IAAE;IAAO;IAAS,CAAC;;EAE9C"}

package/dist/default/hls.js

@@ -1,3 +1,5 @@
 import { createSimpleHlsEngine } from "./playback/engines/hls/engine.js";
 import { SimpleHlsMediaElement, SimpleHlsMediaMixin, simpleHlsMediaDefaultProps } from "./playback/engines/hls/adapter.js";
-export { SimpleHlsMediaElement, SimpleHlsMediaMixin, createSimpleHlsEngine, simpleHlsMediaDefaultProps };
+import { createHlsAudioOnlyEngine } from "./playback/engines/hls/engine-audio-only.js";
+import { SimpleHlsAudioOnlyMediaElement, SimpleHlsAudioOnlyMediaMixin, simpleHlsAudioOnlyMediaDefaultProps } from "./playback/engines/hls/adapter-audio-only.js";
+export { SimpleHlsAudioOnlyMediaElement, SimpleHlsAudioOnlyMediaMixin, SimpleHlsMediaElement, SimpleHlsMediaMixin, createHlsAudioOnlyEngine, createSimpleHlsEngine, simpleHlsAudioOnlyMediaDefaultProps, simpleHlsMediaDefaultProps };

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

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

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

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

package/dist/default/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/default/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/default/media/dom/mse/mediasource-setup.js

@@ -186,6 +186,6 @@ function waitForMediaSourceOpen(mediaSource, signal) {
 	});
 }
 //#endregion
-export { attachMediaSource, buildMimeCodec, createMediaSource, createSourceBuffer, onMediaSourceReadyStateChange, waitForMediaSourceOpen };
+export { attachMediaSource, buildMimeCodec, createMediaSource, createSourceBuffer, isCodecSupported, onMediaSourceReadyStateChange, waitForMediaSourceOpen };
 
 //# sourceMappingURL=mediasource-setup.js.map

package/dist/default/media/dom/text/text-track-slots.js

@@ -1,3 +1,4 @@
+import { isCaptionOrSubtitleTrack } from "@videojs/utils/dom";
 //#region src/media/dom/text/text-track-slots.ts
 /**
 * SPF-owned `<track>` selector. Each slot created by
@@ -23,7 +24,6 @@ function addSubtitlesTracksToMedia(mediaElement, modelTextTracks) {
 		el.label = modelTrack.label;
 		el.toggleAttribute("data-src-track", true);
 		if (modelTrack.language) el.srclang = modelTrack.language;
-		if (modelTrack.default) el.default = true;
 		mediaElement.appendChild(el);
 	}
 }
@@ -38,7 +38,7 @@ function getShowingSubtitlesTrackFromMedia(mediaElement) {
 	const elements = mediaElement.querySelectorAll(SPF_TRACK_SELECTOR);
 	for (const el of elements) {
 		const track = el.track;
-		if (track.mode === "showing" && (track.kind === "subtitles" || track.kind === "captions")) return track;
+		if (track.mode === "showing" && isCaptionOrSubtitleTrack(track)) return track;
 	}
 }
 /**
@@ -59,7 +59,7 @@ function removeAllSubtitlesTracksFromMedia(mediaElement) {
 function syncTextTrackModes(textTracks, selectedId) {
 	for (let i = 0; i < textTracks.length; i++) {
 		const track = textTracks[i];
-		if (track.kind !== "subtitles" && track.kind !== "captions") continue;
+		if (!isCaptionOrSubtitleTrack(track)) continue;
 		track.mode = track.id === selectedId ? "showing" : "disabled";
 	}
 }

package/dist/default/media/dom/text/text-track-slots.js.map

@@ -1 +1 @@
-{"version":3,"file":"text-track-slots.js","names":[],"sources":["../../../../../src/media/dom/text/text-track-slots.ts"],"sourcesContent":["import type { PartiallyResolvedTextTrack, TextTrack } from '../../types';\n\n/**\n * SPF-owned `<track>` selector. Each slot created by\n * `addSubtitlesTracksToMedia` carries this attribute so reads and removals can\n * filter SPF-owned tracks from host-page-owned ones.\n */\nconst SPF_TRACK_SELECTOR = 'track[data-src-track]';\n\n/**\n * Allocate text-track slots on `mediaElement` for each model track by creating\n * and appending `<track>` children. Marks each element with `data-src-track`\n * so it can be distinguished from `<track>` children the host page added\n * directly — used by `getShowingSubtitlesTrackFromMedia` and\n * `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to\n * SPF-owned slots. The spec has no `removeTextTrack` API, so creating\n * `<track>` elements is the only mechanism for adding *and* removing entries\n * to `mediaElement.textTracks`.\n */\nexport function addSubtitlesTracksToMedia(\n  mediaElement: HTMLMediaElement,\n  modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n): void {\n  for (const modelTrack of modelTextTracks) {\n    const el = document.createElement('track');\n    el.id = modelTrack.id;\n    el.kind = modelTrack.kind;\n    el.label = modelTrack.label;\n    el.toggleAttribute('data-src-track', true);\n    if (modelTrack.language) el.srclang = modelTrack.language;\n    if (modelTrack.default) el.default = true;\n    mediaElement.appendChild(el);\n  }\n}\n\n/**\n * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`\n * mode, or `undefined` if none. Restricts the search to slots created by\n * `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing\n * track that the host page added directly is ignored — SPF selection only\n * mirrors tracks it owns.\n */\nexport function getShowingSubtitlesTrackFromMedia(mediaElement: HTMLMediaElement): globalThis.TextTrack | undefined {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n  for (const el of elements) {\n    const track = el.track;\n    if (track.mode === 'showing' && (track.kind === 'subtitles' || track.kind === 'captions')) {\n      return track;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Remove every SPF-owned `<track>` child from `mediaElement` (those tagged\n * with `data-src-track` by `addSubtitlesTracksToMedia`). `<track>` elements\n * the host page added directly are left in place.\n */\nexport function removeAllSubtitlesTracksFromMedia(mediaElement: HTMLMediaElement): void {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n  for (const el of elements) {\n    el.remove();\n  }\n}\n\n/**\n * Apply a selection to a `TextTrackList` by setting each subtitle/caption\n * track's `mode` to `'showing'` if its `id` matches `selectedId` and\n * `'disabled'` otherwise. Tracks of other kinds (chapters, metadata,\n * descriptions) are left untouched — they may be owned by the host page.\n */\nexport function syncTextTrackModes(textTracks: TextTrackList, selectedId: string | undefined): void {\n  for (let i = 0; i < textTracks.length; i++) {\n    const track = textTracks[i]!;\n    if (track.kind !== 'subtitles' && track.kind !== 'captions') continue;\n    track.mode = track.id === selectedId ? 'showing' : 'disabled';\n  }\n}\n"],"mappings":";;;;;;AAOA,MAAM,qBAAqB;;;;;;;;;;;AAY3B,SAAgB,0BACd,cACA,iBACM;AACN,MAAK,MAAM,cAAc,iBAAiB;EACxC,MAAM,KAAK,SAAS,cAAc,QAAQ;AAC1C,KAAG,KAAK,WAAW;AACnB,KAAG,OAAO,WAAW;AACrB,KAAG,QAAQ,WAAW;AACtB,KAAG,gBAAgB,kBAAkB,KAAK;AAC1C,MAAI,WAAW,SAAU,IAAG,UAAU,WAAW;AACjD,MAAI,WAAW,QAAS,IAAG,UAAU;AACrC,eAAa,YAAY,GAAG;;;;;;;;;;AAWhC,SAAgB,kCAAkC,cAAkE;CAClH,MAAM,WAAW,aAAa,iBAAmC,mBAAmB;AACpF,MAAK,MAAM,MAAM,UAAU;EACzB,MAAM,QAAQ,GAAG;AACjB,MAAI,MAAM,SAAS,cAAc,MAAM,SAAS,eAAe,MAAM,SAAS,YAC5E,QAAO;;;;;;;;AAWb,SAAgB,kCAAkC,cAAsC;CACtF,MAAM,WAAW,aAAa,iBAAmC,mBAAmB;AACpF,MAAK,MAAM,MAAM,SACf,IAAG,QAAQ;;;;;;;;AAUf,SAAgB,mBAAmB,YAA2B,YAAsC;AAClG,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,QAAQ,WAAW;AACzB,MAAI,MAAM,SAAS,eAAe,MAAM,SAAS,WAAY;AAC7D,QAAM,OAAO,MAAM,OAAO,aAAa,YAAY"}
+{"version":3,"file":"text-track-slots.js","names":[],"sources":["../../../../../src/media/dom/text/text-track-slots.ts"],"sourcesContent":["import { isCaptionOrSubtitleTrack } from '@videojs/utils/dom';\n\nimport type { PartiallyResolvedTextTrack, TextTrack } from '../../types';\n\n/**\n * SPF-owned `<track>` selector. Each slot created by\n * `addSubtitlesTracksToMedia` carries this attribute so reads and removals can\n * filter SPF-owned tracks from host-page-owned ones.\n */\nconst SPF_TRACK_SELECTOR = 'track[data-src-track]';\n\n/**\n * Allocate text-track slots on `mediaElement` for each model track by creating\n * and appending `<track>` children. Marks each element with `data-src-track`\n * so it can be distinguished from `<track>` children the host page added\n * directly — used by `getShowingSubtitlesTrackFromMedia` and\n * `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to\n * SPF-owned slots. The spec has no `removeTextTrack` API, so creating\n * `<track>` elements is the only mechanism for adding *and* removing entries\n * to `mediaElement.textTracks`.\n */\nexport function addSubtitlesTracksToMedia(\n  mediaElement: HTMLMediaElement,\n  modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n): void {\n  for (const modelTrack of modelTextTracks) {\n    const el = document.createElement('track');\n    el.id = modelTrack.id;\n    el.kind = modelTrack.kind;\n    el.label = modelTrack.label;\n    el.toggleAttribute('data-src-track', true);\n    if (modelTrack.language) el.srclang = modelTrack.language;\n    // Deliberately NOT propagating `modelTrack.default` to the `default`\n    // attribute: that makes the browser auto-activate the slot on insertion,\n    // which fires a `change` that `syncTextTracks` records as user intent —\n    // auto-enabling captions past SPF's opt-in policy (`enableDefaultTrack`\n    // governs DEFAULT=YES handling in `switchTextTrack`, not the browser). SPF\n    // owns selection; these slots are containers, so they carry no selection hint.\n    mediaElement.appendChild(el);\n  }\n}\n\n/**\n * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`\n * mode, or `undefined` if none. Restricts the search to slots created by\n * `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing\n * track that the host page added directly is ignored — SPF selection only\n * mirrors tracks it owns.\n */\nexport function getShowingSubtitlesTrackFromMedia(mediaElement: HTMLMediaElement): globalThis.TextTrack | undefined {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n  for (const el of elements) {\n    const track = el.track;\n    if (track.mode === 'showing' && isCaptionOrSubtitleTrack(track)) {\n      return track;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Remove every SPF-owned `<track>` child from `mediaElement` (those tagged\n * with `data-src-track` by `addSubtitlesTracksToMedia`). `<track>` elements\n * the host page added directly are left in place.\n */\nexport function removeAllSubtitlesTracksFromMedia(mediaElement: HTMLMediaElement): void {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n  for (const el of elements) {\n    el.remove();\n  }\n}\n\n/**\n * Apply a selection to a `TextTrackList` by setting each subtitle/caption\n * track's `mode` to `'showing'` if its `id` matches `selectedId` and\n * `'disabled'` otherwise. Tracks of other kinds (chapters, metadata,\n * descriptions) are left untouched — they may be owned by the host page.\n */\nexport function syncTextTrackModes(textTracks: TextTrackList, selectedId: string | undefined): void {\n  for (let i = 0; i < textTracks.length; i++) {\n    const track = textTracks[i]!;\n    if (!isCaptionOrSubtitleTrack(track)) continue;\n    track.mode = track.id === selectedId ? 'showing' : 'disabled';\n  }\n}\n"],"mappings":";;;;;;;AASA,MAAM,qBAAqB;;;;;;;;;;;AAY3B,SAAgB,0BACd,cACA,iBACM;AACN,MAAK,MAAM,cAAc,iBAAiB;EACxC,MAAM,KAAK,SAAS,cAAc,QAAQ;AAC1C,KAAG,KAAK,WAAW;AACnB,KAAG,OAAO,WAAW;AACrB,KAAG,QAAQ,WAAW;AACtB,KAAG,gBAAgB,kBAAkB,KAAK;AAC1C,MAAI,WAAW,SAAU,IAAG,UAAU,WAAW;AAOjD,eAAa,YAAY,GAAG;;;;;;;;;;AAWhC,SAAgB,kCAAkC,cAAkE;CAClH,MAAM,WAAW,aAAa,iBAAmC,mBAAmB;AACpF,MAAK,MAAM,MAAM,UAAU;EACzB,MAAM,QAAQ,GAAG;AACjB,MAAI,MAAM,SAAS,aAAa,yBAAyB,MAAM,CAC7D,QAAO;;;;;;;;AAWb,SAAgB,kCAAkC,cAAsC;CACtF,MAAM,WAAW,aAAa,iBAAmC,mBAAmB;AACpF,MAAK,MAAM,MAAM,SACf,IAAG,QAAQ;;;;;;;;AAUf,SAAgB,mBAAmB,YAA2B,YAAsC;AAClG,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,QAAQ,WAAW;AACzB,MAAI,CAAC,yBAAyB,MAAM,CAAE;AACtC,QAAM,OAAO,MAAM,OAAO,aAAa,YAAY"}

package/dist/default/media/hls/parse-attributes.js

@@ -44,14 +44,28 @@ function parseFrameRate(value) {
 	if (fps % 1 === 0) return { frameRateNumerator: Math.round(fps) };
 	return { frameRateNumerator: Math.round(fps) };
 }
+const AUDIO_CODEC_PREFIXES = [
+	"mp4a.",
+	"ac-3",
+	"ec-3",
+	"ac-4",
+	"opus",
+	"flac",
+	"dts",
+	"alac",
+	"vorbis"
+];
 /**
 * Parse CODECS attribute into separate video and audio codecs.
 */
 function parseCodecs(codecs) {
 	const parts = codecs.split(",").map((s) => s.trim());
 	const result = {};
-	for (const codec of parts) if (codec.startsWith("avc1.") || codec.startsWith("hvc1.") || codec.startsWith("hev1.")) result.video = codec;
-	else if (codec.startsWith("mp4a.")) result.audio = codec;
+	for (const codec of parts) {
+		const lower = codec.toLowerCase();
+		if (codec.startsWith("avc1.") || codec.startsWith("hvc1.") || codec.startsWith("hev1.")) result.video = codec;
+		else if (AUDIO_CODEC_PREFIXES.some((prefix) => lower.startsWith(prefix))) result.audio = codec;
+	}
 	return result;
 }
 /**

package/dist/default/media/hls/parse-attributes.js.map

@@ -1 +1 @@
-{"version":3,"file":"parse-attributes.js","names":[],"sources":["../../../../src/media/hls/parse-attributes.ts"],"sourcesContent":["import type { FrameRate } from '../types';\n\n/**\n * Parse HLS attribute list from a tag line.\n * Handles both quoted and unquoted values.\n */\nexport function parseAttributeList(line: string): Map<string, string> {\n  const attributes = new Map<string, string>();\n  const regex = /([A-Z0-9-]+)=(?:\"([^\"]*)\"|([^,]*))/g;\n\n  for (const match of line.matchAll(regex)) {\n    const key = match[1];\n    const value = match[2] ?? match[3] ?? '';\n    if (key) {\n      attributes.set(key, value);\n    }\n  }\n\n  return attributes;\n}\n\n/**\n * Parse RESOLUTION attribute value (WIDTHxHEIGHT).\n */\nexport function parseResolution(value: string): { width: number; height: number } | null {\n  const match = /^(\\d+)x(\\d+)$/.exec(value);\n  if (!match) return null;\n\n  const width = Number.parseInt(match[1]!, 10);\n  const height = Number.parseInt(match[2]!, 10);\n\n  return { width, height };\n}\n\n/**\n * Parse FRAME-RATE attribute to rational frame rate.\n */\nexport function parseFrameRate(value: string): FrameRate | undefined {\n  const fps = Number.parseFloat(value);\n  if (Number.isNaN(fps) || fps <= 0) return undefined;\n\n  // Common frame rates with tolerance for floating point precision\n  if (Math.abs(fps - 23.976) < 0.01) {\n    return { frameRateNumerator: 24000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 29.97) < 0.01) {\n    return { frameRateNumerator: 30000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 59.94) < 0.01) {\n    return { frameRateNumerator: 60000, frameRateDenominator: 1001 };\n  }\n\n  // Integer frame rates\n  if (fps % 1 === 0) {\n    return { frameRateNumerator: Math.round(fps) };\n  }\n\n  // Default: use rounded value\n  return { frameRateNumerator: Math.round(fps) };\n}\n\n/**\n * Parse CODECS attribute into separate video and audio codecs.\n */\nexport function parseCodecs(codecs: string): { video?: string; audio?: string } {\n  const parts = codecs.split(',').map((s) => s.trim());\n  const result: { video?: string; audio?: string } = {};\n\n  for (const codec of parts) {\n    if (codec.startsWith('avc1.') || codec.startsWith('hvc1.') || codec.startsWith('hev1.')) {\n      result.video = codec;\n    } else if (codec.startsWith('mp4a.')) {\n      result.audio = codec;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse #EXTINF duration value.\n */\nexport function parseExtInfDuration(value: string): number {\n  const durationPart = value.split(',')[0] ?? value;\n  const duration = Number.parseFloat(durationPart);\n  return Number.isNaN(duration) ? 0 : duration;\n}\n\n/**\n * Parse BYTERANGE attribute value.\n * Format: \"length[@offset]\"\n * If offset is omitted, it continues from the previous byte range end.\n */\nexport function parseByteRange(value: string, previousEnd?: number): { start: number; end: number } | null {\n  const match = /^(\\d+)(?:@(\\d+))?$/.exec(value);\n  if (!match) return null;\n\n  const length = Number.parseInt(match[1]!, 10);\n  if (Number.isNaN(length)) return null;\n\n  let start: number;\n  if (match[2] !== undefined) {\n    start = Number.parseInt(match[2], 10);\n    if (Number.isNaN(start)) return null;\n  } else if (previousEnd !== undefined) {\n    start = previousEnd;\n  } else {\n    return null;\n  }\n\n  return { start, end: start + length - 1 };\n}\n\n/**\n * AttributeList - Typed attribute access wrapper.\n */\nexport interface AttributeList {\n  get: (key: string) => string | undefined;\n  getInt: (key: string, defaultValue?: number) => number | undefined;\n  getFloat: (key: string, defaultValue?: number) => number | undefined;\n  getBool: (key: string) => boolean;\n  getResolution: (key: string) => { width: number; height: number } | undefined;\n  getFrameRate: (key: string) => FrameRate | undefined;\n}\n\n/**\n * Create AttributeList from raw attribute string.\n */\nexport function createAttributeList(line: string): AttributeList {\n  const map = parseAttributeList(line);\n\n  return {\n    get(key: string): string | undefined {\n      return map.get(key);\n    },\n\n    getInt(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseInt(value, 10);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getFloat(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseFloat(value);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getBool(key: string): boolean {\n      return map.get(key) === 'YES';\n    },\n\n    getResolution(key: string): { width: number; height: number } | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseResolution(value) ?? undefined;\n    },\n\n    getFrameRate(key: string): FrameRate | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseFrameRate(value);\n    },\n  };\n}\n\n/**\n * Match a tag and extract its attributes.\n * Returns null if the line doesn't match the tag.\n */\nexport function matchTag(line: string, tag: string): AttributeList | null {\n  const prefix = `#${tag}:`;\n  if (!line.startsWith(prefix)) return null;\n  return createAttributeList(line.slice(prefix.length));\n}\n"],"mappings":"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"}
+{"version":3,"file":"parse-attributes.js","names":[],"sources":["../../../../src/media/hls/parse-attributes.ts"],"sourcesContent":["import type { FrameRate } from '../types';\n\n/**\n * Parse HLS attribute list from a tag line.\n * Handles both quoted and unquoted values.\n */\nexport function parseAttributeList(line: string): Map<string, string> {\n  const attributes = new Map<string, string>();\n  const regex = /([A-Z0-9-]+)=(?:\"([^\"]*)\"|([^,]*))/g;\n\n  for (const match of line.matchAll(regex)) {\n    const key = match[1];\n    const value = match[2] ?? match[3] ?? '';\n    if (key) {\n      attributes.set(key, value);\n    }\n  }\n\n  return attributes;\n}\n\n/**\n * Parse RESOLUTION attribute value (WIDTHxHEIGHT).\n */\nexport function parseResolution(value: string): { width: number; height: number } | null {\n  const match = /^(\\d+)x(\\d+)$/.exec(value);\n  if (!match) return null;\n\n  const width = Number.parseInt(match[1]!, 10);\n  const height = Number.parseInt(match[2]!, 10);\n\n  return { width, height };\n}\n\n/**\n * Parse FRAME-RATE attribute to rational frame rate.\n */\nexport function parseFrameRate(value: string): FrameRate | undefined {\n  const fps = Number.parseFloat(value);\n  if (Number.isNaN(fps) || fps <= 0) return undefined;\n\n  // Common frame rates with tolerance for floating point precision\n  if (Math.abs(fps - 23.976) < 0.01) {\n    return { frameRateNumerator: 24000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 29.97) < 0.01) {\n    return { frameRateNumerator: 30000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 59.94) < 0.01) {\n    return { frameRateNumerator: 60000, frameRateDenominator: 1001 };\n  }\n\n  // Integer frame rates\n  if (fps % 1 === 0) {\n    return { frameRateNumerator: Math.round(fps) };\n  }\n\n  // Default: use rounded value\n  return { frameRateNumerator: Math.round(fps) };\n}\n\n// Audio codec identifiers, matched case-insensitively against each CODECS\n// entry's prefix. Beyond AAC (`mp4a.*`): Dolby (`ac-3`, `ec-3`, `ac-4`), Opus,\n// FLAC (`fLaC`), DTS (`dts*`), ALAC, and Vorbis. Recognizing these is what lets\n// capability probing filter undecodable audio renditions (e.g. an AC-3 5.1\n// track on a browser without AC-3) — an unrecognized codec parses empty and is\n// treated as unprobeable, so it would never be pruned.\nconst AUDIO_CODEC_PREFIXES = ['mp4a.', 'ac-3', 'ec-3', 'ac-4', 'opus', 'flac', 'dts', 'alac', 'vorbis'];\n\n/**\n * Parse CODECS attribute into separate video and audio codecs.\n */\nexport function parseCodecs(codecs: string): { video?: string; audio?: string } {\n  const parts = codecs.split(',').map((s) => s.trim());\n  const result: { video?: string; audio?: string } = {};\n\n  for (const codec of parts) {\n    const lower = codec.toLowerCase();\n    if (codec.startsWith('avc1.') || codec.startsWith('hvc1.') || codec.startsWith('hev1.')) {\n      result.video = codec;\n    } else if (AUDIO_CODEC_PREFIXES.some((prefix) => lower.startsWith(prefix))) {\n      result.audio = codec;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse #EXTINF duration value.\n */\nexport function parseExtInfDuration(value: string): number {\n  const durationPart = value.split(',')[0] ?? value;\n  const duration = Number.parseFloat(durationPart);\n  return Number.isNaN(duration) ? 0 : duration;\n}\n\n/**\n * Parse BYTERANGE attribute value.\n * Format: \"length[@offset]\"\n * If offset is omitted, it continues from the previous byte range end.\n */\nexport function parseByteRange(value: string, previousEnd?: number): { start: number; end: number } | null {\n  const match = /^(\\d+)(?:@(\\d+))?$/.exec(value);\n  if (!match) return null;\n\n  const length = Number.parseInt(match[1]!, 10);\n  if (Number.isNaN(length)) return null;\n\n  let start: number;\n  if (match[2] !== undefined) {\n    start = Number.parseInt(match[2], 10);\n    if (Number.isNaN(start)) return null;\n  } else if (previousEnd !== undefined) {\n    start = previousEnd;\n  } else {\n    return null;\n  }\n\n  return { start, end: start + length - 1 };\n}\n\n/**\n * AttributeList - Typed attribute access wrapper.\n */\nexport interface AttributeList {\n  get: (key: string) => string | undefined;\n  getInt: (key: string, defaultValue?: number) => number | undefined;\n  getFloat: (key: string, defaultValue?: number) => number | undefined;\n  getBool: (key: string) => boolean;\n  getResolution: (key: string) => { width: number; height: number } | undefined;\n  getFrameRate: (key: string) => FrameRate | undefined;\n}\n\n/**\n * Create AttributeList from raw attribute string.\n */\nexport function createAttributeList(line: string): AttributeList {\n  const map = parseAttributeList(line);\n\n  return {\n    get(key: string): string | undefined {\n      return map.get(key);\n    },\n\n    getInt(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseInt(value, 10);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getFloat(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseFloat(value);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getBool(key: string): boolean {\n      return map.get(key) === 'YES';\n    },\n\n    getResolution(key: string): { width: number; height: number } | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseResolution(value) ?? undefined;\n    },\n\n    getFrameRate(key: string): FrameRate | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseFrameRate(value);\n    },\n  };\n}\n\n/**\n * Match a tag and extract its attributes.\n * Returns null if the line doesn't match the tag.\n */\nexport function matchTag(line: string, tag: string): AttributeList | null {\n  const prefix = `#${tag}:`;\n  if (!line.startsWith(prefix)) return null;\n  return createAttributeList(line.slice(prefix.length));\n}\n"],"mappings":"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"}

package/dist/default/media/hls/parse-media-playlist.js

@@ -1,6 +1,26 @@
 import { matchTag, parseByteRange, parseExtInfDuration } from "./parse-attributes.js";
 import { resolveUrl } from "./resolve-url.js";
-//#region src/media/hls/parse-media-playlist.ts
+const CONTAINER_MIME_BY_EXTENSION = {
+	".ts": "video/mp2t",
+	".aac": "audio/aac"
+};
+/** The non-fMP4 container MIMEs the parser detects — all currently treated as unplayable. */
+const NON_FMP4_CONTAINER_MIMES = new Set(Object.values(CONTAINER_MIME_BY_EXTENSION));
+/**
+* Non-fMP4 container MIME for a (resolved, absolute) segment URL, by file
+* extension, ignoring the query string. `undefined` for fMP4 / unrecognized.
+*/
+function containerMimeFromSegment(url) {
+	if (!url) return void 0;
+	let path;
+	try {
+		path = new URL(url).pathname.toLowerCase();
+	} catch {
+		path = url.toLowerCase().split("?")[0] ?? "";
+	}
+	const dot = path.lastIndexOf(".");
+	return dot === -1 ? void 0 : CONTAINER_MIME_BY_EXTENSION[path.slice(dot)];
+}
 /**
 * Parse HLS media playlist and resolve track with segments.
 *
@@ -68,8 +88,11 @@ function parseMediaPlaylist(text, unresolved) {
 		url: initSegmentUrl,
 		...initSegmentByteRange ? { byteRange: initSegmentByteRange } : {}
 	} : { url: "" };
+	const detectedContainer = initSegmentUrl ? void 0 : containerMimeFromSegment(segments[0]?.url);
+	const mimeType = unresolved.type !== "text" && detectedContainer ? detectedContainer : unresolved.mimeType;
 	return {
 		...unresolved,
+		mimeType,
 		startTime: 0,
 		duration: totalDuration,
 		segments,
@@ -77,6 +100,6 @@ function parseMediaPlaylist(text, unresolved) {
 	};
 }
 //#endregion
-export { parseMediaPlaylist };
+export { NON_FMP4_CONTAINER_MIMES, parseMediaPlaylist };
 
 //# sourceMappingURL=parse-media-playlist.js.map