@mertushka/webrtc-node 0.1.0-alpha.0 → 0.1.0

package/lib/index.js

@@ -53,17 +53,23 @@ class SimpleEventTarget {
       map.set(key, listeners);
     }
     const once = typeof options === "object" && options !== null && Boolean(options.once);
+    let added = false;
     if (!listeners.some((listener) => listener.callback === callback)) {
       listeners.push({ callback, once });
+      added = true;
     }
-    if (typeof this._eventListenerAdded === "function") this._eventListenerAdded(key);
+    if (added && typeof this._eventListenerAdded === "function") this._eventListenerAdded(key);
   }
 
   removeEventListener(type, callback) {
-    const listeners = kHandlers.get(this)?.get(String(type));
+    const key = String(type);
+    const listeners = kHandlers.get(this)?.get(key);
     if (!listeners) return;
     const index = listeners.findIndex((listener) => listener.callback === callback);
-    if (index !== -1) listeners.splice(index, 1);
+    if (index !== -1) {
+      listeners.splice(index, 1);
+      if (typeof this._eventListenerRemoved === "function") this._eventListenerRemoved(key);
+    }
   }
 
   dispatchEvent(event) {
@@ -72,11 +78,14 @@ class SimpleEventTarget {
     }
     event.target = event.target || this;
     event.currentTarget = this;
-    const listeners = Array.from(kHandlers.get(this)?.get(event.type) || []);
+    const registeredListeners = kHandlers.get(this)?.get(event.type);
+    const listeners = registeredListeners?.length ? Array.from(registeredListeners) : null;
     const handler = this[`on${event.type}`];
-    for (const listener of listeners) {
-      callListener(listener.callback, this, event);
-      if (listener.once) this.removeEventListener(event.type, listener.callback);
+    if (listeners) {
+      for (const listener of listeners) {
+        callListener(listener.callback, this, event);
+        if (listener.once) this.removeEventListener(event.type, listener.callback);
+      }
     }
     if (typeof handler === "function") callListener(handler, this, event);
     return !event.defaultPrevented;
@@ -477,7 +486,7 @@ function maxMessageSizeFromSdp(description) {
 }
 
 function nextTask() {
-  return new Promise((resolve) => setTimeout(resolve, 0));
+  return new Promise((resolve) => setImmediate(resolve));
 }
 
 function delay(ms) {
@@ -1283,6 +1292,9 @@ class RTCDataChannel extends SimpleEventTarget {
     );
     peerConnection._channels.set(channel._native.bindingId, channel);
     peerConnection._registerDataChannelId(channel);
+    if (channel._registeredDataChannelId == null && channel._effectiveId() == null) {
+      peerConnection._dataChannelIdRefreshNeeded = true;
+    }
     return channel;
   }
 
@@ -1305,9 +1317,12 @@ class RTCDataChannel extends SimpleEventTarget {
     this._nativeEventDrainActive = false;
     this._queuedNativeEvents = [];
     this._queuedMessageEvents = [];
+    this._queuedMessageEventIndex = 0;
     this._messageEventFlushScheduled = false;
     this._messageEventGateActive = false;
     this._messageConsumerGateActive = false;
+    this._messageEventListenerCount = 0;
+    this._messageHandlerNeedsTaskYield = false;
     this._pendingPairedDeliveryBytes = 0;
     this._nativeCloseEventQueued = false;
     this._openEventDeferredForIce = false;
@@ -1391,6 +1406,7 @@ class RTCDataChannel extends SimpleEventTarget {
 
   set onmessage(callback) {
     this._onmessage = typeof callback === "function" ? callback : null;
+    this._messageHandlerNeedsTaskYield = this._messageContinuationNeedsTaskYield(this._onmessage);
     if (this._onmessage) this._releaseMessageConsumerGate();
   }
 
@@ -1428,17 +1444,17 @@ class RTCDataChannel extends SimpleEventTarget {
       return;
     }
 
-    const view = toUint8Array(data);
+    const view = data instanceof Uint8Array ? data : toUint8Array(data);
     const size = view.byteLength;
     this._assertWithinMaxMessageSize(size);
     if (this._hasPendingSends() || !this._nativeReadyForSend()) {
       const payload = new Uint8Array(view);
       this._enqueueSend(() => this._sendNativeBinary(payload), size);
     } else {
-      const payload = new Uint8Array(view);
-      if (this._sendNativeBinary(payload)) {
+      if (this._sendNativeBinary(view)) {
         this._increaseBufferedAmount(size);
       } else {
+        const payload = new Uint8Array(view);
         this._enqueueSend(() => this._sendNativeBinary(payload), size);
       }
     }
@@ -1457,11 +1473,7 @@ class RTCDataChannel extends SimpleEventTarget {
       this._nativeCloseScheduled = true;
       const closeNative = () => {
         const close = () => {
-          const synthesizePairedClose =
-            pairedChannel &&
-            pairedChannel.readyState !== "closed" &&
-            (pairedChannel._syntheticIncoming ||
-              (this._bufferedAmount === 0 && !this._hasPendingSends()));
+          const synthesizePairedClose = pairedChannel && pairedChannel.readyState !== "closed";
           this._native.close();
           if (synthesizePairedClose) {
             setTimeout(() => pairedChannel._handleRemoteChannelClose(), 0);
@@ -1473,7 +1485,7 @@ class RTCDataChannel extends SimpleEventTarget {
         if (shouldDrainBeforeClose) {
           this._closeNativeAfterBufferedSends(close);
         } else {
-          close();
+          setImmediate(close);
         }
       };
       if (this._hasPendingSends()) {
@@ -1487,7 +1499,7 @@ class RTCDataChannel extends SimpleEventTarget {
   _increaseBufferedAmount(size) {
     if (!size) return;
     this._bufferedAmount += size;
-    setTimeout(() => this._decreaseBufferedAmount(size), 0);
+    setImmediate(() => this._decreaseBufferedAmount(size));
   }
 
   _hasPendingSends() {
@@ -1527,8 +1539,12 @@ class RTCDataChannel extends SimpleEventTarget {
   }
 
   _assertWithinMaxMessageSize(size) {
-    const maxMessageSize = this._pc.sctp?.maxMessageSize;
-    if (Number.isFinite(maxMessageSize) && size > maxMessageSize) {
+    const maxMessageSize = this._pc._sctpTransport?._maxMessageSize;
+    if (
+      maxMessageSize !== null &&
+      maxMessageSize !== Number.POSITIVE_INFINITY &&
+      size > maxMessageSize
+    ) {
       throw new TypeError("RTCDataChannel message exceeds RTCSctpTransport.maxMessageSize");
     }
   }
@@ -1589,8 +1605,13 @@ class RTCDataChannel extends SimpleEventTarget {
       return true;
     }
     try {
-      const sent = this._tryNativeSend(() => this._native.sendString(data));
-      if (sent) this._trackPendingPairedDelivery(byteLength(data));
+      let sent = this._native.sendString(data);
+      if (sent !== false) {
+        sent = true;
+      } else {
+        sent = Boolean(this._native?.isOpen);
+      }
+      if (sent && this._pairedChannel) this._pendingPairedDeliveryBytes += byteLength(data);
       return sent;
     } catch (error) {
       throw mapNativeError(error, "OperationError");
@@ -1606,21 +1627,22 @@ class RTCDataChannel extends SimpleEventTarget {
       return true;
     }
     try {
-      const view = toUint8Array(data);
-      const sent = this._tryNativeSend(() => this._native.sendBinary(view));
-      if (sent) this._trackPendingPairedDelivery(view.byteLength);
+      const view = data instanceof Uint8Array ? data : toUint8Array(data);
+      let sent = this._native.sendBinary(view);
+      if (sent !== false) {
+        sent = true;
+      } else {
+        sent = Boolean(this._native?.isOpen);
+      }
+      if (sent && this._pairedChannel && view.byteLength > 0) {
+        this._pendingPairedDeliveryBytes += view.byteLength;
+      }
       return sent;
     } catch (error) {
       throw mapNativeError(error, "OperationError");
     }
   }
 
-  _tryNativeSend(send) {
-    const sent = send();
-    if (sent !== false) return true;
-    return Boolean(this._native?.isOpen);
-  }
-
   _usesSyntheticPairDelivery() {
     return this._syntheticIncoming || this._pairedChannel?._syntheticIncoming;
   }
@@ -1628,10 +1650,10 @@ class RTCDataChannel extends SimpleEventTarget {
   _deliverSyntheticMessage(event) {
     const target = this._pairedChannel;
     if (!target || target.readyState === "closed") return;
-    setTimeout(() => {
+    setImmediate(() => {
       if (target.readyState === "closed") return;
       target._handleNativeEvent({ type: "message", ...event });
-    }, 0);
+    });
   }
 
   _trackPendingPairedDelivery(size) {
@@ -1645,6 +1667,7 @@ class RTCDataChannel extends SimpleEventTarget {
     const size = event.binary ? event.data?.byteLength || 0 : byteLength(event.data || "");
     if (size <= 0) return;
     sender._pendingPairedDeliveryBytes = Math.max(0, sender._pendingPairedDeliveryBytes - size);
+    sender._decreaseBufferedAmount(size);
   }
 
   _decreaseBufferedAmount(size) {
@@ -1839,6 +1862,9 @@ class RTCDataChannel extends SimpleEventTarget {
     if (this._pairedChannel?._pairedChannel === this) this._pairedChannel._pairedChannel = null;
     this._pairedChannel = null;
     this._pc._unregisterDataChannelId(this);
+    if (this._pc._channels.get(this._native.bindingId) === this) {
+      this._pc._channels.delete(this._native.bindingId);
+    }
     if (!this._createdLocally && id != null) {
       this._pc._remoteAnnouncedDataChannelIds.delete(id);
       this._pc._pendingSyntheticDataChannelAnnouncements.delete(id);
@@ -1921,10 +1947,10 @@ class RTCDataChannel extends SimpleEventTarget {
         return;
       }
       this._handleNativeEvent(event, true);
-      if (this._queuedNativeEvents.length) setTimeout(dispatchNext, 0);
+      if (this._queuedNativeEvents.length) setImmediate(dispatchNext);
       else this._nativeEventDrainActive = false;
     };
-    setTimeout(dispatchNext, 0);
+    setImmediate(dispatchNext);
   }
 
   _queueMessageEvent(event) {
@@ -1932,39 +1958,175 @@ class RTCDataChannel extends SimpleEventTarget {
     this._scheduleMessageEventFlush();
   }
 
+  _queueMessageEvents(events) {
+    for (const event of events) this._queuedMessageEvents.push(event);
+    this._scheduleMessageEventFlush();
+  }
+
   _scheduleMessageEventFlush() {
     if (this._messageEventFlushScheduled) return;
     this._messageEventFlushScheduled = true;
-    setTimeout(() => {
+    setImmediate(() => {
       this._messageEventFlushScheduled = false;
       this._flushQueuedMessageEvents();
-    }, 0);
+    });
+  }
+
+  _scheduleMessageEventContinuation({ yieldToTask = false } = {}) {
+    if (this._messageEventFlushScheduled) return;
+    this._messageEventFlushScheduled = true;
+    const schedule = yieldToTask ? setTimeout : setImmediate;
+    schedule(
+      () => {
+        this._messageEventFlushScheduled = false;
+        this._flushQueuedMessageEvents();
+      },
+      yieldToTask ? 1 : 0,
+    );
+  }
+
+  _messageContinuationNeedsTaskYield(handler = this._onmessage) {
+    if (typeof handler !== "function") return false;
+    try {
+      return /\[native code\]/.test(Function.prototype.toString.call(handler));
+    } catch {
+      return false;
+    }
+  }
+
+  _hasMessageEventListeners() {
+    return this._messageEventListenerCount > 0;
+  }
+
+  _canContinueMessageBatchInCurrentTask(handler, yieldToTask) {
+    return (
+      typeof handler === "function" &&
+      handler instanceof Function &&
+      this._onmessage === handler &&
+      !yieldToTask &&
+      !this._hasMessageEventListeners()
+    );
+  }
+
+  _canUseDirectMessageHandler(handler, yieldToTask, hasMessageListeners) {
+    return !hasMessageListeners && this._canContinueMessageBatchInCurrentTask(handler, yieldToTask);
+  }
+
+  _dispatchMessageEvent(event, directHandler) {
+    const messageEvent = makeMessageEvent("message", { data: this._convertMessage(event) });
+    if (directHandler) {
+      messageEvent.target = this;
+      messageEvent.currentTarget = this;
+      callListener(directHandler, this, messageEvent);
+    } else {
+      this.dispatchEvent(messageEvent);
+    }
   }
 
   _flushQueuedMessageEvents() {
-    if (this._readyState === "closed") {
-      this._queuedMessageEvents.length = 0;
-      return;
+    while (true) {
+      if (this._readyState === "closed") {
+        this._queuedMessageEvents.length = 0;
+        this._queuedMessageEventIndex = 0;
+        return;
+      }
+
+      const pendingPeer =
+        this._pc._operationsPending > 0
+          ? this._pc
+          : this._pc._pairedPeer?._operationsPending > 0
+            ? this._pc._pairedPeer
+            : null;
+      if (pendingPeer) {
+        pendingPeer._afterOperationsIdle(() => this._scheduleMessageEventFlush());
+        return;
+      }
+
+      if (this._messageEventGateActive) return;
+      if (this._messageConsumerGateActive && !this._hasEventConsumer("message")) return;
+      if (this._messageConsumerGateActive) this._messageConsumerGateActive = false;
+
+      const event = this._queuedMessageEvents[this._queuedMessageEventIndex++];
+      if (!event) {
+        this._queuedMessageEventIndex = 0;
+        return;
+      }
+      const handler = this._onmessage;
+      const hasMessageListeners = this._hasMessageEventListeners();
+      const yieldToTask = this._messageHandlerNeedsTaskYield;
+      const directHandler = this._canUseDirectMessageHandler(
+        handler,
+        yieldToTask,
+        hasMessageListeners,
+      )
+        ? handler
+        : null;
+      this._dispatchMessageEvent(event, directHandler);
+      this._markPairedDeliveryReceived(event);
+
+      if (this._queuedMessageEventIndex >= this._queuedMessageEvents.length) {
+        this._queuedMessageEvents.length = 0;
+        this._queuedMessageEventIndex = 0;
+        return;
+      }
+      if (this._queuedMessageEventIndex > 1024) {
+        this._queuedMessageEvents.splice(0, this._queuedMessageEventIndex);
+        this._queuedMessageEventIndex = 0;
+      }
+      if (!this._canContinueMessageBatchInCurrentTask(handler, yieldToTask)) {
+        this._scheduleMessageEventContinuation({ yieldToTask });
+        return;
+      }
     }
-    if (!this._queuedMessageEvents.length) return;
+  }
+
+  _dispatchNativeMessageBatch(events) {
+    if (this._readyState === "closed") return true;
     const pendingPeer =
       this._pc._operationsPending > 0
         ? this._pc
         : this._pc._pairedPeer?._operationsPending > 0
           ? this._pc._pairedPeer
           : null;
-    if (pendingPeer) {
-      pendingPeer._afterOperationsIdle(() => this._scheduleMessageEventFlush());
-      return;
-    }
-    if (this._messageEventGateActive) return;
-    if (this._messageConsumerGateActive && !this._hasEventConsumer("message")) return;
+    if (pendingPeer || this._messageEventGateActive) return false;
+    if (this._messageConsumerGateActive && !this._hasEventConsumer("message")) return false;
     if (this._messageConsumerGateActive) this._messageConsumerGateActive = false;
 
-    const event = this._queuedMessageEvents.shift();
-    this.dispatchEvent(makeMessageEvent("message", { data: this._convertMessage(event) }));
-    this._markPairedDeliveryReceived(event);
-    if (this._queuedMessageEvents.length) this._scheduleMessageEventFlush();
+    const handler = this._onmessage;
+    const hasMessageListeners = this._hasMessageEventListeners();
+    const yieldToTask = this._messageHandlerNeedsTaskYield;
+    const directHandler = this._canUseDirectMessageHandler(
+      handler,
+      yieldToTask,
+      hasMessageListeners,
+    )
+      ? handler
+      : null;
+    if (!directHandler) return false;
+
+    const shouldCreateBlob = this._binaryType === "blob" && typeof Blob !== "undefined";
+    for (let index = 0; index < events.length; index += 1) {
+      const event = events[index];
+      const messageEvent = makeMessageEvent("message", {
+        data: event.binary && shouldCreateBlob ? new Blob([event.data]) : event.data,
+      });
+      messageEvent.target = this;
+      messageEvent.currentTarget = this;
+      directHandler.call(this, messageEvent);
+      this._markPairedDeliveryReceived(event);
+      if (this._readyState === "closed") return true;
+      if (
+        index + 1 < events.length &&
+        !this._canContinueMessageBatchInCurrentTask(handler, yieldToTask)
+      ) {
+        for (let remaining = index + 1; remaining < events.length; remaining += 1) {
+          this._queuedMessageEvents.push(events[remaining]);
+        }
+        this._scheduleMessageEventContinuation({ yieldToTask: this._messageHandlerNeedsTaskYield });
+        return true;
+      }
+    }
+    return true;
   }
 
   _gateMessageEventsAfterAnnouncement() {
@@ -1991,7 +2153,15 @@ class RTCDataChannel extends SimpleEventTarget {
   }
 
   _eventListenerAdded(type) {
-    if (type === "message") this._releaseMessageConsumerGate();
+    if (type !== "message") return;
+    this._messageEventListenerCount += 1;
+    this._releaseMessageConsumerGate();
+  }
+
+  _eventListenerRemoved(type) {
+    if (type === "message" && this._messageEventListenerCount > 0) {
+      this._messageEventListenerCount -= 1;
+    }
   }
 
   _convertMessage(event) {
@@ -2004,6 +2174,7 @@ class RTCDataChannel extends SimpleEventTarget {
 }
 
 function toUint8Array(data) {
+  if (data instanceof Uint8Array) return data;
   if (data instanceof ArrayBuffer) return new Uint8Array(data);
   if (ArrayBuffer.isView(data)) {
     return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
@@ -2024,6 +2195,7 @@ class RTCPeerConnection extends SimpleEventTarget {
     this._configuration = normalizedConfiguration;
     this._channels = new Map();
     this._usedDataChannelIds = new Map();
+    this._dataChannelIdRefreshNeeded = false;
     this._closed = false;
     this._localDescription = null;
     this._remoteDescription = null;
@@ -2049,6 +2221,8 @@ class RTCPeerConnection extends SimpleEventTarget {
     this._lastCreatedOffer = null;
     this._lastCreatedAnswer = null;
     this._localDescriptionSetByApi = false;
+    this._localDescriptionRefreshScheduled = false;
+    this._nativeCandidateGatheringScheduled = false;
     this._iceRestartPending = false;
     this._pendingIceRestartCredentials = null;
     this._jsOnlyIceRestartOfferPending = false;
@@ -2105,9 +2279,13 @@ class RTCPeerConnection extends SimpleEventTarget {
       nativeCertificates = [createDefaultNativeCertificate()];
       nativeConfiguration.certificates = nativeCertificates;
     }
-    const nativePeerConnection = new native.NativePeerConnection(nativeConfiguration, (event) =>
-      this._handleNativeEvent(event),
-    );
+    const nativePeerConnection = new native.NativePeerConnection(nativeConfiguration, (event) => {
+      if (Array.isArray(event)) {
+        this._handleNativeEventBatch(event);
+      } else {
+        this._handleNativeEvent(event);
+      }
+    });
     this._nativeCertificates = nativeCertificates;
     this._native = nativePeerConnection;
     return this._native;
@@ -2516,6 +2694,7 @@ class RTCPeerConnection extends SimpleEventTarget {
             ? new RTCSessionDescription(nativeDescription)
             : null;
           this._syncStatesFromNative();
+          this._scheduleNativeCandidateGathering();
         }
       }
       if (type === "offer") {
@@ -2557,6 +2736,7 @@ class RTCPeerConnection extends SimpleEventTarget {
       normalized.type === "answer" &&
       this._signalingState !== "have-local-offer" &&
       this._signalingState !== "have-remote-pranswer" &&
+      !this._jsOnlyIceRestartOfferPending &&
       this._operationsPending === 0
     ) {
       throw makeDOMException(
@@ -2592,7 +2772,8 @@ class RTCPeerConnection extends SimpleEventTarget {
       if (
         normalized.type === "answer" &&
         this._signalingState !== "have-local-offer" &&
-        this._signalingState !== "have-remote-pranswer"
+        this._signalingState !== "have-remote-pranswer" &&
+        !this._jsOnlyIceRestartOfferPending
       ) {
         throw makeDOMException(
           "Cannot set a remote answer in current signaling state",
@@ -2879,9 +3060,9 @@ class RTCPeerConnection extends SimpleEventTarget {
         }
       }, PEER_CONNECTION_NATIVE_CLOSE_DELAY_MS);
     }
-    setTimeout(() => {
+    setImmediate(() => {
       if (pairedPeer && !pairedPeer._closed) pairedPeer._handleRemotePeerClosed();
-    }, 0);
+    });
     this._connectionState = "closed";
     this._iceConnectionState = "closed";
     this._deferredIceEvents = [];
@@ -3088,12 +3269,12 @@ class RTCPeerConnection extends SimpleEventTarget {
   _scheduleSctpConnectedTransition() {
     if (this._sctpConnectedTransitionScheduled) return;
     this._sctpConnectedTransitionScheduled = true;
-    setTimeout(() => {
+    setImmediate(() => {
       this._sctpConnectedTransitionScheduled = false;
       if (this._closed || !this._sctpTransport) return;
       this._sctpConnectedTransitionReady = true;
       this._updateSctpTransport();
-    }, 0);
+    });
   }
 
   _shouldRepairConnectedState() {
@@ -3205,13 +3386,13 @@ class RTCPeerConnection extends SimpleEventTarget {
       this._pairedPeer?._flushPendingRemoteCandidatesForNative();
       this._scheduleDeferredIceEventFlush();
       const callbacks = this._operationIdleCallbacks.splice(0);
-      for (const callback of callbacks) setTimeout(callback, 0);
+      for (const callback of callbacks) setImmediate(callback);
     }
   }
 
   _afterOperationsIdle(callback) {
     if (this._closed || this._operationsPending === 0) {
-      setTimeout(callback, 0);
+      setImmediate(callback);
       return;
     }
     this._operationIdleCallbacks.push(callback);
@@ -3225,7 +3406,7 @@ class RTCPeerConnection extends SimpleEventTarget {
   _scheduleDeferredIceEventFlush() {
     if (this._iceEventFlushScheduled || this._deferredIceEvents.length === 0) return;
     this._iceEventFlushScheduled = true;
-    setTimeout(() => {
+    setImmediate(() => {
       this._iceEventFlushScheduled = false;
       if (this._closed) {
         this._deferredIceEvents = [];
@@ -3245,7 +3426,7 @@ class RTCPeerConnection extends SimpleEventTarget {
       }
       if (this._deferredIceEvents.length) this._scheduleDeferredIceEventFlush();
       else this._flushIceEventIdleCallbacks();
-    }, 0);
+    });
   }
 
   _hasPendingDeferredIceEvents() {
@@ -3258,7 +3439,7 @@ class RTCPeerConnection extends SimpleEventTarget {
 
   _afterDeferredIceEventsFlushed(callback) {
     if (this._closed || !this._hasPendingDeferredIceEvents()) {
-      setTimeout(callback, 0);
+      setImmediate(callback);
       return;
     }
     this._iceEventIdleCallbacks.push(callback);
@@ -3268,7 +3449,7 @@ class RTCPeerConnection extends SimpleEventTarget {
   _flushIceEventIdleCallbacks() {
     if (this._hasPendingDeferredIceEvents()) return;
     const callbacks = this._iceEventIdleCallbacks.splice(0);
-    for (const callback of callbacks) setTimeout(callback, 0);
+    for (const callback of callbacks) setImmediate(callback);
   }
 
   _queueSyntheticIceRestartGathering() {
@@ -3285,7 +3466,7 @@ class RTCPeerConnection extends SimpleEventTarget {
   _scheduleSctpTransportUpdate() {
     if (this._sctpTransportUpdateScheduled) return;
     this._sctpTransportUpdateScheduled = true;
-    setTimeout(() => {
+    setImmediate(() => {
       this._sctpTransportUpdateScheduled = false;
       if (
         !this._closed &&
@@ -3297,7 +3478,7 @@ class RTCPeerConnection extends SimpleEventTarget {
         this._iceConnectionState = this._native.iceConnectionState;
       }
       this._updateSctpTransport();
-    }, 0);
+    });
   }
 
   _scheduleSctpConnectPollIfNeeded() {
@@ -3771,6 +3952,7 @@ class RTCPeerConnection extends SimpleEventTarget {
       ? new RTCSessionDescription(nativeDescription)
       : null;
     this._syncStatesFromNative();
+    this._scheduleNativeCandidateGathering();
     for (const candidate of this._pendingIce.splice(0)) await this.addIceCandidate(candidate);
     this._flushPendingRemoteCandidatesForNative();
     await nextTask();
@@ -3814,11 +3996,23 @@ class RTCPeerConnection extends SimpleEventTarget {
     await nextTask();
   }
 
-  async _refreshLocalDescriptionAfterGatheringWindow() {
+  _scheduleNativeCandidateGathering() {
+    if (this._closed || !this._native || !hasDataMediaSection(this._localDescription)) return;
+    if (this._nativeCandidateGatheringScheduled) return;
+    this._nativeCandidateGatheringScheduled = true;
+    setImmediate(() => {
+      this._nativeCandidateGatheringScheduled = false;
+      if (this._closed || !this._native || !hasDataMediaSection(this._localDescription)) return;
+      try {
+        this._native.gatherLocalCandidates();
+      } catch {
+        // Gathering may already be complete or the native transport may be closing.
+      }
+    });
+  }
+
+  _refreshLocalDescriptionFromNative() {
     if (this._closed || !this._localDescription) return;
-    if (this._iceGatheringState !== "complete") {
-      await delay(50);
-    }
     if (!this._native) return;
     const nativeDescription = this._native.localDescription();
     if (nativeDescription) {
@@ -3828,12 +4022,27 @@ class RTCPeerConnection extends SimpleEventTarget {
     this._syncStatesFromNative();
   }
 
+  _refreshLocalDescriptionAfterGatheringWindow() {
+    this._refreshLocalDescriptionFromNative();
+    if (this._closed || !this._localDescription || this._iceGatheringState === "complete") return;
+    if (this._localDescriptionRefreshScheduled) return;
+    this._localDescriptionRefreshScheduled = true;
+    setTimeout(() => {
+      this._localDescriptionRefreshScheduled = false;
+      this._refreshLocalDescriptionFromNative();
+    }, 50);
+  }
+
   _syncStatesFromNative() {
     if (this._closed) return;
     if (!this._native) return;
     this._connectionState = this._native.connectionState;
     this._iceConnectionState = this._native.iceConnectionState;
-    this._signalingState = this._native.signalingState;
+    if (this._jsOnlyIceRestartOfferPending) {
+      this._signalingState = "have-local-offer";
+    } else {
+      this._signalingState = this._native.signalingState;
+    }
     this._refreshIceRole();
     this._updateSctpTransport();
   }
@@ -3936,6 +4145,10 @@ class RTCPeerConnection extends SimpleEventTarget {
         this._closeChannelsOnPeerFailure();
         break;
       case "signalingstatechange":
+        if (this._jsOnlyIceRestartOfferPending) {
+          this._signalingState = "have-local-offer";
+          break;
+        }
         this._signalingState = event.state;
         if (this._suppressNextNativeSignalingState === event.state) {
           this._suppressNextNativeSignalingState = null;
@@ -3946,6 +4159,43 @@ class RTCPeerConnection extends SimpleEventTarget {
     }
   }
 
+  _handleNativeEventBatch(events) {
+    if (!events.length) return;
+    const first = events[0];
+    if (first?.target !== "datachannel" || first.type !== "message" || first.channelId == null) {
+      for (const event of events) this._handleNativeEvent(event);
+      return;
+    }
+
+    const channelId = first.channelId;
+    for (let index = 1; index < events.length; index += 1) {
+      const event = events[index];
+      if (
+        event?.target !== "datachannel" ||
+        event.type !== "message" ||
+        event.channelId !== channelId
+      ) {
+        for (const item of events) this._handleNativeEvent(item);
+        return;
+      }
+    }
+
+    const channel = this._channels.get(channelId);
+    if (channel) {
+      if (channel._announcementPending || channel._nativeEventDrainActive) {
+        for (const event of events) channel._queuedNativeEvents.push(event);
+        return;
+      }
+      if (channel._dispatchNativeMessageBatch(events)) return;
+      channel._queueMessageEvents(events);
+      return;
+    }
+
+    const pending = this._pendingNativeDataChannelEvents.get(channelId) || [];
+    for (const event of events) pending.push(event);
+    this._pendingNativeDataChannelEvents.set(channelId, pending);
+  }
+
   _registerDataChannelId(channel, id = channel._effectiveId()) {
     if (id == null) return;
     if (channel._registeredDataChannelId === id) return;
@@ -3980,10 +4230,22 @@ class RTCPeerConnection extends SimpleEventTarget {
   }
 
   _isDataChannelIdInUse(id) {
-    for (const channel of this._channels.values()) {
-      this._registerDataChannelId(channel, channel._effectiveId());
+    let channel = this._usedDataChannelIds.get(id);
+    if (channel && channel.readyState !== "closed") return true;
+    if (!this._dataChannelIdRefreshNeeded) return false;
+
+    let refreshStillNeeded = false;
+    for (const currentChannel of this._channels.values()) {
+      if (currentChannel.readyState === "closed") continue;
+      const effectiveId = currentChannel._effectiveId();
+      if (effectiveId == null) {
+        refreshStillNeeded = true;
+        continue;
+      }
+      this._registerDataChannelId(currentChannel, effectiveId);
     }
-    const channel = this._usedDataChannelIds.get(id);
+    this._dataChannelIdRefreshNeeded = refreshStillNeeded;
+    channel = this._usedDataChannelIds.get(id);
     return Boolean(channel && channel.readyState !== "closed");
   }
 
@@ -4069,6 +4331,7 @@ class RTCPeerConnection extends SimpleEventTarget {
       const events = this._pendingDataChannelEvents.splice(0);
       for (const event of events) {
         if (this._closed) return;
+        event.channel._gateMessageEventsUntilConsumer();
         this.dispatchEvent(event);
         event.channel._announcementPending = false;
         event.channel._announceOpenAfterDataChannelEvent();