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

package/dist/playback.js

@@ -0,0 +1,387 @@
+import { RemediaEventEmitter } from './events.js';
+import { createReadableInput, toNativeSource, } from './input.js';
+import { lifecycleContext, PlaybackHooks, PlaybackSessionEvents as PlaybackEvent, } from './lifecycle.js';
+import { toStreamInfo, } from './types.js';
+import { FilterControls, validateVolume } from './filters.js';
+/** Controls one playback session. Local sessions decode into a no-op output. */
+export class PlaybackSession extends RemediaEventEmitter {
+    #native;
+    #playbackId;
+    #onDispose;
+    #terminalGenerations = new Set();
+    #metadata = new Map();
+    #startedGenerations = new Set();
+    hooks;
+    filters;
+    #input;
+    #disposed = false;
+    #starting = false;
+    #playController;
+    #signal;
+    #abortListener;
+    #latestGeneration = 0;
+    #guildId;
+    /** @internal */
+    constructor(native, playbackId, onDispose, guildId, hooks) {
+        super();
+        this.#native = native;
+        this.#playbackId = playbackId;
+        this.#onDispose = onDispose;
+        this.#guildId = guildId;
+        this.hooks = hooks ?? new PlaybackHooks();
+        this.filters = new FilterControls(() => this.#native.playbackFilterGraph(this.#playbackId) ?? null, (graph) => this.#replaceFilterGraph(graph), () => this.#replaceFilterGraph(null));
+    }
+    /** Stable opaque identity for this wrapper, suitable for correlating lifecycle events. */
+    get sessionId() {
+        return this.#playbackId;
+    }
+    /** @internal Latest native source generation observed by this wrapper. */
+    get currentGeneration() {
+        return this.#latestGeneration;
+    }
+    get state() {
+        return this.#native.playbackState(this.#playbackId);
+    }
+    get position() {
+        const position = this.#native.playbackPosition(this.#playbackId);
+        return {
+            mediaMs: position.mediaMs ?? null,
+            mediaPositionAccuracy: position.mediaPositionAccuracy === 'timestamp' ||
+                position.mediaPositionAccuracy === 'estimated'
+                ? position.mediaPositionAccuracy
+                : null,
+            submittedMs: position.submittedMs,
+            playedMs: position.playedMs ?? null,
+        };
+    }
+    get durationMs() {
+        return this.#native.playbackDurationMs(this.#playbackId) ?? null;
+    }
+    get error() {
+        return this.#native.playbackError(this.#playbackId) ?? null;
+    }
+    /** Current normalized linear master gain, from 0.0 (mute) through 2.0. */
+    get volume() {
+        return this.#native.playbackVolume(this.#playbackId);
+    }
+    /** Set master gain independently of the raw filtergraph. */
+    async setVolume(gain) {
+        this.#assertActive();
+        validateVolume(gain);
+        const previousVolume = this.volume;
+        if (previousVolume === gain)
+            return;
+        await this.#native.playbackSetVolume(this.#playbackId, gain);
+        this.emit(PlaybackEvent.volumeChanged, {
+            ...this.#eventContext(),
+            previousVolume,
+            volume: gain,
+        });
+    }
+    async play(source, options = {}) {
+        this.#assertActive();
+        if (this.#starting || isPlaybackActive(this.state)) {
+            throw new Error('playback is already active; stop it before starting another source');
+        }
+        if (options.signal?.aborted)
+            throw abortError(options.signal.reason);
+        this.#starting = true;
+        const controller = new AbortController();
+        let nativeAttempted = false;
+        this.#playController = controller;
+        this.#signal = options.signal;
+        const abortListener = () => {
+            controller.abort(options.signal?.reason);
+            // This native operation is asynchronous and cancellation-aware. It is never invoked from a
+            // Rust callback or while the core holds a playback-state lock.
+            if (nativeAttempted)
+                void this.#native.stop(this.#playbackId).catch(() => undefined);
+        };
+        this.#abortListener = abortListener;
+        options.signal?.addEventListener('abort', abortListener, { once: true });
+        let input;
+        const previousGeneration = numericGeneration(this.#native.playbackGeneration(this.#playbackId));
+        try {
+            await this.hooks.runBeforePlay({
+                source,
+                customMetadata: options.customMetadata,
+                signal: controller.signal,
+            });
+            this.#assertActive();
+            if (controller.signal.aborted)
+                throw abortError(controller.signal.reason);
+            await this.#releaseInput();
+            let nativeSource;
+            if ('stream' in source) {
+                input = createReadableInput(this.#native, source.stream);
+                nativeSource = input.source;
+                this.#input = input;
+            }
+            else {
+                nativeSource = toNativeSource(source);
+            }
+            if (controller.signal.aborted)
+                throw abortError(controller.signal.reason);
+            nativeAttempted = true;
+            const info = toStreamInfo(await this.#native.play(this.#playbackId, nativeSource));
+            const generation = numericGeneration(this.#native.playbackGeneration(this.#playbackId));
+            this.#latestGeneration = generation;
+            this.#metadata.set(generation, options.customMetadata);
+            this.#boundMetadata(generation);
+            this.#startedGenerations.add(generation);
+            this.emit(PlaybackEvent.playbackStarted, {
+                ...this.#eventContext(generation),
+                state: 'playing',
+                info,
+            });
+            this.#starting = false;
+            void this.#observeGeneration(generation, input);
+            return info;
+        }
+        catch (error) {
+            if (input && this.#input === input)
+                await this.#releaseInput();
+            if (nativeAttempted && !(error instanceof Error && error.name === 'AbortError')) {
+                const generation = numericGeneration(this.#native.playbackGeneration(this.#playbackId));
+                this.#latestGeneration = generation;
+                if (generation > previousGeneration && this.state === 'failed') {
+                    this.#metadata.set(generation, options.customMetadata);
+                    this.#emitTerminal('failed', generation, error);
+                }
+            }
+            if (controller.signal.aborted)
+                throw abortError(controller.signal.reason);
+            throw error;
+        }
+        finally {
+            this.#starting = false;
+            if (!nativeAttempted || this.state === 'failed' || controller.signal.aborted) {
+                this.#clearAbortBinding(controller);
+            }
+        }
+    }
+    async pause() {
+        this.#assertActive();
+        const previousState = this.state;
+        await this.#native.pause(this.#playbackId);
+        if (previousState === 'playing' && this.state === 'paused') {
+            this.emit(PlaybackEvent.playbackPaused, {
+                ...this.#eventContext(),
+                previousState,
+                state: 'paused',
+            });
+        }
+    }
+    async resume() {
+        this.#assertActive();
+        const previousState = this.state;
+        await this.#native.resume(this.#playbackId);
+        if (previousState === 'paused' && this.state === 'playing') {
+            this.emit(PlaybackEvent.playbackResumed, {
+                ...this.#eventContext(),
+                previousState,
+                state: 'playing',
+            });
+        }
+    }
+    async seek(positionMs) {
+        this.#assertActive();
+        const previousPositionMs = this.position.mediaMs;
+        await this.#native.seek(this.#playbackId, positionMs);
+        if (previousPositionMs !== positionMs) {
+            this.emit(PlaybackEvent.playbackSeeked, {
+                ...this.#eventContext(),
+                positionMs,
+                previousPositionMs,
+            });
+        }
+    }
+    async stop() {
+        this.#assertActive();
+        const previousState = this.state;
+        const generation = numericGeneration(this.#native.playbackGeneration(this.#playbackId));
+        try {
+            await this.#native.stop(this.#playbackId);
+            if (isPlaybackActive(previousState) && this.state === 'stopped') {
+                this.#emitTerminal('stopped', generation, undefined, 'stop');
+            }
+        }
+        finally {
+            await this.#releaseInput();
+        }
+    }
+    async wait() {
+        this.#assertActive();
+        // Capture synchronously so the native blocking waiter stays bound to the source
+        // that was active when wait() was called, even if play() replaces it first.
+        const generation = this.#native.playbackGeneration(this.#playbackId);
+        try {
+            return (await this.#native.wait(this.#playbackId, generation));
+        }
+        finally {
+            await this.#releaseInput();
+        }
+    }
+    /** Stop and release this standalone playback session. */
+    async dispose() {
+        if (this.#disposed)
+            return;
+        this.#playController?.abort(new Error('playback session disposed'));
+        this.#signal?.removeEventListener('abort', this.#abortListener);
+        try {
+            await this.#native.disposePlaybackSession(this.#playbackId);
+        }
+        finally {
+            await this.#releaseInput();
+            this.#disposed = true;
+            this.hooks.clear();
+            this.#metadata.clear();
+            this.emit(PlaybackEvent.sessionDisposed, {
+                sessionId: this.sessionId,
+                ...(this.#guildId === undefined ? {} : { guildId: this.#guildId }),
+                nodeId: null,
+                generation: this.#latestGeneration,
+            });
+            this.#onDispose?.();
+        }
+    }
+    /** @internal */
+    async releaseInput() {
+        await this.#releaseInput();
+    }
+    async #replaceFilterGraph(graph) {
+        this.#assertActive();
+        const previousGraph = this.filters.graph;
+        if (previousGraph === graph)
+            return;
+        if (graph === null)
+            await this.#native.playbackClearFilterGraph(this.#playbackId);
+        else
+            await this.#native.playbackSetFilterGraph(this.#playbackId, graph);
+        this.emit(PlaybackEvent.filterChanged, {
+            ...this.#eventContext(),
+            previousGraph,
+            graph,
+        });
+    }
+    #eventContext(generation) {
+        const activeGeneration = generation ?? this.#latestGeneration;
+        const context = lifecycleContext(this.sessionId, activeGeneration, this.#metadata.get(activeGeneration));
+        return this.#guildId === undefined ? context : { ...context, guildId: this.#guildId };
+    }
+    async #observeGeneration(generation, input) {
+        try {
+            const state = (await this.#native.wait(this.#playbackId, String(generation)));
+            if (state === 'completed' || state === 'failed' || state === 'stopped') {
+                const error = state === 'failed' ? new Error(this.error ?? 'playback failed') : undefined;
+                this.#emitTerminal(state, generation, error);
+            }
+        }
+        catch (error) {
+            if (!this.#disposed) {
+                // Native disposal can remove the session before this generation-bound
+                // wait settles. In that race, reading playbackState also rejects; the
+                // disposal lifecycle event is authoritative and no terminal event is
+                // needed for the removed session.
+                let state;
+                try {
+                    state = this.state;
+                }
+                catch {
+                    state = undefined;
+                }
+                if (state === 'failed')
+                    this.#emitTerminal('failed', generation, asError(error));
+            }
+        }
+        finally {
+            this.#metadata.delete(generation);
+            this.#startedGenerations.delete(generation);
+            if (this.#latestGeneration === generation) {
+                this.#clearAbortBinding(this.#playController);
+            }
+            await this.#releaseInput(input, generation);
+        }
+    }
+    #emitTerminal(state, generation, error, reason) {
+        if ((state !== 'failed' && !this.#startedGenerations.has(generation)) ||
+            this.#terminalGenerations.has(generation))
+            return;
+        this.#terminalGenerations.add(generation);
+        while (this.#terminalGenerations.size > 16) {
+            const oldest = this.#terminalGenerations.values().next().value;
+            if (oldest === undefined)
+                break;
+            this.#terminalGenerations.delete(oldest);
+        }
+        const base = this.#eventContext(generation);
+        if (state === 'completed') {
+            this.emit(PlaybackEvent.playbackCompleted, { ...base, state, position: this.position });
+        }
+        else if (state === 'stopped') {
+            this.emit(PlaybackEvent.playbackStopped, reason ? { ...base, state, reason } : { ...base, state });
+        }
+        else {
+            this.emit(PlaybackEvent.playbackFailed, { ...base, state, error: asError(error) });
+        }
+        this.#metadata.delete(generation);
+        this.#clearAbortBinding(this.#playController);
+    }
+    #boundMetadata(generation) {
+        while (this.#metadata.size > 4) {
+            const oldest = this.#metadata.keys().next().value;
+            if (oldest === undefined || oldest === generation)
+                break;
+            this.#metadata.delete(oldest);
+        }
+    }
+    #clearAbortBinding(controller) {
+        if (!controller || this.#playController !== controller)
+            return;
+        this.#signal?.removeEventListener('abort', this.#abortListener);
+        this.#playController = undefined;
+        this.#signal = undefined;
+        this.#abortListener = undefined;
+    }
+    async #releaseInput(expected, generation) {
+        if (generation !== undefined && this.#latestGeneration !== generation) {
+            await expected?.cancel();
+            return;
+        }
+        const input = this.#input;
+        if (expected !== undefined && input !== expected) {
+            await expected.cancel();
+            return;
+        }
+        this.#input = undefined;
+        if (input)
+            await input.cancel();
+    }
+    #assertActive() {
+        if (this.#disposed)
+            throw new Error('Playback session has been disposed');
+    }
+}
+function isPlaybackActive(state) {
+    return (state === 'starting' ||
+        state === 'playing' ||
+        state === 'pausing' ||
+        state === 'resuming' ||
+        state === 'paused' ||
+        state === 'stopping');
+}
+function numericGeneration(value) {
+    const generation = Number(value);
+    if (!Number.isSafeInteger(generation) || generation < 0) {
+        throw new RangeError('native playback generation exceeds the JavaScript safe integer range');
+    }
+    return generation;
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function abortError(reason) {
+    const error = new Error(reason instanceof Error ? reason.message : 'playback was cancelled');
+    error.name = 'AbortError';
+    return error;
+}

package/dist/remedia.d.ts

@@ -0,0 +1,32 @@
+import { RemediaEventEmitter } from './events.js';
+import { DiscordSession, type DiscordSessionOptions } from './discord.js';
+import { type DiscordGatewaySend } from './gateway.js';
+import type { RemediaLifecycleEvents } from './lifecycle.js';
+import { PlaybackSession } from './playback.js';
+import { type DebugListener, type DiagnosticEvent } from './types.js';
+export interface RemediaOptions {
+    /** Send raw Gateway payloads through the application's existing Discord client or shard. */
+    send: DiscordGatewaySend;
+}
+/**
+ * One embedded Remedia context. Create instances with `await Remedia.create()` so native
+ * observability and optional asynchronous OpenTelemetry exporters initialize on NAPI-RS's runtime.
+ */
+export declare class Remedia extends RemediaEventEmitter<RemediaLifecycleEvents> {
+    #private;
+    private constructor();
+    /** Create an independent native context using REMEDIA_* and OTEL_* environment settings. */
+    static create(options?: RemediaOptions): Promise<Remedia>;
+    /** Number of diagnostic events dropped by either bounded event queue. */
+    get droppedDebugEvents(): number;
+    /** Register a structured native diagnostic listener. */
+    /** Create a local decoder session that discards its PCM output. */
+    createPlaybackSession<Metadata = unknown>(): PlaybackSession<Metadata>;
+    /** Create a Gateway-managed voice session. Call `connect()` to send OP 4 and join the channel. */
+    createDiscordSession<Metadata = unknown>(options: DiscordSessionOptions): DiscordSession<Metadata>;
+    /** Forward a raw Discord Gateway packet to the matching in-process voice session. */
+    receive(packet: unknown): void;
+    /** Stop all playbacks, disconnect transports, flush telemetry, and release native resources. */
+    close(): Promise<void>;
+}
+export type { DebugListener, DiagnosticEvent };

package/dist/remedia.js

@@ -0,0 +1,132 @@
+import { RemediaEventEmitter } from './events.js';
+import { NativeRemedia } from '../native.js';
+import { DiscordSession } from './discord.js';
+import { DiscordGatewayAdapter } from './gateway.js';
+import { PlaybackSessionEvents as PlaybackEvent, RemediaEvents as RemediaEvent, VoiceSessionEvents as VoiceEvent, } from './lifecycle.js';
+import { PlaybackSession } from './playback.js';
+import { toDiagnosticEvent } from './types.js';
+/**
+ * One embedded Remedia context. Create instances with `await Remedia.create()` so native
+ * observability and optional asynchronous OpenTelemetry exporters initialize on NAPI-RS's runtime.
+ */
+export class Remedia extends RemediaEventEmitter {
+    #native;
+    #sessions = new Set();
+    #discordSessions = new Map();
+    #gateway;
+    #closed = false;
+    constructor(native, options) {
+        super();
+        this.#native = native;
+        this.#gateway = options ? new DiscordGatewayAdapter(options.send) : undefined;
+        native.setDebugCallback((event) => {
+            const diagnostic = toDiagnosticEvent(event);
+            this.emit(RemediaEvent.debug, diagnostic);
+        });
+    }
+    /** Create an independent native context using REMEDIA_* and OTEL_* environment settings. */
+    static async create(options) {
+        return new Remedia(await NativeRemedia.create(), options);
+    }
+    /** Number of diagnostic events dropped by either bounded event queue. */
+    get droppedDebugEvents() {
+        return this.#native.droppedDebugEvents;
+    }
+    /** Register a structured native diagnostic listener. */
+    /** Create a local decoder session that discards its PCM output. */
+    createPlaybackSession() {
+        this.#assertOpen();
+        let playback;
+        playback = new PlaybackSession(this.#native, this.#native.createPlaybackSession(), () => {
+            this.#sessions.delete(playback);
+        });
+        forwardLifecycleEvents(playback, this);
+        this.#sessions.add(playback);
+        return playback;
+    }
+    /** Create a Gateway-managed voice session. Call `connect()` to send OP 4 and join the channel. */
+    createDiscordSession(options) {
+        this.#assertOpen();
+        if (!this.#gateway) {
+            throw new Error('Remedia.create() requires a Gateway send function for Discord sessions');
+        }
+        if (this.#discordSessions.has(options.guildId)) {
+            throw new Error(`a Discord voice session already exists for guild ${options.guildId}`);
+        }
+        let session;
+        session = new DiscordSession(this.#native, this.#gateway, options, () => {
+            this.#discordSessions.delete(session.guildId);
+        });
+        forwardLifecycleEvents(session, this);
+        this.#discordSessions.set(session.guildId, session);
+        return session;
+    }
+    /** Forward a raw Discord Gateway packet to the matching in-process voice session. */
+    receive(packet) {
+        if (this.#closed || !this.#gateway)
+            return;
+        const dispatch = this.#gateway.receive(packet);
+        if (!dispatch)
+            return;
+        this.#discordSessions
+            .get(dispatch.guildId)
+            ?.receiveGatewayDispatch(dispatch.event, dispatch.data, dispatch.sequence, dispatch.epoch);
+    }
+    /** Stop all playbacks, disconnect transports, flush telemetry, and release native resources. */
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        const voiceCleanup = await Promise.allSettled([...this.#discordSessions.values()].map((session) => session.dispose()));
+        try {
+            await Promise.all([...this.#sessions].map((session) => session.dispose()));
+            await this.#native.close();
+        }
+        finally {
+            await Promise.all([...this.#sessions].map((session) => session.releaseInput()));
+            this.#sessions.clear();
+            this.#discordSessions.clear();
+        }
+        const failures = voiceCleanup.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
+        if (failures.length > 0) {
+            throw new AggregateError(failures, 'one or more Discord voice sessions failed to close');
+        }
+    }
+    #assertOpen() {
+        if (this.#closed)
+            throw new Error('Remedia instance is closed');
+    }
+}
+function forwardLifecycleEvents(source, target) {
+    const sourceEvents = source;
+    const targetEvents = target;
+    const names = [
+        PlaybackEvent.playbackStarted,
+        PlaybackEvent.playbackCompleted,
+        PlaybackEvent.playbackStopped,
+        PlaybackEvent.playbackFailed,
+        PlaybackEvent.playbackPaused,
+        PlaybackEvent.playbackResumed,
+        PlaybackEvent.playbackSeeked,
+        PlaybackEvent.filterChanged,
+        PlaybackEvent.volumeChanged,
+        PlaybackEvent.sessionDisposed,
+        ...(source instanceof DiscordSession
+            ? [VoiceEvent.voiceStateChanged, VoiceEvent.voiceFailed]
+            : []),
+    ];
+    const unsubs = [];
+    for (const name of names) {
+        const listener = (event) => {
+            targetEvents.emit(name, event);
+        };
+        sourceEvents.on(name, listener);
+        unsubs.push(() => sourceEvents.off(name, listener));
+    }
+    const detach = () => {
+        sourceEvents.off(PlaybackEvent.sessionDisposed, detach);
+        for (const unsubscribe of unsubs.splice(0))
+            unsubscribe();
+    };
+    sourceEvents.once(PlaybackEvent.sessionDisposed, detach);
+}

package/dist/types.d.ts

@@ -0,0 +1,48 @@
+import type { NativeDiagnosticEvent, NativeStreamInfo } from '../native.js';
+export type PlaybackState = 'idle' | 'starting' | 'playing' | 'pausing' | 'resuming' | 'paused' | 'stopping' | 'stopped' | 'completed' | 'failed';
+export type VoiceConnectionState = 'connecting' | 'negotiatingDave' | 'connected' | 'reconnecting' | 'disconnecting' | 'disconnected' | 'failed';
+export interface AudioStreamInfo {
+    streamIndex: number;
+    codec: string;
+    sampleRate: number | null;
+    channels: number | null;
+    channelLayout: string | null;
+    durationMs: number | null;
+    bitRate: number | null;
+    metadata: Readonly<Record<string, string>>;
+}
+export interface PlaybackPosition {
+    /** Original media timeline associated with the latest submitted PCM block. */
+    mediaMs: number | null;
+    /** `timestamp` when derived from source PTS, `estimated` when inferred, or null. */
+    mediaPositionAccuracy: 'timestamp' | 'estimated' | null;
+    submittedMs: number;
+    playedMs: number | null;
+}
+export type DiagnosticSeverity = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+export type DiagnosticFieldValue = {
+    kind: 'string' | 'debug';
+    value: string;
+} | {
+    kind: 'integer';
+    value: string;
+} | {
+    kind: 'boolean';
+    value: boolean;
+} | {
+    kind: 'number';
+    value: number;
+};
+export interface DiagnosticEvent {
+    timestamp: number;
+    severity: DiagnosticSeverity;
+    target: string;
+    event: string;
+    message: string | null;
+    playbackId: string | null;
+    voiceConnectionId: string | null;
+    fields: Readonly<Record<string, DiagnosticFieldValue>>;
+}
+export type DebugListener = (event: DiagnosticEvent) => void;
+export declare function toStreamInfo(info: NativeStreamInfo): AudioStreamInfo;
+export declare function toDiagnosticEvent(event: NativeDiagnosticEvent): DiagnosticEvent;

package/dist/types.js

@@ -0,0 +1,65 @@
+export function toStreamInfo(info) {
+    return {
+        streamIndex: info.streamIndex,
+        codec: info.codec,
+        sampleRate: info.sampleRate ?? null,
+        channels: info.channels ?? null,
+        channelLayout: info.channelLayout ?? null,
+        durationMs: info.durationMs ?? null,
+        bitRate: info.bitRate ?? null,
+        metadata: info.metadata,
+    };
+}
+export function toDiagnosticEvent(event) {
+    const severity = event.severity;
+    if (!isDiagnosticSeverity(severity)) {
+        throw new Error(`Unknown native diagnostic severity: ${severity}`);
+    }
+    const fields = {};
+    for (const [key, field] of Object.entries(event.fields)) {
+        if (field.kind === 'string' || field.kind === 'debug') {
+            if (field.stringValue === undefined) {
+                throw new Error(`Invalid native diagnostic field: ${key}`);
+            }
+            fields[key] = { kind: field.kind, value: field.stringValue };
+        }
+        else if (field.kind === 'integer') {
+            if (field.stringValue === undefined) {
+                throw new Error(`Invalid native diagnostic field: ${key}`);
+            }
+            fields[key] = { kind: 'integer', value: field.stringValue };
+        }
+        else if (field.kind === 'boolean') {
+            if (field.boolValue === undefined) {
+                throw new Error(`Invalid native diagnostic field: ${key}`);
+            }
+            fields[key] = { kind: 'boolean', value: field.boolValue };
+        }
+        else if (field.kind === 'number') {
+            if (field.numberValue === undefined) {
+                throw new Error(`Invalid native diagnostic field: ${key}`);
+            }
+            fields[key] = { kind: 'number', value: field.numberValue };
+        }
+        else {
+            throw new Error(`Unknown native diagnostic field kind: ${field.kind}`);
+        }
+    }
+    return {
+        timestamp: event.timestamp,
+        severity,
+        target: event.target,
+        event: event.event,
+        message: event.message ?? null,
+        playbackId: event.playbackId ?? null,
+        voiceConnectionId: event.voiceConnectionId ?? null,
+        fields,
+    };
+}
+function isDiagnosticSeverity(value) {
+    return (value === 'trace' ||
+        value === 'debug' ||
+        value === 'info' ||
+        value === 'warn' ||
+        value === 'error');
+}