@gjsify/webrtc 0.1.15

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

@@ -0,0 +1,855 @@
+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 { withGstPromise } from "./gst-utils.js";
+import {
+  gstToSignalingState,
+  gstToConnectionState,
+  gstToIceConnectionState,
+  gstToIceGatheringState,
+  w3cDirectionToGst
+} from "./gst-enum-maps.js";
+import { RTCSessionDescription } from "./rtc-session-description.js";
+import { RTCIceCandidate } from "./rtc-ice-candidate.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";
+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;
+}
+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) {
+      const DOMExc = globalThis.DOMException;
+      const msg = `@gjsify/webrtc requires GStreamer >= 1.20 (you have ${major}.${minor}). webrtcbin is only stable from 1.20 onward.`;
+      if (DOMExc) throw new DOMExc(msg, "NotSupportedError");
+      throw new Error(msg);
+    }
+    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;
+    const DOMExc = globalThis.DOMException;
+    const msg = `RTCPeerConnection.${method}: connection is closed`;
+    throw DOMExc ? new DOMExc(msg, "InvalidStateError") : new Error(msg);
+  }
+  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 {
+        const DOMExc = globalThis.DOMException;
+        const msg = `setLocalDescription: cannot auto-create SDP in signalingState '${state}'`;
+        throw DOMExc ? new DOMExc(msg, "InvalidStateError") : new Error(msg);
+      }
+    }
+    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) {
+      const DOMExc = globalThis.DOMException;
+      const msg = "Cannot create a data channel on a closed RTCPeerConnection";
+      if (DOMExc) throw new DOMExc(msg, "InvalidStateError");
+      throw new Error(msg);
+    }
+    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) {
+        const DOMExc = globalThis.DOMException;
+        const msg = "The selector track is not associated with a sender or receiver of this connection";
+        throw DOMExc ? new DOMExc(msg, "InvalidAccessError") : new Error(msg);
+      }
+    }
+    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")) {
+      const DOMExc = globalThis.DOMException;
+      const msg = "setConfiguration: bundlePolicy cannot be changed";
+      throw DOMExc ? new DOMExc(msg, "InvalidModificationError") : new Error(msg);
+    }
+    if (configuration.rtcpMuxPolicy && configuration.rtcpMuxPolicy !== (this._conf.rtcpMuxPolicy ?? "require")) {
+      const DOMExc = globalThis.DOMException;
+      const msg = "setConfiguration: rtcpMuxPolicy cannot be changed";
+      throw DOMExc ? new DOMExc(msg, "InvalidModificationError") : new Error(msg);
+    }
+    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
+};