werift 0.24.4 → 0.25.0-alpha.0

package/lib/nonstandard/index.mjs

@@ -579,7 +579,7 @@ var Event2 = class {
       error
     );
   };
-  watch = (cb, timeLimit) => new Promise((resolve2, reject) => {
+  watch = (cb, timeLimit) => new Promise((resolve, reject) => {
     const timeout = timeLimit && setTimeout(() => {
       reject("Event watch timeout");
     }, timeLimit);
@@ -588,22 +588,22 @@ var Event2 = class {
       if (done) {
         if (timeout) clearTimeout(timeout);
         unSubscribe();
-        resolve2(args);
+        resolve(args);
       }
     });
   });
-  asPromise = (timeLimit) => new Promise((resolve2, reject) => {
+  asPromise = (timeLimit) => new Promise((resolve, reject) => {
     const timeout = timeLimit && setTimeout(() => {
       reject("Event asPromise timeout");
     }, timeLimit);
     this.once(
       (...args) => {
         if (timeout) clearTimeout(timeout);
-        resolve2(args);
+        resolve(args);
       },
       () => {
         if (timeout) clearTimeout(timeout);
-        resolve2([]);
+        resolve([]);
       },
       (err5) => {
         if (timeout) clearTimeout(timeout);
@@ -642,6 +642,7 @@ import * as net from "node:net";
 import * as tls from "node:tls";
 import { connect as connect2 } from "node:net";
 var log = debug("werift-ice:packages/ice/src/transport.ts");
+var DEFAULT_CONNECT_TIMEOUT_MS = 8e3;
 var UdpTransport = class _UdpTransport {
   constructor(socketType, options = {}) {
     this.socketType = socketType;
@@ -710,6 +711,10 @@ var UdpTransport = class _UdpTransport {
   get address() {
     return this.socket.address();
   }
+  /** IP family of the bound socket: 4 for udp4, 6 for udp6. */
+  get addressFamily() {
+    return this.socketType === "udp6" ? 6 : 4;
+  }
   get host() {
     return this.socket.address().address;
   }
@@ -729,16 +734,23 @@ var UdpTransport = class _UdpTransport {
 var TcpTransport = class _TcpTransport {
   type = "tcp";
   stream;
-  constructor(addr) {
+  constructor(addr, options = {}) {
     this.stream = new StreamTransport(
       "tcp",
-      () => connect2({ port: addr[1], host: addr[0] })
+      () => connect2({ port: addr[1], host: addr[0] }),
+      void 0,
+      options.connectTimeoutMs
     );
   }
-  static async init(addr) {
-    const transport = new _TcpTransport(addr);
-    await transport.init();
-    return transport;
+  static async init(addr, options = {}) {
+    const transport = new _TcpTransport(addr, options);
+    try {
+      await transport.init();
+      return transport;
+    } catch (error) {
+      await transport.close();
+      throw error;
+    }
   }
   async init() {
     await this.stream.waitForConnect();
@@ -746,6 +758,9 @@ var TcpTransport = class _TcpTransport {
   get address() {
     return this.stream.address;
   }
+  get remoteAddress() {
+    return this.stream.remoteAddress;
+  }
   get closed() {
     return this.stream.closed;
   }
@@ -765,20 +780,27 @@ var TcpTransport = class _TcpTransport {
 var TlsTransport = class _TlsTransport {
   type = "tls";
   stream;
-  constructor(addr, options = {}) {
+  constructor(addr, options = {}, streamOptions = {}) {
     this.stream = new StreamTransport(
       "tls",
       () => tls.connect({
         ...options,
         host: addr[0],
         port: addr[1]
-      })
+      }),
+      void 0,
+      streamOptions.connectTimeoutMs
     );
   }
-  static async init(addr, options = {}) {
-    const transport = new _TlsTransport(addr, options);
-    await transport.init();
-    return transport;
+  static async init(addr, options = {}, streamOptions = {}) {
+    const transport = new _TlsTransport(addr, options, streamOptions);
+    try {
+      await transport.init();
+      return transport;
+    } catch (error) {
+      await transport.close();
+      throw error;
+    }
   }
   async init() {
     await this.stream.waitForConnect();
@@ -786,6 +808,9 @@ var TlsTransport = class _TlsTransport {
   get address() {
     return this.stream.address;
   }
+  get remoteAddress() {
+    return this.stream.remoteAddress;
+  }
   get closed() {
     return this.stream.closed;
   }
@@ -803,9 +828,10 @@ var TlsTransport = class _TlsTransport {
   };
 };
 var StreamTransport = class {
-  constructor(type, createClient, connectEvent = type === "tls" ? "secureConnect" : "connect") {
+  constructor(type, createClient, connectEvent = type === "tls" ? "secureConnect" : "connect", connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
     this.createClient = createClient;
     this.connectEvent = connectEvent;
+    this.connectTimeoutMs = connectTimeoutMs;
     this.type = type;
     this.connect();
   }
@@ -815,6 +841,7 @@ var StreamTransport = class {
   onData = () => {
   };
   closed = false;
+  rejectConnecting;
   connect() {
     if (this.closed) {
       return;
@@ -824,27 +851,40 @@ var StreamTransport = class {
     }
     const client = this.createClient();
     this.client = client;
-    this.connecting = new Promise((r, f) => {
-      const onConnect = () => {
+    this.connecting = new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer2);
+        client.off(this.connectEvent, onConnect);
         client.off("error", onConnectError);
-        r();
+        this.rejectConnecting = void 0;
+        error ? reject(error) : resolve();
+      };
+      const onConnect = () => {
+        settle();
       };
       const onConnectError = (error) => {
-        client.off(this.connectEvent, onConnect);
-        f(error);
+        this.closed = true;
+        settle(error);
+        client.destroy();
       };
+      const timer2 = setTimeout(() => {
+        this.closed = true;
+        settle(
+          new Error(
+            `${this.type} connect timed out after ${this.connectTimeoutMs}ms`
+          )
+        );
+        client.destroy();
+      }, this.connectTimeoutMs);
+      this.rejectConnecting = (error) => settle(error);
       client.once(this.connectEvent, onConnect);
       client.once("error", onConnectError);
     });
     client.on("data", (data) => {
-      const addr = [
-        this.client.remoteAddress,
-        this.client.remotePort
-      ];
-      this.onData(data, addr);
-    });
-    client.on("end", () => {
-      this.connect();
+      this.onData(data, this.remoteAddress);
     });
     client.on("error", (error) => {
       log(`${this.type} transport error`, error);
@@ -856,24 +896,36 @@ var StreamTransport = class {
   get address() {
     return {};
   }
+  /** The peer the stream is connected to, once connected. */
+  get remoteAddress() {
+    const { remoteAddress, remotePort } = this.client;
+    if (!remoteAddress || !remotePort) {
+      return void 0;
+    }
+    return [stripZoneId(remoteAddress), remotePort];
+  }
   send = async (data, addr) => {
     void addr;
     await this.connecting;
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve, reject) => {
       this.client.write(data, (err5) => {
         if (err5) {
           reject(err5);
           return;
         }
-        resolve2();
+        resolve();
       });
     });
   };
   close = async () => {
     this.closed = true;
+    this.rejectConnecting?.(new Error(`${this.type} transport closed`));
     this.client?.destroy();
   };
 };
+function stripZoneId(address) {
+  return address.split("%")[0];
+}
 
 // ../rtp/src/extra/container/mp4/container.ts
 var Mp4Container = class {
@@ -897,6 +949,8 @@ var Mp4Container = class {
   #startPromise;
   #stopPromise;
   #stopped = false;
+  // EncodedChunk timestamps may be negative; EncodedPacket requires >= 0.
+  #timestampOrigin = {};
   #videoFrame;
   #videoMeta;
   #videoSource;
@@ -1131,10 +1185,17 @@ var Mp4Container = class {
   async #writePacket(frame, duration) {
     const data = new Uint8Array(frame.byteLength);
     frame.copyTo(data.buffer);
+    if (this.#timestampOrigin[frame.track] == void 0) {
+      this.#timestampOrigin[frame.track] = Math.min(0, frame.timestamp);
+    }
+    const timestamp = Math.max(
+      0,
+      frame.timestamp - this.#timestampOrigin[frame.track]
+    );
     const packet = new EncodedPacket(
       data,
       frame.type,
-      frame.timestamp / 1e6,
+      timestamp / 1e6,
       duration / 1e6
     );
     if (frame.track === "audio") {
@@ -1148,12 +1209,7 @@ var Mp4Container = class {
       }
       await this.#videoSource.add(packet, this.#videoMeta);
     }
-    this.#rememberFragmentPacket(
-      frame.track,
-      frame.type,
-      frame.timestamp,
-      duration
-    );
+    this.#rememberFragmentPacket(frame.track, frame.type, timestamp, duration);
   }
   #rememberFragmentPacket(kind, type, timestamp, duration) {
     const end = timestamp + duration;
@@ -5809,17 +5865,17 @@ var JitterBufferBase = class {
     this.rtpBuffer[rtp.header.sequenceNumber] = rtp;
   }
   resolveBuffer(seqNumFrom) {
-    const resolve2 = [];
+    const resolve = [];
     for (let index = seqNumFrom; ; index = uint16Add(index, 1)) {
       const rtp = this.rtpBuffer[index];
       if (rtp) {
-        resolve2.push(rtp);
+        resolve.push(rtp);
         delete this.rtpBuffer[index];
       } else {
         break;
       }
     }
-    return resolve2;
+    return resolve;
   }
   sortAndClearBuffer(rtpBuffer) {
     const buffer2 = [];
@@ -6141,7 +6197,7 @@ var MP4Base = class {
       if (eol) {
         this.videoStopped = true;
         if (!this.tracks.some((track2) => track2.kind === "audio") || this.audioStopped) {
-          void this.stop();
+          void this.stop().catch(() => void 0);
         }
       }
       return;
@@ -6198,7 +6254,7 @@ var MP4Base = class {
       if (eol) {
         this.audioStopped = true;
         if (!this.tracks.some((track2) => track2.kind === "video") || this.videoStopped) {
-          void this.stop();
+          void this.stop().catch(() => void 0);
         }
       }
       return;
@@ -6233,7 +6289,10 @@ var MP4Base = class {
       return;
     }
     this.stopped = true;
-    await this.container.stop();
+    try {
+      await this.container.stop();
+    } catch {
+    }
     await this.output({ eol: true });
     await this.onStopped.execute();
   }
@@ -6294,7 +6353,7 @@ var MP4Callback = class extends MP4Base {
     this.processVideoInput(input);
   };
   destroy = () => {
-    void this.stop().finally(() => {
+    void this.stop().catch(() => void 0).finally(() => {
       this.cb = void 0;
       this.queue.cancel();
     });
@@ -9242,10 +9301,6 @@ var log25 = debug("werift-ice : packages/ice/src/ice.ts : log");
 
 // src/helper.ts
 import { EventEmitter } from "node:events";
-function divide(from, split) {
-  const arr = from.split(split);
-  return [arr[0], arr.slice(1).join(split)];
-}
 var EventTarget2 = class extends EventEmitter {
   emit(type, ...args) {
     if (typeof type !== "string") {
@@ -9357,6 +9412,12 @@ var usePCMU = (props = {}) => new RTCRtpCodecParameters({
   payloadType: 0,
   ...props
 });
+function defaultCodecs() {
+  return {
+    audio: [useOPUS(), usePCMU()],
+    video: [useVP8()]
+  };
+}
 var supportedCodecs = [
   useAV1X(),
   useVP9(),
@@ -9385,23 +9446,83 @@ var DTLS_SETUP_ROLE = Object.keys(
   acc[key] = cur;
   return acc;
 }, {});
-var FMTP_INT_PARAMETERS = [
-  "apt",
-  "max-fr",
-  "max-fs",
-  "maxplaybackrate",
-  "minptime",
-  "stereo",
-  "useinbandfec"
-];
 var SRTP_PROFILE = {
   SRTP_AES128_CM_HMAC_SHA1_80: ProtectionProfileAes128CmHmacSha1_80,
   SRTP_AEAD_AES_128_GCM: ProtectionProfileAeadAes128Gcm
 };
 
+// src/transport/dtls.ts
+import { Certificate as Certificate3, PrivateKey as PrivateKey2 } from "@fidm/x509";
+
 // src/media/track.ts
 import { randomUUID as randomUUID5 } from "crypto";
-var MediaStreamTrack = class extends EventTarget2 {
+var sourceCodecsByTrack = /* @__PURE__ */ new WeakMap();
+var sourceCodecsCapturedByTrack = /* @__PURE__ */ new WeakSet();
+function setTrackSourceCodecs(track, codecs) {
+  sourceCodecsCapturedByTrack.add(track);
+  if (codecs == void 0) sourceCodecsByTrack.delete(track);
+  else sourceCodecsByTrack.set(track, codecs);
+}
+function getTrackSourceCodecs(track) {
+  return track == void 0 ? void 0 : sourceCodecsByTrack.get(track);
+}
+function captureTrackSourceCodecs(track) {
+  if (sourceCodecsCapturedByTrack.has(track)) return;
+  sourceCodecsCapturedByTrack.add(track);
+  if (track.codec != void 0) {
+    sourceCodecsByTrack.set(track, [track.codec]);
+  }
+}
+var TrackBroadcastSource = class {
+  tracks = /* @__PURE__ */ new Set();
+  upstreamStops = /* @__PURE__ */ new Set();
+  attach(track) {
+    this.tracks.add(track);
+  }
+  detach(track) {
+    this.tracks.delete(track);
+    if (this.tracks.size > 0) {
+      return;
+    }
+    for (const stop of [...this.upstreamStops]) {
+      stop();
+    }
+    this.upstreamStops.clear();
+  }
+  addUpstreamStop(stop) {
+    const once = () => {
+      this.upstreamStops.delete(once);
+      stop();
+    };
+    this.upstreamStops.add(once);
+  }
+  deliverRtp(packet, extensions) {
+    const live = [...this.tracks].filter((track) => !track.stopped);
+    for (const track of live) {
+      track.applyIncomingRtp(packet.clone(), extensions);
+    }
+  }
+  deliverRtcp(packet) {
+    for (const track of this.tracks) {
+      if (!track.stopped) {
+        track.onReceiveRtcp.execute(packet);
+      }
+    }
+  }
+  deliverSourceChanged(header) {
+    for (const track of this.tracks) {
+      if (!track.stopped) {
+        track.onSourceChanged.execute(header);
+      }
+    }
+  }
+  stopAllTracks() {
+    for (const track of [...this.tracks]) {
+      track.stop();
+    }
+  }
+};
+var MediaStreamTrack = class _MediaStreamTrack extends EventTarget2 {
   uuid = randomUUID5().toString();
   /**MediaStream ID*/
   streamId;
@@ -9421,34 +9542,83 @@ var MediaStreamTrack = class extends EventTarget2 {
   onSourceChanged = new Event2();
   stopped = false;
   muted = true;
+  broadcastSource;
   constructor(props) {
     super();
+    const sharedSource = props.broadcastSource;
     Object.assign(this, props);
+    this.id ??= this.uuid;
+    this.broadcastSource = sharedSource ?? new TrackBroadcastSource();
+    if (!this.stopped) {
+      this.broadcastSource.attach(this);
+    }
     this.onReceiveRtp.subscribe((rtp) => {
       this.muted = false;
       this.header = rtp.header;
     });
     this.label = `${this.remote ? "remote" : "local"} ${this.kind}`;
   }
+  get readyState() {
+    return this.stopped ? "ended" : "live";
+  }
   stop = () => {
+    if (this.stopped) {
+      return;
+    }
     this.stopped = true;
     this.muted = true;
     this.onReceiveRtp.complete();
     this.emit("ended");
+    this.broadcastSource.detach(this);
   };
   writeRtp = (rtp) => {
     if (this.remote) {
       throw new Error("this is remoteTrack");
     }
+    const packet = Buffer.isBuffer(rtp) ? RtpPacket.deSerialize(rtp) : rtp.clone();
+    packet.header.payloadType = this.codec?.payloadType ?? packet.header.payloadType;
+    this.broadcastSource.deliverRtp(packet);
+  };
+  writeRtcp = (rtcp) => {
+    this.broadcastSource.deliverRtcp(rtcp);
+  };
+  notifySourceChanged(header) {
+    this.broadcastSource.deliverSourceChanged(header);
+  }
+  applyIncomingRtp(packet, extensions) {
     if (this.stopped) {
       return;
     }
-    const packet = Buffer.isBuffer(rtp) ? RtpPacket.deSerialize(rtp) : rtp;
-    packet.header.payloadType = this.codec?.payloadType ?? packet.header.payloadType;
-    this.onReceiveRtp.execute(packet);
-  };
+    this.onReceiveRtp.execute(packet, extensions);
+  }
+  bindUpstreamStop(stop) {
+    this.broadcastSource.addUpstreamStop(stop);
+  }
+  stopMediaSource() {
+    this.broadcastSource.stopAllTracks();
+  }
+  clone() {
+    const cloned = new _MediaStreamTrack({
+      kind: this.kind,
+      remote: this.remote,
+      enabled: this.enabled,
+      muted: this.muted,
+      stopped: this.stopped,
+      codec: this.codec,
+      ssrc: this.ssrc,
+      rid: this.rid,
+      header: this.header,
+      broadcastSource: this.broadcastSource
+    });
+    if (sourceCodecsCapturedByTrack.has(this)) {
+      setTrackSourceCodecs(cloned, getTrackSourceCodecs(this));
+    } else {
+      captureTrackSourceCodecs(cloned);
+    }
+    return cloned;
+  }
 };
-var MediaStream = class {
+var MediaStream = class _MediaStream {
   id;
   tracks = [];
   constructor(props = {}) {
@@ -9478,6 +9648,19 @@ var MediaStream = class {
   getVideoTracks() {
     return this.tracks.filter((track) => track.kind === "video");
   }
+  getTrackById(id) {
+    return this.tracks.find((track) => track.id === id);
+  }
+  get active() {
+    return this.tracks.some((track) => !track.stopped);
+  }
+  clone() {
+    const cloned = new _MediaStream();
+    for (const track of this.tracks) {
+      cloned.addTrack(track.clone());
+    }
+    return cloned;
+  }
 };
 
 // src/utils.ts
@@ -9486,21 +9669,17 @@ var milliTime = Date.now;
 var startupTimestampInMicroseconds = BigInt(Date.now()) * 1000n - process.hrtime.bigint() / 1000n;
 var createSelfSignedCertificate = CipherContext.createSelfSignedCertificateWithKey;
 
-// src/media/receiver/nack.ts
-var log28 = debug("werift:packages/webrtc/src/media/receiver/nack.ts");
-var LOST_SIZE2 = 30 * 5;
-
-// src/media/receiver/receiverTwcc.ts
-var log29 = debug("werift:packages/webrtc/media/receiver/receiverTwcc");
-
 // src/transport/dtls.ts
-import { Certificate as Certificate3, PrivateKey as PrivateKey2 } from "@fidm/x509";
-var log30 = debug("werift:packages/webrtc/src/transport/dtls.ts");
+var log28 = debug("werift:packages/webrtc/src/transport/dtls.ts");
 
 // src/transport/ice.ts
-var log31 = debug("werift:packages/webrtc/src/transport/ice.ts");
+var log29 = debug("werift:packages/webrtc/src/transport/ice.ts");
 
 // ../sctp/src/chunk.ts
+var SCTP_PADDING_MULTIPLE = 4;
+var SCTP_CHUNK_HEADER_SIZE = 4;
+var SCTP_DATA_FIXED_HEADER_SIZE = 12;
+var SCTP_DATA_CHUNK_HEADER_SIZE = SCTP_CHUNK_HEADER_SIZE + SCTP_DATA_FIXED_HEADER_SIZE;
 var Chunk = class _Chunk {
   constructor(flags = 0, _body = Buffer.from("")) {
     this.flags = flags;
@@ -9518,10 +9697,10 @@ var Chunk = class _Chunk {
   }
   get bytes() {
     if (!this.body) throw new Error();
-    const header = Buffer.alloc(4);
+    const header = Buffer.alloc(SCTP_CHUNK_HEADER_SIZE);
     header.writeUInt8(this.type, 0);
     header.writeUInt8(this.flags, 1);
-    header.writeUInt16BE(this.body.length + 4, 2);
+    header.writeUInt16BE(this.body.length + SCTP_CHUNK_HEADER_SIZE, 2);
     const data = Buffer.concat([
       header,
       this.body,
@@ -9646,8 +9825,8 @@ var DataChunk = class _DataChunk extends Chunk {
   maxRetransmits;
   sentTime;
   get bytes() {
-    const length = 16 + this.userData.length;
-    const header = Buffer.alloc(16);
+    const length = SCTP_DATA_CHUNK_HEADER_SIZE + this.userData.length;
+    const header = Buffer.alloc(SCTP_DATA_CHUNK_HEADER_SIZE);
     header.writeUInt8(this.type, 0);
     header.writeUInt8(this.flags, 1);
     header.writeUInt16BE(length, 2);
@@ -9857,8 +10036,8 @@ var CHUNK_BY_TYPE = CHUNK_CLASSES.reduce(
   {}
 );
 function padL(l) {
-  const m = l % 4;
-  return m ? 4 - m : 0;
+  const m = l % SCTP_PADDING_MULTIPLE;
+  return m ? SCTP_PADDING_MULTIPLE - m : 0;
 }
 function encodeParams(params) {
   let body = Buffer.from("");
@@ -9888,35 +10067,22 @@ function decodeParams(body) {
 }
 
 // ../sctp/src/sctp.ts
-var log32 = debug("werift/sctp/sctp");
+var log30 = debug("werift/sctp/sctp");
+var DEFAULT_SCTP_MTU = 1191;
 var SCTP_RTO_ALPHA = 1 / 8;
 var SCTP_RTO_BETA = 1 / 4;
 var SCTP_TSN_MODULO = 2 ** 32;
 
 // src/transport/sctp.ts
-var log33 = debug("werift:packages/webrtc/src/transport/sctp.ts");
+var log31 = debug("werift:packages/webrtc/src/transport/sctp.ts");
 var DEFAULT_MAX_MESSAGE_SIZE = 65536;
 
-// src/sdp.ts
-function codecParametersFromString(str) {
-  const parameters = {};
-  str.split(";").forEach((param) => {
-    if (param.includes("=")) {
-      const [k, v] = divide(param, "=");
-      if (FMTP_INT_PARAMETERS.includes(k)) {
-        parameters[k] = Number(v);
-      } else {
-        parameters[k] = v;
-      }
-    } else if (param.includes(":")) {
-      const [k, v] = param.split(":");
-      parameters[k] = Number.isNaN(Number(v)) ? v : Number(v);
-    } else {
-      parameters[param] = void 0;
-    }
-  });
-  return parameters;
-}
+// src/media/receiver/nack.ts
+var log32 = debug("werift:packages/webrtc/src/media/receiver/nack.ts");
+var LOST_SIZE2 = 30 * 5;
+
+// src/media/receiver/receiverTwcc.ts
+var log33 = debug("werift:packages/webrtc/media/receiver/receiverTwcc");
 
 // src/media/rtpReceiver.ts
 var log34 = debug("werift:packages/webrtc/src/media/rtpReceiver.ts");
@@ -9927,11 +10093,14 @@ var log35 = debug("werift:packages/webrtc/src/media/router.ts");
 // src/media/rtpSender.ts
 var log36 = debug("werift:packages/webrtc/src/media/rtpSender.ts");
 
+// src/transceiverManager.ts
+var log37 = debug("werift:packages/webrtc/src/media/rtpTransceiverManager.ts");
+
 // src/sctpManager.ts
-var log37 = debug("werift:packages/webrtc/src/transport/sctpManager.ts");
+var log38 = debug("werift:packages/webrtc/src/transport/sctpManager.ts");
 
 // src/secureTransportManager.ts
-var log38 = debug(
+var log39 = debug(
   "werift:packages/webrtc/src/transport/secureTransportManager.ts"
 );
 var srtpProfiles = [
@@ -9941,13 +10110,10 @@ var srtpProfiles = [
 ];
 
 // src/peerConnection.ts
-var log39 = debug("werift:packages/webrtc/src/peerConnection.ts");
+var log40 = debug("werift:packages/webrtc/src/peerConnection.ts");
 function generateDefaultPeerConfig() {
   return {
-    codecs: {
-      audio: [useOPUS(), usePCMU()],
-      video: [useVP8()]
-    },
+    codecs: defaultCodecs(),
     headerExtensions: {
       audio: [],
       video: []
@@ -9961,8 +10127,12 @@ function generateDefaultPeerConfig() {
     iceUseIpv4: true,
     iceUseIpv6: true,
     iceUseTcp: false,
+    iceTcpPassive: true,
+    iceStunGatherTimeout: void 0,
+    iceTurnConnectTimeout: void 0,
     turnTransport: void 0,
     turnTlsOptions: void 0,
+    turnUdpFamily: void 0,
     iceFilterStunResponse: void 0,
     iceFilterCandidatePair: void 0,
     icePasswordPrefix: void 0,
@@ -9975,14 +10145,14 @@ function generateDefaultPeerConfig() {
     debug: {},
     midSuffix: false,
     forceTurnTCP: false,
-    maxMessageSize: DEFAULT_MAX_MESSAGE_SIZE
+    maxMessageSize: DEFAULT_MAX_MESSAGE_SIZE,
+    sctp: { mtu: DEFAULT_SCTP_MTU },
+    pendingRtp: false,
+    mLineReuse: "compatible"
   };
 }
 var defaultPeerConfig = generateDefaultPeerConfig();
 
-// src/transceiverManager.ts
-var log40 = debug("werift:packages/webrtc/src/media/rtpTransceiverManager.ts");
-
 // src/nonstandard/dummyMedia.ts
 var AUDIO_PACKET_MS = 20;
 var AUDIO_TIMESTAMP_STEP = 960;
@@ -10268,6 +10438,7 @@ var WebmFactory = class extends MediaWriter {
                 return "VP9";
               case "h264":
                 return "MPEG4/ISO/AVC";
+              case "av1":
               case "av1x":
                 return "AV1";
               default:
@@ -10425,893 +10596,6 @@ var MediaRecorder = class {
     await this.writer.stop();
   }
 };
-
-// src/nonstandard/userMedia.ts
-import { randomUUID as randomUUID6 } from "crypto";
-import { homedir } from "os";
-import { isAbsolute, resolve } from "path";
-import { Readable } from "stream";
-import { readFile } from "fs/promises";
-import {
-  setImmediate as onNextTurn,
-  setTimeout as wait
-} from "timers/promises";
-import {
-  BufferSource,
-  EncodedPacketSink,
-  Input,
-  MP4,
-  WEBM
-} from "mediabunny";
-
-// src/nonstandard/userMedia/packetizer.ts
-var DEFAULT_MAX_RTP_PAYLOAD_SIZE = 1200;
-var supportedSourceCodecs = [
-  "avc",
-  "vp8",
-  "vp9",
-  "av1",
-  "opus"
-];
-function toSupportedMimeType(codec) {
-  switch (codec) {
-    case "avc":
-      return "video/h264";
-    case "vp8":
-      return "video/vp8";
-    case "vp9":
-      return "video/vp9";
-    case "av1":
-      return "video/av1x";
-    case "opus":
-      return "audio/opus";
-  }
-}
-function createPacketizer({
-  codec,
-  sourceCodec,
-  decoderDescription
-}) {
-  switch (sourceCodec) {
-    case "avc":
-      return new H264Packetizer(codec, decoderDescription ?? null);
-    case "vp8":
-      return new Vp8Packetizer(codec);
-    case "vp9":
-      return new Vp9Packetizer(codec);
-    case "av1":
-      return new Av1Packetizer(codec);
-    case "opus":
-      return new OpusPacketizer(codec);
-  }
-}
-var BasePacketizer = class {
-  constructor(codec, maxPayloadSize = DEFAULT_MAX_RTP_PAYLOAD_SIZE) {
-    this.codec = codec;
-    this.maxPayloadSize = maxPayloadSize;
-  }
-  sequenceNumber = random16();
-  buildPacket(payload, timestamp, marker) {
-    const packet = new RtpPacket(
-      new RtpHeader({
-        payloadType: this.codec.payloadType ?? 96,
-        sequenceNumber: this.sequenceNumber,
-        timestamp,
-        marker
-      }),
-      payload
-    );
-    this.sequenceNumber = this.sequenceNumber + 1 & 65535;
-    return packet;
-  }
-};
-var OpusPacketizer = class extends BasePacketizer {
-  packetize(packet, rtpTimestamp) {
-    return [this.buildPacket(toBuffer(packet.data), rtpTimestamp, true)];
-  }
-};
-var Vp8Packetizer = class extends BasePacketizer {
-  packetize(packet, rtpTimestamp) {
-    const frame = toBuffer(packet.data);
-    const chunkSize = this.maxPayloadSize - 1;
-    if (chunkSize <= 0) {
-      throw new Error("invalid VP8 RTP payload size");
-    }
-    const packets = [];
-    for (let offset = 0; offset < frame.length; offset += chunkSize) {
-      const chunk = frame.subarray(
-        offset,
-        Math.min(frame.length, offset + chunkSize)
-      );
-      const descriptor = Buffer.from([offset === 0 ? 16 : 0]);
-      packets.push(
-        this.buildPacket(
-          Buffer.concat([descriptor, chunk]),
-          rtpTimestamp,
-          offset + chunk.length >= frame.length
-        )
-      );
-    }
-    return packets;
-  }
-};
-var Vp9Packetizer = class extends BasePacketizer {
-  packetize(packet, rtpTimestamp) {
-    const frame = toBuffer(packet.data);
-    const chunkSize = this.maxPayloadSize - 1;
-    if (chunkSize <= 0) {
-      throw new Error("invalid VP9 RTP payload size");
-    }
-    const packets = [];
-    for (let offset = 0; offset < frame.length; offset += chunkSize) {
-      const chunk = frame.subarray(
-        offset,
-        Math.min(frame.length, offset + chunkSize)
-      );
-      const descriptor = new BitWriter(8).set(1, 0, 0).set(1, 1, packet.type === "delta" ? 1 : 0).set(1, 2, 0).set(1, 3, 0).set(1, 4, offset === 0 ? 1 : 0).set(1, 5, offset + chunk.length >= frame.length ? 1 : 0).set(1, 6, 0).set(1, 7, 0).buffer;
-      packets.push(
-        this.buildPacket(
-          Buffer.concat([descriptor, chunk]),
-          rtpTimestamp,
-          offset + chunk.length >= frame.length
-        )
-      );
-    }
-    return packets;
-  }
-};
-var Av1Packetizer = class extends BasePacketizer {
-  packetize(packet, rtpTimestamp) {
-    const obus = splitAv1Obus(toBuffer(packet.data));
-    const packets = [];
-    const fragmentSize = this.maxPayloadSize - 1;
-    if (fragmentSize <= 0) {
-      throw new Error("invalid AV1 RTP payload size");
-    }
-    let firstPacketInFrame = true;
-    const startsNewCodedVideoSequence = packet.type === "key";
-    for (const obu of obus) {
-      if (obu.length <= fragmentSize) {
-        const aggregationHeader = createAv1AggregationHeader({
-          startsWithFragment: false,
-          endsWithFragment: false,
-          startsNewCodedVideoSequence: firstPacketInFrame && startsNewCodedVideoSequence
-        });
-        packets.push(
-          this.buildPacket(
-            Buffer.concat([aggregationHeader, obu]),
-            rtpTimestamp,
-            false
-          )
-        );
-        firstPacketInFrame = false;
-        continue;
-      }
-      for (let offset = 0; offset < obu.length; offset += fragmentSize) {
-        const chunk = obu.subarray(
-          offset,
-          Math.min(obu.length, offset + fragmentSize)
-        );
-        const aggregationHeader = createAv1AggregationHeader({
-          startsWithFragment: offset > 0,
-          endsWithFragment: offset + chunk.length < obu.length,
-          startsNewCodedVideoSequence: firstPacketInFrame && startsNewCodedVideoSequence
-        });
-        packets.push(
-          this.buildPacket(
-            Buffer.concat([aggregationHeader, chunk]),
-            rtpTimestamp,
-            false
-          )
-        );
-        firstPacketInFrame = false;
-      }
-    }
-    if (packets.length === 0) {
-      throw new Error("AV1 sample did not contain any OBU data");
-    }
-    packets.at(-1).header.marker = true;
-    return packets;
-  }
-};
-var H264Packetizer = class extends BasePacketizer {
-  naluLengthSize;
-  parameterSets;
-  constructor(codec, decoderDescription) {
-    super(codec);
-    const packetizationMode = getH264PacketizationMode(codec.parameters);
-    if (packetizationMode !== 1) {
-      throw new Error(
-        `Unsupported H264 packetization-mode=${packetizationMode}. File playback requires packetization-mode=1.`
-      );
-    }
-    const avcConfig = parseAvcDecoderConfiguration(decoderDescription);
-    this.naluLengthSize = avcConfig?.naluLengthSize ?? 4;
-    this.parameterSets = avcConfig ? [...avcConfig.sps.map(Buffer.from), ...avcConfig.pps.map(Buffer.from)] : [];
-  }
-  packetize(packet, rtpTimestamp) {
-    let nalUnits = splitH264Sample(toBuffer(packet.data), this.naluLengthSize);
-    if (packet.type === "key" && this.parameterSets.length > 0 && !containsH264ParameterSets(nalUnits)) {
-      nalUnits = [...this.parameterSets, ...nalUnits];
-    }
-    const packets = [];
-    nalUnits.forEach((nalUnit, index) => {
-      const marker = index === nalUnits.length - 1;
-      if (nalUnit.length <= this.maxPayloadSize) {
-        packets.push(this.buildPacket(nalUnit, rtpTimestamp, marker));
-        return;
-      }
-      const nalHeader = nalUnit[0];
-      const fragmentPayload = nalUnit.subarray(1);
-      const fragmentSize = this.maxPayloadSize - 2;
-      if (fragmentSize <= 0) {
-        throw new Error("invalid H264 RTP payload size");
-      }
-      const fuIndicator = nalHeader & 224 | 28;
-      const nalType = nalHeader & 31;
-      for (let offset = 0; offset < fragmentPayload.length; offset += fragmentSize) {
-        const chunk = fragmentPayload.subarray(
-          offset,
-          Math.min(fragmentPayload.length, offset + fragmentSize)
-        );
-        const fuHeader = Buffer.from([
-          (offset === 0 ? 128 : 0) | (offset + chunk.length >= fragmentPayload.length ? 64 : 0) | nalType
-        ]);
-        packets.push(
-          this.buildPacket(
-            Buffer.concat([Buffer.from([fuIndicator]), fuHeader, chunk]),
-            rtpTimestamp,
-            marker && offset + chunk.length >= fragmentPayload.length
-          )
-        );
-      }
-    });
-    return packets;
-  }
-};
-function createAv1AggregationHeader({
-  startsWithFragment,
-  endsWithFragment,
-  startsNewCodedVideoSequence
-}) {
-  return new BitWriter(8).set(1, 0, startsWithFragment ? 1 : 0).set(1, 1, endsWithFragment ? 1 : 0).set(2, 2, 1).set(1, 4, startsNewCodedVideoSequence ? 1 : 0).set(3, 5, 0).buffer;
-}
-function parseAvcDecoderConfiguration(decoderDescription) {
-  if (!decoderDescription) {
-    return null;
-  }
-  const description = toDescriptionBuffer(decoderDescription);
-  if (description.length < 7) {
-    throw new Error("invalid H264 decoder configuration");
-  }
-  const naluLengthSize = (description[4] & 3) + 1;
-  const spsCount = description[5] & 31;
-  let offset = 6;
-  const sps = [];
-  for (let index = 0; index < spsCount; index++) {
-    const length = description.readUInt16BE(offset);
-    offset += 2;
-    sps.push(description.subarray(offset, offset + length));
-    offset += length;
-  }
-  const ppsCount = description[offset] ?? 0;
-  offset++;
-  const pps = [];
-  for (let index = 0; index < ppsCount; index++) {
-    const length = description.readUInt16BE(offset);
-    offset += 2;
-    pps.push(description.subarray(offset, offset + length));
-    offset += length;
-  }
-  return { naluLengthSize, sps, pps };
-}
-function splitH264Sample(sample, naluLengthSize) {
-  if (looksLikeAnnexB(sample)) {
-    const nalUnits2 = [];
-    const parser = new H264AnnexBParser(sample);
-    let payload = parser.readNextNaluPayload();
-    while (payload) {
-      nalUnits2.push(Buffer.from(payload.data));
-      payload = parser.readNextNaluPayload();
-    }
-    return nalUnits2;
-  }
-  const nalUnits = [];
-  let offset = 0;
-  while (offset < sample.length) {
-    const length = readUintLength(sample, offset, naluLengthSize);
-    offset += naluLengthSize;
-    const end = offset + length;
-    if (end > sample.length) {
-      throw new Error("invalid H264 sample length");
-    }
-    nalUnits.push(sample.subarray(offset, end));
-    offset = end;
-  }
-  return nalUnits;
-}
-function splitAv1Obus(sample) {
-  const obus = [];
-  let offset = 0;
-  while (offset < sample.length) {
-    const start = offset;
-    const header = sample[offset];
-    offset += 1;
-    if (header == void 0) {
-      break;
-    }
-    const extensionFlag = getBit(header, 5);
-    const hasSizeField = getBit(header, 6);
-    if (extensionFlag) {
-      offset += 1;
-    }
-    if (!hasSizeField) {
-      obus.push(sample.subarray(start));
-      break;
-    }
-    const [obuSize, leb128Length] = leb128decode(sample.subarray(offset));
-    offset += leb128Length;
-    const end = offset + obuSize;
-    if (end > sample.length) {
-      throw new Error("invalid AV1 OBU size");
-    }
-    obus.push(sample.subarray(start, end));
-    offset = end;
-  }
-  return obus;
-}
-function containsH264ParameterSets(nalUnits) {
-  return nalUnits.some((nalUnit) => {
-    const nalType = nalUnit[0] & 31;
-    return nalType === 7 || nalType === 8;
-  });
-}
-function looksLikeAnnexB(sample) {
-  return sample.length >= 4 && sample[0] === 0 && sample[1] === 0 && (sample[2] === 0 && sample[3] === 1 || sample[2] === 1);
-}
-function readUintLength(buffer2, offset, length) {
-  switch (length) {
-    case 1:
-      return buffer2.readUInt8(offset);
-    case 2:
-      return buffer2.readUInt16BE(offset);
-    case 3:
-      return buffer2.readUIntBE(offset, 3);
-    case 4:
-      return buffer2.readUInt32BE(offset);
-    default:
-      throw new Error(`unsupported H264 NALU length size: ${length}`);
-  }
-}
-function getH264PacketizationMode(parameters) {
-  if (!parameters) {
-    return 1;
-  }
-  const packetizationMode = parameters.split(";").map((part) => part.trim()).find((part) => part.startsWith("packetization-mode="));
-  if (!packetizationMode) {
-    return 1;
-  }
-  return Number(packetizationMode.split("=")[1] ?? 1);
-}
-function toDescriptionBuffer(decoderDescription) {
-  if (ArrayBuffer.isView(decoderDescription)) {
-    return Buffer.from(
-      decoderDescription.buffer,
-      decoderDescription.byteOffset,
-      decoderDescription.byteLength
-    );
-  }
-  return Buffer.from(decoderDescription);
-}
-function toBuffer(data) {
-  return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-}
-
-// src/nonstandard/userMedia.ts
-var getUserMedia = async (options) => {
-  assertSupportedOptions(options);
-  const replayableSource = await createReplayableSource(options);
-  const input = await createInput(replayableSource);
-  try {
-    if (!await input.canRead()) {
-      throw new Error("Only MP4 and WebM file playback is supported");
-    }
-    const streamId = randomUUID6().toString();
-    const playbackTracks = await selectPlaybackTracks(input, streamId);
-    if (playbackTracks.length === 0) {
-      throw new Error(
-        "The media source does not contain playable audio or video tracks"
-      );
-    }
-    const mediaStartTimestamp = await input.getFirstTimestamp(
-      playbackTracks.map(({ inputTrack }) => inputTrack)
-    );
-    return new MediaPlayer({
-      source: replayableSource,
-      loop: options.loop ?? false,
-      streamId,
-      session: createPlaybackSession({
-        input,
-        mediaStartTimestamp,
-        playbackTracks
-      })
-    });
-  } catch (error) {
-    input.dispose();
-    throw error;
-  }
-};
-var MediaPlayer = class {
-  audio;
-  video;
-  onError = new Event2();
-  source;
-  loop;
-  streamId;
-  session;
-  running;
-  abortController;
-  hasStartedPlayback = false;
-  stopped = false;
-  constructor({
-    source,
-    loop,
-    streamId,
-    session
-  }) {
-    this.source = source;
-    this.loop = loop;
-    this.streamId = streamId;
-    this.session = session;
-    this.audio = session.playbackTracks.find(
-      ({ track }) => track.kind === "audio"
-    )?.track;
-    this.video = session.playbackTracks.find(
-      ({ track }) => track.kind === "video"
-    )?.track;
-  }
-  async start() {
-    if (this.stopped) {
-      throw new Error("The media source has already been stopped");
-    }
-    if (this.running) {
-      return;
-    }
-    const abortController = new AbortController();
-    this.abortController = abortController;
-    let startupPending = true;
-    let session;
-    const playback = (async () => {
-      session = await this.getOrCreateSession();
-      if (abortController.signal.aborted || this.stopped) {
-        return;
-      }
-      session.runners.forEach((runner) => runner.assertReady());
-      const initialSourceChanged = this.hasStartedPlayback;
-      this.hasStartedPlayback = true;
-      await this.run(session, abortController, initialSourceChanged);
-    })();
-    const observedPlayback = playback.catch((error) => {
-      if (abortController.signal.aborted) {
-        return;
-      }
-      this.onError.execute(toError(error));
-      if (startupPending) {
-        throw error;
-      }
-    });
-    this.running = observedPlayback.finally(() => {
-      if (this.abortController === abortController) {
-        this.abortController = void 0;
-      }
-      this.running = void 0;
-      this.disposeSession(session);
-    });
-    try {
-      await Promise.race([this.running, onNextTurn()]);
-    } finally {
-      startupPending = false;
-    }
-  }
-  stop() {
-    if (this.stopped) {
-      return;
-    }
-    this.stopped = true;
-    this.abortController?.abort();
-    if (!this.running) {
-      this.disposeSession();
-    }
-  }
-  async run(session, abortController, initialSourceChanged) {
-    let sourceChanged = initialSourceChanged;
-    do {
-      const startedAt = performance.now();
-      await Promise.all(
-        session.runners.map(
-          (runner) => runner.play({
-            startedAt,
-            signal: abortController.signal,
-            sourceChanged
-          })
-        )
-      );
-      if (!this.loop || abortController.signal.aborted) {
-        break;
-      }
-      sourceChanged = true;
-    } while (!abortController.signal.aborted);
-  }
-  async getOrCreateSession() {
-    if (this.session) {
-      return this.session;
-    }
-    const input = await createInput(this.source);
-    try {
-      if (!await input.canRead()) {
-        throw new Error("Only MP4 and WebM file playback is supported");
-      }
-      const playbackTracks = await selectPlaybackTracks(
-        input,
-        this.streamId,
-        buildExistingTrackMap(this.audio, this.video)
-      );
-      const mediaStartTimestamp = await input.getFirstTimestamp(
-        playbackTracks.map(({ inputTrack }) => inputTrack)
-      );
-      const session = createPlaybackSession({
-        input,
-        mediaStartTimestamp,
-        playbackTracks
-      });
-      this.session = session;
-      return session;
-    } catch (error) {
-      input.dispose();
-      throw error;
-    }
-  }
-  disposeSession(session = this.session) {
-    if (!session) {
-      return;
-    }
-    session.input.dispose();
-    if (this.session === session) {
-      this.session = void 0;
-    }
-  }
-};
-var TrackPlaybackRunner = class {
-  constructor(props) {
-    this.props = props;
-  }
-  async play({
-    startedAt,
-    signal,
-    sourceChanged
-  }) {
-    const codec = this.requireNegotiatedCodec();
-    const packetizer = createPacketizer({
-      codec,
-      sourceCodec: this.props.sourceCodec,
-      decoderDescription: this.props.decoderDescription
-    });
-    const packetSink = new EncodedPacketSink(this.props.inputTrack);
-    let sourceChangeNotified = false;
-    try {
-      for await (const packet of packetSink.packets(void 0, void 0, {
-        verifyKeyPackets: this.props.track.kind === "video"
-      })) {
-        signal.throwIfAborted?.();
-        const dueAtMs = (packet.timestamp - this.props.mediaStartTimestamp) * 1e3;
-        const remainingMs = dueAtMs - (performance.now() - startedAt);
-        if (remainingMs > 0) {
-          await wait(remainingMs, void 0, { signal });
-        }
-        const rtpTimestamp = toRtpTimestamp(
-          packet.timestamp,
-          this.props.mediaStartTimestamp,
-          codec.clockRate
-        );
-        const packets = packetizer.packetize(packet, rtpTimestamp);
-        if (packets.length === 0) {
-          continue;
-        }
-        if (sourceChanged && !sourceChangeNotified) {
-          this.props.track.onSourceChanged.execute(packets[0].header);
-          sourceChangeNotified = true;
-        }
-        for (const rtpPacket of packets) {
-          this.props.track.writeRtp(rtpPacket);
-        }
-      }
-    } catch (error) {
-      if (signal.aborted || isAbortError(error)) {
-        return;
-      }
-      throw error;
-    }
-  }
-  assertReady() {
-    const codec = this.requireNegotiatedCodec();
-    createPacketizer({
-      codec,
-      sourceCodec: this.props.sourceCodec,
-      decoderDescription: this.props.decoderDescription
-    });
-  }
-  requireNegotiatedCodec() {
-    const codec = this.props.track.codec;
-    if (!codec) {
-      throw new Error(
-        `Cannot start ${this.props.track.kind} playback before the track is attached to an RTCRtpSender`
-      );
-    }
-    const expectedMimeType = toSupportedMimeType(this.props.sourceCodec);
-    const negotiatedMimeType = normalizeMimeType(codec.mimeType);
-    if (negotiatedMimeType !== expectedMimeType) {
-      throw new Error(
-        `Input ${this.props.track.kind} codec ${expectedMimeType} does not match negotiated codec ${codec.mimeType}`
-      );
-    }
-    const expectedClockRate = this.props.track.kind === "audio" ? 48e3 : 9e4;
-    if (codec.clockRate !== expectedClockRate) {
-      throw new Error(
-        `Input ${this.props.track.kind} clock rate ${expectedClockRate} does not match negotiated clock rate ${codec.clockRate}`
-      );
-    }
-    assertCodecParameters({
-      trackKind: this.props.track.kind === "audio" ? "audio" : "video",
-      codec,
-      sourceCodec: this.props.sourceCodec,
-      decoderDescription: this.props.decoderDescription,
-      sourceChannels: this.props.sourceChannels
-    });
-    return codec;
-  }
-};
-async function selectPlaybackTracks(input, streamId, existingTracks = {}) {
-  const primaryVideoTrack = await input.getPrimaryVideoTrack();
-  const primaryAudioTrack = primaryVideoTrack ? await primaryVideoTrack.getPrimaryPairableAudioTrack() ?? await input.getPrimaryAudioTrack() : await input.getPrimaryAudioTrack();
-  const playbackTracks = [];
-  if (primaryAudioTrack) {
-    playbackTracks.push(
-      await createPlaybackTrack(
-        primaryAudioTrack,
-        streamId,
-        existingTracks.audio
-      )
-    );
-  }
-  if (primaryVideoTrack) {
-    playbackTracks.push(
-      await createPlaybackTrack(
-        primaryVideoTrack,
-        streamId,
-        existingTracks.video
-      )
-    );
-  }
-  if (!primaryVideoTrack && !primaryAudioTrack) {
-    const fallbackAudioTrack = await input.getPrimaryAudioTrack();
-    if (fallbackAudioTrack) {
-      playbackTracks.push(
-        await createPlaybackTrack(
-          fallbackAudioTrack,
-          streamId,
-          existingTracks.audio
-        )
-      );
-    }
-  }
-  return playbackTracks;
-}
-async function createPlaybackTrack(inputTrack, streamId, track) {
-  const sourceCodec = await requireSupportedCodec(inputTrack);
-  const decoderConfig = await inputTrack.getDecoderConfig();
-  const kind = inputTrack.isAudioTrack() ? "audio" : "video";
-  return {
-    inputTrack,
-    sourceCodec,
-    decoderDescription: decoderConfig && "description" in decoderConfig ? decoderConfig.description ?? null : null,
-    sourceChannels: decoderConfig && "numberOfChannels" in decoderConfig ? decoderConfig.numberOfChannels : void 0,
-    track: track ?? new MediaStreamTrack({
-      kind,
-      streamId
-    })
-  };
-}
-async function requireSupportedCodec(inputTrack) {
-  const codec = await inputTrack.getCodec();
-  if (codec && supportedSourceCodecs.includes(codec)) {
-    return codec;
-  }
-  const codecLabel = codec ?? await inputTrack.getCodecParameterString() ?? String(await inputTrack.getInternalCodecId() ?? "unknown");
-  throw new Error(
-    `Unsupported ${inputTrack.type} codec "${codecLabel}". File playback supports H264, VP8, VP9, AV1, and Opus only.`
-  );
-}
-async function createReplayableSource(options) {
-  if (typeof options.path === "string") {
-    return { path: options.path };
-  }
-  const buffer2 = options.buffer != void 0 ? toBuffer2(options.buffer) : await readStreamToBuffer(options.stream);
-  return { buffer: buffer2 };
-}
-async function createInput(options) {
-  if (typeof options.path === "string") {
-    const buffer2 = await readFile(resolveUserMediaPath(options.path));
-    return new Input({
-      source: new BufferSource(buffer2),
-      formats: [MP4, WEBM]
-    });
-  }
-  return new Input({
-    source: new BufferSource(options.buffer),
-    formats: [MP4, WEBM]
-  });
-}
-function resolveUserMediaPath(path2) {
-  if (path2 === "~") {
-    return homedir();
-  }
-  if (path2.startsWith("~/")) {
-    return resolve(homedir(), path2.slice(2));
-  }
-  return isAbsolute(path2) ? path2 : resolve(path2);
-}
-async function readStreamToBuffer(stream) {
-  const chunks = [];
-  if (stream instanceof Readable) {
-    for await (const chunk of stream) {
-      chunks.push(toBuffer2(chunk));
-    }
-    return Buffer.concat(chunks);
-  }
-  const reader = stream.getReader();
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      if (value) {
-        chunks.push(
-          Buffer.from(value.buffer, value.byteOffset, value.byteLength)
-        );
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  return Buffer.concat(chunks);
-}
-function toBuffer2(value) {
-  if (Buffer.isBuffer(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return Buffer.from(value);
-  }
-  if (ArrayBuffer.isView(value)) {
-    return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-  }
-  return Buffer.from(new Uint8Array(value));
-}
-function normalizeMimeType(mimeType) {
-  return mimeType.toLowerCase();
-}
-function assertSupportedOptions(options) {
-  const legacyOptions = options;
-  if (legacyOptions.width != void 0 || legacyOptions.height != void 0) {
-    throw new Error(
-      "getUserMedia({ width, height }) is no longer supported for file playback. Resize or re-encode the source before calling getUserMedia()."
-    );
-  }
-}
-function createPlaybackSession({
-  input,
-  mediaStartTimestamp,
-  playbackTracks
-}) {
-  return {
-    input,
-    mediaStartTimestamp,
-    playbackTracks,
-    runners: playbackTracks.map(
-      (playbackTrack) => new TrackPlaybackRunner({
-        mediaStartTimestamp,
-        ...playbackTrack
-      })
-    )
-  };
-}
-function buildExistingTrackMap(audio, video) {
-  return {
-    ...audio ? { audio } : {},
-    ...video ? { video } : {}
-  };
-}
-function assertCodecParameters({
-  trackKind,
-  codec,
-  sourceCodec,
-  decoderDescription,
-  sourceChannels
-}) {
-  if (sourceCodec === "opus" && sourceChannels && codec.channels != void 0) {
-    if (codec.channels !== sourceChannels) {
-      throw new Error(
-        `Input ${trackKind} channels ${sourceChannels} do not match negotiated channels ${codec.channels}`
-      );
-    }
-    return;
-  }
-  if (sourceCodec !== "avc") {
-    return;
-  }
-  const negotiatedParameters = codecParametersFromString(
-    codec.parameters ?? ""
-  );
-  const negotiatedPacketizationMode = Number(
-    negotiatedParameters["packetization-mode"] ?? 1
-  );
-  if (negotiatedPacketizationMode !== 1) {
-    throw new Error(
-      `Input ${trackKind} packetization-mode 1 does not match negotiated packetization-mode ${negotiatedPacketizationMode}`
-    );
-  }
-  const sourceProfileLevelId = getH264ProfileLevelId(decoderDescription);
-  const negotiatedProfileLevelId = normalizeOptionalHexParameter(
-    negotiatedParameters["profile-level-id"]
-  );
-  if (!sourceProfileLevelId) {
-    return;
-  }
-  if (!negotiatedProfileLevelId) {
-    throw new Error(
-      `Input ${trackKind} profile-level-id ${sourceProfileLevelId} does not match negotiated profile-level-id <missing>`
-    );
-  }
-  if (sourceProfileLevelId !== negotiatedProfileLevelId) {
-    throw new Error(
-      `Input ${trackKind} profile-level-id ${sourceProfileLevelId} does not match negotiated profile-level-id ${negotiatedProfileLevelId}`
-    );
-  }
-}
-function getH264ProfileLevelId(decoderDescription) {
-  if (!decoderDescription) {
-    return void 0;
-  }
-  const description = toDescriptionBuffer2(decoderDescription);
-  if (description.length < 4) {
-    throw new Error("invalid H264 decoder configuration");
-  }
-  return description.subarray(1, 4).toString("hex");
-}
-function normalizeOptionalHexParameter(value) {
-  return typeof value === "string" ? value.toLowerCase() : void 0;
-}
-function toRtpTimestamp(packetTimestamp, mediaStartTimestamp, clockRate) {
-  const relativeSeconds = Math.max(0, packetTimestamp - mediaStartTimestamp);
-  return Math.round(relativeSeconds * clockRate) >>> 0;
-}
-function isAbortError(error) {
-  return error instanceof Error && (error.name === "AbortError" || error.message === "The operation was aborted");
-}
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-function toDescriptionBuffer2(decoderDescription) {
-  if (ArrayBuffer.isView(decoderDescription)) {
-    return Buffer.from(
-      decoderDescription.buffer,
-      decoderDescription.byteOffset,
-      decoderDescription.byteLength
-    );
-  }
-  return Buffer.from(decoderDescription);
-}
 export {
   AV1Obu,
   AV1RtpPayload,
@@ -11451,7 +10735,6 @@ export {
   getEBMLByteLength,
   getNumberByteLength,
   getSizeMask,
-  getUserMedia,
   growBufferSize,
   int,
   int16Bit,