import { Cue, Segment } from "../../media/types/index.js";
import { AnySlotMap } from "../../core/composition/create-composition.js";
//#region src/playback/primitives/text-segment-load-pipeline.d.ts
/**
 * 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 stays DOM-free. A pure `url → cues` primitive (the text
 * analog of the v/a loader's `fetchBytes`); composition-awareness lives in
 * the injected {@link TextLoadStep}s, not here.
 */
type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;
/** Internal load-task descriptor — one segment fetch + dispatch unit. */
interface TextLoadTask {
  segment: Segment;
  trackId: string;
}
/**
 * A text load in mid-pipeline — the text analog of the v/a loader's `Frame`.
 * `resolveCuesStep` fills `cues`; `dispatchCuesStep` sends them. `metadata` is
 * opaque header metadata a resolve step may attach for a later step to read
 * (e.g. relocation stashes the `X-TIMESTAMP-MAP` correlation here for its rebase
 * step). Typed `unknown` so the generic loader stays host-agnostic — the step
 * that reads it knows its concrete shape (mirrors `StepDeps.state`).
 */
interface TextFrame<C extends Cue = Cue> {
  readonly op: TextLoadTask;
  cues?: C[];
  metadata?: unknown;
}
/**
 * One stage of a text message pipeline — the text analog of the v/a loader's
 * `LoadStep`. Mutates the {@link TextFrame} in place and may be async; the runner
 * checks `signal.aborted` before each step and passes the actor's
 * {@link TextStepDeps} on every call, so a stateless step (`resolveCuesStep`) is a
 * plain value and a step that needs composition signals (relocation's cue rebase)
 * reads them from `deps` at call time.
 */
type TextLoadStep<C extends Cue = Cue> = (frame: TextFrame<C>, signal: AbortSignal, deps: TextStepDeps) => void | Promise<void>;
/**
 * The uniform passthrough handed to each {@link TextLoadStep} — the composition triple,
 * the text analog of `StepDeps`. `state`/`context` are the composition signal maps;
 * `config` is the threaded config with the loader's wiring folded in (see
 * {@link textStepWiring} + `createTextTrackSegmentLoaderActor`). Typed loose: composition
 * steps read `state`; base steps read the folded wiring off `config`.
 */
interface TextStepDeps {
  state: AnySlotMap;
  context: AnySlotMap;
  config: object;
}
/**
 * Builds the ordered step list, called **once per actor** (mirrors the v/a loader's
 * `MessagePipelines`, but text has a single op type so it's a flat array, not a
 * `Record`). The default ({@link DEFAULT_TEXT_MESSAGE_PIPELINES}) is
 * `resolveCues → dispatchCues`; a non-zero-PTS composition returns a list that
 * inserts a cue-rebase step (see `relocatingTextPipelines`), so the loader stays
 * oblivious to relocation.
 */
type TextMessagePipelines<C extends Cue = Cue> = () => TextLoadStep<C>[];
//#endregion
export { TextFrame, TextLoadStep, TextLoadTask, TextMessagePipelines, TextStepDeps, TextTrackSegmentResolver };
//# sourceMappingURL=text-segment-load-pipeline.d.ts.map