@gjsify/webrtc 0.1.15

package/src/get-user-media.ts

@@ -0,0 +1,131 @@
+// getUserMedia for GJS — wraps GStreamer source elements as MediaStreamTracks.
+//
+// Phase 3: basic media capture. Tries real audio/video sources first
+// (pipewiresrc, pulsesrc, v4l2src), falls back to test sources.
+// Phase 4.3: constraint support — width, height, frameRate, sampleRate,
+// channelCount mapped to GStreamer capsfilter elements.
+//
+// Reference: W3C Media Capture and Streams spec § 10.3
+
+import { Gst, ensureGstInit } from './gst-init.js';
+import { MediaStreamTrack } from './media-stream-track.js';
+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 async function getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream> {
+    ensureGstInit();
+
+    if (!constraints.audio && !constraints.video) {
+        throw new TypeError(
+            "Failed to execute 'getUserMedia': At least one of audio or video must be requested",
+        );
+    }
+
+    const tracks: MediaStreamTrack[] = [];
+
+    if (constraints.audio) {
+        const audioConstraints = typeof constraints.audio === 'object' ? constraints.audio : {};
+        const source = _createAudioSource();
+        const pipeline = new Gst.Pipeline() as any;
+        pipeline.add(source);
+
+        // Apply audio constraints via capsfilter
+        const capsStr = _buildAudioCaps(audioConstraints);
+        if (capsStr) {
+            const capsfilter = Gst.ElementFactory.make('capsfilter', null)!;
+            (capsfilter as any).caps = Gst.Caps.from_string(capsStr);
+            pipeline.add(capsfilter);
+            source.link(capsfilter);
+        }
+
+        tracks.push(new MediaStreamTrack({
+            kind: 'audio',
+            label: source.name ?? 'audio',
+            _gst: { source, pipeline },
+        }));
+    }
+
+    if (constraints.video) {
+        const videoConstraints = typeof constraints.video === 'object' ? constraints.video : {};
+        const source = _createVideoSource();
+        const pipeline = new Gst.Pipeline() as any;
+        pipeline.add(source);
+
+        // Apply video constraints via capsfilter
+        const capsStr = _buildVideoCaps(videoConstraints);
+        if (capsStr) {
+            const capsfilter = Gst.ElementFactory.make('capsfilter', null)!;
+            (capsfilter as any).caps = Gst.Caps.from_string(capsStr);
+            pipeline.add(capsfilter);
+            source.link(capsfilter);
+        }
+
+        tracks.push(new MediaStreamTrack({
+            kind: 'video',
+            label: source.name ?? 'video',
+            _gst: { source, pipeline },
+        }));
+    }
+
+    return new MediaStream(tracks);
+}
+
+/** Build a GStreamer caps string for audio constraints. */
+function _buildAudioCaps(c: MediaTrackConstraints): string | null {
+    const parts: string[] = [];
+    if (c.sampleRate != null) parts.push(`rate=${Math.trunc(c.sampleRate)}`);
+    if (c.channelCount != null) parts.push(`channels=${Math.trunc(c.channelCount)}`);
+    if (parts.length === 0) return null;
+    return `audio/x-raw,${parts.join(',')}`;
+}
+
+/** Build a GStreamer caps string for video constraints. */
+function _buildVideoCaps(c: MediaTrackConstraints): string | null {
+    const parts: string[] = [];
+    if (c.width != null) parts.push(`width=${Math.trunc(c.width)}`);
+    if (c.height != null) parts.push(`height=${Math.trunc(c.height)}`);
+    if (c.frameRate != null) parts.push(`framerate=${Math.trunc(c.frameRate)}/1`);
+    if (parts.length === 0) return null;
+    return `video/x-raw,${parts.join(',')}`;
+}
+
+function _createAudioSource(): any {
+    // Try real sources in priority order
+    for (const name of ['pipewiresrc', 'pulsesrc', 'autoaudiosrc']) {
+        const el = Gst.ElementFactory.make(name, null);
+        if (el) {
+            try { (el as any).is_live = true; } catch { /* not all sources have is-live */ }
+            return el;
+        }
+    }
+    // Fallback: test source (sine wave, audible for debugging)
+    const el = Gst.ElementFactory.make('audiotestsrc', null)!;
+    (el as any).is_live = true;
+    (el as any).wave = 0; // sine
+    return el;
+}
+
+function _createVideoSource(): any {
+    for (const name of ['pipewiresrc', 'v4l2src', 'autovideosrc']) {
+        const el = Gst.ElementFactory.make(name, null);
+        if (el) return el;
+    }
+    // Fallback: test pattern
+    const el = Gst.ElementFactory.make('videotestsrc', null)!;
+    (el as any).is_live = true;
+    (el as any).pattern = 0; // SMPTE bars
+    return el;
+}

package/src/gst-enum-maps.ts

@@ -0,0 +1,125 @@
+// GStreamer ↔ W3C enum conversions for WebRTC types.
+//
+// Centralises the bidirectional mapping between GstWebRTC C enums and
+// W3C string literals used across RTCPeerConnection and RTCRtpTransceiver.
+
+import GstWebRTC from 'gi://GstWebRTC?version=1.0';
+
+import type {
+    RTCSignalingState,
+    RTCPeerConnectionState,
+    RTCIceConnectionState,
+    RTCIceGatheringState,
+} from './rtc-peer-connection.js';
+import type { RTCRtpTransceiverDirection } from './rtc-rtp-sender.js';
+
+// ---- Signaling state --------------------------------------------------------
+
+const SIGNALING_STATE_MAP: Record<number, RTCSignalingState> = {
+    [GstWebRTC.WebRTCSignalingState.STABLE]: 'stable',
+    [GstWebRTC.WebRTCSignalingState.CLOSED]: 'closed',
+    [GstWebRTC.WebRTCSignalingState.HAVE_LOCAL_OFFER]: 'have-local-offer',
+    [GstWebRTC.WebRTCSignalingState.HAVE_REMOTE_OFFER]: 'have-remote-offer',
+    [GstWebRTC.WebRTCSignalingState.HAVE_LOCAL_PRANSWER]: 'have-local-pranswer',
+    [GstWebRTC.WebRTCSignalingState.HAVE_REMOTE_PRANSWER]: 'have-remote-pranswer',
+};
+
+export function gstToSignalingState(v: number): RTCSignalingState {
+    return SIGNALING_STATE_MAP[v] ?? 'stable';
+}
+
+// ---- Connection state -------------------------------------------------------
+
+const CONNECTION_STATE_MAP: Record<number, RTCPeerConnectionState> = {
+    [GstWebRTC.WebRTCPeerConnectionState.NEW]: 'new',
+    [GstWebRTC.WebRTCPeerConnectionState.CONNECTING]: 'connecting',
+    [GstWebRTC.WebRTCPeerConnectionState.CONNECTED]: 'connected',
+    [GstWebRTC.WebRTCPeerConnectionState.DISCONNECTED]: 'disconnected',
+    [GstWebRTC.WebRTCPeerConnectionState.FAILED]: 'failed',
+    [GstWebRTC.WebRTCPeerConnectionState.CLOSED]: 'closed',
+};
+
+export function gstToConnectionState(v: number): RTCPeerConnectionState {
+    return CONNECTION_STATE_MAP[v] ?? 'new';
+}
+
+// ---- ICE connection state ---------------------------------------------------
+
+const ICE_CONNECTION_STATE_MAP: Record<number, RTCIceConnectionState> = {
+    [GstWebRTC.WebRTCICEConnectionState.NEW]: 'new',
+    [GstWebRTC.WebRTCICEConnectionState.CHECKING]: 'checking',
+    [GstWebRTC.WebRTCICEConnectionState.CONNECTED]: 'connected',
+    [GstWebRTC.WebRTCICEConnectionState.COMPLETED]: 'completed',
+    [GstWebRTC.WebRTCICEConnectionState.FAILED]: 'failed',
+    [GstWebRTC.WebRTCICEConnectionState.DISCONNECTED]: 'disconnected',
+    [GstWebRTC.WebRTCICEConnectionState.CLOSED]: 'closed',
+};
+
+export function gstToIceConnectionState(v: number): RTCIceConnectionState {
+    return ICE_CONNECTION_STATE_MAP[v] ?? 'new';
+}
+
+// ---- ICE gathering state ----------------------------------------------------
+
+const ICE_GATHERING_STATE_MAP: Record<number, RTCIceGatheringState> = {
+    [GstWebRTC.WebRTCICEGatheringState.NEW]: 'new',
+    [GstWebRTC.WebRTCICEGatheringState.GATHERING]: 'gathering',
+    [GstWebRTC.WebRTCICEGatheringState.COMPLETE]: 'complete',
+};
+
+export function gstToIceGatheringState(v: number): RTCIceGatheringState {
+    return ICE_GATHERING_STATE_MAP[v] ?? 'new';
+}
+
+// ---- Transceiver direction (bidirectional) ----------------------------------
+
+const DIRECTION_GST_TO_W3C: Record<number, RTCRtpTransceiverDirection> = {
+    [GstWebRTC.WebRTCRTPTransceiverDirection.SENDRECV]: 'sendrecv',
+    [GstWebRTC.WebRTCRTPTransceiverDirection.SENDONLY]: 'sendonly',
+    [GstWebRTC.WebRTCRTPTransceiverDirection.RECVONLY]: 'recvonly',
+};
+
+const DIRECTION_W3C_TO_GST: Record<string, number> = {
+    sendrecv: GstWebRTC.WebRTCRTPTransceiverDirection.SENDRECV,
+    sendonly: GstWebRTC.WebRTCRTPTransceiverDirection.SENDONLY,
+    recvonly: GstWebRTC.WebRTCRTPTransceiverDirection.RECVONLY,
+    inactive: GstWebRTC.WebRTCRTPTransceiverDirection.NONE,
+};
+
+export function gstDirectionToW3C(v: number): RTCRtpTransceiverDirection {
+    return DIRECTION_GST_TO_W3C[v] ?? 'inactive';
+}
+
+export function w3cDirectionToGst(d: RTCRtpTransceiverDirection): number {
+    return DIRECTION_W3C_TO_GST[d] ?? GstWebRTC.WebRTCRTPTransceiverDirection.NONE;
+}
+
+// ---- Stats type (GstWebRTC → W3C RTCStatsType string) -----------------------
+
+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';
+
+const STATS_TYPE_MAP: Record<number, RTCStatsType> = {
+    [GstWebRTC.WebRTCStatsType.CODEC]: 'codec',
+    [GstWebRTC.WebRTCStatsType.INBOUND_RTP]: 'inbound-rtp',
+    [GstWebRTC.WebRTCStatsType.OUTBOUND_RTP]: 'outbound-rtp',
+    [GstWebRTC.WebRTCStatsType.REMOTE_INBOUND_RTP]: 'remote-inbound-rtp',
+    [GstWebRTC.WebRTCStatsType.REMOTE_OUTBOUND_RTP]: 'remote-outbound-rtp',
+    [GstWebRTC.WebRTCStatsType.CSRC]: 'csrc',
+    [GstWebRTC.WebRTCStatsType.PEER_CONNECTION]: 'peer-connection',
+    [GstWebRTC.WebRTCStatsType.DATA_CHANNEL]: 'data-channel',
+    [GstWebRTC.WebRTCStatsType.STREAM]: 'stream',
+    [GstWebRTC.WebRTCStatsType.TRANSPORT]: 'transport',
+    [GstWebRTC.WebRTCStatsType.CANDIDATE_PAIR]: 'candidate-pair',
+    [GstWebRTC.WebRTCStatsType.LOCAL_CANDIDATE]: 'local-candidate',
+    [GstWebRTC.WebRTCStatsType.REMOTE_CANDIDATE]: 'remote-candidate',
+    [GstWebRTC.WebRTCStatsType.CERTIFICATE]: 'certificate',
+};
+
+export function gstToStatsType(v: number): RTCStatsType | undefined {
+    return STATS_TYPE_MAP[v];
+}

package/src/gst-init.ts

@@ -0,0 +1,52 @@
+// Lazy GStreamer initialization for the WebRTC backend.
+//
+// `webrtcbin` ships with GStreamer's gst-plugins-bad (`libgstwebrtc.so`).
+// On Fedora: gstreamer1-plugins-bad-free + gstreamer1-plugins-bad-free-extras.
+// On Ubuntu/Debian: gstreamer1.0-plugins-bad + gstreamer1.0-nice.
+//
+// This module is GJS-only — the Node alias layer routes it to @gjsify/empty.
+
+import Gst from 'gi://Gst?version=1.0';
+
+let initialized = false;
+
+export function ensureGstInit(): void {
+    if (initialized) return;
+    Gst.init(null);
+    initialized = true;
+}
+
+/** Throws if the `webrtcbin` element is not registered (gst-plugins-bad missing). */
+export function ensureWebrtcbinAvailable(): void {
+    ensureGstInit();
+    const webrtcFactory = Gst.ElementFactory.find('webrtcbin');
+    if (!webrtcFactory) {
+        throwNotSupported(
+            'GStreamer element "webrtcbin" not available. Install gst-plugins-bad:\n' +
+            '  Fedora:        dnf install gstreamer1-plugins-bad-free gstreamer1-plugins-bad-free-extras\n' +
+            '  Ubuntu/Debian: apt install gstreamer1.0-plugins-bad',
+        );
+    }
+    // webrtcbin requires libnice's GStreamer plugin for ICE transport —
+    // without it, pipeline state-change to PLAYING fails and createDataChannel
+    // hits the "webrtc->priv->is_closed" assertion.
+    const niceFactory = Gst.ElementFactory.find('nicesrc');
+    if (!niceFactory) {
+        throwNotSupported(
+            'GStreamer "nice" plugin (libnice-gstreamer) not available — required by webrtcbin.\n' +
+            '  Fedora:        dnf install libnice-gstreamer1\n' +
+            '  Ubuntu/Debian: apt install gstreamer1.0-nice\n' +
+            '  Verify with:   gst-inspect-1.0 nicesrc',
+        );
+    }
+}
+
+function throwNotSupported(message: string): never {
+    const DOMExceptionCtor: typeof DOMException | undefined = (globalThis as any).DOMException;
+    if (DOMExceptionCtor) {
+        throw new DOMExceptionCtor(message, 'NotSupportedError');
+    }
+    throw new Error(message);
+}
+
+export { Gst };

package/src/gst-stats-parser.ts

@@ -0,0 +1,137 @@
+// GstStructure → W3C RTCStatsReport parser.
+//
+// webrtcbin's `get-stats` action signal returns a GstStructure where each
+// field is a nested GstStructure containing one stats entry. Each entry
+// has a `type` field (GstWebRTCStatsType enum), an `id` field, a `timestamp`
+// field, plus type-specific fields in GStreamer snake_case naming.
+//
+// This module iterates the top-level fields, converts each nested structure
+// to a W3C-compliant stats dictionary with camelCase keys.
+
+import type Gst from 'gi://Gst?version=1.0';
+
+import { gstToStatsType } from './gst-enum-maps.js';
+import { RTCStatsReport, type RTCStats } from './rtc-stats-report.js';
+
+/**
+ * Convert a GStreamer snake_case field name to W3C camelCase.
+ * Examples: `bytes-sent` → `bytesSent`, `packets-received` → `packetsReceived`
+ */
+function snakeToCamel(name: string): string {
+    return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+/**
+ * Extract all fields from a GstStructure into a plain object.
+ * GJS unboxes `get_value` for boxed/simple types directly — no
+ * GObject.Value wrapper is returned for primitive types.
+ */
+function extractFields(structure: Gst.Structure): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    const n = structure.n_fields();
+    for (let i = 0; i < n; i++) {
+        const fieldName = structure.nth_field_name(i);
+        try {
+            const value = structure.get_value(fieldName);
+            result[fieldName] = value;
+        } catch {
+            // Some fields may not be extractable — skip silently
+        }
+    }
+    return result;
+}
+
+/**
+ * Parse a single stats entry (nested GstStructure) into a W3C RTCStats object.
+ */
+function parseStatsEntry(structure: Gst.Structure): RTCStats | null {
+    const raw = extractFields(structure);
+
+    // The `type` field is a GstWebRTCStatsType enum value
+    const gstType = raw['type'];
+    if (gstType == null) return null;
+    const w3cType = gstToStatsType(Number(gstType));
+    if (!w3cType) return null;
+
+    const id = String(raw['id'] ?? structure.get_name() ?? '');
+    // GStreamer provides timestamp in nanoseconds (pipeline clock).
+    // Convert to milliseconds for W3C (performance.now()-relative).
+    const tsRaw = raw['timestamp'];
+    const timestamp = tsRaw != null ? Number(tsRaw) / 1_000_000 : performance.now();
+
+    const stats: RTCStats = { type: w3cType, id, timestamp };
+
+    // Copy remaining fields, converting snake_case → camelCase
+    for (const [key, value] of Object.entries(raw)) {
+        if (key === 'type' || key === 'id' || key === 'timestamp') continue;
+        const camelKey = snakeToCamel(key);
+        stats[camelKey] = value;
+    }
+
+    return stats;
+}
+
+/**
+ * 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 function parseGstStats(reply: Gst.Structure | null): RTCStatsReport {
+    if (!reply) return new RTCStatsReport();
+
+    const entries: Array<[string, RTCStats]> = [];
+    const n = reply.n_fields();
+
+    for (let i = 0; i < n; i++) {
+        const fieldName = reply.nth_field_name(i);
+        try {
+            const nested = reply.get_value(fieldName);
+            // GJS unboxes the nested GstStructure directly
+            if (nested && typeof (nested as any).n_fields === 'function') {
+                const stats = parseStatsEntry(nested as unknown as Gst.Structure);
+                if (stats) {
+                    entries.push([stats.id, stats]);
+                }
+            }
+        } catch {
+            // Non-structure fields (e.g. metadata) — skip
+        }
+    }
+
+    return new RTCStatsReport(entries);
+}
+
+/**
+ * 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 function filterStatsByTrackId(report: RTCStatsReport, trackId: string): RTCStatsReport {
+    const entries: Array<[string, RTCStats]> = [];
+    const relatedIds = new Set<string>();
+
+    // First pass: find stats entries that reference this track
+    for (const [id, stats] of report) {
+        if (stats.trackIdentifier === trackId) {
+            entries.push([id, stats]);
+            relatedIds.add(id);
+            // Collect referenced IDs (transportId, codecId, remoteId, etc.)
+            for (const value of Object.values(stats)) {
+                if (typeof value === 'string' && report.has(value)) {
+                    relatedIds.add(value);
+                }
+            }
+        }
+    }
+
+    // Second pass: include referenced stats (codec, transport, candidate-pair, etc.)
+    for (const [id, stats] of report) {
+        if (relatedIds.has(id) && !entries.some(([entryId]) => entryId === id)) {
+            entries.push([id, stats]);
+        }
+    }
+
+    return new RTCStatsReport(entries);
+}

package/src/gst-utils.ts

@@ -0,0 +1,41 @@
+// Async bridging between GstPromise and JavaScript Promises.
+//
+// Reference: refs/node-gst-webrtc/src/gstUtils.ts (ISC, Ratchanan Srirattanamet)
+//
+// Why a native bridge? Gst.Promise.new_with_change_func() invokes its
+// callback on GStreamer's internal streaming thread. GJS blocks any JS
+// callback invoked from a non-main thread (to prevent SpiderMonkey VM
+// corruption), so the change_func is never delivered to JS — the Promise
+// would hang forever.
+//
+// `@gjsify/webrtc-native/PromiseBridge` is a Vala helper that registers
+// the change_func on the C side, hops through `g_main_context_invoke()`
+// to the GLib main thread, and only then emits `replied` / `rejected`
+// signals which JS can safely consume.
+
+import type Gst from 'gi://Gst?version=1.0';
+import { PromiseBridge } from '@gjsify/webrtc-native';
+
+/**
+ * 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 function withGstPromise(
+    emit: (promise: Gst.Promise) => void,
+): Promise<Gst.Structure | null> {
+    return new Promise((resolve, reject) => {
+        const bridge = new PromiseBridge();
+        bridge.connect('replied', (_b: unknown, reply: Gst.Structure | null) => {
+            resolve(reply);
+        });
+        bridge.connect('rejected', (_b: unknown, message: string) => {
+            reject(new Error(message));
+        });
+        emit(bridge.promise);
+    });
+}

package/src/index.ts

@@ -0,0 +1,104 @@
+// W3C WebRTC API for GJS — backed by GStreamer webrtcbin.
+//
+// This module has no side effects. Importing @gjsify/webrtc gives named
+// access to the classes but does NOT register globals. Use
+// @gjsify/webrtc/register (or a granular subpath) to set globalThis.RTCPeerConnection etc.
+
+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/src/media-device-info.ts

@@ -0,0 +1,33 @@
+// W3C MediaDeviceInfo for GJS — backed by GStreamer Device Monitor.
+//
+// Reference: W3C Media Capture and Streams spec § 10.2.1
+
+export type MediaDeviceKind = 'audioinput' | 'audiooutput' | 'videoinput';
+
+export class MediaDeviceInfo {
+    readonly deviceId: string;
+    readonly kind: MediaDeviceKind;
+    readonly label: string;
+    readonly groupId: string;
+
+    constructor(init: {
+        deviceId: string;
+        kind: MediaDeviceKind;
+        label: string;
+        groupId?: string;
+    }) {
+        this.deviceId = init.deviceId;
+        this.kind = init.kind;
+        this.label = init.label;
+        this.groupId = init.groupId ?? '';
+    }
+
+    toJSON(): object {
+        return {
+            deviceId: this.deviceId,
+            kind: this.kind,
+            label: this.label,
+            groupId: this.groupId,
+        };
+    }
+}