@gjsify/webrtc 0.3.13 → 0.3.14

package/lib/esm/rtc-peer-connection.js

@@ -1,861 +1,812 @@
-import GLib from "gi://GLib?version=2.0";
-import GObject from "gi://GObject?version=2.0";
-import GstWebRTC from "gi://GstWebRTC?version=1.0";
-import {
-  WebrtcbinBridge
-} from "@gjsify/webrtc-native";
-import { ensureWebrtcbinAvailable, Gst } from "./gst-init.js";
+import { Gst, ensureWebrtcbinAvailable } from "./gst-init.js";
+import { MediaStreamTrack } from "./media-stream-track.js";
+import { MediaStream } from "./media-stream.js";
+import { gstToConnectionState, gstToIceConnectionState, gstToIceGatheringState, gstToSignalingState, w3cDirectionToGst } from "./gst-enum-maps.js";
+import { filterStatsByTrackId, parseGstStats } from "./gst-stats-parser.js";
 import { withGstPromise } from "./gst-utils.js";
-import {
-  gstToSignalingState,
-  gstToConnectionState,
-  gstToIceConnectionState,
-  gstToIceGatheringState,
-  w3cDirectionToGst
-} from "./gst-enum-maps.js";
-import { DOMException } from "@gjsify/dom-exception";
 import { RTCSessionDescription } from "./rtc-session-description.js";
 import { RTCIceCandidate } from "./rtc-ice-candidate.js";
+import { RTCDataChannelEvent, RTCPeerConnectionIceEvent } from "./rtc-events.js";
 import { RTCDataChannel } from "./rtc-data-channel.js";
-import { RTCPeerConnectionIceEvent, RTCDataChannelEvent } from "./rtc-events.js";
 import { RTCRtpSender } 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 { parseGstStats, filterStatsByTrackId } from "./gst-stats-parser.js";
 import { RTCIceTransport } from "./rtc-ice-transport.js";
 import { RTCDtlsTransport } from "./rtc-dtls-transport.js";
 import { RTCSctpTransport } from "./rtc-sctp-transport.js";
 import { RTCCertificate, generateCertificate } from "./rtc-certificate.js";
+import { DOMException } from "@gjsify/dom-exception";
+import GLib from "gi://GLib?version=2.0";
+import GstWebRTC from "gi://GstWebRTC?version=1.0";
+import { WebrtcbinBridge } from "@gjsify/webrtc-native";
+import GObject from "gi://GObject?version=2.0";
+
+//#region src/rtc-peer-connection.ts
+/**
+* Web-IDL `[EnforceRange] unsigned short` coercion. Coerces via ToNumber,
+* rejects values that can't be represented as an unsigned short (0..65535).
+* Matches Web-IDL §3.2.4.10: reject NaN, ±Infinity, and integers outside
+* the range; "100" → 100; fractional values are truncated.
+*
+* Reference: refs/wpt/webrtc/RTCDataChannelInit-{maxPacketLifeTime,maxRetransmits}-enforce-range.html
+*/
 function coerceUnsignedShort(name, raw) {
-  const n = Number(raw);
-  if (!Number.isFinite(n)) {
-    throw new TypeError(`createDataChannel: ${name} must be a finite number, got ${String(raw)}`);
-  }
-  const truncated = Math.trunc(n);
-  if (truncated < 0 || truncated > 65535) {
-    throw new TypeError(`createDataChannel: ${name}=${truncated} is outside the [0, 65535] range`);
-  }
-  return truncated;
+	const n = Number(raw);
+	if (!Number.isFinite(n)) {
+		throw new TypeError(`createDataChannel: ${name} must be a finite number, got ${String(raw)}`);
+	}
+	const truncated = Math.trunc(n);
+	if (truncated < 0 || truncated > 65535) {
+		throw new TypeError(`createDataChannel: ${name}=${truncated} is outside the [0, 65535] range`);
+	}
+	return truncated;
 }
 let globalCounter = 0;
-class RTCPeerConnection extends EventTarget {
-  _pipeline;
-  _webrtcbin;
-  _bridge;
-  _conf;
-  _closed = false;
-  _iceRestartNeeded = false;
-  _hasNegotiated = false;
-  _dataChannels = /* @__PURE__ */ new Map();
-  _transceivers = /* @__PURE__ */ new Map();
-  _senders = [];
-  _receivers = [];
-  _iceTransport = null;
-  _dtlsTransport = null;
-  _sctpTransport = null;
-  canTrickleIceCandidates = true;
-  constructor(configuration) {
-    super();
-    ensureWebrtcbinAvailable();
-    const [major, minor] = Gst.version();
-    if (major < 1 || major === 1 && minor < 20) {
-      throw new DOMException(
-        `@gjsify/webrtc requires GStreamer >= 1.20 (you have ${major}.${minor}). webrtcbin is only stable from 1.20 onward.`,
-        "NotSupportedError"
-      );
-    }
-    const id = ++globalCounter;
-    this._pipeline = new Gst.Pipeline({ name: `gjsify-webrtc-pipeline-${id}` });
-    const bin = Gst.ElementFactory.make("webrtcbin", `gjsify-webrtcbin-${id}`);
-    if (!bin) {
-      throw new Error("Failed to create webrtcbin element");
-    }
-    this._webrtcbin = bin;
-    this._conf = { ...configuration };
-    if (configuration?.certificates) {
-      for (const cert of configuration.certificates) {
-        if (cert instanceof RTCCertificate && cert.expires <= Date.now()) {
-          throw new DOMException(
-            "RTCPeerConnection: one of the provided certificates has expired",
-            "InvalidAccessError"
-          );
-        }
-      }
-    }
-    this._applyIceServers(configuration?.iceServers ?? []);
-    this._applyIceTransportPolicy(configuration?.iceTransportPolicy);
-    this._applyBundlePolicy(configuration?.bundlePolicy);
-    this._pipeline.add(this._webrtcbin);
-    this._bridge = new WebrtcbinBridge({ bin: this._webrtcbin });
-    this._bridge.connect("negotiation-needed", () => this._handleNegotiationNeeded());
-    this._bridge.connect("icecandidate", (_b, mlineIndex, candidate) => this._handleIceCandidate(mlineIndex, candidate));
-    this._bridge.connect("datachannel", (_b, channelBridge) => this._handleDataChannel(channelBridge));
-    this._bridge.connect("new-transceiver", (_b, gstTrans) => this._handleNewTransceiver(gstTrans));
-    this._bridge.connect("pad-added", (_b, pad) => this._handlePadAdded(pad));
-    this._bridge.connect("connection-state-changed", () => this._dispatchStateChange("connectionstatechange"));
-    this._bridge.connect("ice-connection-state-changed", () => this._dispatchStateChange("iceconnectionstatechange"));
-    this._bridge.connect("ice-gathering-state-changed", () => this._dispatchStateChange("icegatheringstatechange"));
-    this._bridge.connect("signaling-state-changed", () => this._dispatchStateChange("signalingstatechange"));
-    this._pipeline.set_state(Gst.State.PLAYING);
-  }
-  // ---- ICE server / policy config ---------------------------------------
-  _applyIceServers(iceServers) {
-    let stunSet = false;
-    for (const server of iceServers) {
-      const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
-      if (urls.length === 0) {
-        throw new SyntaxError("RTCIceServer.urls must not be empty");
-      }
-      for (const url of urls) {
-        if (typeof url !== "string" || url.length === 0) {
-          throw new TypeError("RTCIceServer.urls entries must be non-empty strings");
-        }
-        const colonIdx = url.indexOf(":");
-        if (colonIdx < 0) {
-          throw new TypeError(`Invalid ICE server URL "${url}"`);
-        }
-        const proto = url.slice(0, colonIdx + 1);
-        const hostPort = url.slice(colonIdx + 1);
-        if (proto === "stun:" || proto === "stuns:") {
-          if (stunSet) continue;
-          this._webrtcbin.stun_server = `${proto}//${hostPort}`;
-          stunSet = true;
-        } else if (proto === "turn:" || proto === "turns:") {
-          if (typeof server.username !== "string" || typeof server.credential !== "string") {
-            throw new TypeError(`TURN server credential for ${url} missing`);
-          }
-          const encUser = encodeURIComponent(server.username);
-          const encCred = encodeURIComponent(server.credential);
-          const turnUrl = `${proto}//${encUser}:${encCred}@${hostPort}`;
-          try {
-            this._webrtcbin.emit("add-turn-server", turnUrl);
-          } catch {
-            this._webrtcbin.turn_server = turnUrl;
-          }
-        } else {
-          throw new TypeError(`Unsupported ICE server protocol "${proto}"`);
-        }
-      }
-    }
-  }
-  _applyIceTransportPolicy(policy) {
-    if (!policy) return;
-    const gstPolicy = policy === "relay" ? GstWebRTC.WebRTCICETransportPolicy.RELAY : GstWebRTC.WebRTCICETransportPolicy.ALL;
-    try {
-      this._webrtcbin.ice_transport_policy = gstPolicy;
-    } catch {
-    }
-  }
-  _applyBundlePolicy(policy) {
-    if (!policy) return;
-    let gstPolicy;
-    switch (policy) {
-      case "balanced":
-        gstPolicy = GstWebRTC.WebRTCBundlePolicy.BALANCED;
-        break;
-      case "max-compat":
-        gstPolicy = GstWebRTC.WebRTCBundlePolicy.MAX_COMPAT;
-        break;
-      case "max-bundle":
-        gstPolicy = GstWebRTC.WebRTCBundlePolicy.MAX_BUNDLE;
-        break;
-      default:
-        return;
-    }
-    try {
-      this._webrtcbin.bundle_policy = gstPolicy;
-    } catch {
-    }
-  }
-  // ---- Properties --------------------------------------------------------
-  get signalingState() {
-    if (this._closed) return "closed";
-    try {
-      return gstToSignalingState(this._webrtcbin.signaling_state);
-    } catch {
-      return "stable";
-    }
-  }
-  get connectionState() {
-    if (this._closed) return "closed";
-    try {
-      return gstToConnectionState(this._webrtcbin.connection_state);
-    } catch {
-      return "new";
-    }
-  }
-  get iceConnectionState() {
-    if (this._closed) return "closed";
-    try {
-      return gstToIceConnectionState(this._webrtcbin.ice_connection_state);
-    } catch {
-      return "new";
-    }
-  }
-  get iceGatheringState() {
-    try {
-      return gstToIceGatheringState(this._webrtcbin.ice_gathering_state);
-    } catch {
-      return "new";
-    }
-  }
-  _descProp(prop) {
-    try {
-      const desc = this._webrtcbin[prop];
-      if (!desc) return null;
-      return RTCSessionDescription.fromGstDesc(desc);
-    } catch {
-      return null;
-    }
-  }
-  get localDescription() {
-    return this._descProp("local_description");
-  }
-  get remoteDescription() {
-    return this._descProp("remote_description");
-  }
-  get currentLocalDescription() {
-    return this._descProp("current_local_description");
-  }
-  get currentRemoteDescription() {
-    return this._descProp("current_remote_description");
-  }
-  get pendingLocalDescription() {
-    return this._descProp("pending_local_description");
-  }
-  get pendingRemoteDescription() {
-    return this._descProp("pending_remote_description");
-  }
-  get sctp() {
-    return this._sctpTransport;
-  }
-  get peerIdentity() {
-    return Promise.reject(new TypeError("peerIdentity assertions are not implemented"));
-  }
-  get idpErrorInfo() {
-    return null;
-  }
-  get idpLoginUrl() {
-    return null;
-  }
-  // ---- Core methods ------------------------------------------------------
-  _rejectIfClosed(method) {
-    if (!this._closed) return;
-    throw new DOMException(
-      `RTCPeerConnection.${method}: connection is closed`,
-      "InvalidStateError"
-    );
-  }
-  async createOffer(_options) {
-    this._rejectIfClosed("createOffer");
-    const opts = Gst.Structure.new_empty("offer-options");
-    if (this._iceRestartNeeded) {
-      this._setStructureField(opts, "ice-restart", "boolean", true);
-      this._iceRestartNeeded = false;
-    }
-    const reply = await withGstPromise((p) => {
-      this._webrtcbin.emit("create-offer", opts, p);
-    });
-    const desc = reply.get_value("offer");
-    return RTCSessionDescription.fromGstDesc(desc).toJSON();
-  }
-  async createAnswer(_options) {
-    this._rejectIfClosed("createAnswer");
-    const opts = Gst.Structure.new_empty("answer-options");
-    const reply = await withGstPromise((p) => {
-      this._webrtcbin.emit("create-answer", opts, p);
-    });
-    const desc = reply.get_value("answer");
-    return RTCSessionDescription.fromGstDesc(desc).toJSON();
-  }
-  async setLocalDescription(description) {
-    this._rejectIfClosed("setLocalDescription");
-    if (!description || !description.type || !description.sdp) {
-      const state = this.signalingState;
-      if (state === "stable" || state === "have-local-offer") {
-        description = await this.createOffer();
-      } else if (state === "have-remote-offer" || state === "have-remote-pranswer") {
-        description = await this.createAnswer();
-      } else {
-        throw new DOMException(
-          `setLocalDescription: cannot auto-create SDP in signalingState '${state}'`,
-          "InvalidStateError"
-        );
-      }
-    }
-    this._pipeline.set_state(Gst.State.PLAYING);
-    const gstDesc = new RTCSessionDescription(description).toGstDesc();
-    await withGstPromise((p) => {
-      this._webrtcbin.emit("set-local-description", gstDesc, p);
-    });
-  }
-  async setRemoteDescription(description) {
-    this._rejectIfClosed("setRemoteDescription");
-    if (!description || !description.sdp || !description.type) {
-      throw new TypeError("setRemoteDescription requires an RTCSessionDescriptionInit with sdp and type");
-    }
-    this._pipeline.set_state(Gst.State.PLAYING);
-    const gstDesc = new RTCSessionDescription(description).toGstDesc();
-    await withGstPromise((p) => {
-      this._webrtcbin.emit("set-remote-description", gstDesc, p);
-    });
-    if (this.signalingState === "stable") {
-      this._hasNegotiated = true;
-    }
-  }
-  async addIceCandidate(candidate) {
-    this._rejectIfClosed("addIceCandidate");
-    if (!candidate) return;
-    const { candidate: cand, sdpMLineIndex } = candidate;
-    if (typeof cand !== "string" || typeof sdpMLineIndex !== "number") return;
-    this._webrtcbin.emit("add-ice-candidate", sdpMLineIndex, cand);
-  }
-  createDataChannel(label, options = {}) {
-    if (this._closed) {
-      throw new DOMException(
-        "Cannot create a data channel on a closed RTCPeerConnection",
-        "InvalidStateError"
-      );
-    }
-    if (typeof label !== "string") {
-      throw new TypeError("createDataChannel: label must be a string");
-    }
-    if (new TextEncoder().encode(label).byteLength > 65535) {
-      throw new TypeError("createDataChannel: label too long (> 65535 bytes)");
-    }
-    const maxPacketLifeTime = options.maxPacketLifeTime == null ? void 0 : coerceUnsignedShort("maxPacketLifeTime", options.maxPacketLifeTime);
-    const maxRetransmits = options.maxRetransmits == null ? void 0 : coerceUnsignedShort("maxRetransmits", options.maxRetransmits);
-    const id = options.id == null ? void 0 : coerceUnsignedShort("id", options.id);
-    if (maxPacketLifeTime !== void 0 && maxRetransmits !== void 0) {
-      throw new TypeError("createDataChannel: maxPacketLifeTime and maxRetransmits are mutually exclusive");
-    }
-    if (options.negotiated === true && id === void 0) {
-      throw new TypeError("createDataChannel: negotiated=true requires an id");
-    }
-    if (id === 65535) {
-      throw new TypeError("createDataChannel: id 65535 is reserved");
-    }
-    const gstOpts = Gst.Structure.new_empty("data-channel-opts");
-    this._setStructureField(gstOpts, "ordered", "boolean", options.ordered);
-    this._setStructureField(gstOpts, "max-packet-lifetime", "int", maxPacketLifeTime);
-    this._setStructureField(gstOpts, "max-retransmits", "int", maxRetransmits);
-    this._setStructureField(gstOpts, "protocol", "string", options.protocol);
-    this._setStructureField(gstOpts, "negotiated", "boolean", options.negotiated);
-    this._setStructureField(gstOpts, "id", "int", id);
-    let native = null;
-    try {
-      native = this._webrtcbin.emit("create-data-channel", label, gstOpts);
-    } catch (err) {
-      throw new Error(`create-data-channel failed: ${err?.message ?? err}`);
-    }
-    if (!native) {
-      throw new Error("webrtcbin returned null data channel (check id/label/options)");
-    }
-    this._ensureSctpTransport();
-    const js = new RTCDataChannel(native);
-    this._dataChannels.set(native, js);
-    js.addEventListener("close", () => {
-      this._dataChannels.delete(native);
-    });
-    return js;
-  }
-  _setStructureField(structure, name, type, value) {
-    if (value == null) return;
-    const gvalue = new GObject.Value();
-    if (type === "boolean") {
-      gvalue.init(GObject.TYPE_BOOLEAN);
-      gvalue.set_boolean(Boolean(value));
-    } else if (type === "int") {
-      gvalue.init(GObject.TYPE_INT);
-      gvalue.set_int(Number(value));
-    } else if (type === "string") {
-      gvalue.init(GObject.TYPE_STRING);
-      gvalue.set_string(String(value));
-    }
-    structure.set_value(name, gvalue);
-    gvalue.unset();
-  }
-  getConfiguration() {
-    return { ...this._conf };
-  }
-  close() {
-    if (this._closed) return;
-    this._closed = true;
-    GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
-      try {
-        this._pipeline.set_state(Gst.State.NULL);
-      } catch {
-      }
-      for (const ch of this._dataChannels.values()) {
-        try {
-          ch._disconnectSignals();
-        } catch {
-        }
-      }
-      this._dataChannels.clear();
-      for (const s of this._senders) {
-        try {
-          s._teardownPipeline();
-        } catch {
-        }
-      }
-      for (const r of this._receivers) {
-        try {
-          r._dispose();
-        } catch {
-        }
-      }
-      this._transceivers.clear();
-      this._senders.length = 0;
-      this._receivers.length = 0;
-      if (this._dtlsTransport) this._dtlsTransport._setState("closed");
-      if (this._iceTransport) this._iceTransport._setState("closed");
-      if (this._sctpTransport) this._sctpTransport._setState("closed");
-      try {
-        this._bridge.dispose_bridge();
-      } catch {
-      }
-      return GLib.SOURCE_REMOVE;
-    });
-  }
-  // ---- Media / Transceiver API (Phase 2) ----------------------------------
-  addTransceiver(trackOrKind, init) {
-    this._rejectIfClosed("addTransceiver");
-    let kind;
-    if (typeof trackOrKind === "string") {
-      if (trackOrKind !== "audio" && trackOrKind !== "video") {
-        throw new TypeError(
-          `Failed to execute 'addTransceiver' on 'RTCPeerConnection': The provided value '${trackOrKind}' is not a valid enum value of type MediaStreamTrackKind.`
-        );
-      }
-      kind = trackOrKind;
-    } else if (trackOrKind instanceof MediaStreamTrack) {
-      kind = trackOrKind.kind;
-    } else {
-      throw new TypeError(
-        "Failed to execute 'addTransceiver' on 'RTCPeerConnection': parameter 1 is not of type 'MediaStreamTrack' or a valid MediaStreamTrackKind."
-      );
-    }
-    if (init?.sendEncodings) {
-      const rids = /* @__PURE__ */ new Set();
-      for (const enc of init.sendEncodings) {
-        if (enc.rid !== void 0) {
-          if (typeof enc.rid !== "string" || enc.rid.length === 0 || enc.rid.length > 16 || !/^[a-zA-Z0-9]+$/.test(enc.rid)) {
-            throw new TypeError(`Invalid RID value: ${enc.rid}`);
-          }
-          if (rids.has(enc.rid)) {
-            throw new TypeError(`Duplicate RID: ${enc.rid}`);
-          }
-          rids.add(enc.rid);
-        }
-        if (enc.scaleResolutionDownBy !== void 0 && enc.scaleResolutionDownBy < 1) {
-          throw new RangeError("scaleResolutionDownBy must be >= 1.0");
-        }
-      }
-    }
-    const direction = init?.direction ?? "sendrecv";
-    const validDirections = ["sendrecv", "sendonly", "recvonly", "inactive"];
-    if (!validDirections.includes(direction)) {
-      throw new TypeError(
-        `Failed to execute 'addTransceiver' on 'RTCPeerConnection': The provided value '${direction}' is not a valid enum value of type RTCRtpTransceiverDirection.`
-      );
-    }
-    const hasGstSource = trackOrKind instanceof MediaStreamTrack && trackOrKind._gstSource;
-    const wantsSend = direction === "sendrecv" || direction === "sendonly";
-    let gstTrans;
-    let jsTrans;
-    if (hasGstSource && wantsSend) {
-      const track = trackOrKind;
-      const sender = new RTCRtpSender(null, this._pipeline, this._webrtcbin);
-      sender._kind = kind;
-      sender._onPipelineChanged = (newPipeline) => {
-        this._pipeline = newPipeline;
-      };
-      sender._setTrack(track);
-      sender._wirePipeline(track);
-      gstTrans = this._findNewGstTransceiver();
-      if (!gstTrans) {
-        throw new Error("webrtcbin did not create a transceiver for the send pad");
-      }
-      const gstReceiver = gstTrans.receiver ?? null;
-      const receiver = new RTCRtpReceiver(kind, gstReceiver, this._pipeline);
-      const statsDelegate = (t) => this.getStats(t);
-      sender._getStatsForTrack = statsDelegate;
-      receiver._getStatsForTrack = statsDelegate;
-      const dtls = this._ensureTransports();
-      sender._transport = dtls;
-      receiver._transport = dtls;
-      jsTrans = new RTCRtpTransceiver(gstTrans, sender, receiver);
-      sender._transceiver = jsTrans;
-      this._transceivers.set(gstTrans, jsTrans);
-      this._senders.push(sender);
-      this._receivers.push(receiver);
-      gstTrans.direction = w3cDirectionToGst(direction);
-    } else {
-      const caps = Gst.Caps.from_string(`application/x-rtp,media=${kind}`);
-      const createDirection = direction === "inactive" ? w3cDirectionToGst("sendrecv") : w3cDirectionToGst(direction);
-      gstTrans = this._webrtcbin.emit("add-transceiver", createDirection, caps);
-      if (!gstTrans) {
-        throw new Error("webrtcbin did not create a transceiver");
-      }
-      jsTrans = this._transceivers.get(gstTrans);
-      if (!jsTrans) {
-        jsTrans = this._createTransceiverWrapper(gstTrans);
-      }
-      gstTrans.direction = w3cDirectionToGst(direction);
-      if (trackOrKind instanceof MediaStreamTrack) {
-        jsTrans.sender._setTrack(trackOrKind);
-      }
-    }
-    return jsTrans;
-  }
-  addTrack(track, ..._streams) {
-    this._rejectIfClosed("addTrack");
-    if (!(track instanceof MediaStreamTrack)) {
-      throw new TypeError(
-        "Failed to execute 'addTrack' on 'RTCPeerConnection': parameter 1 is not a MediaStreamTrack"
-      );
-    }
-    const existing = this._senders.find((s) => s.track === track);
-    if (existing) {
-      throw new DOMException(
-        "Track already exists in a sender of this connection",
-        "InvalidAccessError"
-      );
-    }
-    let reusable;
-    for (const t of this._transceivers.values()) {
-      if (t.sender.track === null && !t.stopped && t.direction !== "stopped" && t.receiver.track.kind === track.kind) {
-        const dir = t.direction;
-        if (dir === "recvonly" || dir === "inactive") {
-          reusable = t;
-          break;
-        }
-      }
-    }
-    if (reusable) {
-      const dir = reusable.direction;
-      reusable.direction = dir === "recvonly" ? "sendrecv" : "sendonly";
-      reusable.sender._setTrack(track);
-      return reusable.sender;
-    }
-    const transceiver = this.addTransceiver(track, { direction: "sendrecv" });
-    return transceiver.sender;
-  }
-  removeTrack(sender) {
-    this._rejectIfClosed("removeTrack");
-    if (!this._senders.includes(sender)) {
-      throw new DOMException(
-        "sender was not created by this connection",
-        "InvalidAccessError"
-      );
-    }
-    sender._setTrack(null);
-  }
-  getSenders() {
-    return [...this._senders];
-  }
-  getReceivers() {
-    return [...this._receivers];
-  }
-  getTransceivers() {
-    return [...this._transceivers.values()];
-  }
-  async getStats(selector) {
-    this._rejectIfClosed("getStats");
-    if (selector != null && selector instanceof MediaStreamTrack) {
-      const hasSender = this._senders.some((s) => s.track === selector);
-      const hasReceiver = this._receivers.some((r) => r.track === selector);
-      if (!hasSender && !hasReceiver) {
-        throw new DOMException(
-          "The selector track is not associated with a sender or receiver of this connection",
-          "InvalidAccessError"
-        );
-      }
-    }
-    const reply = await withGstPromise((p) => {
-      this._webrtcbin.emit("get-stats", null, p);
-    });
-    const report = parseGstStats(reply);
-    if (selector != null && selector instanceof MediaStreamTrack) {
-      return filterStatsByTrackId(report, selector.id);
-    }
-    return report;
-  }
-  // ---- ICE restart / reconfiguration (Phase 4.4) ---------------------------
-  restartIce() {
-    if (this._closed) return;
-    this._iceRestartNeeded = true;
-    if (this._hasNegotiated) {
-      Promise.resolve().then(() => {
-        if (this._closed) return;
-        this._handleNegotiationNeeded();
-      });
-    }
-  }
-  setConfiguration(configuration) {
-    this._rejectIfClosed("setConfiguration");
-    if (configuration.bundlePolicy && configuration.bundlePolicy !== (this._conf.bundlePolicy ?? "balanced")) {
-      throw new DOMException(
-        "setConfiguration: bundlePolicy cannot be changed",
-        "InvalidModificationError"
-      );
-    }
-    if (configuration.rtcpMuxPolicy && configuration.rtcpMuxPolicy !== (this._conf.rtcpMuxPolicy ?? "require")) {
-      throw new DOMException(
-        "setConfiguration: rtcpMuxPolicy cannot be changed",
-        "InvalidModificationError"
-      );
-    }
-    if (configuration.iceServers) {
-      this._applyIceServers(configuration.iceServers);
-    }
-    if (configuration.iceTransportPolicy) {
-      this._applyIceTransportPolicy(configuration.iceTransportPolicy);
-    }
-    this._conf = { ...this._conf, ...configuration };
-  }
-  getIdentityAssertion() {
-    return Promise.reject(new Error("getIdentityAssertion is not implemented"));
-  }
-  // ---- Transceiver helper -------------------------------------------------
-  /** Find a GstWebRTCRTPTransceiver not yet in our map (created by request_pad_simple). */
-  _findNewGstTransceiver() {
-    for (let i = 0; ; i++) {
-      const gt = this._webrtcbin.emit("get-transceiver", i);
-      if (!gt) return null;
-      if (!this._transceivers.has(gt)) return gt;
-    }
-  }
-  /** Lazily create the shared DTLS and ICE transport instances (max-bundle → one pair). */
-  _ensureTransports() {
-    if (!this._dtlsTransport) {
-      this._iceTransport = new RTCIceTransport();
-      this._dtlsTransport = new RTCDtlsTransport(this._iceTransport);
-    }
-    return this._dtlsTransport;
-  }
-  /** Create the SCTP transport when a data channel is first negotiated. */
-  _ensureSctpTransport() {
-    if (this._sctpTransport) return;
-    const dtls = this._ensureTransports();
-    this._sctpTransport = new RTCSctpTransport(dtls);
-  }
-  _createTransceiverWrapper(gstTrans) {
-    let kind = "audio";
-    try {
-      const gstKind = gstTrans.kind;
-      if (gstKind === GstWebRTC.WebRTCKind.VIDEO) kind = "video";
-    } catch {
-    }
-    const gstReceiver = gstTrans.receiver ?? null;
-    const gstSender = gstTrans.sender ?? null;
-    const receiver = new RTCRtpReceiver(kind, gstReceiver, this._pipeline);
-    const sender = new RTCRtpSender(gstSender, this._pipeline, this._webrtcbin);
-    sender._kind = kind;
-    sender._onPipelineChanged = (newPipeline) => {
-      this._pipeline = newPipeline;
-    };
-    const statsDelegate = (track) => this.getStats(track);
-    sender._getStatsForTrack = statsDelegate;
-    receiver._getStatsForTrack = statsDelegate;
-    const dtls = this._ensureTransports();
-    sender._transport = dtls;
-    receiver._transport = dtls;
-    try {
-      const mline = gstTrans.mlineindex;
-      if (typeof mline === "number" && mline >= 0) {
-        sender._setMlineIndex(mline);
-      }
-    } catch {
-    }
-    const transceiver = new RTCRtpTransceiver(gstTrans, sender, receiver);
-    sender._transceiver = transceiver;
-    this._transceivers.set(gstTrans, transceiver);
-    this._senders.push(sender);
-    this._receivers.push(receiver);
-    return transceiver;
-  }
-  // ---- Signal handlers ---------------------------------------------------
-  // The WebrtcbinBridge (webrtc-native) has already marshalled these from
-  // the GStreamer streaming thread onto the GLib main context, so we can
-  // synchronously dispatch from here.
-  _handleNegotiationNeeded() {
-    const ev = new Event("negotiationneeded");
-    this._onnegotiationneeded?.call(this, ev);
-    this.dispatchEvent(ev);
-  }
-  _handleIceCandidate(sdpMLineIndex, candidate) {
-    const cand = new RTCIceCandidate({ candidate, sdpMLineIndex });
-    const ev = new RTCPeerConnectionIceEvent("icecandidate", { candidate: cand });
-    this._onicecandidate?.call(this, ev);
-    this.dispatchEvent(ev);
-  }
-  _handleNewTransceiver(gstTrans) {
-    if (this._closed) return;
-    if (this._transceivers.has(gstTrans)) return;
-    this._createTransceiverWrapper(gstTrans);
-  }
-  _handlePadAdded(pad) {
-    if (this._closed) return;
-    if (pad.direction !== Gst.PadDirection.SRC) return;
-    const gstTrans = pad.transceiver;
-    if (!gstTrans) return;
-    let jsTrans = this._transceivers.get(gstTrans);
-    if (!jsTrans) {
-      jsTrans = this._createTransceiverWrapper(gstTrans);
-    }
-    jsTrans.receiver._connectToPad(pad);
-    const stream = new MediaStream([jsTrans.receiver.track]);
-    const ev = new RTCTrackEvent("track", {
-      receiver: jsTrans.receiver,
-      track: jsTrans.receiver.track,
-      streams: [stream],
-      transceiver: jsTrans
-    });
-    this._ontrack?.call(this, ev);
-    this.dispatchEvent(ev);
-  }
-  _handleDataChannel(channelBridge) {
-    this._ensureSctpTransport();
-    const native = channelBridge.channel;
-    let js = this._dataChannels.get(native);
-    if (!js) {
-      js = new RTCDataChannel(channelBridge);
-      this._dataChannels.set(native, js);
-      js.addEventListener("close", () => {
-        this._dataChannels.delete(native);
-      });
-    }
-    const ev = new RTCDataChannelEvent("datachannel", { channel: js });
-    this._ondatachannel?.call(this, ev);
-    this.dispatchEvent(ev);
-  }
-  _dispatchStateChange(type) {
-    if (type === "connectionstatechange") {
-      this._syncDtlsState();
-    } else if (type === "iceconnectionstatechange") {
-      this._syncIceState();
-    } else if (type === "icegatheringstatechange") {
-      this._syncIceGatheringState();
-    }
-    const ev = new Event(type);
-    switch (type) {
-      case "connectionstatechange":
-        this._onconnectionstatechange?.call(this, ev);
-        break;
-      case "iceconnectionstatechange":
-        this._oniceconnectionstatechange?.call(this, ev);
-        break;
-      case "icegatheringstatechange":
-        this._onicegatheringstatechange?.call(this, ev);
-        break;
-      case "signalingstatechange":
-        this._onsignalingstatechange?.call(this, ev);
-        break;
-    }
-    this.dispatchEvent(ev);
-  }
-  /** Map PC connection state → DTLS transport state. */
-  _syncDtlsState() {
-    if (!this._dtlsTransport) return;
-    const pcState = this.connectionState;
-    const dtlsMap = {
-      "new": "new",
-      "connecting": "connecting",
-      "connected": "connected",
-      "disconnected": "connected",
-      // DTLS stays connected even if ICE disconnects
-      "failed": "failed",
-      "closed": "closed"
-    };
-    this._dtlsTransport._setState(dtlsMap[pcState] ?? "new");
-    if (pcState === "connected" && this._sctpTransport) {
-      this._sctpTransport._setState("connected");
-    }
-  }
-  /** Map PC ICE connection state → ICE transport state. */
-  _syncIceState() {
-    if (!this._iceTransport) return;
-    const iceState = this.iceConnectionState;
-    this._iceTransport._setState(iceState);
-  }
-  /** Map PC ICE gathering state → ICE transport gathering state. */
-  _syncIceGatheringState() {
-    if (!this._iceTransport) return;
-    const gatheringState = this.iceGatheringState;
-    this._iceTransport._setGatheringState(gatheringState);
-  }
-  // ---- on<event> attribute handlers --------------------------------------
-  _onconnectionstatechange = null;
-  _ondatachannel = null;
-  _onicecandidate = null;
-  _oniceconnectionstatechange = null;
-  _onicegatheringstatechange = null;
-  _onnegotiationneeded = null;
-  _onsignalingstatechange = null;
-  get onconnectionstatechange() {
-    return this._onconnectionstatechange;
-  }
-  set onconnectionstatechange(v) {
-    this._onconnectionstatechange = v;
-  }
-  get ondatachannel() {
-    return this._ondatachannel;
-  }
-  set ondatachannel(v) {
-    this._ondatachannel = v;
-  }
-  get onicecandidate() {
-    return this._onicecandidate;
-  }
-  set onicecandidate(v) {
-    this._onicecandidate = v;
-  }
-  get oniceconnectionstatechange() {
-    return this._oniceconnectionstatechange;
-  }
-  set oniceconnectionstatechange(v) {
-    this._oniceconnectionstatechange = v;
-  }
-  get onicegatheringstatechange() {
-    return this._onicegatheringstatechange;
-  }
-  set onicegatheringstatechange(v) {
-    this._onicegatheringstatechange = v;
-  }
-  get onnegotiationneeded() {
-    return this._onnegotiationneeded;
-  }
-  set onnegotiationneeded(v) {
-    this._onnegotiationneeded = v;
-  }
-  get onsignalingstatechange() {
-    return this._onsignalingstatechange;
-  }
-  set onsignalingstatechange(v) {
-    this._onsignalingstatechange = v;
-  }
-  _ontrack = null;
-  get ontrack() {
-    return this._ontrack;
-  }
-  set ontrack(v) {
-    this._ontrack = v;
-  }
-  get onicecandidateerror() {
-    return null;
-  }
-  set onicecandidateerror(_v) {
-  }
-  // ---- Certificate management (Phase 4.7) --------------------------------
-  static generateCertificate(keygenAlgorithm) {
-    return generateCertificate(keygenAlgorithm);
-  }
-}
-export {
-  RTCPeerConnection
+var RTCPeerConnection = class extends EventTarget {
+	_pipeline;
+	_webrtcbin;
+	_bridge;
+	_conf;
+	_closed = false;
+	_iceRestartNeeded = false;
+	_hasNegotiated = false;
+	_dataChannels = new Map();
+	_transceivers = new Map();
+	_senders = [];
+	_receivers = [];
+	_iceTransport = null;
+	_dtlsTransport = null;
+	_sctpTransport = null;
+	canTrickleIceCandidates = true;
+	constructor(configuration) {
+		super();
+		ensureWebrtcbinAvailable();
+		const [major, minor] = Gst.version();
+		if (major < 1 || major === 1 && minor < 20) {
+			throw new DOMException(`@gjsify/webrtc requires GStreamer >= 1.20 (you have ${major}.${minor}). webrtcbin is only stable from 1.20 onward.`, "NotSupportedError");
+		}
+		const id = ++globalCounter;
+		this._pipeline = new Gst.Pipeline({ name: `gjsify-webrtc-pipeline-${id}` });
+		const bin = Gst.ElementFactory.make("webrtcbin", `gjsify-webrtcbin-${id}`);
+		if (!bin) {
+			throw new Error("Failed to create webrtcbin element");
+		}
+		this._webrtcbin = bin;
+		this._conf = { ...configuration };
+		if (configuration?.certificates) {
+			for (const cert of configuration.certificates) {
+				if (cert instanceof RTCCertificate && cert.expires <= Date.now()) {
+					throw new DOMException("RTCPeerConnection: one of the provided certificates has expired", "InvalidAccessError");
+				}
+			}
+		}
+		this._applyIceServers(configuration?.iceServers ?? []);
+		this._applyIceTransportPolicy(configuration?.iceTransportPolicy);
+		this._applyBundlePolicy(configuration?.bundlePolicy);
+		this._pipeline.add(this._webrtcbin);
+		this._bridge = new WebrtcbinBridge({ bin: this._webrtcbin });
+		this._bridge.connect("negotiation-needed", () => this._handleNegotiationNeeded());
+		this._bridge.connect("icecandidate", (_b, mlineIndex, candidate) => this._handleIceCandidate(mlineIndex, candidate));
+		this._bridge.connect("datachannel", (_b, channelBridge) => this._handleDataChannel(channelBridge));
+		this._bridge.connect("new-transceiver", (_b, gstTrans) => this._handleNewTransceiver(gstTrans));
+		this._bridge.connect("pad-added", (_b, pad) => this._handlePadAdded(pad));
+		this._bridge.connect("connection-state-changed", () => this._dispatchStateChange("connectionstatechange"));
+		this._bridge.connect("ice-connection-state-changed", () => this._dispatchStateChange("iceconnectionstatechange"));
+		this._bridge.connect("ice-gathering-state-changed", () => this._dispatchStateChange("icegatheringstatechange"));
+		this._bridge.connect("signaling-state-changed", () => this._dispatchStateChange("signalingstatechange"));
+		this._pipeline.set_state(Gst.State.PLAYING);
+	}
+	_applyIceServers(iceServers) {
+		let stunSet = false;
+		for (const server of iceServers) {
+			const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
+			if (urls.length === 0) {
+				throw new SyntaxError("RTCIceServer.urls must not be empty");
+			}
+			for (const url of urls) {
+				if (typeof url !== "string" || url.length === 0) {
+					throw new TypeError("RTCIceServer.urls entries must be non-empty strings");
+				}
+				const colonIdx = url.indexOf(":");
+				if (colonIdx < 0) {
+					throw new TypeError(`Invalid ICE server URL "${url}"`);
+				}
+				const proto = url.slice(0, colonIdx + 1);
+				const hostPort = url.slice(colonIdx + 1);
+				if (proto === "stun:" || proto === "stuns:") {
+					if (stunSet) continue;
+					this._webrtcbin.stun_server = `${proto}//${hostPort}`;
+					stunSet = true;
+				} else if (proto === "turn:" || proto === "turns:") {
+					if (typeof server.username !== "string" || typeof server.credential !== "string") {
+						throw new TypeError(`TURN server credential for ${url} missing`);
+					}
+					const encUser = encodeURIComponent(server.username);
+					const encCred = encodeURIComponent(server.credential);
+					const turnUrl = `${proto}//${encUser}:${encCred}@${hostPort}`;
+					try {
+						this._webrtcbin.emit("add-turn-server", turnUrl);
+					} catch {
+						this._webrtcbin.turn_server = turnUrl;
+					}
+				} else {
+					throw new TypeError(`Unsupported ICE server protocol "${proto}"`);
+				}
+			}
+		}
+	}
+	_applyIceTransportPolicy(policy) {
+		if (!policy) return;
+		const gstPolicy = policy === "relay" ? GstWebRTC.WebRTCICETransportPolicy.RELAY : GstWebRTC.WebRTCICETransportPolicy.ALL;
+		try {
+			this._webrtcbin.ice_transport_policy = gstPolicy;
+		} catch {}
+	}
+	_applyBundlePolicy(policy) {
+		if (!policy) return;
+		let gstPolicy;
+		switch (policy) {
+			case "balanced":
+				gstPolicy = GstWebRTC.WebRTCBundlePolicy.BALANCED;
+				break;
+			case "max-compat":
+				gstPolicy = GstWebRTC.WebRTCBundlePolicy.MAX_COMPAT;
+				break;
+			case "max-bundle":
+				gstPolicy = GstWebRTC.WebRTCBundlePolicy.MAX_BUNDLE;
+				break;
+			default: return;
+		}
+		try {
+			this._webrtcbin.bundle_policy = gstPolicy;
+		} catch {}
+	}
+	get signalingState() {
+		if (this._closed) return "closed";
+		try {
+			return gstToSignalingState(this._webrtcbin.signaling_state);
+		} catch {
+			return "stable";
+		}
+	}
+	get connectionState() {
+		if (this._closed) return "closed";
+		try {
+			return gstToConnectionState(this._webrtcbin.connection_state);
+		} catch {
+			return "new";
+		}
+	}
+	get iceConnectionState() {
+		if (this._closed) return "closed";
+		try {
+			return gstToIceConnectionState(this._webrtcbin.ice_connection_state);
+		} catch {
+			return "new";
+		}
+	}
+	get iceGatheringState() {
+		try {
+			return gstToIceGatheringState(this._webrtcbin.ice_gathering_state);
+		} catch {
+			return "new";
+		}
+	}
+	_descProp(prop) {
+		try {
+			const desc = this._webrtcbin[prop];
+			if (!desc) return null;
+			return RTCSessionDescription.fromGstDesc(desc);
+		} catch {
+			return null;
+		}
+	}
+	get localDescription() {
+		return this._descProp("local_description");
+	}
+	get remoteDescription() {
+		return this._descProp("remote_description");
+	}
+	get currentLocalDescription() {
+		return this._descProp("current_local_description");
+	}
+	get currentRemoteDescription() {
+		return this._descProp("current_remote_description");
+	}
+	get pendingLocalDescription() {
+		return this._descProp("pending_local_description");
+	}
+	get pendingRemoteDescription() {
+		return this._descProp("pending_remote_description");
+	}
+	get sctp() {
+		return this._sctpTransport;
+	}
+	get peerIdentity() {
+		return Promise.reject(new TypeError("peerIdentity assertions are not implemented"));
+	}
+	get idpErrorInfo() {
+		return null;
+	}
+	get idpLoginUrl() {
+		return null;
+	}
+	_rejectIfClosed(method) {
+		if (!this._closed) return;
+		throw new DOMException(`RTCPeerConnection.${method}: connection is closed`, "InvalidStateError");
+	}
+	async createOffer(_options) {
+		this._rejectIfClosed("createOffer");
+		const opts = Gst.Structure.new_empty("offer-options");
+		if (this._iceRestartNeeded) {
+			this._setStructureField(opts, "ice-restart", "boolean", true);
+			this._iceRestartNeeded = false;
+		}
+		const reply = await withGstPromise((p) => {
+			this._webrtcbin.emit("create-offer", opts, p);
+		});
+		const desc = reply.get_value("offer");
+		return RTCSessionDescription.fromGstDesc(desc).toJSON();
+	}
+	async createAnswer(_options) {
+		this._rejectIfClosed("createAnswer");
+		const opts = Gst.Structure.new_empty("answer-options");
+		const reply = await withGstPromise((p) => {
+			this._webrtcbin.emit("create-answer", opts, p);
+		});
+		const desc = reply.get_value("answer");
+		return RTCSessionDescription.fromGstDesc(desc).toJSON();
+	}
+	async setLocalDescription(description) {
+		this._rejectIfClosed("setLocalDescription");
+		if (!description || !description.type || !description.sdp) {
+			const state = this.signalingState;
+			if (state === "stable" || state === "have-local-offer") {
+				description = await this.createOffer();
+			} else if (state === "have-remote-offer" || state === "have-remote-pranswer") {
+				description = await this.createAnswer();
+			} else {
+				throw new DOMException(`setLocalDescription: cannot auto-create SDP in signalingState '${state}'`, "InvalidStateError");
+			}
+		}
+		this._pipeline.set_state(Gst.State.PLAYING);
+		const gstDesc = new RTCSessionDescription(description).toGstDesc();
+		await withGstPromise((p) => {
+			this._webrtcbin.emit("set-local-description", gstDesc, p);
+		});
+	}
+	async setRemoteDescription(description) {
+		this._rejectIfClosed("setRemoteDescription");
+		if (!description || !description.sdp || !description.type) {
+			throw new TypeError("setRemoteDescription requires an RTCSessionDescriptionInit with sdp and type");
+		}
+		this._pipeline.set_state(Gst.State.PLAYING);
+		const gstDesc = new RTCSessionDescription(description).toGstDesc();
+		await withGstPromise((p) => {
+			this._webrtcbin.emit("set-remote-description", gstDesc, p);
+		});
+		if (this.signalingState === "stable") {
+			this._hasNegotiated = true;
+		}
+	}
+	async addIceCandidate(candidate) {
+		this._rejectIfClosed("addIceCandidate");
+		if (!candidate) return;
+		const { candidate: cand, sdpMLineIndex } = candidate;
+		if (typeof cand !== "string" || typeof sdpMLineIndex !== "number") return;
+		this._webrtcbin.emit("add-ice-candidate", sdpMLineIndex, cand);
+	}
+	createDataChannel(label, options = {}) {
+		if (this._closed) {
+			throw new DOMException("Cannot create a data channel on a closed RTCPeerConnection", "InvalidStateError");
+		}
+		if (typeof label !== "string") {
+			throw new TypeError("createDataChannel: label must be a string");
+		}
+		if (new TextEncoder().encode(label).byteLength > 65535) {
+			throw new TypeError("createDataChannel: label too long (> 65535 bytes)");
+		}
+		const maxPacketLifeTime = options.maxPacketLifeTime == null ? undefined : coerceUnsignedShort("maxPacketLifeTime", options.maxPacketLifeTime);
+		const maxRetransmits = options.maxRetransmits == null ? undefined : coerceUnsignedShort("maxRetransmits", options.maxRetransmits);
+		const id = options.id == null ? undefined : coerceUnsignedShort("id", options.id);
+		if (maxPacketLifeTime !== undefined && maxRetransmits !== undefined) {
+			throw new TypeError("createDataChannel: maxPacketLifeTime and maxRetransmits are mutually exclusive");
+		}
+		if (options.negotiated === true && id === undefined) {
+			throw new TypeError("createDataChannel: negotiated=true requires an id");
+		}
+		if (id === 65535) {
+			throw new TypeError("createDataChannel: id 65535 is reserved");
+		}
+		const gstOpts = Gst.Structure.new_empty("data-channel-opts");
+		this._setStructureField(gstOpts, "ordered", "boolean", options.ordered);
+		this._setStructureField(gstOpts, "max-packet-lifetime", "int", maxPacketLifeTime);
+		this._setStructureField(gstOpts, "max-retransmits", "int", maxRetransmits);
+		this._setStructureField(gstOpts, "protocol", "string", options.protocol);
+		this._setStructureField(gstOpts, "negotiated", "boolean", options.negotiated);
+		this._setStructureField(gstOpts, "id", "int", id);
+		let native = null;
+		try {
+			native = this._webrtcbin.emit("create-data-channel", label, gstOpts);
+		} catch (err) {
+			throw new Error(`create-data-channel failed: ${err?.message ?? err}`);
+		}
+		if (!native) {
+			throw new Error("webrtcbin returned null data channel (check id/label/options)");
+		}
+		this._ensureSctpTransport();
+		const js = new RTCDataChannel(native);
+		this._dataChannels.set(native, js);
+		js.addEventListener("close", () => {
+			this._dataChannels.delete(native);
+		});
+		return js;
+	}
+	_setStructureField(structure, name, type, value) {
+		if (value == null) return;
+		const gvalue = new GObject.Value();
+		if (type === "boolean") {
+			gvalue.init(GObject.TYPE_BOOLEAN);
+			gvalue.set_boolean(Boolean(value));
+		} else if (type === "int") {
+			gvalue.init(GObject.TYPE_INT);
+			gvalue.set_int(Number(value));
+		} else if (type === "string") {
+			gvalue.init(GObject.TYPE_STRING);
+			gvalue.set_string(String(value));
+		}
+		structure.set_value(name, gvalue);
+		gvalue.unset();
+	}
+	getConfiguration() {
+		return { ...this._conf };
+	}
+	close() {
+		if (this._closed) return;
+		this._closed = true;
+		GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
+			try {
+				this._pipeline.set_state(Gst.State.NULL);
+			} catch {}
+			for (const ch of this._dataChannels.values()) {
+				try {
+					ch._disconnectSignals();
+				} catch {}
+			}
+			this._dataChannels.clear();
+			for (const s of this._senders) {
+				try {
+					s._teardownPipeline();
+				} catch {}
+			}
+			for (const r of this._receivers) {
+				try {
+					r._dispose();
+				} catch {}
+			}
+			this._transceivers.clear();
+			this._senders.length = 0;
+			this._receivers.length = 0;
+			if (this._dtlsTransport) this._dtlsTransport._setState("closed");
+			if (this._iceTransport) this._iceTransport._setState("closed");
+			if (this._sctpTransport) this._sctpTransport._setState("closed");
+			try {
+				this._bridge.dispose_bridge();
+			} catch {}
+			return GLib.SOURCE_REMOVE;
+		});
+	}
+	addTransceiver(trackOrKind, init) {
+		this._rejectIfClosed("addTransceiver");
+		let kind;
+		if (typeof trackOrKind === "string") {
+			if (trackOrKind !== "audio" && trackOrKind !== "video") {
+				throw new TypeError(`Failed to execute 'addTransceiver' on 'RTCPeerConnection': The provided value '${trackOrKind}' is not a valid enum value of type MediaStreamTrackKind.`);
+			}
+			kind = trackOrKind;
+		} else if (trackOrKind instanceof MediaStreamTrack) {
+			kind = trackOrKind.kind;
+		} else {
+			throw new TypeError("Failed to execute 'addTransceiver' on 'RTCPeerConnection': parameter 1 is not of type 'MediaStreamTrack' or a valid MediaStreamTrackKind.");
+		}
+		if (init?.sendEncodings) {
+			const rids = new Set();
+			for (const enc of init.sendEncodings) {
+				if (enc.rid !== undefined) {
+					if (typeof enc.rid !== "string" || enc.rid.length === 0 || enc.rid.length > 16 || !/^[a-zA-Z0-9]+$/.test(enc.rid)) {
+						throw new TypeError(`Invalid RID value: ${enc.rid}`);
+					}
+					if (rids.has(enc.rid)) {
+						throw new TypeError(`Duplicate RID: ${enc.rid}`);
+					}
+					rids.add(enc.rid);
+				}
+				if (enc.scaleResolutionDownBy !== undefined && enc.scaleResolutionDownBy < 1) {
+					throw new RangeError("scaleResolutionDownBy must be >= 1.0");
+				}
+			}
+		}
+		const direction = init?.direction ?? "sendrecv";
+		const validDirections = [
+			"sendrecv",
+			"sendonly",
+			"recvonly",
+			"inactive"
+		];
+		if (!validDirections.includes(direction)) {
+			throw new TypeError(`Failed to execute 'addTransceiver' on 'RTCPeerConnection': The provided value '${direction}' is not a valid enum value of type RTCRtpTransceiverDirection.`);
+		}
+		const hasGstSource = trackOrKind instanceof MediaStreamTrack && trackOrKind._gstSource;
+		const wantsSend = direction === "sendrecv" || direction === "sendonly";
+		let gstTrans;
+		let jsTrans;
+		if (hasGstSource && wantsSend) {
+			const track = trackOrKind;
+			const sender = new RTCRtpSender(null, this._pipeline, this._webrtcbin);
+			sender._kind = kind;
+			sender._onPipelineChanged = (newPipeline) => {
+				this._pipeline = newPipeline;
+			};
+			sender._setTrack(track);
+			sender._wirePipeline(track);
+			gstTrans = this._findNewGstTransceiver();
+			if (!gstTrans) {
+				throw new Error("webrtcbin did not create a transceiver for the send pad");
+			}
+			const gstReceiver = gstTrans.receiver ?? null;
+			const receiver = new RTCRtpReceiver(kind, gstReceiver, this._pipeline);
+			const statsDelegate = (t) => this.getStats(t);
+			sender._getStatsForTrack = statsDelegate;
+			receiver._getStatsForTrack = statsDelegate;
+			const dtls = this._ensureTransports();
+			sender._transport = dtls;
+			receiver._transport = dtls;
+			jsTrans = new RTCRtpTransceiver(gstTrans, sender, receiver);
+			sender._transceiver = jsTrans;
+			this._transceivers.set(gstTrans, jsTrans);
+			this._senders.push(sender);
+			this._receivers.push(receiver);
+			gstTrans.direction = w3cDirectionToGst(direction);
+		} else {
+			const caps = Gst.Caps.from_string(`application/x-rtp,media=${kind}`);
+			const createDirection = direction === "inactive" ? w3cDirectionToGst("sendrecv") : w3cDirectionToGst(direction);
+			gstTrans = this._webrtcbin.emit("add-transceiver", createDirection, caps);
+			if (!gstTrans) {
+				throw new Error("webrtcbin did not create a transceiver");
+			}
+			jsTrans = this._transceivers.get(gstTrans);
+			if (!jsTrans) {
+				jsTrans = this._createTransceiverWrapper(gstTrans);
+			}
+			gstTrans.direction = w3cDirectionToGst(direction);
+			if (trackOrKind instanceof MediaStreamTrack) {
+				jsTrans.sender._setTrack(trackOrKind);
+			}
+		}
+		return jsTrans;
+	}
+	addTrack(track, ..._streams) {
+		this._rejectIfClosed("addTrack");
+		if (!(track instanceof MediaStreamTrack)) {
+			throw new TypeError("Failed to execute 'addTrack' on 'RTCPeerConnection': parameter 1 is not a MediaStreamTrack");
+		}
+		const existing = this._senders.find((s) => s.track === track);
+		if (existing) {
+			throw new DOMException("Track already exists in a sender of this connection", "InvalidAccessError");
+		}
+		let reusable;
+		for (const t of this._transceivers.values()) {
+			if (t.sender.track === null && !t.stopped && t.direction !== "stopped" && t.receiver.track.kind === track.kind) {
+				const dir = t.direction;
+				if (dir === "recvonly" || dir === "inactive") {
+					reusable = t;
+					break;
+				}
+			}
+		}
+		if (reusable) {
+			const dir = reusable.direction;
+			reusable.direction = dir === "recvonly" ? "sendrecv" : "sendonly";
+			reusable.sender._setTrack(track);
+			return reusable.sender;
+		}
+		const transceiver = this.addTransceiver(track, { direction: "sendrecv" });
+		return transceiver.sender;
+	}
+	removeTrack(sender) {
+		this._rejectIfClosed("removeTrack");
+		if (!this._senders.includes(sender)) {
+			throw new DOMException("sender was not created by this connection", "InvalidAccessError");
+		}
+		sender._setTrack(null);
+	}
+	getSenders() {
+		return [...this._senders];
+	}
+	getReceivers() {
+		return [...this._receivers];
+	}
+	getTransceivers() {
+		return [...this._transceivers.values()];
+	}
+	async getStats(selector) {
+		this._rejectIfClosed("getStats");
+		if (selector != null && selector instanceof MediaStreamTrack) {
+			const hasSender = this._senders.some((s) => s.track === selector);
+			const hasReceiver = this._receivers.some((r) => r.track === selector);
+			if (!hasSender && !hasReceiver) {
+				throw new DOMException("The selector track is not associated with a sender or receiver of this connection", "InvalidAccessError");
+			}
+		}
+		const reply = await withGstPromise((p) => {
+			this._webrtcbin.emit("get-stats", null, p);
+		});
+		const report = parseGstStats(reply);
+		if (selector != null && selector instanceof MediaStreamTrack) {
+			return filterStatsByTrackId(report, selector.id);
+		}
+		return report;
+	}
+	restartIce() {
+		if (this._closed) return;
+		this._iceRestartNeeded = true;
+		if (this._hasNegotiated) {
+			Promise.resolve().then(() => {
+				if (this._closed) return;
+				this._handleNegotiationNeeded();
+			});
+		}
+	}
+	setConfiguration(configuration) {
+		this._rejectIfClosed("setConfiguration");
+		if (configuration.bundlePolicy && configuration.bundlePolicy !== (this._conf.bundlePolicy ?? "balanced")) {
+			throw new DOMException("setConfiguration: bundlePolicy cannot be changed", "InvalidModificationError");
+		}
+		if (configuration.rtcpMuxPolicy && configuration.rtcpMuxPolicy !== (this._conf.rtcpMuxPolicy ?? "require")) {
+			throw new DOMException("setConfiguration: rtcpMuxPolicy cannot be changed", "InvalidModificationError");
+		}
+		if (configuration.iceServers) {
+			this._applyIceServers(configuration.iceServers);
+		}
+		if (configuration.iceTransportPolicy) {
+			this._applyIceTransportPolicy(configuration.iceTransportPolicy);
+		}
+		this._conf = {
+			...this._conf,
+			...configuration
+		};
+	}
+	getIdentityAssertion() {
+		return Promise.reject(new Error("getIdentityAssertion is not implemented"));
+	}
+	/** Find a GstWebRTCRTPTransceiver not yet in our map (created by request_pad_simple). */
+	_findNewGstTransceiver() {
+		for (let i = 0;; i++) {
+			const gt = this._webrtcbin.emit("get-transceiver", i);
+			if (!gt) return null;
+			if (!this._transceivers.has(gt)) return gt;
+		}
+	}
+	/** Lazily create the shared DTLS and ICE transport instances (max-bundle → one pair). */
+	_ensureTransports() {
+		if (!this._dtlsTransport) {
+			this._iceTransport = new RTCIceTransport();
+			this._dtlsTransport = new RTCDtlsTransport(this._iceTransport);
+		}
+		return this._dtlsTransport;
+	}
+	/** Create the SCTP transport when a data channel is first negotiated. */
+	_ensureSctpTransport() {
+		if (this._sctpTransport) return;
+		const dtls = this._ensureTransports();
+		this._sctpTransport = new RTCSctpTransport(dtls);
+	}
+	_createTransceiverWrapper(gstTrans) {
+		let kind = "audio";
+		try {
+			const gstKind = gstTrans.kind;
+			if (gstKind === GstWebRTC.WebRTCKind.VIDEO) kind = "video";
+		} catch {}
+		const gstReceiver = gstTrans.receiver ?? null;
+		const gstSender = gstTrans.sender ?? null;
+		const receiver = new RTCRtpReceiver(kind, gstReceiver, this._pipeline);
+		const sender = new RTCRtpSender(gstSender, this._pipeline, this._webrtcbin);
+		sender._kind = kind;
+		sender._onPipelineChanged = (newPipeline) => {
+			this._pipeline = newPipeline;
+		};
+		const statsDelegate = (track) => this.getStats(track);
+		sender._getStatsForTrack = statsDelegate;
+		receiver._getStatsForTrack = statsDelegate;
+		const dtls = this._ensureTransports();
+		sender._transport = dtls;
+		receiver._transport = dtls;
+		try {
+			const mline = gstTrans.mlineindex;
+			if (typeof mline === "number" && mline >= 0) {
+				sender._setMlineIndex(mline);
+			}
+		} catch {}
+		const transceiver = new RTCRtpTransceiver(gstTrans, sender, receiver);
+		sender._transceiver = transceiver;
+		this._transceivers.set(gstTrans, transceiver);
+		this._senders.push(sender);
+		this._receivers.push(receiver);
+		return transceiver;
+	}
+	_handleNegotiationNeeded() {
+		const ev = new Event("negotiationneeded");
+		this._onnegotiationneeded?.call(this, ev);
+		this.dispatchEvent(ev);
+	}
+	_handleIceCandidate(sdpMLineIndex, candidate) {
+		const cand = new RTCIceCandidate({
+			candidate,
+			sdpMLineIndex
+		});
+		const ev = new RTCPeerConnectionIceEvent("icecandidate", { candidate: cand });
+		this._onicecandidate?.call(this, ev);
+		this.dispatchEvent(ev);
+	}
+	_handleNewTransceiver(gstTrans) {
+		if (this._closed) return;
+		if (this._transceivers.has(gstTrans)) return;
+		this._createTransceiverWrapper(gstTrans);
+	}
+	_handlePadAdded(pad) {
+		if (this._closed) return;
+		if (pad.direction !== Gst.PadDirection.SRC) return;
+		const gstTrans = pad.transceiver;
+		if (!gstTrans) return;
+		let jsTrans = this._transceivers.get(gstTrans);
+		if (!jsTrans) {
+			jsTrans = this._createTransceiverWrapper(gstTrans);
+		}
+		jsTrans.receiver._connectToPad(pad);
+		const stream = new MediaStream([jsTrans.receiver.track]);
+		const ev = new RTCTrackEvent("track", {
+			receiver: jsTrans.receiver,
+			track: jsTrans.receiver.track,
+			streams: [stream],
+			transceiver: jsTrans
+		});
+		this._ontrack?.call(this, ev);
+		this.dispatchEvent(ev);
+	}
+	_handleDataChannel(channelBridge) {
+		this._ensureSctpTransport();
+		const native = channelBridge.channel;
+		let js = this._dataChannels.get(native);
+		if (!js) {
+			js = new RTCDataChannel(channelBridge);
+			this._dataChannels.set(native, js);
+			js.addEventListener("close", () => {
+				this._dataChannels.delete(native);
+			});
+		}
+		const ev = new RTCDataChannelEvent("datachannel", { channel: js });
+		this._ondatachannel?.call(this, ev);
+		this.dispatchEvent(ev);
+	}
+	_dispatchStateChange(type) {
+		if (type === "connectionstatechange") {
+			this._syncDtlsState();
+		} else if (type === "iceconnectionstatechange") {
+			this._syncIceState();
+		} else if (type === "icegatheringstatechange") {
+			this._syncIceGatheringState();
+		}
+		const ev = new Event(type);
+		switch (type) {
+			case "connectionstatechange":
+				this._onconnectionstatechange?.call(this, ev);
+				break;
+			case "iceconnectionstatechange":
+				this._oniceconnectionstatechange?.call(this, ev);
+				break;
+			case "icegatheringstatechange":
+				this._onicegatheringstatechange?.call(this, ev);
+				break;
+			case "signalingstatechange":
+				this._onsignalingstatechange?.call(this, ev);
+				break;
+		}
+		this.dispatchEvent(ev);
+	}
+	/** Map PC connection state → DTLS transport state. */
+	_syncDtlsState() {
+		if (!this._dtlsTransport) return;
+		const pcState = this.connectionState;
+		const dtlsMap = {
+			"new": "new",
+			"connecting": "connecting",
+			"connected": "connected",
+			"disconnected": "connected",
+			"failed": "failed",
+			"closed": "closed"
+		};
+		this._dtlsTransport._setState(dtlsMap[pcState] ?? "new");
+		if (pcState === "connected" && this._sctpTransport) {
+			this._sctpTransport._setState("connected");
+		}
+	}
+	/** Map PC ICE connection state → ICE transport state. */
+	_syncIceState() {
+		if (!this._iceTransport) return;
+		const iceState = this.iceConnectionState;
+		this._iceTransport._setState(iceState);
+	}
+	/** Map PC ICE gathering state → ICE transport gathering state. */
+	_syncIceGatheringState() {
+		if (!this._iceTransport) return;
+		const gatheringState = this.iceGatheringState;
+		this._iceTransport._setGatheringState(gatheringState);
+	}
+	_onconnectionstatechange = null;
+	_ondatachannel = null;
+	_onicecandidate = null;
+	_oniceconnectionstatechange = null;
+	_onicegatheringstatechange = null;
+	_onnegotiationneeded = null;
+	_onsignalingstatechange = null;
+	get onconnectionstatechange() {
+		return this._onconnectionstatechange;
+	}
+	set onconnectionstatechange(v) {
+		this._onconnectionstatechange = v;
+	}
+	get ondatachannel() {
+		return this._ondatachannel;
+	}
+	set ondatachannel(v) {
+		this._ondatachannel = v;
+	}
+	get onicecandidate() {
+		return this._onicecandidate;
+	}
+	set onicecandidate(v) {
+		this._onicecandidate = v;
+	}
+	get oniceconnectionstatechange() {
+		return this._oniceconnectionstatechange;
+	}
+	set oniceconnectionstatechange(v) {
+		this._oniceconnectionstatechange = v;
+	}
+	get onicegatheringstatechange() {
+		return this._onicegatheringstatechange;
+	}
+	set onicegatheringstatechange(v) {
+		this._onicegatheringstatechange = v;
+	}
+	get onnegotiationneeded() {
+		return this._onnegotiationneeded;
+	}
+	set onnegotiationneeded(v) {
+		this._onnegotiationneeded = v;
+	}
+	get onsignalingstatechange() {
+		return this._onsignalingstatechange;
+	}
+	set onsignalingstatechange(v) {
+		this._onsignalingstatechange = v;
+	}
+	_ontrack = null;
+	get ontrack() {
+		return this._ontrack;
+	}
+	set ontrack(v) {
+		this._ontrack = v;
+	}
+	get onicecandidateerror() {
+		return null;
+	}
+	set onicecandidateerror(_v) {}
+	static generateCertificate(keygenAlgorithm) {
+		return generateCertificate(keygenAlgorithm);
+	}
 };
+
+//#endregion
+export { RTCPeerConnection };