demuxe 0.3.0-beta.3

package/web/generated/internal/playback-plans.js

@@ -0,0 +1,110 @@
+/** Finite execution plans; qualification is local to a feature, not a browser claim. */
+export const PLAYBACK_PLANS = Object.freeze([
+    { id: 'native-direct', mode: 'native', video: 'browser', audio: 'original', qualification: 'existing' },
+    { id: 'native-remux', mode: 'native', video: 'packet-copy', audio: 'packet-copy', qualification: 'existing' },
+    { id: 'native-direct-gain', mode: 'native', video: 'browser', audio: 'web-audio-gain', qualification: 'experimental' },
+    { id: 'native-remux-gain', mode: 'native', video: 'packet-copy', audio: 'web-audio-gain', qualification: 'experimental' },
+    { id: 'native-flac', mode: 'native', video: 'packet-copy', audio: 'flac-lossless', qualification: 'experimental' },
+    { id: 'native-flac-gain', mode: 'native', video: 'packet-copy', audio: 'flac-lossless+web-audio-gain', qualification: 'experimental' },
+    { id: 'native-direct-ass', mode: 'native', video: 'browser', audio: 'original', qualification: 'experimental' },
+    { id: 'native-direct-ass-gain', mode: 'native', video: 'browser', audio: 'original+web-audio-gain', qualification: 'experimental' },
+    { id: 'native-remux-ass', mode: 'native', video: 'packet-copy', audio: 'packet-copy', qualification: 'experimental' },
+    { id: 'native-remux-ass-gain', mode: 'native', video: 'packet-copy', audio: 'packet-copy+web-audio-gain', qualification: 'experimental' },
+    { id: 'native-flac-ass', mode: 'native', video: 'packet-copy', audio: 'flac-lossless', qualification: 'experimental' },
+    { id: 'native-flac-ass-gain', mode: 'native', video: 'packet-copy', audio: 'flac-lossless+web-audio-gain', qualification: 'experimental' },
+    { id: 'native-opus', mode: 'native', video: 'packet-copy', audio: 'opus-lossy', qualification: 'experimental' },
+    { id: 'native-opus-gain', mode: 'native', video: 'packet-copy', audio: 'opus-lossy+web-audio-gain', qualification: 'experimental' },
+    { id: 'hybrid', mode: 'hybrid', video: 'webcodecs', audio: 'mpv', qualification: 'existing' },
+    { id: 'hybrid-audio-filter', mode: 'hybrid', video: 'webcodecs', audio: 'mpv-filter', qualification: 'experimental' },
+    { id: 'hybrid-gain', mode: 'hybrid', video: 'webcodecs', audio: 'mpv+web-audio-gain', qualification: 'experimental' },
+    { id: 'hybrid-audio-filter-gain', mode: 'hybrid', video: 'webcodecs', audio: 'mpv-filter+web-audio-gain', qualification: 'experimental' },
+    { id: 'software-gain', mode: 'software', video: 'ffmpeg', audio: 'mpv+web-audio-gain', qualification: 'experimental' },
+    { id: 'software', mode: 'software', video: 'ffmpeg', audio: 'mpv', qualification: 'existing' },
+].map(plan => Object.freeze({ ...plan,
+    source: (plan.id.startsWith('native-remux') || plan.id.startsWith('native-flac') || plan.id.startsWith('native-opus')) ? 'qualified random-access file and selected codec packaging' : plan.mode === 'native' ? 'browser-supported source and selected tracks' : 'existing mpv source/track contract',
+    prerequisites: (plan.id.startsWith('native-remux') || plan.id.startsWith('native-flac') || plan.id.startsWith('native-opus')) ? 'MSE, cross-origin isolation, qualified MIME' : plan.mode === 'native' ? 'HTMLMediaElement' + (plan.id.endsWith('gain') ? ', Web Audio and CORS-clean media' : '') : 'cross-origin isolation' + (plan.mode === 'hybrid' ? ', supported complete WebCodecs configuration' : ''),
+    subtitles: plan.id.includes('-ass') ? 'external ASS/SSA via pinned libass; container presentation only' : plan.mode === 'native' ? 'browser text tracks' : 'mpv/libass',
+    fidelity: plan.id.startsWith('native-opus') ? 'Explicitly permitted lossy audio; no resampling/downmix; video copied' : plan.id.startsWith('native-flac') ? 'Selected integer audio encoded losslessly as FLAC; video copied; no downmix/resample' : 'No audio encoding, downmix or resampling added by route selection; existing backend output contracts apply',
+    resources: plan.mode === 'native' ? 'existing bounded remux buffers when used; browser decoder allocations are opaque' : 'existing mpv allocation, PCM ring and retained-frame limits',
+    fallback: plan.mode === 'software' ? 'terminal' : 'existing diagnosed-path fallback with source and user intent preserved',
+})));
+// Only the demonstrated scalar filter is admitted. Expressions, chains, channel
+// remapping, resampling, latency-changing filters and video filters are excluded.
+export function qualifiedAudioFilter(chain) {
+    const match = /^(?:volume=([0-9]+(?:\.[0-9]+)?)|lavfi=\[volume=([0-9]+(?:\.[0-9]+)?)\])$/.exec(chain);
+    return !!match && Number(match[1] ?? match[2]) <= 1;
+}
+export function featureRejection(mode, features) {
+    if (mode === 'software')
+        return;
+    if (features.vf || features.toneMapping !== 'off')
+        return 'Video filters and tone mapping require Software. Clear filters before leaving software mode.';
+    if (!features.af)
+        return;
+    if (mode === 'native')
+        return 'Audio filters require mpv. Clear filters before selecting Native.';
+    if (!features.hybridAudioFilters)
+        return 'Hybrid audio filters require explicit experimental admission';
+    if (!qualifiedAudioFilter(features.af))
+        return 'This audio filter has not been qualified for Hybrid';
+}
+export function executionPlan(mode, packaging, audioFilter, gain = 1, nativeASS = false) {
+    let id = (mode === 'native' ? packaging === 'adapted-opus' ? gain !== 1 ? 'native-opus-gain' : 'native-opus' : packaging === 'adapted-flac' ? gain !== 1 ? 'native-flac-gain' : 'native-flac' : packaging === 'remux' ? gain !== 1 ? 'native-remux-gain' : 'native-remux' : gain !== 1 ? 'native-direct-gain' : 'native-direct' : mode === 'hybrid' ? audioFilter ? gain !== 1 ? 'hybrid-audio-filter-gain' : 'hybrid-audio-filter' : gain !== 1 ? 'hybrid-gain' : 'hybrid' : gain !== 1 ? 'software-gain' : 'software');
+    if (mode === 'native' && nativeASS)
+        id = gain !== 1 ? id.replace(/-gain$/, '-ass-gain') : id + '-ass';
+    return PLAYBACK_PLANS.find(plan => plan.id === id);
+}
+/** Admission is executable and deliberately finite. Runtime output verification
+ * still owns acceptance; browser capability signals cannot prove presentation. */
+export function planAdmission(f) {
+    return PLAYBACK_PLANS.map(plan => {
+        let code, reason;
+        const reject = (c, r) => { code = c; reason = r; };
+        const gain = plan.id.endsWith('-gain'), ass = plan.id.includes('-ass'), flac = plan.id.startsWith('native-flac'), opus = plan.id.startsWith('native-opus');
+        const effect = featureRejection(plan.mode, { ...f });
+        if (effect)
+            reject('FEATURE_UNSUPPORTED', effect);
+        else if (gain !== (f.gain !== 1))
+            reject('PLAN_NOT_REQUESTED', 'Gain stage does not match the requested presentation');
+        else if (gain && !f.webAudio)
+            reject('DEPLOYMENT_UNAVAILABLE', 'Web Audio is unavailable');
+        else if (plan.mode !== 'native' && !f.isolated)
+            reject('ISOLATION_REQUIRED', 'mpv deployment requires cross-origin isolation');
+        else if (plan.mode === 'hybrid' && !f.webCodecs)
+            reject('DEPLOYMENT_UNAVAILABLE', 'WebCodecs video decoding is unavailable');
+        else if (plan.mode === 'hybrid' && plan.id.includes('audio-filter') !== !!f.af)
+            reject('PLAN_NOT_REQUESTED', 'mpv scalar filter stage does not match the request');
+        else if (plan.mode !== 'native' && f.browserTextTracks)
+            reject('FEATURE_UNSUPPORTED', 'External browser text tracks cannot be silently discarded');
+        else if (plan.mode === 'native') {
+            const prepared = plan.id.startsWith('native-remux') || flac || opus;
+            if (f.audioOutput !== 'stereo')
+                reject('FEATURE_UNSUPPORTED', 'Explicit PCM layout requires mpv');
+            else if (ass !== !!f.externalFormats.length)
+                reject('PLAN_NOT_REQUESTED', 'Subtitle component does not match the requested presentation');
+            else if (ass && (!f.nativeASS || f.externalFormats.some(format => !['ass', 'ssa'].includes(format))))
+                reject('FEATURE_UNSUPPORTED', 'External subtitle format requires mpv or explicit Native ASS admission');
+            else if (ass && f.manifest)
+                reject('QUALIFICATION_REQUIRED', 'Native ASS is qualified only on file presentations');
+            else if (ass && !f.isolated)
+                reject('ISOLATION_REQUIRED', 'Native libass requires cross-origin isolation');
+            else if (prepared && f.manifest)
+                reject('QUALIFICATION_REQUIRED', 'File preparation is not qualified for manifest sources');
+            else if (prepared && !f.isolated)
+                reject('ISOLATION_REQUIRED', 'Native preparation requires cross-origin isolation');
+            else if (prepared && (f.nativeRemux === 'never' || !f.mse))
+                reject('DEPLOYMENT_UNAVAILABLE', 'Native preparation requires permitted MSE and cross-origin isolation');
+            else if (!prepared && (f.nativeRemux === 'always' || f.requiresRemux))
+                reject('SOURCE_UNSUPPORTED', 'This source policy requires controlled remux transport');
+            else if ((flac || opus) && (f.automatic ? (!flac || !f.automaticLossless) : f.adaptation !== (flac ? 'flac' : 'opus')))
+                reject('QUALIFICATION_REQUIRED', 'Audio adaptation requires explicit profile or qualified automatic lossless policy');
+            else if (opus && !f.allowLossy)
+                reject('POLICY_PROHIBITS_TRANSFORM', 'Lossy audio permission is absent');
+            else if (flac && f.automatic && !f.adaptationSourceQualified)
+                reject('SOURCE_UNSUPPORTED', f.adaptationSourceRejection ?? 'Automatic FLAC source has not been qualified');
+            else if (f.nativeSourceRejection && !(flac && f.automatic && f.automaticLossless))
+                reject('SOURCE_UNSUPPORTED', f.nativeSourceRejection);
+        }
+        return { id: plan.id, mode: plan.mode, eligible: !code, ...(code ? { code, reason } : {}) };
+    });
+}

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

@@ -0,0 +1,45 @@
+import type { PlaybackMode } from '../types.js';
+export type ProbeTrack = {
+    id: string;
+    index: number;
+    type: string;
+    codec: string;
+    codecString?: string;
+    default?: boolean;
+    forced?: boolean;
+    channels?: number;
+    aacObject?: number;
+    attachedPicture?: boolean;
+    sampleRate?: number;
+    bits?: number;
+    startTime?: number;
+    endTime?: number;
+    width?: number;
+    height?: number;
+};
+export type Probe = {
+    tracks: ProbeTrack[];
+    duration: number;
+    format?: string;
+    identity?: {
+        size: string;
+        etag?: string;
+    };
+};
+/** Narrow file-only automatic FLAC admission. Unknown or unequal ends are rejected.
+ * The runtime still verifies packets, samples, actual MSE output and work bounds. */
+export declare function losslessAdaptationRejection(probe: Probe, settings: {
+    aid: string;
+    sid: string;
+    subtitles: boolean;
+}): string | undefined;
+export type SelectionAttempt = {
+    mode: PlaybackMode | 'probe';
+    outcome: 'skipped' | 'failed' | 'selected';
+    reason: string;
+};
+export declare function nativeRejection(probe: Probe, settings: {
+    aid: string;
+    sid: string;
+    subtitles: boolean;
+}, video: HTMLVideoElement): string | undefined;

package/web/generated/internal/selection.js

@@ -0,0 +1,45 @@
+/** Narrow file-only automatic FLAC admission. Unknown or unequal ends are rejected.
+ * The runtime still verifies packets, samples, actual MSE output and work bounds. */
+export function losslessAdaptationRejection(probe, settings) {
+    if (!probe.format?.includes('matroska'))
+        return 'Automatic FLAC requires inspected Matroska';
+    const selected = (type, id = 'auto') => { const tracks = probe.tracks.filter(t => t.type === type && !t.attachedPicture); return id === 'no' ? undefined : id === 'auto' ? (tracks.find(t => t.default) || tracks[0]) : tracks.find(t => t.id === id); };
+    if (settings.subtitles && selected('sub', settings.sid))
+        return 'Embedded subtitles require mpv rendering';
+    const v = selected('video'), a = selected('audio', settings.aid);
+    if (!v || v.codec !== 'h264' || !v.width || !v.height || v.width * v.height > 1920 * 1080)
+        return 'Automatic FLAC requires H264 up to 1080p';
+    if (!a || !['pcm_s16le', 'pcm_s24le'].includes(a.codec) || a.sampleRate !== 48000 || ![1, 2].includes(a.channels ?? 0) || ![16, 24].includes(a.bits ?? 0))
+        return 'Automatic FLAC requires selected 48 kHz mono/stereo PCM16/24';
+    if ([v, a].some(t => !Number.isFinite(t.startTime) || t.startTime < 0 || !Number.isFinite(t.endTime) || t.endTime <= t.startTime))
+        return 'Automatic FLAC requires known selected-track bounds';
+    if (Math.abs(v.startTime - a.startTime) > .05 || Math.abs(v.endTime - a.endTime) > .05)
+        return 'Automatic FLAC selected-track offsets or tails exceed qualification';
+    if (!Number.isFinite(probe.duration) || probe.duration <= 0)
+        return 'Automatic FLAC requires a finite duration';
+}
+export function nativeRejection(probe, settings, video) {
+    const selected = (type, id = 'auto') => { const tracks = probe.tracks.filter(t => t.type === type && !t.attachedPicture); return id === 'no' ? undefined : id === 'auto' ? (tracks.find(t => t.default) || tracks[0]) : tracks.find(t => t.id === id); };
+    // Browser text-track exposure cannot reliably prove embedded subtitle delivery.
+    if (settings.subtitles && selected('sub', settings.sid))
+        return 'Embedded subtitles require mpv rendering';
+    const v = selected('video'), a = selected('audio', settings.aid);
+    if (!['auto', 'no'].includes(settings.aid) && !a)
+        return 'Requested audio track was not found';
+    const codecs = { h264: 'avc1', hevc: 'hev1', vp8: 'vp8', vp9: 'vp09.00.10.08', av1: 'av01.0.04M.08', aac: 'mp4a.40.2', mp3: 'mp3', opus: 'opus', vorbis: 'vorbis', flac: 'flac', ac3: 'ac-3', eac3: 'ec-3' };
+    if (!v && !a)
+        return 'No selected playable streams';
+    for (const t of [v, a])
+        if (t && !codecs[t.codec])
+            return `Native has no qualified ${t.type} mapping for ${t.codec}`;
+    if (a?.codec === 'aac') {
+        if (!a.aacObject || a.aacObject < 1 || a.aacObject >= 31)
+            return 'Native AAC profile is unavailable';
+        codecs.aac = `mp4a.40.${a.aacObject}`;
+    }
+    // Try each relevant packaging contract. A WebM rejection does not rule out MP4
+    // (for example VP9 plus AAC). Actual remux configuration and playback still gate.
+    const mimes = ['mp4', 'webm'].map(container => `${v ? 'video' : 'audio'}/${container}; codecs="${[v, a].filter(Boolean).map(t => container === 'webm' && t.codec === 'vp9' ? 'vp9' : t.codecString ?? codecs[t.codec]).join(',')}"`);
+    if (!mimes.some(mime => video.canPlayType(mime)))
+        return `Browser does not report support for ${mimes.join(' or ')}`;
+}

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

@@ -0,0 +1,8 @@
+import type { MediaInfo, MediaTrack, TimeRange, PlaybackMode } from '../types.js';
+export declare function freeze<T>(value: T): T;
+export declare function ranges(value: unknown): readonly TimeRange[] | null;
+export type RawTrack = Record<string, any>;
+export declare function usesRemuxTracks(plan?: string): boolean;
+export declare function trackKey(track: RawTrack, mode: PlaybackMode, plan?: string): string;
+export declare function tracks(raw: RawTrack[], sourceId: number, mode: PlaybackMode, plan?: string): MediaTrack[];
+export declare function mediaInfo(properties: ReadonlyMap<string, unknown>, mode: PlaybackMode, surface: HTMLCanvasElement | HTMLVideoElement | undefined, list: MediaTrack[]): MediaInfo;

package/web/generated/internal/state.js

@@ -0,0 +1,56 @@
+export function freeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.values(value).forEach(freeze);
+        Object.freeze(value);
+    }
+    return value;
+}
+export function ranges(value) {
+    if (!Array.isArray(value))
+        return null;
+    const out = value.map(r => ({ start: Number(r.start), end: Number(r.end) }));
+    return out.every(r => Number.isFinite(r.start) && Number.isFinite(r.end) && r.start >= 0 && r.end >= r.start) ? out : null;
+}
+export function usesRemuxTracks(plan) { return plan === 'remux' || plan === 'adapted-flac' || plan === 'adapted-opus'; }
+export function trackKey(track, mode, plan) {
+    const type = track.type;
+    // ff-index belongs to each demuxer: separate subtitle files commonly all use 0.
+    // Attachments are replayed in the same order on replacement, retaining mpv IDs.
+    if (track.external)
+        return `${type}:external:${track['external-index'] ?? track.id}`;
+    const index = Number.isInteger(track['ff-index']) ? track['ff-index'] : mode === 'native' && usesRemuxTracks(plan) && type === 'audio' ? Number(track.id) - 1 : undefined;
+    return index !== undefined ? `${type}:stream:${index}` : `${type}:${mode === 'native' ? 'native' : 'mpv'}:${track.id}`;
+}
+export function tracks(raw, sourceId, mode, plan) {
+    return raw.filter(t => ['audio', 'sub', 'video'].includes(t.type)).map(t => ({ id: `${sourceId}:${trackKey(t, mode, plan)}`, type: t.type === 'sub' ? 'subtitle' : t.type,
+        label: String(t.title || t.lang || `${t.type === 'sub' ? 'Subtitle' : t.type === 'audio' ? 'Audio' : 'Video'} ${t.id}`), language: t.lang ? String(t.lang) : null,
+        codec: t.codec ? String(t.codec) : null, selected: !!t.selected, external: !!t.external }));
+}
+const positive = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null;
+export function mediaInfo(properties, mode, surface, list) {
+    const raw = properties.get('track-list')?.find(t => t.type === 'video' && t.selected);
+    let width = null, height = null, rotation = null;
+    if (surface?.tagName === 'VIDEO') {
+        width = positive(surface.videoWidth);
+        height = positive(surface.videoHeight);
+    }
+    else {
+        const p = (mode === 'hybrid' ? undefined : properties.get('video-out-params') || properties.get('video-params'));
+        width = positive(p?.dw);
+        height = positive(p?.dh);
+        if (!width || !height) {
+            width = positive(p?.w) || positive(raw?.['demux-w']);
+            height = positive(p?.h) || positive(raw?.['demux-h']);
+            if (width)
+                width *= positive(p?.par) || positive(raw?.['demux-par']) || 1;
+        }
+        const angle = p?.rotate ?? raw?.['demux-rotation'];
+        rotation = typeof angle === 'number' ? angle : null;
+        if (width && height) {
+            const a = (rotation || 0) * Math.PI / 180, c = Math.abs(Math.cos(a)), s = Math.abs(Math.sin(a));
+            [width, height] = [width * c + height * s, width * s + height * c];
+        }
+    }
+    return { displayWidth: width, displayHeight: height, aspectRatio: width && height ? width / height : null, rotation,
+        video: list.find(t => t.type === 'video' && t.selected) ?? null, audio: list.find(t => t.type === 'audio' && t.selected) ?? null, subtitle: list.find(t => t.type === 'subtitle' && t.selected) ?? null };
+}

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

@@ -0,0 +1,127 @@
+import type { AudioOutput, FontAsset, ResourceLimits, SubtitleAsset, MediaInputOptions, StreamingOptions } from '../types.js';
+export type PlayerEvent = {
+    event: string;
+    id?: number;
+    name?: string;
+    data?: unknown;
+    error?: string;
+    [key: string]: unknown;
+};
+export type RemoteSource = MediaInputOptions & {
+    streaming?: StreamingOptions;
+    url: string;
+    format?: 'file' | 'hls' | 'dash';
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    allowedOrigins?: string[];
+    immutable?: boolean;
+    refreshAuthorization?: (resource?: {
+        url: string;
+    }) => Promise<{
+        url?: string;
+        headers?: Record<string, string>;
+    }>;
+};
+export type PlayerDiagnostics = {
+    path: 'wasm';
+    presentation?: {
+        position?: number;
+        pts?: number[];
+        retained?: number;
+        pending?: number;
+        received?: number;
+        closed?: number;
+    };
+    decoder?: 'software' | 'webcodecs';
+    decoderStats?: Record<string, number | boolean>;
+    rendered: number;
+    heapBytes: number;
+    queuedFrames: number;
+    epoch: number;
+    io?: Record<string, number | string>;
+    seeking?: boolean;
+    position?: number;
+    presentedPosition?: number;
+    ioPending?: boolean;
+    interruptions?: number;
+    renderMs?: number;
+    copyMs?: number;
+};
+/** One isolated software engine per player; bounded remote ranges and local File reads; ArrayBuffer inputs remain capped. */
+export declare class WasmPlayer extends EventTarget {
+    private loading;
+    private worker;
+    private workerOwner;
+    private audioContext;
+    private audioNode?;
+    private analyser?;
+    private gainNode?;
+    private gainValue;
+    private timing?;
+    private lastTiming?;
+    private nextId;
+    private pending;
+    private destroyed;
+    private destruction?;
+    private onDestroyed?;
+    private readyTimer?;
+    private rejectReady?;
+    private eventWaiters;
+    private hasFile;
+    private opening;
+    private refreshAuthorization?;
+    private audioHeader;
+    private outputChannels;
+    private requestedOutput;
+    private deviceChannels;
+    diagnostics?: PlayerDiagnostics;
+    browserCodecsAbsent: boolean;
+    properties: Map<string, unknown>;
+    readonly ready: Promise<void>;
+    constructor(canvas: HTMLCanvasElement, { disableBrowserCodecs, measureOutput, mode, softwarePresenter, audioOutput, audioFallback, resourceLimits, fonts, assetBase }?: {
+        assetBase?: URL;
+        audioOutput?: AudioOutput;
+        audioFallback?: 'stereo' | 'reject';
+        resourceLimits?: ResourceLimits;
+        fonts?: FontAsset[];
+        disableBrowserCodecs?: boolean;
+        measureOutput?: boolean;
+        mode?: 'hybrid' | 'software';
+        softwarePresenter?: 'rgb' | 'experimental-yuv';
+    });
+    private sendTiming;
+    private fail;
+    private request;
+    open(file: File | ArrayBuffer, options?: MediaInputOptions): Promise<void>;
+    openRemote(source: RemoteSource): Promise<void>;
+    private waitForEvent;
+    private openLocal;
+    inspectMetadata(): Promise<void>;
+    command(...args: string[]): Promise<void>;
+    private setPause;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    seek(seconds: number): Promise<any>;
+    rate(rate: number): Promise<void>;
+    volume(percent: number): Promise<void>;
+    gain(value: number): Promise<void>;
+    selectTrack(type: 'audio' | 'sub', id: string): Promise<void>;
+    addSubtitle(subtitle: SubtitleAsset): Promise<void>;
+    subtitleVisible(visible: boolean): Promise<void>;
+    resize(width: number, height: number): void;
+    audioDiagnostics(): {
+        gain: number;
+        gainStage: string;
+        requestedOutput: AudioOutput;
+        outputChannels: number;
+        deviceChannels: number;
+        channelLayout: string;
+        state: AudioContextState;
+        sampleRate: number;
+        mediaFrames: number;
+        underruns: number;
+        rms: number;
+        latencyConfidence: string;
+    };
+    destroy(): Promise<void>;
+}