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

package/cdn/{select-tracks-nRPBa1NC.js → error-surface-D0bo71gD.js}

@@ -542,6 +542,54 @@ function effect(fn) {
 	};
 }
 
+//#endregion
+//#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.
+*
+* Covers both ways a composition can end up with nothing to select: renditions
+* that existed and were all excluded as unplayable, and — where the composition
+* composes `reportAbsentTrackType` to say it needs the type — a source carrying
+* none to begin with. Deliberately one code for both, because they are the same
+* answer to a viewer, and because the alternative is a code the SVTA spec doesn't
+* define. Whether an absent type is a failure is the composition's to state,
+* which is why it opts in rather than being read off the source.
+*/
+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/core/signals/primitives.js
 /** Read a signal value without tracking it as a dependency. */
@@ -2034,6 +2082,73 @@ function parseMediaPlaylist(text, previous) {
 	};
 }
 
+//#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/media/hls/parse-multivariant.js
 /**
@@ -2389,6 +2504,40 @@ function emitError(state, error) {
 	update(state.errors, (errors) => [...errors ?? [], error]);
 }
 /**
+* A "constraint" that reports a type the source carries **no** renditions of, for
+* a composition that can't play without it.
+*
+* Strange on purpose, and the strangeness is the point: it never constrains
+* anything, always returning its input untouched. It is shaped as a rule so a
+* composition opts in by adding it to `constraints` — nothing to thread through
+* config, and no cost at all to a composition that leaves it out.
+*
+* **Belongs first in the chain.** A constraint sees the list as it stands at its
+* own position, so only at the head does an empty input mean "the source offers
+* none of this type" rather than "the constraints ahead of me pruned them all."
+*
+* This is the one failure no per-rendition cause can report: causes come from
+* `reportUnsupportedTrackConditions` as each media playlist resolves, and here
+* nothing resolves, because there is nothing to resolve. Everything else already
+* reports something more specific than a verdict.
+*
+* Idempotent because the constraint chain runs inside a `computed` that re-derives
+* on every `presentation` write — segment appends and live reloads included — and
+* the sequence deliberately keeps duplicates. `peek` is what keeps that computed
+* from subscribing to the slot this writes.
+*
+* @example
+* // engine-background-video.ts — video-only, so a source with none can't play
+* constraints: [reportAbsentTrackType(SVTA_NO_SUPPORTED_VIDEO_TRACK), excludeUnplayableTracks]
+*/
+function reportAbsentTrackType(code) {
+	return (tracks, { state }) => {
+		const reported = state.errors && peek(state.errors);
+		if (!tracks.length && !reported?.some((error) => error.code === code)) emitError(state, { code });
+		return tracks;
+	};
+}
+/**
 * Own `errors` for the resolved source's lifetime.
 *
 * @example
@@ -4667,58 +4816,44 @@ function matchesPartialTrack(track, filter) {
 	}
 	return true;
 }
-/**
-* Pick the first track of the given type from a presentation.
-*
-* Returns the first track in the first switching set of the matching
-* selection set, or `undefined` if either is missing. POC-shaped
-* default-pick — `pickVideoTrack` / `pickAudioTrack` honor bandwidth +
-* language preferences and will replace this once selection callers are
-* ready.
-*/
-function pickFirstTrackId(presentation, type) {
-	return presentation.selectionSets?.find((set) => set.type === type)?.switchingSets[0]?.tracks[0]?.id;
+/** Missing dimensions are treated as area `0`, so a track without them ranks last. */
+function pixelArea(track) {
+	return (track.width ?? 0) * (track.height ?? 0);
 }
 /**
-* Pick the track with the highest pixel area at or below `maxPixelArea`.
-* Falls back to the lowest track when nothing satisfies the cap (the
-* lowest of the above-cap set is the closest to the cap from above).
-* Tiebreak on bandwidth. Missing dimensions are treated as area `0`.
+* Narrow to the tracks at or below `maxPixelArea`, and nothing else: no ordering,
+* no fallback. Survivors keep their incoming order, and an empty result is a real
+* answer — "none of these fit".
+*
+* Deliberately only the filter, because as a selection rule this composes under
+* `applyRules`, which already owns both halves a caller might expect here: an empty
+* result is skipped, so a preference can never narrow the candidate set to nothing;
+* and ordering the survivors is a separate rule's job
+* ({@link byDescendingResolution}, bandwidth ABR). Doing either here would duplicate
+* the composer and give one rule two responsibilities.
 */
-function pickTrackUnderPixelArea(tracks, maxPixelArea = Number.POSITIVE_INFINITY) {
-	if (tracks.length === 0) return void 0;
-	const sorted = [...tracks].sort((a, b) => (b.width ?? 0) * (b.height ?? 0) - (a.width ?? 0) * (a.height ?? 0) || (b.bandwidth ?? 0) - (a.bandwidth ?? 0));
-	return sorted.find((t) => (t.width ?? 0) * (t.height ?? 0) <= maxPixelArea) ?? sorted[sorted.length - 1];
+function tracksUnderPixelArea(tracks, maxPixelArea = Number.POSITIVE_INFINITY) {
+	return tracks.filter((track) => pixelArea(track) <= maxPixelArea);
 }
 /**
-* Pick the video track with the highest pixel area.
+* Compare two tracks by resolution, largest first, with bandwidth as the tiebreak
+* for renditions of identical dimensions. Missing dimensions are treated as area
+* `0`, so a track without them sorts last.
 *
-* Pair with `selectVideoTrack`; compose `switchVideoQuality` instead
-* for runtime-adapted quality.
+* A comparator rather than a "highest track" function: the selection-rule chain
+* takes the head of the list it produces, so ranking never has to collapse to a
+* single track. `preferHighestResolution` is `sort` over this and nothing more.
 */
-function pickHighestResolutionVideoTrack(presentation) {
-	const tracks = (presentation.selectionSets?.find((set) => set.type === "video"))?.switchingSets[0]?.tracks;
-	if (!tracks?.length) return void 0;
-	return pickTrackUnderPixelArea(tracks)?.id;
+function byDescendingResolution(a, b) {
+	return pixelArea(b) - pixelArea(a) || (b.bandwidth ?? 0) - (a.bandwidth ?? 0);
 }
 /**
-* Pick audio track.
+* Default audio policy over a candidate list: the three-tier pick a selection-rule
+* chain applies once it has narrowed the candidates.
 *
-* Selection priority:
-* 1. First track matching preferred language (if specified)
-* 2. First default track
-* 3. First audio track
-*
-* @param presentation - Presentation with audio tracks
-* @param config - Selection configuration (preferred language)
-* @returns Selected audio track ID, or undefined if no audio tracks
+* Priority: `preferredAudioLanguage` match → `DEFAULT=YES` → first track.
 */
-function pickAudioTrack(presentation, config) {
-	const audioSet = presentation.selectionSets?.find((set) => set.type === "audio");
-	if (!audioSet || audioSet.switchingSets.length === 0) return;
-	const switchingSet = audioSet.switchingSets[0];
-	if (!switchingSet || switchingSet.tracks.length === 0) return;
-	const tracks = switchingSet.tracks;
+function pickAudioTrackFromTracks(tracks, config) {
 	if (config?.preferredAudioLanguage) {
 		const languageMatch = tracks.find((track) => track.language === config.preferredAudioLanguage);
 		if (languageMatch) return languageMatch.id;
@@ -4728,11 +4863,9 @@ function pickAudioTrack(presentation, config) {
 	return tracks[0]?.id;
 }
 /**
-* Default text-track policy over an explicit candidate list (rather than a whole
-* presentation): the opt-in three-tier pick `pickTextTrack` delegates to, factored
-* out so a caller that has already narrowed the candidates — a constrained,
-* CDN-scoped track-switching chain — applies the same policy without re-deriving
-* from the presentation.
+* Default text-track policy over a candidate list: the opt-in three-tier pick
+* `switchTextTrack`'s terminal applies once it has narrowed the renditions to the
+* constrained, CDN-scoped set.
 *
 * Priority: `preferredSubtitleLanguage` match → `DEFAULT=YES + AUTOSELECT=YES`
 * (only when `enableDefaultTrack`) → `undefined` (opt-in). FORCED tracks are
@@ -4754,5 +4887,266 @@ function pickTextTrackFromTracks(tracks, config) {
 }
 
 //#endregion
-export { createComposition as $, getResolvedSelectedTrackDuration as A, AUDIO_TYPE_CONFIG as B, endOfStream as C, collectErrors as D, getOrderedCdnIds as E, isCodecSupported as F, getSegmentsToLoad as G, findTrackById as H, trackCurrentTime as I, isResolvedPresentation as J, deriveStreamType as K, loadAudioSegments as L, NON_FMP4_CONTAINER_MIMES as M, attachMediaSourceAsSourceElement as N, emitError as O, buildMimeCodec as P, makeShareSignals as Q, loadTextTrackSegments as R, getBandwidthEstimate as S, getCdnId as T, getTracksByType as U, VIDEO_TYPE_CONFIG as V, DEFAULT_FORWARD_BUFFER_CONFIG as W, createMachineReactor as X, isResolvedTrack as Y, createMachineCore as Z, fetchStep as _, pickTextTrackFromTracks as a, effect as at, Task as b, resolveTextTrack as c, isStandardPreload as d, defineBehavior as et, updateMediaSourceDuration as f, dispatchStep as g, setupVideoBufferActors as h, pickHighestResolutionVideoTrack as i, update as it, parseMultivariantPlaylist as j, calculatePresentationDuration as k, resolveVideoTrack as l, setupAudioBufferActors as m, pickAudioTrack as n, peek as nt, pickTrackUnderPixelArea as o, setupMediaSource as p, getMediaPlaylistMetadata as q, pickFirstTrackId as r, untrack as rt, resolveAudioTrack as s, matchesPartialTrack as t, computed as tt, resolvePresentation as u, createMachineActor as v, getMinBufferedEnd as w, DEFAULT_BANDWIDTH_CONFIG as x, SerialRunner as y, loadVideoSegments as z };
-//# sourceMappingURL=select-tracks-nRPBa1NC.js.map
+//#region ../spf/dist/dev/playback/primitives/selection-rules.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;
+}
+/**
+* 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
+//#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.";
+/**
+* Logged for **any** fatal condition, by a composition whose failures don't all
+* reduce to a missing feature.
+*
+* The background variant is the case: it treats a per-rendition cause as fatal on
+* its own, so what reaches its surface can be an unsupported container, DRM it
+* can't decrypt, or a source carrying no video at all. Naming one feature would be
+* wrong for the last of those, so all three are named broadly. Deferring the *why*
+* to the conditions instead would promise prose they don't carry — an `SvtaError`
+* is a code and its context, and nothing on this path sets `message`.
+*/
+const UNPLAYABLE_SOURCE_MESSAGE = "Can't play this source — unsupported container, encryption, or no usable video track.";
+/**
+* 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 { getTracksByType as $, SerialRunner as A, reportAbsentTrackType as B, updateMediaSourceDuration as C, dispatchStep as D, setupVideoBufferActors as E, getMinBufferedEnd as F, attachMediaSourceAsSourceElement as G, getResolvedSelectedTrackDuration as H, getCdnId as I, loadTextTrackSegments as J, trackCurrentTime as K, getOrderedCdnIds as L, DEFAULT_BANDWIDTH_CONFIG as M, getBandwidthEstimate as N, fetchStep as O, endOfStream as P, findTrackById as Q, collectErrors as R, isStandardPreload as S, setupAudioBufferActors as T, parseMultivariantPlaylist as U, calculatePresentationDuration as V, canPlayTrack as W, AUDIO_TYPE_CONFIG as X, loadVideoSegments as Y, VIDEO_TYPE_CONFIG as Z, tracksUnderPixelArea as _, SVTA_UNSUPPORTED_DRM_SYSTEM as _t, LOW_LATENCY_UNSUPPORTED_MESSAGE as a, isResolvedTrack as at, resolveVideoTrack as b, effect as bt, reportUnsupportedTrackConditions as c, makeShareSignals as ct, excludeUnplayableTracks as d, computed as dt, DEFAULT_FORWARD_BUFFER_CONFIG as et, sameCandidateSet as f, peek as ft, pickTextTrackFromTracks as g, SVTA_NO_SUPPORTED_VIDEO_TRACK as gt, pickAudioTrackFromTracks as h, SVTA_NO_SUPPORTED_AUDIO_TRACK as ht, DVR_EXPERIMENTAL_MESSAGE as i, isResolvedPresentation as it, Task as j, createMachineActor as k, applyConstraints as l, createComposition as lt, matchesPartialTrack as m, update as mt, hasUnsupportedFeatureCause as n, deriveStreamType as nt, UNPLAYABLE_SOURCE_MESSAGE as o, createMachineReactor as ot, byDescendingResolution as p, untrack as pt, loadAudioSegments as q, withAlternativeMediaSuggestion as r, getMediaPlaylistMetadata as rt, UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE as s, createMachineCore as st, firstFatal as t, getSegmentsToLoad as tt, applyRules as u, defineBehavior as ut, resolveAudioTrack as v, SVTA_UNSUPPORTED_PLAYBACK_FEATURE as vt, setupMediaSource as w, resolvePresentation as x, resolveTextTrack as y, SVTA_UNSUPPORTED_VIDEO_FORMAT as yt, emitError as z };
+//# sourceMappingURL=error-surface-D0bo71gD.js.map