werift 0.22.1 → 0.22.3

package/lib/webrtc/src/peerConnection.js

@@ -1,135 +1,87 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultPeerConfig = exports.findCodecByMimeType = exports.RTCPeerConnection = void 0;
-exports.createMediaDescriptionForTransceiver = createMediaDescriptionForTransceiver;
-exports.createMediaDescriptionForSctp = createMediaDescriptionForSctp;
-exports.addTransportDescription = addTransportDescription;
-exports.allocateMid = allocateMid;
-const cloneDeep_js_1 = __importDefault(require("lodash/cloneDeep.js"));
-const isEqual_js_1 = __importDefault(require("lodash/isEqual.js"));
-const uuid = __importStar(require("uuid"));
-const const_1 = require("./const");
-const dataChannel_1 = require("./dataChannel");
+const crypto_1 = require("crypto");
 const helper_1 = require("./helper");
 const common_1 = require("./imports/common");
 const media_1 = require("./media");
+const stats_1 = require("./media/stats");
+const sctpManager_1 = require("./sctpManager");
 const sdp_1 = require("./sdp");
-const dtls_1 = require("./transport/dtls");
-const ice_1 = require("./transport/ice");
-const sctp_1 = require("./transport/sctp");
+const sdpManager_1 = require("./sdpManager");
+const secureTransportManager_1 = require("./secureTransportManager");
 const utils_1 = require("./utils");
 const log = (0, common_1.debug)("werift:packages/webrtc/src/peerConnection.ts");
 class RTCPeerConnection extends helper_1.EventTarget {
-    pushTransceiver(t) {
-        this.transceivers.push(t);
-    }
-    replaceTransceiver(t, index) {
-        this.transceivers[index] = t;
-    }
-    get dtlsTransports() {
-        const transports = this.transceivers.map((t) => t.dtlsTransport);
-        if (this.sctpTransport) {
-            transports.push(this.sctpTransport.dtlsTransport);
-        }
-        return transports.reduce((acc, cur) => {
-            if (!acc.map((d) => d.id).includes(cur.id)) {
-                acc.push(cur);
-            }
-            return acc;
-        }, []);
-    }
-    get iceTransports() {
-        return this.dtlsTransports.map((d) => d.iceTransport);
-    }
-    get extIdUriMap() {
-        return this.router.extIdUriMap;
-    }
-    get iceGeneration() {
-        return this.iceTransports[0].connection.generation;
-    }
     constructor(config = {}) {
         super();
         Object.defineProperty(this, "cname", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: uuid.v4()
+            value: (0, crypto_1.randomUUID)().toString()
         });
-        Object.defineProperty(this, "sctpTransport", {
+        Object.defineProperty(this, "config", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: generateDefaultPeerConfig()
         });
-        Object.defineProperty(this, "config", {
+        Object.defineProperty(this, "signalingState", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: (0, cloneDeep_js_1.default)(exports.defaultPeerConfig)
+            value: "stable"
         });
-        Object.defineProperty(this, "connectionState", {
+        Object.defineProperty(this, "negotiationneeded", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "new"
+            value: false
         });
-        Object.defineProperty(this, "iceConnectionState", {
+        Object.defineProperty(this, "needRestart", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "new"
+            value: false
         });
-        Object.defineProperty(this, "iceGatheringState", {
+        Object.defineProperty(this, "router", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "new"
+            value: new media_1.RtpRouter()
         });
-        Object.defineProperty(this, "signalingState", {
+        Object.defineProperty(this, "sdpManager", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "stable"
+            value: void 0
         });
-        Object.defineProperty(this, "negotiationneeded", {
+        Object.defineProperty(this, "transceiverManager", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: void 0
         });
-        Object.defineProperty(this, "transceivers", {
+        Object.defineProperty(this, "sctpManager", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: void 0
         });
-        Object.defineProperty(this, "needRestart", {
+        Object.defineProperty(this, "secureManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isClosed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "shouldNegotiationneeded", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -207,96 +159,48 @@ class RTCPeerConnection extends helper_1.EventTarget {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "onnegotiationneeded", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "onsignalingstatechange", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "ontrack", {
+        Object.defineProperty(this, "onicecandidateerror", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "onconnectionstatechange", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "oniceconnectionstatechange", {
+        Object.defineProperty(this, "onicegatheringstatechange", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "router", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new media_1.RtpRouter()
-        });
-        Object.defineProperty(this, "certificate", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "sctpRemotePort", {
+        Object.defineProperty(this, "onnegotiationneeded", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "seenMid", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Set()
-        });
-        Object.defineProperty(this, "currentLocalDescription", {
+        Object.defineProperty(this, "onsignalingstatechange", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "currentRemoteDescription", {
+        Object.defineProperty(this, "ontrack", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "pendingLocalDescription", {
+        Object.defineProperty(this, "onconnectionstatechange", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "pendingRemoteDescription", {
+        Object.defineProperty(this, "oniceconnectionstatechange", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "isClosed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "shouldNegotiationneeded", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
         Object.defineProperty(this, "needNegotiation", {
             enumerable: true,
             configurable: true,
@@ -316,16 +220,113 @@ class RTCPeerConnection extends helper_1.EventTarget {
             }
         });
         this.setConfiguration(config);
-        this.iceConnectionStateChange.subscribe((state) => {
-            switch (state) {
-                case "disconnected":
-                    this.setConnectionState("disconnected");
-                    break;
-                case "closed":
-                    this.close();
-                    break;
+        this.sdpManager = new sdpManager_1.SDPManager({
+            cname: this.cname,
+            bundlePolicy: this.config.bundlePolicy,
+        });
+        this.transceiverManager = new media_1.TransceiverManager(this.cname, this.config, this.router);
+        this.transceiverManager.onTransceiverAdded.pipe(this.onTransceiverAdded);
+        this.transceiverManager.onRemoteTransceiverAdded.pipe(this.onRemoteTransceiverAdded);
+        this.transceiverManager.onTrack.subscribe(({ track, stream, transceiver }) => {
+            const event = {
+                track,
+                streams: [stream],
+                transceiver,
+                receiver: transceiver.receiver,
+            };
+            this.onTrack.execute(track);
+            this.emit("track", event);
+            if (this.ontrack) {
+                this.ontrack(event);
+            }
+        });
+        this.transceiverManager.onNegotiationNeeded.subscribe(() => this.needNegotiation());
+        this.sctpManager = new sctpManager_1.SctpTransportManager();
+        this.sctpManager.onDataChannel.subscribe((channel) => {
+            this.onDataChannel.execute(channel);
+            const event = { channel };
+            this.ondatachannel?.(event);
+            this.emit("datachannel", event);
+        });
+        this.secureManager = new secureTransportManager_1.SecureTransportManager({
+            config: this.config,
+            sctpManager: this.sctpManager,
+            transceiverManager: this.transceiverManager,
+        });
+        this.secureManager.iceGatheringStateChange.pipe(this.iceGatheringStateChange);
+        this.secureManager.iceConnectionStateChange.subscribe((state) => {
+            if (state === "closed") {
+                this.close();
             }
+            this.iceConnectionStateChange.execute(state);
         });
+        this.secureManager.connectionStateChange.subscribe((state) => {
+            this.connectionStateChange.execute(state);
+            this.onconnectionstatechange?.();
+            this.emit("connectionstatechange");
+        });
+        this.secureManager.onIceCandidate.subscribe((candidate) => {
+            const iceCandidate = candidate ? candidate.toJSON() : undefined;
+            this.onIceCandidate.execute(iceCandidate);
+            this.onicecandidate?.({ candidate: iceCandidate });
+            this.emit("icecandidate", { candidate: iceCandidate });
+        });
+    }
+    get connectionState() {
+        return this.secureManager.connectionState;
+    }
+    get iceConnectionState() {
+        return this.secureManager.iceConnectionState;
+    }
+    get iceGathererState() {
+        return this.secureManager.iceGatheringState;
+    }
+    get iceGatheringState() {
+        return this.secureManager.iceGatheringState;
+    }
+    get dtlsTransports() {
+        return this.secureManager.dtlsTransports;
+    }
+    get sctpTransport() {
+        return this.sctpManager.sctpTransport;
+    }
+    get sctpRemotePort() {
+        return this.sctpManager.sctpRemotePort;
+    }
+    get iceTransports() {
+        return this.secureManager.iceTransports;
+    }
+    get extIdUriMap() {
+        return this.router.extIdUriMap;
+    }
+    get iceGeneration() {
+        return this.iceTransports[0].connection.generation;
+    }
+    get localDescription() {
+        return this.sdpManager.localDescription;
+    }
+    get remoteDescription() {
+        return this.sdpManager.remoteDescription;
+    }
+    get remoteIsBundled() {
+        return this.sdpManager.remoteIsBundled;
+    }
+    /**@private */
+    get _localDescription() {
+        return this.sdpManager._localDescription;
+    }
+    /**@private */
+    get _remoteDescription() {
+        return this.sdpManager._remoteDescription;
+    }
+    getTransceivers() {
+        return this.transceiverManager.getTransceivers();
+    }
+    getSenders() {
+        return this.transceiverManager.getSenders();
+    }
+    getReceivers() {
+        return this.transceiverManager.getReceivers();
     }
     setConfiguration(config) {
         (0, utils_1.deepMerge)(this.config, config);
@@ -367,38 +368,6 @@ class RTCPeerConnection extends helper_1.EventTarget {
         ].forEach((v, i) => {
             v.id = 1 + i;
         });
-        if (this.config.dtls) {
-            const { keys } = this.config.dtls;
-            if (keys) {
-                this.certificate = new dtls_1.RTCCertificate(keys.keyPem, keys.certPem, keys.signatureHash);
-            }
-        }
-    }
-    get localDescription() {
-        if (!this._localDescription) {
-            return undefined;
-        }
-        return this._localDescription.toJSON();
-    }
-    get remoteDescription() {
-        if (!this._remoteDescription) {
-            return undefined;
-        }
-        return this._remoteDescription.toJSON();
-    }
-    /**@private */
-    get _localDescription() {
-        return this.pendingLocalDescription || this.currentLocalDescription;
-    }
-    /**@private */
-    get _remoteDescription() {
-        return this.pendingRemoteDescription || this.currentRemoteDescription;
-    }
-    getTransceiverByMid(mid) {
-        return this.transceivers.find((transceiver) => transceiver.mid === mid);
-    }
-    getTransceiverByMLineIndex(index) {
-        return this.transceivers.find((transceiver) => transceiver.mLineIndex === index);
     }
     getConfiguration() {
         return this.config;
@@ -406,207 +375,64 @@ class RTCPeerConnection extends helper_1.EventTarget {
     async createOffer({ iceRestart } = {}) {
         if (iceRestart || this.needRestart) {
             this.needRestart = false;
-            for (const t of this.iceTransports) {
-                t.restart();
-            }
+            this.secureManager.restartIce();
         }
-        await this.ensureCerts();
-        const description = this.buildOfferSdp();
-        return description.toJSON();
-    }
-    assignTransceiverCodecs(transceiver) {
-        const codecs = this.config.codecs[transceiver.kind].filter((codecCandidate) => {
-            switch (codecCandidate.direction) {
-                case "recvonly": {
-                    if (const_1.ReceiverDirection.includes(transceiver.direction))
-                        return true;
-                    return false;
-                }
-                case "sendonly": {
-                    if (const_1.SenderDirections.includes(transceiver.direction))
-                        return true;
-                    return false;
-                }
-                case "sendrecv": {
-                    if ([media_1.Sendrecv, media_1.Recvonly, media_1.Sendonly].includes(transceiver.direction))
-                        return true;
-                    return false;
-                }
-                case "all": {
-                    return true;
-                }
-                default:
-                    return false;
-            }
-        });
-        transceiver.codecs = codecs;
-    }
-    buildOfferSdp() {
-        this.transceivers.forEach((transceiver) => {
+        await this.secureManager.ensureCerts();
+        for (const transceiver of this.transceiverManager.getTransceivers()) {
             if (transceiver.codecs.length === 0) {
-                this.assignTransceiverCodecs(transceiver);
+                this.transceiverManager.assignTransceiverCodecs(transceiver);
             }
             if (transceiver.headerExtensions.length === 0) {
                 transceiver.headerExtensions =
                     this.config.headerExtensions[transceiver.kind] ?? [];
             }
-        });
-        const description = new sdp_1.SessionDescription();
-        (0, sdp_1.addSDPHeader)("offer", description);
-        // # handle existing transceivers / sctp
-        const currentMedia = this._localDescription
-            ? this._localDescription.media
-            : [];
-        currentMedia.forEach((m, i) => {
-            const mid = m.rtp.muxId;
-            if (!mid) {
-                log("mid missing", m);
-                return;
-            }
-            if (m.kind === "application") {
-                if (!this.sctpTransport) {
-                    throw new Error("sctpTransport not found");
-                }
-                this.sctpTransport.mLineIndex = i;
-                description.media.push(createMediaDescriptionForSctp(this.sctpTransport));
-            }
-            else {
-                const transceiver = this.getTransceiverByMid(mid);
-                if (!transceiver) {
-                    if (m.direction === "inactive") {
-                        description.media.push(m);
-                        return;
-                    }
-                    throw new Error("transceiver not found");
-                }
-                transceiver.mLineIndex = i;
-                description.media.push(createMediaDescriptionForTransceiver(transceiver, this.cname, transceiver.direction));
-            }
-        });
-        // # handle new transceivers / sctp
-        this.transceivers
-            .filter((t) => !description.media.find((m) => m.rtp.muxId === t.mid))
-            .forEach((transceiver) => {
-            if (transceiver.mid == undefined) {
-                transceiver.mid = allocateMid(this.seenMid, this.config.midSuffix ? "av" : "");
-            }
-            const mediaDescription = createMediaDescriptionForTransceiver(transceiver, this.cname, transceiver.direction);
-            if (transceiver.mLineIndex === undefined) {
-                transceiver.mLineIndex = description.media.length;
-                description.media.push(mediaDescription);
-            }
-            else {
-                description.media[transceiver.mLineIndex] = mediaDescription;
-            }
-        });
-        if (this.sctpTransport &&
-            !description.media.find((m) => m.kind === "application")) {
-            this.sctpTransport.mLineIndex = description.media.length;
-            if (this.sctpTransport.mid == undefined) {
-                this.sctpTransport.mid = allocateMid(this.seenMid, this.config.midSuffix ? "dc" : "");
-            }
-            description.media.push(createMediaDescriptionForSctp(this.sctpTransport));
-        }
-        if (this.config.bundlePolicy !== "disable") {
-            const mids = description.media
-                .map((m) => (m.direction !== "inactive" ? m.rtp.muxId : undefined))
-                .filter((v) => v);
-            if (mids.length) {
-                const bundle = new sdp_1.GroupDescription("BUNDLE", mids);
-                description.group.push(bundle);
-            }
         }
-        return description;
+        const description = this.sdpManager.buildOfferSdp(this.transceiverManager.getTransceivers(), this.sctpTransport);
+        return description.toJSON();
+    }
+    createSctpTransport() {
+        const sctp = this.sctpManager.createSctpTransport();
+        const dtlsTransport = this.findOrCreateTransport();
+        sctp.setDtlsTransport(dtlsTransport);
+        return sctp;
     }
     createDataChannel(label, options = {}) {
-        const base = {
-            protocol: "",
-            ordered: true,
-            negotiated: false,
-        };
-        const settings = { ...base, ...options };
-        if (settings.maxPacketLifeTime && settings.maxRetransmits) {
-            throw new Error("can not select both");
-        }
         if (!this.sctpTransport) {
-            this.sctpTransport = this.createSctpTransport();
+            this.createSctpTransport();
             this.needNegotiation();
         }
-        const parameters = new dataChannel_1.RTCDataChannelParameters({
-            id: settings.id,
-            label,
-            maxPacketLifeTime: settings.maxPacketLifeTime,
-            maxRetransmits: settings.maxRetransmits,
-            negotiated: settings.negotiated,
-            ordered: settings.ordered,
-            protocol: settings.protocol,
-        });
-        const channel = new dataChannel_1.RTCDataChannel(this.sctpTransport, parameters);
+        const channel = this.sctpManager.createDataChannel(label, options);
+        if (!channel.sctp.dtlsTransport) {
+            const dtlsTransport = this.findOrCreateTransport();
+            channel.sctp.setDtlsTransport(dtlsTransport);
+        }
         return channel;
     }
     removeTrack(sender) {
-        if (this.isClosed)
+        if (this.isClosed) {
             throw new Error("peer closed");
-        if (!this.getSenders().find(({ ssrc }) => sender.ssrc === ssrc)) {
-            throw new Error("unExist");
-        }
-        const transceiver = this.transceivers.find(({ sender: { ssrc } }) => sender.ssrc === ssrc);
-        if (!transceiver)
-            throw new Error("unExist");
-        sender.stop();
-        if (transceiver.currentDirection === "recvonly") {
-            this.needNegotiation();
-            return;
-        }
-        if (transceiver.stopping || transceiver.stopped) {
-            transceiver.setDirection("inactive");
-        }
-        else {
-            if (transceiver.direction === "sendrecv") {
-                transceiver.setDirection("recvonly");
-            }
-            else if (transceiver.direction === "sendonly" ||
-                transceiver.direction === "recvonly") {
-                transceiver.setDirection("inactive");
-            }
         }
+        this.transceiverManager.removeTrack(sender);
         this.needNegotiation();
     }
-    createTransport(srtpProfiles = []) {
+    findOrCreateTransport() {
         const [existing] = this.iceTransports;
         // Gather ICE candidates for only one track. If the remote endpoint is not bundle-aware, negotiate only one media track.
         // https://w3c.github.io/webrtc-pc/#rtcbundlepolicy-enum
-        if (this.config.bundlePolicy === "max-bundle") {
+        if (this.sdpManager.bundlePolicy === "max-bundle" ||
+            (this.sdpManager.bundlePolicy !== "disable" && this.remoteIsBundled)) {
             if (existing) {
                 return this.dtlsTransports[0];
             }
         }
-        const iceGatherer = new ice_1.RTCIceGatherer({
-            ...(0, utils_1.parseIceServers)(this.config.iceServers),
-            forceTurn: this.config.iceTransportPolicy === "relay",
-            portRange: this.config.icePortRange,
-            interfaceAddresses: this.config.iceInterfaceAddresses,
-            additionalHostAddresses: this.config.iceAdditionalHostAddresses,
-            filterStunResponse: this.config.iceFilterStunResponse,
-            filterCandidatePair: this.config.iceFilterCandidatePair,
-            localPasswordPrefix: this.config.icePasswordPrefix,
-            useIpv4: this.config.iceUseIpv4,
-            useIpv6: this.config.iceUseIpv6,
-            turnTransport: this.config.forceTurnTCP === true ? "tcp" : "udp",
-            useLinkLocalAddress: this.config.iceUseLinkLocalAddress,
+        const dtlsTransport = this.secureManager.createTransport();
+        dtlsTransport.onRtp.subscribe((rtp) => {
+            this.router.routeRtp(rtp);
         });
-        if (existing) {
-            iceGatherer.connection.localUsername = existing.connection.localUsername;
-            iceGatherer.connection.localPassword = existing.connection.localPassword;
-        }
-        iceGatherer.onGatheringStateChange.subscribe(() => {
-            this.updateIceGatheringState();
-        });
-        this.updateIceGatheringState();
-        const iceTransport = new ice_1.RTCIceTransport(iceGatherer);
-        iceTransport.onStateChange.subscribe(() => {
-            this.updateIceConnectionState();
+        dtlsTransport.onRtcp.subscribe((rtcp) => {
+            this.router.routeRtcp(rtcp);
         });
+        const iceTransport = dtlsTransport.iceTransport;
         iceTransport.onNegotiationNeeded.subscribe(() => {
             this.needNegotiation();
         });
@@ -616,7 +442,7 @@ class RTCPeerConnection extends helper_1.EventTarget {
                 return;
             }
             if (!candidate) {
-                this.setLocal(this._localDescription);
+                this.sdpManager.setLocal(this._localDescription, this.transceiverManager.getTransceivers(), this.sctpTransport);
                 this.onIceCandidate.execute(undefined);
                 if (this.onicecandidate) {
                     this.onicecandidate({ candidate: undefined });
@@ -624,58 +450,44 @@ class RTCPeerConnection extends helper_1.EventTarget {
                 this.emit("icecandidate", { candidate: undefined });
                 return;
             }
-            if (this.config.bundlePolicy === "max-bundle" || this.remoteIsBundled) {
-                candidate.sdpMLineIndex = 0;
-                const media = this._localDescription?.media[0];
-                if (media) {
-                    candidate.sdpMid = media.rtp.muxId;
-                }
-            }
-            else {
-                const transceiver = this.transceivers.find((t) => t.dtlsTransport.iceTransport.id === iceTransport.id);
-                if (transceiver) {
-                    candidate.sdpMLineIndex = transceiver.mLineIndex;
-                    candidate.sdpMid = transceiver.mid;
-                }
-                if (this.sctpTransport?.dtlsTransport.iceTransport.id === iceTransport.id) {
-                    candidate.sdpMLineIndex = this.sctpTransport.mLineIndex;
-                    candidate.sdpMid = this.sctpTransport.mid;
-                }
-            }
-            candidate.foundation = "candidate:" + candidate.foundation;
-            this.onIceCandidate.execute(candidate.toJSON());
-            if (this.onicecandidate) {
-                this.onicecandidate({ candidate: candidate.toJSON() });
+            if (!this._localDescription) {
+                log("localDescription not found when ice candidate was gathered");
+                return;
             }
-            this.emit("icecandidate", { candidate });
+            this.secureManager.handleNewIceCandidate({
+                candidate,
+                bundlePolicy: this.sdpManager.bundlePolicy,
+                remoteIsBundled: !!this.sdpManager.remoteIsBundled,
+                media: this._localDescription.media[0],
+                transceiver: this.transceiverManager
+                    .getTransceivers()
+                    .find((t) => t.dtlsTransport.iceTransport.id === iceTransport.id),
+                sctpTransport: this.sctpTransport?.dtlsTransport.iceTransport.id === iceTransport.id
+                    ? this.sctpTransport
+                    : undefined,
+            });
         });
-        const dtlsTransport = new dtls_1.RTCDtlsTransport(this.config, iceTransport, this.router, this.certificate, srtpProfiles);
         return dtlsTransport;
     }
-    createSctpTransport() {
-        const dtlsTransport = this.createTransport([
-            const_1.SRTP_PROFILE.SRTP_AEAD_AES_128_GCM, // prefer
-            const_1.SRTP_PROFILE.SRTP_AES128_CM_HMAC_SHA1_80,
-        ]);
-        const sctp = new sctp_1.RTCSctpTransport();
-        sctp.setDtlsTransport(dtlsTransport);
-        sctp.mid = undefined;
-        sctp.onDataChannel.subscribe((channel) => {
-            this.onDataChannel.execute(channel);
-            const event = { channel };
-            if (this.ondatachannel)
-                this.ondatachannel(event);
-            this.emit("datachannel", event);
-        });
-        this.sctpTransport = sctp;
-        this.updateIceConnectionState();
-        return sctp;
-    }
     async setLocalDescription(sessionDescription) {
+        // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/setLocalDescription#type
+        const implicitOfferState = [
+            "stable",
+            "have-local-offer",
+            "have-remote-pranswer",
+        ];
+        sessionDescription =
+            sessionDescription ??
+                (implicitOfferState.includes(this.signalingState)
+                    ? await this.createOffer()
+                    : await this.createAnswer());
         // # parse and validate description
-        const description = sdp_1.SessionDescription.parse(sessionDescription.sdp);
-        description.type = sessionDescription.type;
-        this.validateDescription(description, true);
+        const description = this.sdpManager.parseSdp({
+            sdp: sessionDescription.sdp,
+            isLocal: true,
+            signalingState: this.signalingState,
+            type: sessionDescription.type,
+        });
         // # update signaling state
         if (description.type === "offer") {
             this.setSignalingState("have-local-offer");
@@ -686,9 +498,9 @@ class RTCPeerConnection extends helper_1.EventTarget {
         // # assign MID
         for (const [i, media] of (0, helper_1.enumerate)(description.media)) {
             const mid = media.rtp.muxId;
-            this.seenMid.add(mid);
+            this.sdpManager.registerMid(mid);
             if (["audio", "video"].includes(media.kind)) {
-                const transceiver = this.getTransceiverByMLineIndex(i);
+                const transceiver = this.transceiverManager.getTransceiverByMLineIndex(i);
                 if (transceiver) {
                     transceiver.mid = mid;
                 }
@@ -698,38 +510,21 @@ class RTCPeerConnection extends helper_1.EventTarget {
             }
         }
         // setup ice,dtls role
-        for (const dtlsTransport of this.dtlsTransports) {
-            const iceTransport = dtlsTransport.iceTransport;
-            // # set ICE role
-            if (description.type === "offer") {
-                iceTransport.connection.iceControlling = true;
-            }
-            else {
-                iceTransport.connection.iceControlling = false;
-            }
-            // One agent full, one lite:  The full agent MUST take the controlling role, and the lite agent MUST take the controlled role
-            // RFC 8445 S6.1.1
-            if (iceTransport.connection.remoteIsLite) {
-                iceTransport.connection.iceControlling = true;
-            }
-            // # set DTLS role for mediasoup
-            if (description.type === "answer") {
-                const role = description.media.find((media) => media.dtlsParams)
-                    ?.dtlsParams?.role;
-                if (role) {
-                    dtlsTransport.role = role;
-                }
-            }
-        }
+        const role = description.media.find((media) => media.dtlsParams)?.dtlsParams
+            ?.role;
+        this.secureManager.setLocalRole({
+            type: description.type,
+            role,
+        });
         // # configure direction
         if (["answer", "pranswer"].includes(description.type)) {
-            for (const t of this.transceivers) {
+            for (const t of this.transceiverManager.getTransceivers()) {
                 const direction = (0, utils_1.andDirection)(t.direction, t.offerDirection);
                 t.setCurrentDirection(direction);
             }
         }
         // for trickle ice
-        this.setLocal(description);
+        this.sdpManager.setLocal(description, this.transceiverManager.getTransceivers(), this.sctpTransport);
         await this.gatherCandidates().catch((e) => {
             log("gatherCandidates failed", e);
         });
@@ -737,84 +532,21 @@ class RTCPeerConnection extends helper_1.EventTarget {
         if (description.type === "answer") {
             this.connect().catch((err) => {
                 log("connect failed", err);
-                this.setConnectionState("failed");
+                this.secureManager.setConnectionState("failed");
             });
         }
-        this.setLocal(description);
+        this.sdpManager.setLocal(description, this.transceiverManager.getTransceivers(), this.sctpTransport);
         if (this.shouldNegotiationneeded) {
             this.needNegotiation();
         }
         return description;
     }
     async gatherCandidates() {
-        // # gather candidates
-        const connected = this.iceTransports.find((transport) => transport.state === "connected");
-        if (this.remoteIsBundled && connected) {
-            // no need to gather ice candidates on an existing bundled connection
-        }
-        else {
-            await Promise.allSettled(this.iceTransports.map((iceTransport) => iceTransport.gather()));
-        }
-    }
-    setLocal(description) {
-        description.media
-            .filter((m) => ["audio", "video"].includes(m.kind))
-            .forEach((m, i) => {
-            addTransportDescription(m, this.transceivers[i].dtlsTransport);
-        });
-        const sctpMedia = description.media.find((m) => m.kind === "application");
-        if (this.sctpTransport && sctpMedia) {
-            addTransportDescription(sctpMedia, this.sctpTransport.dtlsTransport);
-        }
-        if (description.type === "answer") {
-            this.currentLocalDescription = description;
-            this.pendingLocalDescription = undefined;
-        }
-        else {
-            this.pendingLocalDescription = description;
-        }
-    }
-    getTransportByMid(mid) {
-        let iceTransport;
-        const transceiver = this.transceivers.find((t) => t.mid === mid);
-        if (transceiver) {
-            iceTransport = transceiver.dtlsTransport.iceTransport;
-        }
-        else if (!iceTransport && this.sctpTransport?.mid === mid) {
-            iceTransport = this.sctpTransport?.dtlsTransport.iceTransport;
-        }
-        return iceTransport;
-    }
-    getTransportByMLineIndex(index) {
-        const sdp = this.buildOfferSdp();
-        const media = sdp.media[index];
-        if (!media) {
-            return;
-        }
-        const transport = this.getTransportByMid(media.rtp.muxId);
-        return transport;
+        await this.secureManager.gatherCandidates(!!this.sdpManager.remoteIsBundled);
     }
     async addIceCandidate(candidateMessage) {
-        const candidate = ice_1.IceCandidate.fromJSON(candidateMessage);
-        if (!candidate) {
-            return;
-        }
-        let iceTransport;
-        if (typeof candidate.sdpMid === "number") {
-            iceTransport = this.getTransportByMid(candidate.sdpMid);
-        }
-        if (!iceTransport && typeof candidate.sdpMLineIndex === "number") {
-            iceTransport = this.getTransportByMLineIndex(candidate.sdpMLineIndex);
-        }
-        if (!iceTransport) {
-            iceTransport = this.iceTransports[0];
-        }
-        if (iceTransport) {
-            await iceTransport.addRemoteCandidate(candidate);
-        }
-        else {
-            log("iceTransport not found", candidate);
-        }
+        const sdp = this.sdpManager.buildOfferSdp(this.transceiverManager.getTransceivers(), this.sctpTransport);
+        await this.secureManager.addIceCandidate(sdp, candidateMessage);
     }
     async connect() {
         log("start connect");
@@ -823,12 +555,16 @@ class RTCPeerConnection extends helper_1.EventTarget {
             if (iceTransport.state === "connected") {
                 return;
             }
-            this.setConnectionState("connecting");
+            const checkDtlsConnected = () => dtlsTransport.state === "connected";
+            if (checkDtlsConnected()) {
+                return;
+            }
+            this.secureManager.setConnectionState("connecting");
             await iceTransport.start().catch((err) => {
                 log("iceTransport.start failed", err);
                 throw err;
             });
-            if (dtlsTransport.state === "connected") {
+            if (checkDtlsConnected()) {
                 return;
             }
             await dtlsTransport.start().catch((err) => {
@@ -836,85 +572,27 @@ class RTCPeerConnection extends helper_1.EventTarget {
                 throw err;
             });
             if (this.sctpTransport &&
-                this.sctpRemotePort &&
                 this.sctpTransport.dtlsTransport.id === dtlsTransport.id) {
-                await this.sctpTransport.start(this.sctpRemotePort);
-                await this.sctpTransport.sctp.stateChanged.connected.asPromise();
-                log("sctp connected");
+                await this.sctpManager.connectSctp();
             }
         }));
         if (res.find((r) => r.status === "rejected")) {
-            this.setConnectionState("failed");
+            this.secureManager.setConnectionState("failed");
         }
         else {
-            this.setConnectionState("connected");
+            this.secureManager.setConnectionState("connected");
         }
     }
-    getLocalRtpParams(transceiver) {
-        if (transceiver.mid == undefined)
-            throw new Error("mid not assigned");
-        const rtp = {
-            codecs: transceiver.codecs,
-            muxId: transceiver.mid,
-            headerExtensions: transceiver.headerExtensions,
-            rtcp: { cname: this.cname, ssrc: transceiver.sender.ssrc, mux: true },
-        };
-        return rtp;
-    }
-    getRemoteRtpParams(media, transceiver) {
-        const receiveParameters = {
-            muxId: media.rtp.muxId,
-            rtcp: media.rtp.rtcp,
-            codecs: transceiver.codecs,
-            headerExtensions: transceiver.headerExtensions,
-            encodings: Object.values(transceiver.codecs.reduce((acc, codec) => {
-                if (codec.name.toLowerCase() === "rtx") {
-                    const params = (0, sdp_1.codecParametersFromString)(codec.parameters ?? "");
-                    const apt = acc[params["apt"]];
-                    if (apt && media.ssrc.length === 2) {
-                        apt.rtx = new media_1.RTCRtpRtxParameters({ ssrc: media.ssrc[1].ssrc });
-                    }
-                    return acc;
-                }
-                acc[codec.payloadType] = new media_1.RTCRtpCodingParameters({
-                    ssrc: media.ssrc[0]?.ssrc,
-                    payloadType: codec.payloadType,
-                });
-                return acc;
-            }, {})),
-        };
-        return receiveParameters;
-    }
-    get remoteIsBundled() {
-        const remoteSdp = this._remoteDescription;
-        if (!remoteSdp) {
-            return undefined;
-        }
-        const bundle = remoteSdp.group.find((g) => g.semantic === "BUNDLE" && this.config.bundlePolicy !== "disable");
-        return bundle;
-    }
     restartIce() {
         this.needRestart = true;
         this.needNegotiation();
     }
     async setRemoteDescription(sessionDescription) {
-        if (!sessionDescription.sdp ||
-            !sessionDescription.type ||
-            sessionDescription.type === "rollback" ||
-            sessionDescription.type === "pranswer") {
-            throw new Error("invalid sessionDescription");
+        if (sessionDescription instanceof sdp_1.SessionDescription) {
+            sessionDescription = sessionDescription.toSdp();
         }
         // # parse and validate description
-        const remoteSdp = sdp_1.SessionDescription.parse(sessionDescription.sdp);
-        remoteSdp.type = sessionDescription.type;
-        this.validateDescription(remoteSdp, false);
-        if (remoteSdp.type === "answer") {
-            this.currentRemoteDescription = remoteSdp;
-            this.pendingRemoteDescription = undefined;
-        }
-        else {
-            this.pendingRemoteDescription = remoteSdp;
-        }
+        const remoteSdp = this.sdpManager.setRemoteDescription(sessionDescription, this.signalingState);
         let bundleTransport;
         // # apply description
         const matchTransceiverWithMedia = (transceiver, media) => transceiver.kind === media.kind &&
@@ -922,10 +600,12 @@ class RTCPeerConnection extends helper_1.EventTarget {
         let transports = remoteSdp.media.map((remoteMedia, i) => {
             let dtlsTransport;
             if (["audio", "video"].includes(remoteMedia.kind)) {
-                let transceiver = this.transceivers.find((t) => matchTransceiverWithMedia(t, remoteMedia));
+                let transceiver = this.transceiverManager
+                    .getTransceivers()
+                    .find((t) => matchTransceiverWithMedia(t, remoteMedia));
                 if (!transceiver) {
                     // create remote transceiver
-                    transceiver = this._addTransceiver(remoteMedia.kind, {
+                    transceiver = this.addTransceiver(remoteMedia.kind, {
                         direction: "recvonly",
                     });
                     transceiver.mid = remoteMedia.rtp.muxId;
@@ -940,7 +620,7 @@ class RTCPeerConnection extends helper_1.EventTarget {
                         return;
                     }
                 }
-                if (this.remoteIsBundled) {
+                if (this.sdpManager.remoteIsBundled) {
                     if (!bundleTransport) {
                         bundleTransport = transceiver.dtlsTransport;
                     }
@@ -949,30 +629,31 @@ class RTCPeerConnection extends helper_1.EventTarget {
                     }
                 }
                 dtlsTransport = transceiver.dtlsTransport;
-                this.setRemoteRTP(transceiver, remoteMedia, remoteSdp.type, i);
+                this.transceiverManager.setRemoteRTP(transceiver, remoteMedia, remoteSdp.type, i);
             }
             else if (remoteMedia.kind === "application") {
-                if (!this.sctpTransport) {
-                    this.sctpTransport = this.createSctpTransport();
-                    this.sctpTransport.mid = remoteMedia.rtp.muxId;
+                let sctpTransport = this.sctpTransport;
+                if (!sctpTransport) {
+                    sctpTransport = this.createSctpTransport();
+                    sctpTransport.mid = remoteMedia.rtp.muxId;
                 }
-                if (this.remoteIsBundled) {
+                if (this.sdpManager.remoteIsBundled) {
                     if (!bundleTransport) {
-                        bundleTransport = this.sctpTransport.dtlsTransport;
+                        bundleTransport = sctpTransport.dtlsTransport;
                     }
                     else {
-                        this.sctpTransport.setDtlsTransport(bundleTransport);
+                        sctpTransport.setDtlsTransport(bundleTransport);
                     }
                 }
-                dtlsTransport = this.sctpTransport.dtlsTransport;
-                this.setRemoteSCTP(remoteMedia, this.sctpTransport, i);
+                dtlsTransport = sctpTransport.dtlsTransport;
+                this.sctpManager.setRemoteSCTP(remoteMedia, i);
             }
             else {
                 throw new Error("invalid media kind");
             }
             const iceTransport = dtlsTransport.iceTransport;
             if (remoteMedia.iceParams) {
-                const renomination = !!remoteSdp.media.find((m) => m.direction === "inactive");
+                const renomination = !!this.sdpManager.inactiveRemoteMedia;
                 iceTransport.setRemoteParams(remoteMedia.iceParams, renomination);
                 // One agent full, one lite:  The full agent MUST take the controlling role, and the lite agent MUST take the controlled role
                 // RFC 8445 S6.1.1
@@ -997,7 +678,9 @@ class RTCPeerConnection extends helper_1.EventTarget {
         });
         // filter out inactive transports
         transports = transports.filter((iceTransport) => !!iceTransport);
-        const removedTransceivers = this.transceivers.filter((t) => remoteSdp.media.find((m) => matchTransceiverWithMedia(t, m)) ==
+        const removedTransceivers = this.transceiverManager
+            .getTransceivers()
+            .filter((t) => remoteSdp.media.find((m) => matchTransceiverWithMedia(t, m)) ==
             undefined);
         if (sessionDescription.type === "answer") {
             for (const transceiver of removedTransceivers) {
@@ -1018,7 +701,7 @@ class RTCPeerConnection extends helper_1.EventTarget {
             log("caller start connect");
             this.connect().catch((err) => {
                 log("connect failed", err);
-                this.setConnectionState("failed");
+                this.secureManager.setConnectionState("failed");
             });
         }
         this.negotiationneeded = false;
@@ -1026,177 +709,12 @@ class RTCPeerConnection extends helper_1.EventTarget {
             this.needNegotiation();
         }
     }
-    setRemoteRTP(transceiver, remoteMedia, type, mLineIndex) {
-        if (!transceiver.mid) {
-            transceiver.mid = remoteMedia.rtp.muxId;
-        }
-        transceiver.mLineIndex = mLineIndex;
-        // # negotiate codecs
-        transceiver.codecs = remoteMedia.rtp.codecs.filter((remoteCodec) => {
-            const localCodecs = this.config.codecs[remoteMedia.kind] || [];
-            const existCodec = (0, exports.findCodecByMimeType)(localCodecs, remoteCodec);
-            if (!existCodec) {
-                return false;
-            }
-            if (existCodec?.name.toLowerCase() === "rtx") {
-                const params = (0, sdp_1.codecParametersFromString)(existCodec.parameters ?? "");
-                const pt = params["apt"];
-                const origin = remoteMedia.rtp.codecs.find((c) => c.payloadType === pt);
-                if (!origin) {
-                    return false;
-                }
-                return !!(0, exports.findCodecByMimeType)(localCodecs, origin);
-            }
-            return true;
-        });
-        log("negotiated codecs", transceiver.codecs);
-        if (transceiver.codecs.length === 0) {
-            throw new Error("negotiate codecs failed.");
-        }
-        transceiver.headerExtensions = remoteMedia.rtp.headerExtensions.filter((extension) => (this.config.headerExtensions[remoteMedia.kind] || []).find((v) => v.uri === extension.uri));
-        // # configure direction
-        const mediaDirection = remoteMedia.direction ?? "inactive";
-        const direction = (0, utils_1.reverseDirection)(mediaDirection);
-        if (["answer", "pranswer"].includes(type)) {
-            transceiver.setCurrentDirection(direction);
-        }
-        else {
-            transceiver.offerDirection = direction;
-        }
-        const localParams = this.getLocalRtpParams(transceiver);
-        transceiver.sender.prepareSend(localParams);
-        if (["recvonly", "sendrecv"].includes(transceiver.direction)) {
-            const remotePrams = this.getRemoteRtpParams(remoteMedia, transceiver);
-            // register simulcast receiver
-            remoteMedia.simulcastParameters.forEach((param) => {
-                this.router.registerRtpReceiverByRid(transceiver, param, remotePrams);
-            });
-            transceiver.receiver.prepareReceive(remotePrams);
-            // register ssrc receiver
-            this.router.registerRtpReceiverBySsrc(transceiver, remotePrams);
-        }
-        if (["sendonly", "sendrecv"].includes(mediaDirection)) {
-            if (remoteMedia.msid) {
-                const [streamId, trackId] = remoteMedia.msid.split(" ");
-                transceiver.receiver.remoteStreamId = streamId;
-                transceiver.receiver.remoteTrackId = trackId;
-            }
-            this.fireOnTrack(transceiver.receiver.track, transceiver, new media_1.MediaStream({
-                id: transceiver.receiver.remoteStreamId,
-                tracks: [transceiver.receiver.track],
-            }));
-        }
-        if (remoteMedia.ssrc[0]?.ssrc) {
-            transceiver.receiver.setupTWCC(remoteMedia.ssrc[0].ssrc);
-        }
-    }
-    setRemoteSCTP(remoteMedia, sctpTransport, mLineIndex) {
-        // # configure sctp
-        this.sctpRemotePort = remoteMedia.sctpPort;
-        if (!this.sctpRemotePort) {
-            throw new Error("sctpRemotePort not exist");
-        }
-        sctpTransport.setRemotePort(this.sctpRemotePort);
-        sctpTransport.mLineIndex = mLineIndex;
-        if (!sctpTransport.mid) {
-            sctpTransport.mid = remoteMedia.rtp.muxId;
-        }
-    }
-    validateDescription(description, isLocal) {
-        if (isLocal) {
-            if (description.type === "offer") {
-                if (!["stable", "have-local-offer"].includes(this.signalingState))
-                    throw new Error("Cannot handle offer in signaling state");
-            }
-            else if (description.type === "answer") {
-                if (!["have-remote-offer", "have-local-pranswer"].includes(this.signalingState)) {
-                    throw new Error("Cannot handle answer in signaling state");
-                }
-            }
-        }
-        else {
-            if (description.type === "offer") {
-                if (!["stable", "have-remote-offer"].includes(this.signalingState)) {
-                    throw new Error("Cannot handle offer in signaling state");
-                }
-            }
-            else if (description.type === "answer") {
-                if (!["have-local-offer", "have-remote-pranswer"].includes(this.signalingState)) {
-                    throw new Error("Cannot handle answer in signaling state");
-                }
-            }
-        }
-        description.media.forEach((media) => {
-            if (media.direction === "inactive")
-                return;
-            if (!media.iceParams ||
-                !media.iceParams.usernameFragment ||
-                !media.iceParams.password)
-                throw new Error("ICE username fragment or password is missing");
-        });
-        if (["answer", "pranswer"].includes(description.type || "")) {
-            const offer = isLocal ? this._remoteDescription : this._localDescription;
-            if (!offer)
-                throw new Error();
-            const answerMedia = description.media.map((v, i) => [v.kind, i]);
-            const offerMedia = offer.media.map((v, i) => [v.kind, i]);
-            if (!(0, isEqual_js_1.default)(offerMedia, answerMedia)) {
-                throw new Error("Media sections in answer do not match offer");
-            }
-        }
-    }
-    fireOnTrack(track, transceiver, stream) {
-        const event = {
-            track,
-            streams: [stream],
-            transceiver,
-            receiver: transceiver.receiver,
-        };
-        this.onTrack.execute(track);
-        this.emit("track", event);
-        if (this.ontrack) {
-            this.ontrack(event);
-        }
-    }
     addTransceiver(trackOrKind, options = {}) {
-        return this._addTransceiver(trackOrKind, options);
-    }
-    _addTransceiver(trackOrKind, options = {}) {
-        const kind = typeof trackOrKind === "string" ? trackOrKind : trackOrKind.kind;
-        const direction = options.direction || "sendrecv";
-        const dtlsTransport = this.createTransport([
-            const_1.SRTP_PROFILE.SRTP_AEAD_AES_128_GCM, // prefer
-            const_1.SRTP_PROFILE.SRTP_AES128_CM_HMAC_SHA1_80,
-        ]);
-        const sender = new media_1.RTCRtpSender(trackOrKind);
-        const receiver = new media_1.RTCRtpReceiver(this.config, kind, sender.ssrc);
-        const newTransceiver = new media_1.RTCRtpTransceiver(kind, dtlsTransport, receiver, sender, direction);
-        newTransceiver.options = options;
-        this.router.registerRtpSender(newTransceiver.sender);
-        // reuse inactive
-        const inactiveTransceiverIndex = this.transceivers.findIndex((t) => t.currentDirection === "inactive");
-        const inactiveTransceiver = this.transceivers.find((t) => t.currentDirection === "inactive");
-        if (inactiveTransceiverIndex > -1 && inactiveTransceiver) {
-            this.replaceTransceiver(newTransceiver, inactiveTransceiverIndex);
-            newTransceiver.mLineIndex = inactiveTransceiver.mLineIndex;
-            inactiveTransceiver.setCurrentDirection(undefined);
-        }
-        else {
-            this.pushTransceiver(newTransceiver);
-        }
-        this.onTransceiverAdded.execute(newTransceiver);
-        this.updateIceConnectionState();
+        const dtlsTransport = this.findOrCreateTransport();
+        const transceiver = this.transceiverManager.addTransceiver(trackOrKind, dtlsTransport, options);
+        this.secureManager.updateIceConnectionState();
         this.needNegotiation();
-        return newTransceiver;
-    }
-    getTransceivers() {
-        return this.transceivers;
-    }
-    getSenders() {
-        return this.getTransceivers().map((t) => t.sender);
-    }
-    getReceivers() {
-        return this.getTransceivers().map((t) => t.receiver);
+        return transceiver;
     }
     // todo fix
     addTrack(track, 
@@ -1205,207 +723,29 @@ class RTCPeerConnection extends helper_1.EventTarget {
         if (this.isClosed) {
             throw new Error("is closed");
         }
-        if (this.getSenders().find((sender) => sender.track?.uuid === track.uuid)) {
-            throw new Error("track exist");
-        }
-        const emptyTrackSender = this.transceivers.find((t) => t.sender.track == undefined &&
-            t.kind === track.kind &&
-            const_1.SenderDirections.includes(t.direction) === true);
-        if (emptyTrackSender) {
-            const sender = emptyTrackSender.sender;
-            sender.registerTrack(track);
-            this.needNegotiation();
-            return sender;
-        }
-        const notSendTransceiver = this.transceivers.find((t) => t.sender.track == undefined &&
-            t.kind === track.kind &&
-            const_1.SenderDirections.includes(t.direction) === false &&
-            !t.usedForSender);
-        if (notSendTransceiver) {
-            const sender = notSendTransceiver.sender;
-            sender.registerTrack(track);
-            switch (notSendTransceiver.direction) {
-                case "recvonly":
-                    notSendTransceiver.setDirection("sendrecv");
-                    break;
-                case "inactive":
-                    notSendTransceiver.setDirection("sendonly");
-                    break;
-            }
-            this.needNegotiation();
-            return sender;
-        }
-        else {
-            const transceiver = this._addTransceiver(track, {
-                direction: "sendrecv",
-            });
-            this.needNegotiation();
-            return transceiver.sender;
-        }
-    }
-    async ensureCerts() {
-        if (!this.certificate) {
-            this.certificate = await dtls_1.RTCDtlsTransport.SetupCertificate();
-        }
-        for (const dtlsTransport of this.dtlsTransports) {
-            dtlsTransport.localCertificate = this.certificate;
+        const transceiver = this.transceiverManager.addTrack(track, ms);
+        if (!transceiver.dtlsTransport) {
+            const dtlsTransport = this.findOrCreateTransport();
+            transceiver.setDtlsTransport(dtlsTransport);
         }
+        this.needNegotiation();
+        return transceiver.sender;
     }
     async createAnswer() {
-        await this.ensureCerts();
-        const description = this.buildAnswer();
-        return description.toJSON();
-    }
-    buildAnswer() {
         this.assertNotClosed();
-        if (!["have-remote-offer", "have-local-pranswer"].includes(this.signalingState)) {
-            throw new Error("createAnswer failed");
-        }
-        if (!this._remoteDescription) {
-            throw new Error("wrong state");
-        }
-        const description = new sdp_1.SessionDescription();
-        (0, sdp_1.addSDPHeader)("answer", description);
-        this._remoteDescription.media.forEach((remoteMedia) => {
-            let dtlsTransport;
-            let media;
-            if (["audio", "video"].includes(remoteMedia.kind)) {
-                const transceiver = this.getTransceiverByMid(remoteMedia.rtp.muxId);
-                media = createMediaDescriptionForTransceiver(transceiver, this.cname, (0, utils_1.andDirection)(transceiver.direction, transceiver.offerDirection));
-                dtlsTransport = transceiver.dtlsTransport;
-            }
-            else if (remoteMedia.kind === "application") {
-                if (!this.sctpTransport || !this.sctpTransport.mid) {
-                    throw new Error("sctpTransport not found");
-                }
-                media = createMediaDescriptionForSctp(this.sctpTransport);
-                dtlsTransport = this.sctpTransport.dtlsTransport;
-            }
-            else {
-                throw new Error("invalid kind");
-            }
-            // # determine DTLS role, or preserve the currently configured role
-            if (media.dtlsParams) {
-                if (dtlsTransport.role === "auto") {
-                    media.dtlsParams.role = "client";
-                }
-                else {
-                    media.dtlsParams.role = dtlsTransport.role;
-                }
-            }
-            media.simulcastParameters = remoteMedia.simulcastParameters.map((v) => ({
-                ...v,
-                direction: (0, utils_1.reverseSimulcastDirection)(v.direction),
-            }));
-            description.media.push(media);
-        });
-        if (this.config.bundlePolicy !== "disable") {
-            const bundle = new sdp_1.GroupDescription("BUNDLE", []);
-            for (const media of description.media) {
-                if (media.direction !== "inactive") {
-                    bundle.items.push(media.rtp.muxId);
-                }
-            }
-            description.group.push(bundle);
-        }
-        return description;
-    }
-    async close() {
-        if (this.isClosed)
-            return;
-        this.isClosed = true;
-        this.setSignalingState("closed");
-        this.setConnectionState("closed");
-        this.transceivers.forEach((transceiver) => {
-            transceiver.receiver.stop();
-            transceiver.sender.stop();
+        await this.secureManager.ensureCerts();
+        const description = this.sdpManager.buildAnswerSdp({
+            transceivers: this.transceiverManager.getTransceivers(),
+            sctpTransport: this.sctpTransport,
+            signalingState: this.signalingState,
         });
-        if (this.sctpTransport) {
-            await this.sctpTransport.stop();
-        }
-        for (const dtlsTransport of this.dtlsTransports) {
-            await dtlsTransport.stop();
-            await dtlsTransport.iceTransport.stop();
-        }
-        this.dispose();
-        log("peerConnection closed");
+        return description.toJSON();
     }
     assertNotClosed() {
         if (this.isClosed) {
             throw new Error("RTCPeerConnection is closed");
         }
     }
-    // https://w3c.github.io/webrtc-pc/#dom-rtcicegatheringstate
-    updateIceGatheringState() {
-        const all = this.iceTransports;
-        function allMatch(...state) {
-            return (all.filter((check) => state.includes(check.gatheringState)).length ===
-                all.length);
-        }
-        let newState;
-        if (all.length && allMatch("complete")) {
-            newState = "complete";
-        }
-        else if (!all.length || allMatch("new", "complete")) {
-            newState = "new";
-        }
-        else if (all.map((check) => check.gatheringState).includes("gathering")) {
-            newState = "gathering";
-        }
-        else {
-            newState = "new";
-        }
-        if (this.iceGatheringState === newState) {
-            return;
-        }
-        log("iceGatheringStateChange", newState);
-        this.iceGatheringState = newState;
-        this.iceGatheringStateChange.execute(newState);
-        this.emit("icegatheringstatechange", newState);
-    }
-    // https://w3c.github.io/webrtc-pc/#dom-rtciceconnectionstate
-    updateIceConnectionState() {
-        const all = this.iceTransports;
-        let newState;
-        function allMatch(...state) {
-            return (all.filter((check) => state.includes(check.state)).length === all.length);
-        }
-        if (this.connectionState === "closed") {
-            newState = "closed";
-        }
-        else if (allMatch("failed")) {
-            newState = "failed";
-        }
-        else if (allMatch("disconnected")) {
-            newState = "disconnected";
-        }
-        else if (allMatch("new", "closed")) {
-            newState = "new";
-        }
-        else if (allMatch("new", "checking")) {
-            newState = "checking";
-        }
-        else if (allMatch("completed", "closed")) {
-            newState = "completed";
-        }
-        else if (allMatch("connected", "completed", "closed")) {
-            newState = "connected";
-        }
-        else {
-            // unreachable?
-            newState = "new";
-        }
-        if (this.iceConnectionState === newState) {
-            return;
-        }
-        log("iceConnectionStateChange", newState);
-        this.iceConnectionState = newState;
-        this.iceConnectionStateChange.execute(newState);
-        this.emit("iceconnectionstatechange", newState);
-        if (this.oniceconnectionstatechange) {
-            this.oniceconnectionstatechange();
-        }
-    }
     setSignalingState(state) {
         log("signalingStateChange", state);
         this.signalingState = state;
@@ -1414,16 +754,43 @@ class RTCPeerConnection extends helper_1.EventTarget {
             this.onsignalingstatechange({});
         }
     }
-    setConnectionState(state) {
-        log("connectionStateChange", state);
-        this.connectionState = state;
-        this.connectionStateChange.execute(state);
-        if (this.onconnectionstatechange) {
-            this.onconnectionstatechange();
+    createPeerConnectionStats() {
+        const timestamp = (0, stats_1.getStatsTimestamp)();
+        return {
+            type: "peer-connection",
+            id: (0, stats_1.generateStatsId)("peer-connection"),
+            timestamp,
+            dataChannelsOpened: this.sctpManager.dataChannelsOpened,
+            dataChannelsClosed: this.sctpManager.dataChannelsClosed,
+        };
+    }
+    async getStats(selector) {
+        const stats = [];
+        // Peer connection stats - always included regardless of selector
+        stats.push(this.createPeerConnectionStats());
+        // Get stats from transceivers
+        const transceiverStats = await this.transceiverManager.getStats(selector);
+        stats.push(...transceiverStats);
+        // Get transport stats - always included regardless of selector
+        const transportStats = await this.secureManager.getStats();
+        stats.push(...transportStats);
+        // Get data channel stats - always included regardless of selector
+        if (this.sctpTransport) {
+            const dataChannelStats = await this.sctpManager.getStats();
+            if (dataChannelStats) {
+                stats.push(...dataChannelStats);
+            }
         }
-        this.emit("connectionstatechange");
+        return new stats_1.RTCStatsReport(stats);
     }
-    dispose() {
+    async close() {
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        this.setSignalingState("closed");
+        this.transceiverManager.close();
+        await this.secureManager.close();
+        await this.sctpManager.close();
         this.onDataChannel.allUnsubscribe();
         this.iceGatheringStateChange.allUnsubscribe();
         this.iceConnectionStateChange.allUnsubscribe();
@@ -1431,105 +798,41 @@ class RTCPeerConnection extends helper_1.EventTarget {
         this.onTransceiverAdded.allUnsubscribe();
         this.onRemoteTransceiverAdded.allUnsubscribe();
         this.onIceCandidate.allUnsubscribe();
+        log("peerConnection closed");
     }
 }
 exports.RTCPeerConnection = RTCPeerConnection;
-function createMediaDescriptionForTransceiver(transceiver, cname, direction) {
-    const media = new sdp_1.MediaDescription(transceiver.kind, 9, "UDP/TLS/RTP/SAVPF", transceiver.codecs.map((c) => c.payloadType));
-    media.direction = direction;
-    media.msid = transceiver.msid;
-    media.rtp = {
-        codecs: transceiver.codecs,
-        headerExtensions: transceiver.headerExtensions,
-        muxId: transceiver.mid,
-    };
-    media.rtcpHost = "0.0.0.0";
-    media.rtcpPort = 9;
-    media.rtcpMux = true;
-    media.ssrc = [new sdp_1.SsrcDescription({ ssrc: transceiver.sender.ssrc, cname })];
-    if (transceiver.options.simulcast) {
-        media.simulcastParameters = transceiver.options.simulcast.map((o) => new media_1.RTCRtpSimulcastParameters(o));
-    }
-    if (media.rtp.codecs.find((c) => c.name.toLowerCase() === "rtx")) {
-        media.ssrc.push(new sdp_1.SsrcDescription({ ssrc: transceiver.sender.rtxSsrc, cname }));
-        media.ssrcGroup = [
-            new sdp_1.GroupDescription("FID", [
-                transceiver.sender.ssrc.toString(),
-                transceiver.sender.rtxSsrc.toString(),
-            ]),
-        ];
-    }
-    addTransportDescription(media, transceiver.dtlsTransport);
-    return media;
-}
-function createMediaDescriptionForSctp(sctp) {
-    const media = new sdp_1.MediaDescription("application", const_1.DISCARD_PORT, "UDP/DTLS/SCTP", ["webrtc-datachannel"]);
-    media.sctpPort = sctp.port;
-    media.rtp.muxId = sctp.mid;
-    media.sctpCapabilities = sctp_1.RTCSctpTransport.getCapabilities();
-    addTransportDescription(media, sctp.dtlsTransport);
-    return media;
-}
-function addTransportDescription(media, dtlsTransport) {
-    const iceTransport = dtlsTransport.iceTransport;
-    media.iceCandidates = iceTransport.localCandidates;
-    media.iceCandidatesComplete = iceTransport.gatheringState === "complete";
-    media.iceParams = iceTransport.localParameters;
-    media.iceOptions = "trickle";
-    media.host = const_1.DISCARD_HOST;
-    media.port = const_1.DISCARD_PORT;
-    if (media.direction === "inactive") {
-        media.port = 0;
-        media.msid = undefined;
-    }
-    if (!media.dtlsParams) {
-        media.dtlsParams = dtlsTransport.localParameters;
-        if (!media.dtlsParams.fingerprints) {
-            media.dtlsParams.fingerprints =
-                dtlsTransport.localParameters.fingerprints;
-        }
-    }
-}
-function allocateMid(mids, type) {
-    let mid = "";
-    for (let i = 0;;) {
-        // rfc9143.html#name-security-considerations
-        // SHOULD be 3 bytes or fewer to allow them to efficiently fit into the MID RTP header extension
-        mid = (i++).toString() + type;
-        if (!mids.has(mid))
-            break;
-    }
-    mids.add(mid);
-    return mid;
-}
 const findCodecByMimeType = (codecs, target) => codecs.find((localCodec) => localCodec.mimeType.toLowerCase() === target.mimeType.toLowerCase())
     ? target
     : undefined;
 exports.findCodecByMimeType = findCodecByMimeType;
-exports.defaultPeerConfig = {
-    codecs: {
-        audio: [(0, media_1.useOPUS)(), (0, media_1.usePCMU)()],
-        video: [(0, media_1.useVP8)()],
-    },
-    headerExtensions: {
-        audio: [],
-        video: [],
-    },
-    iceTransportPolicy: "all",
-    iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
-    icePortRange: undefined,
-    iceInterfaceAddresses: undefined,
-    iceAdditionalHostAddresses: undefined,
-    iceUseIpv4: true,
-    iceUseIpv6: true,
-    iceFilterStunResponse: undefined,
-    iceFilterCandidatePair: undefined,
-    icePasswordPrefix: undefined,
-    iceUseLinkLocalAddress: undefined,
-    dtls: {},
-    bundlePolicy: "max-compat",
-    debug: {},
-    midSuffix: false,
-    forceTurnTCP: false,
-};
+function generateDefaultPeerConfig() {
+    return {
+        codecs: {
+            audio: [(0, media_1.useOPUS)(), (0, media_1.usePCMU)()],
+            video: [(0, media_1.useVP8)()],
+        },
+        headerExtensions: {
+            audio: [],
+            video: [],
+        },
+        iceTransportPolicy: "all",
+        iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
+        icePortRange: undefined,
+        iceInterfaceAddresses: undefined,
+        iceAdditionalHostAddresses: undefined,
+        iceUseIpv4: true,
+        iceUseIpv6: true,
+        iceFilterStunResponse: undefined,
+        iceFilterCandidatePair: undefined,
+        icePasswordPrefix: undefined,
+        iceUseLinkLocalAddress: undefined,
+        dtls: {},
+        bundlePolicy: "max-compat",
+        debug: {},
+        midSuffix: false,
+        forceTurnTCP: false,
+    };
+}
+exports.defaultPeerConfig = generateDefaultPeerConfig();
 //# sourceMappingURL=peerConnection.js.map