demuxe 0.3.0-beta.3

package/web/generated/internal/backend.d.ts

@@ -0,0 +1,27 @@
+import type { RemoteSource, TextTrackSource, TrackType, SubtitleAsset, MediaInputOptions } from '../types.js';
+export interface Backend extends EventTarget {
+    readonly ready: Promise<void>;
+    readonly properties: Map<string, unknown>;
+    readonly diagnostics?: object;
+    open(file: File | ArrayBuffer, options?: MediaInputOptions): Promise<void>;
+    openRemote(source: RemoteSource): Promise<void>;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    seek(seconds: number): Promise<void>;
+    rate(value: number): Promise<void>;
+    volume(value: number): Promise<void>;
+    gain?(value: number): Promise<void>;
+    selectTrack(type: TrackType, id: string): Promise<void>;
+    subtitleVisible(visible: boolean): Promise<void>;
+    resize(width: number, height: number): void;
+    command?(...args: string[]): Promise<void>;
+    addTextTrack?(track: TextTrackSource): Promise<void>;
+    addSubtitle?(subtitle: SubtitleAsset): Promise<void>;
+    audioDiagnostics(): object;
+    destroy(): Promise<void>;
+}
+export type Session = {
+    backend: Backend;
+    surface: HTMLCanvasElement | HTMLVideoElement;
+    error?: Error;
+};

package/web/generated/internal/backend.js

@@ -0,0 +1 @@
+export {};

package/web/generated/internal/errors.d.ts

@@ -0,0 +1,13 @@
+import type { PlayerErrorCode, SessionError, OperationKind } from '../types.js';
+/** Public text intentionally omits all URL queries, fragments and userinfo. */
+export declare function redact(value: unknown): any;
+export declare class PlayerError extends Error implements SessionError {
+    readonly code: PlayerErrorCode;
+    readonly operationId: number | null;
+    readonly operation: OperationKind | null;
+    readonly scope: 'operation' | 'session';
+    readonly retryable: boolean;
+    constructor(code: PlayerErrorCode, message: string, operationId?: number | null, operation?: OperationKind | null, scope?: 'operation' | 'session', retryable?: boolean);
+    toJSON(): SessionError;
+}
+export declare function playerError(error: unknown, id?: number | null, operation?: OperationKind | null, scope?: 'operation' | 'session'): PlayerError;

package/web/generated/internal/errors.js

@@ -0,0 +1,54 @@
+/** Public text intentionally omits all URL queries, fragments and userinfo. */
+export function redact(value) {
+    if (typeof value === 'string')
+        return value.replace(/https?:\/\/[^\s<>"']+/gi, text => {
+            try {
+                const u = new URL(text);
+                return u.origin + u.pathname + (u.search || u.hash ? '?[redacted]' : '');
+            }
+            catch {
+                return '[redacted URL]';
+            }
+        }).replace(/\b(authorization|proxy-authorization|cookie|set-cookie|x-api-key)\s*[:=]\s*[^\r\n]+/gi, '$1: [redacted]').replace(/\b(Bearer|Basic)\s+[^\s,;]+/gi, '$1 [redacted]');
+    if (Array.isArray(value))
+        return value.map(redact);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, v]) => [key, /authorization|cookie|token|secret|password|headers/i.test(key) ? '[redacted]' : redact(v)]));
+    return value;
+}
+export class PlayerError extends Error {
+    code;
+    operationId;
+    operation;
+    scope;
+    retryable;
+    constructor(code, message, operationId = null, operation = null, scope = 'operation', retryable = false) {
+        super(redact(message));
+        this.code = code;
+        this.operationId = operationId;
+        this.operation = operation;
+        this.scope = scope;
+        this.retryable = retryable;
+        this.name = 'PlayerError';
+    }
+    toJSON() { return { code: this.code, message: this.message, operationId: this.operationId, operation: this.operation, scope: this.scope, retryable: this.retryable }; }
+}
+export function playerError(error, id = null, operation = null, scope = 'operation') {
+    if (error instanceof PlayerError)
+        return new PlayerError(error.code, error.message, id ?? error.operationId, operation ?? error.operation, scope, error.retryable);
+    if (error instanceof Error && 'code' in error && error.code === 'UNSUPPORTED_TIMELINE')
+        return new PlayerError('UNSUPPORTED_TIMELINE', error.message, id, operation, scope);
+    const message = error instanceof Error ? error.message : String(error);
+    const name = error instanceof Error ? error.name : '';
+    const code = name === 'AbortError' || /^(?:Operation aborted|Open aborted|Player (?:element )?(?:is )?destroyed|Player element disconnected)|cancelled/i.test(message) ? 'ABORTED'
+        : name === 'NotAllowedError' || /autoplay|user gesture|audio context.*suspended/i.test(message) ? 'AUTOPLAY_BLOCKED'
+            : /cross.origin isolat|secure.*isolated/i.test(message) ? 'ISOLATION_REQUIRED'
+                : /representation changed|changed length|Source changed/i.test(message) ? 'SOURCE_CHANGED'
+                    : /401|403|permission|origin.*not allowed|authorization/i.test(message) ? 'SOURCE_PERMISSION'
+                        : /timed? ?out|deadline/i.test(message) ? 'NETWORK_TIMEOUT'
+                            : /fetch.*module|load.*font|\.wasm|initialization|worker.*failed|import.*module|Aborted\(.*fetch|wasm.*failed|WebAssembly.*(?:compile|instantiate)/i.test(message) ? 'ASSET_LOAD_FAILED'
+                                : /Invalid|Expected|must be|limited to|queue.*full|No source/i.test(message) ? 'INVALID_ARGUMENT'
+                                    : /preserve.*track|unknown.*track|require.*mode|unsupported.*feature|not supported.*source|filters require|cannot.*discard|external.*require/i.test(message) ? 'UNSUPPORTED_FEATURE'
+                                        : /unsupported|no playback route|no browser bridge/i.test(message) ? 'UNSUPPORTED_MEDIA' : 'DECODE_FAILED';
+    return new PlayerError(code, message, id, operation, scope, ['NETWORK_TIMEOUT', 'ASSET_LOAD_FAILED', 'AUTOPLAY_BLOCKED'].includes(code));
+}

package/web/generated/internal/native-ass.d.ts

@@ -0,0 +1,38 @@
+import type { FontAsset, SubtitleAsset } from '../types.js';
+/** External ASS rendering on the accepted media timeline. One bounded RPC at a time. */
+export declare class NativeASS {
+    private video;
+    private time;
+    private failed;
+    readonly canvas: HTMLCanvasElement;
+    private worker;
+    private pending;
+    private sequence;
+    private revision;
+    private stopped;
+    private enabled;
+    private busy;
+    private changingTrack;
+    private frame;
+    private last;
+    private lastRevision;
+    private loading;
+    private observer?;
+    private handlers;
+    readonly ready: Promise<void>;
+    readonly stats: {
+        renders: number;
+        bitmapUpdates: number;
+        bytes: number;
+        peakBytes: number;
+        discarded: number;
+    };
+    constructor(video: HTMLVideoElement, time: () => number, base: URL, fonts: FontAsset[], failed: (e: Error) => void);
+    private request;
+    private fail;
+    load(asset: SubtitleAsset): Promise<void>;
+    visible(value: boolean): void;
+    private invalidate;
+    private tick;
+    destroy(): void;
+}

package/web/generated/internal/native-ass.js

@@ -0,0 +1,206 @@
+/** External ASS rendering on the accepted media timeline. One bounded RPC at a time. */
+export class NativeASS {
+    video;
+    time;
+    failed;
+    canvas = document.createElement('canvas');
+    worker;
+    pending = new Map();
+    sequence = 0;
+    revision = 0;
+    stopped = false;
+    enabled = false;
+    busy = false;
+    changingTrack = false;
+    frame = 0;
+    last = '';
+    lastRevision = -1;
+    loading = new AbortController();
+    observer;
+    handlers = [];
+    ready;
+    stats = { renders: 0, bitmapUpdates: 0, bytes: 0, peakBytes: 0, discarded: 0 };
+    constructor(video, time, base, fonts, failed) {
+        this.video = video;
+        this.time = time;
+        this.failed = failed;
+        if (!crossOriginIsolated)
+            throw Error('Native ASS requires cross-origin isolation');
+        this.canvas.className = 'demuxe-native-ass';
+        this.canvas.style.cssText = 'position:absolute;pointer-events:none;display:none';
+        if (!video.parentElement)
+            throw Error('Missing Native presentation container');
+        // Worker construction can synchronously fail (CSP, URL or allocation).
+        // Do not attach a canvas until its owner exists.
+        this.worker = new Worker(new URL('web/native-ass-worker.js', base), { type: 'module' });
+        const parent = video.parentElement, prior = { position: parent.style.position, fit: video.style.objectFit, pip: video.disablePictureInPicture, remote: video.disableRemotePlayback };
+        try {
+            parent.style.position = 'relative';
+            parent.append(this.canvas);
+            video.style.objectFit = 'contain';
+            video.disablePictureInPicture = true;
+            video.disableRemotePlayback = true;
+            this.worker.onmessage = ({ data }) => { const p = this.pending.get(data.id); if (!p)
+                return; clearTimeout(p.timer); this.pending.delete(data.id); data.error ? p.reject(Error(data.error)) : p.resolve(data); };
+            this.worker.onerror = e => { e.preventDefault(); this.fail(Error(e.message || 'Subtitle worker failed')); };
+            this.worker.onmessageerror = () => this.fail(Error('Subtitle worker message failure'));
+            this.observer = new ResizeObserver(() => this.invalidate());
+            this.observer.observe(video);
+            for (const event of ['seeked', 'seeking', 'pause', 'play', 'ratechange', 'loadedmetadata']) {
+                const listener = () => this.invalidate();
+                video.addEventListener(event, listener);
+                this.handlers.push(() => video.removeEventListener(event, listener));
+            }
+            const fullscreen = () => { if (document.fullscreenElement === video)
+                this.fail(Error('Native ASS requires fullscreen on the player container, not the video element'));
+            else
+                this.invalidate(); };
+            document.addEventListener('fullscreenchange', fullscreen);
+            this.handlers.push(() => document.removeEventListener('fullscreenchange', fullscreen));
+            this.ready = (async () => {
+                const deadline = setTimeout(() => this.loading.abort(), 10000);
+                try {
+                    const response = await fetch(new URL('fixtures/DejaVuSans.ttf', base), { signal: this.loading.signal });
+                    if (!response.ok)
+                        throw Error('Subtitle default font unavailable');
+                    const bytes = await response.arrayBuffer();
+                    if (bytes.byteLength > 8 * 1024 * 1024)
+                        throw Error('Subtitle font budget exceeded');
+                    if (this.stopped)
+                        throw Error('Subtitle renderer destroyed');
+                    await this.request('init', { fonts: [{ name: 'DejaVuSans.ttf', bytes }, ...fonts] });
+                }
+                finally {
+                    clearTimeout(deadline);
+                }
+            })();
+            this.ready.catch(() => { });
+        }
+        catch (error) {
+            this.destroy();
+            parent.style.position = prior.position;
+            video.style.objectFit = prior.fit;
+            video.disablePictureInPicture = prior.pip;
+            video.disableRemotePlayback = prior.remote;
+            throw error;
+        }
+    }
+    request(type, data = {}) {
+        if (this.stopped)
+            return Promise.reject(Error('Subtitle renderer destroyed'));
+        const id = ++this.sequence;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => this.fail(Error('Subtitle worker deadline exceeded')), 10000);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.worker.postMessage({ id, type, ...data });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    fail(error) { if (this.stopped)
+        return; this.destroy(); this.failed(error); }
+    async load(asset) {
+        await this.ready;
+        // Keep the accepted bitmap visible until parsing succeeds. Prevent render
+        // requests from racing the track transaction; rejected parses retain the old
+        // native track and force a fresh render on the same presentation timeline.
+        this.changingTrack = true;
+        this.revision++;
+        try {
+            await this.request('load', { bytes: asset.bytes });
+        }
+        finally {
+            this.changingTrack = false;
+            this.invalidate();
+        }
+    }
+    visible(value) { this.enabled = value; this.canvas.style.display = value ? 'block' : 'none'; this.invalidate(); }
+    invalidate() { this.revision++; this.last = ''; if (!this.stopped && !this.frame)
+        this.frame = requestAnimationFrame(() => this.tick()); }
+    tick() {
+        this.frame = 0;
+        if (this.stopped || !this.enabled || this.changingTrack)
+            return;
+        const rect = this.video.getBoundingClientRect(), parent = this.video.parentElement.getBoundingClientRect();
+        const ratio = this.video.videoWidth / this.video.videoHeight;
+        let width = rect.width, height = rect.height;
+        if (Number.isFinite(ratio)) {
+            if (width / height > ratio)
+                width = height * ratio;
+            else
+                height = width / ratio;
+        }
+        if (width < 1 || height < 1) {
+            this.frame = requestAnimationFrame(() => this.tick());
+            return;
+        }
+        this.canvas.style.left = `${rect.left - parent.left + (rect.width - width) / 2}px`;
+        this.canvas.style.top = `${rect.top - parent.top + (rect.height - height) / 2}px`;
+        this.canvas.style.width = `${width}px`;
+        this.canvas.style.height = `${height}px`;
+        const scale = Math.min(1, 1920 / width, 1080 / height), w = Math.max(1, Math.round(width * scale)), h = Math.max(1, Math.round(height * scale));
+        const sourceWidth = this.video.videoWidth, sourceHeight = this.video.videoHeight;
+        const seconds = this.time(), key = `${w}:${h}:${sourceWidth}:${sourceHeight}:${seconds}`, revision = this.revision;
+        if (!this.busy && key !== this.last) {
+            this.busy = true;
+            this.request('render', { seconds, width: w, height: h, sourceWidth, sourceHeight, force: this.lastRevision !== revision }).then(({ tiles, size, unchanged }) => {
+                if (this.stopped || !this.enabled || revision !== this.revision) {
+                    this.stats.discarded++;
+                    return;
+                }
+                this.lastRevision = revision;
+                if (unchanged) {
+                    this.stats.renders++;
+                    this.last = key;
+                    return;
+                }
+                // Resize only when a complete accepted replacement bitmap is ready. A
+                // paused resize must redraw active cues even if libass reports unchanged.
+                this.canvas.width = w;
+                this.canvas.height = h;
+                const context = this.canvas.getContext('2d');
+                for (const t of tiles) {
+                    const pixels = new ImageData(t.w, t.h);
+                    for (let i = 0; i < t.bytes.length; i++) {
+                        pixels.data[i * 4] = t.color >>> 24;
+                        pixels.data[i * 4 + 1] = (t.color >>> 16) & 255;
+                        pixels.data[i * 4 + 2] = (t.color >>> 8) & 255;
+                        pixels.data[i * 4 + 3] = Math.round(t.bytes[i] * (255 - (t.color & 255)) / 255);
+                    }
+                    const tile = new OffscreenCanvas(t.w, t.h);
+                    tile.getContext('2d').putImageData(pixels, 0, 0);
+                    context.drawImage(tile, t.x, t.y);
+                }
+                this.stats.renders++;
+                this.stats.bitmapUpdates++;
+                this.stats.bytes += size;
+                this.stats.peakBytes = Math.max(this.stats.peakBytes, size);
+                this.last = key;
+            }, error => this.fail(error)).finally(() => { this.busy = false; });
+        }
+        if (!this.video.paused || this.busy || this.last !== key)
+            this.frame = requestAnimationFrame(() => this.tick());
+    }
+    destroy() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.revision++;
+        this.loading.abort();
+        cancelAnimationFrame(this.frame);
+        this.observer?.disconnect();
+        this.handlers.forEach(f => f());
+        this.worker.terminate();
+        for (const p of this.pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(Error('Subtitle renderer destroyed'));
+        }
+        this.pending.clear();
+        this.canvas.remove();
+    }
+}

package/web/generated/internal/native-player.d.ts

@@ -0,0 +1,95 @@
+import type { RemoteSource, TextTrackSource, TrackType, SubtitleAsset, FontAsset } from '../types.js';
+import type { Backend } from './backend.js';
+/** Browser media ownership, including listeners, pending loads and object URLs. */
+export declare class NativePlayer extends EventTarget implements Backend {
+    private video;
+    private remuxPolicy;
+    private assetBase;
+    private bufferedSeeks;
+    private audioAdaptation?;
+    private initialAudioTrack?;
+    private nativeASS;
+    private fonts;
+    readonly ready: Promise<void>;
+    readonly properties: Map<string, unknown>;
+    private stopped;
+    private ass?;
+    private assAssets;
+    private assIndex;
+    private gainContext?;
+    private gainSource?;
+    private gainNode?;
+    private gainValue;
+    gain(value: number): Promise<void>;
+    private resumeGain;
+    private destruction?;
+    private opening;
+    private remux?;
+    private adapted;
+    private remuxSource?;
+    private directFailure?;
+    private shiftedCues;
+    private sourceTime;
+    private sourceDuration;
+    private objectURL?;
+    private selectedSub;
+    private subsVisible;
+    private cancelers;
+    private listeners;
+    constructor(video: HTMLVideoElement, remuxPolicy?: 'auto' | 'never' | 'always', assetBase?: URL, bufferedSeeks?: boolean, audioAdaptation?: "flac" | "opus" | undefined, initialAudioTrack?: number | undefined, nativeASS?: boolean, fonts?: FontAsset[]);
+    private emit;
+    private assertActive;
+    private wait;
+    private refresh;
+    get diagnostics(): {
+        path: string;
+        plan: string;
+        subtitleOverlay: {
+            renders: number;
+            bitmapUpdates: number;
+            bytes: number;
+            peakBytes: number;
+            discarded: number;
+            component: string;
+            scope: string;
+            destination: string;
+        } | undefined;
+        audioProcessing: {
+            component: string;
+            gain: number;
+            contextState: AudioContextState | undefined;
+            baseLatency: number | undefined;
+        };
+        directFailure: string | undefined;
+        remux: Record<string, unknown> | undefined;
+        position: number;
+        rendered: number;
+        dropped: number;
+        readyState: number;
+    };
+    private load;
+    private startRemux;
+    private loadPlan;
+    open(file: File | ArrayBuffer): Promise<void>;
+    openRemote(source: RemoteSource): Promise<void>;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    seek(seconds: number): Promise<void>;
+    private seekPresented;
+    rate(value: number): Promise<void>;
+    volume(value: number): Promise<void>;
+    selectTrack(type: TrackType, id: string): Promise<void>;
+    private applySubtitles;
+    subtitleVisible(visible: boolean): Promise<void>;
+    addSubtitle(asset: SubtitleAsset): Promise<void>;
+    addTextTrack(source: TextTrackSource): Promise<void>;
+    private shiftTextTrack;
+    resize(width: number, height: number): void;
+    audioDiagnostics(): {
+        state: string;
+        source: string;
+        decodedSampleCountersAvailable: boolean;
+    };
+    destroy(): Promise<void>;
+    private dispose;
+}