@gjsify/webrtc 0.1.15

package/lib/esm/get-user-media.js

@@ -0,0 +1,93 @@
+import { Gst, ensureGstInit } from "./gst-init.js";
+import { MediaStreamTrack } from "./media-stream-track.js";
+import { MediaStream } from "./media-stream.js";
+async function getUserMedia(constraints) {
+  ensureGstInit();
+  if (!constraints.audio && !constraints.video) {
+    throw new TypeError(
+      "Failed to execute 'getUserMedia': At least one of audio or video must be requested"
+    );
+  }
+  const tracks = [];
+  if (constraints.audio) {
+    const audioConstraints = typeof constraints.audio === "object" ? constraints.audio : {};
+    const source = _createAudioSource();
+    const pipeline = new Gst.Pipeline();
+    pipeline.add(source);
+    const capsStr = _buildAudioCaps(audioConstraints);
+    if (capsStr) {
+      const capsfilter = Gst.ElementFactory.make("capsfilter", null);
+      capsfilter.caps = Gst.Caps.from_string(capsStr);
+      pipeline.add(capsfilter);
+      source.link(capsfilter);
+    }
+    tracks.push(new MediaStreamTrack({
+      kind: "audio",
+      label: source.name ?? "audio",
+      _gst: { source, pipeline }
+    }));
+  }
+  if (constraints.video) {
+    const videoConstraints = typeof constraints.video === "object" ? constraints.video : {};
+    const source = _createVideoSource();
+    const pipeline = new Gst.Pipeline();
+    pipeline.add(source);
+    const capsStr = _buildVideoCaps(videoConstraints);
+    if (capsStr) {
+      const capsfilter = Gst.ElementFactory.make("capsfilter", null);
+      capsfilter.caps = Gst.Caps.from_string(capsStr);
+      pipeline.add(capsfilter);
+      source.link(capsfilter);
+    }
+    tracks.push(new MediaStreamTrack({
+      kind: "video",
+      label: source.name ?? "video",
+      _gst: { source, pipeline }
+    }));
+  }
+  return new MediaStream(tracks);
+}
+function _buildAudioCaps(c) {
+  const parts = [];
+  if (c.sampleRate != null) parts.push(`rate=${Math.trunc(c.sampleRate)}`);
+  if (c.channelCount != null) parts.push(`channels=${Math.trunc(c.channelCount)}`);
+  if (parts.length === 0) return null;
+  return `audio/x-raw,${parts.join(",")}`;
+}
+function _buildVideoCaps(c) {
+  const parts = [];
+  if (c.width != null) parts.push(`width=${Math.trunc(c.width)}`);
+  if (c.height != null) parts.push(`height=${Math.trunc(c.height)}`);
+  if (c.frameRate != null) parts.push(`framerate=${Math.trunc(c.frameRate)}/1`);
+  if (parts.length === 0) return null;
+  return `video/x-raw,${parts.join(",")}`;
+}
+function _createAudioSource() {
+  for (const name of ["pipewiresrc", "pulsesrc", "autoaudiosrc"]) {
+    const el2 = Gst.ElementFactory.make(name, null);
+    if (el2) {
+      try {
+        el2.is_live = true;
+      } catch {
+      }
+      return el2;
+    }
+  }
+  const el = Gst.ElementFactory.make("audiotestsrc", null);
+  el.is_live = true;
+  el.wave = 0;
+  return el;
+}
+function _createVideoSource() {
+  for (const name of ["pipewiresrc", "v4l2src", "autovideosrc"]) {
+    const el2 = Gst.ElementFactory.make(name, null);
+    if (el2) return el2;
+  }
+  const el = Gst.ElementFactory.make("videotestsrc", null);
+  el.is_live = true;
+  el.pattern = 0;
+  return el;
+}
+export {
+  getUserMedia
+};

package/lib/esm/gst-enum-maps.js

@@ -0,0 +1,88 @@
+import GstWebRTC from "gi://GstWebRTC?version=1.0";
+const SIGNALING_STATE_MAP = {
+  [GstWebRTC.WebRTCSignalingState.STABLE]: "stable",
+  [GstWebRTC.WebRTCSignalingState.CLOSED]: "closed",
+  [GstWebRTC.WebRTCSignalingState.HAVE_LOCAL_OFFER]: "have-local-offer",
+  [GstWebRTC.WebRTCSignalingState.HAVE_REMOTE_OFFER]: "have-remote-offer",
+  [GstWebRTC.WebRTCSignalingState.HAVE_LOCAL_PRANSWER]: "have-local-pranswer",
+  [GstWebRTC.WebRTCSignalingState.HAVE_REMOTE_PRANSWER]: "have-remote-pranswer"
+};
+function gstToSignalingState(v) {
+  return SIGNALING_STATE_MAP[v] ?? "stable";
+}
+const CONNECTION_STATE_MAP = {
+  [GstWebRTC.WebRTCPeerConnectionState.NEW]: "new",
+  [GstWebRTC.WebRTCPeerConnectionState.CONNECTING]: "connecting",
+  [GstWebRTC.WebRTCPeerConnectionState.CONNECTED]: "connected",
+  [GstWebRTC.WebRTCPeerConnectionState.DISCONNECTED]: "disconnected",
+  [GstWebRTC.WebRTCPeerConnectionState.FAILED]: "failed",
+  [GstWebRTC.WebRTCPeerConnectionState.CLOSED]: "closed"
+};
+function gstToConnectionState(v) {
+  return CONNECTION_STATE_MAP[v] ?? "new";
+}
+const ICE_CONNECTION_STATE_MAP = {
+  [GstWebRTC.WebRTCICEConnectionState.NEW]: "new",
+  [GstWebRTC.WebRTCICEConnectionState.CHECKING]: "checking",
+  [GstWebRTC.WebRTCICEConnectionState.CONNECTED]: "connected",
+  [GstWebRTC.WebRTCICEConnectionState.COMPLETED]: "completed",
+  [GstWebRTC.WebRTCICEConnectionState.FAILED]: "failed",
+  [GstWebRTC.WebRTCICEConnectionState.DISCONNECTED]: "disconnected",
+  [GstWebRTC.WebRTCICEConnectionState.CLOSED]: "closed"
+};
+function gstToIceConnectionState(v) {
+  return ICE_CONNECTION_STATE_MAP[v] ?? "new";
+}
+const ICE_GATHERING_STATE_MAP = {
+  [GstWebRTC.WebRTCICEGatheringState.NEW]: "new",
+  [GstWebRTC.WebRTCICEGatheringState.GATHERING]: "gathering",
+  [GstWebRTC.WebRTCICEGatheringState.COMPLETE]: "complete"
+};
+function gstToIceGatheringState(v) {
+  return ICE_GATHERING_STATE_MAP[v] ?? "new";
+}
+const DIRECTION_GST_TO_W3C = {
+  [GstWebRTC.WebRTCRTPTransceiverDirection.SENDRECV]: "sendrecv",
+  [GstWebRTC.WebRTCRTPTransceiverDirection.SENDONLY]: "sendonly",
+  [GstWebRTC.WebRTCRTPTransceiverDirection.RECVONLY]: "recvonly"
+};
+const DIRECTION_W3C_TO_GST = {
+  sendrecv: GstWebRTC.WebRTCRTPTransceiverDirection.SENDRECV,
+  sendonly: GstWebRTC.WebRTCRTPTransceiverDirection.SENDONLY,
+  recvonly: GstWebRTC.WebRTCRTPTransceiverDirection.RECVONLY,
+  inactive: GstWebRTC.WebRTCRTPTransceiverDirection.NONE
+};
+function gstDirectionToW3C(v) {
+  return DIRECTION_GST_TO_W3C[v] ?? "inactive";
+}
+function w3cDirectionToGst(d) {
+  return DIRECTION_W3C_TO_GST[d] ?? GstWebRTC.WebRTCRTPTransceiverDirection.NONE;
+}
+const STATS_TYPE_MAP = {
+  [GstWebRTC.WebRTCStatsType.CODEC]: "codec",
+  [GstWebRTC.WebRTCStatsType.INBOUND_RTP]: "inbound-rtp",
+  [GstWebRTC.WebRTCStatsType.OUTBOUND_RTP]: "outbound-rtp",
+  [GstWebRTC.WebRTCStatsType.REMOTE_INBOUND_RTP]: "remote-inbound-rtp",
+  [GstWebRTC.WebRTCStatsType.REMOTE_OUTBOUND_RTP]: "remote-outbound-rtp",
+  [GstWebRTC.WebRTCStatsType.CSRC]: "csrc",
+  [GstWebRTC.WebRTCStatsType.PEER_CONNECTION]: "peer-connection",
+  [GstWebRTC.WebRTCStatsType.DATA_CHANNEL]: "data-channel",
+  [GstWebRTC.WebRTCStatsType.STREAM]: "stream",
+  [GstWebRTC.WebRTCStatsType.TRANSPORT]: "transport",
+  [GstWebRTC.WebRTCStatsType.CANDIDATE_PAIR]: "candidate-pair",
+  [GstWebRTC.WebRTCStatsType.LOCAL_CANDIDATE]: "local-candidate",
+  [GstWebRTC.WebRTCStatsType.REMOTE_CANDIDATE]: "remote-candidate",
+  [GstWebRTC.WebRTCStatsType.CERTIFICATE]: "certificate"
+};
+function gstToStatsType(v) {
+  return STATS_TYPE_MAP[v];
+}
+export {
+  gstDirectionToW3C,
+  gstToConnectionState,
+  gstToIceConnectionState,
+  gstToIceGatheringState,
+  gstToSignalingState,
+  gstToStatsType,
+  w3cDirectionToGst
+};

package/lib/esm/gst-init.js

@@ -0,0 +1,34 @@
+import Gst from "gi://Gst?version=1.0";
+let initialized = false;
+function ensureGstInit() {
+  if (initialized) return;
+  Gst.init(null);
+  initialized = true;
+}
+function ensureWebrtcbinAvailable() {
+  ensureGstInit();
+  const webrtcFactory = Gst.ElementFactory.find("webrtcbin");
+  if (!webrtcFactory) {
+    throwNotSupported(
+      'GStreamer element "webrtcbin" not available. Install gst-plugins-bad:\n  Fedora:        dnf install gstreamer1-plugins-bad-free gstreamer1-plugins-bad-free-extras\n  Ubuntu/Debian: apt install gstreamer1.0-plugins-bad'
+    );
+  }
+  const niceFactory = Gst.ElementFactory.find("nicesrc");
+  if (!niceFactory) {
+    throwNotSupported(
+      'GStreamer "nice" plugin (libnice-gstreamer) not available \u2014 required by webrtcbin.\n  Fedora:        dnf install libnice-gstreamer1\n  Ubuntu/Debian: apt install gstreamer1.0-nice\n  Verify with:   gst-inspect-1.0 nicesrc'
+    );
+  }
+}
+function throwNotSupported(message) {
+  const DOMExceptionCtor = globalThis.DOMException;
+  if (DOMExceptionCtor) {
+    throw new DOMExceptionCtor(message, "NotSupportedError");
+  }
+  throw new Error(message);
+}
+export {
+  Gst,
+  ensureGstInit,
+  ensureWebrtcbinAvailable
+};

package/lib/esm/gst-stats-parser.js

@@ -0,0 +1,79 @@
+import { gstToStatsType } from "./gst-enum-maps.js";
+import { RTCStatsReport } from "./rtc-stats-report.js";
+function snakeToCamel(name) {
+  return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function extractFields(structure) {
+  const result = {};
+  const n = structure.n_fields();
+  for (let i = 0; i < n; i++) {
+    const fieldName = structure.nth_field_name(i);
+    try {
+      const value = structure.get_value(fieldName);
+      result[fieldName] = value;
+    } catch {
+    }
+  }
+  return result;
+}
+function parseStatsEntry(structure) {
+  const raw = extractFields(structure);
+  const gstType = raw["type"];
+  if (gstType == null) return null;
+  const w3cType = gstToStatsType(Number(gstType));
+  if (!w3cType) return null;
+  const id = String(raw["id"] ?? structure.get_name() ?? "");
+  const tsRaw = raw["timestamp"];
+  const timestamp = tsRaw != null ? Number(tsRaw) / 1e6 : performance.now();
+  const stats = { type: w3cType, id, timestamp };
+  for (const [key, value] of Object.entries(raw)) {
+    if (key === "type" || key === "id" || key === "timestamp") continue;
+    const camelKey = snakeToCamel(key);
+    stats[camelKey] = value;
+  }
+  return stats;
+}
+function parseGstStats(reply) {
+  if (!reply) return new RTCStatsReport();
+  const entries = [];
+  const n = reply.n_fields();
+  for (let i = 0; i < n; i++) {
+    const fieldName = reply.nth_field_name(i);
+    try {
+      const nested = reply.get_value(fieldName);
+      if (nested && typeof nested.n_fields === "function") {
+        const stats = parseStatsEntry(nested);
+        if (stats) {
+          entries.push([stats.id, stats]);
+        }
+      }
+    } catch {
+    }
+  }
+  return new RTCStatsReport(entries);
+}
+function filterStatsByTrackId(report, trackId) {
+  const entries = [];
+  const relatedIds = /* @__PURE__ */ new Set();
+  for (const [id, stats] of report) {
+    if (stats.trackIdentifier === trackId) {
+      entries.push([id, stats]);
+      relatedIds.add(id);
+      for (const value of Object.values(stats)) {
+        if (typeof value === "string" && report.has(value)) {
+          relatedIds.add(value);
+        }
+      }
+    }
+  }
+  for (const [id, stats] of report) {
+    if (relatedIds.has(id) && !entries.some(([entryId]) => entryId === id)) {
+      entries.push([id, stats]);
+    }
+  }
+  return new RTCStatsReport(entries);
+}
+export {
+  filterStatsByTrackId,
+  parseGstStats
+};

package/lib/esm/gst-utils.js

@@ -0,0 +1,16 @@
+import { PromiseBridge } from "@gjsify/webrtc-native";
+function withGstPromise(emit) {
+  return new Promise((resolve, reject) => {
+    const bridge = new PromiseBridge();
+    bridge.connect("replied", (_b, reply) => {
+      resolve(reply);
+    });
+    bridge.connect("rejected", (_b, message) => {
+      reject(new Error(message));
+    });
+    emit(bridge.promise);
+  });
+}
+export {
+  withGstPromise
+};

package/lib/esm/index.js

@@ -0,0 +1,53 @@
+import { RTCPeerConnection } from "./rtc-peer-connection.js";
+import { RTCDataChannel } from "./rtc-data-channel.js";
+import { RTCSessionDescription } from "./rtc-session-description.js";
+import { RTCIceCandidate } from "./rtc-ice-candidate.js";
+import { RTCError } from "./rtc-error.js";
+import {
+  RTCPeerConnectionIceEvent,
+  RTCDataChannelEvent,
+  RTCErrorEvent
+} 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 { MediaStreamTrackEvent } from "./media-stream.js";
+import { MediaStreamTrack } from "./media-stream-track.js";
+import { RTCTrackEvent } from "./rtc-track-event.js";
+import { getUserMedia } from "./get-user-media.js";
+import { MediaDevices } from "./media-devices.js";
+import { MediaDeviceInfo } from "./media-device-info.js";
+import { RTCStatsReport } from "./rtc-stats-report.js";
+import { RTCDtlsTransport } from "./rtc-dtls-transport.js";
+import { RTCIceTransport } from "./rtc-ice-transport.js";
+import { RTCSctpTransport } from "./rtc-sctp-transport.js";
+import { RTCDTMFSender, RTCDTMFToneChangeEvent } from "./rtc-dtmf-sender.js";
+import { RTCCertificate } from "./rtc-certificate.js";
+export {
+  MediaDeviceInfo,
+  MediaDevices,
+  MediaStream,
+  MediaStreamTrack,
+  MediaStreamTrackEvent,
+  RTCCertificate,
+  RTCDTMFSender,
+  RTCDTMFToneChangeEvent,
+  RTCDataChannel,
+  RTCDataChannelEvent,
+  RTCDtlsTransport,
+  RTCError,
+  RTCErrorEvent,
+  RTCIceCandidate,
+  RTCIceTransport,
+  RTCPeerConnection,
+  RTCPeerConnectionIceEvent,
+  RTCRtpReceiver,
+  RTCRtpSender,
+  RTCRtpTransceiver,
+  RTCSctpTransport,
+  RTCSessionDescription,
+  RTCStatsReport,
+  RTCTrackEvent,
+  getUserMedia
+};

package/lib/esm/media-device-info.js

@@ -0,0 +1,23 @@
+class MediaDeviceInfo {
+  deviceId;
+  kind;
+  label;
+  groupId;
+  constructor(init) {
+    this.deviceId = init.deviceId;
+    this.kind = init.kind;
+    this.label = init.label;
+    this.groupId = init.groupId ?? "";
+  }
+  toJSON() {
+    return {
+      deviceId: this.deviceId,
+      kind: this.kind,
+      label: this.label,
+      groupId: this.groupId
+    };
+  }
+}
+export {
+  MediaDeviceInfo
+};

package/lib/esm/media-devices.js

@@ -0,0 +1,147 @@
+import "@gjsify/dom-events/register/event-target";
+import { ensureGstInit, Gst } from "./gst-init.js";
+import { getUserMedia } from "./get-user-media.js";
+import { MediaDeviceInfo } from "./media-device-info.js";
+const DEVICE_CLASS_MAP = {
+  "Audio/Source": "audioinput",
+  "Video/Source": "videoinput",
+  "Audio/Sink": "audiooutput"
+};
+let _permissionGranted = false;
+function isDeviceMonitorSafe() {
+  try {
+    const GLib = imports.gi.GLib;
+    if (GLib.getenv("CI")) return false;
+    if (!GLib.getenv("DISPLAY") && !GLib.getenv("WAYLAND_DISPLAY")) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+class MediaDevices extends EventTarget {
+  _ondevicechange = null;
+  get ondevicechange() {
+    return this._ondevicechange;
+  }
+  set ondevicechange(v) {
+    this._ondevicechange = v;
+  }
+  async getUserMedia(constraints) {
+    if (!constraints) {
+      throw new TypeError(
+        "Failed to execute 'getUserMedia' on 'MediaDevices': At least one of audio or video must be requested"
+      );
+    }
+    const stream = await getUserMedia(constraints);
+    _permissionGranted = true;
+    return stream;
+  }
+  async enumerateDevices() {
+    ensureGstInit();
+    let monitor = null;
+    const result = [];
+    try {
+      if (!isDeviceMonitorSafe()) {
+        return result;
+      }
+      monitor = new Gst.DeviceMonitor();
+      monitor.set_show_all_devices(true);
+      const audioCaps = Gst.Caps.from_string("audio/x-raw");
+      const videoCaps = Gst.Caps.from_string("video/x-raw");
+      if (audioCaps) {
+        monitor.add_filter("Audio/Source", audioCaps);
+        monitor.add_filter("Audio/Sink", audioCaps);
+      }
+      if (videoCaps) {
+        monitor.add_filter("Video/Source", videoCaps);
+      }
+      if (!monitor.start()) {
+        return result;
+      }
+      let gstDevices;
+      try {
+        gstDevices = monitor.get_devices() ?? [];
+      } catch {
+        return result;
+      }
+      for (const device of gstDevices) {
+        const deviceClass = device.get_device_class?.() ?? "";
+        const kind = DEVICE_CLASS_MAP[deviceClass];
+        if (!kind) continue;
+        const displayName = device.get_display_name?.() ?? "";
+        let deviceId = "";
+        let groupId = "";
+        try {
+          const props = device.get_properties?.();
+          if (props) {
+            const n = props.n_fields();
+            for (let i = 0; i < n; i++) {
+              const name = props.nth_field_name(i);
+              if (name === "persistent-id" || name === "node.name") {
+                const val = props.get_value(name);
+                if (val && !deviceId) deviceId = String(val);
+              }
+              if (name === "group-id") {
+                const val = props.get_value(name);
+                if (val) groupId = String(val);
+              }
+            }
+          }
+        } catch {
+        }
+        if (!deviceId) {
+          deviceId = displayName || `${kind}-${result.length}`;
+        }
+        if (_permissionGranted) {
+          result.push(new MediaDeviceInfo({
+            deviceId,
+            kind,
+            label: displayName,
+            groupId
+          }));
+        } else {
+          if (!result.some((d) => d.kind === kind)) {
+            result.push(new MediaDeviceInfo({
+              deviceId: "",
+              kind,
+              label: "",
+              groupId: ""
+            }));
+          }
+        }
+      }
+    } catch {
+      return result;
+    } finally {
+      try {
+        monitor?.stop();
+      } catch {
+      }
+    }
+    const order = { audioinput: 0, videoinput: 1, audiooutput: 2 };
+    result.sort((a, b) => (order[a.kind] ?? 3) - (order[b.kind] ?? 3));
+    return result;
+  }
+  getSupportedConstraints() {
+    return {
+      deviceId: true,
+      width: true,
+      height: true,
+      frameRate: true,
+      sampleRate: true,
+      channelCount: true,
+      // Not yet supported — return false
+      aspectRatio: false,
+      facingMode: false,
+      resizeMode: false,
+      echoCancellation: false,
+      autoGainControl: false,
+      noiseSuppression: false,
+      latency: false,
+      groupId: false
+    };
+  }
+}
+export {
+  MediaDevices
+};

package/lib/esm/media-stream-track.js

@@ -0,0 +1,142 @@
+import "@gjsify/dom-events/register/event-target";
+import GLib from "gi://GLib?version=2.0";
+import { Gst } from "./gst-init.js";
+class MediaStreamTrack extends EventTarget {
+  id;
+  kind;
+  label;
+  _enabled = true;
+  _muted;
+  _ended = false;
+  _contentHint = "";
+  _onended = null;
+  _onmute = null;
+  _onunmute = null;
+  /** @internal GStreamer source element (e.g. pulsesrc, audiotestsrc) */
+  _gstSource = null;
+  /** @internal Pipeline the source currently lives in (updated by VideoBridge) */
+  _gstPipeline = null;
+  /** @internal Tee element inserted by VideoBridge for preview fan-out */
+  _gstTee = null;
+  /** @internal TeeMultiplexer for multi-PC fan-out (created on second addTrack) */
+  _teeMultiplexer = null;
+  /** @internal Callback set by RTCRtpSender to control valve drop property */
+  _enableCallback = null;
+  constructor(init) {
+    super();
+    this.id = init.id ?? GLib.uuid_string_random();
+    this.kind = init.kind;
+    this.label = init.label ?? "";
+    this._muted = init.muted ?? false;
+    if (init._gst) {
+      this._gstSource = init._gst.source;
+      this._gstPipeline = init._gst.pipeline;
+    }
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  set enabled(v) {
+    const val = !!v;
+    if (this._enabled === val) return;
+    this._enabled = val;
+    this._enableCallback?.(val);
+  }
+  get muted() {
+    return this._muted;
+  }
+  get readyState() {
+    return this._ended ? "ended" : "live";
+  }
+  get contentHint() {
+    return this._contentHint;
+  }
+  set contentHint(v) {
+    if (this.kind === "audio") {
+      if (v !== "" && v !== "speech" && v !== "speech-recognition" && v !== "music") return;
+    } else {
+      if (v !== "" && v !== "motion" && v !== "detail" && v !== "text") return;
+    }
+    this._contentHint = v;
+  }
+  get onended() {
+    return this._onended;
+  }
+  set onended(v) {
+    this._onended = v;
+  }
+  get onmute() {
+    return this._onmute;
+  }
+  set onmute(v) {
+    this._onmute = v;
+  }
+  get onunmute() {
+    return this._onunmute;
+  }
+  set onunmute(v) {
+    this._onunmute = v;
+  }
+  clone() {
+    const cloned = new MediaStreamTrack({
+      kind: this.kind,
+      label: this.label,
+      muted: this._muted
+    });
+    cloned._enabled = this._enabled;
+    return cloned;
+  }
+  stop() {
+    if (this._ended) return;
+    this._ended = true;
+    if (this._gstSource || this._gstPipeline) {
+      try {
+        this._gstPipeline?.set_state(Gst.State.NULL);
+      } catch {
+      }
+      try {
+        this._gstSource?.set_state(Gst.State.NULL);
+      } catch {
+      }
+      this._gstSource = null;
+      this._gstPipeline = null;
+    }
+    const ev = new Event("ended");
+    this._onended?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  getCapabilities() {
+    return {};
+  }
+  getConstraints() {
+    return {};
+  }
+  getSettings() {
+    return {};
+  }
+  applyConstraints(_constraints) {
+    return Promise.reject(new DOMException(
+      "applyConstraints is not supported",
+      "NotSupportedError"
+    ));
+  }
+  /** @internal — used by RTCRtpReceiver to toggle mute state */
+  _setMuted(muted) {
+    if (this._muted === muted) return;
+    this._muted = muted;
+    const ev = new Event(muted ? "mute" : "unmute");
+    if (muted) {
+      this._onmute?.call(this, ev);
+    } else {
+      this._onunmute?.call(this, ev);
+    }
+    this.dispatchEvent(ev);
+  }
+  /** @internal — called by RTCRtpSender to wire valve control */
+  _setEnableCallback(cb) {
+    this._enableCallback = cb;
+  }
+}
+export {
+  MediaStreamTrack
+};