@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/peer/peerConnection.js

@@ -0,0 +1,1585 @@
+import { randomUUID } from 'node:crypto';
+import { DEFAULT_SCTP_MTU, validateSctpMtu } from '../sctp/index.js';
+import { createWebRtcDomException, createWebRtcTypeError } from './errors.js';
+import { EventTarget, enumerate } from './helper.js';
+import { Event, debug, runDetached } from './imports/common.js';
+import { RTCRtpHeaderExtensionParameters, RtpRouter, TransceiverManager, defaultCodecs } from './media/index.js';
+import { buildStatsReport, generateStatsId, getStatsTimestamp } from './media/stats.js';
+import { SctpTransportManager } from './sctpManager.js';
+import { SessionDescription } from './sdp.js';
+import { SDPManager } from './sdpManager.js';
+import { SecureTransportManager } from './secureTransportManager.js';
+import { DEFAULT_MAX_MESSAGE_SIZE } from './transport/sctp.js';
+import { andDirection, deepMerge } from './utils.js';
+const log = debug('webrtc/peer/peerConnection');
+/**
+ * W3C compatibility notes kept near the public RTCPeerConnection surface so the
+ * reviewable diff does not depend on external PR text.
+ *
+ * - `current/pending*Description`, `canTrickleIceCandidates`, `sctp`,
+ *   `addIceCandidate(null)`, and `RTCConfiguration` round-trip behavior are
+ *   implemented here and covered by `tests/wpt/peerConnectionApiCompatibility.test.ts`.
+ * - `addIceCandidate()` also validates `sdpMid` / `sdpMLineIndex` /
+ *   `usernameFragment` against the applied remote description and appends
+ *   candidates or end-of-candidates markers to the corresponding m-section.
+ *   The public API keeps werift's historical pre-SRD buffering behavior, while
+ *   the WPT runner wraps the class to exercise strict spec rejection.
+ * - `bundlePolicy: "balanced"` is accepted for input compatibility but is
+ *   normalized to werift's `"max-compat"` behavior, so `getConfiguration()`
+ *   returns the normalized value.
+ * - `setLocalDescription()` keeps the historical `SessionDescription` return
+ *   value for non-rollback calls, while `{ type: "rollback" }` resolves `void`
+ *   to match the actual behavior without pretending to return a description.
+ * - API reference markdown is regenerated with `cd packages/webrtc && npm run doc`.
+ *   The generated output lives under `packages/webrtc/doc/`; compatibility
+ *   notes remain here and in the package README so review context is visible
+ *   even when generated docs are not committed in the same change.
+ */
+export class RTCPeerConnection extends EventTarget {
+    get ondatachannel() {
+        return this.eventHandlers.ondatachannel ?? null;
+    }
+    set ondatachannel(value) {
+        this.eventHandlers.ondatachannel = value ?? undefined;
+    }
+    get onicecandidate() {
+        return this.eventHandlers.onicecandidate ?? null;
+    }
+    set onicecandidate(value) {
+        this.eventHandlers.onicecandidate = value ?? undefined;
+    }
+    get onicecandidateerror() {
+        return this.eventHandlers.onicecandidateerror ?? null;
+    }
+    set onicecandidateerror(value) {
+        this.eventHandlers.onicecandidateerror = value ?? undefined;
+    }
+    get onicegatheringstatechange() {
+        return this.eventHandlers.onicegatheringstatechange ?? null;
+    }
+    set onicegatheringstatechange(value) {
+        this.eventHandlers.onicegatheringstatechange = value ?? undefined;
+    }
+    get onnegotiationneeded() {
+        return this.eventHandlers.onnegotiationneeded ?? null;
+    }
+    set onnegotiationneeded(value) {
+        this.eventHandlers.onnegotiationneeded = value ?? undefined;
+    }
+    get onsignalingstatechange() {
+        return this.eventHandlers.onsignalingstatechange ?? null;
+    }
+    set onsignalingstatechange(value) {
+        this.eventHandlers.onsignalingstatechange = value ?? undefined;
+    }
+    get ontrack() {
+        return this.eventHandlers.ontrack ?? null;
+    }
+    set ontrack(value) {
+        this.eventHandlers.ontrack = value ?? undefined;
+    }
+    get onconnectionstatechange() {
+        return this.eventHandlers.onconnectionstatechange ?? null;
+    }
+    set onconnectionstatechange(value) {
+        this.eventHandlers.onconnectionstatechange = value ?? undefined;
+    }
+    get oniceconnectionstatechange() {
+        return this.eventHandlers.oniceconnectionstatechange ?? null;
+    }
+    set oniceconnectionstatechange(value) {
+        this.eventHandlers.oniceconnectionstatechange = value ?? undefined;
+    }
+    constructor(config = {}) {
+        super();
+        this.id = randomUUID().toString();
+        this.cname = randomUUID().toString();
+        this.config = generateDefaultPeerConfig();
+        this.signalingState = 'stable';
+        this.negotiationneeded = false;
+        /**同じ tick の複数の変更で negotiationneeded を重複発火しないための予約フラグ */
+        this.negotiationneededScheduled = false;
+        /**交渉が必要な変更の通し番号 */
+        this.negotiationChangeSeq = 0;
+        /**answer まで確定した local offer が反映している変更の通し番号 */
+        this.negotiatedChangeSeq = 0;
+        this.lastCreatedOfferChangeSeq = 0;
+        this.needRestart = false;
+        this.router = new RtpRouter();
+        this.isClosed = false;
+        this.shouldNegotiationneeded = false;
+        this.pendingRemoteCandidates = [];
+        this.iceGatheringStateChange = new Event();
+        this.iceConnectionStateChange = new Event();
+        this.signalingStateChange = new Event();
+        this.connectionStateChange = new Event();
+        this.onDataChannel = new Event();
+        this.onRemoteTransceiverAdded = new Event();
+        this.onTransceiverAdded = new Event();
+        this.onIceCandidate = new Event();
+        this.onNegotiationneeded = new Event();
+        this.onTrack = new Event();
+        this.eventHandlers = {};
+        /**交渉が必要な変更を記録し、negotiationneeded を予約する */
+        this.needNegotiation = () => {
+            this.negotiationChangeSeq++;
+            this.scheduleNegotiationneeded();
+        };
+        this.setConfiguration(config);
+        this.sdpManager = new SDPManager({
+            cname: this.cname,
+            bundlePolicy: this.config.bundlePolicy,
+            mLineReuse: this.config.mLineReuse
+        });
+        this.transceiverManager = new TransceiverManager(this.cname, this.config, this.router);
+        this.transceiverManager.onTransceiverAdded.pipe(this.onTransceiverAdded);
+        this.transceiverManager.onRemoteTransceiverAdded.pipe(this.onRemoteTransceiverAdded);
+        this.transceiverManager.onTrack.subscribe(({ track, streams, transceiver }) => {
+            const event = new RTCTrackEvent({
+                track,
+                streams,
+                transceiver,
+                receiver: transceiver.receiver
+            });
+            this.onTrack.execute(track);
+            this.emit('track', event);
+            if (this.ontrack) {
+                runDetached(() => this.ontrack(event), (error) => log('event handler failed', error));
+            }
+        });
+        this.transceiverManager.onNegotiationNeeded.subscribe(() => this.needNegotiation());
+        this.sctpManager = new SctpTransportManager();
+        this.sctpManager.onDataChannel.subscribe((channel) => {
+            this.onDataChannel.execute(channel);
+            const event = { type: 'datachannel', channel };
+            if (this.ondatachannel)
+                runDetached(() => this.ondatachannel(event), (error) => log('event handler failed', error));
+            this.emit('datachannel', event);
+        });
+        this.secureManager = new SecureTransportManager({
+            config: this.config,
+            sctpManager: this.sctpManager,
+            transceiverManager: this.transceiverManager
+        });
+        this.secureManager.iceGatheringStateChange.subscribe((state) => {
+            this.iceGatheringStateChange.execute(state);
+            if (this.onicegatheringstatechange) {
+                runDetached(() => this.onicegatheringstatechange(new globalThis.Event('icegatheringstatechange')), (error) => log('event handler failed', error));
+            }
+            this.emit('icegatheringstatechange');
+        });
+        this.secureManager.iceConnectionStateChange.subscribe((state) => {
+            if (state === 'closed') {
+                this.close().catch((error) => log('close failed', error));
+            }
+            this.iceConnectionStateChange.execute(state);
+            if (this.oniceconnectionstatechange)
+                runDetached(() => this.oniceconnectionstatechange(), (error) => log('event handler failed', error));
+            this.emit('iceconnectionstatechange');
+        });
+        this.secureManager.connectionStateChange.subscribe((state) => {
+            this.connectionStateChange.execute(state);
+            if (this.onconnectionstatechange)
+                runDetached(() => this.onconnectionstatechange(), (error) => log('event handler failed', error));
+            this.emit('connectionstatechange');
+        });
+        this.secureManager.onIceCandidate.subscribe((candidate) => {
+            const iceCandidate = candidate ? candidate.toJSON() : undefined;
+            this.onIceCandidate.execute(iceCandidate);
+            const event = {
+                type: 'icecandidate',
+                candidate: iceCandidate
+            };
+            if (this.onicecandidate)
+                runDetached(() => this.onicecandidate(event), (error) => log('event handler failed', error));
+            this.emit('icecandidate', event);
+        });
+    }
+    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 sctp() {
+        return this.sctpTransport ?? null;
+    }
+    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 ?? null;
+    }
+    get currentLocalDescription() {
+        return this.sdpManager.currentLocalDescription?.toJSON() ?? null;
+    }
+    get pendingLocalDescription() {
+        return this.sdpManager.pendingLocalDescription?.toJSON() ?? null;
+    }
+    get remoteDescription() {
+        return this.sdpManager.remoteDescription ?? null;
+    }
+    get currentRemoteDescription() {
+        return this.sdpManager.currentRemoteDescription?.toJSON() ?? null;
+    }
+    get pendingRemoteDescription() {
+        return this.sdpManager.pendingRemoteDescription?.toJSON() ?? null;
+    }
+    get canTrickleIceCandidates() {
+        const remoteDescription = this.sdpManager._remoteDescription;
+        if (!remoteDescription) {
+            return null;
+        }
+        const iceOptions = [
+            remoteDescription.iceOptions,
+            ...remoteDescription.media.map((media) => media.iceOptions)
+        ]
+            .filter((value) => !!value)
+            .join(' ');
+        return iceOptions.split(/\s+/).includes('trickle');
+    }
+    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) {
+        const normalizedConfig = normalizePeerConfiguration(config);
+        const isReconfiguration = !!this.sdpManager;
+        if (normalizedConfig.rtcpMuxPolicy &&
+            normalizedConfig.rtcpMuxPolicy !== 'require') {
+            throw new Error('rtcpMuxPolicy must be require');
+        }
+        if (normalizedConfig.iceCandidatePoolSize !== undefined &&
+            (!Number.isInteger(normalizedConfig.iceCandidatePoolSize) ||
+                normalizedConfig.iceCandidatePoolSize < 0)) {
+            throw new Error('iceCandidatePoolSize must be a non-negative integer');
+        }
+        if (isReconfiguration &&
+            normalizedConfig.bundlePolicy !== undefined &&
+            normalizedConfig.bundlePolicy !== this.config.bundlePolicy) {
+            throw new Error('bundlePolicy cannot be changed');
+        }
+        if (normalizedConfig.mLineReuse !== undefined &&
+            !MLineReuseModes.includes(normalizedConfig.mLineReuse)) {
+            throw createWebRtcTypeError(`mLineReuse must be one of ${MLineReuseModes.join(', ')}`);
+        }
+        if (isReconfiguration &&
+            normalizedConfig.mLineReuse !== undefined &&
+            normalizedConfig.mLineReuse !== this.config.mLineReuse) {
+            throw createWebRtcDomException('InvalidModificationError', 'mLineReuse cannot be changed');
+        }
+        if (isReconfiguration &&
+            normalizedConfig.rtcpMuxPolicy !== undefined &&
+            normalizedConfig.rtcpMuxPolicy !== this.config.rtcpMuxPolicy) {
+            throw new Error('rtcpMuxPolicy cannot be changed');
+        }
+        if (isReconfiguration &&
+            normalizedConfig.certificates !== undefined &&
+            !hasSameCertificates(normalizedConfig.certificates, this.config.certificates)) {
+            throw new Error('certificates cannot be changed');
+        }
+        if (isReconfiguration &&
+            normalizedConfig.iceCandidatePoolSize !== undefined &&
+            this.localDescription &&
+            normalizedConfig.iceCandidatePoolSize !== this.config.iceCandidatePoolSize) {
+            throw new Error('iceCandidatePoolSize cannot be changed after setLocalDescription');
+        }
+        if ((normalizedConfig.iceCandidatePoolSize ?? 0) > 0) {
+            throw new Error('iceCandidatePoolSize > 0 is not supported');
+        }
+        if (normalizedConfig.sctp !== undefined) {
+            const requestedSctpMtu = normalizedConfig.sctp.mtu ?? DEFAULT_SCTP_MTU;
+            validateSctpMtu(requestedSctpMtu);
+            if (this.sctpManager?.sctpTransport &&
+                requestedSctpMtu !== this.config.sctp.mtu) {
+                throw new Error('sctp.mtu cannot be changed after SCTP transport creation');
+            }
+        }
+        deepMerge(this.config, normalizedConfig);
+        this.config.sctp = {
+            mtu: this.config.sctp?.mtu ?? DEFAULT_SCTP_MTU
+        };
+        if (this.config.icePortRange) {
+            const [min, max] = this.config.icePortRange;
+            if (min === max)
+                throw new Error('should not be same value');
+            if (min >= max)
+                throw new Error('The min must be less than max');
+        }
+        if (!Number.isInteger(this.config.maxMessageSize) ||
+            this.config.maxMessageSize < 0) {
+            throw new Error('maxMessageSize must be a non-negative integer');
+        }
+        if (this.sctpManager?.sctpTransport) {
+            this.sctpManager.sctpTransport.maxMessageSize =
+                this.config.maxMessageSize;
+        }
+        assignDynamicPayloadTypes(this.config);
+        //One id per extension, the same in all the media (of a bundle)
+        const extensionIds = new Map();
+        const extensions = [
+            ...(this.config.headerExtensions.audio || []),
+            ...(this.config.headerExtensions.video || [])
+        ];
+        extensions.forEach((v) => {
+            if (!extensionIds.has(v.uri))
+                extensionIds.set(v.uri, extensionIds.size + 1);
+            v.id = extensionIds.get(v.uri);
+        });
+        // 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);
+    }
+    /**
+     * The header extensions of a media not negotiated yet: the ones configured, with the ids the connection negotiated
+     * for them in its other media (an extension has one id in all the media of a bundle: a browser refuses another one),
+     * else their configured ids when not taken by another extension, else free ones
+     */
+    headerExtensionsFor(kind) {
+        const negotiated = new Map();
+        for (const transceiver of this.transceiverManager.getTransceivers()) {
+            for (const extension of transceiver.headerExtensions)
+                negotiated.set(extension.uri, extension.id);
+        }
+        const taken = new Set(negotiated.values());
+        return (this.config.headerExtensions[kind] ?? []).flatMap((extension) => {
+            let id = negotiated.get(extension.uri);
+            if (id === undefined) {
+                id = taken.has(extension.id)
+                    ? Array.from({ length: 14 }, (_, index) => index + 1).find((free) => !taken.has(free))
+                    : extension.id;
+                if (id === undefined)
+                    return [];
+                taken.add(id);
+                negotiated.set(extension.uri, id);
+            }
+            return [new RTCRtpHeaderExtensionParameters({ uri: extension.uri, id })];
+        });
+    }
+    async createOffer({ iceRestart } = {}) {
+        if (iceRestart || this.needRestart) {
+            this.needRestart = false;
+            this.secureManager.restartIce();
+        }
+        await this.secureManager.ensureCerts();
+        for (const transceiver of this.transceiverManager.getTransceivers()) {
+            if (transceiver.codecs.length === 0 ||
+                transceiver.codecPreferencesNeedResolution) {
+                this.transceiverManager.assignTransceiverCodecs(transceiver);
+            }
+            if (transceiver.headerExtensions.length === 0) {
+                transceiver.headerExtensions = this.headerExtensionsFor(transceiver.kind);
+            }
+        }
+        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, this.config.sctp);
+        const dtlsTransport = this.findOrCreateTransport();
+        sctp.setDtlsTransport(dtlsTransport);
+        return sctp;
+    }
+    createDataChannel(label, options = {}) {
+        if (!this.sctpTransport) {
+            this.createSctpTransport();
+            this.needNegotiation();
+        }
+        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) {
+            throw createWebRtcDomException('InvalidStateError', 'peer closed');
+        }
+        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) {
+                runDetached(() => this.onnegotiationneeded(new globalThis.Event('negotiationneeded')), (error) => log('event handler failed', error));
+            }
+            this.emit('negotiationneeded');
+        });
+    }
+    invalidateLastCreatedDescriptions() {
+        this.lastCreatedAnswer = undefined;
+        this.lastCreatedOffer = undefined;
+    }
+    async waitForPendingDescriptionTask() {
+        this.assertNotClosed();
+        await Promise.resolve();
+        if (this.isClosed) {
+            await new Promise(() => undefined);
+        }
+    }
+    findOrCreateTransport() {
+        const existingDtlsTransport = this.dtlsTransports.find((transport) => transport.state !== 'closed');
+        // 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' ||
+            (this.sdpManager.bundlePolicy !== 'disable' && this.remoteIsBundled)) {
+            if (existingDtlsTransport) {
+                return existingDtlsTransport;
+            }
+        }
+        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);
+        });
+        dtlsTransport.onRtcp.subscribe((rtcp) => {
+            this.router.routeRtcp(rtcp);
+        });
+        const iceTransport = dtlsTransport.iceTransport;
+        iceTransport.onNegotiationNeeded.subscribe(() => {
+            this.needNegotiation();
+        });
+        iceTransport.onIceCandidate.subscribe((candidate) => {
+            if (!this.localDescription) {
+                log('localDescription not found when ice candidate was gathered');
+                return;
+            }
+            if (!candidate) {
+                this.sdpManager.setLocal(this._localDescription, this.transceiverManager.getTransceivers(), this.sctpTransport);
+                this.onIceCandidate.execute(undefined);
+                if (this.onicecandidate) {
+                    runDetached(() => this.onicecandidate({ candidate: undefined }), (error) => log('event handler failed', error));
+                }
+                this.emit('icecandidate', { candidate: undefined });
+                return;
+            }
+            if (!this._localDescription) {
+                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,
+                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 = [
+            'stable',
+            'have-local-offer',
+            'have-remote-pranswer'
+        ];
+        await this.waitForPendingDescriptionTask();
+        if (sessionDescription?.type === 'rollback') {
+            this.sdpManager.rollbackLocalDescription(this.signalingState);
+            this.rollbackLocalOffer();
+            for (const transceiver of this.transceiverManager.getTransceivers()) {
+                transceiver.pendingLocalOfferCodecs = undefined;
+            }
+            this.pendingOfferChangeSeq = undefined;
+            this.setSignalingState('stable');
+            if (this.shouldNegotiationneeded) {
+                this.scheduleNegotiationneeded();
+            }
+            this.invalidateLastCreatedDescriptions();
+            return;
+        }
+        const needsGeneratedDescription = !sessionDescription?.type ||
+            !sessionDescription.sdp ||
+            sessionDescription.sdp.length === 0;
+        const generatedDescription = needsGeneratedDescription
+            ? sessionDescription?.type === 'offer'
+                ? (this.lastCreatedOffer ?? (await this.createOffer()))
+                : sessionDescription?.type === 'answer' ||
+                    sessionDescription?.type === 'pranswer'
+                    ? (this.lastCreatedAnswer ?? (await this.createAnswer()))
+                    : implicitOfferState.includes(this.signalingState)
+                        ? (this.lastCreatedOffer ?? (await this.createOffer()))
+                        : (this.lastCreatedAnswer ?? (await this.createAnswer()))
+            : undefined;
+        sessionDescription = {
+            type: sessionDescription?.type ?? generatedDescription.type,
+            sdp: sessionDescription?.sdp && sessionDescription.sdp.length > 0
+                ? sessionDescription.sdp
+                : generatedDescription.sdp
+        };
+        if (sessionDescription.type === 'offer' &&
+            this.lastCreatedOffer &&
+            sessionDescription.sdp !== this.lastCreatedOffer.sdp) {
+            throw createWebRtcDomException('InvalidModificationError', 'setLocalDescription must use the latest created offer');
+        }
+        // # parse and validate description
+        const descriptionType = sessionDescription.type;
+        const descriptionSdp = sessionDescription.sdp;
+        const description = this.sdpManager.parseSdp({
+            sdp: descriptionSdp,
+            isLocal: true,
+            signalingState: this.signalingState,
+            type: descriptionType
+        });
+        // # 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') {
+            this.setSignalingState('stable');
+        }
+        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 enumerate(description.media)) {
+            const mid = media.rtp.muxId;
+            this.sdpManager.registerMid(mid);
+            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) {
+                this.sctpTransport.mid = mid;
+            }
+        }
+        // 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 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'
+                    : andDirection(t.direction, t.offerDirection);
+                t.setCurrentDirection(direction);
+            }
+        }
+        // for trickle ice
+        this.sdpManager.setLocal(description, this.transceiverManager.getTransceivers(), this.sctpTransport);
+        await this.gatherCandidates().catch((e) => {
+            log('gatherCandidates failed', e);
+        });
+        // connect transports
+        if (description.type === 'answer') {
+            this.connect().catch((err) => {
+                log('connect failed', err);
+                this.secureManager.setConnectionState('failed');
+            });
+        }
+        this.sdpManager.setLocal(description, this.transceiverManager.getTransceivers(), this.sctpTransport);
+        // 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();
+    }
+    async addIceCandidate(candidateMessage = {}) {
+        if (this.isClosed) {
+            throw createWebRtcDomException('InvalidStateError', 'is closed');
+        }
+        if (!this.remoteDescription || !this.sdpManager._remoteDescription) {
+            this.pendingRemoteCandidates.push(candidateMessage);
+            return;
+        }
+        await this.applyRemoteIceCandidate(candidateMessage);
+    }
+    async applyRemoteIceCandidate(candidateMessage) {
+        const sdp = this.sdpManager._remoteDescription;
+        if (!sdp) {
+            return;
+        }
+        const appliedCandidate = await this.secureManager.addIceCandidate(sdp, candidateMessage);
+        const remoteDescription = this.sdpManager._remoteDescription;
+        if (!remoteDescription || !appliedCandidate) {
+            return;
+        }
+        if (appliedCandidate.kind === 'end-of-candidates') {
+            for (const mediaIndex of appliedCandidate.mediaIndices) {
+                const media = remoteDescription.media[mediaIndex];
+                if (media) {
+                    media.iceCandidatesComplete = true;
+                }
+            }
+            return;
+        }
+        for (const mediaIndex of appliedCandidate.mediaIndices) {
+            const media = remoteDescription.media[mediaIndex];
+            if (!media) {
+                continue;
+            }
+            media.iceCandidates.push(appliedCandidate.candidate);
+        }
+    }
+    async flushPendingRemoteCandidates() {
+        while (this.pendingRemoteCandidates.length > 0 &&
+            this.remoteDescription &&
+            this.sdpManager._remoteDescription) {
+            const candidate = this.pendingRemoteCandidates.shift();
+            await this.applyRemoteIceCandidate(candidate ?? null);
+        }
+    }
+    async connect() {
+        log('start connect');
+        const res = await Promise.allSettled(this.dtlsTransports.map(async (dtlsTransport) => {
+            const { iceTransport } = dtlsTransport;
+            if (iceTransport.state === 'connected') {
+                return;
+            }
+            //Not negotiated yet (the transport of a transceiver added since, which the next offer bundles): the
+            //negotiation giving it its remote parameters connects it
+            if (!iceTransport.connection.remoteUsername || !iceTransport.connection.remotePassword) {
+                return;
+            }
+            const checkDtlsConnected = () => dtlsTransport.state === 'connected';
+            if (checkDtlsConnected()) {
+                //After an ICE restart (new credentials, no pair nominated), DTLS is still connected: ICE checks
+                //again, and the records go over the pair it nominates
+                if (!iceTransport.connection.nominated) {
+                    await iceTransport.start().catch((err) => {
+                        log('iceTransport.start failed', err);
+                        throw err;
+                    });
+                }
+                return;
+            }
+            this.secureManager.setConnectionState('connecting');
+            await iceTransport.start().catch((err) => {
+                log('iceTransport.start failed', err);
+                throw err;
+            });
+            if (checkDtlsConnected()) {
+                return;
+            }
+            await dtlsTransport.start().catch((err) => {
+                log('dtlsTransport.start failed', err);
+                throw err;
+            });
+            if (this.sctpTransport &&
+                this.sctpTransport.dtlsTransport.id === dtlsTransport.id) {
+                await this.sctpManager.connectSctp();
+            }
+        }));
+        if (res.find((r) => r.status === 'rejected')) {
+            this.secureManager.setConnectionState('failed');
+        }
+        else {
+            this.secureManager.setConnectionState('connected');
+        }
+    }
+    restartIce() {
+        this.needRestart = true;
+        this.needNegotiation();
+    }
+    async setRemoteDescription(sessionDescription) {
+        if (sessionDescription instanceof SessionDescription) {
+            sessionDescription = sessionDescription.toSdp();
+        }
+        await this.waitForPendingDescriptionTask();
+        //An offer of the other side while this side offers: this side's offer is rolled back first, the offer of the
+        //other side then associated with the transceivers as they were before it
+        const needsImplicitLocalRollback = sessionDescription.type === 'offer' &&
+            ['have-local-offer', 'have-local-pranswer'].includes(this.signalingState);
+        if (needsImplicitLocalRollback) {
+            this.sdpManager.rollbackLocalDescription(this.signalingState);
+            this.rollbackLocalOffer();
+            for (const transceiver of this.transceiverManager.getTransceivers()) {
+                transceiver.pendingLocalOfferCodecs = undefined;
+            }
+            this.pendingOfferChangeSeq = undefined;
+            this.shouldNegotiationneeded = true;
+            this.setSignalingState('stable');
+            await Promise.resolve();
+        }
+        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, sessionDescription.type === 'offer');
+                if (transceiver)
+                    planned.add(transceiver);
+                return transceiver;
+            });
+        }
+        // # 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.scheduleNegotiationneeded();
+            }
+            this.invalidateLastCreatedDescriptions();
+            return;
+        }
+        if (remoteSdp.type === 'offer') {
+            this.transceiverManager.beginRemoteOffer();
+        }
+        // # apply description
+        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.findTransceiverForRemoteMedia(remoteMedia, index, associated, remoteSdp.type === 'offer');
+                if (!transceiver) {
+                    if (remoteMedia.port === 0) {
+                        // 未知の MID の拒否済み m-line には transceiver を関連付けない
+                        return { remoteMedia, index };
+                    }
+                    transceiver = this.addRemoteTransceiver(remoteMedia, index);
+                }
+                else if (transceiver.mid == null) {
+                    this.transceiverManager.associateMLine(transceiver, index);
+                }
+                associated.add(transceiver);
+                return { remoteMedia, index, transceiver };
+            }
+            else if (remoteMedia.kind === 'application') {
+                let sctpTransport = this.sctpTransport;
+                if (!sctpTransport) {
+                    sctpTransport = this.createSctpTransport();
+                    sctpTransport.mid = remoteMedia.rtp.muxId;
+                }
+                return { remoteMedia, index, sctpTransport };
+            }
+            else {
+                throw new Error('invalid media kind');
+            }
+        });
+        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;
+                }
+            }
+        }
+        // ## 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
+            for (const candidate of remoteMedia.iceCandidates) {
+                iceTransport.addRemoteCandidate(candidate).catch((error) => log('add candidate failed', error));
+            }
+            if (remoteMedia.iceCandidatesComplete) {
+                iceTransport.addRemoteCandidate(undefined).catch((error) => log('end of candidates failed', error));
+            }
+            // # set DTLS role
+            if (remoteSdp.type === 'answer' && remoteMedia.dtlsParams?.role) {
+                dtlsTransport.role =
+                    remoteMedia.dtlsParams.role === 'client' ? 'server' : 'client';
+            }
+        }
+        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');
+        }
+        else if (remoteSdp.type === 'answer') {
+            this.setSignalingState('stable');
+        }
+        else if (remoteSdp.type === 'pranswer') {
+            this.setSignalingState('have-remote-pranswer');
+        }
+        await this.flushPendingRemoteCandidates();
+        // connect transports
+        if (remoteSdp.type === 'answer') {
+            log('caller start connect');
+            this.connect().catch((err) => {
+                log('connect failed', err);
+                this.secureManager.setConnectionState('failed');
+            });
+        }
+        this.negotiationneeded = false;
+        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 = 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 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, offer) {
+        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;
+        }
+        //A media of an offer asking to receive takes a transceiver of addTrack, never one of addTransceiver (it sends
+        //something else: RFC 8829 5.10)
+        const unassociated = candidates.filter((t) => t.mid == null &&
+            !t.stopping &&
+            !t.stopped &&
+            (!offer ||
+                (t.addedByAddTrack &&
+                    ['sendrecv', 'recvonly'].includes(remoteMedia.direction ?? 'sendrecv'))));
+        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);
+        this.secureManager.updateIceConnectionState();
+        this.needNegotiation();
+        return transceiver;
+    }
+    // todo fix
+    addTrack(track, ...streams) {
+        return this.addTrackOn(undefined, track, ...streams);
+    }
+    /**
+     * Whether addTrack may give a track of its kind to a transceiver, rather than adding one
+     * @param transceiver
+     */
+    reusableForTrack(transceiver) {
+        return this.transceiverManager.reusableForTrack(transceiver, transceiver.kind);
+    }
+    /**
+     * addTrack, on the transceiver chosen already (by the main thread, for a connection served in a worker thread) if
+     * it may still take the track, else on a new one, as for null
+     * @param chosen
+     * @param track
+     * @param streams
+     */
+    addTrackOn(chosen, track, ...streams) {
+        if (this.isClosed) {
+            throw createWebRtcDomException('InvalidStateError', 'is closed');
+        }
+        const transceiver = this.transceiverManager.addTrack(track, streams, chosen);
+        if (!transceiver.dtlsTransport) {
+            const dtlsTransport = this.findOrCreateTransport();
+            transceiver.setDtlsTransport(dtlsTransport);
+        }
+        this.needNegotiation();
+        return transceiver.sender;
+    }
+    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.headerExtensionsFor(transceiver.kind);
+            }
+        }
+        const description = this.sdpManager.buildAnswerSdp({
+            transceivers: this.transceiverManager.getTransceivers(),
+            sctpTransport: this.sctpTransport,
+            signalingState: this.signalingState
+        });
+        const createdAnswer = description.toJSON();
+        this.lastCreatedAnswer = createdAnswer;
+        return createdAnswer;
+    }
+    assertNotClosed() {
+        if (this.isClosed) {
+            throw createWebRtcDomException('InvalidStateError', 'RTCPeerConnection is closed');
+        }
+    }
+    /**
+   * The signaling state is stable: the associations of the transceivers and of the data channels are kept, for a
+   * rollback of the next local offer
+   */
+    markStable() {
+        this.transceiverManager.markStable();
+        const sctp = this.sctpTransport;
+        this.stableSctp = sctp ? { mid: sctp.mid, mLineIndex: sctp.mLineIndex } : undefined;
+    }
+    /**
+   * A local offer is rolled back: the transceivers and the data channels are associated as before it
+   */
+    rollbackLocalOffer() {
+        this.transceiverManager.rollbackLocalOffer();
+        const sctp = this.sctpTransport;
+        if (sctp) {
+            sctp.mid = this.stableSctp?.mid;
+            sctp.mLineIndex = this.stableSctp?.mLineIndex;
+        }
+    }
+    setSignalingState(state) {
+        if (this.signalingState === state) {
+            return;
+        }
+        log('signalingStateChange', state);
+        this.signalingState = state;
+        if (state === 'stable')
+            this.markStable();
+        this.signalingStateChange.execute(state);
+        if (this.onsignalingstatechange) {
+            runDetached(() => this.onsignalingstatechange(new globalThis.Event('signalingstatechange')), (error) => log('event handler failed', error));
+        }
+        this.emit('signalingstatechange');
+    }
+    createPeerConnectionStats(timestamp) {
+        return {
+            type: 'peer-connection',
+            id: generateStatsId('peer-connection', this.id),
+            timestamp,
+            dataChannelsOpened: this.sctpManager.dataChannelsOpened,
+            dataChannelsClosed: this.sctpManager.dataChannelsClosed
+        };
+    }
+    async getStats(selector) {
+        const timestamp = getStatsTimestamp();
+        const stats = [];
+        if (!selector) {
+            stats.push(this.createPeerConnectionStats(timestamp));
+        }
+        stats.push(...this.transceiverManager.collectStats(timestamp));
+        const transportStats = await this.secureManager.getStats(timestamp);
+        stats.push(...transportStats);
+        if (!selector && this.sctpTransport) {
+            const dataChannelStats = await this.sctpManager.getStats(timestamp);
+            if (dataChannelStats) {
+                stats.push(...dataChannelStats);
+            }
+        }
+        if (!selector) {
+            return buildStatsReport(stats);
+        }
+        return buildStatsReport(stats, this.transceiverManager.getStatsRootIds(selector));
+    }
+    async close() {
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        this.pendingRemoteCandidates.length = 0;
+        this.setSignalingState('closed');
+        this.transceiverManager.close();
+        // SCTP ABORT は DTLS/ICE が生きている間に送る（close は abrupt であり SHUTDOWN ではない）
+        await this.sctpManager.close();
+        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();
+            }
+        }
+    }
+}
+const MLineReuseModes = ['compatible', 'aggressive'];
+export const findCodecByMimeType = (codecs, target) => codecs.find((localCodec) => localCodec.mimeType.toLowerCase() === target.mimeType.toLowerCase())
+    ? target
+    : undefined;
+function assignDynamicPayloadTypes(config) {
+    for (const [i, codecParams] of 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: defaultCodecs(),
+        headerExtensions: {
+            audio: [],
+            video: []
+        },
+        iceTransportPolicy: 'all',
+        iceLite: false,
+        iceServers: [],
+        icePortRange: undefined,
+        iceInterfaceAddresses: undefined,
+        iceAdditionalHostAddresses: undefined,
+        iceUseIpv4: true,
+        iceUseIpv6: true,
+        iceUseTcp: false,
+        iceTcpPassive: true,
+        iceStunGatherTimeout: undefined,
+        iceTurnConnectTimeout: undefined,
+        turnTransport: undefined,
+        turnTlsOptions: undefined,
+        turnUdpFamily: undefined,
+        iceFilterStunResponse: undefined,
+        iceFilterCandidatePair: undefined,
+        icePasswordPrefix: undefined,
+        iceUseLinkLocalAddress: undefined,
+        dtls: {},
+        bundlePolicy: 'max-compat',
+        rtcpMuxPolicy: 'require',
+        iceCandidatePoolSize: 0,
+        certificates: [],
+        debug: {},
+        midSuffix: false,
+        forceTurnTCP: false,
+        maxMessageSize: DEFAULT_MAX_MESSAGE_SIZE,
+        sctp: { mtu: DEFAULT_SCTP_MTU },
+        pendingRtp: false,
+        mLineReuse: 'compatible'
+    };
+}
+export const 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';
+    }
+    if ('certificates' in input) {
+        if (input.certificates === undefined) {
+            normalizedConfig.certificates = undefined;
+        }
+        else if (!Array.isArray(input.certificates) ||
+            input.certificates.some((certificate) => certificate == null)) {
+            throw createWebRtcTypeError('certificates must be an array of RTCCertificate');
+        }
+        else {
+            normalizedConfig.certificates = [...input.certificates];
+        }
+    }
+    if ('iceCandidatePoolSize' in input) {
+        normalizedConfig.iceCandidatePoolSize = coerceUnsignedShort(input.iceCandidatePoolSize, 'iceCandidatePoolSize');
+    }
+    return normalizedConfig;
+}
+function coerceUnsignedShort(value, name) {
+    const coerced = Number(value);
+    if (!Number.isFinite(coerced) ||
+        !Number.isInteger(coerced) ||
+        coerced < 0 ||
+        coerced > 65535) {
+        throw createWebRtcTypeError(`${name} must be an unsigned short`);
+    }
+    return coerced;
+}
+function hasSameCertificates(left, right) {
+    return (left.length === right.length &&
+        left.every((certificate, index) => certificate === right[index]));
+}
+function clonePeerConfiguration(config) {
+    return {
+        ...config,
+        codecs: {
+            audio: config.codecs.audio ? [...config.codecs.audio] : undefined,
+            video: config.codecs.video ? [...config.codecs.video] : undefined
+        },
+        headerExtensions: {
+            audio: config.headerExtensions.audio
+                ? [...config.headerExtensions.audio]
+                : undefined,
+            video: config.headerExtensions.video
+                ? [...config.headerExtensions.video]
+                : undefined
+        },
+        iceServers: config.iceServers.map((server) => ({
+            ...server,
+            urls: Array.isArray(server.urls) ? [...server.urls] : server.urls
+        })),
+        icePortRange: config.icePortRange
+            ? [...config.icePortRange]
+            : undefined,
+        iceAdditionalHostAddresses: config.iceAdditionalHostAddresses
+            ? [...config.iceAdditionalHostAddresses]
+            : undefined,
+        dtls: { ...config.dtls },
+        certificates: [...config.certificates],
+        debug: { ...config.debug },
+        sctp: { ...config.sctp },
+        pendingRtp: typeof config.pendingRtp === 'object' && config.pendingRtp != undefined
+            ? { ...config.pendingRtp }
+            : config.pendingRtp
+    };
+}
+export class RTCTrackEvent {
+    constructor(init) {
+        this.type = 'track';
+        this.track = init.track;
+        this.streams = [...init.streams];
+        this.transceiver = init.transceiver;
+        this.receiver = init.receiver;
+    }
+}