@gjsify/webrtc 0.1.15

package/lib/esm/tee-multiplexer.js

@@ -0,0 +1,62 @@
+import { Gst } from "./gst-init.js";
+class TeeMultiplexer {
+  _tee;
+  // Gst.Element
+  _pipeline;
+  // Gst.Pipeline
+  _branchCount = 0;
+  /**
+   * Create a tee in the given pipeline and link it to the source's output.
+   * The source must already be in the pipeline.
+   */
+  constructor(pipeline, source) {
+    this._pipeline = pipeline;
+    this._tee = Gst.ElementFactory.make("tee", null);
+    this._tee.allow_not_linked = true;
+    pipeline.add(this._tee);
+    this._tee.sync_state_with_parent();
+    source.link(this._tee);
+  }
+  /** Request a new src pad from the tee for a consumer branch. */
+  requestSrcPad() {
+    const padName = "src_%u";
+    const srcPad = this._tee.request_pad_simple ? this._tee.request_pad_simple(padName) : this._tee.get_request_pad(padName);
+    if (srcPad) this._branchCount++;
+    return srcPad;
+  }
+  /**
+   * Release a branch's src pad from the tee.
+   * Adds a DROP probe before unlinking to prevent errors.
+   */
+  releaseSrcPad(srcPad) {
+    if (!srcPad) return;
+    try {
+      srcPad.add_probe(
+        Gst.PadProbeType.BLOCK_DOWNSTREAM,
+        () => Gst.PadProbeReturn.DROP
+      );
+    } catch {
+    }
+    try {
+      const peer = srcPad.get_peer();
+      if (peer) srcPad.unlink(peer);
+    } catch {
+    }
+    try {
+      this._tee.release_request_pad(srcPad);
+    } catch {
+    }
+    this._branchCount--;
+  }
+  /** Number of active branches. */
+  get branchCount() {
+    return this._branchCount;
+  }
+  /** The tee element (for pipeline queries). */
+  get element() {
+    return this._tee;
+  }
+}
+export {
+  TeeMultiplexer
+};

package/lib/esm/wpt-helpers.js

@@ -0,0 +1,122 @@
+import {
+  RTCPeerConnection
+} from "./index.js";
+function createPeerConnection() {
+  return new RTCPeerConnection();
+}
+async function exchangeOfferAnswer(pc1, pc2) {
+  pc1.onicecandidate = (ev) => {
+    if (ev.candidate) pc2.addIceCandidate(ev.candidate.toJSON()).catch(() => {
+    });
+  };
+  pc2.onicecandidate = (ev) => {
+    if (ev.candidate) pc1.addIceCandidate(ev.candidate.toJSON()).catch(() => {
+    });
+  };
+  const offer = await pc1.createOffer();
+  await pc1.setLocalDescription(offer);
+  await pc2.setRemoteDescription(offer);
+  const answer = await pc2.createAnswer();
+  await pc2.setLocalDescription(answer);
+  await pc1.setRemoteDescription(answer);
+}
+async function createDataChannelPair(options = {}, pc1 = createPeerConnection(), pc2 = createPeerConnection(), label = "wpt") {
+  let pair;
+  let bothOpen;
+  if (options.negotiated) {
+    const dc1 = pc1.createDataChannel(label, options);
+    const dc2 = pc2.createDataChannel(label, options);
+    pair = [dc1, dc2];
+    bothOpen = Promise.all(pair.map((dc) => new Promise((res, rej) => {
+      if (dc.readyState === "open") return res();
+      dc.onopen = () => res();
+      dc.onerror = (ev) => rej(ev?.error ?? new Error("onerror"));
+    })));
+  } else {
+    const dc1 = pc1.createDataChannel(label, options);
+    bothOpen = Promise.all([
+      new Promise((res, rej) => {
+        if (dc1.readyState === "open") return res();
+        dc1.onopen = () => res();
+        dc1.onerror = (ev) => rej(ev?.error ?? new Error("onerror"));
+      }),
+      new Promise((res, rej) => {
+        pc2.ondatachannel = (ev) => {
+          const dc2 = ev.channel;
+          if (dc2.readyState === "open") return res(dc2);
+          dc2.onopen = () => res(dc2);
+          dc2.onerror = (e) => rej(e?.error ?? new Error("onerror"));
+        };
+      }).then((dc2) => {
+        pair[1] = dc2;
+      })
+    ]);
+    pair = [dc1, void 0];
+  }
+  await exchangeOfferAnswer(pc1, pc2);
+  await bothOpen;
+  return [pair[0], pair[1], pc1, pc2];
+}
+function awaitMessage(channel) {
+  return new Promise((resolve, reject) => {
+    const messageHandler = (ev) => {
+      channel.removeEventListener("message", messageHandler);
+      channel.removeEventListener("error", errorHandler);
+      resolve(ev.data);
+    };
+    const errorHandler = (ev) => {
+      channel.removeEventListener("message", messageHandler);
+      channel.removeEventListener("error", errorHandler);
+      reject(ev?.error ?? new Error("channel error"));
+    };
+    channel.addEventListener("message", messageHandler);
+    channel.addEventListener("error", errorHandler);
+  });
+}
+class EventWatcher {
+  _events = [];
+  _waiters = [];
+  constructor(target, eventTypes) {
+    for (const type of eventTypes) {
+      target.addEventListener(type, () => {
+        this._events.push(type);
+        this._tryResolve();
+      });
+    }
+  }
+  wait_for(expected) {
+    const types = Array.isArray(expected) ? expected : [expected];
+    return new Promise((resolve, reject) => {
+      this._waiters.push({ types, resolve, reject });
+      this._tryResolve();
+    });
+  }
+  _tryResolve() {
+    while (this._waiters.length > 0 && this._events.length >= this._waiters[0].types.length) {
+      const waiter = this._waiters.shift();
+      const got = this._events.splice(0, waiter.types.length);
+      const matches = waiter.types.every((t, i) => got[i] === t);
+      if (matches) {
+        waiter.resolve();
+      } else {
+        waiter.reject(new Error(`EventWatcher: expected ${JSON.stringify(waiter.types)}, got ${JSON.stringify(got)}`));
+      }
+    }
+  }
+}
+function closePeerConnections(...pcs) {
+  for (const pc of pcs) {
+    try {
+      pc?.close();
+    } catch {
+    }
+  }
+}
+export {
+  EventWatcher,
+  awaitMessage,
+  closePeerConnections,
+  createDataChannelPair,
+  createPeerConnection,
+  exchangeOfferAnswer
+};

package/lib/types/get-user-media.d.ts

@@ -0,0 +1,14 @@
+import { MediaStream } from './media-stream.js';
+export interface MediaTrackConstraints {
+    deviceId?: string;
+    sampleRate?: number;
+    channelCount?: number;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+}
+export interface MediaStreamConstraints {
+    audio?: boolean | MediaTrackConstraints;
+    video?: boolean | MediaTrackConstraints;
+}
+export declare function getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;

package/lib/types/gst-enum-maps.d.ts

@@ -0,0 +1,10 @@
+import type { RTCSignalingState, RTCPeerConnectionState, RTCIceConnectionState, RTCIceGatheringState } from './rtc-peer-connection.js';
+import type { RTCRtpTransceiverDirection } from './rtc-rtp-sender.js';
+export declare function gstToSignalingState(v: number): RTCSignalingState;
+export declare function gstToConnectionState(v: number): RTCPeerConnectionState;
+export declare function gstToIceConnectionState(v: number): RTCIceConnectionState;
+export declare function gstToIceGatheringState(v: number): RTCIceGatheringState;
+export declare function gstDirectionToW3C(v: number): RTCRtpTransceiverDirection;
+export declare function w3cDirectionToGst(d: RTCRtpTransceiverDirection): number;
+export type RTCStatsType = 'codec' | 'inbound-rtp' | 'outbound-rtp' | 'remote-inbound-rtp' | 'remote-outbound-rtp' | 'csrc' | 'peer-connection' | 'data-channel' | 'stream' | 'transport' | 'candidate-pair' | 'local-candidate' | 'remote-candidate' | 'certificate';
+export declare function gstToStatsType(v: number): RTCStatsType | undefined;

package/lib/types/gst-init.d.ts

@@ -0,0 +1,5 @@
+import Gst from 'gi://Gst?version=1.0';
+export declare function ensureGstInit(): void;
+/** Throws if the `webrtcbin` element is not registered (gst-plugins-bad missing). */
+export declare function ensureWebrtcbinAvailable(): void;
+export { Gst };

package/lib/types/gst-stats-parser.d.ts

@@ -0,0 +1,16 @@
+import type Gst from 'gi://Gst?version=1.0';
+import { RTCStatsReport } from './rtc-stats-report.js';
+/**
+ * Parse the top-level GstStructure returned by webrtcbin's `get-stats`
+ * signal into a W3C RTCStatsReport.
+ *
+ * The top-level structure has one field per stats entry. Each field's value
+ * is a nested GstStructure (GJS unboxes boxed types automatically).
+ */
+export declare function parseGstStats(reply: Gst.Structure | null): RTCStatsReport;
+/**
+ * Filter an RTCStatsReport to entries relevant to a specific track identifier.
+ * Used by RTCRtpSender.getStats() and RTCRtpReceiver.getStats() to return
+ * only the stats associated with their track.
+ */
+export declare function filterStatsByTrackId(report: RTCStatsReport, trackId: string): RTCStatsReport;

package/lib/types/gst-utils.d.ts

@@ -0,0 +1,11 @@
+import type Gst from 'gi://Gst?version=1.0';
+/**
+ * Wrap a GstPromise-consuming emit into a JS Promise that resolves on the
+ * main thread.
+ *
+ * Usage:
+ *   const reply = await withGstPromise((promise) => {
+ *     webrtcbin.emit('create-offer', options, promise);
+ *   });
+ */
+export declare function withGstPromise(emit: (promise: Gst.Promise) => void): Promise<Gst.Structure | null>;

package/lib/types/index.d.ts

@@ -0,0 +1,41 @@
+export { RTCPeerConnection } from './rtc-peer-connection.js';
+export type { RTCConfiguration, RTCIceServer, RTCOfferOptions, RTCAnswerOptions, RTCDataChannelInit, RTCSignalingState, RTCPeerConnectionState, RTCIceConnectionState, RTCIceGatheringState, RTCIceTransportPolicy, RTCBundlePolicy, RTCRtcpMuxPolicy, } from './rtc-peer-connection.js';
+export { RTCDataChannel } from './rtc-data-channel.js';
+export type { RTCDataChannelState, BinaryType } from './rtc-data-channel.js';
+export { RTCSessionDescription } from './rtc-session-description.js';
+export type { RTCSessionDescriptionInit, RTCSdpType } from './rtc-session-description.js';
+export { RTCIceCandidate } from './rtc-ice-candidate.js';
+export type { RTCIceCandidateInit, RTCIceComponent, RTCIceProtocol, RTCIceCandidateType, RTCIceTcpCandidateType, } from './rtc-ice-candidate.js';
+export { RTCError } from './rtc-error.js';
+export type { RTCErrorInit, RTCErrorDetailType } from './rtc-error.js';
+export { RTCPeerConnectionIceEvent, RTCDataChannelEvent, RTCErrorEvent, } from './rtc-events.js';
+export type { RTCPeerConnectionIceEventInit, RTCDataChannelEventInit, RTCErrorEventInit, } from './rtc-events.js';
+export { RTCRtpSender } from './rtc-rtp-sender.js';
+export type { RTCRtpTransceiverDirection, RTCRtpCapabilities, RTCRtpCodecCapability, RTCRtpHeaderExtensionCapability, RTCRtpSendParameters, RTCRtpEncodingParameters, RTCRtpCodecParameters, RTCRtpHeaderExtensionParameters, RTCRtcpParameters, } from './rtc-rtp-sender.js';
+export { RTCRtpReceiver } from './rtc-rtp-receiver.js';
+export type { RTCRtpReceiveParameters } from './rtc-rtp-receiver.js';
+export { RTCRtpTransceiver } from './rtc-rtp-transceiver.js';
+export { MediaStream } from './media-stream.js';
+export { MediaStreamTrackEvent } from './media-stream.js';
+export { MediaStreamTrack } from './media-stream-track.js';
+export type { MediaStreamTrackInit } from './media-stream-track.js';
+export { RTCTrackEvent } from './rtc-track-event.js';
+export type { RTCTrackEventInit } from './rtc-track-event.js';
+export type { RTCRtpTransceiverInit } from './rtc-peer-connection.js';
+export { getUserMedia } from './get-user-media.js';
+export type { MediaStreamConstraints, MediaTrackConstraints } from './get-user-media.js';
+export { MediaDevices } from './media-devices.js';
+export { MediaDeviceInfo } from './media-device-info.js';
+export type { MediaDeviceKind } from './media-device-info.js';
+export { RTCStatsReport } from './rtc-stats-report.js';
+export type { RTCStats } from './rtc-stats-report.js';
+export { RTCDtlsTransport } from './rtc-dtls-transport.js';
+export type { RTCDtlsTransportState } from './rtc-dtls-transport.js';
+export { RTCIceTransport } from './rtc-ice-transport.js';
+export type { RTCIceTransportState, RTCIceRole, RTCIceParameters, RTCIceCandidatePair } from './rtc-ice-transport.js';
+export { RTCSctpTransport } from './rtc-sctp-transport.js';
+export type { RTCSctpTransportState } from './rtc-sctp-transport.js';
+export { RTCDTMFSender, RTCDTMFToneChangeEvent } from './rtc-dtmf-sender.js';
+export type { RTCDTMFToneChangeEventInit } from './rtc-dtmf-sender.js';
+export { RTCCertificate } from './rtc-certificate.js';
+export type { RTCDtlsFingerprint, AlgorithmIdentifier } from './rtc-certificate.js';

package/lib/types/media-device-info.d.ts

@@ -0,0 +1,14 @@
+export type MediaDeviceKind = 'audioinput' | 'audiooutput' | 'videoinput';
+export declare class MediaDeviceInfo {
+    readonly deviceId: string;
+    readonly kind: MediaDeviceKind;
+    readonly label: string;
+    readonly groupId: string;
+    constructor(init: {
+        deviceId: string;
+        kind: MediaDeviceKind;
+        label: string;
+        groupId?: string;
+    });
+    toJSON(): object;
+}

package/lib/types/media-devices.d.ts

@@ -0,0 +1,12 @@
+import '@gjsify/dom-events/register/event-target';
+import { type MediaStreamConstraints } from './get-user-media.js';
+import { MediaDeviceInfo } from './media-device-info.js';
+import type { MediaStream } from './media-stream.js';
+export declare class MediaDevices extends EventTarget {
+    private _ondevicechange;
+    get ondevicechange(): ((ev: Event) => void) | null;
+    set ondevicechange(v: ((ev: Event) => void) | null);
+    getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+    enumerateDevices(): Promise<MediaDeviceInfo[]>;
+    getSupportedConstraints(): Record<string, boolean>;
+}

package/lib/types/media-stream-track.d.ts

@@ -0,0 +1,59 @@
+import '@gjsify/dom-events/register/event-target';
+/** @internal GStreamer backing for tracks created by getUserMedia */
+export interface MediaStreamTrackGstInit {
+    source: any;
+    pipeline: any;
+}
+export interface MediaStreamTrackInit {
+    kind: 'audio' | 'video';
+    label?: string;
+    id?: string;
+    muted?: boolean;
+    /** @internal */
+    _gst?: MediaStreamTrackGstInit;
+}
+export declare class MediaStreamTrack extends EventTarget {
+    readonly id: string;
+    readonly kind: 'audio' | 'video';
+    readonly label: string;
+    private _enabled;
+    private _muted;
+    private _ended;
+    private _contentHint;
+    private _onended;
+    private _onmute;
+    private _onunmute;
+    /** @internal GStreamer source element (e.g. pulsesrc, audiotestsrc) */
+    _gstSource: any;
+    /** @internal Pipeline the source currently lives in (updated by VideoBridge) */
+    _gstPipeline: any;
+    /** @internal Tee element inserted by VideoBridge for preview fan-out */
+    _gstTee: any;
+    /** @internal TeeMultiplexer for multi-PC fan-out (created on second addTrack) */
+    _teeMultiplexer: any;
+    /** @internal Callback set by RTCRtpSender to control valve drop property */
+    private _enableCallback;
+    constructor(init: MediaStreamTrackInit);
+    get enabled(): boolean;
+    set enabled(v: boolean);
+    get muted(): boolean;
+    get readyState(): 'live' | 'ended';
+    get contentHint(): string;
+    set contentHint(v: string);
+    get onended(): ((ev: Event) => void) | null;
+    set onended(v: ((ev: Event) => void) | null);
+    get onmute(): ((ev: Event) => void) | null;
+    set onmute(v: ((ev: Event) => void) | null);
+    get onunmute(): ((ev: Event) => void) | null;
+    set onunmute(v: ((ev: Event) => void) | null);
+    clone(): MediaStreamTrack;
+    stop(): void;
+    getCapabilities(): Record<string, unknown>;
+    getConstraints(): Record<string, unknown>;
+    getSettings(): Record<string, unknown>;
+    applyConstraints(_constraints?: unknown): Promise<void>;
+    /** @internal — used by RTCRtpReceiver to toggle mute state */
+    _setMuted(muted: boolean): void;
+    /** @internal — called by RTCRtpSender to wire valve control */
+    _setEnableCallback(cb: ((enabled: boolean) => void) | null): void;
+}

package/lib/types/media-stream.d.ts

@@ -0,0 +1,28 @@
+import '@gjsify/dom-events/register/event-target';
+import { MediaStreamTrack } from './media-stream-track.js';
+export declare class MediaStream extends EventTarget {
+    readonly id: string;
+    private _tracks;
+    private _onaddtrack;
+    private _onremovetrack;
+    constructor(streamOrTracks?: MediaStream | MediaStreamTrack[]);
+    get active(): boolean;
+    get onaddtrack(): ((ev: Event) => void) | null;
+    set onaddtrack(v: ((ev: Event) => void) | null);
+    get onremovetrack(): ((ev: Event) => void) | null;
+    set onremovetrack(v: ((ev: Event) => void) | null);
+    getTracks(): MediaStreamTrack[];
+    getAudioTracks(): MediaStreamTrack[];
+    getVideoTracks(): MediaStreamTrack[];
+    getTrackById(id: string): MediaStreamTrack | null;
+    addTrack(track: MediaStreamTrack): void;
+    removeTrack(track: MediaStreamTrack): void;
+    clone(): MediaStream;
+}
+export interface MediaStreamTrackEventInit extends EventInit {
+    track: MediaStreamTrack;
+}
+export declare class MediaStreamTrackEvent extends Event {
+    readonly track: MediaStreamTrack;
+    constructor(type: string, init: MediaStreamTrackEventInit);
+}

package/lib/types/register/data-channel.d.ts

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

package/lib/types/register/error.d.ts

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

package/lib/types/register/media-devices.d.ts

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

package/lib/types/register/media.d.ts

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

package/lib/types/register/peer-connection.d.ts

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

package/lib/types/register.d.ts

@@ -0,0 +1,5 @@
+import './register/peer-connection.js';
+import './register/data-channel.js';
+import './register/error.js';
+import './register/media.js';
+import './register/media-devices.js';

package/lib/types/register.spec.d.ts

@@ -0,0 +1,3 @@
+import '@gjsify/webrtc/register';
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/rtc-certificate.d.ts

@@ -0,0 +1,23 @@
+export interface RTCDtlsFingerprint {
+    algorithm?: string;
+    value?: string;
+}
+export declare class RTCCertificate {
+    readonly expires: number;
+    private _fingerprints;
+    private _algorithm;
+    /** @internal — use RTCPeerConnection.generateCertificate() */
+    constructor(algorithm: string, expires: number, fingerprints: RTCDtlsFingerprint[]);
+    getFingerprints(): RTCDtlsFingerprint[];
+    /** @internal — the algorithm name for debugging/inspection */
+    get _algorithmName(): string;
+}
+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 declare function generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;

package/lib/types/rtc-data-channel.d.ts

@@ -0,0 +1,64 @@
+import type GstWebRTC from 'gi://GstWebRTC?version=1.0';
+import { type DataChannelBridge as DataChannelBridgeType } from '@gjsify/webrtc-native';
+import { RTCErrorEvent } from './rtc-events.js';
+export type RTCDataChannelState = 'connecting' | 'open' | 'closing' | 'closed';
+export type BinaryType = 'blob' | 'arraybuffer';
+type EventHandler<E extends Event = Event> = ((this: RTCDataChannel, ev: E) => any) | null;
+export declare class RTCDataChannel extends EventTarget {
+    private readonly _native;
+    private readonly _bridge;
+    private _binaryType;
+    private _bufferedAmount;
+    private _closed;
+    private _onopen;
+    private _onclose;
+    private _onerror;
+    private _onmessage;
+    private _onbufferedamountlow;
+    private _onclosing;
+    /**
+     * @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);
+    get label(): string;
+    get ordered(): boolean;
+    get protocol(): string;
+    get negotiated(): boolean;
+    get id(): number | null;
+    get maxPacketLifeTime(): number | null;
+    get maxRetransmits(): number | null;
+    get readyState(): RTCDataChannelState;
+    get bufferedAmount(): number;
+    get bufferedAmountLowThreshold(): number;
+    set bufferedAmountLowThreshold(v: number);
+    get binaryType(): BinaryType;
+    set binaryType(v: BinaryType);
+    get onopen(): EventHandler;
+    set onopen(h: EventHandler);
+    get onclose(): EventHandler;
+    set onclose(h: EventHandler);
+    get onclosing(): EventHandler;
+    set onclosing(h: EventHandler);
+    get onerror(): EventHandler<RTCErrorEvent>;
+    set onerror(h: EventHandler<RTCErrorEvent>);
+    get onmessage(): EventHandler<MessageEvent>;
+    set onmessage(h: EventHandler<MessageEvent>);
+    get onbufferedamountlow(): EventHandler;
+    set onbufferedamountlow(h: EventHandler);
+    send(data: string | ArrayBuffer | ArrayBufferView | Blob): void;
+    close(): void;
+    /** @internal */
+    _disconnectSignals(): void;
+    private _handleOpen;
+    private _handleClose;
+    private _handleError;
+    private _handleString;
+    private _handleData;
+    private _handleBufferedAmountLow;
+    private _handleReadyStateChange;
+}
+export {};

package/lib/types/rtc-dtls-transport.d.ts

@@ -0,0 +1,20 @@
+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 declare class RTCDtlsTransport extends EventTarget {
+    readonly iceTransport: RTCIceTransport;
+    private _state;
+    private _onstatechange;
+    private _onerror;
+    constructor(iceTransport: RTCIceTransport);
+    get state(): RTCDtlsTransportState;
+    get onstatechange(): EventHandler;
+    set onstatechange(v: EventHandler);
+    get onerror(): EventHandler;
+    set onerror(v: EventHandler);
+    getRemoteCertificates(): ArrayBuffer[];
+    /** @internal */
+    _setState(state: RTCDtlsTransportState): void;
+}
+export {};

package/lib/types/rtc-dtmf-sender.d.ts

@@ -0,0 +1,31 @@
+import '@gjsify/dom-events/register/event-target';
+type EventHandler = ((ev: Event) => void) | null;
+export interface RTCDTMFToneChangeEventInit extends EventInit {
+    tone?: string;
+}
+export declare class RTCDTMFToneChangeEvent extends Event {
+    readonly tone: string;
+    constructor(type: string, init?: RTCDTMFToneChangeEventInit);
+}
+export declare class RTCDTMFSender extends EventTarget {
+    private _toneBuffer;
+    private _duration;
+    private _interToneGap;
+    private _timerId;
+    private _canInsert;
+    private _ontonechange;
+    /** @internal — back-references set by RTCRtpSender */
+    _isStopped: () => boolean;
+    _getCurrentDirection: () => string | null;
+    get toneBuffer(): string;
+    get canInsertDTMF(): boolean;
+    get ontonechange(): EventHandler;
+    set ontonechange(v: EventHandler);
+    insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
+    private _scheduleNextTone;
+    private _playNextTone;
+    private _fireToneChange;
+    /** @internal — called by RTCRtpSender on cleanup */
+    _stop(): void;
+}
+export {};

package/lib/types/rtc-error.d.ts

@@ -0,0 +1,19 @@
+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 declare 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);
+}

package/lib/types/rtc-events.d.ts

@@ -0,0 +1,27 @@
+import '@gjsify/dom-events/register/event-target';
+import type { RTCIceCandidate } from './rtc-ice-candidate.js';
+import type { RTCDataChannel } from './rtc-data-channel.js';
+import type { RTCError } from './rtc-error.js';
+export interface RTCPeerConnectionIceEventInit extends EventInit {
+    candidate?: RTCIceCandidate | null;
+    url?: string | null;
+}
+export declare class RTCPeerConnectionIceEvent extends Event {
+    readonly candidate: RTCIceCandidate | null;
+    readonly url: string | null;
+    constructor(type: string, init?: RTCPeerConnectionIceEventInit);
+}
+export interface RTCDataChannelEventInit extends EventInit {
+    channel: RTCDataChannel;
+}
+export declare class RTCDataChannelEvent extends Event {
+    readonly channel: RTCDataChannel;
+    constructor(type: string, init: RTCDataChannelEventInit);
+}
+export interface RTCErrorEventInit extends EventInit {
+    error: RTCError;
+}
+export declare class RTCErrorEvent extends Event {
+    readonly error: RTCError;
+    constructor(type: string, init: RTCErrorEventInit);
+}

package/lib/types/rtc-ice-candidate.d.ts

@@ -0,0 +1,28 @@
+export interface RTCIceCandidateInit {
+    candidate?: string;
+    sdpMid?: string | null;
+    sdpMLineIndex?: number | null;
+    usernameFragment?: string | null;
+}
+export type RTCIceComponent = 'rtp' | 'rtcp';
+export type RTCIceProtocol = 'udp' | 'tcp';
+export type RTCIceCandidateType = 'host' | 'srflx' | 'prflx' | 'relay';
+export type RTCIceTcpCandidateType = 'active' | 'passive' | 'so';
+export declare class RTCIceCandidate {
+    readonly candidate: string;
+    readonly sdpMid: string | null;
+    readonly sdpMLineIndex: number | null;
+    readonly usernameFragment: string | null;
+    readonly foundation: string | null;
+    readonly component: RTCIceComponent | null;
+    readonly priority: number | null;
+    readonly protocol: RTCIceProtocol | null;
+    readonly address: string | null;
+    readonly port: number | null;
+    readonly type: RTCIceCandidateType | null;
+    readonly tcpType: RTCIceTcpCandidateType | null;
+    readonly relatedAddress: string | null;
+    readonly relatedPort: number | null;
+    constructor(init?: RTCIceCandidateInit);
+    toJSON(): RTCIceCandidateInit;
+}