@gjsify/webrtc 0.1.15

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

@@ -0,0 +1,56 @@
+import '@gjsify/dom-events/register/event-target';
+import { RTCIceCandidate, type RTCIceCandidateInit } from './rtc-ice-candidate.js';
+export type RTCIceRole = 'unknown' | 'controlling' | 'controlled';
+export type RTCIceComponent = 'rtp' | 'rtcp';
+export type RTCIceTransportState = 'new' | 'checking' | 'connected' | 'completed' | 'disconnected' | 'failed' | 'closed';
+export interface RTCIceParameters {
+    usernameFragment?: string;
+    password?: string;
+}
+export interface RTCIceCandidatePair {
+    local: RTCIceCandidate;
+    remote: RTCIceCandidate;
+}
+type EventHandler = ((ev: Event) => void) | null;
+export declare class RTCIceTransport extends EventTarget {
+    private _state;
+    private _gatheringState;
+    private _role;
+    private _component;
+    private _localCandidates;
+    private _remoteCandidates;
+    private _localParams;
+    private _remoteParams;
+    private _onstatechange;
+    private _ongatheringstatechange;
+    private _onselectedcandidatepairchange;
+    get state(): RTCIceTransportState;
+    get gatheringState(): RTCIceGatheringState;
+    get role(): RTCIceRole;
+    get component(): RTCIceComponent;
+    get onstatechange(): EventHandler;
+    set onstatechange(v: EventHandler);
+    get ongatheringstatechange(): EventHandler;
+    set ongatheringstatechange(v: EventHandler);
+    get onselectedcandidatepairchange(): EventHandler;
+    set onselectedcandidatepairchange(v: EventHandler);
+    getLocalCandidates(): RTCIceCandidate[];
+    getRemoteCandidates(): RTCIceCandidate[];
+    getSelectedCandidatePair(): RTCIceCandidatePair | null;
+    getLocalParameters(): RTCIceParameters | null;
+    getRemoteParameters(): RTCIceParameters | null;
+    /** @internal */
+    _setState(state: RTCIceTransportState): void;
+    /** @internal */
+    _setGatheringState(state: RTCIceGatheringState): void;
+    /** @internal */
+    _addLocalCandidate(init: RTCIceCandidateInit): void;
+    /** @internal */
+    _addRemoteCandidate(init: RTCIceCandidateInit): void;
+    /** @internal */
+    _setLocalParameters(params: RTCIceParameters): void;
+    /** @internal */
+    _setRemoteParameters(params: RTCIceParameters): void;
+}
+type RTCIceGatheringState = 'new' | 'gathering' | 'complete';
+export {};

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

@@ -0,0 +1,165 @@
+import { RTCSessionDescription, type RTCSessionDescriptionInit } from './rtc-session-description.js';
+import { RTCIceCandidate, type RTCIceCandidateInit } from './rtc-ice-candidate.js';
+import { RTCDataChannel } from './rtc-data-channel.js';
+import { RTCPeerConnectionIceEvent, RTCDataChannelEvent } from './rtc-events.js';
+import { RTCRtpSender, type RTCRtpTransceiverDirection } from './rtc-rtp-sender.js';
+import { RTCRtpReceiver } from './rtc-rtp-receiver.js';
+import { RTCRtpTransceiver } from './rtc-rtp-transceiver.js';
+import { MediaStream } from './media-stream.js';
+import { MediaStreamTrack } from './media-stream-track.js';
+import { RTCTrackEvent } from './rtc-track-event.js';
+import type { RTCStatsReport } from './rtc-stats-report.js';
+import { RTCSctpTransport } from './rtc-sctp-transport.js';
+import { RTCCertificate, type AlgorithmIdentifier } from './rtc-certificate.js';
+export type RTCSignalingState = 'stable' | 'closed' | 'have-local-offer' | 'have-remote-offer' | 'have-local-pranswer' | 'have-remote-pranswer';
+export type RTCPeerConnectionState = 'new' | 'connecting' | 'connected' | 'disconnected' | 'failed' | 'closed';
+export type RTCIceConnectionState = 'new' | 'checking' | 'connected' | 'completed' | 'failed' | 'disconnected' | 'closed';
+export type RTCIceGatheringState = 'new' | 'gathering' | 'complete';
+export type RTCIceTransportPolicy = 'all' | 'relay';
+export type RTCBundlePolicy = 'balanced' | 'max-compat' | 'max-bundle';
+export type RTCRtcpMuxPolicy = 'require';
+export interface RTCIceServer {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+    credentialType?: 'password';
+}
+export interface RTCConfiguration {
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    bundlePolicy?: RTCBundlePolicy;
+    rtcpMuxPolicy?: RTCRtcpMuxPolicy;
+    peerIdentity?: string;
+    certificates?: unknown[];
+    iceCandidatePoolSize?: number;
+}
+export interface RTCOfferOptions {
+    offerToReceiveAudio?: boolean;
+    offerToReceiveVideo?: boolean;
+    iceRestart?: boolean;
+}
+export interface RTCAnswerOptions {
+}
+export interface RTCDataChannelInit {
+    ordered?: boolean;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+    protocol?: string;
+    negotiated?: boolean;
+    id?: number;
+    priority?: 'very-low' | 'low' | 'medium' | 'high';
+}
+type EventHandler<E extends Event = Event> = ((this: RTCPeerConnection, ev: E) => any) | null;
+export interface RTCRtpTransceiverInit {
+    direction?: RTCRtpTransceiverDirection;
+    streams?: MediaStream[];
+    sendEncodings?: Array<{
+        rid?: string;
+        active?: boolean;
+        maxBitrate?: number;
+        scaleResolutionDownBy?: number;
+    }>;
+}
+export declare class RTCPeerConnection extends EventTarget {
+    private _pipeline;
+    private _webrtcbin;
+    private _bridge;
+    private _conf;
+    private _closed;
+    private _iceRestartNeeded;
+    private _hasNegotiated;
+    private _dataChannels;
+    private _transceivers;
+    private _senders;
+    private _receivers;
+    private _iceTransport;
+    private _dtlsTransport;
+    private _sctpTransport;
+    readonly canTrickleIceCandidates: boolean;
+    constructor(configuration?: RTCConfiguration);
+    private _applyIceServers;
+    private _applyIceTransportPolicy;
+    private _applyBundlePolicy;
+    get signalingState(): RTCSignalingState;
+    get connectionState(): RTCPeerConnectionState;
+    get iceConnectionState(): RTCIceConnectionState;
+    get iceGatheringState(): RTCIceGatheringState;
+    private _descProp;
+    get localDescription(): RTCSessionDescription | null;
+    get remoteDescription(): RTCSessionDescription | null;
+    get currentLocalDescription(): RTCSessionDescription | null;
+    get currentRemoteDescription(): RTCSessionDescription | null;
+    get pendingLocalDescription(): RTCSessionDescription | null;
+    get pendingRemoteDescription(): RTCSessionDescription | null;
+    get sctp(): RTCSctpTransport | null;
+    get peerIdentity(): Promise<never>;
+    get idpErrorInfo(): null;
+    get idpLoginUrl(): null;
+    private _rejectIfClosed;
+    createOffer(_options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
+    createAnswer(_options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit>;
+    setLocalDescription(description?: RTCSessionDescriptionInit): Promise<void>;
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidateInit | RTCIceCandidate | null): Promise<void>;
+    createDataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel;
+    private _setStructureField;
+    getConfiguration(): RTCConfiguration;
+    close(): void;
+    addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
+    addTrack(track: MediaStreamTrack, ..._streams: MediaStream[]): RTCRtpSender;
+    removeTrack(sender: RTCRtpSender): void;
+    getSenders(): RTCRtpSender[];
+    getReceivers(): RTCRtpReceiver[];
+    getTransceivers(): RTCRtpTransceiver[];
+    getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
+    restartIce(): void;
+    setConfiguration(configuration: RTCConfiguration): void;
+    getIdentityAssertion(): Promise<never>;
+    /** Find a GstWebRTCRTPTransceiver not yet in our map (created by request_pad_simple). */
+    private _findNewGstTransceiver;
+    /** Lazily create the shared DTLS and ICE transport instances (max-bundle → one pair). */
+    private _ensureTransports;
+    /** Create the SCTP transport when a data channel is first negotiated. */
+    private _ensureSctpTransport;
+    private _createTransceiverWrapper;
+    private _handleNegotiationNeeded;
+    private _handleIceCandidate;
+    private _handleNewTransceiver;
+    private _handlePadAdded;
+    private _handleDataChannel;
+    private _dispatchStateChange;
+    /** Map PC connection state → DTLS transport state. */
+    private _syncDtlsState;
+    /** Map PC ICE connection state → ICE transport state. */
+    private _syncIceState;
+    /** Map PC ICE gathering state → ICE transport gathering state. */
+    private _syncIceGatheringState;
+    private _onconnectionstatechange;
+    private _ondatachannel;
+    private _onicecandidate;
+    private _oniceconnectionstatechange;
+    private _onicegatheringstatechange;
+    private _onnegotiationneeded;
+    private _onsignalingstatechange;
+    get onconnectionstatechange(): EventHandler;
+    set onconnectionstatechange(v: EventHandler);
+    get ondatachannel(): EventHandler<RTCDataChannelEvent>;
+    set ondatachannel(v: EventHandler<RTCDataChannelEvent>);
+    get onicecandidate(): EventHandler<RTCPeerConnectionIceEvent>;
+    set onicecandidate(v: EventHandler<RTCPeerConnectionIceEvent>);
+    get oniceconnectionstatechange(): EventHandler;
+    set oniceconnectionstatechange(v: EventHandler);
+    get onicegatheringstatechange(): EventHandler;
+    set onicegatheringstatechange(v: EventHandler);
+    get onnegotiationneeded(): EventHandler;
+    set onnegotiationneeded(v: EventHandler);
+    get onsignalingstatechange(): EventHandler;
+    set onsignalingstatechange(v: EventHandler);
+    private _ontrack;
+    get ontrack(): EventHandler<RTCTrackEvent>;
+    set ontrack(v: EventHandler<RTCTrackEvent>);
+    get onicecandidateerror(): EventHandler;
+    set onicecandidateerror(_v: EventHandler);
+    static generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
+}
+export {};

package/lib/types/rtc-rtp-receiver.d.ts

@@ -0,0 +1,45 @@
+import type GstWebRTC from 'gi://GstWebRTC?version=1.0';
+import type Gst from 'gi://Gst?version=1.0';
+import { MediaStreamTrack } from './media-stream-track.js';
+import type { RTCStatsReport } from './rtc-stats-report.js';
+import type { RTCDtlsTransport } from './rtc-dtls-transport.js';
+import type { RTCRtpCapabilities, RTCRtpCodecParameters, RTCRtpHeaderExtensionParameters, RTCRtcpParameters } from './rtc-rtp-sender.js';
+export interface RTCRtpReceiveParameters {
+    codecs: RTCRtpCodecParameters[];
+    headerExtensions: RTCRtpHeaderExtensionParameters[];
+    rtcp: RTCRtcpParameters;
+}
+export interface RTCRtpContributingSource {
+    timestamp: number;
+    source: number;
+    audioLevel?: number;
+    rtpTimestamp: number;
+}
+export interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
+    voiceActivityFlag?: boolean;
+}
+export declare class RTCRtpReceiver {
+    private _gstReceiver;
+    private _track;
+    private _jitterBufferTarget;
+    private _pipeline;
+    private _receiverBridge;
+    /** @internal — stats callback set by RTCPeerConnection */
+    _getStatsForTrack: ((track: MediaStreamTrack) => Promise<RTCStatsReport>) | null;
+    constructor(kind: 'audio' | 'video', gstReceiver: GstWebRTC.WebRTCRTPReceiver | null, pipeline?: any);
+    /** @internal — called from RTCPeerConnection._handlePadAdded */
+    _connectToPad(pad: Gst.Pad): void;
+    /** @internal — called from RTCPeerConnection.close() */
+    _dispose(): void;
+    /** @internal — set by RTCPeerConnection */
+    _transport: RTCDtlsTransport | null;
+    get track(): MediaStreamTrack;
+    get transport(): RTCDtlsTransport | null;
+    get jitterBufferTarget(): number | null;
+    set jitterBufferTarget(v: number | null);
+    getParameters(): RTCRtpReceiveParameters;
+    getContributingSources(): RTCRtpContributingSource[];
+    getSynchronizationSources(): RTCRtpSynchronizationSource[];
+    getStats(): Promise<RTCStatsReport>;
+    static getCapabilities(kind: string): RTCRtpCapabilities | null;
+}

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

@@ -0,0 +1,98 @@
+import type GstWebRTC from 'gi://GstWebRTC?version=1.0';
+import { RTCDTMFSender } from './rtc-dtmf-sender.js';
+import type { RTCStatsReport } from './rtc-stats-report.js';
+import type { RTCDtlsTransport } from './rtc-dtls-transport.js';
+import type { MediaStreamTrack } from './media-stream-track.js';
+import type { MediaStream } from './media-stream.js';
+export type RTCRtpTransceiverDirection = 'sendrecv' | 'sendonly' | 'recvonly' | 'inactive' | 'stopped';
+export interface RTCRtpCodecCapability {
+    mimeType: string;
+    clockRate: number;
+    channels?: number;
+    sdpFmtpLine?: string;
+}
+export interface RTCRtpHeaderExtensionCapability {
+    uri: string;
+}
+export interface RTCRtpCapabilities {
+    codecs: RTCRtpCodecCapability[];
+    headerExtensions: RTCRtpHeaderExtensionCapability[];
+}
+export interface RTCRtpEncodingParameters {
+    rid?: string;
+    active?: boolean;
+    maxBitrate?: number;
+    maxFramerate?: number;
+    scaleResolutionDownBy?: number;
+}
+export interface RTCRtpCodecParameters {
+    payloadType: number;
+    mimeType: string;
+    clockRate: number;
+    channels?: number;
+    sdpFmtpLine?: string;
+}
+export interface RTCRtpHeaderExtensionParameters {
+    uri: string;
+    id: number;
+    encrypted?: boolean;
+}
+export interface RTCRtcpParameters {
+    cname?: string;
+    reducedSize?: boolean;
+}
+export interface RTCRtpSendParameters {
+    transactionId: string;
+    encodings: RTCRtpEncodingParameters[];
+    codecs: RTCRtpCodecParameters[];
+    headerExtensions: RTCRtpHeaderExtensionParameters[];
+    rtcp: RTCRtcpParameters;
+}
+export declare class RTCRtpSender {
+    private _gstSender;
+    private _track;
+    private _lastParams;
+    /** @internal GStreamer pipeline references (set by RTCPeerConnection) */
+    private _pipeline;
+    private _webrtcbin;
+    private _mlineIndex;
+    private _elements;
+    private _valve;
+    _linked: boolean;
+    /** @internal — tee src pad if this sender uses a shared source */
+    private _teeSrcPad;
+    /** @internal — stats callback set by RTCPeerConnection */
+    _getStatsForTrack: ((track: MediaStreamTrack) => Promise<RTCStatsReport>) | null;
+    /** @internal — set by RTCPeerConnection */
+    _transport: RTCDtlsTransport | null;
+    /** @internal — DTMF sender, created lazily for audio senders */
+    private _dtmf;
+    /** @internal — the kind of media this sender handles */
+    _kind: 'audio' | 'video' | null;
+    /** @internal — back-reference for DTMF stopped/direction checks */
+    _transceiver: {
+        stopped: boolean;
+        currentDirection: string | null;
+    } | null;
+    /** @internal — callback to notify RTCPeerConnection when pipeline changes (cross-pipeline fix) */
+    _onPipelineChanged: ((newPipeline: any) => void) | null;
+    constructor(gstSender: GstWebRTC.WebRTCRTPSender | null, pipeline?: any, webrtcbin?: any);
+    get track(): MediaStreamTrack | null;
+    /** Returns the DTMF sender for audio senders, null for video. */
+    get dtmf(): RTCDTMFSender | null;
+    get transport(): RTCDtlsTransport | null;
+    /** @internal */
+    _setTrack(track: MediaStreamTrack | null): void;
+    /** @internal — called by RTCPeerConnection._createTransceiverWrapper */
+    _setMlineIndex(index: number): void;
+    /** @internal — build the outgoing encoder chain and link to webrtcbin */
+    _wirePipeline(track: MediaStreamTrack): void;
+    /** @internal — tear down the encoder chain on close/removeTrack */
+    _teardownPipeline(): void;
+    getParameters(): RTCRtpSendParameters;
+    setParameters(params: RTCRtpSendParameters): Promise<void>;
+    replaceTrack(track: MediaStreamTrack | null): Promise<void>;
+    getStats(): Promise<RTCStatsReport>;
+    setStreams(..._streams: MediaStream[]): void;
+    static getCapabilities(kind: string): RTCRtpCapabilities | null;
+}

package/lib/types/rtc-rtp-transceiver.d.ts

@@ -0,0 +1,20 @@
+import type GstWebRTC from 'gi://GstWebRTC?version=1.0';
+import { RTCRtpSender, type RTCRtpTransceiverDirection, type RTCRtpCodecCapability } from './rtc-rtp-sender.js';
+import { RTCRtpReceiver } from './rtc-rtp-receiver.js';
+export declare class RTCRtpTransceiver {
+    private _gstTrans;
+    readonly sender: RTCRtpSender;
+    readonly receiver: RTCRtpReceiver;
+    private _stopped;
+    private _codecPreferences;
+    constructor(gstTrans: GstWebRTC.WebRTCRTPTransceiver, sender: RTCRtpSender, receiver: RTCRtpReceiver);
+    get mid(): string | null;
+    get direction(): RTCRtpTransceiverDirection;
+    set direction(d: RTCRtpTransceiverDirection);
+    get currentDirection(): RTCRtpTransceiverDirection | null;
+    get stopped(): boolean;
+    stop(): void;
+    setCodecPreferences(codecs: RTCRtpCodecCapability[]): void;
+    /** @internal */
+    get _nativeTransceiver(): GstWebRTC.WebRTCRTPTransceiver;
+}

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

@@ -0,0 +1,20 @@
+import '@gjsify/dom-events/register/event-target';
+import { RTCDtlsTransport } from './rtc-dtls-transport.js';
+export type RTCSctpTransportState = 'connecting' | 'connected' | 'closed';
+type EventHandler = ((ev: Event) => void) | null;
+export declare class RTCSctpTransport extends EventTarget {
+    readonly transport: RTCDtlsTransport;
+    private _state;
+    private _maxMessageSize;
+    private _maxChannels;
+    private _onstatechange;
+    constructor(dtlsTransport: RTCDtlsTransport);
+    get state(): RTCSctpTransportState;
+    get maxMessageSize(): number;
+    get maxChannels(): number | null;
+    get onstatechange(): EventHandler;
+    set onstatechange(v: EventHandler);
+    /** @internal */
+    _setState(state: RTCSctpTransportState): void;
+}
+export {};

package/lib/types/rtc-session-description.d.ts

@@ -0,0 +1,18 @@
+import GstWebRTC from 'gi://GstWebRTC?version=1.0';
+export type RTCSdpType = 'offer' | 'pranswer' | 'answer' | 'rollback';
+export interface RTCSessionDescriptionInit {
+    type?: RTCSdpType;
+    sdp?: string;
+}
+export declare class RTCSessionDescription {
+    readonly type: RTCSdpType;
+    readonly sdp: string;
+    constructor(init?: RTCSessionDescriptionInit);
+    toJSON(): {
+        type: RTCSdpType;
+        sdp: string;
+    };
+    /** Build a GstWebRTC.WebRTCSessionDescription for use with webrtcbin signals. */
+    toGstDesc(): GstWebRTC.WebRTCSessionDescription;
+    static fromGstDesc(desc: GstWebRTC.WebRTCSessionDescription): RTCSessionDescription;
+}

package/lib/types/rtc-stats-report.d.ts

@@ -0,0 +1,22 @@
+export interface RTCStats {
+    timestamp: number;
+    type: string;
+    id: string;
+    [key: string]: unknown;
+}
+/**
+ * Read-only Map-like collection of stats entries keyed by id.
+ * W3C requires iteration support but not mutation.
+ */
+export declare class RTCStatsReport {
+    private readonly _map;
+    constructor(entries?: Iterable<[string, RTCStats]>);
+    get size(): number;
+    get(key: string): RTCStats | undefined;
+    has(key: string): boolean;
+    forEach(callbackfn: (value: RTCStats, key: string, map: RTCStatsReport) => void, thisArg?: unknown): void;
+    entries(): IterableIterator<[string, RTCStats]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<RTCStats>;
+    [Symbol.iterator](): IterableIterator<[string, RTCStats]>;
+}

package/lib/types/rtc-track-event.d.ts

@@ -0,0 +1,18 @@
+import '@gjsify/dom-events/register/event-target';
+import type { RTCRtpReceiver } from './rtc-rtp-receiver.js';
+import type { RTCRtpTransceiver } from './rtc-rtp-transceiver.js';
+import type { MediaStreamTrack } from './media-stream-track.js';
+import type { MediaStream } from './media-stream.js';
+export interface RTCTrackEventInit extends EventInit {
+    receiver: RTCRtpReceiver;
+    track: MediaStreamTrack;
+    streams?: MediaStream[];
+    transceiver: RTCRtpTransceiver;
+}
+export declare class RTCTrackEvent extends Event {
+    readonly receiver: RTCRtpReceiver;
+    readonly track: MediaStreamTrack;
+    readonly streams: ReadonlyArray<MediaStream>;
+    readonly transceiver: RTCRtpTransceiver;
+    constructor(type: string, init: RTCTrackEventInit);
+}

package/lib/types/rtp-capabilities.d.ts

@@ -0,0 +1,3 @@
+import type { RTCRtpCapabilities } from './rtc-rtp-sender.js';
+/** Shared implementation for RTCRtpSender.getCapabilities / RTCRtpReceiver.getCapabilities. */
+export declare function getRtpCapabilities(kind: string): RTCRtpCapabilities | null;

package/lib/types/tee-multiplexer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Manages a GStreamer `tee` element that fans out one source to multiple
+ * consumer branches. Each branch gets its own src pad from the tee.
+ */
+export declare class TeeMultiplexer {
+    private _tee;
+    private _pipeline;
+    private _branchCount;
+    /**
+     * 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: any, source: any);
+    /** Request a new src pad from the tee for a consumer branch. */
+    requestSrcPad(): any;
+    /**
+     * Release a branch's src pad from the tee.
+     * Adds a DROP probe before unlinking to prevent errors.
+     */
+    releaseSrcPad(srcPad: any): void;
+    /** Number of active branches. */
+    get branchCount(): number;
+    /** The tee element (for pipeline queries). */
+    get element(): any;
+}

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

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/wpt-helpers.d.ts

@@ -0,0 +1,30 @@
+import { RTCPeerConnection, type RTCDataChannel, type RTCDataChannelInit } from './index.js';
+/** Mirror WPT's `createPeerConnectionWithCleanup` — returns a fresh pc. */
+export declare function createPeerConnection(): RTCPeerConnection;
+/**
+ * Mirror WPT's `exchangeOfferAnswer(pc1, pc2)` + `exchangeIceCandidates`.
+ * Runs the full handshake to completion.
+ */
+export declare function exchangeOfferAnswer(pc1: RTCPeerConnection, pc2: RTCPeerConnection): Promise<void>;
+/**
+ * Port of WPT `createDataChannelPair(t, options, pc1, pc2)` — returns
+ * `[dc1, dc2]` both in `'open'` state, handshake complete. If `options.negotiated`
+ * both sides pre-create the channel with matching id; otherwise pc1 creates
+ * and pc2 receives via `ondatachannel`.
+ */
+export declare function createDataChannelPair(options?: RTCDataChannelInit, pc1?: RTCPeerConnection, pc2?: RTCPeerConnection, label?: string): Promise<[RTCDataChannel, RTCDataChannel, RTCPeerConnection, RTCPeerConnection]>;
+/** Port of WPT `awaitMessage(channel)` — resolves with the next incoming data. */
+export declare function awaitMessage<T = unknown>(channel: RTCDataChannel): Promise<T>;
+/**
+ * Mirror WPT's `EventWatcher(t, target, events)` — accumulates events in
+ * order and returns `wait_for(types)` that matches the expected sequence.
+ */
+export declare class EventWatcher {
+    private _events;
+    private _waiters;
+    constructor(target: EventTarget, eventTypes: string[]);
+    wait_for(expected: string | string[]): Promise<void>;
+    private _tryResolve;
+}
+/** Close an array of RTCPeerConnection instances, ignoring errors. */
+export declare function closePeerConnections(...pcs: (RTCPeerConnection | undefined)[]): void;

package/lib/types/wpt-media.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@gjsify/webrtc",
+  "version": "0.1.15",
+  "description": "W3C WebRTC API for GJS using GStreamer webrtcbin as the peer-connection backend",
+  "type": "module",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    },
+    "./register": {
+      "types": "./lib/types/register.d.ts",
+      "default": "./lib/esm/register.js"
+    },
+    "./register/peer-connection": {
+      "default": "./lib/esm/register/peer-connection.js"
+    },
+    "./register/data-channel": {
+      "default": "./lib/esm/register/data-channel.js"
+    },
+    "./register/error": {
+      "default": "./lib/esm/register/error.js"
+    },
+    "./register/media": {
+      "default": "./lib/esm/register/media.js"
+    },
+    "./register/media-devices": {
+      "default": "./lib/esm/register/media-devices.js"
+    }
+  },
+  "sideEffects": [
+    "./lib/esm/register.js",
+    "./lib/esm/register/*.js"
+  ],
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc",
+    "build:test": "yarn build:test:gjs",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:gjs",
+    "test:gjs": "gjsify run test.gjs.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "webrtc",
+    "gstreamer",
+    "webrtcbin",
+    "rtc",
+    "data-channel",
+    "peer-connection"
+  ],
+  "dependencies": {
+    "@gjsify/dom-events": "^0.1.15",
+    "@gjsify/dom-exception": "^0.1.15",
+    "@gjsify/webrtc-native": "^0.1.15"
+  },
+  "devDependencies": {
+    "@girs/gjs": "^4.0.0-rc.3",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-rc.3",
+    "@girs/gobject-2.0": "^2.88.0-4.0.0-rc.3",
+    "@girs/gst-1.0": "^1.28.1-4.0.0-rc.3",
+    "@girs/gstsdp-1.0": "^1.0.0-4.0.0-rc.3",
+    "@girs/gstwebrtc-1.0": "^1.0.0-4.0.0-rc.3",
+    "@gjsify/cli": "^0.1.15",
+    "@gjsify/unit": "^0.1.15",
+    "@types/node": "^25.6.0",
+    "typescript": "^6.0.2"
+  }
+}