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

package/dist/dev/playback/actors/text-track-segment-loader.d.ts

@@ -1,6 +1,8 @@
-import { MessageActor } from "../../core/actors/create-machine-actor.js";
 import { Cue, TextTrack } from "../../media/types/index.js";
+import { MessageActor } from "../../core/actors/create-machine-actor.js";
 import { ForwardBufferConfig } from "../../media/buffer/forward-buffer.js";
+import { TextMessagePipelines } from "../primitives/text-segment-load-pipeline.js";
+import "./text-tracks.js";
 //#region src/playback/actors/text-track-segment-loader.d.ts
 /**
  * Mirrors the v/a `SegmentLoaderMessage` shape. `range` carries the
@@ -35,15 +37,6 @@ interface TextTrackSegmentLoaderActorContext {
   inFlightSegmentId: string | null;
 }
 type TextTrackSegmentLoaderActor = MessageActor<TextTrackSegmentLoaderActorState, TextTrackSegmentLoaderActorContext, TextTrackSegmentLoaderMessage>;
-/**
- * Resolves a text-track segment URL into the array of cues it contains.
- *
- * "Resolve" because the fn covers both network fetch and parse into the
- * domain model. Host-agnostic — the concrete resolver (e.g. the
- * browser's native VTT resolver) is supplied at engine-assembly time,
- * so this actor stays DOM-free.
- */
-type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;
 /**
  * Configuration for `createTextTrackSegmentLoaderActor`. Spread over
  * `DEFAULT_FORWARD_BUFFER_CONFIG` to override individual forward-window
@@ -51,9 +44,11 @@ type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[
  * concern — cues evict by their playhead-relative window at runtime —
  * so no `backBuffer` config field.
  */
-interface TextTrackSegmentLoaderActorConfig {
+interface TextTrackSegmentLoaderActorConfig<C extends Cue = Cue> {
   forwardBuffer?: Partial<ForwardBufferConfig>;
+  /** Ordered step pipeline. Defaults to {@link DEFAULT_TEXT_MESSAGE_PIPELINES} (`resolveCues → dispatchCues`). */
+  messagePipelines?: TextMessagePipelines<C>;
 }
 //#endregion
-export { TextTrackSegmentLoaderActor, TextTrackSegmentLoaderActorConfig, TextTrackSegmentResolver };
+export { TextTrackSegmentLoaderActor, TextTrackSegmentLoaderActorConfig, TextTrackSegmentLoaderActorContext, TextTrackSegmentLoaderActorState, TextTrackSegmentLoaderMessage };
 //# sourceMappingURL=text-track-segment-loader.d.ts.map

package/dist/dev/playback/actors/text-track-segment-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text-track-segment-loader.d.ts","names":[],"sources":["../../../../src/playback/actors/text-track-segment-loader.ts"],"mappings":";;;;;;AAsBA;;;;;KAAY,6BAAA;EACV,IAAA;EACA,KAAA,EAAO,SAAA;EACP,KAAA;IAAU,KAAA;IAAe,GAAA;EAAA;AAAA;;KAIf,gCAAA;;UAGK,kCAAA;EAAA;;;;;AAejB;EARE,eAAA;;;;;EAKA,iBAAA;AAAA;AAAA,KAGU,2BAAA,GAA8B,YAAA,CACxC,gCAAA,EACA,kCAAA,EACA,6BAAA;;;;;;;AAWF;;KAAY,wBAAA,WAAmC,GAAA,GAAM,GAAA,KAAQ,GAAA,aAAgB,OAAA,CAAQ,CAAA;;;;;;;;UASpE,iCAAA;EACf,aAAA,GAAgB,OAAA,CAAQ,mBAAA;AAAA"}
+{"version":3,"file":"text-track-segment-loader.d.ts","names":[],"sources":["../../../../src/playback/actors/text-track-segment-loader.ts"],"mappings":";;;;;;;;;;;;;KA8BY;EACV;EACA,OAAO;EACP;IAAU;IAAe;;;;KAIf;;UAGK;;;;;;;EAOf;;;;;EAKA;;KAGU,8BAA8B,aACxC,kCACA,oCACA;;;;;;;;UAUe,kCAAkC,UAAU,MAAM;EACjE,gBAAgB,QAAQ;;EAExB,mBAAmB,qBAAqB"}

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

@@ -2,6 +2,7 @@ import { peek } from "../../core/signals/primitives.js";
 import { SerialRunner, Task } from "../../core/tasks/task.js";
 import { createMachineActor } from "../../core/actors/create-machine-actor.js";
 import { DEFAULT_FORWARD_BUFFER_CONFIG, getSegmentsToLoad } from "../../media/buffer/forward-buffer.js";
+import { DEFAULT_TEXT_MESSAGE_PIPELINES } from "../primitives/text-segment-load-pipeline.js";
 //#region src/playback/actors/text-track-segment-loader.ts
 /**
 * Loads text-track segments for a track and delegates cue management
@@ -30,11 +31,25 @@ import { DEFAULT_FORWARD_BUFFER_CONFIG, getSegmentsToLoad } from "../../media/bu
 * host supplies a VTT parser backed by `<track>`/`TextTrack` APIs; a
 * non-DOM host (worker, test fake, alternate runtime) supplies its own.
 */
-function createTextTrackSegmentLoaderActor(textTracksActor, resolveSegment, config = {}) {
+function createTextTrackSegmentLoaderActor(textTracksActor, resolveSegment, config = {}, compositionDeps = {
+	state: {},
+	context: {},
+	config: {}
+}) {
 	const forwardBufferConfig = {
 		...DEFAULT_FORWARD_BUFFER_CONFIG,
 		...config.forwardBuffer
 	};
+	const deps = {
+		state: compositionDeps.state,
+		context: compositionDeps.context,
+		config: {
+			...compositionDeps.config,
+			textTracksActor,
+			resolveSegment
+		}
+	};
+	const pipeline = (config.messagePipelines ?? DEFAULT_TEXT_MESSAGE_PIPELINES)();
 	/**
 	* Translate a load message into an ordered TextLoadTask list based on
 	* committed actor state. In-flight awareness is handled separately in
@@ -55,31 +70,30 @@ function createTextTrackSegmentLoaderActor(textTracksActor, resolveSegment, conf
 		}));
 	};
 	/**
-	* Wraps a TextLoadTask into a Task that fetches + dispatches `add-cues`.
-	* Updates `inFlightSegmentId` around the fetch so the load handler can
-	* make accurate continue/preempt decisions.
+	* Wraps a TextLoadTask into a Task that runs the op's step pipeline
+	* (resolve/relocate/dispatch, per the composition's `messagePipelines`).
+	* Updates `inFlightSegmentId` around the async region so the load handler can
+	* make accurate continue/preempt decisions, and checks the abort signal before
+	* each step.
+	*
+	* Text degrades gracefully: a step throwing (e.g. a failed segment fetch) is
+	* logged and swallowed so the runner continues to the next segment — unlike the
+	* v/a loader, where a failed init must abort the remaining tasks.
 	*/
 	const makeLoadTask = (op, { getContext, setContext }) => {
 		return new Task(async (signal) => {
 			if (signal.aborted) return;
+			const frame = { op };
 			setContext({
 				...getContext(),
 				inFlightTrackId: op.trackId,
 				inFlightSegmentId: op.segment.id
 			});
 			try {
-				const cues = await resolveSegment(op.segment.url);
-				if (signal.aborted) return;
-				textTracksActor.send({
-					type: "add-cues",
-					meta: {
-						trackId: op.trackId,
-						id: op.segment.id,
-						startTime: op.segment.startTime,
-						duration: op.segment.duration
-					},
-					cues
-				});
+				for (const step of pipeline) {
+					if (signal.aborted) return;
+					await step(frame, signal, deps);
+				}
 			} catch (error) {
 				console.error("Failed to load text-track segment:", error);
 			} finally {

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

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

package/dist/dev/playback/actors/text-tracks.d.ts

@@ -1,11 +1,7 @@
-import { TransitionActor } from "../../core/actors/create-transition-actor.js";
 import { Cue, Segment } from "../../media/types/index.js";
-
+import { TransitionActor } from "../../core/actors/create-transition-actor.js";
+import { AddCuesMessage } from "../primitives/text-track-messages.js";
 //#region src/playback/actors/text-tracks.d.ts
-/** Segment identity and timing — mirrors AppendSegmentMeta without trackId (keyed separately). */
-type CueSegmentMeta = Pick<Segment, 'id' | 'startTime' | 'duration'> & {
-  trackId: string;
-};
 /** Non-finite (extended) data managed by the actor — the XState "context". */
 interface TextTracksActorContext {
   /** Cues added per track ID. Used for duplicate detection and snapshot observability. */
@@ -13,11 +9,6 @@ interface TextTracksActorContext {
   /** Segments whose cues have been fully added, keyed by track ID. Used for load planning. */
   segments: Record<string, Array<Pick<Segment, 'id' | 'startTime' | 'duration'>>>;
 }
-interface AddCuesMessage<C extends Cue = Cue> {
-  type: 'add-cues';
-  meta: CueSegmentMeta;
-  cues: C[];
-}
 /**
  * Wipe the actor's `loaded` + `segments` context. Sent on source reset
  * (typically by `syncTextTracks` on state exit) so a subsequent
@@ -38,5 +29,5 @@ type TextTracksActorMessage<C extends Cue = Cue> = AddCuesMessage<C> | ClearMess
  */
 type TextTracksActor<C extends Cue = Cue> = TransitionActor<TextTracksActorContext, TextTracksActorMessage<C>>;
 //#endregion
-export { AddCuesMessage, ClearMessage, CueSegmentMeta, TextTracksActor, TextTracksActorContext, TextTracksActorMessage };
+export { ClearMessage, TextTracksActor, TextTracksActorContext, TextTracksActorMessage };
 //# sourceMappingURL=text-tracks.d.ts.map

package/dist/dev/playback/actors/text-tracks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text-tracks.d.ts","names":[],"sources":["../../../../src/playback/actors/text-tracks.ts"],"mappings":";;;;;KAQY,cAAA,GAAiB,IAAA,CAAK,OAAA;EAA8C,OAAA;AAAA;;UAG/D,sBAAA;EAHY;EAK3B,MAAA,EAAQ,MAAA,SAAe,GAAA;EALuD;EAO9E,QAAA,EAAU,MAAA,SAAe,KAAA,CAAM,IAAA,CAAK,OAAA;AAAA;AAAA,UAGrB,cAAA,WAAyB,GAAA,GAAM,GAAA;EAC9C,IAAA;EACA,IAAA,EAAM,cAAA;EACN,IAAA,EAAM,CAAA;AAAA;;;;;;;;;UAWS,YAAA;EACf,IAAA;AAAA;AAAA,KAGU,sBAAA,WAAiC,GAAA,GAAM,GAAA,IAAO,cAAA,CAAe,CAAA,IAAK,YAAA;;;;;AAlB9E;;KA0BY,eAAA,WAA0B,GAAA,GAAM,GAAA,IAAO,eAAA,CAAgB,sBAAA,EAAwB,sBAAA,CAAuB,CAAA"}
+{"version":3,"file":"text-tracks.d.ts","names":[],"sources":["../../../../src/playback/actors/text-tracks.ts"],"mappings":";;;;;UASiB;;EAEf,QAAQ,eAAe;;EAEvB,UAAU,eAAe,MAAM,KAAK;;;;;;;;;;UAWrB;EACf;;KAGU,uBAAuB,UAAU,MAAM,OAAO,eAAe,KAAK;;;;;;;KAQlE,gBAAgB,UAAU,MAAM,OAAO,gBAAgB,wBAAwB,uBAAuB"}

package/dist/dev/playback/behaviors/calculate-presentation-duration.d.ts

@@ -1,5 +1,6 @@
 import { MaybeResolvedPresentation } from "../../media/types/index.js";
-
+import "../../core/signals/primitives.js";
+import "../../core/composition/create-composition.js";
 //#region src/playback/behaviors/calculate-presentation-duration.d.ts
 /**
  * Input shape passed to the duration resolver. Represents the union of
@@ -21,5 +22,5 @@ interface PresentationDurationState {
  */
 type PresentationDurationResolver = (state: PresentationDurationState) => number | undefined;
 //#endregion
-export { PresentationDurationResolver };
+export { PresentationDurationResolver, PresentationDurationState };
 //# sourceMappingURL=calculate-presentation-duration.d.ts.map

package/dist/dev/playback/behaviors/calculate-presentation-duration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculate-presentation-duration.d.ts","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"mappings":";;;;;;;;;;;UA0CiB,yBAAA;EACf,YAAA,GAAe,yBAAA;EACf,oBAAA;EACA,oBAAA;AAAA;;;;;;KAQU,4BAAA,IAAgC,KAAA,EAAO,yBAAA"}
+{"version":3,"file":"calculate-presentation-duration.d.ts","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"mappings":";;;;;;;;;;;;UA0CiB;EACf,eAAe;EACf;EACA;;;;;;;KAQU,gCAAgC,OAAO"}

package/dist/dev/playback/behaviors/calculate-presentation-duration.js.map

@@ -1 +1 @@
-{"version":3,"file":"calculate-presentation-duration.js","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"sourcesContent":["/**\n * **Populate presentation duration via a config-supplied resolver.**\n *\n * Once a presentation is in place and its `duration` is still undefined,\n * calls `config.resolveDuration(state)` whenever a tracked slot changes. The\n * resolver decides what counts as \"duration is now derivable\" for the variant\n * in play; the behavior itself stays variant-agnostic:\n *\n * - **VoD** — derive from the first resolved selected track's `duration`\n *   (video preferred, audio fallback). The HLS engine wires\n *   `getResolvedSelectedTrackDuration` from `media/utils/track-selection.ts`\n *   as the default. Audio-only falls out of the same resolver naturally\n *   (no video selected → audio is the first resolved track).\n * - **Live** — return `Number.POSITIVE_INFINITY` once the presentation is\n *   established as live. This is the MSE-spec value for `mediaSource.duration`\n *   under live playback; downstream `updateMediaSourceDuration` propagates it through.\n *\n * Validation: writes whatever the resolver returns as long as it's a positive\n * number, including `Infinity`. `undefined` / `NaN` / `<= 0` are skipped.\n *\n * Fires at most once per presentation — an already-set `duration` is never\n * overwritten, and the next reset arrives structurally when a new\n * (unresolved) presentation replaces the current one. The resolver may\n * return `undefined` while duration is still indeterminate; subsequent\n * tracked-slot changes re-run the effect until the resolver commits a value.\n *\n * Downstream of `resolveVideoTrack` / `resolveAudioTrack`; upstream of\n * `updateMediaSourceDuration` (which writes the value through to `mediaSource.duration`).\n */\nimport type { Behavior } from '../../core/composition/create-composition';\nimport { effect } from '../../core/signals/effect';\nimport { type ReadonlySignal, type Signal, untrack, update } from '../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../media/types';\n\n/**\n * Input shape passed to the duration resolver. Represents the union of\n * track-selection slots the default `getResolvedSelectedTrackDuration`\n * resolver inspects to pick a representative resolved track. Variants\n * that compose neither audio nor video selection still satisfy this\n * shape — the missing fields read as `undefined` and the resolver\n * falls through.\n */\nexport interface PresentationDurationState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\n/**\n * Resolver supplied via `config.resolveDuration`. Returns the duration to\n * write to `presentation.duration`, or `undefined` when it isn't yet\n * derivable. Positive `Infinity` is the canonical live value.\n */\nexport type PresentationDurationResolver = (state: PresentationDurationState) => number | undefined;\n\nexport interface PresentationDurationConfig {\n  resolveDuration: PresentationDurationResolver;\n}\n\nfunction calculatePresentationDurationSetup({\n  state,\n  config,\n}: {\n  state: {\n    presentation: Signal<PresentationDurationState['presentation']>;\n    // selectedVideoTrackId / selectedAudioTrackId are read defensively —\n    // they are *not* declared in this behavior's stateKeys. The slots are\n    // contributed by other behaviors (`switchVideoTrack` writes the\n    // video slot in the default engine; `selectAudioTrack` writes the\n    // audio slot) which compose conditionally per engine variant. Treating\n    // each signal as optional lets calculatePresentationDuration stay\n    // variant-agnostic — it feeds whatever's present to the resolver and\n    // lets the resolver decide.\n    selectedVideoTrackId?: ReadonlySignal<PresentationDurationState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<PresentationDurationState['selectedAudioTrackId']>;\n  };\n  config: PresentationDurationConfig;\n}): () => void {\n  return effect(() => {\n    const presentation = state.presentation.get();\n    if (!presentation || presentation.duration !== undefined) return;\n\n    // presentation drives the effect; selection-only changes can't yield a\n    // writable duration on their own (resolver returns undefined until a\n    // track resolves, at which point resolve-track writes back through\n    // state.presentation anyway), so we read the rest untracked.\n    const resolverInput: PresentationDurationState = untrack(() => ({\n      presentation,\n      selectedVideoTrackId: state.selectedVideoTrackId?.get(),\n      selectedAudioTrackId: state.selectedAudioTrackId?.get(),\n    }));\n    const duration = config.resolveDuration(resolverInput);\n    if (duration === undefined || Number.isNaN(duration) || duration <= 0) return;\n\n    // Patch-object form requires `T extends object`; `state.presentation`'s\n    // T is `MaybeResolvedPresentation | undefined`, which doesn't satisfy\n    // the constraint. The guard at the top of the effect already\n    // established that the slot holds a defined value, so cast to narrow\n    // the signal type and use the cleaner merge form.\n    update(state.presentation as Signal<MaybeResolvedPresentation>, { duration });\n  });\n}\n\n/**\n * `calculatePresentationDuration` uses a manual `Behavior<>` literal\n * (rather than `defineBehavior`) so it can declare just `presentation`\n * in its stateKeys while the typed setup-param shape includes the\n * optional `selectedVideoTrackId` / `selectedAudioTrackId` reads used\n * at runtime. Mirrors the pattern in `endOfStream` for the same\n * reason: the behavior is uniform-across-tracks and reads slots\n * contributed by other behaviors, so it shouldn't leak those slot\n * declarations into variants that don't compose the contributors.\n */\nexport const calculatePresentationDuration: Behavior<\n  { presentation: Signal<PresentationDurationState['presentation']> },\n  Record<string, never>,\n  PresentationDurationConfig\n> = {\n  stateKeys: ['presentation'],\n  contextKeys: [],\n  setup: calculatePresentationDurationSetup,\n};\n"],"mappings":";;;AA2DA,SAAS,mCAAmC,EAC1C,OACA,UAgBa;AACb,QAAO,aAAa;EAClB,MAAM,eAAe,MAAM,aAAa,KAAK;AAC7C,MAAI,CAAC,gBAAgB,aAAa,aAAa,KAAA,EAAW;EAM1D,MAAM,gBAA2C,eAAe;GAC9D;GACA,sBAAsB,MAAM,sBAAsB,KAAK;GACvD,sBAAsB,MAAM,sBAAsB,KAAK;GACxD,EAAE;EACH,MAAM,WAAW,OAAO,gBAAgB,cAAc;AACtD,MAAI,aAAa,KAAA,KAAa,OAAO,MAAM,SAAS,IAAI,YAAY,EAAG;AAOvE,SAAO,MAAM,cAAmD,EAAE,UAAU,CAAC;GAC7E;;;;;;;;;;;;AAaJ,MAAa,gCAIT;CACF,WAAW,CAAC,eAAe;CAC3B,aAAa,EAAE;CACf,OAAO;CACR"}
+{"version":3,"file":"calculate-presentation-duration.js","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"sourcesContent":["/**\n * **Populate presentation duration via a config-supplied resolver.**\n *\n * Once a presentation is in place and its `duration` is still undefined,\n * calls `config.resolveDuration(state)` whenever a tracked slot changes. The\n * resolver decides what counts as \"duration is now derivable\" for the variant\n * in play; the behavior itself stays variant-agnostic:\n *\n * - **VoD** — derive from the first resolved selected track's `duration`\n *   (video preferred, audio fallback). The HLS engine wires\n *   `getResolvedSelectedTrackDuration` from `media/utils/track-selection.ts`\n *   as the default. Audio-only falls out of the same resolver naturally\n *   (no video selected → audio is the first resolved track).\n * - **Live** — return `Number.POSITIVE_INFINITY` once the presentation is\n *   established as live. This is the MSE-spec value for `mediaSource.duration`\n *   under live playback; downstream `updateMediaSourceDuration` propagates it through.\n *\n * Validation: writes whatever the resolver returns as long as it's a positive\n * number, including `Infinity`. `undefined` / `NaN` / `<= 0` are skipped.\n *\n * Fires at most once per presentation — an already-set `duration` is never\n * overwritten, and the next reset arrives structurally when a new\n * (unresolved) presentation replaces the current one. The resolver may\n * return `undefined` while duration is still indeterminate; subsequent\n * tracked-slot changes re-run the effect until the resolver commits a value.\n *\n * Downstream of `resolveVideoTrack` / `resolveAudioTrack`; upstream of\n * `updateMediaSourceDuration` (which writes the value through to `mediaSource.duration`).\n */\nimport type { Behavior } from '../../core/composition/create-composition';\nimport { effect } from '../../core/signals/effect';\nimport { type ReadonlySignal, type Signal, untrack, update } from '../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../media/types';\n\n/**\n * Input shape passed to the duration resolver. Represents the union of\n * track-selection slots the default `getResolvedSelectedTrackDuration`\n * resolver inspects to pick a representative resolved track. Variants\n * that compose neither audio nor video selection still satisfy this\n * shape — the missing fields read as `undefined` and the resolver\n * falls through.\n */\nexport interface PresentationDurationState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\n/**\n * Resolver supplied via `config.resolveDuration`. Returns the duration to\n * write to `presentation.duration`, or `undefined` when it isn't yet\n * derivable. Positive `Infinity` is the canonical live value.\n */\nexport type PresentationDurationResolver = (state: PresentationDurationState) => number | undefined;\n\nexport interface PresentationDurationConfig {\n  resolveDuration: PresentationDurationResolver;\n}\n\nfunction calculatePresentationDurationSetup({\n  state,\n  config,\n}: {\n  state: {\n    presentation: Signal<PresentationDurationState['presentation']>;\n    // selectedVideoTrackId / selectedAudioTrackId are read defensively —\n    // they are *not* declared in this behavior's stateKeys. The slots are\n    // contributed by other behaviors (`switchVideoTrack` writes the\n    // video slot in the default engine; `selectAudioTrack` writes the\n    // audio slot) which compose conditionally per engine variant. Treating\n    // each signal as optional lets calculatePresentationDuration stay\n    // variant-agnostic — it feeds whatever's present to the resolver and\n    // lets the resolver decide.\n    selectedVideoTrackId?: ReadonlySignal<PresentationDurationState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<PresentationDurationState['selectedAudioTrackId']>;\n  };\n  config: PresentationDurationConfig;\n}): () => void {\n  return effect(() => {\n    const presentation = state.presentation.get();\n    if (!presentation || presentation.duration !== undefined) return;\n\n    // presentation drives the effect; selection-only changes can't yield a\n    // writable duration on their own (resolver returns undefined until a\n    // track resolves, at which point resolve-track writes back through\n    // state.presentation anyway), so we read the rest untracked.\n    const resolverInput: PresentationDurationState = untrack(() => ({\n      presentation,\n      selectedVideoTrackId: state.selectedVideoTrackId?.get(),\n      selectedAudioTrackId: state.selectedAudioTrackId?.get(),\n    }));\n    const duration = config.resolveDuration(resolverInput);\n    if (duration === undefined || Number.isNaN(duration) || duration <= 0) return;\n\n    // Patch-object form requires `T extends object`; `state.presentation`'s\n    // T is `MaybeResolvedPresentation | undefined`, which doesn't satisfy\n    // the constraint. The guard at the top of the effect already\n    // established that the slot holds a defined value, so cast to narrow\n    // the signal type and use the cleaner merge form.\n    update(state.presentation as Signal<MaybeResolvedPresentation>, { duration });\n  });\n}\n\n/**\n * `calculatePresentationDuration` uses a manual `Behavior<>` literal\n * (rather than `defineBehavior`) so it can declare just `presentation`\n * in its stateKeys while the typed setup-param shape includes the\n * optional `selectedVideoTrackId` / `selectedAudioTrackId` reads used\n * at runtime. Mirrors the pattern in `endOfStream` for the same\n * reason: the behavior is uniform-across-tracks and reads slots\n * contributed by other behaviors, so it shouldn't leak those slot\n * declarations into variants that don't compose the contributors.\n */\nexport const calculatePresentationDuration: Behavior<\n  { presentation: Signal<PresentationDurationState['presentation']> },\n  Record<string, never>,\n  PresentationDurationConfig\n> = {\n  stateKeys: ['presentation'],\n  contextKeys: [],\n  setup: calculatePresentationDurationSetup,\n};\n"],"mappings":";;;AA2DA,SAAS,mCAAmC,EAC1C,OACA,UAgBa;CACb,OAAO,aAAa;EAClB,MAAM,eAAe,MAAM,aAAa,IAAI;EAC5C,IAAI,CAAC,gBAAgB,aAAa,aAAa,KAAA,GAAW;EAM1D,MAAM,gBAA2C,eAAe;GAC9D;GACA,sBAAsB,MAAM,sBAAsB,IAAI;GACtD,sBAAsB,MAAM,sBAAsB,IAAI;EACxD,EAAE;EACF,MAAM,WAAW,OAAO,gBAAgB,aAAa;EACrD,IAAI,aAAa,KAAA,KAAa,OAAO,MAAM,QAAQ,KAAK,YAAY,GAAG;EAOvE,OAAO,MAAM,cAAmD,EAAE,SAAS,CAAC;CAC9E,CAAC;AACH;;;;;;;;;;;AAYA,MAAa,gCAIT;CACF,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC;CACd,OAAO;AACT"}

package/dist/dev/playback/behaviors/derive-cdn-priority.js.map

@@ -1 +1 @@
-{"version":3,"file":"derive-cdn-priority.js","names":["getCdnId","defaultGetCdnId"],"sources":["../../../../src/playback/behaviors/derive-cdn-priority.ts"],"sourcesContent":["/**\n * **Session-level CDN priority.** While a presentation is resolved, owns the\n * `cdnPriority` signal: the distinct CDNs the source is served from (origin of\n * each track's URL), in manifest priority order — most-preferred first. Cleared\n * on src unload. The name mirrors HLS content steering's `PATHWAY-PRIORITY`.\n *\n * Redundant-stream sources (e.g. Mux's `?redundant_streams=true`) list the same\n * content on multiple hosts, so the candidate tracks already include one variant\n * per CDN. This behavior publishes *which* CDNs exist and their priority; the\n * `preferActiveCdn` scope rule in `track-switching` reads `cdnPriority` and\n * narrows each type's candidates to the first CDN with surviving tracks — so\n * video / audio / text all resolve from one host (the shared list is the\n * per-presentation coherence guarantee).\n *\n * The \"active\" CDN is not stored — it's derived by the scope as the\n * highest-priority entry in `cdnPriority` that still has tracks after the\n * constraints pre-pass. That makes failover a pure consequence of the (future)\n * failed-CDN constraint: when the primary's tracks are pruned during cooldown,\n * the scope falls to the next CDN; when the primary recovers, it snaps back.\n * Content steering, when it lands, reorders `cdnPriority` (pathway priority as a\n * sort key).\n *\n * Lifecycle: `'presentation-unresolved'` ↔ `'presentation-resolved'`, mirroring\n * `setupTrackSwitching`. The resolved state owns the signal; its entry-returned\n * cleanup clears it on exit (canonical cleanup-binds-to-setup per `reactors.md`).\n */\n\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport { createMachineReactor } from '../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../core/signals/primitives';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../media/types';\nimport { getCdnId as defaultGetCdnId, type GetCdnId, getOrderedCdnIds } from '../../media/utils/cdn';\n\nexport interface DeriveCdnPriorityState {\n  presentation?: MaybeResolvedPresentation;\n  cdnPriority?: string[];\n}\n\nconst samePriority = (a: string[] | undefined, b: string[]): boolean =>\n  !!a && a.length === b.length && a.every((cdn, i) => cdn === b[i]);\n\n/**\n * Manage `cdnPriority`: publish the manifest-ordered CDN list on src load, clear\n * on src unload.\n *\n * @example\n * const reactor = deriveCdnPriority.setup({ state });\n */\nexport const deriveCdnPriority = defineBehavior({\n  stateKeys: ['presentation', 'cdnPriority'],\n  contextKeys: [],\n  setup: ({\n    state,\n    config = {},\n  }: {\n    state: {\n      presentation: ReadonlySignal<DeriveCdnPriorityState['presentation']>;\n      cdnPriority: Signal<DeriveCdnPriorityState['cdnPriority']>;\n    };\n    config?: { getCdnId?: GetCdnId };\n  }) => {\n    const getCdnId = config.getCdnId ?? defaultGetCdnId;\n    const derivedStateSignal = computed(() =>\n      isResolvedPresentation(state.presentation.get())\n        ? ('presentation-resolved' as const)\n        : ('presentation-unresolved' as const)\n    );\n\n    return createMachineReactor({\n      initial: 'presentation-unresolved',\n      monitor: () => derivedStateSignal.get(),\n      states: {\n        'presentation-unresolved': {},\n        'presentation-resolved': {\n          // Cleanup-binds-to-setup: the CDN priority list is valid for exactly\n          // 'presentation-resolved'. Clear fires on exit (src unload + destroy).\n          entry: () => () => state.cdnPriority.set(undefined),\n          effects: [\n            () => {\n              const presentation = state.presentation.get();\n              if (!isResolvedPresentation(presentation)) return;\n              const next = getOrderedCdnIds(presentation, getCdnId);\n              // Skip the write when the CDN set is unchanged — a live reload swaps\n              // in a new presentation object with the same hosts, and re-setting a\n              // fresh array would re-fire the scope for an identical result.\n              // `peek` reads without subscribing, so this never self-triggers.\n              if (!samePriority(peek(state.cdnPriority), next)) state.cdnPriority.set(next);\n            },\n          ],\n        },\n      },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAM,gBAAgB,GAAyB,MAC7C,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,KAAK,MAAM,QAAQ,EAAE,GAAG;;;;;;;;AASnE,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,cAAc;CAC1C,aAAa,EAAE;CACf,QAAQ,EACN,OACA,SAAS,EAAE,OAOP;EACJ,MAAMA,aAAW,OAAO,YAAYC;EACpC,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,KAAK,CAAC,GAC3C,0BACA,0BACN;AAED,SAAO,qBAAqB;GAC1B,SAAS;GACT,eAAe,mBAAmB,KAAK;GACvC,QAAQ;IACN,2BAA2B,EAAE;IAC7B,yBAAyB;KAGvB,mBAAmB,MAAM,YAAY,IAAI,KAAA,EAAU;KACnD,SAAS,OACD;MACJ,MAAM,eAAe,MAAM,aAAa,KAAK;AAC7C,UAAI,CAAC,uBAAuB,aAAa,CAAE;MAC3C,MAAM,OAAO,iBAAiB,cAAcD,WAAS;AAKrD,UAAI,CAAC,aAAa,KAAK,MAAM,YAAY,EAAE,KAAK,CAAE,OAAM,YAAY,IAAI,KAAK;OAEhF;KACF;IACF;GACF,CAAC;;CAEL,CAAC"}
+{"version":3,"file":"derive-cdn-priority.js","names":["getCdnId","defaultGetCdnId"],"sources":["../../../../src/playback/behaviors/derive-cdn-priority.ts"],"sourcesContent":["/**\n * **Session-level CDN priority.** While a presentation is resolved, owns the\n * `cdnPriority` signal: the distinct CDNs the source is served from (origin of\n * each track's URL), in manifest priority order — most-preferred first. Cleared\n * on src unload. The name mirrors HLS content steering's `PATHWAY-PRIORITY`.\n *\n * Redundant-stream sources (e.g. Mux's `?redundant_streams=true`) list the same\n * content on multiple hosts, so the candidate tracks already include one variant\n * per CDN. This behavior publishes *which* CDNs exist and their priority; the\n * `preferActiveCdn` scope rule in `track-switching` reads `cdnPriority` and\n * narrows each type's candidates to the first CDN with surviving tracks — so\n * video / audio / text all resolve from one host (the shared list is the\n * per-presentation coherence guarantee).\n *\n * The \"active\" CDN is not stored — it's derived by the scope as the\n * highest-priority entry in `cdnPriority` that still has tracks after the\n * constraints pre-pass. That makes failover a pure consequence of the (future)\n * failed-CDN constraint: when the primary's tracks are pruned during cooldown,\n * the scope falls to the next CDN; when the primary recovers, it snaps back.\n * Content steering, when it lands, reorders `cdnPriority` (pathway priority as a\n * sort key).\n *\n * Lifecycle: `'presentation-unresolved'` ↔ `'presentation-resolved'`, mirroring\n * `setupTrackSwitching`. The resolved state owns the signal; its entry-returned\n * cleanup clears it on exit (canonical cleanup-binds-to-setup per `reactors.md`).\n */\n\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport { createMachineReactor } from '../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../core/signals/primitives';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../media/types';\nimport { getCdnId as defaultGetCdnId, type GetCdnId, getOrderedCdnIds } from '../../media/utils/cdn';\n\nexport interface DeriveCdnPriorityState {\n  presentation?: MaybeResolvedPresentation;\n  cdnPriority?: string[];\n}\n\nconst samePriority = (a: string[] | undefined, b: string[]): boolean =>\n  !!a && a.length === b.length && a.every((cdn, i) => cdn === b[i]);\n\n/**\n * Manage `cdnPriority`: publish the manifest-ordered CDN list on src load, clear\n * on src unload.\n *\n * @example\n * const reactor = deriveCdnPriority.setup({ state });\n */\nexport const deriveCdnPriority = defineBehavior({\n  stateKeys: ['presentation', 'cdnPriority'],\n  contextKeys: [],\n  setup: ({\n    state,\n    config = {},\n  }: {\n    state: {\n      presentation: ReadonlySignal<DeriveCdnPriorityState['presentation']>;\n      cdnPriority: Signal<DeriveCdnPriorityState['cdnPriority']>;\n    };\n    config?: { getCdnId?: GetCdnId };\n  }) => {\n    const getCdnId = config.getCdnId ?? defaultGetCdnId;\n    const derivedStateSignal = computed(() =>\n      isResolvedPresentation(state.presentation.get())\n        ? ('presentation-resolved' as const)\n        : ('presentation-unresolved' as const)\n    );\n\n    return createMachineReactor({\n      initial: 'presentation-unresolved',\n      monitor: () => derivedStateSignal.get(),\n      states: {\n        'presentation-unresolved': {},\n        'presentation-resolved': {\n          // Cleanup-binds-to-setup: the CDN priority list is valid for exactly\n          // 'presentation-resolved'. Clear fires on exit (src unload + destroy).\n          entry: () => () => state.cdnPriority.set(undefined),\n          effects: [\n            () => {\n              const presentation = state.presentation.get();\n              if (!isResolvedPresentation(presentation)) return;\n              const next = getOrderedCdnIds(presentation, getCdnId);\n              // Skip the write when the CDN set is unchanged — a live reload swaps\n              // in a new presentation object with the same hosts, and re-setting a\n              // fresh array would re-fire the scope for an identical result.\n              // `peek` reads without subscribing, so this never self-triggers.\n              if (!samePriority(peek(state.cdnPriority), next)) state.cdnPriority.set(next);\n            },\n          ],\n        },\n      },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAM,gBAAgB,GAAyB,MAC7C,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,KAAK,MAAM,QAAQ,EAAE,EAAE;;;;;;;;AASlE,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,aAAa;CACzC,aAAa,CAAC;CACd,QAAQ,EACN,OACA,SAAS,CAAC,QAON;EACJ,MAAMA,aAAW,OAAO,YAAYC;EACpC,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,IAAI,CAAC,IAC1C,0BACA,yBACP;EAEA,OAAO,qBAAqB;GAC1B,SAAS;GACT,eAAe,mBAAmB,IAAI;GACtC,QAAQ;IACN,2BAA2B,CAAC;IAC5B,yBAAyB;KAGvB,mBAAmB,MAAM,YAAY,IAAI,KAAA,CAAS;KAClD,SAAS,OACD;MACJ,MAAM,eAAe,MAAM,aAAa,IAAI;MAC5C,IAAI,CAAC,uBAAuB,YAAY,GAAG;MAC3C,MAAM,OAAO,iBAAiB,cAAcD,UAAQ;MAKpD,IAAI,CAAC,aAAa,KAAK,MAAM,WAAW,GAAG,IAAI,GAAG,MAAM,YAAY,IAAI,IAAI;KAC9E,CACF;IACF;GACF;EACF,CAAC;CACH;AACF,CAAC"}

package/dist/dev/playback/behaviors/dom/airplay.js

@@ -0,0 +1,211 @@
+import { computed, peek } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { isWebKitAirPlayCapable, listen } from "@videojs/utils/dom";
+//#region src/playback/behaviors/dom/airplay.ts
+/**
+* **Bridge MSE playback to AirPlay on WebKit.**
+* MSE streams can't be handed to an AirPlay receiver directly.
+* The WebKit-recommended workaround is to append a fallback
+* `<source type="application/x-mpegURL">` carrying the original manifest URL:
+* Safari exposes the AirPlay picker and, when a wireless target is selected,
+* plays that native-HLS source on the receiver. The session state (WebKit's
+* wireless flag, falling edge debounced — see `REMOTE_INACTIVE_SETTLE_MS`) is
+* written straight to its policy consequences, declared here so the
+* cause→policy mapping stays with the feature:
+*
+* - `state.loadingSuspended` — held while the session is live. Observed by
+*   the `loadXSegments` dispatchers (no fetching alongside the receiver) and
+*   by `setupMediaSource` (its post-close rebuild waits — attaching runs
+*   `element.load()` under the live receiver, which destroys a session still
+*   being established). The suspension this behavior holds doubles as its own
+*   session fact — same writer, same edges.
+* - `state.startPosition` — one-shot command: the position is captured from
+*   the element at the session's settled end (still receiver-mirrored) and
+*   written once the rebuild's `load()` resets the element (its `'emptied'`),
+*   so `applyStartPosition` applies it to the rebuilt source — never to the
+*   pre-rebuild element — and starts it where the receiver left off. The
+*   playing state rides the same snapshot but stays behavior-local: this
+*   behavior itself calls `play()` once the command has been *consumed* — i.e.
+*   after the seek — when the receiver was playing at session end. The whole
+*   restore is bound to the presentation the session owned and retracted if
+*   that changes.
+*
+* A source change during a live session releases the hold rather than deferring
+* until the session ends, so the rebuild runs and WebKit switches the receiver
+* to the newly-built AirPlay alternate. Measured, not contracted — see the
+* effect below.
+* https://webkit.org/blog/15036/how-to-use-media-source-extensions-with-airplay/
+*
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'airplay-capable'`):
+* gated on a WebKit-AirPlay-capable media element being in scope. The entry —
+* gated on `context.mediaSource` — appends the fallback `<source>` (kept
+* current from `state.presentation`) and enables the AirPlay picker once the
+* MediaSource is open, removing the source the moment the MediaSource detaches
+* so it never survives an MSE teardown. State-exit cleanup (author opt-out,
+* detach, source reset, behavior destroy) removes the source and restores the
+* element's `disableRemotePlayback` default. No-op on non-WebKit platforms
+* (Chromium, Firefox) — `deriveState` never leaves `'preconditions-unmet'`.
+*
+* MMS and AirPlay want *opposite* values of `disableRemotePlayback` on the same
+* element, so it is **sequenced**:
+*
+* - **MMS needs `true` to open.** `setupMediaSource` sets
+*   `disableRemotePlayback = true` when it attaches a ManagedMediaSource —
+*   Safari won't fire `sourceopen` (and MSE playback never starts) otherwise.
+* - **AirPlay needs `false` to offer the picker.** Flipping to `false` *before*
+*   the source opens would prevent `sourceopen`, so the flip is gated on
+*   `context.mediaSource` — which `setupMediaSource` publishes exactly once the
+*   MS is open. Re-fires per source (the slot clears + republishes on reset).
+* - **Author opt-out wins.** `state.disableRemotePlayback` is the author's
+*   intent, written only by the media adapter's IDL property; MMS/programmatic
+*   code touch the element's own `disableRemotePlayback` instead. A `true`
+*   there is unambiguously the author's choice to disable remote playback, so
+*   it holds the machine in `'preconditions-unmet'` and nothing is set up.
+*/
+/**
+* How long WebKit's wireless flag must read *inactive* before the
+* session-driven `loadingSuspended` clears.
+*
+* Measured on Safari 26.4 (macOS): when an AirPlay session engages, Safari
+* closes the ManagedMediaSource and — while its pipeline switches to the
+* native-HLS fallback source — transiently reports
+* `webkitCurrentPlaybackTargetIsWireless === false`, firing the changed
+* event. Trusting an instantaneous inactive reading would release
+* `setupMediaSource`'s rebuild hold mid-handoff; its recovery `load()` then
+* destroys the very session being established. Rising edges apply
+* immediately; only the falling edge waits out this settle window.
+*/
+const REMOTE_INACTIVE_SETTLE_MS = 1e3;
+function deriveState(mediaElement, authorDisabledRemotePlayback) {
+	if (!mediaElement || !isWebKitAirPlayCapable(mediaElement)) return "preconditions-unmet";
+	if (authorDisabledRemotePlayback) return "preconditions-unmet";
+	return "airplay-capable";
+}
+function setupAirPlaySetup({ state, context }) {
+	const derivedStateSignal = computed(() => deriveState(context.mediaElement.get(), state.disableRemotePlayback.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"airplay-capable": { entry: () => {
+				const mediaElement = context.mediaElement.get();
+				const isSessionActive = () => !!mediaElement.webkitCurrentPlaybackTargetIsWireless;
+				let settleTimer;
+				let sessionPresentationUrl;
+				let pendingRestore;
+				/** Presentation an already-written `state.startPosition` belongs to. */
+				let restoreOwnerUrl;
+				let resumeWhenRestored = false;
+				const sync = () => {
+					if (isSessionActive()) {
+						clearTimeout(settleTimer);
+						settleTimer = void 0;
+						if (!peek(state.loadingSuspended)) sessionPresentationUrl = peek(state.presentation)?.url;
+						state.loadingSuspended.set(true);
+					} else if (peek(state.loadingSuspended)) settleTimer ??= setTimeout(() => {
+						settleTimer = void 0;
+						const stillActive = isSessionActive();
+						if (!stillActive) {
+							const ownerUrl = sessionPresentationUrl;
+							sessionPresentationUrl = void 0;
+							if (peek(state.presentation)?.url === ownerUrl) pendingRestore = {
+								position: mediaElement.currentTime,
+								wasPlaying: !mediaElement.paused,
+								presentationUrl: ownerUrl
+							};
+						}
+						state.loadingSuspended.set(stillActive);
+					}, REMOTE_INACTIVE_SETTLE_MS);
+					else state.loadingSuspended.set(false);
+				};
+				const listenerCleanup = new AbortController();
+				listen(mediaElement, "webkitcurrentplaybacktargetiswirelesschanged", sync, { signal: listenerCleanup.signal });
+				listen(mediaElement, "emptied", () => {
+					if (!pendingRestore) return;
+					const { position, wasPlaying, presentationUrl } = pendingRestore;
+					pendingRestore = void 0;
+					if (peek(state.presentation)?.url !== presentationUrl) return;
+					state.startPosition.set(position);
+					restoreOwnerUrl = presentationUrl;
+					resumeWhenRestored = wasPlaying;
+				}, { signal: listenerCleanup.signal });
+				const disposeSourceChangeEnd = effect(() => {
+					const url = state.presentation.get()?.url;
+					if (!peek(state.loadingSuspended) || url === sessionPresentationUrl) return;
+					sessionPresentationUrl = void 0;
+					clearTimeout(settleTimer);
+					settleTimer = void 0;
+					state.loadingSuspended.set(false);
+				});
+				const disposeRestoreWatch = effect(() => {
+					const url = state.presentation.get()?.url;
+					const position = state.startPosition.get();
+					if (!restoreOwnerUrl) return;
+					if (url !== restoreOwnerUrl) {
+						restoreOwnerUrl = void 0;
+						resumeWhenRestored = false;
+						if (position !== void 0) state.startPosition.set(void 0);
+						return;
+					}
+					if (position !== void 0) return;
+					restoreOwnerUrl = void 0;
+					if (!resumeWhenRestored) return;
+					resumeWhenRestored = false;
+					mediaElement.play().catch((err) => {
+						console.warn("[setupAirPlay] session-end resume play() rejected — staying paused:", err);
+					});
+				});
+				let sourceEl = null;
+				const disposeSource = effect(() => {
+					const hasMediaSource = !!context.mediaSource.get();
+					const sessionActive = !!state.loadingSuspended.get();
+					const url = state.presentation.get()?.url ?? "";
+					if (!hasMediaSource && !sessionActive) {
+						sourceEl?.remove();
+						sourceEl = null;
+					} else if (hasMediaSource && (!sourceEl || sourceEl.parentNode !== mediaElement)) {
+						sourceEl = document.createElement("source");
+						sourceEl.type = "application/x-mpegURL";
+						mediaElement.append(sourceEl);
+						mediaElement.disableRemotePlayback = false;
+					}
+					if (sourceEl) sourceEl.src = url;
+				});
+				sync();
+				return () => {
+					disposeSource();
+					disposeSourceChangeEnd();
+					disposeRestoreWatch();
+					listenerCleanup.abort();
+					clearTimeout(settleTimer);
+					sourceEl?.remove();
+					sourceEl = null;
+					mediaElement.disableRemotePlayback = true;
+					state.loadingSuspended.set(false);
+					if (restoreOwnerUrl) {
+						restoreOwnerUrl = void 0;
+						resumeWhenRestored = false;
+						if (peek(state.startPosition) !== void 0) state.startPosition.set(void 0);
+					}
+				};
+			} }
+		}
+	});
+}
+const setupAirPlay = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"disableRemotePlayback",
+		"loadingSuspended",
+		"startPosition"
+	],
+	contextKeys: ["mediaElement", "mediaSource"],
+	setup: setupAirPlaySetup
+});
+//#endregion
+export { setupAirPlay };
+
+//# sourceMappingURL=airplay.js.map

package/dist/dev/playback/behaviors/dom/airplay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"airplay.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/airplay.ts"],"sourcesContent":["/**\n * **Bridge MSE playback to AirPlay on WebKit.**\n * MSE streams can't be handed to an AirPlay receiver directly.\n * The WebKit-recommended workaround is to append a fallback\n * `<source type=\"application/x-mpegURL\">` carrying the original manifest URL:\n * Safari exposes the AirPlay picker and, when a wireless target is selected,\n * plays that native-HLS source on the receiver. The session state (WebKit's\n * wireless flag, falling edge debounced — see `REMOTE_INACTIVE_SETTLE_MS`) is\n * written straight to its policy consequences, declared here so the\n * cause→policy mapping stays with the feature:\n *\n * - `state.loadingSuspended` — held while the session is live. Observed by\n *   the `loadXSegments` dispatchers (no fetching alongside the receiver) and\n *   by `setupMediaSource` (its post-close rebuild waits — attaching runs\n *   `element.load()` under the live receiver, which destroys a session still\n *   being established). The suspension this behavior holds doubles as its own\n *   session fact — same writer, same edges.\n * - `state.startPosition` — one-shot command: the position is captured from\n *   the element at the session's settled end (still receiver-mirrored) and\n *   written once the rebuild's `load()` resets the element (its `'emptied'`),\n *   so `applyStartPosition` applies it to the rebuilt source — never to the\n *   pre-rebuild element — and starts it where the receiver left off. The\n *   playing state rides the same snapshot but stays behavior-local: this\n *   behavior itself calls `play()` once the command has been *consumed* — i.e.\n *   after the seek — when the receiver was playing at session end. The whole\n *   restore is bound to the presentation the session owned and retracted if\n *   that changes.\n *\n * A source change during a live session releases the hold rather than deferring\n * until the session ends, so the rebuild runs and WebKit switches the receiver\n * to the newly-built AirPlay alternate. Measured, not contracted — see the\n * effect below.\n * https://webkit.org/blog/15036/how-to-use-media-source-extensions-with-airplay/\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'airplay-capable'`):\n * gated on a WebKit-AirPlay-capable media element being in scope. The entry —\n * gated on `context.mediaSource` — appends the fallback `<source>` (kept\n * current from `state.presentation`) and enables the AirPlay picker once the\n * MediaSource is open, removing the source the moment the MediaSource detaches\n * so it never survives an MSE teardown. State-exit cleanup (author opt-out,\n * detach, source reset, behavior destroy) removes the source and restores the\n * element's `disableRemotePlayback` default. No-op on non-WebKit platforms\n * (Chromium, Firefox) — `deriveState` never leaves `'preconditions-unmet'`.\n *\n * MMS and AirPlay want *opposite* values of `disableRemotePlayback` on the same\n * element, so it is **sequenced**:\n *\n * - **MMS needs `true` to open.** `setupMediaSource` sets\n *   `disableRemotePlayback = true` when it attaches a ManagedMediaSource —\n *   Safari won't fire `sourceopen` (and MSE playback never starts) otherwise.\n * - **AirPlay needs `false` to offer the picker.** Flipping to `false` *before*\n *   the source opens would prevent `sourceopen`, so the flip is gated on\n *   `context.mediaSource` — which `setupMediaSource` publishes exactly once the\n *   MS is open. Re-fires per source (the slot clears + republishes on reset).\n * - **Author opt-out wins.** `state.disableRemotePlayback` is the author's\n *   intent, written only by the media adapter's IDL property; MMS/programmatic\n *   code touch the element's own `disableRemotePlayback` instead. A `true`\n *   there is unambiguously the author's choice to disable remote playback, so\n *   it holds the machine in `'preconditions-unmet'` and nothing is set up.\n */\n\nimport { isWebKitAirPlayCapable, listen, type WebKitVideoElement } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { effect } from '../../../core/signals/effect';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport type { StartPositionState } from './apply-start-position';\nimport type { SegmentLoadingState } from './load-segments';\n\n/**\n * How long WebKit's wireless flag must read *inactive* before the\n * session-driven `loadingSuspended` clears.\n *\n * Measured on Safari 26.4 (macOS): when an AirPlay session engages, Safari\n * closes the ManagedMediaSource and — while its pipeline switches to the\n * native-HLS fallback source — transiently reports\n * `webkitCurrentPlaybackTargetIsWireless === false`, firing the changed\n * event. Trusting an instantaneous inactive reading would release\n * `setupMediaSource`'s rebuild hold mid-handoff; its recovery `load()` then\n * destroys the very session being established. Rising edges apply\n * immediately; only the falling edge waits out this settle window.\n */\nconst REMOTE_INACTIVE_SETTLE_MS = 1000;\n\ntype AirPlayFsmState = 'preconditions-unmet' | 'airplay-capable';\n\nfunction deriveState(\n  mediaElement: HTMLMediaElement | undefined,\n  authorDisabledRemotePlayback: boolean | undefined\n): AirPlayFsmState {\n  if (!mediaElement || !isWebKitAirPlayCapable(mediaElement)) return 'preconditions-unmet';\n  if (authorDisabledRemotePlayback) return 'preconditions-unmet';\n  return 'airplay-capable';\n}\n\nfunction setupAirPlaySetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;\n    disableRemotePlayback: ReadonlySignal<boolean | undefined>;\n    loadingSuspended: Signal<SegmentLoadingState['loadingSuspended']>;\n    startPosition: Signal<StartPositionState['startPosition']>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<HTMLMediaElement | undefined>;\n    mediaSource: ReadonlySignal<MediaSource | undefined>;\n  };\n}): Reactor<AirPlayFsmState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() => deriveState(context.mediaElement.get(), state.disableRemotePlayback.get()));\n\n  return createMachineReactor<AirPlayFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'airplay-capable': {\n        entry: () => {\n          const mediaElement = context.mediaElement.get() as WebKitVideoElement;\n\n          // WebKit's wireless flag is the only session signal. The standard\n          // Remote Playback API's `remote.state` is deliberately not consulted:\n          // it doesn't track AirPlay sessions reliably on WebKit (same reason\n          // `remotePlaybackFeature` in @videojs/core skips it), and a stale\n          // `'connected'` would pin `loadingSuspended` on — stranding the\n          // rebuild in a way the settle window below can't recover from.\n          const isSessionActive = () => !!mediaElement.webkitCurrentPlaybackTargetIsWireless;\n\n          let settleTimer: ReturnType<typeof setTimeout> | undefined;\n          // Session-end restore. The position/playing snapshot is taken at the\n          // settled falling edge (the element still mirrors the receiver) but\n          // acted on only at the element's next `'emptied'` — once the\n          // rebuild's `load()` has reset the element. Writing it earlier would\n          // hand `applyStartPosition` a command against the pre-rebuild element\n          // (readyState still >= HAVE_METADATA), which it would apply and\n          // consume before the rebuilt source exists.\n          //\n          // The restore is bound to the presentation the session owned, and\n          // that identity is re-checked at *every* async hop — settle timer,\n          // `'emptied'`, and the outstanding-command effect below. Checking at\n          // only one hop leaves the others open: a source change inside the\n          // settle window, or between `'emptied'` and the element becoming\n          // seekable, would otherwise strand the old session's position (and an\n          // unrequested `play()`) on the new source.\n          let sessionPresentationUrl: string | undefined;\n          let pendingRestore:\n            | { position: number; wasPlaying: boolean; presentationUrl: string | undefined }\n            | undefined;\n          /** Presentation an already-written `state.startPosition` belongs to. */\n          let restoreOwnerUrl: string | undefined;\n          let resumeWhenRestored = false;\n\n          const sync = () => {\n            if (isSessionActive()) {\n              clearTimeout(settleTimer);\n              settleTimer = undefined;\n              // Rising edge — the presentation the receiver is taking over.\n              if (!peek(state.loadingSuspended)) sessionPresentationUrl = peek(state.presentation)?.url;\n              state.loadingSuspended.set(true);\n            } else if (peek(state.loadingSuspended)) {\n              // Falling edge: don't trust an instantaneous inactive reading —\n              // re-check once the flag has settled.\n              settleTimer ??= setTimeout(() => {\n                settleTimer = undefined;\n                const stillActive = isSessionActive();\n                if (!stillActive) {\n                  const ownerUrl = sessionPresentationUrl;\n                  sessionPresentationUrl = undefined;\n                  // Snapshot only while the session's own presentation is still\n                  // current. `currentTime` here belongs to that presentation —\n                  // during a session `setupMediaSource` has already torn down,\n                  // so a source change inside this window resets neither the\n                  // element nor its position, and pairing that position with the\n                  // incoming URL would smuggle it onto the new source.\n                  if (peek(state.presentation)?.url === ownerUrl) {\n                    pendingRestore = {\n                      position: mediaElement.currentTime,\n                      wasPlaying: !mediaElement.paused,\n                      presentationUrl: ownerUrl,\n                    };\n                  }\n                }\n                state.loadingSuspended.set(stillActive);\n              }, REMOTE_INACTIVE_SETTLE_MS);\n            } else {\n              state.loadingSuspended.set(false);\n            }\n          };\n          const listenerCleanup = new AbortController();\n          listen(mediaElement, 'webkitcurrentplaybacktargetiswirelesschanged', sync, {\n            signal: listenerCleanup.signal,\n          });\n          listen(\n            mediaElement,\n            'emptied',\n            () => {\n              if (!pendingRestore) return;\n              const { position, wasPlaying, presentationUrl } = pendingRestore;\n              pendingRestore = undefined;\n              if (peek(state.presentation)?.url !== presentationUrl) return;\n              state.startPosition.set(position);\n              restoreOwnerUrl = presentationUrl;\n              resumeWhenRestored = wasPlaying;\n            },\n            { signal: listenerCleanup.signal }\n          );\n\n          // A source change during a live session releases the hold, letting the\n          // rebuild run instead of waiting for the session to end.\n          //\n          // Doing nothing is not a neutral choice — it silently defers the\n          // change. `<source>` children are only consulted while resource\n          // selection runs, so the effect below rewriting the fallback's `src`\n          // does nothing to what the receiver is already playing, and the\n          // rebuild is held by `loadingSuspended`, so the receiver stays on the\n          // outgoing stream until the user disengages.\n          //\n          // Releasing the hold lets the rebuild proceed, and the receiver ends\n          // up on the new stream — measured on Safari 26.4. Note where the\n          // handover actually happens, because it is not the rebuild's `load()`:\n          // clearing the hold also makes the source effect below see an inactive\n          // session with no `context.mediaSource`, so it drops the fallback, and\n          // the rebuild's resource selection runs with the MSE source alone. The\n          // switch comes afterwards, when that effect re-creates the fallback\n          // against the new presentation once the MediaSource opens and WebKit\n          // moves the live session onto the newly-appeared alternate.\n          //\n          // That leaves a window where an active session has no compatible\n          // alternate on the element, and it survives it. Holding the fallback\n          // across the rebuild instead would close the window and make the\n          // handover selection-driven, but it swaps a measured path for an\n          // argued one — don't without a device pass.\n          //\n          // Measured, not contracted: this is under-specified territory, so\n          // nothing here depends on the handover succeeding. If a UA drops the\n          // session instead, the falling edge runs its ordinary course; the\n          // restore is suppressed either way because the snapshot is bound to\n          // the presentation the session owned.\n          //\n          // Note this is *not* an attempt to end the session. Setting\n          // `disableRemotePlayback = true` was tried: the Remote Playback API\n          // requires it to disconnect (spec §5.3.2) but WebKit does not honor\n          // that for AirPlay — the session survived, measured on Safari 26.4.\n          // Deliberately not written here, so that behavior can't silently flip\n          // to \"receiver drops\" if WebKit ever implements the disconnect.\n          const disposeSourceChangeEnd = effect(() => {\n            const url = state.presentation.get()?.url;\n            // `loadingSuspended` is this behavior's own session fact; peeked so\n            // clearing it below doesn't re-trigger.\n            if (!peek(state.loadingSuspended) || url === sessionPresentationUrl) return;\n            sessionPresentationUrl = undefined;\n            clearTimeout(settleTimer);\n            settleTimer = undefined;\n            state.loadingSuspended.set(false);\n          });\n\n          // Watches an outstanding restore command to its end. Two outcomes:\n          //\n          // - **Consumed** (`startPosition` back to `undefined`): the element is\n          //   at the restored position, so resuming is safe. Keying the resume\n          //   off consumption rather than off `'loadedmetadata'` orders it after\n          //   `applyStartPosition`'s seek — arming a listener for the same event\n          //   would put `play()` ahead of the seek, since this behavior registers\n          //   synchronously while `applyStartPosition` only reaches its state a\n          //   microtask later. The rebuild's load algorithm forced `paused =\n          //   true`; a rejection here (autoplay policy) degrades to\n          //   paused-at-position. Requires a `startPosition` consumer in the\n          //   composition (`applyStartPosition`) — without one the position is\n          //   never restored either, so resuming would be wrong anyway.\n          // - **Superseded** (presentation changed): retract the command and\n          //   disarm, so neither the seek nor the resume reaches the new source.\n          const disposeRestoreWatch = effect(() => {\n            const url = state.presentation.get()?.url;\n            const position = state.startPosition.get();\n            if (!restoreOwnerUrl) return;\n\n            if (url !== restoreOwnerUrl) {\n              restoreOwnerUrl = undefined;\n              resumeWhenRestored = false;\n              if (position !== undefined) state.startPosition.set(undefined);\n              return;\n            }\n\n            if (position !== undefined) return;\n            restoreOwnerUrl = undefined;\n            if (!resumeWhenRestored) return;\n            resumeWhenRestored = false;\n            mediaElement.play().catch((err) => {\n              console.warn('[setupAirPlay] session-end resume play() rejected — staying paused:', err);\n            });\n          });\n\n          // This effect combines:\n          // - adding a native HLS fallback source when the mediaSource is\n          //   attached / removing it when it's detached — UNLESS a session is\n          //   live: during an AirPlay session the engine detaches its dead\n          //   MediaSource (see setupMediaSource's sourceclose recovery) while\n          //   the receiver is playing exactly this fallback source, so it\n          //   must survive until the session's falling edge (the rebuild's\n          //   republish then adopts it again).\n          // - keeping this sourceEl's src in sync with the current presentation.\n          // The created source is also cleaned on state exit.\n          // The dependence on context.mediaSource means the source is appended\n          // only after the MMS has been attached and opened (therefore we can\n          // flip disableRemotePlayback). Being in this state also implies\n          // that the author has not disabled remote playback.\n          let sourceEl: HTMLSourceElement | null = null;\n          const disposeSource = effect(() => {\n            const hasMediaSource = !!context.mediaSource.get();\n            const sessionActive = !!state.loadingSuspended.get();\n            const url = state.presentation.get()?.url ?? '';\n\n            if (!hasMediaSource && !sessionActive) {\n              sourceEl?.remove();\n              sourceEl = null;\n            } else if (hasMediaSource && (!sourceEl || sourceEl.parentNode !== mediaElement)) {\n              sourceEl = document.createElement('source');\n              sourceEl.type = 'application/x-mpegURL';\n              mediaElement.append(sourceEl);\n              mediaElement.disableRemotePlayback = false;\n            }\n            if (sourceEl) sourceEl.src = url;\n          });\n\n          // AirPlay may already be active at (re)attach.\n          sync();\n\n          return () => {\n            disposeSource();\n            disposeSourceChangeEnd();\n            disposeRestoreWatch();\n            listenerCleanup.abort();\n            clearTimeout(settleTimer);\n            sourceEl?.remove();\n            sourceEl = null;\n            // Undo the picker enable: hand the element back to its MMS-default\n            // `disableRemotePlayback = true`.\n            mediaElement.disableRemotePlayback = true;\n            // Don't strand the engine held/suspended if we tear down\n            // mid-session (author opt-out, detach, destroy).\n            state.loadingSuspended.set(false);\n            // Nor leave a restore command behind for the next source to apply.\n            if (restoreOwnerUrl) {\n              restoreOwnerUrl = undefined;\n              resumeWhenRestored = false;\n              if (peek(state.startPosition) !== undefined) state.startPosition.set(undefined);\n            }\n          };\n        },\n      },\n    },\n  });\n}\n\nexport const setupAirPlay = defineBehavior({\n  stateKeys: ['presentation', 'disableRemotePlayback', 'loadingSuspended', 'startPosition'],\n  contextKeys: ['mediaElement', 'mediaSource'],\n  setup: setupAirPlaySetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,MAAM,4BAA4B;AAIlC,SAAS,YACP,cACA,8BACiB;CACjB,IAAI,CAAC,gBAAgB,CAAC,uBAAuB,YAAY,GAAG,OAAO;CACnE,IAAI,8BAA8B,OAAO;CACzC,OAAO;AACT;AAEA,SAAS,kBAAkB,EACzB,OACA,WAYwD;CACxD,MAAM,qBAAqB,eAAe,YAAY,QAAQ,aAAa,IAAI,GAAG,MAAM,sBAAsB,IAAI,CAAC,CAAC;CAEpH,OAAO,qBAAsC;EAC3C,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,mBAAmB,EACjB,aAAa;IACX,MAAM,eAAe,QAAQ,aAAa,IAAI;IAQ9C,MAAM,wBAAwB,CAAC,CAAC,aAAa;IAE7C,IAAI;IAgBJ,IAAI;IACJ,IAAI;;IAIJ,IAAI;IACJ,IAAI,qBAAqB;IAEzB,MAAM,aAAa;KACjB,IAAI,gBAAgB,GAAG;MACrB,aAAa,WAAW;MACxB,cAAc,KAAA;MAEd,IAAI,CAAC,KAAK,MAAM,gBAAgB,GAAG,yBAAyB,KAAK,MAAM,YAAY,CAAC,EAAE;MACtF,MAAM,iBAAiB,IAAI,IAAI;KACjC,OAAO,IAAI,KAAK,MAAM,gBAAgB,GAGpC,gBAAgB,iBAAiB;MAC/B,cAAc,KAAA;MACd,MAAM,cAAc,gBAAgB;MACpC,IAAI,CAAC,aAAa;OAChB,MAAM,WAAW;OACjB,yBAAyB,KAAA;OAOzB,IAAI,KAAK,MAAM,YAAY,CAAC,EAAE,QAAQ,UACpC,iBAAiB;QACf,UAAU,aAAa;QACvB,YAAY,CAAC,aAAa;QAC1B,iBAAiB;OACnB;MAEJ;MACA,MAAM,iBAAiB,IAAI,WAAW;KACxC,GAAG,yBAAyB;UAE5B,MAAM,iBAAiB,IAAI,KAAK;IAEpC;IACA,MAAM,kBAAkB,IAAI,gBAAgB;IAC5C,OAAO,cAAc,gDAAgD,MAAM,EACzE,QAAQ,gBAAgB,OAC1B,CAAC;IACD,OACE,cACA,iBACM;KACJ,IAAI,CAAC,gBAAgB;KACrB,MAAM,EAAE,UAAU,YAAY,oBAAoB;KAClD,iBAAiB,KAAA;KACjB,IAAI,KAAK,MAAM,YAAY,CAAC,EAAE,QAAQ,iBAAiB;KACvD,MAAM,cAAc,IAAI,QAAQ;KAChC,kBAAkB;KAClB,qBAAqB;IACvB,GACA,EAAE,QAAQ,gBAAgB,OAAO,CACnC;IAwCA,MAAM,yBAAyB,aAAa;KAC1C,MAAM,MAAM,MAAM,aAAa,IAAI,CAAC,EAAE;KAGtC,IAAI,CAAC,KAAK,MAAM,gBAAgB,KAAK,QAAQ,wBAAwB;KACrE,yBAAyB,KAAA;KACzB,aAAa,WAAW;KACxB,cAAc,KAAA;KACd,MAAM,iBAAiB,IAAI,KAAK;IAClC,CAAC;IAiBD,MAAM,sBAAsB,aAAa;KACvC,MAAM,MAAM,MAAM,aAAa,IAAI,CAAC,EAAE;KACtC,MAAM,WAAW,MAAM,cAAc,IAAI;KACzC,IAAI,CAAC,iBAAiB;KAEtB,IAAI,QAAQ,iBAAiB;MAC3B,kBAAkB,KAAA;MAClB,qBAAqB;MACrB,IAAI,aAAa,KAAA,GAAW,MAAM,cAAc,IAAI,KAAA,CAAS;MAC7D;KACF;KAEA,IAAI,aAAa,KAAA,GAAW;KAC5B,kBAAkB,KAAA;KAClB,IAAI,CAAC,oBAAoB;KACzB,qBAAqB;KACrB,aAAa,KAAK,CAAC,CAAC,OAAO,QAAQ;MACjC,QAAQ,KAAK,uEAAuE,GAAG;KACzF,CAAC;IACH,CAAC;IAgBD,IAAI,WAAqC;IACzC,MAAM,gBAAgB,aAAa;KACjC,MAAM,iBAAiB,CAAC,CAAC,QAAQ,YAAY,IAAI;KACjD,MAAM,gBAAgB,CAAC,CAAC,MAAM,iBAAiB,IAAI;KACnD,MAAM,MAAM,MAAM,aAAa,IAAI,CAAC,EAAE,OAAO;KAE7C,IAAI,CAAC,kBAAkB,CAAC,eAAe;MACrC,UAAU,OAAO;MACjB,WAAW;KACb,OAAO,IAAI,mBAAmB,CAAC,YAAY,SAAS,eAAe,eAAe;MAChF,WAAW,SAAS,cAAc,QAAQ;MAC1C,SAAS,OAAO;MAChB,aAAa,OAAO,QAAQ;MAC5B,aAAa,wBAAwB;KACvC;KACA,IAAI,UAAU,SAAS,MAAM;IAC/B,CAAC;IAGD,KAAK;IAEL,aAAa;KACX,cAAc;KACd,uBAAuB;KACvB,oBAAoB;KACpB,gBAAgB,MAAM;KACtB,aAAa,WAAW;KACxB,UAAU,OAAO;KACjB,WAAW;KAGX,aAAa,wBAAwB;KAGrC,MAAM,iBAAiB,IAAI,KAAK;KAEhC,IAAI,iBAAiB;MACnB,kBAAkB,KAAA;MAClB,qBAAqB;MACrB,IAAI,KAAK,MAAM,aAAa,MAAM,KAAA,GAAW,MAAM,cAAc,IAAI,KAAA,CAAS;KAChF;IACF;GACF,EACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,eAAe,eAAe;CACzC,WAAW;EAAC;EAAgB;EAAyB;EAAoB;CAAe;CACxF,aAAa,CAAC,gBAAgB,aAAa;CAC3C,OAAO;AACT,CAAC"}