werift 0.22.9 → 0.24.0

package/lib/nonstandard/index.mjs

@@ -1,3 +1,13 @@
+// ../rtp/src/extra/container/mp4/container.ts
+import {
+  EncodedAudioPacketSource,
+  EncodedPacket,
+  EncodedVideoPacketSource,
+  Mp4OutputFormat,
+  NullTarget,
+  Output
+} from "mediabunny";
+
 // ../common/src/binary.ts
 import { randomBytes } from "crypto";
 import { jspack } from "@shinyoshiaki/jspack";
@@ -464,7 +474,7 @@ var WeriftError = class extends Error {
 var debug = Debug.debug;
 
 // ../common/src/event.ts
-var Event = class {
+var Event2 = class {
   event = {
     stack: [],
     promiseStack: [],
@@ -570,7 +580,7 @@ var Event = class {
       error
     );
   };
-  watch = (cb, timeLimit) => new Promise((resolve, reject) => {
+  watch = (cb, timeLimit) => new Promise((resolve2, reject) => {
     const timeout = timeLimit && setTimeout(() => {
       reject("Event watch timeout");
     }, timeLimit);
@@ -579,22 +589,22 @@ var Event = class {
       if (done) {
         if (timeout) clearTimeout(timeout);
         unSubscribe();
-        resolve(args);
+        resolve2(args);
       }
     });
   });
-  asPromise = (timeLimit) => new Promise((resolve, reject) => {
+  asPromise = (timeLimit) => new Promise((resolve2, reject) => {
     const timeout = timeLimit && setTimeout(() => {
       reject("Event asPromise timeout");
     }, timeLimit);
     this.once(
       (...args) => {
         if (timeout) clearTimeout(timeout);
-        resolve(args);
+        resolve2(args);
       },
       () => {
         if (timeout) clearTimeout(timeout);
-        resolve([]);
+        resolve2([]);
       },
       (err5) => {
         if (timeout) clearTimeout(timeout);
@@ -630,7 +640,8 @@ import {
   createSocket as createSocket2
 } from "dgram";
 import * as net from "node:net";
-import { connect } 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 UdpTransport = class _UdpTransport {
   constructor(socketType, options = {}) {
@@ -717,11 +728,89 @@ var UdpTransport = class _UdpTransport {
   });
 };
 var TcpTransport = class _TcpTransport {
+  type = "tcp";
+  stream;
   constructor(addr) {
-    this.addr = addr;
+    this.stream = new StreamTransport(
+      "tcp",
+      () => connect2({ port: addr[1], host: addr[0] })
+    );
+  }
+  static async init(addr) {
+    const transport = new _TcpTransport(addr);
+    await transport.init();
+    return transport;
+  }
+  async init() {
+    await this.stream.waitForConnect();
+  }
+  get address() {
+    return this.stream.address;
+  }
+  get closed() {
+    return this.stream.closed;
+  }
+  get onData() {
+    return this.stream.onData;
+  }
+  set onData(handler) {
+    this.stream.onData = handler;
+  }
+  send = async (data, addr) => {
+    await this.stream.send(data, addr);
+  };
+  close = async () => {
+    await this.stream.close();
+  };
+};
+var TlsTransport = class _TlsTransport {
+  type = "tls";
+  stream;
+  constructor(addr, options = {}) {
+    this.stream = new StreamTransport(
+      "tls",
+      () => tls.connect({
+        ...options,
+        host: addr[0],
+        port: addr[1]
+      })
+    );
+  }
+  static async init(addr, options = {}) {
+    const transport = new _TlsTransport(addr, options);
+    await transport.init();
+    return transport;
+  }
+  async init() {
+    await this.stream.waitForConnect();
+  }
+  get address() {
+    return this.stream.address;
+  }
+  get closed() {
+    return this.stream.closed;
+  }
+  get onData() {
+    return this.stream.onData;
+  }
+  set onData(handler) {
+    this.stream.onData = handler;
+  }
+  send = async (data, addr) => {
+    await this.stream.send(data, addr);
+  };
+  close = async () => {
+    await this.stream.close();
+  };
+};
+var StreamTransport = class {
+  constructor(type, createClient, connectEvent = type === "tls" ? "secureConnect" : "connect") {
+    this.createClient = createClient;
+    this.connectEvent = connectEvent;
+    this.type = type;
     this.connect();
   }
-  type = "tcp";
+  type;
   connecting;
   client;
   onData = () => {
@@ -734,90 +823,88 @@ var TcpTransport = class _TcpTransport {
     if (this.client) {
       this.client.destroy();
     }
+    const client = this.createClient();
+    this.client = client;
     this.connecting = new Promise((r, f) => {
-      try {
-        this.client = connect({ port: this.addr[1], host: this.addr[0] }, r);
-      } catch (error) {
+      const onConnect = () => {
+        client.off("error", onConnectError);
+        r();
+      };
+      const onConnectError = (error) => {
+        client.off(this.connectEvent, onConnect);
         f(error);
-      }
+      };
+      client.once(this.connectEvent, onConnect);
+      client.once("error", onConnectError);
     });
-    this.client.on("data", (data) => {
+    client.on("data", (data) => {
       const addr = [
         this.client.remoteAddress,
         this.client.remotePort
       ];
       this.onData(data, addr);
     });
-    this.client.on("end", () => {
+    client.on("end", () => {
       this.connect();
     });
-    this.client.on("error", (error) => {
-      console.log("error", error);
+    client.on("error", (error) => {
+      log(`${this.type} transport error`, error);
     });
   }
-  async init() {
+  async waitForConnect() {
     await this.connecting;
   }
-  static async init(addr) {
-    const transport = new _TcpTransport(addr);
-    await transport.init();
-    return transport;
-  }
   get address() {
     return {};
   }
   send = async (data, addr) => {
+    void addr;
     await this.connecting;
-    this.client.write(data, (err5) => {
-      if (err5) {
-        console.log("err", err5);
-      }
+    await new Promise((resolve2, reject) => {
+      this.client.write(data, (err5) => {
+        if (err5) {
+          reject(err5);
+          return;
+        }
+        resolve2();
+      });
     });
   };
   close = async () => {
     this.closed = true;
-    this.client.destroy();
+    this.client?.destroy();
   };
 };
 
-// ../rtp/src/extra/container/mp4/mp4box.ts
-import {
-  BoxParser,
-  ISOFile,
-  Log,
-  createFile,
-  DataStream
-} from "mp4box";
-import {
-  BoxParser as BoxParser2
-} from "mp4box";
-BoxParser2.dOpsBox.prototype.write = function(stream) {
-  this.size = 11;
-  this.writeHeader(stream);
-  stream.writeUint8(0);
-  stream.writeUint8(this.OutputChannelCount);
-  stream.writeUint16(this.PreSkip);
-  stream.writeUint32(this.InputSampleRate);
-  stream.writeUint16(0);
-  stream.writeUint8(0);
-};
-
 // ../rtp/src/extra/container/mp4/container.ts
 var Mp4Container = class {
   constructor(props) {
     this.props = props;
-    this.#mp4 = new ISOFile();
-    this.#mp4.init();
   }
-  #mp4;
   #audioFrame;
+  #audioMeta;
+  #audioSource;
+  #currentFragment;
+  #ftyp;
+  #initializationEmitted = false;
+  #lastAudioDuration = 0;
+  #lastMoof;
+  #lastMoofTimestamp = 0;
+  #lastVideoDuration = 0;
+  #moov;
+  #onDataOperation = Promise.resolve();
+  #operation = Promise.resolve();
+  #output;
+  #startPromise;
+  #stopPromise;
+  #stopped = false;
   #videoFrame;
-  // 1 frame buffer
+  #videoMeta;
+  #videoSource;
   audioTrack;
+  frameBuffer = [];
+  onData = new Event2();
   videoTrack;
-  #audioSegment = 0;
-  #videoSegment = 0;
-  onData = new Event();
   get tracksReady() {
     let ready = true;
     if (this.props.track.audio && !this.audioTrack) {
@@ -836,145 +923,259 @@ var Mp4Container = class {
     }
   }
   #init(frame) {
-    let codec = frame.codec.substring(0, 4);
-    if (codec == "opus") {
-      codec = "Opus";
-    }
-    const options = {
-      type: codec,
-      timescale: 1e6
-    };
-    if (isVideoConfig(frame)) {
-      options.width = frame.codedWidth;
-      options.height = frame.codedHeight;
-    } else {
-      options.channel_count = frame.numberOfChannels;
-      options.samplerate = frame.sampleRate;
-      options.hdlr = "soun";
-    }
-    if (!frame.description) throw new Error("missing frame description");
-    const desc = frame.description;
-    if (codec === "avc1") {
-      options.avcDecoderConfigRecord = desc;
-    } else if (codec === "hev1") {
-      options.hevcDecoderConfigRecord = desc;
-    } else if (codec === "Opus") {
-      const dops = new BoxParser.dOpsBox();
-      dops.parse(new DataStream(desc, 8, DataStream.LITTLE_ENDIAN));
-      options.description = dops;
-    } else {
-      throw new Error(`unsupported codec: ${codec}`);
-    }
-    const track = this.#mp4.addTrack(options);
-    if (track == void 0) {
-      throw new Error("failed to initialize MP4 track");
-    }
     if (frame.track === "audio") {
-      this.audioTrack = track;
+      if (isVideoConfig(frame)) {
+        throw new Error("audio track requires an audio decoder config");
+      }
+      if (frame.codec !== "opus") {
+        throw new Error(`unsupported codec: ${frame.codec}`);
+      }
+      this.#audioMeta = {
+        decoderConfig: {
+          codec: "opus",
+          description: frame.description != void 0 ? new Uint8Array(frame.description) : void 0,
+          numberOfChannels: frame.numberOfChannels,
+          sampleRate: frame.sampleRate
+        }
+      };
+      this.audioTrack = 1;
     } else {
-      this.videoTrack = track;
+      if (!isVideoConfig(frame)) {
+        throw new Error("video track requires a video decoder config");
+      }
+      if (!frame.codec.startsWith("avc1")) {
+        throw new Error(`unsupported codec: ${frame.codec}`);
+      }
+      if (frame.codedWidth == void 0 || frame.codedHeight == void 0) {
+        throw new Error("missing coded video dimensions");
+      }
+      this.#videoMeta = {
+        decoderConfig: {
+          codec: frame.codec,
+          codedHeight: frame.codedHeight,
+          codedWidth: frame.codedWidth,
+          description: frame.description != void 0 ? new Uint8Array(frame.description) : void 0,
+          displayAspectHeight: frame.displayAspectHeight,
+          displayAspectWidth: frame.displayAspectWidth
+        }
+      };
+      this.videoTrack = this.props.track.audio ? 2 : 1;
     }
     if (!this.tracksReady) {
       return;
     }
-    const buffer2 = ISOFile.writeInitializationSegment(
-      this.#mp4.ftyp,
-      this.#mp4.moov,
-      0,
-      0
-    );
-    const data = new Uint8Array(buffer2);
-    const res = {
-      type: "init",
-      timestamp: 0,
-      duration: 0,
-      data,
-      kind: frame.track
-    };
-    this.onData.execute(res);
+    void this.#enqueueOperation(async () => {
+      await this.#ensureOutputStarted();
+      await this.#drainFrameBuffer();
+    });
   }
-  frameBuffer = [];
   #enqueue(frame) {
     this.frameBuffer.push(frame);
     if (!this.tracksReady) {
       return;
     }
-    for (const frame2 of this.frameBuffer) {
-      this._enqueue(frame2);
+    void this.#enqueueOperation(async () => {
+      await this.#ensureOutputStarted();
+      await this.#drainFrameBuffer();
+    });
+  }
+  stop() {
+    if (this.#stopPromise) {
+      return this.#stopPromise;
     }
+    this.#stopped = true;
+    this.#stopPromise = this.#enqueueOperation(async () => {
+      if (!this.tracksReady) {
+        this.frameBuffer = [];
+        return;
+      }
+      await this.#ensureOutputStarted();
+      await this.#drainFrameBuffer();
+      await this.#flushPendingFrame("audio");
+      await this.#flushPendingFrame("video");
+      this.#audioSource?.close();
+      this.#videoSource?.close();
+      if (this.#output) {
+        await this.#output.finalize();
+      }
+      await this.#flushOnData();
+    });
+    return this.#stopPromise;
+  }
+  async #drainFrameBuffer() {
+    const frames = this.frameBuffer;
     this.frameBuffer = [];
+    for (const frame of frames) {
+      await this.#processFrame(frame);
+    }
   }
-  _enqueue(frame) {
-    const track = frame.track === "audio" ? this.audioTrack : this.videoTrack;
-    if (!track) {
-      throw new Error("track missing");
+  async #ensureOutputStarted() {
+    if (this.#startPromise) {
+      await this.#startPromise;
+      return;
     }
-    if (frame.track === "video") {
-      if (frame.type == "key") {
-        this.#videoSegment += 1;
-      } else if (this.#videoSegment == 0) {
-        throw new Error("must start with keyframe");
-      }
-    } else {
-      this.#audioSegment += 1;
+    if (!this.tracksReady) {
+      return;
     }
-    if (frame.track === "video") {
-      if (!this.#videoFrame) {
-        this.#videoFrame = frame;
-        return;
-      }
+    const output = new Output({
+      format: new Mp4OutputFormat({
+        fastStart: "fragmented",
+        minimumFragmentDuration: 0,
+        onFtyp: (data) => {
+          this.#ftyp = copyBytes(data);
+        },
+        onMdat: (data) => {
+          if (!this.#lastMoof) {
+            throw new Error("moof missing before mdat");
+          }
+          const fragment = this.#currentFragment;
+          const timestamp = fragment ? fragment.timestamp : Math.round(this.#lastMoofTimestamp * 1e6);
+          const duration = fragment?.duration ?? 0;
+          const kind = fragment?.kind ?? this.#defaultKind();
+          const type = fragment?.type ?? "key";
+          const segment = concatBytes(this.#lastMoof, data);
+          this.#currentFragment = void 0;
+          this.#lastMoof = void 0;
+          void this.#emitData({
+            type,
+            timestamp,
+            duration,
+            data: segment,
+            kind
+          });
+        },
+        onMoof: (data, _position, timestamp) => {
+          this.#lastMoof = copyBytes(data);
+          this.#lastMoofTimestamp = timestamp;
+        },
+        onMoov: (data) => {
+          this.#moov = copyBytes(data);
+          this.#emitInitializationSegment();
+        }
+      }),
+      target: new NullTarget()
+    });
+    if (this.#audioMeta) {
+      this.#audioSource = new EncodedAudioPacketSource("opus");
+      output.addAudioTrack(this.#audioSource);
+    }
+    if (this.#videoMeta) {
+      this.#videoSource = new EncodedVideoPacketSource("avc");
+      output.addVideoTrack(this.#videoSource);
+    }
+    this.#output = output;
+    this.#startPromise = output.start();
+    await this.#startPromise;
+  }
+  #emitInitializationSegment() {
+    if (this.#initializationEmitted || !this.#ftyp || !this.#moov) {
+      return;
+    }
+    this.#initializationEmitted = true;
+    void this.#emitData({
+      type: "init",
+      timestamp: 0,
+      duration: 0,
+      data: concatBytes(this.#ftyp, this.#moov),
+      kind: this.#defaultKind()
+    });
+  }
+  #emitData(data) {
+    const next = this.#onDataOperation.then(() => this.onData.execute(data));
+    this.#onDataOperation = next;
+    return next;
+  }
+  async #flushOnData() {
+    await this.#onDataOperation;
+  }
+  #enqueueOperation(operation) {
+    const next = this.#operation.then(operation);
+    this.#operation = next;
+    return next;
+  }
+  #defaultKind() {
+    return this.props.track.video ? "video" : "audio";
+  }
+  async #flushPendingFrame(track) {
+    const buffered = track === "audio" ? this.#audioFrame : this.#videoFrame;
+    if (!buffered) {
+      return;
+    }
+    const duration = track === "audio" ? this.#lastAudioDuration : this.#lastVideoDuration;
+    await this.#writePacket(buffered, duration);
+    if (track === "audio") {
+      this.#audioFrame = void 0;
     } else {
-      if (!this.#audioFrame) {
+      this.#videoFrame = void 0;
+    }
+  }
+  async #processFrame(frame) {
+    const buffered = frame.track === "audio" ? this.#audioFrame : this.#videoFrame;
+    if (!buffered) {
+      if (frame.track === "audio") {
         this.#audioFrame = frame;
-        return;
+      } else {
+        this.#videoFrame = frame;
       }
+      return;
     }
-    const bufferFrame = frame.track === "video" ? this.#videoFrame : this.#audioFrame;
-    if (!bufferFrame) {
-      throw new Error("bufferFrame missing");
-    }
-    const duration = frame.timestamp - bufferFrame.timestamp;
-    const buffer2 = new ArrayBuffer(bufferFrame.byteLength);
-    bufferFrame.copyTo(buffer2);
-    this.#mp4.addSample(track, buffer2, {
-      duration,
-      dts: bufferFrame.timestamp,
-      cts: bufferFrame.timestamp,
-      is_sync: bufferFrame.type == "key"
-    });
-    const stream = new DataStream(void 0, 0, DataStream.BIG_ENDIAN);
-    for (; ; ) {
-      const moof = this.#mp4.moofs.shift();
-      const mdat = this.#mp4.mdats.shift();
-      if (!moof && !mdat) break;
-      if (!moof) throw new Error("moof missing");
-      if (!mdat) throw new Error("mdat missing");
-      moof.write(stream);
-      mdat.write(stream);
-    }
-    const data = new Uint8Array(stream.buffer);
-    if (frame.track === "video") {
+    const duration = Math.max(frame.timestamp - buffered.timestamp, 0);
+    await this.#writePacket(buffered, duration);
+    if (frame.track === "audio") {
+      this.#audioFrame = frame;
+      this.#lastAudioDuration = duration;
+    } else {
       this.#videoFrame = frame;
+      this.#lastVideoDuration = duration;
+    }
+  }
+  async #writePacket(frame, duration) {
+    const data = new Uint8Array(frame.byteLength);
+    frame.copyTo(data.buffer);
+    const packet = new EncodedPacket(
+      data,
+      frame.type,
+      frame.timestamp / 1e6,
+      duration / 1e6
+    );
+    if (frame.track === "audio") {
+      if (!this.#audioSource || !this.#audioMeta) {
+        throw new Error("audio track missing");
+      }
+      await this.#audioSource.add(packet, this.#audioMeta);
     } else {
-      this.#audioFrame = frame;
+      if (!this.#videoSource || !this.#videoMeta) {
+        throw new Error("video track missing");
+      }
+      await this.#videoSource.add(packet, this.#videoMeta);
     }
-    const res = {
-      type: bufferFrame.type,
-      timestamp: bufferFrame.timestamp,
-      kind: frame.track,
-      duration,
-      data
-    };
-    this.onData.execute(res);
+    this.#rememberFragmentPacket(
+      frame.track,
+      frame.type,
+      frame.timestamp,
+      duration
+    );
   }
-  /* TODO flush the last frame
-  #flush(controller: TransformStreamDefaultController<Chunk>) {
-  	if (this.#frame) {
-  		// TODO guess the duration
-  		this.#enqueue(this.#frame, 0, controller)
-  	}
+  #rememberFragmentPacket(kind, type, timestamp, duration) {
+    const end = timestamp + duration;
+    if (!this.#currentFragment) {
+      this.#currentFragment = {
+        kind,
+        type,
+        timestamp,
+        duration
+      };
+      return;
+    }
+    if (kind === "video" && type === "key") {
+      this.#currentFragment.type = "key";
+    }
+    const fragmentEnd = Math.max(
+      this.#currentFragment.timestamp + this.#currentFragment.duration,
+      end
+    );
+    this.#currentFragment.duration = fragmentEnd - this.#currentFragment.timestamp;
   }
-  */
 };
 function isDecoderConfig(frame) {
   return frame.codec !== void 0;
@@ -983,6 +1184,19 @@ function isVideoConfig(frame) {
   return frame.codedWidth !== void 0;
 }
 var mp4SupportedCodecs = ["avc1", "opus"];
+function concatBytes(...parts) {
+  const size = parts.reduce((sum, part) => sum + part.byteLength, 0);
+  const combined = new Uint8Array(size);
+  let offset = 0;
+  for (const part of parts) {
+    combined.set(part, offset);
+    offset += part.byteLength;
+  }
+  return combined;
+}
+function copyBytes(data) {
+  return new Uint8Array(data);
+}
 
 // ../rtp/src/extra/container/mp4/exp-golomb.ts
 var ExpGolomb = class {
@@ -1521,6 +1735,18 @@ function annexb2avcc(data) {
   );
   return avcc.getData();
 }
+function annexb2avcSample(data) {
+  const annexbParser = new H264AnnexBParser(data);
+  const nalUnits = [];
+  let naluPayload = null;
+  while ((naluPayload = annexbParser.readNextNaluPayload()) != null) {
+    nalUnits.push(Buffer.from(new H264NaluAVC1(naluPayload).data));
+  }
+  if (nalUnits.length === 0) {
+    throw new Error("annexb sample does not contain nal units");
+  }
+  return Buffer.concat(nalUnits);
+}
 
 // ../rtp/src/extra/container/ogg/parser.ts
 var OggParser = class {
@@ -4477,7 +4703,12 @@ import { createHmac as createHmac2 } from "crypto";
 import AES from "aes-js";
 
 // ../rtp/src/srtp/cipher/ctr.ts
-import { createCipheriv as createCipheriv2, createDecipheriv, createHmac } from "crypto";
+import {
+  createCipheriv as createCipheriv2,
+  createDecipheriv,
+  createHmac,
+  timingSafeEqual
+} from "crypto";
 
 // ../rtp/src/srtp/cipher/index.ts
 var CipherAesBase = class {
@@ -4490,7 +4721,7 @@ var CipherAesBase = class {
   encryptRtp(header, payload, rolloverCounter) {
     return Buffer.from([]);
   }
-  decryptRtp(cipherText, rolloverCounter) {
+  decryptRtp(cipherText, rolloverCounter, header) {
     return [];
   }
   encryptRTCP(rawRtcp, srtcpIndex) {
@@ -4501,6 +4732,74 @@ var CipherAesBase = class {
   }
 };
 
+// ../rtp/src/srtp/error.ts
+var SrtpAuthenticationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SrtpAuthenticationError";
+  }
+};
+
+// ../rtp/src/srtp/packet.ts
+var minRtpHeaderSize = 12;
+var minRtcpPacketSize = 8;
+function parseSrtpRtpHeader(packet, authTagLength, message = "Failed to authenticate SRTP packet") {
+  const authTagOffset = packet.length - authTagLength;
+  assertAuthenticatedPacketLength(
+    packet.length >= minRtpHeaderSize + authTagLength,
+    message
+  );
+  const header = wrapAuthenticationError(
+    () => RtpHeader.deSerialize(packet.subarray(0, authTagOffset)),
+    message
+  );
+  header.paddingSize = 0;
+  assertAuthenticatedPacketLength(
+    header.payloadOffset >= minRtpHeaderSize && header.payloadOffset <= authTagOffset,
+    message
+  );
+  return header;
+}
+function parseSrtcpHeader(packet, authTagLength, srtcpIndexSize3, message = "Failed to authenticate SRTCP packet") {
+  assertAuthenticatedPacketLength(
+    packet.length >= minRtcpPacketSize + authTagLength + srtcpIndexSize3,
+    message
+  );
+  return wrapAuthenticationError(
+    () => RtcpHeader.deSerialize(packet.subarray(0, RTCP_HEADER_SIZE)),
+    message
+  );
+}
+function assertAuthenticatedPacketLength(condition, message) {
+  if (!condition) {
+    throw new SrtpAuthenticationError(message);
+  }
+}
+function wrapAuthenticationError(parse, message) {
+  try {
+    return parse();
+  } catch {
+    throw new SrtpAuthenticationError(message);
+  }
+}
+function finalizeSrtpRtpHeader(header, packet, message = "Failed to authenticate SRTP packet") {
+  if (!header.padding) {
+    header.paddingSize = 0;
+    return header;
+  }
+  assertAuthenticatedPacketLength(
+    packet.length > header.payloadOffset,
+    message
+  );
+  const paddingSize = packet[packet.length - 1];
+  assertAuthenticatedPacketLength(
+    paddingSize > 0 && paddingSize <= packet.length - header.payloadOffset,
+    message
+  );
+  header.paddingSize = paddingSize;
+  return header;
+}
+
 // ../rtp/src/srtp/cipher/ctr.ts
 var CipherAesCtr = class extends CipherAesBase {
   constructor(srtpSessionKey, srtpSessionSalt, srtcpSessionKey, srtcpSessionSalt, srtpSessionAuthTag, srtcpSessionAuthTag) {
@@ -4526,10 +4825,20 @@ var CipherAesCtr = class extends CipherAesBase {
     );
     return Buffer.concat([headerBuffer, enc, authTag]);
   }
-  decryptRtp(cipherText, rolloverCounter) {
-    const header = RtpHeader.deSerialize(cipherText);
-    const size = cipherText.length - this.authTagLength;
-    cipherText = cipherText.subarray(0, cipherText.length - this.authTagLength);
+  decryptRtp(cipherText, rolloverCounter, header = parseSrtpRtpHeader(cipherText, this.authTagLength)) {
+    const authTagOffset = cipherText.length - this.authTagLength;
+    const encryptedPacket = cipherText.subarray(0, authTagOffset);
+    const actualAuthTag = cipherText.subarray(authTagOffset);
+    const expectedAuthTag = this.generateSrtpAuthTag(
+      rolloverCounter,
+      encryptedPacket.subarray(0, header.payloadOffset),
+      encryptedPacket.subarray(header.payloadOffset)
+    );
+    assertAuthTag(
+      actualAuthTag,
+      expectedAuthTag,
+      "Failed to authenticate SRTP packet"
+    );
     const counter = this.generateCounter(
       header.sequenceNumber,
       rolloverCounter,
@@ -4541,14 +4850,16 @@ var CipherAesCtr = class extends CipherAesBase {
       this.srtpSessionKey,
       counter
     );
-    const payload = cipherText.subarray(header.payloadOffset);
+    const payload = encryptedPacket.subarray(header.payloadOffset);
     const buf = cipher.update(payload);
     const dst = Buffer.concat([
-      cipherText.subarray(0, header.payloadOffset),
-      buf,
-      Buffer.alloc(size - header.payloadOffset - buf.length)
+      encryptedPacket.subarray(0, header.payloadOffset),
+      buf
     ]);
-    return [dst, header];
+    return [
+      dst,
+      finalizeSrtpRtpHeader(header, dst, "Failed to authenticate SRTP packet")
+    ];
   }
   encryptRTCP(rtcpPacket, srtcpIndex) {
     let out = Buffer.from(rtcpPacket);
@@ -4570,15 +4881,29 @@ var CipherAesCtr = class extends CipherAesBase {
     return out;
   }
   decryptRTCP(encrypted) {
-    const header = RtcpHeader.deSerialize(encrypted);
+    const header = parseSrtcpHeader(
+      encrypted,
+      this.authTagLength,
+      srtcpIndexSize
+    );
     const tailOffset = encrypted.length - (this.authTagLength + srtcpIndexSize);
+    const authenticatedPortion = encrypted.subarray(
+      0,
+      encrypted.length - this.authTagLength
+    );
+    const actualTag = encrypted.subarray(encrypted.length - this.authTagLength);
+    const expectedTag = this.generateSrtcpAuthTag(authenticatedPortion);
+    assertAuthTag(
+      actualTag,
+      expectedTag,
+      "Failed to authenticate SRTCP packet"
+    );
     const out = Buffer.from(encrypted).slice(0, tailOffset);
-    const isEncrypted = encrypted[tailOffset] >> 7;
+    const isEncrypted = encrypted[tailOffset] >>> 7;
     if (isEncrypted === 0) return [out, header];
     let srtcpIndex = encrypted.readUInt32BE(tailOffset);
     srtcpIndex &= ~(1 << 31);
     const ssrc = encrypted.readUInt32BE(4);
-    const actualTag = encrypted.subarray(encrypted.length - 10);
     const counter = this.generateCounter(
       srtcpIndex & 65535,
       srtcpIndex >> 16,
@@ -4619,6 +4944,11 @@ var CipherAesCtr = class extends CipherAesBase {
   }
 };
 var srtcpIndexSize = 4;
+function assertAuthTag(actual, expected, message) {
+  if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
+    throw new SrtpAuthenticationError(message);
+  }
+}
 
 // ../rtp/src/srtp/cipher/gcm.ts
 import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv2 } from "crypto";
@@ -4641,20 +4971,25 @@ var CipherAesGcm = class extends CipherAesBase {
     const dst = Buffer.concat([hdr, enc, authTag]);
     return dst;
   }
-  decryptRtp(cipherText, rolloverCounter) {
-    const header = RtpHeader.deSerialize(cipherText);
+  decryptRtp(cipherText, rolloverCounter, header = parseSrtpRtpHeader(cipherText, this.aeadAuthTagLen)) {
+    const headerBuffer = cipherText.subarray(0, header.payloadOffset);
+    const authTagOffset = cipherText.length - this.aeadAuthTagLen;
+    const authTag = cipherText.subarray(authTagOffset);
     let dst = Buffer.from([]);
     dst = growBufferSize(dst, cipherText.length - this.aeadAuthTagLen);
-    cipherText.slice(0, header.payloadOffset).copy(dst);
+    headerBuffer.copy(dst);
     const iv = this.rtpInitializationVector(header, rolloverCounter);
-    const enc = cipherText.slice(
-      header.payloadOffset,
-      cipherText.length - this.aeadAuthTagLen
-    );
-    const cipher = createDecipheriv2("aes-128-gcm", this.srtpSessionKey, iv);
-    const dec = cipher.update(enc);
+    const enc = cipherText.slice(header.payloadOffset, authTagOffset);
+    const decipher = createDecipheriv2("aes-128-gcm", this.srtpSessionKey, iv);
+    decipher.setAAD(headerBuffer);
+    decipher.setAuthTag(authTag);
+    const dec = decipher.update(enc);
+    finalizeAuthenticatedDecryption(decipher, "SRTP");
     dec.copy(dst, header.payloadOffset);
-    return [dst, header];
+    return [
+      dst,
+      finalizeSrtpRtpHeader(header, dst, "Failed to authenticate SRTP packet")
+    ];
   }
   encryptRTCP(rtcpPacket, srtcpIndex) {
     const ssrc = rtcpPacket.readUInt32BE(4);
@@ -4675,19 +5010,38 @@ var CipherAesGcm = class extends CipherAesBase {
     return dst;
   }
   decryptRTCP(encrypted) {
-    const header = RtcpHeader.deSerialize(encrypted);
-    const aadPos = encrypted.length - srtcpIndexSize2;
-    const dst = Buffer.alloc(aadPos - this.aeadAuthTagLen);
-    encrypted.slice(0, 8).copy(dst);
+    const header = parseSrtcpHeader(
+      encrypted,
+      this.aeadAuthTagLen,
+      srtcpIndexSize2
+    );
+    const srtcpIndexOffset = encrypted.length - srtcpIndexSize2;
+    const authTagOffset = srtcpIndexOffset - this.aeadAuthTagLen;
     const ssrc = encrypted.readUInt32BE(4);
-    let srtcpIndex = encrypted.readUInt32BE(encrypted.length - 4);
-    srtcpIndex &= ~(rtcpEncryptionFlag << 24);
+    const encodedSrtcpIndex = encrypted.readUInt32BE(srtcpIndexOffset);
+    const isEncrypted = encodedSrtcpIndex >>> 31 === 1;
+    const srtcpIndex = encodedSrtcpIndex & ~(rtcpEncryptionFlag << 24);
     const iv = this.rtcpInitializationVector(ssrc, srtcpIndex);
-    const aad = this.rtcpAdditionalAuthenticatedData(encrypted, srtcpIndex);
-    const cipher = createDecipheriv2("aes-128-gcm", this.srtcpSessionKey, iv);
-    cipher.setAAD(aad);
-    const dec = cipher.update(encrypted.slice(8, aadPos));
-    dec.copy(dst, 8);
+    const aad = isEncrypted ? Buffer.concat([
+      encrypted.subarray(0, 8),
+      encrypted.subarray(srtcpIndexOffset)
+    ]) : Buffer.concat([
+      encrypted.subarray(0, authTagOffset),
+      encrypted.subarray(srtcpIndexOffset)
+    ]);
+    const cipherText = isEncrypted ? encrypted.slice(8, authTagOffset) : Buffer.alloc(0);
+    const dst = isEncrypted ? Buffer.alloc(authTagOffset) : Buffer.from(encrypted.subarray(0, authTagOffset));
+    if (isEncrypted) {
+      encrypted.slice(0, 8).copy(dst);
+    }
+    const decipher = createDecipheriv2("aes-128-gcm", this.srtcpSessionKey, iv);
+    decipher.setAAD(aad);
+    decipher.setAuthTag(encrypted.subarray(authTagOffset, srtcpIndexOffset));
+    const dec = decipher.update(cipherText);
+    finalizeAuthenticatedDecryption(decipher, "SRTCP");
+    if (isEncrypted) {
+      dec.copy(dst, 8);
+    }
     return [dst, header];
   }
   // https://tools.ietf.org/html/rfc7714#section-8.1
@@ -4723,6 +5077,15 @@ var CipherAesGcm = class extends CipherAesBase {
 };
 var srtcpIndexSize2 = 4;
 var rtcpEncryptionFlag = 128;
+function finalizeAuthenticatedDecryption(decipher, packetType) {
+  try {
+    decipher.final();
+  } catch {
+    throw new SrtpAuthenticationError(
+      `Failed to authenticate ${packetType} packet`
+    );
+  }
+}
 
 // ../rtp/src/srtp/context/context.ts
 var Context = class {
@@ -4980,12 +5343,29 @@ var SrtpContext = class extends Context {
     return enc;
   }
   decryptRtp(cipherText) {
-    const header = RtpHeader.deSerialize(cipherText);
-    const s = this.getSrtpSsrcState(header.ssrc);
-    this.updateRolloverCount(header.sequenceNumber, s);
-    const dec = this.cipher.decryptRtp(cipherText, s.rolloverCounter);
+    const header = parseSrtpRtpHeader(cipherText, this.rtpAuthTagLength);
+    const existingState = this.srtpSSRCStates[header.ssrc];
+    const nextState = existingState ? { ...existingState } : {
+      ssrc: header.ssrc,
+      rolloverCounter: 0,
+      lastSequenceNumber: 0
+    };
+    this.updateRolloverCount(header.sequenceNumber, nextState);
+    const dec = this.cipher.decryptRtp(
+      cipherText,
+      nextState.rolloverCounter,
+      header
+    );
+    if (existingState) {
+      Object.assign(existingState, nextState);
+    } else {
+      this.srtpSSRCStates[header.ssrc] = nextState;
+    }
     return dec;
   }
+  get rtpAuthTagLength() {
+    return this.profile === ProtectionProfileAeadAes128Gcm ? 16 : 10;
+  }
 };
 
 // ../rtp/src/srtp/srtp.ts
@@ -5048,7 +5428,7 @@ var DepacketizeBase = class {
   frameBroken = false;
   keyframeReceived = false;
   count = 0;
-  onNeedKeyFrame = new Event();
+  onNeedKeyFrame = new Event2();
   internalStats = {};
   toJSON() {
     return {
@@ -5408,17 +5788,17 @@ var JitterBufferBase = class {
     this.rtpBuffer[rtp.header.sequenceNumber] = rtp;
   }
   resolveBuffer(seqNumFrom) {
-    const resolve = [];
+    const resolve2 = [];
     for (let index = seqNumFrom; ; index = uint16Add(index, 1)) {
       const rtp = this.rtpBuffer[index];
       if (rtp) {
-        resolve.push(rtp);
+        resolve2.push(rtp);
         delete this.rtpBuffer[index];
       } else {
         break;
       }
     }
-    return resolve;
+    return resolve2;
   }
   sortAndClearBuffer(rtpBuffer) {
     const buffer2 = [];
@@ -5717,94 +6097,125 @@ var MP4Base = class {
         video: !!this.tracks.find((t) => t.kind === "video")
       }
     });
-    this.container.onData.subscribe((data) => {
-      this.output(data);
+    this.container.onData.subscribe(async (data) => {
+      await this.output(data);
     });
   }
+  audioStopped = false;
   internalStats = {};
   container;
   stopped = false;
-  onStopped = new Event();
+  onStopped = new Event2();
+  videoStopped = false;
   toJSON() {
     return {
       ...this.internalStats
     };
   }
-  processAudioInput = ({ frame }) => {
-    const track = this.tracks.find((t) => t.kind === "audio");
-    if (frame) {
-      if (!this.container.audioTrack) {
+  processVideoInput = ({ eol, frame }) => {
+    if (this.stopped) {
+      return;
+    }
+    if (!frame) {
+      if (eol) {
+        this.videoStopped = true;
+        if (!this.tracks.some((track2) => track2.kind === "audio") || this.audioStopped) {
+          void this.stop();
+        }
+      }
+      return;
+    }
+    const track = this.tracks.find((t) => t.kind === "video");
+    this.videoStopped = false;
+    if (!this.container.videoTrack) {
+      if (frame.isKeyframe) {
+        const avcc = annexb2avcc(frame.data);
+        const sample = annexb2avcSample(frame.data);
+        const [displayAspectWidth, displayAspectHeight] = computeRatio(
+          track.width,
+          track.height
+        );
         this.container.write({
-          codec: track.codec,
-          description: buffer2ArrayBuffer(
-            OpusRtpPayload.createCodecPrivate()
-          ),
-          numberOfChannels: 2,
-          sampleRate: track.clockRate,
-          track: "audio"
+          codec: avccToCodecString(avcc),
+          codedWidth: track.width,
+          codedHeight: track.height,
+          description: toArrayBuffer(Buffer.from(avcc)),
+          displayAspectWidth,
+          displayAspectHeight,
+          track: "video"
         });
-      } else {
         this.container.write({
-          byteLength: frame.data.length,
+          byteLength: sample.length,
           duration: null,
           timestamp: frame.time * 1e3,
           type: "key",
           copyTo: (destination) => {
-            frame.data.copy(destination);
+            new Uint8Array(destination).set(sample);
           },
-          track: "audio"
+          track: "video"
         });
       }
+    } else {
+      const sample = annexb2avcSample(frame.data);
+      this.container.write({
+        byteLength: sample.length,
+        duration: null,
+        timestamp: frame.time * 1e3,
+        type: frame.isKeyframe ? "key" : "delta",
+        copyTo: (destination) => {
+          new Uint8Array(destination).set(sample);
+        },
+        track: "video"
+      });
     }
   };
-  processVideoInput = ({ frame }) => {
-    const track = this.tracks.find((t) => t.kind === "video");
-    if (frame) {
-      if (!this.container.videoTrack) {
-        if (frame.isKeyframe) {
-          const avcc = annexb2avcc(frame.data);
-          const [displayAspectWidth, displayAspectHeight] = computeRatio(
-            track.width,
-            track.height
-          );
-          this.container.write({
-            codec: track.codec,
-            codedWidth: track.width,
-            codedHeight: track.height,
-            description: avcc.buffer,
-            displayAspectWidth,
-            displayAspectHeight,
-            track: "video"
-          });
-          this.container.write({
-            byteLength: frame.data.length,
-            duration: null,
-            timestamp: frame.time * 1e3,
-            type: "key",
-            copyTo: (destination) => {
-              frame.data.copy(destination);
-            },
-            track: "video"
-          });
+  processAudioInput = ({ eol, frame }) => {
+    if (this.stopped) {
+      return;
+    }
+    if (!frame) {
+      if (eol) {
+        this.audioStopped = true;
+        if (!this.tracks.some((track2) => track2.kind === "video") || this.videoStopped) {
+          void this.stop();
         }
-      } else {
-        this.container.write({
-          byteLength: frame.data.length,
-          duration: null,
-          timestamp: frame.time * 1e3,
-          type: frame.isKeyframe ? "key" : "delta",
-          copyTo: (destination) => {
-            frame.data.copy(destination);
-          },
-          track: "video"
-        });
       }
+      return;
     }
-  };
-  start() {
-  }
-  stop() {
-  }
+    const track = this.tracks.find((t) => t.kind === "audio");
+    this.audioStopped = false;
+    if (!this.container.audioTrack) {
+      this.container.write({
+        codec: track.codec,
+        description: toArrayBuffer(OpusRtpPayload.createCodecPrivate()),
+        numberOfChannels: 2,
+        sampleRate: track.clockRate,
+        track: "audio"
+      });
+    } else {
+      this.container.write({
+        byteLength: frame.data.length,
+        duration: null,
+        timestamp: frame.time * 1e3,
+        type: "key",
+        copyTo: (destination) => {
+          new Uint8Array(destination).set(frame.data);
+        },
+        track: "audio"
+      });
+    }
+  };
+  start() {
+  }
+  async stop() {
+    if (this.stopped) {
+      return;
+    }
+    this.stopped = true;
+    await this.container.stop();
+    await this.output({ eol: true });
+    await this.onStopped.execute();
+  }
 };
 function computeRatio(a, b) {
   function gcd(x, y) {
@@ -5818,6 +6229,21 @@ function computeRatio(a, b) {
   const divisor = gcd(a, b);
   return [a / divisor, b / divisor];
 }
+function avccToCodecString(avcc) {
+  if (avcc.byteLength < 4) {
+    throw new Error("invalid avcc decoder configuration record");
+  }
+  return `avc1.${toHex(avcc[1])}${toHex(avcc[2])}${toHex(avcc[3])}`;
+}
+function toHex(value) {
+  return value.toString(16).padStart(2, "0");
+}
+function toArrayBuffer(buffer2) {
+  return buffer2.buffer.slice(
+    buffer2.byteOffset,
+    buffer2.byteOffset + buffer2.byteLength
+  );
+}
 
 // ../rtp/src/extra/processor/mp4Callback.ts
 import { appendFile } from "fs/promises";
@@ -5847,14 +6273,16 @@ var MP4Callback = class extends MP4Base {
     this.processVideoInput(input);
   };
   destroy = () => {
-    this.cb = void 0;
-    this.queue.cancel();
+    void this.stop().finally(() => {
+      this.cb = void 0;
+      this.queue.cancel();
+    });
   };
   static saveToFileSystem = (path2) => {
     const queue = new PromiseQueue();
     return async (value) => {
       await queue.push(async () => {
-        if (value.data) {
+        if ("data" in value) {
           await appendFile(path2, value.data);
         } else if (value.eol) {
         }
@@ -6017,8 +6445,8 @@ var NackHandlerBase = class {
   _lost = {};
   clearNackInterval;
   internalStats = {};
-  onNackSent = new Event();
-  onPacketLost = new Event();
+  onNackSent = new Event2();
+  onPacketLost = new Event2();
   mediaSourceSsrc;
   retryCount = 10;
   stopped = false;
@@ -6164,7 +6592,7 @@ var WebmBase = class {
   stopped = false;
   videoKeyframeReceived = false;
   internalStats = {};
-  onStopped = new Event();
+  onStopped = new Event2();
   toJSON() {
     return {
       ...this.internalStats,
@@ -6557,7 +6985,7 @@ var NtpTimeCallback = class extends SimpleProcessorCallbackBase(NtpTimeBase) {
 var RtcpSourceCallback = class {
   cb;
   destructor;
-  onStopped = new Event();
+  onStopped = new Event2();
   toJSON() {
     return {};
   }
@@ -6595,7 +7023,7 @@ var RtpSourceCallback = class {
   }
   cb;
   destructor;
-  onStopped = new Event();
+  onStopped = new Event2();
   stats = {};
   buffer = [];
   bufferFulfilled = false;
@@ -6831,9 +7259,7 @@ var WebmStream = class extends WebmBase {
 };
 
 // src/nonstandard/navigator.ts
-import { randomBytes as randomBytes5 } from "crypto";
 import { createSocket as createSocket3 } from "dgram";
-import { jspack as jspack8 } from "@shinyoshiaki/jspack";
 
 // ../dtls/src/context/cipher.ts
 import { createSign, randomBytes as randomBytes3, webcrypto } from "crypto";
@@ -8508,6 +8934,16 @@ handlers2[16 /* client_key_exchange_16 */] = ({ cipher, dtls }) => (message) =>
   );
   log18(dtls.sessionId, "setup cipher", cipher.cipher.summary);
 };
+handlers2[11 /* certificate_11 */] = ({ cipher, dtls }) => (message) => {
+  log18(dtls.sessionId, "handshake certificate", message);
+  cipher.remoteCertificate = message.certificateList[0];
+};
+handlers2[15 /* certificate_verify_15 */] = ({ cipher, dtls }) => (message) => {
+  if (!cipher.remoteCertificate) {
+    throw new Error("client certificate missing before certificate verify");
+  }
+  log18(dtls.sessionId, "certificate_verify", message.algorithm);
+};
 handlers2[20 /* finished_20 */] = ({ dtls }) => (message) => {
   log18(dtls.sessionId, "finished", message);
 };
@@ -8515,12 +8951,12 @@ handlers2[20 /* finished_20 */] = ({ dtls }) => (message) => {
 // ../dtls/src/server.ts
 var log19 = debug("werift-dtls : packages/dtls/src/server.ts : log");
 
-// ../ice/src/stun/const.ts
+// ../ice-server/src/stun/const.ts
 var COOKIE = 554869826;
 var IPV4_PROTOCOL = 1;
 var IPV6_PROTOCOL = 2;
 
-// ../ice/src/stun/attributes.ts
+// ../ice-server/src/stun/attributes.ts
 import * as Int64 from "int64-buffer";
 import nodeIp from "ip";
 function packAddress(value) {
@@ -8533,26 +8969,31 @@ function packAddress(value) {
   return Buffer.concat([buffer2, nodeIp.toBuffer(address)]);
 }
 function unpackErrorCode(data) {
-  if (data.length < 4) throw new Error("STUN error code is less than 4 bytes");
+  if (data.length < 4) {
+    throw new Error("STUN error code is less than 4 bytes");
+  }
   const codeHigh = data.readUInt8(2);
   const codeLow = data.readUInt8(3);
   const reason = data.slice(4).toString("utf8");
   return [codeHigh * 100 + codeLow, reason];
 }
 function unpackAddress(data) {
-  if (data.length < 4)
+  if (data.length < 4) {
     throw new Error("STUN address length is less than 4 bytes");
+  }
   const protocol = data.readUInt8(1);
   const port = data.readUInt16BE(2);
   const address = data.slice(4);
   switch (protocol) {
     case IPV4_PROTOCOL:
-      if (address.length != 4)
-        throw new Error(`STUN address has invalid length for IPv4`);
+      if (address.length !== 4) {
+        throw new Error("STUN address has invalid length for IPv4");
+      }
       return [nodeIp.toString(address), port];
     case IPV6_PROTOCOL:
-      if (address.length != 16)
+      if (address.length !== 16) {
         throw new Error("STUN address has invalid length for IPv6");
+      }
       return [nodeIp.toString(address), port];
     default:
       throw new Error("STUN address has unknown protocol");
@@ -8580,8 +9021,25 @@ function packErrorCode(value) {
   buffer2.writeUInt16BE(0, 0);
   buffer2.writeUInt8(Math.floor(value[0] / 100), 2);
   buffer2.writeUInt8(value[0] % 100, 3);
-  const encode20 = Buffer.from(value[1], "utf8");
-  return Buffer.concat([buffer2, encode20]);
+  const encoded = Buffer.from(value[1], "utf8");
+  return Buffer.concat([buffer2, encoded]);
+}
+function packUnknownAttributes(value) {
+  const buffer2 = Buffer.alloc(value.length * 2);
+  value.forEach((attributeType, index) => {
+    buffer2.writeUInt16BE(attributeType, index * 2);
+  });
+  return buffer2;
+}
+function unpackUnknownAttributes(data) {
+  if (data.length % 2 !== 0) {
+    throw new Error("UNKNOWN-ATTRIBUTES must have an even length");
+  }
+  const attributes = [];
+  for (let offset = 0; offset < data.length; offset += 2) {
+    attributes.push(data.readUInt16BE(offset));
+  }
+  return attributes;
 }
 function packXorAddress(value, transactionId) {
   return xorAddress(packAddress(value), transactionId);
@@ -8607,10 +9065,16 @@ var unpackUnsigned64 = (data) => {
 };
 var packString = (value) => Buffer.from(value, "utf8");
 var unpackString = (data) => data.toString("utf8");
+var packSoftware = (value) => {
+  if ([...value].length >= 128) {
+    throw new Error("SOFTWARE must be shorter than 128 characters");
+  }
+  return packString(value);
+};
 var packBytes = (value) => value;
 var unpackBytes = (data) => data;
-var packNone = (value) => Buffer.from([]);
-var unpackNone = (data) => null;
+var packNone = () => Buffer.alloc(0);
+var unpackNone = () => null;
 var ATTRIBUTES = [
   [1, "MAPPED-ADDRESS", packAddress, unpackAddress],
   [3, "CHANGE-REQUEST", packUnsigned, unpackUnsigned],
@@ -8619,6 +9083,12 @@ var ATTRIBUTES = [
   [6, "USERNAME", packString, unpackString],
   [8, "MESSAGE-INTEGRITY", packBytes, unpackBytes],
   [9, "ERROR-CODE", packErrorCode, unpackErrorCode],
+  [
+    10,
+    "UNKNOWN-ATTRIBUTES",
+    packUnknownAttributes,
+    unpackUnknownAttributes
+  ],
   [12, "CHANNEL-NUMBER", packUnsignedShort, unpackUnsignedShort],
   [13, "LIFETIME", packUnsigned, unpackUnsigned],
   [18, "XOR-PEER-ADDRESS", packXorAddress, unpackXorAddress],
@@ -8626,11 +9096,20 @@ var ATTRIBUTES = [
   [20, "REALM", packString, unpackString],
   [21, "NONCE", packBytes, unpackBytes],
   [22, "XOR-RELAYED-ADDRESS", packXorAddress, unpackXorAddress],
+  [23, "REQUESTED-ADDRESS-FAMILY", packUnsigned, unpackUnsigned],
+  [24, "EVEN-PORT", packBytes, unpackBytes],
   [25, "REQUESTED-TRANSPORT", packUnsigned, unpackUnsigned],
+  [28, "MESSAGE-INTEGRITY-SHA256", packBytes, unpackBytes],
+  [29, "PASSWORD-ALGORITHM", packBytes, unpackBytes],
+  [30, "USERHASH", packBytes, unpackBytes],
   [32, "XOR-MAPPED-ADDRESS", packXorAddress, unpackXorAddress],
+  [34, "RESERVATION-TOKEN", packBytes, unpackBytes],
   [36, "PRIORITY", packUnsigned, unpackUnsigned],
   [37, "USE-CANDIDATE", packNone, unpackNone],
-  [32802, "SOFTWARE", packString, unpackString],
+  [32770, "PASSWORD-ALGORITHMS", packBytes, unpackBytes],
+  [32771, "ALTERNATE-DOMAIN", packString, unpackString],
+  [32802, "SOFTWARE", packSoftware, unpackString],
+  [32803, "ALTERNATE-SERVER", packAddress, unpackAddress],
   [32808, "FINGERPRINT", packUnsigned, unpackUnsigned],
   [32809, "ICE-CONTROLLED", packUnsigned64, unpackUnsigned64],
   [32810, "ICE-CONTROLLING", packUnsigned64, unpackUnsigned64],
@@ -8655,12 +9134,14 @@ var ATTRIBUTES_BY_NAME = ATTRIBUTES.reduce(
 // ../ice/src/stun/transaction.ts
 var log20 = debug("werift-ice:packages/ice/src/stun/transaction.ts");
 
+// ../ice/src/stun/tcpProtocol.ts
+var log21 = debug("werift-ice:packages/ice/src/stun/tcpProtocol.ts");
+
 // ../ice/src/stun/protocol.ts
-var log21 = debug("werift-ice : packages/ice/src/stun/protocol.ts");
+var log22 = debug("werift-ice : packages/ice/src/stun/protocol.ts");
 
 // ../ice/src/turn/protocol.ts
-import { jspack as jspack3 } from "@shinyoshiaki/jspack";
-var log22 = debug("werift-ice:packages/ice/src/turn/protocol.ts");
+var log23 = debug("werift-ice:packages/ice/src/turn/protocol.ts");
 
 // ../ice/src/ice.ts
 import * as Int642 from "int64-buffer";
@@ -8670,28 +9151,58 @@ import isEqual from "fast-deep-equal";
 import mdns from "multicast-dns";
 
 // ../ice/src/iceBase.ts
-var log23 = debug("werift-ice : packages/ice/src/ice.ts : log");
+var log24 = debug("werift-ice : packages/ice/src/ice.ts : log");
 
 // ../ice/src/utils.ts
 import nodeIp2 from "ip";
 var logger = debug("werift-ice : packages/ice/src/utils.ts");
 
 // ../ice/src/ice.ts
-var log24 = debug("werift-ice : packages/ice/src/ice.ts : log");
+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 {
-  addEventListener = (type, listener) => {
+  emit(type, ...args) {
+    if (typeof type !== "string") {
+      return super.emit(type, ...args);
+    }
+    if (args.length === 0) {
+      return super.emit(type, new Event(type));
+    }
+    const [event, ...rest] = args;
+    if (event && typeof event === "object" && !("type" in event)) {
+      try {
+        Object.defineProperty(event, "type", {
+          configurable: true,
+          enumerable: true,
+          value: type
+        });
+      } catch {
+        return super.emit(type, { type, ...event }, ...rest);
+      }
+    }
+    return super.emit(type, event, ...rest);
+  }
+  addEventListener = (type, listener, options) => {
+    if (typeof options === "object" && options?.once) {
+      this.once(type, listener);
+      return;
+    }
     this.addListener(type, listener);
   };
   removeEventListener = (type, listener) => {
     this.removeListener(type, listener);
   };
+  dispatchEvent = (event) => this.emit(event.type, event);
 };
 
 // src/dataChannel.ts
-var log25 = debug("werift:packages/webrtc/src/dataChannel.ts");
+var log26 = debug("werift:packages/webrtc/src/dataChannel.ts");
 
 // src/media/extension/rtcpFeedback.ts
 var useNACK = () => ({ type: "nack" });
@@ -8794,6 +9305,15 @@ 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
@@ -8816,9 +9336,9 @@ var MediaStreamTrack = class extends EventTarget2 {
   codec;
   /**todo impl */
   enabled = true;
-  onReceiveRtp = new Event();
-  onReceiveRtcp = new Event();
-  onSourceChanged = new Event();
+  onReceiveRtp = new Event2();
+  onReceiveRtcp = new Event2();
+  onSourceChanged = new Event2();
   stopped = false;
   muted = true;
   constructor(props) {
@@ -8851,7 +9371,7 @@ var MediaStreamTrack = class extends EventTarget2 {
 var MediaStream = class {
   id;
   tracks = [];
-  constructor(props) {
+  constructor(props = {}) {
     if (Array.isArray(props)) {
       this.tracks = props;
     } else {
@@ -8863,6 +9383,12 @@ var MediaStream = class {
     track.streamId = this.id;
     this.tracks.push(track);
   }
+  removeTrack(track) {
+    this.tracks = this.tracks.filter((currentTrack) => currentTrack !== track);
+    if (track.streamId === this.id) {
+      track.streamId = void 0;
+    }
+  }
   getTracks() {
     return this.tracks;
   }
@@ -8875,33 +9401,33 @@ var MediaStream = class {
 };
 
 // src/utils.ts
-var log26 = debug("werift:packages/webrtc/src/utils.ts");
+var log27 = debug("werift:packages/webrtc/src/utils.ts");
 var milliTime = Date.now;
 var startupTimestampInMicroseconds = BigInt(Date.now()) * 1000n - process.hrtime.bigint() / 1000n;
 var createSelfSignedCertificate = CipherContext.createSelfSignedCertificateWithKey;
 
 // src/media/receiver/nack.ts
-var log27 = debug("werift:packages/webrtc/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 log28 = debug("werift:packages/webrtc/media/receiver/receiverTwcc");
+var log29 = debug("werift:packages/webrtc/media/receiver/receiverTwcc");
 
 // src/sdp.ts
 import * as Int643 from "int64-buffer";
 
 // src/transport/dtls.ts
 import { Certificate as Certificate3, PrivateKey as PrivateKey2 } from "@fidm/x509";
-var log29 = debug("werift:packages/webrtc/src/transport/dtls.ts");
+var log30 = debug("werift:packages/webrtc/src/transport/dtls.ts");
 
 // src/transport/ice.ts
-var log30 = debug("werift:packages/webrtc/src/transport/ice.ts");
+var log31 = debug("werift:packages/webrtc/src/transport/ice.ts");
 
 // src/transport/sctp.ts
-import { jspack as jspack6 } from "@shinyoshiaki/jspack";
+import { jspack as jspack5 } from "@shinyoshiaki/jspack";
 
 // ../sctp/src/sctp.ts
-import { jspack as jspack5 } from "@shinyoshiaki/jspack";
+import { jspack as jspack4 } from "@shinyoshiaki/jspack";
 
 // ../sctp/src/chunk.ts
 var Chunk = class _Chunk {
@@ -9291,32 +9817,54 @@ function decodeParams(body) {
 }
 
 // ../sctp/src/param.ts
-import { jspack as jspack4 } from "@shinyoshiaki/jspack";
+import { jspack as jspack3 } from "@shinyoshiaki/jspack";
 
 // ../sctp/src/sctp.ts
-var log31 = debug("werift/sctp/sctp");
+var log32 = debug("werift/sctp/sctp");
 var SCTP_RTO_ALPHA = 1 / 8;
 var SCTP_RTO_BETA = 1 / 4;
 var SCTP_TSN_MODULO = 2 ** 32;
 
 // src/transport/sctp.ts
-var log32 = debug("werift:packages/webrtc/src/transport/sctp.ts");
+var log33 = 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/rtpReceiver.ts
-var log33 = debug("werift:packages/webrtc/src/media/rtpReceiver.ts");
+var log34 = debug("werift:packages/webrtc/src/media/rtpReceiver.ts");
 
 // src/media/router.ts
-var log34 = debug("werift:packages/webrtc/src/media/router.ts");
+var log35 = debug("werift:packages/webrtc/src/media/router.ts");
 
 // src/media/rtpSender.ts
-import { jspack as jspack7 } from "@shinyoshiaki/jspack";
-var log35 = debug("werift:packages/webrtc/src/media/rtpSender.ts");
+import { jspack as jspack6 } from "@shinyoshiaki/jspack";
+var log36 = debug("werift:packages/webrtc/src/media/rtpSender.ts");
 
 // src/sctpManager.ts
-var log36 = debug("werift:packages/webrtc/src/transport/sctpManager.ts");
+var log37 = debug("werift:packages/webrtc/src/transport/sctpManager.ts");
 
 // src/secureTransportManager.ts
-var log37 = debug(
+var log38 = debug(
   "werift:packages/webrtc/src/transport/secureTransportManager.ts"
 );
 var srtpProfiles = [
@@ -9326,7 +9874,7 @@ var srtpProfiles = [
 ];
 
 // src/peerConnection.ts
-var log38 = debug("werift:packages/webrtc/src/peerConnection.ts");
+var log39 = debug("werift:packages/webrtc/src/peerConnection.ts");
 function generateDefaultPeerConfig() {
   return {
     codecs: {
@@ -9338,27 +9886,157 @@ function generateDefaultPeerConfig() {
       video: []
     },
     iceTransportPolicy: "all",
+    iceLite: false,
     iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
     icePortRange: void 0,
     iceInterfaceAddresses: void 0,
     iceAdditionalHostAddresses: void 0,
     iceUseIpv4: true,
     iceUseIpv6: true,
+    iceUseTcp: false,
+    turnTransport: void 0,
+    turnTlsOptions: void 0,
     iceFilterStunResponse: void 0,
     iceFilterCandidatePair: void 0,
     icePasswordPrefix: void 0,
     iceUseLinkLocalAddress: void 0,
     dtls: {},
     bundlePolicy: "max-compat",
+    rtcpMuxPolicy: "require",
+    iceCandidatePoolSize: 0,
+    certificates: [],
     debug: {},
     midSuffix: false,
-    forceTurnTCP: false
+    forceTurnTCP: false,
+    maxMessageSize: DEFAULT_MAX_MESSAGE_SIZE
   };
 }
 var defaultPeerConfig = generateDefaultPeerConfig();
 
 // src/transceiverManager.ts
-var log39 = debug("werift:packages/webrtc/src/media/rtpTransceiverManager.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;
+var AUDIO_PAYLOAD = Buffer.from([248, 255, 254]);
+var DEFAULT_VIDEO_FPS = 30;
+var VIDEO_TIMESTAMP_STEP = 3e3;
+var DUMMY_SSRC_BASE = 439041024;
+var DUMMY_SEQUENCE_BASE = 16384;
+var DUMMY_SEQUENCE_STEP = 256;
+var nextDummySourceId = 0;
+var VP8_KEYFRAME = Buffer.from([
+  16,
+  16,
+  0,
+  0,
+  157,
+  1,
+  42,
+  2,
+  0,
+  2,
+  0
+]);
+var VP8_DELTA_FRAME = Buffer.from([16, 17, 0, 0]);
+function createDummyAudioTrack(options = {}) {
+  const track = new MediaStreamTrack({ kind: "audio" });
+  const source = new ScheduledRtpSource({
+    track,
+    intervalMs: options.packetIntervalMs ?? AUDIO_PACKET_MS,
+    buildPacket: ({ sequenceNumber, timestamp, ssrc }) => new RtpPacket(
+      new RtpHeader({
+        version: 2,
+        payloadType: 111,
+        sequenceNumber,
+        timestamp,
+        ssrc,
+        marker: true
+      }),
+      Buffer.from(AUDIO_PAYLOAD)
+    ),
+    nextTimestamp: (timestamp) => timestamp + AUDIO_TIMESTAMP_STEP
+  });
+  source.start();
+  return { track, source };
+}
+function createDummyVideoTrack(options = {}) {
+  const fps = options.fps ?? DEFAULT_VIDEO_FPS;
+  const keyframeIntervalFrames = options.keyframeIntervalFrames ?? fps;
+  const intervalMs = 1e3 / fps;
+  const track = new MediaStreamTrack({ kind: "video" });
+  const source = new ScheduledRtpSource({
+    track,
+    intervalMs,
+    buildPacket: ({ sequenceNumber, timestamp, ssrc, iteration }) => {
+      const isKeyframe = iteration % keyframeIntervalFrames === 0;
+      return new RtpPacket(
+        new RtpHeader({
+          version: 2,
+          payloadType: 96,
+          sequenceNumber,
+          timestamp,
+          ssrc,
+          marker: true
+        }),
+        Buffer.from(isKeyframe ? VP8_KEYFRAME : VP8_DELTA_FRAME)
+      );
+    },
+    nextTimestamp: (timestamp) => timestamp + VIDEO_TIMESTAMP_STEP
+  });
+  source.start();
+  return { track, source };
+}
+var ScheduledRtpSource = class {
+  constructor(props) {
+    this.props = props;
+  }
+  sourceId = nextDummySourceId++;
+  ssrc = DUMMY_SSRC_BASE + this.sourceId >>> 0;
+  sequenceNumber = DUMMY_SEQUENCE_BASE + this.sourceId * DUMMY_SEQUENCE_STEP & 65535;
+  timestamp = 0;
+  iteration = 0;
+  nextTickAt;
+  timer;
+  stopped = false;
+  start() {
+    this.nextTickAt = performance.now();
+    this.schedule();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+  }
+  schedule() {
+    if (this.stopped || this.props.track.stopped) {
+      this.stop();
+      return;
+    }
+    this.nextTickAt = (this.nextTickAt ?? performance.now()) + this.props.intervalMs;
+    const delay = Math.max(0, this.nextTickAt - performance.now());
+    this.timer = setTimeout(() => {
+      if (this.stopped || this.props.track.stopped) {
+        this.stop();
+        return;
+      }
+      const packet = this.props.buildPacket({
+        sequenceNumber: this.sequenceNumber,
+        timestamp: this.timestamp,
+        ssrc: this.ssrc,
+        iteration: this.iteration
+      });
+      this.props.track.writeRtp(packet);
+      this.sequenceNumber = this.sequenceNumber + 1 & 65535;
+      this.timestamp = this.props.nextTimestamp(this.timestamp) >>> 0;
+      this.iteration += 1;
+      this.schedule();
+    }, delay);
+  }
+};
 
 // src/nonstandard/navigator.ts
 var Navigator = class {
@@ -9368,7 +10046,7 @@ var Navigator = class {
   }
 };
 var MediaDevices = class extends EventTarget {
-  constructor(props) {
+  constructor(props = {}) {
     super();
     this.props = props;
     this.video = props.video;
@@ -9376,31 +10054,16 @@ var MediaDevices = class extends EventTarget {
   }
   video;
   audio;
+  activeSourceStops = /* @__PURE__ */ new Map();
   getUserMedia = async (constraints) => {
-    const video = constraints.video ? new MediaStreamTrack({ kind: "video" }) : void 0;
-    if (video) {
-      this.video?.onReceiveRtp.subscribe((rtp) => {
-        const cloned = rtp.clone();
-        cloned.header.ssrc = jspack8.Unpack("!L", randomBytes5(4))[0];
-        video.onReceiveRtp.execute(cloned);
-      });
-    }
-    const audio = constraints.audio ? new MediaStreamTrack({ kind: "audio" }) : void 0;
-    if (audio) {
-      this.audio?.onReceiveRtp.subscribe((rtp) => {
-        const cloned = rtp.clone();
-        cloned.header.ssrc = jspack8.Unpack("!L", randomBytes5(4))[0];
-        audio.onReceiveRtp.execute(cloned);
-      });
-    }
-    if (constraints.video && constraints.audio) {
-      return new MediaStream([video, audio]);
-    } else if (constraints.audio) {
-      return new MediaStream([audio]);
-    } else if (constraints.video) {
-      return new MediaStream([video]);
+    const tracks = [
+      ...constraints.audio ? [this.createTrack("audio", constraints.audio)] : [],
+      ...constraints.video ? [this.createTrack("video", constraints.video)] : []
+    ];
+    if (tracks.length === 0) {
+      throw new Error("At least one audio or video track is required");
     }
-    throw new Error("Not implemented");
+    return new MediaStream(tracks);
   };
   getDisplayMedia = this.getUserMedia;
   getUdpMedia = ({
@@ -9422,8 +10085,83 @@ var MediaDevices = class extends EventTarget {
     };
     return { track, disposer };
   };
+  cleanup() {
+    for (const stop of this.activeSourceStops.values()) {
+      stop();
+    }
+    this.activeSourceStops.clear();
+  }
+  createTrack(kind, constraints) {
+    const existingTrack = kind === "audio" ? this.audio : this.video;
+    if (existingTrack) {
+      return this.createClonedTrack(kind, existingTrack);
+    }
+    if (this.props.dummyMedia?.enabled) {
+      return this.createDummyTrack(kind, constraints);
+    }
+    throw new Error(`No ${kind} source configured for getUserMedia`);
+  }
+  createClonedTrack(kind, sourceTrack) {
+    const track = new MediaStreamTrack({ kind });
+    const { unSubscribe } = sourceTrack.onReceiveRtp.subscribe((rtp) => {
+      track.onReceiveRtp.execute(rtp.clone());
+    });
+    this.attachTrackStop(track, () => {
+      unSubscribe();
+    });
+    return track;
+  }
+  createDummyTrack(kind, constraints) {
+    const dummy = kind === "audio" ? createDummyAudioTrack(this.props.dummyMedia?.audio) : createDummyVideoTrack({
+      ...this.props.dummyMedia?.video,
+      ...resolveVideoOptions(constraints)
+    });
+    this.attachTrackStop(dummy.track, () => {
+      dummy.source.stop();
+    });
+    return dummy.track;
+  }
+  attachTrackStop(track, stop) {
+    let disposed = false;
+    const originalStop = track.stop;
+    const dispose = () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      stop();
+      this.activeSourceStops.delete(track);
+    };
+    track.stop = () => {
+      dispose();
+      originalStop();
+    };
+    this.activeSourceStops.set(track, dispose);
+  }
 };
 var navigator = new Navigator();
+function resolveVideoOptions(constraints) {
+  if (typeof constraints === "boolean") {
+    return {};
+  }
+  const fps = resolveConstrainNumber(constraints.frameRate);
+  if (!fps) {
+    return {};
+  }
+  return {
+    fps,
+    keyframeIntervalFrames: Math.max(1, Math.round(fps))
+  };
+}
+function resolveConstrainNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  return value.exact ?? value.ideal ?? value.max ?? value.min;
+}
 
 // src/nonstandard/recorder/writer/webm.ts
 import { unlink } from "fs/promises";
@@ -9443,7 +10181,7 @@ var MediaWriter = class {
 var sourcePath = "packages/webrtc/src/nonstandard/recorder/writer/webm.ts";
 var WebmFactory = class extends MediaWriter {
   rtpSources = [];
-  onEol = new Event();
+  onEol = new Event2();
   ended = false;
   unSubscribers = new EventDisposer();
   async start(tracks) {
@@ -9605,7 +10343,7 @@ var MediaRecorder = class {
   ext;
   tracks = [];
   started = false;
-  onError = new Event();
+  onError = new Event2();
   async addTrack(track) {
     this.tracks.push(track);
     await this.start();
@@ -9622,113 +10360,891 @@ var MediaRecorder = class {
 };
 
 // src/nonstandard/userMedia.ts
-import { exec } from "child_process";
 import { randomUUID as randomUUID6 } from "crypto";
-import { createSocket as createSocket4 } from "dgram";
-import { setImmediate as setImmediate2 } from "timers/promises";
-var getUserMedia = async ({
-  path: path2,
-  loop,
-  width,
-  height
-}) => {
-  const audioPort = await randomPort();
-  const videoPort = await randomPort();
-  if (path2.endsWith(".mp4")) {
-    return new MediaPlayerMp4({
-      audioPort,
-      videoPort,
-      path: path2,
-      loop,
-      width,
-      height
+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
+          )
+        );
+      }
     });
-  } else {
-    return new MediaPlayerWebm({
-      audioPort,
-      videoPort,
-      path: path2,
-      loop,
-      width,
-      height
+    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 {
-  constructor(props) {
-    this.props = props;
-    this.setupTrack(props.audioPort, this.audio);
-    this.setupTrack(props.videoPort, this.video);
-  }
-  streamId = randomUUID6().toString();
-  audio = new MediaStreamTrack({ kind: "audio", streamId: this.streamId });
-  video = new MediaStreamTrack({ kind: "video", streamId: this.streamId });
-  process;
+  audio;
+  video;
+  onError = new Event2();
+  source;
+  loop;
+  streamId;
+  session;
+  running;
+  abortController;
+  hasStartedPlayback = false;
   stopped = false;
-  setupTrack = (port, track) => {
-    let payloadType = 0;
-    const socket = createSocket4("udp4");
-    socket.bind(port);
-    socket.on("message", async (buf) => {
-      const rtp = RtpPacket.deSerialize(buf);
-      if (!payloadType) {
-        payloadType = rtp.header.payloadType;
-      }
-      if (payloadType !== rtp.header.payloadType) {
-        payloadType = rtp.header.payloadType;
-        track.onSourceChanged.execute(rtp.header);
-      }
-      track.writeRtp(buf);
+  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.process.kill("SIGINT");
+    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);
   }
-};
-var MediaPlayerMp4 = class extends MediaPlayer {
-  async start() {
-    let payloadType = 96;
-    const run = async () => {
-      if (payloadType > 100) payloadType = 96;
-      let cmd = "";
-      if (this.props.width && this.props.height) {
-        cmd = `gst-launch-1.0 filesrc location= ${this.props.path} ! decodebin ! videoscale ! video/x-raw,width=${this.props.width},height=${this.props.height} ! x264enc ! h264parse ! rtph264pay config-interval=10 pt=${payloadType++} ! udpsink host=127.0.0.1 port=${this.props.videoPort}`;
-      } else {
-        cmd = `gst-launch-1.0 filesrc location= ${this.props.path} ! qtdemux name=d ! queue ! h264parse ! rtph264pay config-interval=10 pt=${payloadType++} ! udpsink host=127.0.0.1 port=${this.props.videoPort} d. ! queue ! aacparse ! avdec_aac ! audioresample ! audioconvert ! opusenc ! rtpopuspay pt=${payloadType++} ! udpsink host=127.0.0.1 port=${this.props.audioPort}`;
-      }
-      console.log(cmd);
-      this.process = exec(cmd);
-      this.process.on("error", (e) => console.error("gst error", e));
-      if (this.props.loop) {
-        await new Promise((r) => this.process.on("close", r));
-        if (!this.stopped) {
-          run();
-        }
+  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");
       }
-    };
-    await setImmediate2();
-    run();
+      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 MediaPlayerWebm = class extends MediaPlayer {
-  async start() {
-    let payloadType = 96;
-    const run = async () => {
-      if (payloadType > 100) payloadType = 96;
-      const cmd = `gst-launch-1.0 filesrc location=${this.props.path} ! matroskademux name=d d.video_0 ! queue ! rtpvp8pay pt=${payloadType++} ! udpsink host=127.0.0.1 port=${this.props.videoPort} d.audio_0 ! queue ! rtpopuspay pt=${payloadType++} ! udpsink host=127.0.0.1 port=${this.props.audioPort}`;
-      this.process = exec(cmd);
-      if (this.props.loop) {
-        await new Promise((r) => this.process.on("close", r));
-        if (!this.stopped) {
-          run();
+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);
         }
       }
-    };
-    await setImmediate2();
-    run();
+    } 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,
@@ -9744,7 +11260,7 @@ export {
   DtxCallback,
   DurationPosition,
   Element,
-  Event,
+  Event2 as Event,
   EventDisposer,
   ExtensionProfiles,
   GenericNack,
@@ -9765,8 +11281,6 @@ export {
   Max32Uint,
   MaxSinged16Int,
   MediaDevices,
-  MediaPlayerMp4,
-  MediaPlayerWebm,
   MediaRecorder,
   Mp4Container,
   MuteCallback,
@@ -9818,9 +11332,11 @@ export {
   SourceDescriptionChunk,
   SourceDescriptionItem,
   SrtcpSession,
+  SrtpAuthenticationError,
   SrtpSession,
   StatusVectorChunk,
   TcpTransport,
+  TlsTransport,
   TransportWideCC,
   UNKNOWN_SIZE,
   UdpTransport,
@@ -9832,6 +11348,7 @@ export {
   WebmCallback,
   WebmStream,
   WeriftError,
+  annexb2avcSample,
   annexb2avcc,
   buffer2ArrayBuffer,
   bufferArrayXor,