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

package/cdn/{error-surface-drmCvBVW.js → relocation-pipelines-Dh8CcgHw.js}

@@ -1,49 +1,8 @@
 import { u as isUndefined } from "./predicate-faYxAB6Z.js";
 import { t as listen } from "./listen-CdeggIF8.js";
 import { t as isWebKitAirPlayCapable } from "./webkit-C682yTT7.js";
-import { E as getOrderedCdnIds, F as isCodecSupported, H as findTrackById, J as isResolvedPresentation, M as NON_FMP4_CONTAINER_MIMES, O as emitError, P as buildMimeCodec, S as getBandwidthEstimate, T as getCdnId, U as getTracksByType, X as createMachineReactor, Y as isResolvedTrack, _ as fetchStep, a as pickTextTrackFromTracks, at as effect, d as isStandardPreload, et as defineBehavior, g as dispatchStep, it as update, nt as peek, q as getMediaPlaylistMetadata, t as matchesPartialTrack, tt as computed, w as getMinBufferedEnd, x as DEFAULT_BANDWIDTH_CONFIG } from "./select-tracks-nRPBa1NC.js";
+import { $ as getTracksByType, D as dispatchStep, F as getMinBufferedEnd, I as getCdnId, L as getOrderedCdnIds, M as DEFAULT_BANDWIDTH_CONFIG, N as getBandwidthEstimate, O as fetchStep, Q as findTrackById, S as isStandardPreload, at as isResolvedTrack, bt as effect, d as excludeUnplayableTracks, dt as computed, f as sameCandidateSet, ft as peek, g as pickTextTrackFromTracks, gt as SVTA_NO_SUPPORTED_VIDEO_TRACK, ht as SVTA_NO_SUPPORTED_AUDIO_TRACK, it as isResolvedPresentation, l as applyConstraints, m as matchesPartialTrack, mt as update, ot as createMachineReactor, u as applyRules, ut as defineBehavior, z as emitError } from "./error-surface-D0bo71gD.js";
 
-//#region ../spf/dist/dev/media/errors.js
-/** SVTA 1 [Media Content] 004 — the video is in a format we can't play (e.g. an MPEG-TS container). */
-const SVTA_UNSUPPORTED_VIDEO_FORMAT = 1004;
-/** SVTA 1 [Media Content] 005 — the audio counterpart of {@link SVTA_UNSUPPORTED_VIDEO_FORMAT}. */
-const SVTA_UNSUPPORTED_AUDIO_FORMAT = 1005;
-/**
-* SVTA 4 [Content Protection] 008 — unsupported or unavailable DRM system. Used
-* for "this source is encrypted and we have no decryption pipeline," which is
-* detection, not a license failure.
-*/
-const SVTA_UNSUPPORTED_DRM_SYSTEM = 4008;
-/**
-* SVTA 2 [Playback] 011 — no video track the environment can play. For a source
-* that *has* video renditions where every one was excluded as unplayable.
-*/
-const SVTA_NO_SUPPORTED_VIDEO_TRACK = 2011;
-/** SVTA 2 [Playback] 012 — the audio counterpart of {@link SVTA_NO_SUPPORTED_VIDEO_TRACK}. */
-const SVTA_NO_SUPPORTED_AUDIO_TRACK = 2012;
-/**
-* SVTA 99 [Custom] 001 — this engine has no pipeline for something the source
-* requires, so the source is unplayable *here* rather than broken.
-*
-* Custom rather than standard because the standard codes available describe
-* either narrower or wider things. The causes (1004/1005 unsupported format,
-* 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no
-* supported track) say a type emptied without saying why it's unfixable. And
-* 2039 "Manifest feature unsupported" covers features that are unsupported but
-* still *playable* — LL-HLS degrading to standard live is a 2039 — so
-* overloading it for a fatal condition would make it useless for the notices it
-* belongs on.
-*
-* Index `001`: the spec defines only `99000` (Unknown) for the custom category
-* and leaves the rest to the publisher, so this is the first code we define.
-*
-* Five digits, and deliberately not special-cased anywhere: {@link svtaCategory}
-* and {@link svtaIndex} decompose it correctly by arithmetic alone, because
-* every standard category is below `8000` and custom starts at `99000`.
-*/
-const SVTA_UNSUPPORTED_PLAYBACK_FEATURE = 99001;
-
-//#endregion
 //#region ../spf/dist/dev/playback/behaviors/dom/track-load-triggers.js
 /**
 * Slot-driven FSM. The slot `loadActivated` is the canonical externally-
@@ -303,73 +262,6 @@ const establishStartMediaTime = {
 	setup: establishStartMediaTimeSetup
 };
 
-//#endregion
-//#region ../spf/dist/dev/media/dom/capabilities.js
-/**
-* 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 (getMediaPlaylistMetadata(track)?.encrypted) 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
 //#region ../spf/dist/dev/playback/behaviors/derive-cdn-priority.js
 /**
@@ -895,49 +787,6 @@ function resolutionArea(track) {
 //#endregion
 //#region ../spf/dist/dev/playback/behaviors/track-switching.js
 /**
-* 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;
-}
-/**
 * User intent — a soft filter. Narrows to tracks matching the partial-track
 * selection in `user*TrackSelection`; an empty match falls through (the
 * composer skips it) to the unfiltered set — e.g. a stale id from a previous
@@ -969,27 +818,6 @@ function excludeFailedCdns(tracks, { state, config }) {
 	return tracks.filter((track) => !failedSet.has(getCdnId$1(track.url)));
 }
 /**
-* Capability constraint — a *hard* filter (constraints pre-pass), shared by
-* video and audio. Removes renditions this environment can't decode, probed via
-* the injected `canPlayTrack` (codec → `MediaSource.isTypeSupported`). Moving
-* the check here — before selection — means an unplayable variant (e.g. HEVC on
-* a browser without HEVC) 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.
-*
-* Passes everything through when there's no `canPlayTrack` probe (a composition
-* that didn't wire it, or DOM-free tests). When it prunes *every* track (no
-* decodable rendition), the empty result is preserved (per `applyConstraints`)
-* — "nothing playable," so the behavior clears the selection (no pick) and the
-* late `createSourceBuffer` check stays as the backstop.
-*/
-function excludeUnplayableTracks(tracks, { config }) {
-	const canPlay = config.canPlayTrack;
-	if (!canPlay) return tracks;
-	return tracks.filter((track) => canPlay(track));
-}
-/**
 * Active-CDN scope — a soft filter, shared by video and audio. Narrows to the
 * highest-priority CDN in `cdnPriority` (owned by `deriveCdnPriority`) that
 * still has tracks, so every track type stays on one CDN. A redundant-streams
@@ -1076,7 +904,7 @@ function selectChainHead(candidates) {
 *     stale pick whose match is gone (e.g. the language dropped on a source
 *     change) falls through to the default policy.
 *   - auto (`undefined`) → the opt-in default policy (`preferredSubtitleLanguage`
-*     → `DEFAULT=YES + AUTOSELECT=YES` → none), shared with `pickTextTrack`.
+*     → `DEFAULT=YES + AUTOSELECT=YES` → none), via `pickTextTrackFromTracks`.
 *
 * Returning `undefined` is a real outcome (captions are opt-in), which is why the
 * text variant relies on `setupTrackSwitching`'s no-selection seam.
@@ -1098,7 +926,7 @@ function setupTrackSwitching(deps) {
 		const presentation = state.presentation.get();
 		if (!isResolvedPresentation(presentation)) return [];
 		return applyConstraints(config.constraints ?? [], getTracks(presentation), deps);
-	}, { equals: (a, b) => a.length === b.length && a.every((track) => b.some((other) => other.id === track.id)) });
+	}, { equals: sameCandidateSet });
 	return createMachineReactor({
 		initial: "presentation-unresolved",
 		monitor: () => derivedStateSignal.get(),
@@ -1719,171 +1547,5 @@ const relocatingTextPipelines = () => [
 ];
 
 //#endregion
-//#region ../spf/dist/dev/playback/primitives/report-track-conditions.js
-/**
-* The seam `resolve-track` uses to report conditions discovered in a freshly
-* parsed media playlist.
-*
-* Injected rather than baked in so `resolve-track` stays free of format and
-* policy knowledge: it parses and commits, and whatever the composition wants
-* noticed about the result is this function's business. Which conditions matter,
-* and which codes they carry, therefore vary per composition — a provider that
-* never ships MPEG-TS can drop that check, and future playlist-derived notices
-* (LL-HLS or DVR support that's partial rather than absent) attach here without
-* touching the resolver.
-*
-* Reported **per rendition, as it resolves**, which is why these are causes and
-* not verdicts: one rendition being unplayable doesn't make the source
-* unplayable. The verdict is `track-switching`'s, which reports
-* `SVTA_NO_SUPPORTED_{VIDEO,AUDIO}_TRACK` when a type's candidates actually
-* empty. Keeping the two apart is what lets a mixed source — some renditions
-* encrypted or MPEG-TS, others playable — log its causes and still play.
-*/
-/** Unsupported-format code per type; text has none — absent captions aren't a failure. */
-const UNSUPPORTED_FORMAT_CODE = {
-	video: SVTA_UNSUPPORTED_VIDEO_FORMAT,
-	audio: SVTA_UNSUPPORTED_AUDIO_FORMAT
-};
-/**
-* The types a reported cause can legitimately describe: the ones whose candidates
-* `canPlayTrack` actually prunes, via `track-switching`'s `excludeUnplayableTracks`
-* pre-pass.
-*
-* Text is outside it by design — its switching chain runs failed-CDN constraints
-* alone, because an MSE codec probe is the wrong question for a WebVTT rendition
-* (see `track-switching.ts`). So nothing prunes a text rendition, no verdict can
-* follow from one, and a cause reported against it would be an orphan: the
-* adapter's unsupported-feature substitution scans the sequence as a whole, so a
-* lone encrypted subtitle would otherwise recode an unrelated verdict — an
-* all-CDN cooldown among them — as "this engine can't play the source".
-*/
-const CAPABILITY_PRUNED_TYPES = /* @__PURE__ */ new Set(["video", "audio"]);
-/**
-* The default: report what makes a rendition unplayable *to this engine* — a
-* container MSE can't accept, or encryption with no decryption pipeline. Both
-* mirror what `canPlayTrack` prunes on, so a reported cause always has a
-* corresponding exclusion.
-*
-* A condition carries its code and its context, not copy. `data.mimeType` is
-* what preserves the specificity — the format codes cover every non-fMP4
-* container, so "which one" lives there for a consumer that wants to say, rather
-* than being flattened into an English sentence here.
-*
-* Both carry `trackType`, redundantly for the format codes (1004/1005 are
-* already per type) but not for 4008, which isn't per type — SVTA has one
-* content-protection code for both. Nothing branches on the tag: it's diagnostic
-* context, reaching a developer through the logged sequence and `error.data`,
-* which is why it goes on every condition rather than only where the code can't
-* carry it. `trackId` alongside it is what distinguishes two renditions of the
-* same type.
-*/
-function reportUnsupportedTrackConditions(track) {
-	if (!CAPABILITY_PRUNED_TYPES.has(track.type)) return [];
-	const conditions = [];
-	const data = {
-		trackType: track.type,
-		trackId: track.id
-	};
-	const formatCode = UNSUPPORTED_FORMAT_CODE[track.type];
-	if (formatCode !== void 0 && NON_FMP4_CONTAINER_MIMES.has(track.mimeType)) conditions.push({
-		code: formatCode,
-		data: {
-			...data,
-			mimeType: track.mimeType
-		}
-	});
-	if (getMediaPlaylistMetadata(track)?.encrypted) conditions.push({
-		code: SVTA_UNSUPPORTED_DRM_SYSTEM,
-		data
-	});
-	return conditions;
-}
-
-//#endregion
-//#region ../spf/dist/dev/playback/primitives/error-messages.js
-/**
-* Developer-facing copy for what this engine reports.
-*
-* Everything here reaches a **console**, never a viewer. Viewer-facing copy for
-* a fatal condition is the presentation layer's to compose: the engine reports a
-* code, and a consumer maps that code to localized text it owns.
-*
-* Plain string constants, one export each. Nothing is parameterized — a message
-* that names the engine has to be built at the call site from state the engine
-* carries around solely to say it, which is a lot of plumbing for a console
-* prefix. Separate exports rather than one object so a composition that logs
-* neither notice doesn't carry their bytes.
-*/
-/**
-* Logged when a fatal `SVTA_UNSUPPORTED_PLAYBACK_FEATURE` is surfaced.
-*
-* The developer's half of that event; the viewer gets the localized copy the
-* code maps to. One sentence is enough because the specifics — which container,
-* which rendition, whether it was DRM — stay structured on the reported
-* conditions logged beside it.
-*/
-const UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE = "Can't play this source: it requires an unsupported playback feature.";
-/**
-* LL-HLS delivery, played as standard live. The parser ignores partial segments
-* and the loader fetches whole ones, so latency lands wherever `HOLD-BACK` puts
-* it — the stream plays, just not at the latency it was published for.
-*/
-const LOW_LATENCY_UNSUPPORTED_MESSAGE = "Low-Latency HLS is unsupported; playing as standard live at higher latency.";
-/**
-* `#EXT-X-PLAYLIST-TYPE:EVENT` — a growing window, which is how DVR is
-* delivered. It plays, but the seekable-range and live-edge handling for it is
-* newer and less exercised than sliding-window live.
-*/
-const DVR_EXPERIMENTAL_MESSAGE = "DVR support for EVENT playlists is experimental.";
-
-//#endregion
-//#region ../spf/dist/dev/playback/adapters/hls-video/error-surface.js
-/**
-* `message`, plus the alternative-Media sentence when `media`'s class names one.
-*
-* Read off the class rather than passed in so a subclass can point at a
-* better-equipped sibling — the SPF Mux Medias name the hls.js-backed one, which
-* plays the MPEG-TS and DRM sources SPF doesn't — without either adapter knowing
-* that sibling exists.
-*/
-function withAlternativeMediaSuggestion(message, media) {
-	const { alternativeMediaSuggestion } = media.constructor;
-	const suggestion = alternativeMediaSuggestion?.trim();
-	return suggestion ? `${message} ${suggestion}` : message;
-}
-/** The first condition `fatalCodes` covers — the root cause, not its consequences. */
-function firstFatal(errors, fatalCodes) {
-	return errors?.find((error) => fatalCodes.has(error.code));
-}
-/**
-* The causes that mean the engine has no pipeline for what the source delivers —
-* a container it can't append, or encryption it can't decrypt.
-*
-* What these have in common is that no retry, no other CDN, and no other
-* rendition of the same source fixes them: the source needs a capability this
-* engine doesn't have. That's the distinction the surfaced code exists to draw,
-* and it's why the set is these three rather than "every cause".
-*/
-const UNSUPPORTED_FEATURE_CAUSES = /* @__PURE__ */ new Set([
-	SVTA_UNSUPPORTED_VIDEO_FORMAT,
-	SVTA_UNSUPPORTED_AUDIO_FORMAT,
-	SVTA_UNSUPPORTED_DRM_SYSTEM
-]);
-/**
-* Whether anything in the sequence is a cause of the "we don't implement this"
-* kind.
-*
-* Deliberately `some` over the whole sequence rather than a per-type match
-* against the verdict. A verdict means one type's candidates emptied, but the
-* *reason* the source is unplayable can sit on another type — an audio-only
-* source whose sole rendition is encrypted empties the audio candidates, and a
-* video source with encrypted video empties the video ones. Both are the same
-* answer to the viewer, so both get the same code.
-*/
-function hasUnsupportedFeatureCause(errors) {
-	return errors?.some((error) => UNSUPPORTED_FEATURE_CAUSES.has(error.code)) ?? false;
-}
-
-//#endregion
-export { gateFirstParseOnAnchor as C, SVTA_UNSUPPORTED_PLAYBACK_FEATURE as D, SVTA_NO_SUPPORTED_VIDEO_TRACK as E, establishStartMediaTime as S, SVTA_NO_SUPPORTED_AUDIO_TRACK as T, applyStartPosition as _, LOW_LATENCY_UNSUPPORTED_MESSAGE as a, canPlayTrack as b, relocatingTextPipelines as c, switchAudioTrack as d, switchTextTrack as f, recoverEndStall as g, setupFailoverMonitor as h, DVR_EXPERIMENTAL_MESSAGE as i, relocationPipelinesFor as l, syncPreload as m, hasUnsupportedFeatureCause as n, UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE as o, switchVideoTrack as p, withAlternativeMediaSuggestion as r, reportUnsupportedTrackConditions as s, firstFatal as t, DEFAULT_TEXT_MESSAGE_PIPELINES as u, setupAirPlay as v, trackLoadTriggers as w, deriveSharedMinStartMediaTime as x, deriveCdnPriority as y };
-//# sourceMappingURL=error-surface-drmCvBVW.js.map
+export { switchTextTrack as a, setupFailoverMonitor as c, setupAirPlay as d, deriveCdnPriority as f, trackLoadTriggers as g, gateFirstParseOnAnchor as h, switchAudioTrack as i, recoverEndStall as l, establishStartMediaTime as m, relocationPipelinesFor as n, switchVideoTrack as o, deriveSharedMinStartMediaTime as p, DEFAULT_TEXT_MESSAGE_PIPELINES as r, syncPreload as s, relocatingTextPipelines as t, applyStartPosition as u };
+//# sourceMappingURL=relocation-pipelines-Dh8CcgHw.js.map