werift 0.24.3 → 0.25.0-alpha.0

package/lib/webrtc/src/peerConnection.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RTCTrackEvent = exports.defaultPeerConfig = exports.findCodecByMimeType = exports.RTCPeerConnection = void 0;
 const crypto_1 = require("crypto");
+const src_1 = require("../../sctp/src");
 const errors_1 = require("./errors");
 const helper_1 = require("./helper");
 const common_1 = require("./imports/common");
@@ -124,6 +125,40 @@ class RTCPeerConnection extends helper_1.EventTarget {
             writable: true,
             value: false
         });
+        /**同じ tick の複数の変更で negotiationneeded を重複発火しないための予約フラグ */
+        Object.defineProperty(this, "negotiationneededScheduled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /**交渉が必要な変更の通し番号 */
+        Object.defineProperty(this, "negotiationChangeSeq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /**answer まで確定した local offer が反映している変更の通し番号 */
+        Object.defineProperty(this, "negotiatedChangeSeq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /**適用中の local offer が反映している変更の通し番号 (rollback で破棄) */
+        Object.defineProperty(this, "pendingOfferChangeSeq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lastCreatedOfferChangeSeq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         Object.defineProperty(this, "needRestart", {
             enumerable: true,
             configurable: true,
@@ -256,31 +291,21 @@ class RTCPeerConnection extends helper_1.EventTarget {
             writable: true,
             value: {}
         });
+        /**交渉が必要な変更を記録し、negotiationneeded を予約する */
         Object.defineProperty(this, "needNegotiation", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: async () => {
-                this.invalidateLastCreatedDescriptions();
-                this.shouldNegotiationneeded = true;
-                if (this.negotiationneeded || this.signalingState !== "stable") {
-                    return;
-                }
-                this.shouldNegotiationneeded = false;
-                setImmediate(() => {
-                    this.negotiationneeded = true;
-                    this.onNegotiationneeded.execute();
-                    if (this.onnegotiationneeded) {
-                        this.onnegotiationneeded(new globalThis.Event("negotiationneeded"));
-                    }
-                    this.emit("negotiationneeded");
-                });
+            value: () => {
+                this.negotiationChangeSeq++;
+                this.scheduleNegotiationneeded();
             }
         });
         this.setConfiguration(config);
         this.sdpManager = new sdpManager_1.SDPManager({
             cname: this.cname,
             bundlePolicy: this.config.bundlePolicy,
+            mLineReuse: this.config.mLineReuse,
         });
         this.transceiverManager = new media_1.TransceiverManager(this.cname, this.config, this.router);
         this.transceiverManager.onTransceiverAdded.pipe(this.onTransceiverAdded);
@@ -441,6 +466,15 @@ class RTCPeerConnection extends helper_1.EventTarget {
             normalizedConfig.bundlePolicy !== this.config.bundlePolicy) {
             throw new Error("bundlePolicy cannot be changed");
         }
+        if (normalizedConfig.mLineReuse !== undefined &&
+            !MLineReuseModes.includes(normalizedConfig.mLineReuse)) {
+            throw (0, errors_1.createWebRtcTypeError)(`mLineReuse must be one of ${MLineReuseModes.join(", ")}`);
+        }
+        if (isReconfiguration &&
+            normalizedConfig.mLineReuse !== undefined &&
+            normalizedConfig.mLineReuse !== this.config.mLineReuse) {
+            throw (0, errors_1.createWebRtcDomException)("InvalidModificationError", "mLineReuse cannot be changed");
+        }
         if (isReconfiguration &&
             normalizedConfig.rtcpMuxPolicy !== undefined &&
             normalizedConfig.rtcpMuxPolicy !== this.config.rtcpMuxPolicy) {
@@ -460,7 +494,18 @@ class RTCPeerConnection extends helper_1.EventTarget {
         if ((normalizedConfig.iceCandidatePoolSize ?? 0) > 0) {
             throw new Error("iceCandidatePoolSize > 0 is not supported");
         }
+        if (normalizedConfig.sctp !== undefined) {
+            const requestedSctpMtu = normalizedConfig.sctp.mtu ?? src_1.DEFAULT_SCTP_MTU;
+            (0, src_1.validateSctpMtu)(requestedSctpMtu);
+            if (this.sctpManager?.sctpTransport &&
+                requestedSctpMtu !== this.config.sctp.mtu) {
+                throw new Error("sctp.mtu cannot be changed after SCTP transport creation");
+            }
+        }
         (0, utils_1.deepMerge)(this.config, normalizedConfig);
+        this.config.sctp = {
+            mtu: this.config.sctp?.mtu ?? src_1.DEFAULT_SCTP_MTU,
+        };
         if (this.config.icePortRange) {
             const [min, max] = this.config.icePortRange;
             if (min === max)
@@ -476,37 +521,26 @@ class RTCPeerConnection extends helper_1.EventTarget {
             this.sctpManager.sctpTransport.maxMessageSize =
                 this.config.maxMessageSize;
         }
-        for (const [i, codecParams] of (0, helper_1.enumerate)([
-            ...(this.config.codecs.audio || []),
-            ...(this.config.codecs.video || []),
-        ])) {
-            if (codecParams.payloadType != undefined) {
-                continue;
-            }
-            codecParams.payloadType = 96 + i;
-            switch (codecParams.name.toLowerCase()) {
-                case "rtx":
-                    {
-                        codecParams.parameters = `apt=${codecParams.payloadType - 1}`;
-                    }
-                    break;
-                case "red":
-                    {
-                        if (codecParams.contentType === "audio") {
-                            const redundant = codecParams.payloadType + 1;
-                            codecParams.parameters = `${redundant}/${redundant}`;
-                            codecParams.payloadType = 63;
-                        }
-                    }
-                    break;
-            }
-        }
+        assignDynamicPayloadTypes(this.config);
         [
             ...(this.config.headerExtensions.audio || []),
             ...(this.config.headerExtensions.video || []),
         ].forEach((v, i) => {
             v.id = 1 + i;
         });
+        // Propagate ICE server changes only to transports still in gathering
+        // state "new". JSEP (RFC 8829 §4.1.18): STUN/TURN changes affect the next
+        // gathering phase; once gathering has started or finished, nothing is
+        // applied to the live Connection (WHIP: createOffer → setConfiguration →
+        // setLocalDescription). Per-transport state is used so a gatherer that
+        // was reset to "new" (e.g. after ICE restart) is not blocked by a stale
+        // manager aggregate of "complete".
+        if (isReconfiguration &&
+            this.secureManager &&
+            (normalizedConfig.iceServers !== undefined ||
+                normalizedConfig.turnUdpFamily !== undefined)) {
+            this.secureManager.updateIceServers();
+        }
     }
     getConfiguration() {
         return clonePeerConfiguration(this.config);
@@ -518,7 +552,8 @@ class RTCPeerConnection extends helper_1.EventTarget {
         }
         await this.secureManager.ensureCerts();
         for (const transceiver of this.transceiverManager.getTransceivers()) {
-            if (transceiver.codecs.length === 0) {
+            if (transceiver.codecs.length === 0 ||
+                transceiver.codecPreferencesNeedResolution) {
                 this.transceiverManager.assignTransceiverCodecs(transceiver);
             }
             if (transceiver.headerExtensions.length === 0) {
@@ -529,10 +564,11 @@ class RTCPeerConnection extends helper_1.EventTarget {
         const description = this.sdpManager.buildOfferSdp(this.transceiverManager.getTransceivers(), this.sctpTransport);
         const createdOffer = description.toJSON();
         this.lastCreatedOffer = createdOffer;
+        this.lastCreatedOfferChangeSeq = this.negotiationChangeSeq;
         return createdOffer;
     }
     createSctpTransport() {
-        const sctp = this.sctpManager.createSctpTransport(this.config.maxMessageSize);
+        const sctp = this.sctpManager.createSctpTransport(this.config.maxMessageSize, this.config.sctp);
         const dtlsTransport = this.findOrCreateTransport();
         sctp.setDtlsTransport(dtlsTransport);
         return sctp;
@@ -553,8 +589,39 @@ class RTCPeerConnection extends helper_1.EventTarget {
         if (this.isClosed) {
             throw (0, errors_1.createWebRtcDomException)("InvalidStateError", "peer closed");
         }
-        this.transceiverManager.removeTrack(sender);
-        this.needNegotiation();
+        if (this.transceiverManager.removeTrack(sender)) {
+            this.needNegotiation();
+        }
+    }
+    /**未交渉の変更が残っていれば negotiationneeded を予約する (stable 復帰時の再判定にも使う) */
+    scheduleNegotiationneeded() {
+        this.invalidateLastCreatedDescriptions();
+        this.shouldNegotiationneeded = true;
+        if (this.negotiationneeded ||
+            this.negotiationneededScheduled ||
+            this.signalingState !== "stable") {
+            return;
+        }
+        this.shouldNegotiationneeded = false;
+        this.negotiationneededScheduled = true;
+        setImmediate(() => {
+            this.negotiationneededScheduled = false;
+            if (this.negotiatedChangeSeq >= this.negotiationChangeSeq) {
+                // 発火前に適用された local offer が変更をすべて含んでいる
+                return;
+            }
+            if (this.signalingState !== "stable") {
+                // stable に戻った時点で改めて判定する
+                this.shouldNegotiationneeded = true;
+                return;
+            }
+            this.negotiationneeded = true;
+            this.onNegotiationneeded.execute();
+            if (this.onnegotiationneeded) {
+                this.onnegotiationneeded(new globalThis.Event("negotiationneeded"));
+            }
+            this.emit("negotiationneeded");
+        });
     }
     invalidateLastCreatedDescriptions() {
         this.lastCreatedAnswer = undefined;
@@ -569,7 +636,6 @@ class RTCPeerConnection extends helper_1.EventTarget {
     }
     findOrCreateTransport() {
         const existingDtlsTransport = this.dtlsTransports.find((transport) => transport.state !== "closed");
-        const existing = existingDtlsTransport?.iceTransport;
         // 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.sdpManager.bundlePolicy === "max-bundle" ||
@@ -578,7 +644,16 @@ class RTCPeerConnection extends helper_1.EventTarget {
                 return existingDtlsTransport;
             }
         }
-        const dtlsTransport = this.secureManager.createTransport();
+        return this.createDtlsTransport();
+    }
+    /**
+     * @param inheritCredentials false の場合は BUNDLE 外の独立 transport として
+     * 既存 transport と異なる ICE credentials を使う
+     */
+    createDtlsTransport({ inheritCredentials = true } = {}) {
+        const dtlsTransport = this.secureManager.createTransport({
+            inheritCredentials,
+        });
         dtlsTransport.onRtp.subscribe((rtp) => {
             this.router.routeRtp(rtp);
         });
@@ -607,21 +682,87 @@ class RTCPeerConnection extends helper_1.EventTarget {
                 log("localDescription not found when ice candidate was gathered");
                 return;
             }
+            const owner = this.resolveLocalCandidateOwner(iceTransport);
+            if (!owner) {
+                // 停止 / 拒否した m-line だけが使う transport の候補は通知しない
+                log("no accepted m-line owns the ice transport", iceTransport.id);
+                return;
+            }
             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,
+                sdpMid: owner.mid,
+                sdpMLineIndex: owner.index,
             });
         });
         return dtlsTransport;
     }
+    /**
+     * local candidate の sdpMid / sdpMLineIndex を、その ICE transport を実際に
+     * 所有する受け入れ済み m-line (BUNDLE なら tag) に合わせる。
+     */
+    resolveLocalCandidateOwner(iceTransport) {
+        const description = this._localDescription;
+        if (!description) {
+            return;
+        }
+        const owners = description.media
+            .map((media, index) => ({ media, index }))
+            .filter(({ media }) => {
+            if (media.port === 0) {
+                return false;
+            }
+            const mid = media.rtp.muxId;
+            if (media.kind === "application") {
+                return (!!this.sctpTransport &&
+                    this.sctpTransport.mid === mid &&
+                    this.sctpTransport.dtlsTransport?.iceTransport.id ===
+                        iceTransport.id);
+            }
+            const transceiver = this.transceiverManager
+                .getTransceivers()
+                .find((t) => t.mid != undefined && t.mid === mid);
+            return (!!transceiver &&
+                !transceiver.stopped &&
+                transceiver.dtlsTransport?.iceTransport.id === iceTransport.id);
+        });
+        const tags = description.group
+            .filter((group) => group.semantic === "BUNDLE")
+            .map((group) => group.items[0]);
+        const owner = owners.find(({ media }) => tags.includes(media.rtp.muxId)) ?? owners[0];
+        if (!owner) {
+            return;
+        }
+        return { mid: owner.media.rtp.muxId, index: owner.index };
+    }
+    /**
+     * answer 確定後の stopping transceiver を整理する。
+     * @returns port 0 を自分の offer で交渉すべき transceiver が残っているか
+     */
+    settleStoppingTransceivers() {
+        const negotiatedMids = new Set((this.sdpManager.currentLocalDescription?.media ?? [])
+            .filter((media) => media.port !== 0 && media.rtp.muxId)
+            .map((media) => media.rtp.muxId));
+        const pending = this.transceiverManager.settleStoppingTransceivers(negotiatedMids);
+        this.closeIdleTransports();
+        return pending;
+    }
+    /**停止した transceiver の transport のうち、live な利用者がいないものを閉じる */
+    closeIdleTransports(candidates = this.transceiverManager
+        .getTransceivers()
+        .filter((t) => t.stopped)
+        .map((t) => t.dtlsTransport)) {
+        const live = new Set(this.dtlsTransports.map((t) => t.id));
+        for (const transport of new Set(candidates)) {
+            if (!transport ||
+                transport.state === "closed" ||
+                live.has(transport.id)) {
+                continue;
+            }
+            transport.stop().catch((error) => {
+                log("failed to close idle transport", error);
+            });
+        }
+    }
     async setLocalDescription(sessionDescription) {
         // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/setLocalDescription#type
         const implicitOfferState = [
@@ -632,9 +773,13 @@ class RTCPeerConnection extends helper_1.EventTarget {
         await this.waitForPendingDescriptionTask();
         if (sessionDescription?.type === "rollback") {
             this.sdpManager.rollbackLocalDescription(this.signalingState);
+            for (const transceiver of this.transceiverManager.getTransceivers()) {
+                transceiver.pendingLocalOfferCodecs = undefined;
+            }
+            this.pendingOfferChangeSeq = undefined;
             this.setSignalingState("stable");
             if (this.shouldNegotiationneeded) {
-                this.needNegotiation();
+                this.scheduleNegotiationneeded();
             }
             this.invalidateLastCreatedDescriptions();
             return;
@@ -674,6 +819,11 @@ class RTCPeerConnection extends helper_1.EventTarget {
         });
         // # update signaling state
         if (description.type === "offer") {
+            // この offer は作成時点までの変更を含む。answer の適用で交渉済みにする
+            this.pendingOfferChangeSeq =
+                this.lastCreatedOffer?.sdp === sessionDescription.sdp
+                    ? this.lastCreatedOfferChangeSeq
+                    : undefined;
             this.setSignalingState("have-local-offer");
         }
         else if (description.type === "answer") {
@@ -682,14 +832,39 @@ class RTCPeerConnection extends helper_1.EventTarget {
         else if (description.type === "pranswer") {
             this.setSignalingState("have-local-pranswer");
         }
+        if (description.type === "answer") {
+            // answer の確定で拒否予定の m-line を停止し、RTP pipeline / 遊休 transport を解放する
+            this.transceiverManager.commitRemoteOffer();
+            // port 0 で答えた m-line (aggressive の inactive など) は offerer 側で拒否として停止が確定する。
+            // answerer 側も同じ位置を停止確定にし、offerer が新 MID で再利用できるようにする
+            for (const media of description.media) {
+                if (!["audio", "video"].includes(media.kind) || media.port !== 0) {
+                    continue;
+                }
+                const transceiver = this.transceiverManager
+                    .getTransceivers()
+                    .find((t) => t.mid === media.rtp.muxId && !t.stopped);
+                transceiver?.commitStopped({ rejected: true });
+            }
+            this.closeIdleTransports();
+        }
         // # assign MID
         for (const [i, media] of (0, helper_1.enumerate)(description.media)) {
             const mid = media.rtp.muxId;
             this.sdpManager.registerMid(mid);
-            if (["audio", "video"].includes(media.kind)) {
-                const transceiver = this.transceiverManager.getTransceiverByMLineIndex(i);
+            if (["audio", "video"].includes(media.kind) && media.port !== 0) {
+                // 停止済み、別 kind、別 MID の transceiver には割り当てない (MID の一意性を保つ)
+                const transceiver = this.transceiverManager
+                    .getTransceivers()
+                    .find((t) => t.mLineIndex === i &&
+                    !t.stopped &&
+                    t.kind === media.kind &&
+                    (t.mid == null || t.mid === mid));
                 if (transceiver) {
                     transceiver.mid = mid;
+                    if (description.type === "offer") {
+                        transceiver.pendingLocalOfferCodecs = [...media.rtp.codecs];
+                    }
                 }
             }
             if (media.kind === "application" && this.sctpTransport) {
@@ -699,14 +874,43 @@ class RTCPeerConnection extends helper_1.EventTarget {
         // setup ice,dtls role
         const role = description.media.find((media) => media.dtlsParams)?.dtlsParams
             ?.role;
+        // transport ごとに、その transport を使う受け入れ済み m-line の a=setup を適用する
+        // (BUNDLE group 外の独立 transport は先頭 m-line と異なる role を持ちうる)
+        const roleOfTransport = new Map();
+        for (const media of description.media) {
+            const mid = media.rtp.muxId;
+            const mediaRole = media.dtlsParams?.role;
+            if (media.port === 0 || mid == undefined || !mediaRole) {
+                continue;
+            }
+            const owner = media.kind === "application"
+                ? this.sctpTransport?.mid === mid
+                    ? this.sctpTransport
+                    : undefined
+                : this.transceiverManager
+                    .getTransceivers()
+                    .find((t) => t.mid === mid && !t.stopped);
+            if (owner?.dtlsTransport && !roleOfTransport.has(owner.dtlsTransport)) {
+                roleOfTransport.set(owner.dtlsTransport, mediaRole);
+            }
+        }
         this.secureManager.setLocalRole({
             type: description.type === "offer" ? "offer" : "answer",
             role,
+            roleOfTransport,
         });
         // # configure direction
         if (["answer", "pranswer"].includes(description.type)) {
-            for (const t of this.transceiverManager.getTransceivers()) {
-                const direction = (0, utils_1.andDirection)(t.direction, t.offerDirection);
+            for (const media of description.media) {
+                const t = this.transceiverManager
+                    .getTransceivers()
+                    .find((t) => t.mid != undefined && t.mid === media.rtp.muxId);
+                if (!t || t.stopped || t.pendingRejection) {
+                    continue;
+                }
+                const direction = t.stopping
+                    ? "inactive"
+                    : (0, utils_1.andDirection)(t.direction, t.offerDirection);
                 t.setCurrentDirection(direction);
             }
         }
@@ -723,14 +927,16 @@ class RTCPeerConnection extends helper_1.EventTarget {
             });
         }
         this.sdpManager.setLocal(description, this.transceiverManager.getTransceivers(), this.sctpTransport);
-        if (this.shouldNegotiationneeded) {
-            this.needNegotiation();
+        // answerer の stop() は次の自分の offer で交渉する
+        const hasUnnegotiatedStop = description.type === "answer" && this.settleStoppingTransceivers();
+        if (this.shouldNegotiationneeded || hasUnnegotiatedStop) {
+            this.scheduleNegotiationneeded();
         }
         this.invalidateLastCreatedDescriptions();
         return description;
     }
     async gatherCandidates() {
-        await this.secureManager.gatherCandidates(!!this.sdpManager.remoteIsBundled);
+        await this.secureManager.gatherCandidates();
     }
     async addIceCandidate(candidateMessage = {}) {
         if (this.isClosed) {
@@ -821,61 +1027,81 @@ class RTCPeerConnection extends helper_1.EventTarget {
             sessionDescription = sessionDescription.toSdp();
         }
         await this.waitForPendingDescriptionTask();
+        let codecPlan = new Map();
+        if (sessionDescription.type &&
+            sessionDescription.type !== "rollback" &&
+            sessionDescription.sdp) {
+            const preview = this.sdpManager.parseSdp({
+                sdp: sessionDescription.sdp,
+                isLocal: false,
+                signalingState: this.signalingState,
+                type: sessionDescription.type,
+            });
+            // 本適用と同じ対応付けで全 m-line の codec を副作用なしに解決する
+            const planned = new Set();
+            codecPlan = this.transceiverManager.planRemoteRtpCodecs(preview, (remoteMedia, index) => {
+                const transceiver = this.findTransceiverForRemoteMedia(remoteMedia, index, planned);
+                if (transceiver)
+                    planned.add(transceiver);
+                return transceiver;
+            });
+        }
         const needsImplicitLocalRollback = sessionDescription.type === "offer" &&
             ["have-local-offer", "have-local-pranswer"].includes(this.signalingState);
         if (needsImplicitLocalRollback) {
             this.sdpManager.rollbackLocalDescription(this.signalingState);
+            for (const transceiver of this.transceiverManager.getTransceivers()) {
+                transceiver.pendingLocalOfferCodecs = undefined;
+            }
+            this.pendingOfferChangeSeq = undefined;
             this.shouldNegotiationneeded = true;
             this.setSignalingState("stable");
             await Promise.resolve();
         }
         // # parse and validate description
+        this.assertAnswerKeepsSharedTransports(sessionDescription);
         const remoteSdp = this.sdpManager.setRemoteDescription(sessionDescription, this.signalingState);
         if (!remoteSdp) {
+            // 非対応 re-offer などの rollback では元の transceiver 対応を復元する
+            const transportsBeforeRollback = this.transceiverManager
+                .getTransceivers()
+                .map((t) => t.dtlsTransport);
+            this.transceiverManager.rollbackRemoteOffer();
+            this.closeIdleTransports(transportsBeforeRollback);
             this.setSignalingState("stable");
             if (this.shouldNegotiationneeded) {
-                this.needNegotiation();
+                this.scheduleNegotiationneeded();
             }
             this.invalidateLastCreatedDescriptions();
             return;
         }
-        let bundleTransport;
+        if (remoteSdp.type === "offer") {
+            this.transceiverManager.beginRemoteOffer();
+        }
         // # apply description
-        const matchTransceiverWithMedia = (transceiver, media) => transceiver.kind === media.kind &&
-            [null, media.rtp.muxId].includes(transceiver.mid);
-        let transports = remoteSdp.media.map((remoteMedia, i) => {
-            let dtlsTransport;
+        const bundleGroups = this.config.bundlePolicy === "disable"
+            ? []
+            : remoteSdp.group.filter((group) => group.semantic === "BUNDLE");
+        const groupOfMid = (mid) => mid == undefined
+            ? undefined
+            : bundleGroups.find((group) => group.items.includes(mid));
+        // ## associate m-lines with transceivers / sctp
+        const associated = new Set();
+        const entries = remoteSdp.media.map((remoteMedia, index) => {
             if (["audio", "video"].includes(remoteMedia.kind)) {
-                let transceiver = this.transceiverManager
-                    .getTransceivers()
-                    .find((t) => matchTransceiverWithMedia(t, remoteMedia));
+                let transceiver = this.findTransceiverForRemoteMedia(remoteMedia, index, associated);
                 if (!transceiver) {
-                    // create remote transceiver
-                    transceiver = this.addTransceiver(remoteMedia.kind, {
-                        direction: "recvonly",
-                    });
-                    transceiver.mid = remoteMedia.rtp.muxId ?? null;
-                    this.onRemoteTransceiverAdded.execute(transceiver);
-                }
-                else {
-                    if (transceiver.direction === "inactive" && transceiver.stopping) {
-                        transceiver.stopped = true;
-                        if (sessionDescription.type === "answer") {
-                            transceiver.setCurrentDirection("inactive");
-                        }
-                        return;
+                    if (remoteMedia.port === 0) {
+                        // 未知の MID の拒否済み m-line には transceiver を関連付けない
+                        return { remoteMedia, index };
                     }
+                    transceiver = this.addRemoteTransceiver(remoteMedia, index);
                 }
-                if (this.sdpManager.remoteIsBundled) {
-                    if (!bundleTransport) {
-                        bundleTransport = transceiver.dtlsTransport;
-                    }
-                    else {
-                        transceiver.setDtlsTransport(bundleTransport);
-                    }
+                else if (transceiver.mid == null) {
+                    this.transceiverManager.associateMLine(transceiver, index);
                 }
-                dtlsTransport = transceiver.dtlsTransport;
-                this.transceiverManager.setRemoteRTP(transceiver, remoteMedia, remoteSdp.type, i);
+                associated.add(transceiver);
+                return { remoteMedia, index, transceiver };
             }
             else if (remoteMedia.kind === "application") {
                 let sctpTransport = this.sctpTransport;
@@ -883,32 +1109,126 @@ class RTCPeerConnection extends helper_1.EventTarget {
                     sctpTransport = this.createSctpTransport();
                     sctpTransport.mid = remoteMedia.rtp.muxId;
                 }
-                if (this.sdpManager.remoteIsBundled) {
-                    if (!bundleTransport) {
-                        bundleTransport = sctpTransport.dtlsTransport;
-                    }
-                    else {
-                        sctpTransport.setDtlsTransport(bundleTransport);
-                    }
-                }
-                dtlsTransport = sctpTransport.dtlsTransport;
-                this.sctpManager.setRemoteSCTP(remoteMedia, i);
+                return { remoteMedia, index, sctpTransport };
             }
             else {
                 throw new Error("invalid media kind");
             }
-            const iceTransport = dtlsTransport.iceTransport;
-            if (remoteMedia.iceParams) {
-                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
-                if (remoteMedia.iceParams.iceLite && !iceTransport.connection.iceLite) {
-                    iceTransport.connection.iceControlling = true;
+        });
+        if (remoteSdp.type === "offer") {
+            this.transceiverManager.releaseUnassociatedReservations(associated, remoteSdp.media.length);
+        }
+        const ownerOf = (entry) => entry.transceiver ?? entry.sctpTransport;
+        // ## transport ownership
+        // remote offer の所有関係は bundlePolicy によらず offer の BUNDLE group だけで決まる
+        // (max-bundle は自分の offer にだけ効く)。group ごとに 1 つの transport を共有し、
+        // 異なる group や group 外の m-line とは共有しない。
+        // remote answer では offer で渡した ICE credentials を保つため transport を作り直さない
+        // (共有 transport を分割する answer は assertAnswerKeepsSharedTransports で事前に拒否済み)
+        const isRemoteOffer = remoteSdp.type === "offer";
+        const liveTransport = (transport) => !!transport && transport.state !== "closed";
+        const groupTransports = new Map();
+        const claimed = new Set();
+        for (const group of bundleGroups) {
+            const members = entries.filter((entry) => !!ownerOf(entry) &&
+                group.items.includes(entry.remoteMedia.rtp.muxId));
+            if (members.length === 0) {
+                continue;
+            }
+            // 既存 member の transport を優先し、他の group が使っていれば新しい transport を作る
+            let shared = members
+                .map((entry) => ownerOf(entry).dtlsTransport)
+                .find((transport) => liveTransport(transport) &&
+                (!isRemoteOffer || !claimed.has(transport)));
+            if (!shared) {
+                shared = this.createDtlsTransport({ inheritCredentials: false });
+            }
+            groupTransports.set(group, shared);
+            claimed.add(shared);
+            for (const entry of members) {
+                const owner = ownerOf(entry);
+                if (owner.dtlsTransport !== shared) {
+                    owner.setDtlsTransport(shared);
+                }
+            }
+        }
+        if (isRemoteOffer) {
+            // group 外 (group のない offer を含む) で受け入れた m-line は独立した transport / ICE credentials を持つ
+            for (const entry of entries) {
+                const owner = ownerOf(entry);
+                if (!owner ||
+                    entry.remoteMedia.port === 0 ||
+                    groupOfMid(entry.remoteMedia.rtp.muxId)) {
+                    continue;
+                }
+                if (!liveTransport(owner.dtlsTransport) ||
+                    claimed.has(owner.dtlsTransport)) {
+                    owner.setDtlsTransport(this.createDtlsTransport({ inheritCredentials: false }));
+                }
+                claimed.add(owner.dtlsTransport);
+            }
+        }
+        // ## apply RTP / SCTP (受け入れ判定)
+        const acceptedEntries = new Set();
+        for (const entry of entries) {
+            const { remoteMedia, index } = entry;
+            if (entry.transceiver) {
+                if (this.transceiverManager.setRemoteRTP(entry.transceiver, remoteMedia, remoteSdp.type, index, codecPlan.get(index) ?? [])) {
+                    acceptedEntries.add(entry);
+                }
+            }
+            else if (entry.sctpTransport) {
+                this.sctpManager.setRemoteSCTP(remoteMedia, index);
+                acceptedEntries.add(entry);
+            }
+        }
+        // ICE / DTLS パラメータは group で最初に受け入れた member (tag) から適用する
+        // (codec 不一致で拒否した member のパラメータは使わない)
+        const groupParamSources = new Map();
+        for (const group of bundleGroups) {
+            for (const mid of group.items) {
+                const entry = entries.find((e) => e.remoteMedia.rtp.muxId === mid &&
+                    e.remoteMedia.port !== 0 &&
+                    acceptedEntries.has(e));
+                if (entry) {
+                    groupParamSources.set(group, entry);
+                    break;
                 }
             }
-            if (remoteMedia.dtlsParams) {
-                dtlsTransport.setRemoteParams(remoteMedia.dtlsParams);
+        }
+        // ## apply transport parameters
+        for (const entry of entries) {
+            const { remoteMedia } = entry;
+            const owner = ownerOf(entry);
+            if (!owner) {
+                continue;
+            }
+            const accepted = acceptedEntries.has(entry);
+            const dtlsTransport = owner.dtlsTransport;
+            const group = groupOfMid(remoteMedia.rtp.muxId);
+            if (remoteMedia.port === 0 ||
+                !dtlsTransport ||
+                dtlsTransport.state === "closed" ||
+                // group 外の拒否 section の transport は使わない
+                (!accepted && !group)) {
+                continue;
+            }
+            const iceTransport = dtlsTransport.iceTransport;
+            const ownsTransportParams = !group || groupParamSources.get(group) === entry;
+            if (ownsTransportParams) {
+                if (remoteMedia.iceParams) {
+                    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
+                    if (remoteMedia.iceParams.iceLite &&
+                        !iceTransport.connection.iceLite) {
+                        iceTransport.connection.iceControlling = true;
+                    }
+                }
+                if (remoteMedia.dtlsParams) {
+                    dtlsTransport.setRemoteParams(remoteMedia.dtlsParams);
+                }
             }
             // # add ICE candidates
             remoteMedia.iceCandidates.forEach(iceTransport.addRemoteCandidate);
@@ -920,21 +1240,17 @@ class RTCPeerConnection extends helper_1.EventTarget {
                 dtlsTransport.role =
                     remoteMedia.dtlsParams.role === "client" ? "server" : "client";
             }
-            return iceTransport;
-        });
-        // filter out inactive transports
-        transports = transports.filter((iceTransport) => !!iceTransport);
-        const removedTransceivers = this.transceiverManager
-            .getTransceivers()
-            .filter((t) => remoteSdp.media.find((m) => matchTransceiverWithMedia(t, m)) ==
-            undefined);
-        if (sessionDescription.type === "answer") {
-            for (const transceiver of removedTransceivers) {
-                // todo: handle answer side transceiver removal work.
-                // event should trigger to notify media source to stop.
-                transceiver.stop();
-                transceiver.stopped = true;
+        }
+        if (remoteSdp.type === "answer") {
+            // answer に含まれない既存 m-line は remote 起因の停止として確定する
+            for (const transceiver of this.transceiverManager.getTransceivers()) {
+                if (!associated.has(transceiver) &&
+                    transceiver.mid != undefined &&
+                    !transceiver.stopped) {
+                    transceiver.commitStopped({ rejected: true });
+                }
             }
+            this.closeIdleTransports();
         }
         if (remoteSdp.type === "offer") {
             this.setSignalingState("have-remote-offer");
@@ -955,11 +1271,96 @@ class RTCPeerConnection extends helper_1.EventTarget {
             });
         }
         this.negotiationneeded = false;
-        if (this.shouldNegotiationneeded) {
-            this.needNegotiation();
+        if (remoteSdp.type === "answer" &&
+            this.pendingOfferChangeSeq != undefined) {
+            this.negotiatedChangeSeq = Math.max(this.negotiatedChangeSeq, this.pendingOfferChangeSeq);
+            this.pendingOfferChangeSeq = undefined;
+        }
+        const hasUnnegotiatedStop = remoteSdp.type === "answer" && this.settleStoppingTransceivers();
+        if (this.shouldNegotiationneeded || hasUnnegotiatedStop) {
+            this.scheduleNegotiationneeded();
         }
         this.invalidateLastCreatedDescriptions();
     }
+    /**
+     * remote answer / pranswer の検証 (offerer 側、状態を変更する前に実行する)。
+     * local offer で 1 つの transport を共有した m-line を、answer が同じ BUNDLE group に置かずに
+     * 異なる ICE credentials で受け入れることはできない (RFC 8843 7.3.2)。共有 transport は分割できず、
+     * 新しい transport を作ると offer で渡した ICE credentials とも一致しなくなる。
+     * group の記述が MID と一致しなくても remote の ICE credentials が同じなら、同じ transport のまま扱う。
+     */
+    assertAnswerKeepsSharedTransports(sessionDescription) {
+        if (!["answer", "pranswer"].includes(sessionDescription.type ?? "") ||
+            !["have-local-offer", "have-local-pranswer"].includes(this.signalingState) ||
+            !sessionDescription.sdp ||
+            this.config.bundlePolicy === "disable") {
+            return;
+        }
+        const answer = sdp_1.SessionDescription.parse(sessionDescription.sdp);
+        const answerGroups = answer.group.filter((g) => g.semantic === "BUNDLE");
+        const byTransport = new Map();
+        for (const media of answer.media) {
+            const mid = media.rtp.muxId;
+            if (media.port === 0 || mid == undefined) {
+                continue;
+            }
+            const owner = media.kind === "application"
+                ? this.sctpTransport?.mid === mid
+                    ? this.sctpTransport
+                    : undefined
+                : this.transceiverManager
+                    .getTransceivers()
+                    .find((t) => t.mid === mid && !t.stopped);
+            const transport = owner?.dtlsTransport;
+            if (!transport) {
+                continue;
+            }
+            const current = {
+                group: answerGroups.find((g) => g.items.includes(mid)),
+                credentials: `${media.iceParams?.usernameFragment}:${media.iceParams?.password}`,
+            };
+            const first = byTransport.get(transport);
+            if (!first) {
+                byTransport.set(transport, current);
+                continue;
+            }
+            const sameGroup = !!current.group && current.group === first.group;
+            if (!sameGroup && current.credentials !== first.credentials) {
+                throw (0, errors_1.createWebRtcDomException)("InvalidAccessError", `mid=${mid} shares a transport in the local offer but the remote ${sessionDescription.type} moves it out of that BUNDLE group`);
+            }
+        }
+    }
+    /**
+     * remote m-line に対応する transceiver を探す。MID の一致を優先し、
+     * 未関連付け transceiver は同じ offer 内で異なる m-line に割り当てる。
+     */
+    findTransceiverForRemoteMedia(remoteMedia, index, associated) {
+        const candidates = this.transceiverManager
+            .getTransceivers()
+            .filter((t) => !associated.has(t) && t.kind === remoteMedia.kind);
+        const mid = remoteMedia.rtp.muxId;
+        const byMid = mid != undefined ? candidates.find((t) => t.mid === mid) : undefined;
+        if (byMid) {
+            return byMid;
+        }
+        if (remoteMedia.port === 0) {
+            return;
+        }
+        const unassociated = candidates.filter((t) => t.mid == null && !t.stopping && !t.stopped);
+        return unassociated.find((t) => t.mLineIndex === index) ?? unassociated[0];
+    }
+    /**
+     * remote offer / answer の m-line 用に transceiver を作る。
+     * 同じ位置に停止済みの旧 transceiver があれば、それを復活させず新しい receiver/router で置き換える。
+     */
+    addRemoteTransceiver(remoteMedia, index) {
+        const dtlsTransport = this.findOrCreateTransport();
+        const transceiver = this.transceiverManager.addTransceiver(remoteMedia.kind, dtlsTransport, { direction: "recvonly" }, { remoteMLineIndex: index });
+        transceiver.mid = remoteMedia.rtp.muxId ?? null;
+        this.secureManager.updateIceConnectionState();
+        this.onRemoteTransceiverAdded.execute(transceiver);
+        return transceiver;
+    }
     addTransceiver(trackOrKind, options = {}) {
         const dtlsTransport = this.findOrCreateTransport();
         const transceiver = this.transceiverManager.addTransceiver(trackOrKind, dtlsTransport, options);
@@ -983,6 +1384,38 @@ class RTCPeerConnection extends helper_1.EventTarget {
     async createAnswer() {
         this.assertNotClosed();
         await this.secureManager.ensureCerts();
+        // setCodecPreferences() で無効化された transceiver を再解決する。
+        // offer 側と異なり answer は remote offer との交渉結果を使い、
+        // sender/receiver の codec 状態も新しい negotiated codec に同期する。
+        for (const transceiver of this.transceiverManager.getTransceivers()) {
+            if (transceiver.codecs.length !== 0 &&
+                !transceiver.codecPreferencesNeedResolution) {
+                continue;
+            }
+            // 拒否予定 / 停止済みの m-line は port 0 で answer するため codec を解決しない
+            if (transceiver.pendingRejection ||
+                transceiver.stopping ||
+                transceiver.stopped) {
+                continue;
+            }
+            const remoteDescription = this.sdpManager._remoteDescription;
+            const remoteMedia = remoteDescription?.media.find((media) => media.rtp.muxId != undefined &&
+                media.rtp.muxId === transceiver.mid &&
+                media.kind === transceiver.kind) ??
+                (transceiver.mLineIndex != undefined
+                    ? remoteDescription?.media[transceiver.mLineIndex]
+                    : undefined);
+            if (remoteMedia && ["audio", "video"].includes(remoteMedia.kind)) {
+                this.transceiverManager.resyncAnswerCodecs(transceiver, remoteMedia);
+            }
+            else {
+                this.transceiverManager.assignTransceiverCodecs(transceiver);
+            }
+            if (transceiver.headerExtensions.length === 0) {
+                transceiver.headerExtensions =
+                    this.config.headerExtensions[transceiver.kind] ?? [];
+            }
+        }
         const description = this.sdpManager.buildAnswerSdp({
             transceivers: this.transceiverManager.getTransceivers(),
             sctpTransport: this.sctpTransport,
@@ -1045,29 +1478,68 @@ class RTCPeerConnection extends helper_1.EventTarget {
         this.pendingRemoteCandidates.length = 0;
         this.setSignalingState("closed");
         this.transceiverManager.close();
-        await this.secureManager.close();
+        // SCTP ABORT は DTLS/ICE が生きている間に送る（close は abrupt であり SHUTDOWN ではない）
         await this.sctpManager.close();
-        this.onDataChannel.allUnsubscribe();
-        this.iceGatheringStateChange.allUnsubscribe();
-        this.iceConnectionStateChange.allUnsubscribe();
-        this.signalingStateChange.allUnsubscribe();
-        this.onTransceiverAdded.allUnsubscribe();
-        this.onRemoteTransceiverAdded.allUnsubscribe();
-        this.onIceCandidate.allUnsubscribe();
+        await this.secureManager.close();
+        // 公開 Event を完了させ、購読者・クロージャが PeerConnection を保持し続けないようにする
+        this.completePeerEvents();
         log("peerConnection closed");
     }
+    completePeerEvents() {
+        const events = [
+            this.onDataChannel,
+            this.iceGatheringStateChange,
+            this.iceConnectionStateChange,
+            this.signalingStateChange,
+            this.connectionStateChange,
+            this.onTransceiverAdded,
+            this.onRemoteTransceiverAdded,
+            this.onIceCandidate,
+            this.onNegotiationneeded,
+        ];
+        for (const event of events) {
+            if (!event.ended) {
+                event.complete();
+            }
+        }
+    }
 }
 exports.RTCPeerConnection = RTCPeerConnection;
+const MLineReuseModes = ["compatible", "aggressive"];
 const findCodecByMimeType = (codecs, target) => codecs.find((localCodec) => localCodec.mimeType.toLowerCase() === target.mimeType.toLowerCase())
     ? target
     : undefined;
 exports.findCodecByMimeType = findCodecByMimeType;
+function assignDynamicPayloadTypes(config) {
+    for (const [i, codecParams] of (0, helper_1.enumerate)([
+        ...(config.codecs.audio || []),
+        ...(config.codecs.video || []),
+    ])) {
+        if (codecParams.payloadType != undefined) {
+            continue;
+        }
+        codecParams.payloadType = 96 + i;
+        switch (codecParams.name.toLowerCase()) {
+            case "rtx":
+                {
+                    codecParams.parameters = `apt=${codecParams.payloadType - 1}`;
+                }
+                break;
+            case "red":
+                {
+                    if (codecParams.contentType === "audio") {
+                        const redundant = codecParams.payloadType + 1;
+                        codecParams.parameters = `${redundant}/${redundant}`;
+                        codecParams.payloadType = 63;
+                    }
+                }
+                break;
+        }
+    }
+}
 function generateDefaultPeerConfig() {
     return {
-        codecs: {
-            audio: [(0, media_1.useOPUS)(), (0, media_1.usePCMU)()],
-            video: [(0, media_1.useVP8)()],
-        },
+        codecs: (0, media_1.defaultCodecs)(),
         headerExtensions: {
             audio: [],
             video: [],
@@ -1081,8 +1553,12 @@ function generateDefaultPeerConfig() {
         iceUseIpv4: true,
         iceUseIpv6: true,
         iceUseTcp: false,
+        iceTcpPassive: true,
+        iceStunGatherTimeout: undefined,
+        iceTurnConnectTimeout: undefined,
         turnTransport: undefined,
         turnTlsOptions: undefined,
+        turnUdpFamily: undefined,
         iceFilterStunResponse: undefined,
         iceFilterCandidatePair: undefined,
         icePasswordPrefix: undefined,
@@ -1096,12 +1572,18 @@ function generateDefaultPeerConfig() {
         midSuffix: false,
         forceTurnTCP: false,
         maxMessageSize: sctp_1.DEFAULT_MAX_MESSAGE_SIZE,
+        sctp: { mtu: src_1.DEFAULT_SCTP_MTU },
+        pendingRtp: false,
+        mLineReuse: "compatible",
     };
 }
 exports.defaultPeerConfig = generateDefaultPeerConfig();
 function normalizePeerConfiguration(config) {
     const input = Object(config ?? {});
     const normalizedConfig = { ...input };
+    if (input.sctp !== undefined) {
+        normalizedConfig.sctp = { ...input.sctp };
+    }
     if (input.bundlePolicy === "balanced") {
         normalizedConfig.bundlePolicy = "max-compat";
     }
@@ -1164,6 +1646,10 @@ function clonePeerConfiguration(config) {
         dtls: { ...config.dtls },
         certificates: [...config.certificates],
         debug: { ...config.debug },
+        sctp: { ...config.sctp },
+        pendingRtp: typeof config.pendingRtp === "object" && config.pendingRtp != undefined
+            ? { ...config.pendingRtp }
+            : config.pendingRtp,
     };
 }
 class RTCTrackEvent {