@remedia/node 0.0.0-stage → 0.1.0-dev.0

package/dist/events.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from 'node:events';
+type EventMap<Events> = {
+    [Key in keyof Events]: unknown[];
+};
+type EventKey<Key, Events> = Events extends [never] ? string | symbol : Key | keyof Events;
+type EventArgs<Key, Events> = Events extends [never] ? any[] : Key extends keyof Events ? Events[Key] : never;
+/** EventEmitter-compatible base that isolates synchronous listener failures from engine work. */
+export declare class RemediaEventEmitter<Events extends EventMap<Events>> extends EventEmitter<Events> {
+    emit<Key>(event: EventKey<Key, Events>, ...args: EventArgs<Key, Events>): boolean;
+}
+export {};

package/dist/events.js

@@ -0,0 +1,18 @@
+import { EventEmitter } from 'node:events';
+/** EventEmitter-compatible base that isolates synchronous listener failures from engine work. */
+export class RemediaEventEmitter extends EventEmitter {
+    emit(event, ...args) {
+        try {
+            return super.emit(event, ...args);
+        }
+        catch {
+            try {
+                process.emitWarning(`A listener for Remedia event ${String(event)} threw; the exception was isolated.`, { code: 'REMEDIA_LISTENER_ERROR' });
+            }
+            catch {
+                // A custom process warning handler must not re-enter native or lifecycle operations.
+            }
+            return false;
+        }
+    }
+}

package/dist/filters.d.ts

@@ -0,0 +1,11 @@
+/** Controls one playback session's trusted raw FFmpeg audio filtergraph. */
+export declare class FilterControls {
+    #private;
+    /** Current configured raw filtergraph, or null when filtering is disabled. */
+    get graph(): string | null;
+    /** Validate and replace the graph at a safe PCM boundary. */
+    set(graph: string): Promise<void>;
+    /** Disable the raw filtergraph without changing master volume. */
+    clear(): Promise<void>;
+}
+export declare function validateVolume(gain: number): void;

package/dist/filters.js

@@ -0,0 +1,36 @@
+/** Controls one playback session's trusted raw FFmpeg audio filtergraph. */
+export class FilterControls {
+    #read;
+    #replace;
+    #clear;
+    /** @internal Constructed by playback session wrappers. */
+    constructor(read, replace, clear) {
+        this.#read = read;
+        this.#replace = replace;
+        this.#clear = clear;
+    }
+    /** Current configured raw filtergraph, or null when filtering is disabled. */
+    get graph() {
+        return this.#read();
+    }
+    /** Validate and replace the graph at a safe PCM boundary. */
+    set(graph) {
+        if (typeof graph !== 'string')
+            throw new TypeError('filtergraph must be a string');
+        if (graph.trim().length === 0) {
+            throw new RangeError('filtergraph must not be empty or whitespace-only');
+        }
+        if (this.graph === graph)
+            return Promise.resolve();
+        return this.#replace(graph);
+    }
+    /** Disable the raw filtergraph without changing master volume. */
+    clear() {
+        return this.#clear();
+    }
+}
+export function validateVolume(gain) {
+    if (!Number.isFinite(gain) || gain < 0 || gain > 2) {
+        throw new RangeError('volume must be a finite linear gain between 0.0 and 2.0');
+    }
+}

package/dist/gateway.d.ts

@@ -0,0 +1,45 @@
+/** Minimal Discord Gateway integration used by the Node.js voice adapter. */
+export interface DiscordGatewayVoicePayload {
+    op: 4;
+    d: {
+        guild_id: string;
+        channel_id: string | null;
+        self_mute: false;
+        self_deaf: false;
+    };
+}
+/** Send a Gateway payload through the application's existing Discord client or shard. */
+export type DiscordGatewaySend = (guildId: string, payload: DiscordGatewayVoicePayload) => void | Promise<void>;
+/** A raw Discord Gateway packet, such as the value emitted by a client's `raw` event. */
+export interface DiscordGatewayPacket {
+    t?: string;
+    d?: unknown;
+    op?: number;
+    [key: string]: unknown;
+}
+export type DiscordVoiceGatewayEvent = 'VOICE_STATE_UPDATE' | 'VOICE_SERVER_UPDATE';
+export interface DiscordVoiceGatewayDispatch {
+    event: DiscordVoiceGatewayEvent;
+    data: Record<string, unknown>;
+    guildId: string;
+    sequence?: number;
+    epoch: number;
+}
+/**
+ * Adapts the caller-owned Discord Gateway to Remedia's voice lifecycle. The adapter only sends
+ * Gateway OP 4 and parses the two voice dispatches; voice WebSocket, UDP, RTP, and DAVE remain in
+ * the native transport.
+ */
+export declare class DiscordGatewayAdapter {
+    #private;
+    constructor(send: DiscordGatewaySend);
+    /** Most recently observed Gateway dispatch sequence, when supplied by the host client. */
+    get lastSequence(): number | undefined;
+    /** Changes when the host Gateway starts a new READY session and resets its sequence. */
+    get epoch(): number;
+    /** Request a voice channel join or leave through Gateway OP 4. */
+    setVoiceChannel(guildId: string, channelId: string | null): void | Promise<void>;
+    /** Parse only relevant voice dispatches; malformed and unrelated packets are ignored. */
+    receive(packet: unknown): DiscordVoiceGatewayDispatch | undefined;
+}
+export declare function isSnowflake(value: string): boolean;

package/dist/gateway.js

@@ -0,0 +1,81 @@
+/**
+ * Adapts the caller-owned Discord Gateway to Remedia's voice lifecycle. The adapter only sends
+ * Gateway OP 4 and parses the two voice dispatches; voice WebSocket, UDP, RTP, and DAVE remain in
+ * the native transport.
+ */
+export class DiscordGatewayAdapter {
+    #send;
+    #lastSequence;
+    #epoch = 0;
+    constructor(send) {
+        this.#send = send;
+    }
+    /** Most recently observed Gateway dispatch sequence, when supplied by the host client. */
+    get lastSequence() {
+        return this.#lastSequence;
+    }
+    /** Changes when the host Gateway starts a new READY session and resets its sequence. */
+    get epoch() {
+        return this.#epoch;
+    }
+    /** Request a voice channel join or leave through Gateway OP 4. */
+    setVoiceChannel(guildId, channelId) {
+        return this.#send(guildId, {
+            op: 4,
+            d: {
+                guild_id: guildId,
+                channel_id: channelId,
+                self_mute: false,
+                self_deaf: false,
+            },
+        });
+    }
+    /** Parse only relevant voice dispatches; malformed and unrelated packets are ignored. */
+    receive(packet) {
+        if (!isRecord(packet) || typeof packet.t !== 'string')
+            return undefined;
+        const sequence = typeof packet.s === 'number' && Number.isSafeInteger(packet.s) && packet.s >= 0
+            ? packet.s
+            : undefined;
+        if (packet.t === 'READY') {
+            this.#epoch += 1;
+            this.#lastSequence = sequence;
+            return undefined;
+        }
+        if (sequence !== undefined) {
+            if (this.#lastSequence !== undefined && sequence <= this.#lastSequence)
+                return undefined;
+            this.#lastSequence = sequence;
+        }
+        if (!isRecord(packet.d))
+            return undefined;
+        if (packet.t !== 'VOICE_STATE_UPDATE' && packet.t !== 'VOICE_SERVER_UPDATE')
+            return undefined;
+        const guildId = packet.d.guild_id;
+        if (typeof guildId !== 'string' || !isSnowflake(guildId))
+            return undefined;
+        const dispatch = {
+            event: packet.t,
+            data: packet.d,
+            guildId,
+            epoch: this.#epoch,
+        };
+        if (sequence !== undefined)
+            dispatch.sequence = sequence;
+        return dispatch;
+    }
+}
+export function isSnowflake(value) {
+    if (!/^\d{1,20}$/.test(value))
+        return false;
+    try {
+        const id = BigInt(value);
+        return id > 0n && id <= 18446744073709551615n;
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { DiscordSession } from './discord.js';
+export type { DiscordConnectOptions, DiscordSessionOptions } from './discord.js';
+export type { DiscordGatewayPacket, DiscordGatewaySend, DiscordGatewayVoicePayload, } from './gateway.js';
+export { PlaybackSession } from './playback.js';
+export { PlaybackHooks, PlaybackSessionEvents, RemediaEvents, VoiceSessionEvents, } from './lifecycle.js';
+export { Remedia, type RemediaOptions } from './remedia.js';
+export type { MediaSource } from './input.js';
+export type { AudioStreamInfo, DebugListener, DiagnosticEvent, DiagnosticFieldValue, DiagnosticSeverity, PlaybackPosition, PlaybackState, VoiceConnectionState, } from './types.js';
+export type { BeforePlayContext, BeforePlayHook, BeforePlayResult, LifecycleVoiceState, PlayOptions, PlaybackEventIdentity, PlaybackLifecycleEvents, PlaybackSessionEventMap, RemediaLifecycleEvents, SessionLifecycleEvents, VoiceEventIdentity, VoiceLifecycleEvents, } from './lifecycle.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { DiscordSession } from './discord.js';
+export { PlaybackSession } from './playback.js';
+export { PlaybackHooks, PlaybackSessionEvents, RemediaEvents, VoiceSessionEvents, } from './lifecycle.js';
+export { Remedia } from './remedia.js';

package/dist/input.d.ts

@@ -0,0 +1,20 @@
+import { Buffer } from 'node:buffer';
+import type { Readable } from 'node:stream';
+import type { NativeMediaSource, NativeRemedia } from '../native.js';
+export type MediaSource = {
+    file: string;
+} | {
+    url: string;
+} | {
+    buffer: Buffer | Uint8Array;
+} | {
+    stream: Readable;
+};
+export interface ReadableInputHandle {
+    readonly source: NativeMediaSource;
+    cancel(): Promise<void>;
+}
+export declare function toNativeSource(source: Exclude<MediaSource, {
+    stream: Readable;
+}>): NativeMediaSource;
+export declare function createReadableInput(native: NativeRemedia, stream: Readable): ReadableInputHandle;

package/dist/input.js

@@ -0,0 +1,124 @@
+import { Buffer } from 'node:buffer';
+export function toNativeSource(source) {
+    if ('file' in source)
+        return { kind: 'file', value: source.file };
+    if ('url' in source)
+        return { kind: 'url', value: source.url };
+    return { kind: 'buffer', bytes: Buffer.from(source.buffer) };
+}
+export function createReadableInput(native, stream) {
+    const streamId = native.createByteStream();
+    const cancellation = new AbortController();
+    const pump = pumpReadable(native, streamId, stream, cancellation.signal);
+    let cleanup;
+    return {
+        source: { kind: 'stream', value: streamId },
+        cancel() {
+            cleanup ??= (async () => {
+                cancellation.abort();
+                native.cancelByteStream(streamId);
+                await pump;
+            })();
+            return cleanup;
+        },
+    };
+}
+async function pumpReadable(native, streamId, stream, signal) {
+    let sourceError;
+    let failureSent = false;
+    const failSource = (error) => {
+        sourceError ??= error;
+        if (failureSent || signal.aborted)
+            return;
+        failureSent = true;
+        void native.failByteStream(streamId, sourceError.message).catch(() => { });
+    };
+    const onError = (error) => failSource(error);
+    stream.pause();
+    stream.on('error', onError);
+    try {
+        while (!signal.aborted) {
+            if (sourceError)
+                throw sourceError;
+            if (stream.errored)
+                throw stream.errored;
+            const chunk = stream.read();
+            if (chunk === null) {
+                const wake = await waitForReadable(stream, signal, () => sourceError);
+                if (wake === 'abort')
+                    return;
+                if (wake === 'end')
+                    break;
+                if (wake === 'close')
+                    throw sourceError ?? new Error('Readable closed before ending');
+                continue;
+            }
+            if (!(chunk instanceof Uint8Array)) {
+                throw new TypeError('Readable media sources must produce Buffer or Uint8Array chunks');
+            }
+            // This copy gives native code an independent snapshot of the chunk. The
+            // byte queue then takes ownership and waits for decoder backpressure.
+            await native.writeByteStream(streamId, Buffer.from(chunk));
+        }
+        if (!signal.aborted && !sourceError)
+            await native.finishByteStream(streamId);
+    }
+    catch (error) {
+        if (!signal.aborted) {
+            failSource(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    finally {
+        stream.pause();
+        stream.off('error', onError);
+    }
+}
+function waitForReadable(stream, signal, getError) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            stream.off('readable', onReadable);
+            stream.off('end', onEnd);
+            stream.off('close', onClose);
+            stream.off('error', onError);
+            signal.removeEventListener('abort', onAbort);
+        };
+        const finish = (wake) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(wake);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        };
+        const onReadable = () => finish('readable');
+        const onEnd = () => finish('end');
+        const onClose = () => finish('close');
+        const onError = (error) => fail(error);
+        const onAbort = () => finish('abort');
+        stream.once('readable', onReadable);
+        stream.once('end', onEnd);
+        stream.once('close', onClose);
+        stream.once('error', onError);
+        signal.addEventListener('abort', onAbort, { once: true });
+        // An event can arrive between read() returning null and listener setup.
+        if (signal.aborted)
+            onAbort();
+        else if (getError())
+            onError(getError());
+        else if (stream.errored)
+            onError(stream.errored);
+        else if (stream.readableEnded)
+            onEnd();
+        else if (stream.destroyed)
+            onClose();
+        else if (stream.readableLength > 0)
+            onReadable();
+    });
+}

package/dist/lifecycle.d.ts

@@ -0,0 +1,166 @@
+import type { MediaSource } from './input.js';
+import type { AudioStreamInfo, PlaybackPosition, PlaybackState } from './types.js';
+/** Stable names for playback/session event subscriptions and emission. */
+export declare const PlaybackSessionEvents: {
+    readonly playbackStarted: "playbackStarted";
+    readonly playbackCompleted: "playbackCompleted";
+    readonly playbackStopped: "playbackStopped";
+    readonly playbackFailed: "playbackFailed";
+    readonly playbackPaused: "playbackPaused";
+    readonly playbackResumed: "playbackResumed";
+    readonly playbackSeeked: "playbackSeeked";
+    readonly filterChanged: "filterChanged";
+    readonly volumeChanged: "volumeChanged";
+    readonly sessionDisposed: "sessionDisposed";
+};
+export type PlaybackSessionEvents = (typeof PlaybackSessionEvents)[keyof typeof PlaybackSessionEvents];
+export declare const VoiceSessionEvents: {
+    readonly voiceStateChanged: "voiceStateChanged";
+    readonly voiceFailed: "voiceFailed";
+};
+export type VoiceSessionEvents = (typeof VoiceSessionEvents)[keyof typeof VoiceSessionEvents];
+export declare const RemediaEvents: {
+    readonly debug: "debug";
+    readonly voiceStateChanged: "voiceStateChanged";
+    readonly voiceFailed: "voiceFailed";
+    readonly playbackStarted: "playbackStarted";
+    readonly playbackCompleted: "playbackCompleted";
+    readonly playbackStopped: "playbackStopped";
+    readonly playbackFailed: "playbackFailed";
+    readonly playbackPaused: "playbackPaused";
+    readonly playbackResumed: "playbackResumed";
+    readonly playbackSeeked: "playbackSeeked";
+    readonly filterChanged: "filterChanged";
+    readonly volumeChanged: "volumeChanged";
+    readonly sessionDisposed: "sessionDisposed";
+};
+export type RemediaEvents = (typeof RemediaEvents)[keyof typeof RemediaEvents];
+export interface PlaybackEventIdentity<Metadata = unknown> {
+    sessionId: string;
+    guildId?: string;
+    nodeId: string | null;
+    generation: number;
+    customMetadata?: Metadata;
+    /** True only when a terminal event was reconstructed from an authoritative remote snapshot. */
+    reconstructed?: boolean;
+}
+export type PlaybackLifecycleEvents<Metadata = unknown> = {
+    [PlaybackSessionEvents.playbackStarted]: [
+        PlaybackEventIdentity<Metadata> & {
+            state: 'playing';
+            info: AudioStreamInfo;
+        }
+    ];
+    [PlaybackSessionEvents.playbackCompleted]: [
+        PlaybackEventIdentity<Metadata> & {
+            state: 'completed';
+            position: PlaybackPosition;
+        }
+    ];
+    [PlaybackSessionEvents.playbackStopped]: [
+        PlaybackEventIdentity<Metadata> & {
+            state: 'stopped';
+            reason?: string;
+        }
+    ];
+    [PlaybackSessionEvents.playbackFailed]: [
+        PlaybackEventIdentity<Metadata> & {
+            state: 'failed';
+            error: Error;
+        }
+    ];
+    [PlaybackSessionEvents.playbackPaused]: [
+        PlaybackEventIdentity<Metadata> & {
+            previousState: PlaybackState;
+            state: 'paused';
+        }
+    ];
+    [PlaybackSessionEvents.playbackResumed]: [
+        PlaybackEventIdentity<Metadata> & {
+            previousState: PlaybackState;
+            state: 'playing';
+        }
+    ];
+    [PlaybackSessionEvents.playbackSeeked]: [
+        PlaybackEventIdentity<Metadata> & {
+            positionMs: number;
+            previousPositionMs: number | null;
+        }
+    ];
+    [PlaybackSessionEvents.filterChanged]: [
+        PlaybackEventIdentity<Metadata> & {
+            previousGraph: string | null;
+            graph: string | null;
+        }
+    ];
+    [PlaybackSessionEvents.volumeChanged]: [
+        PlaybackEventIdentity<Metadata> & {
+            previousVolume: number;
+            volume: number;
+        }
+    ];
+};
+export interface VoiceEventIdentity {
+    sessionId: string;
+    guildId: string;
+    nodeId: string | null;
+}
+export type LifecycleVoiceState = 'connecting' | 'negotiating_dave' | 'connected' | 'reconnecting' | 'disconnecting' | 'disconnected' | 'failed';
+export type VoiceLifecycleEvents = {
+    [VoiceSessionEvents.voiceStateChanged]: [
+        VoiceEventIdentity & {
+            previousState: LifecycleVoiceState;
+            state: LifecycleVoiceState;
+        }
+    ];
+    [VoiceSessionEvents.voiceFailed]: [VoiceEventIdentity & {
+        state: 'failed';
+        error: Error;
+    }];
+};
+export type SessionLifecycleEvents<Metadata = unknown> = PlaybackLifecycleEvents<Metadata> & VoiceLifecycleEvents & {
+    [PlaybackSessionEvents.sessionDisposed]: [
+        {
+            sessionId: string;
+            guildId?: string;
+            nodeId: string | null;
+            generation: number;
+        }
+    ];
+};
+export type PlaybackSessionEventMap<Metadata = unknown> = PlaybackLifecycleEvents<Metadata> & {
+    [PlaybackSessionEvents.sessionDisposed]: [
+        {
+            sessionId: string;
+            guildId?: string;
+            nodeId: string | null;
+            generation: number;
+        }
+    ];
+};
+export interface RemediaLifecycleEvents extends SessionLifecycleEvents<unknown> {
+    [RemediaEvents.debug]: [import('./types.js').DiagnosticEvent];
+}
+export interface PlayOptions<Metadata = unknown> {
+    customMetadata?: Metadata;
+    /** Aborting before startup cancels hooks; aborting after startup stops this playback. */
+    signal?: AbortSignal;
+}
+export interface BeforePlayContext<Metadata = unknown> {
+    readonly source: MediaSource;
+    readonly customMetadata: Metadata | undefined;
+    /** Aborted when the operation signal fires or the session is disposed. */
+    readonly signal: AbortSignal;
+}
+export type BeforePlayResult = void | {
+    cancel: true;
+    reason?: string;
+};
+export type BeforePlayHook<Metadata = unknown> = (context: BeforePlayContext<Metadata>) => BeforePlayResult | Promise<BeforePlayResult>;
+/** Ordered, awaited local middleware. It is not a server authorization mechanism. */
+export declare class PlaybackHooks<Metadata = unknown> {
+    #private;
+    beforePlay(hook: BeforePlayHook<Metadata>): () => void;
+    runBeforePlay(context: BeforePlayContext<Metadata>): Promise<void>;
+}
+export declare function lifecycleContext<Metadata>(sessionId: string, generation: number, customMetadata: Metadata | undefined): PlaybackEventIdentity<Metadata>;

package/dist/lifecycle.js

@@ -0,0 +1,73 @@
+/** Stable names for playback/session event subscriptions and emission. */
+export const PlaybackSessionEvents = {
+    playbackStarted: 'playbackStarted',
+    playbackCompleted: 'playbackCompleted',
+    playbackStopped: 'playbackStopped',
+    playbackFailed: 'playbackFailed',
+    playbackPaused: 'playbackPaused',
+    playbackResumed: 'playbackResumed',
+    playbackSeeked: 'playbackSeeked',
+    filterChanged: 'filterChanged',
+    volumeChanged: 'volumeChanged',
+    sessionDisposed: 'sessionDisposed',
+};
+export const VoiceSessionEvents = {
+    voiceStateChanged: 'voiceStateChanged',
+    voiceFailed: 'voiceFailed',
+};
+export const RemediaEvents = {
+    ...PlaybackSessionEvents,
+    ...VoiceSessionEvents,
+    debug: 'debug',
+};
+/** Ordered, awaited local middleware. It is not a server authorization mechanism. */
+export class PlaybackHooks {
+    #beforePlay = [];
+    beforePlay(hook) {
+        if (typeof hook !== 'function')
+            throw new TypeError('beforePlay hook must be a function');
+        this.#beforePlay.push(hook);
+        return () => {
+            const index = this.#beforePlay.indexOf(hook);
+            if (index >= 0)
+                this.#beforePlay.splice(index, 1);
+        };
+    }
+    async runBeforePlay(context) {
+        for (const hook of [...this.#beforePlay]) {
+            if (context.signal.aborted)
+                throw abortError(context.signal.reason);
+            const result = await raceAbort(Promise.resolve().then(() => hook(context)), context.signal);
+            if (context.signal.aborted)
+                throw abortError(context.signal.reason);
+            if (result?.cancel) {
+                const error = new Error(result.reason ?? 'playback was cancelled by a beforePlay hook');
+                error.name = 'AbortError';
+                throw error;
+            }
+        }
+    }
+    /** @internal Release application hook references when the owning session is disposed. */
+    clear() {
+        this.#beforePlay.length = 0;
+    }
+}
+export function lifecycleContext(sessionId, generation, customMetadata) {
+    return customMetadata === undefined
+        ? { sessionId, nodeId: null, generation }
+        : { sessionId, nodeId: null, generation, customMetadata };
+}
+function abortError(reason) {
+    const error = new Error(reason instanceof Error ? reason.message : 'playback was cancelled');
+    error.name = 'AbortError';
+    return error;
+}
+function raceAbort(operation, signal) {
+    if (signal.aborted)
+        return Promise.reject(abortError(signal.reason));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError(signal.reason));
+        signal.addEventListener('abort', onAbort, { once: true });
+        operation.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}

package/dist/playback.d.ts

@@ -0,0 +1,29 @@
+import { RemediaEventEmitter } from './events.js';
+import { type MediaSource } from './input.js';
+import { PlaybackHooks, type PlayOptions, type PlaybackSessionEventMap } from './lifecycle.js';
+import { type AudioStreamInfo, type PlaybackPosition, type PlaybackState } from './types.js';
+import { FilterControls } from './filters.js';
+/** Controls one playback session. Local sessions decode into a no-op output. */
+export declare class PlaybackSession<Metadata = unknown> extends RemediaEventEmitter<PlaybackSessionEventMap<Metadata>> {
+    #private;
+    readonly hooks: PlaybackHooks<Metadata>;
+    readonly filters: FilterControls;
+    /** Stable opaque identity for this wrapper, suitable for correlating lifecycle events. */
+    get sessionId(): string;
+    get state(): PlaybackState;
+    get position(): PlaybackPosition;
+    get durationMs(): number | null;
+    get error(): string | null;
+    /** Current normalized linear master gain, from 0.0 (mute) through 2.0. */
+    get volume(): number;
+    /** Set master gain independently of the raw filtergraph. */
+    setVolume(gain: number): Promise<void>;
+    play(source: MediaSource, options?: PlayOptions<Metadata>): Promise<AudioStreamInfo>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    seek(positionMs: number): Promise<void>;
+    stop(): Promise<void>;
+    wait(): Promise<PlaybackState>;
+    /** Stop and release this standalone playback session. */
+    dispose(): Promise<void>;
+}