@yaneart/yaneplayer 0.0.0-stage → 0.1.0

package/dist/core/ass-renderer.d.ts

@@ -0,0 +1,5 @@
+/** Keep renderer-specific lifecycle details outside playback/transport/UI. */
+export declare function createAssRenderer(video: HTMLVideoElement, content: string, fonts: Uint8Array[], timeOffset: number, signal: AbortSignal, failed: () => void): Promise<{
+    dispose: () => void;
+    setOffset(value: number): Promise<void>;
+}>;

package/dist/core/async.d.ts

@@ -0,0 +1,5 @@
+export declare const aborted: () => DOMException;
+export declare function checkSignal(signal: AbortSignal): void;
+/** Register before invoking the action, including actions which dispatch synchronously. */
+export declare function confirmation(subscribe: (check: () => void) => () => void, predicate: () => boolean, signal: AbortSignal, timeoutMs: number, action?: () => unknown): Promise<void>;
+export declare function untilAborted<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;

package/dist/core/auto-caption-assets.d.ts

@@ -0,0 +1,7 @@
+export declare const autoCaptionAssets: {
+    worker: string;
+    translationWorker: string;
+    worklet: string;
+    wasm: string;
+    wasmModule: string;
+};

package/dist/core/auto-captions.d.ts

@@ -0,0 +1,14 @@
+import type { AutoCaptionState } from "./types.js";
+/** Owns recognition resources only. The video remains the sole playback clock/output. */
+export declare function createAutoCaptions(video: HTMLVideoElement, changed: () => void, captions: {
+    open(): void;
+    clear(): void;
+    show(text: string, segment: number): void;
+    off(): void;
+}): {
+    readonly state: AutoCaptionState;
+    update(readySource: boolean, preparedTracks: boolean, pending: boolean, selectedAudio: string | null): void;
+    off: () => void;
+    setEnabled(value: boolean): Promise<void>;
+    dispose(): void;
+};

package/dist/core/caption-publication.d.ts

@@ -0,0 +1,22 @@
+export type CaptionFragment = {
+    segment: string;
+    offset: number;
+    text: string;
+    position: number;
+};
+/** Mutable recognition stays here. Only complete source fragments cross into MT/UI. */
+export declare class CaptionPublication {
+    private cues;
+    private tail;
+    readonly stats: {
+        blocked: number;
+        evicted: number;
+        overlap: number;
+    };
+    update(segment: string, text: string, now: number, position: number): void;
+    next(now: number): CaptionFragment | undefined;
+    contains(job: CaptionFragment): boolean;
+    complete(job: CaptionFragment, published?: boolean): boolean;
+    private reconcile;
+    private compatible;
+}

package/dist/core/commands.d.ts

@@ -0,0 +1,10 @@
+import type { CommandType, HostCommand } from "./types.js";
+export type CommandInput = HostCommand extends infer C ? C extends HostCommand ? Omit<C, "target"> : never : never;
+/** Keep the active execute awaited even after abort: abort is not server rollback. */
+export declare function commandQueue(execute: (command: HostCommand, id: number, signal: AbortSignal) => Promise<void>, pending: (value: {
+    type: CommandType;
+    commandId: number;
+} | null) => void, nextId: () => number): {
+    enqueue(command: CommandInput): Promise<void>;
+    clear(): void;
+};

package/dist/core/errors.d.ts

@@ -0,0 +1,7 @@
+import type { PlayerError } from "./types.js";
+export declare class RuntimeError extends Error {
+    readonly detail: PlayerError;
+    constructor(detail: PlayerError);
+}
+export declare function failure(code: PlayerError["code"], stage: PlayerError["stage"], message: string, retryable?: boolean): RuntimeError;
+export declare function safeError(error: unknown, stage: PlayerError["stage"]): RuntimeError;

package/dist/core/hls.d.ts

@@ -0,0 +1,4 @@
+import type { PlayerSource } from "./types.js";
+import type { Transport } from "./transport.js";
+export declare const supportsMse: () => boolean;
+export declare function hlsTransport(video: HTMLVideoElement, source: PlayerSource): Transport;

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+import type { PlayerOptions, PlayerRuntime } from "./types.js";
+/** Package version; importing core does not create a player or access the DOM. */
+export declare const version: string;
+export type * from "./types.js";
+/** Browser-only factory. Importing this module does not access the DOM or create media. */
+export declare function createPlayer(options: PlayerOptions): PlayerRuntime;

package/dist/core/platform.d.ts

@@ -0,0 +1,22 @@
+import type { VideoPlayerStore } from "@videojs/core/dom";
+import type { PlatformOptions, PlatformState, PlayerRuntime, PlayerSnapshot, PlayerSource } from "./types.js";
+export declare function createPlatform(video: HTMLVideoElement, container: HTMLElement, store: VideoPlayerStore, changed: () => void, runtime: () => PlayerRuntime, initial?: PlatformOptions, timeoutMs?: number): {
+    bindMedia(media: object): () => void;
+    capabilities(): {
+        fullscreen: boolean;
+        pictureInPicture: boolean;
+        wakeLock: boolean;
+        mediaSession: boolean;
+        orientation: boolean;
+        preservesPitch: boolean;
+    };
+    readonly state: PlatformState;
+    update(next: PlayerSnapshot): void;
+    setSource(next: PlayerSource | null): void;
+    setOptions(next: PlatformOptions): void;
+    enterFullscreen: () => Promise<void>;
+    exitFullscreen: () => Promise<void>;
+    requestPictureInPicture: () => Promise<void>;
+    exitPictureInPicture: () => Promise<void>;
+    dispose(): void;
+};

package/dist/core/preferences.d.ts

@@ -0,0 +1,10 @@
+import type { PlayerPreferences, PlayerSnapshot, PreferencesAdapter } from "./types.js";
+/** Validate the whole record before applying any part of an untrusted host response. */
+export declare function validatePlayerPreferences(value: PlayerPreferences): PlayerPreferences;
+export declare function createPreferences(apply: (value: PlayerPreferences, signal: AbortSignal) => Promise<void>, capture: () => PlayerPreferences, changed: () => void): {
+    readonly state: PlayerSnapshot["preferences"];
+    readonly applying: boolean;
+    setAdapter(next?: PreferencesAdapter): Promise<void>;
+    schedule(): void;
+    dispose(): void;
+};

package/dist/core/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { PlayerOptions, PlayerRuntime } from "./types.js";
+/** Single coordinator owning its foundation store and transport lifecycle. */
+export declare function createRuntime(options: PlayerOptions): PlayerRuntime;

package/dist/core/source.d.ts

@@ -0,0 +1,6 @@
+import type { PlayerSource, TimeRange } from "./types.js";
+export declare function freeze<T>(value: T): T;
+export declare function validateSource(source: PlayerSource, base: string): PlayerSource;
+export declare function offset(source: PlayerSource | null): number | null;
+export declare function absoluteRanges(ranges: readonly TimeRange[], anchor: number | null): TimeRange[];
+export declare const contains: (ranges: readonly TimeRange[], time: number) => boolean;

package/dist/core/subtitle-assets.d.ts

@@ -0,0 +1,6 @@
+export declare const subtitleAssets: {
+    worker: string;
+    wasm: string;
+    modernWasm: string;
+    font: string;
+};

package/dist/core/subtitle-data.d.ts

@@ -0,0 +1,11 @@
+import type { SubtitleResource, SubtitleTrack } from "./types.js";
+export declare const MiB: number;
+export declare const subtitleId: (id: string) => string;
+export declare const localSubtitleId = "subtitle:local";
+export declare const subtitleFailure: (message: string) => import("./errors.js").RuntimeError;
+export declare function validateSubtitles(tracks: readonly SubtitleTrack[] | undefined, base: string): void;
+export declare function resourceURL(resource: SubtitleResource, base: string): URL;
+/** The stream is bounded even when Content-Length is absent or dishonest. */
+export declare function readResource(resource: SubtitleResource, base: string, limit: number, signal: AbortSignal): Promise<Uint8Array<ArrayBuffer>>;
+export declare function decodeSubtitle(data: Uint8Array): string;
+export declare function prepareSubtitle(text: string, format: string): string;

package/dist/core/subtitles.d.ts

@@ -0,0 +1,22 @@
+import type { CaptionState, CaptionStyle, PlayerSource, PlayerTrack } from "./types.js";
+export declare const defaultCaptionStyle: CaptionStyle;
+/** Only subtitle resources/settings live here; playback remains in the foundation store. */
+export declare function createSubtitles(video: HTMLVideoElement, changed: () => void, timeoutMs: number, failed: (cause: unknown) => void): {
+    tracks: () => PlayerTrack[];
+    readonly selected: string | null;
+    readonly localActive: boolean;
+    readonly state: CaptionState;
+    owns: (id: string | null | undefined) => boolean;
+    select: (id: string, signal: AbortSignal) => Promise<void>;
+    openAuto(): void;
+    clearAuto(): void;
+    showAuto(text: string, segment: number): void;
+    off(): void;
+    transport(showing: boolean, hostRendered: boolean): void;
+    setSource(next: PlayerSource, keepLocal?: boolean): void;
+    loadFile(file: File, signal: AbortSignal, current: () => boolean): Promise<void>;
+    removeLocal(): void;
+    setDelay(value: number): Promise<void>;
+    setStyle(value: Partial<CaptionStyle>): void;
+    dispose(): void;
+};

package/dist/core/tracks.d.ts

@@ -0,0 +1,7 @@
+import type { PlayerTrack, TrackPreferences } from "./types.js";
+/** Ordered language matching; accessibility flags are strict filters, default breaks ties. */
+export declare function preferredTrack(tracks: readonly PlayerTrack[], languages?: readonly string[], flags?: {
+    forced?: boolean;
+    sdh?: boolean;
+}): PlayerTrack | undefined;
+export declare function validatePreferences(value: TrackPreferences | undefined): void;

package/dist/core/translation-model.d.ts

@@ -0,0 +1,6 @@
+export declare const translationModel: {
+    model: string;
+    revision: string;
+    bytes: number;
+    files: string[];
+};

package/dist/core/transport.d.ts

@@ -0,0 +1,15 @@
+import type { HlsJsAdapter } from "@videojs/hlsjs-video";
+import type { PlayerSource, PlayerTrack } from "./types.js";
+export interface Transport {
+    readonly media: HTMLVideoElement | HlsJsAdapter;
+    /** HLS foundation marks audio enabled at SWITCHING; expose SWITCHED confirmation. */
+    readonly confirmedAudioId?: string | null;
+    disableText?(): void;
+    textReady?(id: string): boolean;
+    refreshText?(id: string): void;
+    trackMetadata?(kind: "audio" | "text", track: PlayerTrack): Partial<PlayerTrack>;
+    attach(): void;
+    start(): void | Promise<void>;
+    destroy(): void;
+}
+export declare function prepareTransport(video: HTMLVideoElement, source: PlayerSource): Promise<Transport>;

package/dist/core/types.d.ts

@@ -0,0 +1,331 @@
+export type Playback = "idle" | "loading" | "ready" | "playing" | "paused" | "buffering" | "ended" | "error";
+export type Intent = "playing" | "paused";
+export type TimeRange = readonly [start: number, end: number];
+export type Controller = "none" | "transport" | "host";
+export type CommandType = "seek" | "audio" | "text" | "quality";
+export interface PlayerTimeline {
+    readonly mode: "vod" | "live" | "windowed-vod";
+    readonly absoluteAnchorSeconds: number | null;
+    readonly mediaAnchorSeconds: number | null;
+    readonly durationSeconds: number | null;
+    /** Actual local media ranges in absolute coordinates, never torrent download ranges. */
+    readonly seekableRanges?: readonly TimeRange[];
+}
+export interface PlayerTrack {
+    readonly id: string;
+    readonly label?: string;
+    readonly language?: string;
+    readonly channels?: string;
+    readonly default?: boolean;
+    readonly forced?: boolean;
+    readonly sdh?: boolean;
+    readonly description?: string;
+    readonly codec?: string;
+    readonly format?: string;
+    readonly available?: boolean;
+    readonly unavailableReason?: string;
+}
+export interface RequestPolicy {
+    readonly allowedOrigins: readonly string[];
+    readonly credentials?: RequestCredentials;
+    /** Sent only to the original manifest origin. Never copied to another allowed origin. */
+    readonly headers?: Readonly<Record<string, string>>;
+}
+export interface SubtitleResource {
+    readonly src: string;
+    readonly request?: RequestPolicy;
+}
+export interface SubtitleTrack extends PlayerTrack, SubtitleResource {
+    readonly format: "vtt" | "srt" | "ass" | "ssa" | "pgs" | "vobsub";
+    readonly fonts?: readonly SubtitleResource[];
+}
+export interface CaptionStyle {
+    readonly fontScale: number;
+    readonly color: string;
+    readonly background: string;
+    readonly edge: "none" | "outline" | "shadow";
+    /** Rounded UI card for ordinary text cues; headless and authored layouts stay native. */
+    readonly presentation?: "native" | "card";
+}
+export interface CaptionState {
+    readonly delaySeconds: number;
+    readonly style: CaptionStyle;
+    readonly renderer: "native" | "ass" | null;
+    readonly status: "off" | "loading" | "ready" | "error";
+    readonly warning: "ass-style" | "video-only" | "host-rendered" | null;
+}
+export type AutoCaptionMode = "off" | "original" | "ru";
+/** Web Component presentation; recognition remains in snapshot.autoCaptions. */
+export interface AutoCaptionPresentation {
+    readonly mode: AutoCaptionMode;
+    readonly loading: boolean;
+    readonly progress: number | null;
+    readonly error: string | null;
+    readonly videoOnly: boolean;
+}
+export interface AutoCaptionState {
+    readonly available: boolean;
+    readonly reason: "source" | "tracks" | "browser" | null;
+    readonly status: "off" | "loading" | "listening" | "error";
+    readonly progress: number | null;
+    readonly error: string | null;
+    readonly backend: "cpu" | "gpu" | null;
+    /** Age of the oldest audio in the latest hypothesis; not end-of-phrase delay. */
+    readonly latencySeconds: number | null;
+}
+export interface PlayerSource {
+    readonly id: string;
+    readonly revision: string;
+    readonly kind: "mp4" | "hls";
+    readonly src: string;
+    readonly title?: string;
+    readonly metadata?: {
+        readonly artist?: string;
+        readonly album?: string;
+        readonly artwork?: readonly {
+            readonly src: string;
+            readonly sizes?: string;
+            readonly type?: string;
+        }[];
+    };
+    readonly chapters?: readonly PlayerChapter[];
+    readonly timeline?: PlayerTimeline;
+    readonly audioTracks?: readonly PlayerTrack[];
+    readonly textTracks?: readonly PlayerTrack[];
+    /** Sidecar times are absolute. Snapshot IDs are prefixed with `subtitle:`. */
+    readonly subtitles?: readonly SubtitleTrack[];
+    readonly qualities?: readonly PlayerTrack[];
+    readonly capabilities?: {
+        readonly seek?: "none" | "local" | "host";
+        readonly audio?: Controller;
+        readonly text?: Controller;
+        readonly quality?: Controller;
+        readonly playbackRates?: readonly number[];
+    };
+    readonly request?: RequestPolicy;
+    /** Auto prefers MSE, falling back to native HLS; strict request policies require MSE. */
+    readonly hlsPlayback?: "auto" | "native" | "mse";
+}
+export interface PlayerCapabilities {
+    readonly fullscreen: boolean;
+    readonly pictureInPicture: boolean;
+    readonly wakeLock: boolean;
+    readonly mediaSession: boolean;
+    readonly orientation: boolean;
+    readonly preservesPitch: boolean;
+    readonly seek: "none" | "local" | "host";
+    readonly audio: Controller;
+    readonly text: Controller;
+    readonly quality: Controller;
+    readonly autoQuality: boolean;
+    readonly playbackRates: readonly number[];
+    readonly volume: boolean;
+    readonly muted: boolean;
+    readonly reasons: Readonly<Partial<Record<"seek" | "audio" | "text" | "quality" | PlatformFeature, string>>>;
+}
+export interface PlayerError {
+    readonly code: "autoplay-blocked" | "unsupported" | "invalid-source" | "invalid-command" | "network" | "media" | "host" | "timeout";
+    readonly message: string;
+    readonly stage: "source" | "play" | "seek" | "audio" | "text" | "quality" | "media";
+    readonly retryable: boolean;
+}
+export interface PlayerSelection {
+    readonly audioId: string | null;
+    readonly textId: string | null;
+    readonly qualityId: string | null;
+}
+export interface PlayerSnapshot {
+    readonly platform: PlatformState;
+    readonly preferences: {
+        readonly status: "idle" | "loading" | "ready" | "saving" | "error";
+        readonly error: string | null;
+    };
+    readonly navigation: {
+        readonly previous: boolean;
+        readonly next: boolean;
+        readonly pending: "previous" | "next" | null;
+        readonly error: string | null;
+    };
+    readonly chapters: readonly PlayerChapter[];
+    readonly preservesPitch: boolean;
+    readonly source: Readonly<Pick<PlayerSource, "id" | "revision" | "kind">> | null;
+    readonly playback: Playback;
+    readonly intent: Intent;
+    readonly pending: {
+        readonly type: "source" | CommandType;
+        readonly commandId: number;
+    } | null;
+    readonly positionSeconds: number | null;
+    readonly durationSeconds: number | null;
+    readonly buffered: readonly TimeRange[];
+    readonly seekable: readonly TimeRange[];
+    readonly audioTracks: readonly PlayerTrack[];
+    readonly textTracks: readonly PlayerTrack[];
+    readonly qualities: readonly PlayerTrack[];
+    readonly selection: PlayerSelection;
+    readonly volume: number;
+    readonly muted: boolean;
+    readonly playbackRate: number;
+    readonly captions: CaptionState;
+    readonly autoCaptions: AutoCaptionState;
+    readonly capabilities: PlayerCapabilities;
+    readonly error: PlayerError | null;
+}
+export interface HostTarget {
+    readonly positionSeconds?: number;
+    readonly audioId?: string;
+    readonly textId?: string | null;
+    readonly qualityId?: string;
+}
+export type HostCommand = ({
+    readonly type: "seek";
+    readonly seconds: number;
+} | {
+    readonly type: "audio";
+    readonly id: string;
+} | {
+    readonly type: "text";
+    readonly id: string | null;
+} | {
+    readonly type: "quality";
+    readonly id: string;
+}) & {
+    readonly target: HostTarget;
+};
+export interface HostContext {
+    readonly sourceId: string;
+    readonly revision: string;
+    readonly commandId: number;
+    readonly signal: AbortSignal;
+    readonly positionSeconds: number | null;
+    /** Getter: play/pause during preparation is visible without starting another mutation. */
+    readonly intent: Intent;
+}
+export interface HostResult {
+    readonly source?: PlayerSource;
+    /** Confirmation from host, not admission. Replacement still waits for media readiness. */
+    readonly selection?: Partial<PlayerSelection>;
+}
+export interface HostAdapter {
+    execute(command: HostCommand, context: HostContext): Promise<HostResult>;
+}
+export type PlayerEventType = "statechange" | "positionchange" | "trackchange" | "qualitychange" | "commandchange" | "capabilitieschange" | "ended" | "error";
+export interface PlayerEvent {
+    readonly type: PlayerEventType;
+    readonly source: PlayerSnapshot["source"];
+    readonly snapshot: PlayerSnapshot;
+}
+export interface PlayerOptions {
+    readonly media: HTMLVideoElement;
+    readonly container?: HTMLElement;
+    readonly platform?: PlatformOptions;
+    readonly preferences?: PreferencesAdapter;
+    readonly navigation?: PlayerNavigation;
+    readonly thumbnail?: ThumbnailResolver;
+    readonly host?: HostAdapter;
+    readonly onEvent?: (event: PlayerEvent) => void;
+    /** Bounds media readiness/confirmation. Host owns reconciliation of accepted mutations. */
+    readonly commandTimeoutMs?: number;
+}
+export interface SourceOptions {
+    readonly positionSeconds?: number;
+    readonly intent?: Intent;
+    readonly trackPreferences?: TrackPreferences;
+}
+/** Per-source initial choices. Hosts own persistence; IDs never become preferences. */
+export interface TrackPreferences {
+    readonly audioLanguages?: readonly string[];
+    /** Omitted/null means Off, including DEFAULT/FORCED tracks. */
+    readonly text?: {
+        readonly languages?: readonly string[];
+        readonly forced?: boolean;
+        readonly sdh?: boolean;
+    } | null;
+}
+export interface PlayerRuntime {
+    getSnapshot(): PlayerSnapshot;
+    subscribe(listener: () => void): () => void;
+    setSource(source: PlayerSource, options?: SourceOptions): Promise<void>;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    seek(seconds: number): Promise<void>;
+    selectAudio(id: string): Promise<void>;
+    selectText(id: string | null): Promise<void>;
+    /** Read locally without uploading. Replaces the previous local subtitle file. */
+    loadSubtitles(file: File): Promise<void>;
+    removeLocalSubtitles(): Promise<void>;
+    setCaptionStyle(style: Partial<CaptionStyle>): Promise<void>;
+    setCaptionDelay(seconds: number): Promise<void>;
+    /** Local recognition, only when no prepared subtitles are available. Off on source change. */
+    setAutoCaptions(enabled: boolean): Promise<void>;
+    selectQuality(id: string): Promise<void>;
+    setVolume(value: number): Promise<void>;
+    setMuted(value: boolean): Promise<void>;
+    setPlaybackRate(value: number): Promise<void>;
+    setPreservesPitch(value: boolean): Promise<void>;
+    enterFullscreen(): Promise<void>;
+    exitFullscreen(): Promise<void>;
+    requestPictureInPicture(): Promise<void>;
+    exitPictureInPicture(): Promise<void>;
+    setPlatformOptions(options: PlatformOptions): void;
+    setPreferences(adapter?: PreferencesAdapter): Promise<void>;
+    setNavigation(navigation: PlayerNavigation): void;
+    navigate(direction: "previous" | "next"): Promise<void>;
+    setThumbnailResolver(resolver?: ThumbnailResolver): void;
+    getThumbnail(seconds: number, signal: AbortSignal): Promise<PlayerThumbnail | null>;
+    dispose(): void;
+}
+export type PlatformFeature = "fullscreen" | "pictureInPicture" | "wakeLock" | "mediaSession" | "orientation";
+export interface PlatformOptions {
+    readonly wakeLock?: boolean;
+    readonly mediaSession?: boolean;
+    /** Optional fullscreen-only lock. Never required for successful fullscreen. */
+    readonly orientation?: "landscape";
+}
+export interface PlatformState {
+    readonly fullscreen: boolean;
+    readonly pictureInPicture: boolean;
+    readonly wakeLock: boolean;
+    readonly orientationLocked: boolean;
+    readonly mediaSessionActive: boolean;
+    readonly pending: "fullscreen" | "pictureInPicture" | null;
+    readonly error: {
+        readonly feature: PlatformFeature;
+        readonly message: string;
+    } | null;
+}
+export interface PlayerPreferences {
+    readonly volume?: number;
+    readonly muted?: boolean;
+    readonly playbackRate?: number;
+    readonly preservesPitch?: boolean;
+    readonly tracks?: TrackPreferences;
+    readonly captionStyle?: Partial<CaptionStyle>;
+    readonly captionDelaySeconds?: number;
+}
+export interface PreferencesAdapter {
+    load(context: {
+        readonly signal: AbortSignal;
+    }): Promise<PlayerPreferences | null>;
+    save(preferences: PlayerPreferences, context: {
+        readonly signal: AbortSignal;
+    }): Promise<void>;
+}
+export interface PlayerNavigation {
+    readonly previous?: () => void | Promise<void>;
+    readonly next?: () => void | Promise<void>;
+    /** Only an actual ended event invokes next automatically. Defaults to false. */
+    readonly autoAdvance?: boolean;
+}
+export interface PlayerChapter {
+    readonly startSeconds: number;
+    readonly title: string;
+}
+export interface PlayerThumbnail {
+    readonly src: string;
+}
+export type ThumbnailResolver = (context: {
+    readonly source: NonNullable<PlayerSnapshot["source"]>;
+    readonly seconds: number;
+    readonly signal: AbortSignal;
+}) => Promise<PlayerThumbnail | null>;