@gjsify/webrtc 0.1.15

package/src/rtc-certificate.ts

@@ -0,0 +1,110 @@
+// W3C RTCCertificate for GJS.
+//
+// Lightweight certificate representation for RTCPeerConnection.
+// generateCertificate() validates algorithm parameters and returns a
+// certificate with a future expiry. The actual DTLS certificate used by
+// webrtcbin is generated internally by GStreamer — this class provides
+// the W3C API surface for certificate management.
+//
+// Reference: W3C WebRTC spec § 4.10
+// Reference: refs/wpt/webrtc/RTCPeerConnection-generateCertificate.html
+// Reference: refs/wpt/webrtc/RTCCertificate.html
+
+import GLib from 'gi://GLib?version=2.0';
+
+export interface RTCDtlsFingerprint {
+    algorithm?: string;
+    value?: string;
+}
+
+// Default certificate lifetime: 30 days
+const DEFAULT_EXPIRY_MS = 30 * 24 * 60 * 60 * 1000;
+
+export class RTCCertificate {
+    readonly expires: number; // DOMTimeStamp (ms since epoch)
+    private _fingerprints: RTCDtlsFingerprint[];
+    private _algorithm: string;
+
+    /** @internal — use RTCPeerConnection.generateCertificate() */
+    constructor(algorithm: string, expires: number, fingerprints: RTCDtlsFingerprint[]) {
+        this._algorithm = algorithm;
+        this.expires = expires;
+        this._fingerprints = fingerprints;
+    }
+
+    getFingerprints(): RTCDtlsFingerprint[] {
+        return [...this._fingerprints];
+    }
+
+    /** @internal — the algorithm name for debugging/inspection */
+    get _algorithmName(): string {
+        return this._algorithm;
+    }
+}
+
+export type AlgorithmIdentifier = string | Record<string, unknown>;
+
+/**
+ * Generate a self-signed certificate for use with RTCPeerConnection.
+ * Supports ECDSA P-256 and RSASSA-PKCS1-v1_5 with SHA-256.
+ *
+ * The actual DTLS certificate used by webrtcbin is generated internally
+ * by GStreamer — this provides the spec-compliant JS API surface.
+ */
+export async function generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate> {
+    let name: string;
+
+    if (typeof keygenAlgorithm === 'string') {
+        name = keygenAlgorithm.toLowerCase();
+    } else if (keygenAlgorithm && typeof keygenAlgorithm === 'object' && typeof keygenAlgorithm.name === 'string') {
+        name = (keygenAlgorithm.name as string).toLowerCase();
+    } else {
+        throw new DOMException(
+            'generateCertificate: algorithm must have a name property',
+            'NotSupportedError',
+        );
+    }
+
+    // Validate supported algorithms
+    if (name === 'ecdsa') {
+        const curve = (keygenAlgorithm as any).namedCurve;
+        if (curve && curve !== 'P-256') {
+            throw new DOMException(
+                `generateCertificate: unsupported ECDSA curve '${curve}'`,
+                'NotSupportedError',
+            );
+        }
+    } else if (name === 'rsassa-pkcs1-v1_5') {
+        const hash = (keygenAlgorithm as any).hash;
+        const hashName = typeof hash === 'string' ? hash : hash?.name;
+        if (hashName && hashName.toUpperCase() === 'SHA-1') {
+            throw new DOMException(
+                'generateCertificate: SHA-1 is not supported for RSA certificates',
+                'NotSupportedError',
+            );
+        }
+    } else {
+        throw new DOMException(
+            `generateCertificate: unsupported algorithm '${name}'`,
+            'NotSupportedError',
+        );
+    }
+
+    // Generate a pseudo-random fingerprint using GLib
+    const uuid = GLib.uuid_string_random();
+    const checksum = GLib.Checksum.new(GLib.ChecksumType.SHA256);
+    checksum!.update(new TextEncoder().encode(uuid + Date.now()));
+    const fingerprintHex = checksum!.get_string()!;
+
+    // Format as colon-separated hex pairs (sha-256 fingerprint format)
+    const formatted = fingerprintHex.slice(0, 64)
+        .match(/.{2}/g)!
+        .join(':')
+        .toUpperCase();
+
+    const expires = Date.now() + DEFAULT_EXPIRY_MS;
+
+    return new RTCCertificate(name, expires, [
+        { algorithm: 'sha-256', value: formatted },
+    ]);
+}

package/src/rtc-data-channel.ts

@@ -0,0 +1,284 @@
+// RTCDataChannel — W3C WebRTC data channel backed by GstWebRTC.WebRTCDataChannel.
+//
+// Reference: refs/node-gst-webrtc/src/webrtc/RTCDataChannel.ts (ISC) +
+//            refs/node-datachannel/src/polyfill/RTCDataChannel.ts (MIT)
+//
+// Uses `@gjsify/webrtc-native`'s DataChannelBridge to marshal the six
+// GstWebRTCDataChannel signals (on-open / on-close / on-error /
+// on-message-string / on-message-data / on-buffered-amount-low) from the
+// GStreamer streaming thread onto the GLib main context. The raw `connect`
+// path is unusable because GJS blocks JS callbacks invoked from non-main
+// threads — see STATUS.md "WebRTC Status".
+
+import GLib from 'gi://GLib?version=2.0';
+import type GstWebRTC from 'gi://GstWebRTC?version=1.0';
+
+import { DataChannelBridge, type DataChannelBridge as DataChannelBridgeType } from '@gjsify/webrtc-native';
+
+import { RTCError } from './rtc-error.js';
+import { RTCErrorEvent } from './rtc-events.js';
+
+export type RTCDataChannelState = 'connecting' | 'open' | 'closing' | 'closed';
+export type BinaryType = 'blob' | 'arraybuffer';
+
+// NOTE: the GstWebRTCDataChannelState C enum is 1-based (CONNECTING=1 …
+// CLOSED=4), but the TypeScript @girs/gstwebrtc-1.0 declaration omits the
+// explicit initialiser so the `.d.ts` mis-infers 0-based values. Map
+// against the real runtime values.
+const STATE_MAP: Record<number, RTCDataChannelState> = {
+    1: 'connecting',
+    2: 'open',
+    3: 'closing',
+    4: 'closed',
+};
+
+type EventHandler<E extends Event = Event> = ((this: RTCDataChannel, ev: E) => any) | null;
+
+/** Convert a JS typed array / ArrayBuffer to a GLib.Bytes. */
+function toGBytes(buffer: ArrayBuffer | ArrayBufferView): GLib.Bytes {
+    let view: Uint8Array;
+    if (ArrayBuffer.isView(buffer)) {
+        view = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    } else {
+        view = new Uint8Array(buffer);
+    }
+    return new GLib.Bytes(view);
+}
+
+/** Convert a GLib.Bytes payload to an ArrayBuffer. */
+function bytesToArrayBuffer(bytes: GLib.Bytes): ArrayBuffer {
+    const arr = (bytes as any).toArray?.();
+    if (arr instanceof Uint8Array) {
+        return (arr.buffer as ArrayBuffer).slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
+    }
+    const data = (bytes as any).get_data?.();
+    if (data instanceof Uint8Array) {
+        return (data.buffer as ArrayBuffer).slice(data.byteOffset, data.byteOffset + data.byteLength);
+    }
+    return new ArrayBuffer(0);
+}
+
+export class RTCDataChannel extends EventTarget {
+    private readonly _native: GstWebRTC.WebRTCDataChannel;
+    private readonly _bridge: DataChannelBridgeType;
+    private _binaryType: BinaryType = 'arraybuffer';
+    private _bufferedAmount = 0;
+    private _closed = false;
+
+    // `on<event>` attribute handlers — W3C requires both addEventListener and on*.
+    private _onopen: EventHandler = null;
+    private _onclose: EventHandler = null;
+    private _onerror: EventHandler<RTCErrorEvent> = null;
+    private _onmessage: EventHandler<MessageEvent> = null;
+    private _onbufferedamountlow: EventHandler = null;
+    private _onclosing: EventHandler = null;
+
+    /**
+     * @internal
+     * Accepts either a raw GstWebRTCDataChannel (for locally-created channels)
+     * or a pre-made DataChannelBridge (for remotely-originated channels that
+     * the WebrtcbinBridge already wrapped on the streaming thread to avoid
+     * missing early messages).
+     */
+    constructor(source: GstWebRTC.WebRTCDataChannel | DataChannelBridgeType) {
+        super();
+        if ((source as DataChannelBridgeType).channel !== undefined && (source as any).dispose_bridge) {
+            this._bridge = source as DataChannelBridgeType;
+            this._native = this._bridge.channel as unknown as GstWebRTC.WebRTCDataChannel;
+        } else {
+            this._native = source as GstWebRTC.WebRTCDataChannel;
+            this._bridge = new (DataChannelBridge as any)({ channel: this._native });
+        }
+
+        this._bridge.connect('opened', () => this._handleOpen());
+        this._bridge.connect('closed', () => this._handleClose());
+        this._bridge.connect('error-occurred', (_b, message) => this._handleError(message));
+        this._bridge.connect('message-string', (_b, data) => this._handleString(data));
+        this._bridge.connect('message-data', (_b, data) => this._handleData(data));
+        this._bridge.connect('buffered-amount-low', () => this._handleBufferedAmountLow());
+        this._bridge.connect('ready-state-changed', () => this._handleReadyStateChange());
+    }
+
+    // ---- Properties --------------------------------------------------------
+
+    get label(): string { return this._native.label; }
+    get ordered(): boolean { return this._native.ordered; }
+    get protocol(): string { return this._native.protocol; }
+    get negotiated(): boolean { return this._native.negotiated; }
+    get id(): number | null { return this._native.id >= 0 ? this._native.id : null; }
+
+    get maxPacketLifeTime(): number | null {
+        const v = this._native.max_packet_lifetime;
+        return v >= 0 ? v : null;
+    }
+
+    get maxRetransmits(): number | null {
+        const v = this._native.max_retransmits;
+        return v >= 0 ? v : null;
+    }
+
+    get readyState(): RTCDataChannelState {
+        if (this._closed) return 'closed';
+        return STATE_MAP[this._native.ready_state as number] ?? 'connecting';
+    }
+
+    get bufferedAmount(): number {
+        try {
+            return Number(this._native.buffered_amount) || this._bufferedAmount;
+        } catch {
+            return this._bufferedAmount;
+        }
+    }
+
+    get bufferedAmountLowThreshold(): number {
+        return Number(this._native.buffered_amount_low_threshold) || 0;
+    }
+    set bufferedAmountLowThreshold(v: number) {
+        this._native.buffered_amount_low_threshold = v;
+    }
+
+    get binaryType(): BinaryType { return this._binaryType; }
+    set binaryType(v: BinaryType) {
+        // W3C §6.2 (and WPT RTCDataChannel-binaryType tests): invalid
+        // values must be silently ignored — keep the previous value.
+        // See: refs/wpt/webrtc/RTCDataChannel-binaryType.window.js
+        if (v !== 'arraybuffer' && v !== 'blob') return;
+        if (v === 'blob' && typeof (globalThis as any).Blob === 'undefined') {
+            const DOMExc = (globalThis as any).DOMException;
+            const msg = `binaryType 'blob' requires globalThis.Blob. Import '@gjsify/buffer/register' to provide it.`;
+            throw DOMExc ? new DOMExc(msg, 'NotSupportedError') : new Error(msg);
+        }
+        this._binaryType = v;
+    }
+
+    // ---- on<event> attribute accessors -------------------------------------
+
+    get onopen() { return this._onopen; }
+    set onopen(h: EventHandler) { this._onopen = h; }
+    get onclose() { return this._onclose; }
+    set onclose(h: EventHandler) { this._onclose = h; }
+    get onclosing() { return this._onclosing; }
+    set onclosing(h: EventHandler) { this._onclosing = h; }
+    get onerror() { return this._onerror; }
+    set onerror(h: EventHandler<RTCErrorEvent>) { this._onerror = h; }
+    get onmessage() { return this._onmessage; }
+    set onmessage(h: EventHandler<MessageEvent>) { this._onmessage = h; }
+    get onbufferedamountlow() { return this._onbufferedamountlow; }
+    set onbufferedamountlow(h: EventHandler) { this._onbufferedamountlow = h; }
+
+    // ---- Methods -----------------------------------------------------------
+
+    send(data: string | ArrayBuffer | ArrayBufferView | Blob): void {
+        const state = this.readyState;
+        if (state !== 'open') {
+            const DOMExc = (globalThis as any).DOMException;
+            const msg = `RTCDataChannel.send: readyState is '${state}', expected 'open'`;
+            throw DOMExc ? new DOMExc(msg, 'InvalidStateError') : new Error(msg);
+        }
+
+        if (typeof data === 'string') {
+            this._native.send_string(data);
+            this._bufferedAmount += new TextEncoder().encode(data).byteLength;
+            return;
+        }
+
+        if (typeof (globalThis as any).Blob !== 'undefined' && data instanceof (globalThis as any).Blob) {
+            const blob = data as Blob;
+            blob.arrayBuffer().then((buf) => {
+                try {
+                    this._native.send_data(toGBytes(buf));
+                    this._bufferedAmount += buf.byteLength;
+                } catch {
+                    /* channel may have closed mid-flight */
+                }
+            });
+            return;
+        }
+
+        if (ArrayBuffer.isView(data)) {
+            const bytes = toGBytes(data);
+            this._native.send_data(bytes);
+            this._bufferedAmount += data.byteLength;
+            return;
+        }
+        if (data instanceof ArrayBuffer) {
+            const bytes = toGBytes(data);
+            this._native.send_data(bytes);
+            this._bufferedAmount += data.byteLength;
+            return;
+        }
+
+        throw new TypeError('RTCDataChannel.send: unsupported data type');
+    }
+
+    close(): void {
+        if (this._closed) return;
+        try { this._native.close(); } catch { /* ignore */ }
+        this._disconnectSignals();
+        this._closed = true;
+    }
+
+    /** @internal */
+    _disconnectSignals(): void {
+        try { this._bridge.dispose_bridge(); } catch { /* ignore */ }
+    }
+
+    // ---- Signal → event translators ---------------------------------------
+    // Already running on the main context (DataChannelBridge did the hop).
+
+    private _handleOpen(): void {
+        const ev = new Event('open');
+        this._onopen?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+
+    private _handleClose(): void {
+        this._closed = true;
+        const ev = new Event('close');
+        this._onclose?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+
+    private _handleError(message: string): void {
+        const rtcErr = new RTCError(
+            { errorDetail: 'data-channel-failure' },
+            message || 'RTCDataChannel error',
+        );
+        const ev = new RTCErrorEvent('error', { error: rtcErr });
+        this._onerror?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+
+    private _handleString(data: string): void {
+        const ev = new MessageEvent('message', { data });
+        this._onmessage?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+
+    private _handleData(bytes: GLib.Bytes): void {
+        if (!bytes) return;
+        const buf = bytesToArrayBuffer(bytes);
+        let data: ArrayBuffer | Blob = buf;
+        if (this._binaryType === 'blob' && typeof (globalThis as any).Blob !== 'undefined') {
+            data = new (globalThis as any).Blob([buf]);
+        }
+        const ev = new MessageEvent('message', { data });
+        this._onmessage?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+
+    private _handleBufferedAmountLow(): void {
+        this._bufferedAmount = Number(this._native.buffered_amount) || 0;
+        const ev = new Event('bufferedamountlow');
+        this._onbufferedamountlow?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+
+    private _handleReadyStateChange(): void {
+        if (this.readyState === 'closing') {
+            const ev = new Event('closing');
+            this._onclosing?.call(this, ev);
+            this.dispatchEvent(ev);
+        }
+    }
+}

package/src/rtc-dtls-transport.ts

@@ -0,0 +1,48 @@
+// W3C RTCDtlsTransport for GJS.
+//
+// Thin wrapper reflecting the DTLS state of a webrtcbin transport.
+// State is updated by RTCPeerConnection via the WebrtcbinBridge.
+//
+// Reference: W3C WebRTC spec § 5.5
+// Reference: refs/wpt/webrtc/RTCDtlsTransport-state.html
+
+import '@gjsify/dom-events/register/event-target';
+
+import { RTCIceTransport } from './rtc-ice-transport.js';
+
+export type RTCDtlsTransportState = 'new' | 'connecting' | 'connected' | 'closed' | 'failed';
+
+type EventHandler = ((ev: Event) => void) | null;
+
+export class RTCDtlsTransport extends EventTarget {
+    readonly iceTransport: RTCIceTransport;
+    private _state: RTCDtlsTransportState = 'new';
+
+    private _onstatechange: EventHandler = null;
+    private _onerror: EventHandler = null;
+
+    constructor(iceTransport: RTCIceTransport) {
+        super();
+        this.iceTransport = iceTransport;
+    }
+
+    get state(): RTCDtlsTransportState { return this._state; }
+
+    get onstatechange(): EventHandler { return this._onstatechange; }
+    set onstatechange(v: EventHandler) { this._onstatechange = v; }
+    get onerror(): EventHandler { return this._onerror; }
+    set onerror(v: EventHandler) { this._onerror = v; }
+
+    getRemoteCertificates(): ArrayBuffer[] { return []; }
+
+    // ---- Internal setters (called by RTCPeerConnection) ---------------------
+
+    /** @internal */
+    _setState(state: RTCDtlsTransportState): void {
+        if (this._state === state) return;
+        this._state = state;
+        const ev = new Event('statechange');
+        this._onstatechange?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+}

package/src/rtc-dtmf-sender.ts

@@ -0,0 +1,146 @@
+// W3C RTCDTMFSender for GJS.
+//
+// Implements tone insertion, validation, and tonechange event dispatch.
+// Actual DTMF RTP packet generation requires GStreamer dtmfsrc integration
+// (Phase 4.6+); the timer-based event loop is spec-compliant regardless.
+//
+// Reference: W3C WebRTC spec § 7
+// Reference: refs/wpt/webrtc/RTCDTMFSender-insertDTMF.https.html
+// Reference: refs/wpt/webrtc/RTCDTMFSender-helper.js
+
+import '@gjsify/dom-events/register/event-target';
+
+const VALID_DTMF_CHARS = new Set('0123456789ABCDabcd#*,');
+const MIN_DURATION = 40;
+const MAX_DURATION = 6000;
+const DEFAULT_DURATION = 100;
+const MIN_INTER_TONE_GAP = 30;
+const DEFAULT_INTER_TONE_GAP = 70;
+const COMMA_DELAY = 2000;
+
+type EventHandler = ((ev: Event) => void) | null;
+
+export interface RTCDTMFToneChangeEventInit extends EventInit {
+    tone?: string;
+}
+
+export class RTCDTMFToneChangeEvent extends Event {
+    readonly tone: string;
+
+    constructor(type: string, init: RTCDTMFToneChangeEventInit = {}) {
+        super(type, init);
+        this.tone = init.tone ?? '';
+    }
+}
+
+export class RTCDTMFSender extends EventTarget {
+    private _toneBuffer = '';
+    private _duration = DEFAULT_DURATION;
+    private _interToneGap = DEFAULT_INTER_TONE_GAP;
+    private _timerId: ReturnType<typeof setTimeout> | null = null;
+    private _canInsert = true;
+    private _ontonechange: EventHandler = null;
+
+    /** @internal — back-references set by RTCRtpSender */
+    _isStopped: () => boolean = () => false;
+    _getCurrentDirection: () => string | null = () => null;
+
+    get toneBuffer(): string { return this._toneBuffer; }
+    get canInsertDTMF(): boolean { return this._canInsert; }
+
+    get ontonechange(): EventHandler { return this._ontonechange; }
+    set ontonechange(v: EventHandler) { this._ontonechange = v; }
+
+    insertDTMF(tones: string, duration?: number, interToneGap?: number): void {
+        // Step 3: If transceiver.stopped is true, throw InvalidStateError
+        if (this._isStopped()) {
+            throw new DOMException(
+                "Failed to execute 'insertDTMF': The associated transceiver is stopped",
+                'InvalidStateError',
+            );
+        }
+
+        // Step 4: If currentDirection is recvonly or inactive, throw InvalidStateError
+        const dir = this._getCurrentDirection();
+        if (dir === 'recvonly' || dir === 'inactive') {
+            throw new DOMException(
+                "Failed to execute 'insertDTMF': The associated transceiver direction does not allow sending",
+                'InvalidStateError',
+            );
+        }
+
+        // Step 6: If tones contains invalid characters, throw InvalidCharacterError
+        for (const ch of tones) {
+            if (!VALID_DTMF_CHARS.has(ch)) {
+                throw new DOMException(
+                    `Failed to execute 'insertDTMF': Invalid DTMF character '${ch}'`,
+                    'InvalidCharacterError',
+                );
+            }
+        }
+
+        // Normalize a-d to uppercase
+        tones = tones.replace(/[a-d]/g, c => c.toUpperCase());
+
+        // Clamp duration to [40, 6000]
+        const d = duration ?? DEFAULT_DURATION;
+        this._duration = Math.max(MIN_DURATION, Math.min(MAX_DURATION, d));
+
+        // Clamp interToneGap to [30, ...]
+        const g = interToneGap ?? DEFAULT_INTER_TONE_GAP;
+        this._interToneGap = Math.max(MIN_INTER_TONE_GAP, g);
+
+        // Step 9: Set the object's toneBuffer to tones
+        this._toneBuffer = tones;
+
+        // Step 10: If toneBuffer was empty before, start the playout task
+        if (this._timerId !== null) {
+            clearTimeout(this._timerId);
+            this._timerId = null;
+        }
+        if (tones.length > 0) {
+            this._scheduleNextTone(0);
+        }
+    }
+
+    private _scheduleNextTone(delay: number): void {
+        this._timerId = setTimeout(() => {
+            this._timerId = null;
+            this._playNextTone();
+        }, delay);
+    }
+
+    private _playNextTone(): void {
+        if (this._toneBuffer.length === 0) {
+            // Spec: fire one final tonechange with empty tone
+            this._fireToneChange('');
+            return;
+        }
+
+        const tone = this._toneBuffer[0];
+        this._toneBuffer = this._toneBuffer.slice(1);
+
+        // Fire tonechange event for this tone
+        this._fireToneChange(tone);
+
+        // Schedule next tone after duration + interToneGap (comma = 2s delay)
+        const delay = tone === ',' ? COMMA_DELAY : (this._duration + this._interToneGap);
+        this._scheduleNextTone(delay);
+    }
+
+    private _fireToneChange(tone: string): void {
+        const ev = new RTCDTMFToneChangeEvent('tonechange', { tone });
+        this._ontonechange?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+
+    /** @internal — called by RTCRtpSender on cleanup */
+    _stop(): void {
+        if (this._timerId !== null) {
+            clearTimeout(this._timerId);
+            this._timerId = null;
+        }
+        this._toneBuffer = '';
+        this._canInsert = false;
+    }
+}

package/src/rtc-error.ts

@@ -0,0 +1,49 @@
+// RTCError extends DOMException per W3C WebRTC spec §7.
+//
+// Reference: refs/node-datachannel/src/polyfill/RTCError.ts (MIT) +
+//            https://www.w3.org/TR/webrtc/#rtcerror-interface
+//
+// CLAUDE.md Rule 8 exception: the class below extends `DOMException`
+// (a global). Seed the global before the class body is evaluated.
+
+import '@gjsify/dom-exception/register';
+
+export type RTCErrorDetailType =
+    | 'data-channel-failure'
+    | 'dtls-failure'
+    | 'fingerprint-failure'
+    | 'sctp-failure'
+    | 'sdp-syntax-error'
+    | 'hardware-encoder-not-available'
+    | 'hardware-encoder-error';
+
+export interface RTCErrorInit {
+    errorDetail: RTCErrorDetailType;
+    sdpLineNumber?: number | null;
+    sctpCauseCode?: number | null;
+    receivedAlert?: number | null;
+    sentAlert?: number | null;
+    httpRequestStatusCode?: number | null;
+}
+
+export class RTCError extends DOMException {
+    readonly errorDetail: RTCErrorDetailType;
+    readonly sdpLineNumber: number | null;
+    readonly sctpCauseCode: number | null;
+    readonly receivedAlert: number | null;
+    readonly sentAlert: number | null;
+    readonly httpRequestStatusCode: number | null;
+
+    constructor(init: RTCErrorInit, message?: string) {
+        super(message ?? init.errorDetail, 'OperationError');
+        if (!init || !init.errorDetail) {
+            throw new TypeError('RTCError: errorDetail is required');
+        }
+        this.errorDetail = init.errorDetail;
+        this.sdpLineNumber = init.sdpLineNumber ?? null;
+        this.sctpCauseCode = init.sctpCauseCode ?? null;
+        this.receivedAlert = init.receivedAlert ?? null;
+        this.sentAlert = init.sentAlert ?? null;
+        this.httpRequestStatusCode = init.httpRequestStatusCode ?? null;
+    }
+}