@videojs/spf 10.0.0-beta.28 → 10.0.0-beta.29

package/dist/dev/playback/primitives/selection-rules.js

@@ -0,0 +1,85 @@
+//#region src/playback/primitives/selection-rules.ts
+/**
+* Apply rules to a candidate list in order; the pick is the first survivor.
+* Two responsibilities the rules don't carry: a rule that returns nothing is
+* skipped (fall-through — a preference never empties the set), and once one
+* survivor remains the chain stops (early-bail — later rules, including the
+* bandwidth ranker, never run, so the effect doesn't subscribe to their
+* signals while the choice is fixed).
+*
+* @param rules - Rules to apply, most authoritative first
+* @param tracks - Candidate tracks
+* @param deps - The behavior's `{ state, context, config }`, passed through to each rule
+* @returns The surviving candidates, pick first
+*/
+function applyRules(rules, tracks, deps) {
+	let current = tracks;
+	for (const rule of rules) {
+		const remaining = rule(current, deps);
+		if (remaining.length === 0) continue;
+		current = remaining;
+		if (current.length === 1) break;
+	}
+	return current;
+}
+/**
+* Apply hard constraints to a candidate list — the pre-pass that runs before the
+* rule chain. A constraint shares a rule's signature but its exclusion is
+* *hard*: it removes the unplayable (a codec the environment can't decode, a CDN
+* in failover cooldown) and a removed track is never attempted. Unlike
+* `applyRules`, this never skips an empty result and never early-bails — every
+* constraint always applies, and an empty survivor set is a real outcome
+* ("nothing playable here"), not a fall-through. Because each constraint only
+* removes, the order they run in can't change the result.
+*
+* @param constraints - Constraints to apply (pooled, order-independent)
+* @param tracks - Candidate tracks
+* @param deps - The behavior's `{ state, context, config }`, passed to each constraint
+* @returns The playable survivors (possibly empty)
+*/
+function applyConstraints(constraints, tracks, deps) {
+	let current = tracks;
+	for (const constraint of constraints) current = constraint(current, deps);
+	return current;
+}
+/**
+* Whether two candidate sets hold the same tracks, by id.
+*
+* The `equals` both selection behaviors give their candidate-set `computed`. A
+* live playlist refresh swaps in a new presentation object carrying the same
+* variants, and a constraint's own inputs can churn without changing which
+* tracks survive; in both cases the set is unchanged and the reaction must not
+* re-fire. Compares by id rather than array identity for exactly that.
+*/
+function sameCandidateSet(a, b) {
+	return a.length === b.length && a.every((track) => b.some((other) => other.id === track.id));
+}
+/**
+* Capability constraint — a *hard* filter for the {@link applyConstraints}
+* pre-pass. Removes renditions this environment can't decode, probed via the
+* injected `canPlayTrack` (codec → `MediaSource.isTypeSupported`, plus the
+* container and encryption assertions that probe can't make). Constraining here
+* — before selection — means an unplayable variant is pruned upstream and never
+* picked, instead of surviving into the pipeline to fail late at
+* `createSourceBuffer`. That late throw stays as a defensive structural
+* guarantee; with this constraint it should rarely fire.
+*
+* Lives here rather than beside `switchVideoTrack` for the reason this module
+* exists: both the re-evaluating variant and the pinned `selectVideoTrack` apply
+* it, and reaching it through `behaviors/track-switching.ts` would drag the ABR
+* path into a composition that deliberately omits it.
+*
+* Passes everything through when there's no probe (a composition that didn't
+* wire one, or DOM-free tests). When it prunes *every* track, the empty result is
+* preserved (per `applyConstraints`) — "nothing playable" — which each consuming
+* behavior answers by clearing its selection and reporting the type's verdict.
+*/
+function excludeUnplayableTracks(tracks, { config }) {
+	const canPlay = config?.canPlayTrack;
+	if (!canPlay) return tracks;
+	return tracks.filter((track) => canPlay(track));
+}
+//#endregion
+export { applyConstraints, applyRules, excludeUnplayableTracks, sameCandidateSet };
+
+//# sourceMappingURL=selection-rules.js.map

package/dist/dev/playback/primitives/selection-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-rules.js","names":[],"sources":["../../../../src/playback/primitives/selection-rules.ts"],"sourcesContent":["/**\n * The selection-rule substrate: the shape of a rule, and the two composers that\n * turn a list of them into a pick.\n *\n * Lives here rather than beside `switchVideoTrack` so both track-selection\n * behaviors can share rules. The simple `selectVideoTrack` variant exists\n * specifically to tree-shake the ABR path out, so importing a composer from\n * `behaviors/track-switching.ts` would drag the bandwidth estimator and quality\n * selection back in with it. These four have no dependencies at all — pure\n * generics over a candidate list — so either side can reach them freely.\n *\n * See `internal/design/spf/track-switching-model.md` for the model these\n * implement: a hard constraints pre-pass, then an ordered chain of soft\n * narrowing rules and rankers, with the pick as the first survivor.\n */\n\nimport type { CanPlayTrack } from '../../media/types';\n\n/**\n * Deps handed to each rule and to `applyRules`, mirroring a behavior's setup\n * deps so a rule reads from the same surfaces a behavior does. `context` is\n * optional — it's threaded through but absent on direct setup calls (and\n * unread by today's rules), so the whole deps object can pass straight through.\n */\nexport interface SelectionRuleDeps<State = unknown, Context = unknown, Config = unknown> {\n  state: State;\n  context?: Context;\n  config: Config;\n}\n\n/**\n * A selection rule narrows or reorders the candidate list. It reads the state,\n * context, and config it needs at apply time (tightly-coupled reads), so a\n * rule's `.get()`s subscribe the running effect to exactly what it consulted.\n * Returning an empty list means \"no match\" — the composer skips it, so a soft\n * filter never narrows the set to nothing. A ranker returns the list with its\n * pick at the head.\n */\nexport type SelectionRule<T, State = unknown, Context = unknown, Config = unknown> = (\n  tracks: readonly T[],\n  deps: SelectionRuleDeps<State, Context, Config>\n) => readonly T[];\n\n/**\n * Apply rules to a candidate list in order; the pick is the first survivor.\n * Two responsibilities the rules don't carry: a rule that returns nothing is\n * skipped (fall-through — a preference never empties the set), and once one\n * survivor remains the chain stops (early-bail — later rules, including the\n * bandwidth ranker, never run, so the effect doesn't subscribe to their\n * signals while the choice is fixed).\n *\n * @param rules - Rules to apply, most authoritative first\n * @param tracks - Candidate tracks\n * @param deps - The behavior's `{ state, context, config }`, passed through to each rule\n * @returns The surviving candidates, pick first\n */\nexport function applyRules<T, State, Context, Config>(\n  rules: readonly SelectionRule<T, State, Context, Config>[],\n  tracks: readonly T[],\n  deps: SelectionRuleDeps<State, Context, Config>\n): readonly T[] {\n  let current = tracks;\n  for (const rule of rules) {\n    const remaining = rule(current, deps);\n    if (remaining.length === 0) continue;\n    current = remaining;\n    if (current.length === 1) break;\n  }\n  return current;\n}\n\n/**\n * Apply hard constraints to a candidate list — the pre-pass that runs before the\n * rule chain. A constraint shares a rule's signature but its exclusion is\n * *hard*: it removes the unplayable (a codec the environment can't decode, a CDN\n * in failover cooldown) and a removed track is never attempted. Unlike\n * `applyRules`, this never skips an empty result and never early-bails — every\n * constraint always applies, and an empty survivor set is a real outcome\n * (\"nothing playable here\"), not a fall-through. Because each constraint only\n * removes, the order they run in can't change the result.\n *\n * @param constraints - Constraints to apply (pooled, order-independent)\n * @param tracks - Candidate tracks\n * @param deps - The behavior's `{ state, context, config }`, passed to each constraint\n * @returns The playable survivors (possibly empty)\n */\nexport function applyConstraints<T, State, Context, Config>(\n  constraints: readonly SelectionRule<T, State, Context, Config>[],\n  tracks: readonly T[],\n  deps: SelectionRuleDeps<State, Context, Config>\n): readonly T[] {\n  let current = tracks;\n  for (const constraint of constraints) current = constraint(current, deps);\n  return current;\n}\n\n/**\n * Whether two candidate sets hold the same tracks, by id.\n *\n * The `equals` both selection behaviors give their candidate-set `computed`. A\n * live playlist refresh swaps in a new presentation object carrying the same\n * variants, and a constraint's own inputs can churn without changing which\n * tracks survive; in both cases the set is unchanged and the reaction must not\n * re-fire. Compares by id rather than array identity for exactly that.\n */\nexport function sameCandidateSet<T extends { id: string }>(a: readonly T[], b: readonly T[]): boolean {\n  return a.length === b.length && a.every((track) => b.some((other) => other.id === track.id));\n}\n\n/**\n * What {@link excludeUnplayableTracks} reads off the config it is handed.\n *\n * Read through a cast rather than constraining the rule's `Config` generic, the\n * same way `screenResolutionCap` reads `screenResolution` off its state: a rule\n * composes into chains whose config types have nothing else in common, and\n * constraining the generic would make every one of those a weak-type mismatch.\n * Each engine defaults `canPlayTrack` to the DOM-bound probe; unwired means \"no\n * capability filtering\" and the constraint passes everything through.\n */\nexport interface CapabilityConstraintConfig {\n  canPlayTrack?: CanPlayTrack;\n}\n\n/**\n * Capability constraint — a *hard* filter for the {@link applyConstraints}\n * pre-pass. Removes renditions this environment can't decode, probed via the\n * injected `canPlayTrack` (codec → `MediaSource.isTypeSupported`, plus the\n * container and encryption assertions that probe can't make). Constraining here\n * — before selection — means an unplayable variant is pruned upstream and never\n * picked, instead of surviving into the pipeline to fail late at\n * `createSourceBuffer`. That late throw stays as a defensive structural\n * guarantee; with this constraint it should rarely fire.\n *\n * Lives here rather than beside `switchVideoTrack` for the reason this module\n * exists: both the re-evaluating variant and the pinned `selectVideoTrack` apply\n * it, and reaching it through `behaviors/track-switching.ts` would drag the ABR\n * path into a composition that deliberately omits it.\n *\n * Passes everything through when there's no probe (a composition that didn't\n * wire one, or DOM-free tests). When it prunes *every* track, the empty result is\n * preserved (per `applyConstraints`) — \"nothing playable\" — which each consuming\n * behavior answers by clearing its selection and reporting the type's verdict.\n */\nexport function excludeUnplayableTracks<T, State, Context, Config>(\n  tracks: readonly T[],\n  { config }: SelectionRuleDeps<State, Context, Config>\n): readonly T[] {\n  const canPlay = (config as CapabilityConstraintConfig | undefined)?.canPlayTrack;\n  if (!canPlay) return tracks;\n  return tracks.filter((track) => canPlay(track as Parameters<CanPlayTrack>[0]));\n}\n"],"mappings":";;;;;;;;;;;;;;AAwDA,SAAgB,WACd,OACA,QACA,MACc;CACd,IAAI,UAAU;CACd,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,YAAY,KAAK,SAAS,IAAI;EACpC,IAAI,UAAU,WAAW,GAAG;EAC5B,UAAU;EACV,IAAI,QAAQ,WAAW,GAAG;CAC5B;CACA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,iBACd,aACA,QACA,MACc;CACd,IAAI,UAAU;CACd,KAAK,MAAM,cAAc,aAAa,UAAU,WAAW,SAAS,IAAI;CACxE,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,iBAA2C,GAAiB,GAA0B;CACpG,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,UAAU,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM,EAAE,CAAC;AAC7F;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,wBACd,QACA,EAAE,UACY;CACd,MAAM,UAAW,QAAmD;CACpE,IAAI,CAAC,SAAS,OAAO;CACrB,OAAO,OAAO,QAAQ,UAAU,QAAQ,KAAoC,CAAC;AAC/E"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@videojs/spf",
   "type": "module",
-  "version": "10.0.0-beta.28",
+  "version": "10.0.0-beta.29",
   "description": "Stream Processing Framework for Video.js 10",
   "license": "Apache-2.0",
   "repository": {
@@ -77,8 +77,8 @@
   ],
   "dependencies": {
     "signal-polyfill": "^0.2.2",
-    "@videojs/media": "10.0.0-beta.28",
-    "@videojs/utils": "10.0.0-beta.28"
+    "@videojs/media": "10.0.0-beta.29",
+    "@videojs/utils": "10.0.0-beta.29"
   },
   "devDependencies": {
     "@vitest/browser": "^4.1.10",

package/dist/dev/media/primitives/select-tracks.d.ts

@@ -1,35 +0,0 @@
-import { MaybeResolvedPresentation } from "../types/index.js";
-//#region src/media/primitives/select-tracks.d.ts
-/**
- * Configuration for video track selection.
- */
-interface VideoSelectionConfig {
-  /**
-   * Initial bandwidth estimate for cold start (bits per second).
-   * Used to select video quality before we have real measurements.
-   * Default: 1 Mbps (conservative).
-   */
-  initialBandwidth?: number;
-  /**
-   * Safety margin for quality selection (0-1).
-   * Default: 0.85 (15% headroom).
-   */
-  safetyMargin?: number;
-}
-/**
- * Contract for a track picker — a pure function that consults a
- * presentation (and optional config) and returns the id of the track to
- * select, or `undefined` to leave the slot unset.
- *
- * Behaviors that own a track-selection slot (`selectAudioTrack`,
- * `selectVideoTrack`, `switchVideoTrack`) accept a
- * `TrackPicker` via config. The behavior passes its own config straight
- * through as the picker's second argument — pickers that need richer
- * options (language preferences, default-track filtering, bandwidth-aware
- * selection) read from `config`; pickers that don't (e.g., first-track)
- * ignore it.
- */
-type TrackPicker<Config = unknown> = (presentation: MaybeResolvedPresentation, config?: Config) => string | undefined;
-//#endregion
-export { TrackPicker, VideoSelectionConfig };
-//# sourceMappingURL=select-tracks.d.ts.map

package/dist/dev/media/primitives/select-tracks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"select-tracks.d.ts","names":[],"sources":["../../../../src/media/primitives/select-tracks.ts"],"mappings":";;;;;UA0CiB;;;;;;EAMf;;;;;EAMA;;;;;;;;;;;;;;;KA8DU,YAAY,qBACtB,cAAc,2BACd,SAAS"}