werift 0.24.3 → 0.24.4

package/lib/index.mjs

@@ -517,7 +517,7 @@ var Event2 = class {
   };
   allUnsubscribe = () => {
     if (this.ended) {
-      throw new Error("event completed");
+      return;
     }
     this.event = {
       stack: [],
@@ -7928,6 +7928,12 @@ var UDP_TRANSPORT = 285212672;
 function isStreamTransport(transport) {
   return transport.type === "tcp" || transport.type === "tls";
 }
+function permissionKey(addr) {
+  return addr[0];
+}
+function channelKey(addr) {
+  return JSON.stringify(addr);
+}
 var StunOverTurnProtocol = class _StunOverTurnProtocol {
   constructor(turn) {
     this.turn = turn;
@@ -8030,11 +8036,24 @@ var TurnProtocol = class _TurnProtocol {
   addrByChannel = {};
   /**sec */
   channelRefreshTime;
-  channelBinding;
-  channelRefreshAt = 0;
+  /**
+   * Serializes ChannelBind requests so allocation-wide auth state
+   * (nonce/realm/integrityKey) is not updated concurrently. Rejections
+   * must not poison this tail — see channelBindQueue assignment sites.
+   */
+  channelBindQueue = Promise.resolve();
+  /** In-flight ChannelBind per peer transport address (dedupe concurrent). */
+  channelBindingByAddr = /* @__PURE__ */ new Map();
   tcpBuffer = Buffer.alloc(0);
+  /** Permission cache keyed by peer IP only (RFC 8656). */
   permissionByAddr = {};
-  creatingPermission = Promise.resolve();
+  /**
+   * Serializes CreatePermission requests (auth state race avoidance).
+   * Rejections must not poison this tail.
+   */
+  permissionQueue = Promise.resolve();
+  /** In-flight CreatePermission per peer IP (dedupe concurrent). */
+  creatingPermissionByAddr = /* @__PURE__ */ new Map();
   async connectionMade() {
     this.transport.onData = (data, addr) => {
       this.dataReceived(data, addr);
@@ -8119,10 +8138,7 @@ var TurnProtocol = class _TurnProtocol {
   async createPermission(peerAddress) {
     const request = new Message(8 /* CREATE_PERMISSION */, 0 /* REQUEST */);
     request.setAttribute("XOR-PEER-ADDRESS", peerAddress).setAttribute("USERNAME", this.username).setAttribute("REALM", this.realm).setAttribute("NONCE", this.nonce);
-    await this.request(request, this.server).catch((e) => {
-      request;
-      throw e;
-    });
+    await this.requestWithRetry(request, this.server);
   }
   refresh = (exp) => {
     this.refreshHandle = cancelable(async (_, __, onCancel) => {
@@ -8202,10 +8218,13 @@ var TurnProtocol = class _TurnProtocol {
     return [message, address];
   }
   async sendData(data, addr) {
-    const channel = await this.getChannel(addr).catch((e) => {
-      return new Error("channelBind error");
-    });
-    if (channel instanceof Error) {
+    let channel;
+    try {
+      channel = await this.getChannel(addr);
+    } catch (e) {
+      log21("channelBind error; falling back to Send Indication", e);
+    }
+    if (!channel) {
       await this.getPermission(addr);
       const indicate = new Message(6 /* SEND */, 16 /* INDICATION */).setAttribute("DATA", data).setAttribute("XOR-PEER-ADDRESS", addr);
       await this.sendStun(indicate, this.server);
@@ -8213,49 +8232,111 @@ var TurnProtocol = class _TurnProtocol {
     }
     await this.send(encodeChannelData(channel.number, data), this.server);
   }
+  /**
+   * Ensure a CreatePermission exists for the peer IP.
+   * Peer failures are isolated: a rejection for peer A does not poison peer B.
+   */
   async getPermission(addr) {
-    await this.creatingPermission;
-    const permitted = this.permissionByAddr[addr.join(":")];
-    if (!permitted) {
-      this.creatingPermission = this.createPermission(addr);
-      this.permissionByAddr[addr.join(":")] = true;
-      await this.creatingPermission.catch((e) => {
-        log21("createPermission error", e);
-        throw e;
-      });
+    const key = permissionKey(addr);
+    if (this.permissionByAddr[key]) {
+      return;
+    }
+    const existing = this.creatingPermissionByAddr.get(key);
+    if (existing) {
+      return existing;
+    }
+    const operation = this.permissionQueue.then(async () => {
+      if (this.permissionByAddr[key]) {
+        return;
+      }
+      await this.createPermission(addr);
+      this.permissionByAddr[key] = true;
+    });
+    this.permissionQueue = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    this.creatingPermissionByAddr.set(key, operation);
+    try {
+      await operation;
+    } catch (error) {
+      log21("createPermission error", error);
+      throw error;
+    } finally {
+      if (this.creatingPermissionByAddr.get(key) === operation) {
+        this.creatingPermissionByAddr.delete(key);
+      }
     }
   }
+  /**
+   * Ensure a ChannelBind exists for the peer transport address.
+   * Peer failures are isolated; concurrent same-peer calls share one Promise.
+   */
   async getChannel(addr) {
-    if (this.channelBinding) {
-      await this.channelBinding;
+    const key = channelKey(addr);
+    const existing = this.channelBindingByAddr.get(key);
+    if (existing) {
+      return existing;
+    }
+    const cached = this.channelByAddr[key];
+    const now = int(Date.now() / 1e3);
+    if (cached && cached.refreshAt > now) {
+      return cached;
     }
-    let channel = this.channelByAddr[addr.join(":")];
+    const operation = this.channelBindQueue.then(
+      () => this.ensureChannel(addr)
+    );
+    this.channelBindQueue = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    this.channelBindingByAddr.set(key, operation);
+    try {
+      return await operation;
+    } catch (error) {
+      log21("channelBind error", error);
+      throw error;
+    } finally {
+      if (this.channelBindingByAddr.get(key) === operation) {
+        this.channelBindingByAddr.delete(key);
+      }
+    }
+  }
+  /**
+   * Create or refresh a channel for addr. Provisional mapping is installed
+   * before the request so early ChannelData can be decoded; only a failed
+   * *initial* bind rolls the mapping back. Failed channel numbers are never
+   * reused.
+   */
+  async ensureChannel(addr) {
+    const key = channelKey(addr);
+    const now = int(Date.now() / 1e3);
+    let channel = this.channelByAddr[key];
+    if (channel && channel.refreshAt > now) {
+      return channel;
+    }
+    const isNew = !channel;
     if (!channel) {
-      this.channelByAddr[addr.join(":")] = {
+      channel = {
         number: this.channelNumber++,
-        address: addr
+        address: addr,
+        refreshAt: 0
       };
-      channel = this.channelByAddr[addr.join(":")];
+      this.channelByAddr[key] = channel;
       this.addrByChannel[channel.number] = addr;
-      this.channelBinding = this.channelBind(channel.number, addr);
-      await this.channelBinding.catch((e) => {
-        log21("channelBind error", e);
-        throw e;
-      });
-      this.channelRefreshAt = int(Date.now() / 1e3) + this.channelRefreshTime;
-      this.channelBinding = void 0;
-      log21("channelBind", channel);
-    } else if (this.channelRefreshAt < int(Date.now() / 1e3)) {
-      this.channelBinding = this.channelBind(channel.number, addr);
-      this.channelRefreshAt = int(Date.now() / 1e3) + this.channelRefreshTime;
-      await this.channelBinding.catch((e) => {
-        log21("channelBind error", e);
-        throw e;
-      });
-      this.channelBinding = void 0;
-      log21("channelBind refresh", channel);
     }
-    return channel;
+    try {
+      await this.channelBind(channel.number, addr);
+      channel.refreshAt = int(Date.now() / 1e3) + this.channelRefreshTime;
+      log21(isNew ? "channelBind" : "channelBind refresh", channel);
+      return channel;
+    } catch (error) {
+      if (isNew) {
+        delete this.channelByAddr[key];
+        delete this.addrByChannel[channel.number];
+      }
+      throw error;
+    }
   }
   async channelBind(channelNumber, addr) {
     const request = new Message(9 /* CHANNEL_BIND */, 0 /* REQUEST */);
@@ -17883,15 +17964,27 @@ var RTCPeerConnection = class extends EventTarget {
     this.transceiverManager.close();
     await this.secureManager.close();
     await this.sctpManager.close();
-    this.onDataChannel.allUnsubscribe();
-    this.iceGatheringStateChange.allUnsubscribe();
-    this.iceConnectionStateChange.allUnsubscribe();
-    this.signalingStateChange.allUnsubscribe();
-    this.onTransceiverAdded.allUnsubscribe();
-    this.onRemoteTransceiverAdded.allUnsubscribe();
-    this.onIceCandidate.allUnsubscribe();
+    this.completePeerEvents();
     log37("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();
+      }
+    }
+  }
 };
 var findCodecByMimeType = (codecs, target) => codecs.find(
   (localCodec) => localCodec.mimeType.toLowerCase() === target.mimeType.toLowerCase()

package/lib/nonstandard/index.mjs

@@ -527,7 +527,7 @@ var Event2 = class {
   };
   allUnsubscribe = () => {
     if (this.ended) {
-      throw new Error("event completed");
+      return;
     }
     this.event = {
       stack: [],

package/lib/webrtc/src/peerConnection.d.ts

@@ -198,6 +198,7 @@ export declare class RTCPeerConnection extends EventTarget {
     private createPeerConnectionStats;
     getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
     close(): Promise<void>;
+    private completePeerEvents;
 }
 export type DebugConfig = Partial<{
     /**% */

package/lib/webrtc/src/peerConnection.js

@@ -1047,15 +1047,28 @@ class RTCPeerConnection extends helper_1.EventTarget {
         this.transceiverManager.close();
         await this.secureManager.close();
         await this.sctpManager.close();
-        this.onDataChannel.allUnsubscribe();
-        this.iceGatheringStateChange.allUnsubscribe();
-        this.iceConnectionStateChange.allUnsubscribe();
-        this.signalingStateChange.allUnsubscribe();
-        this.onTransceiverAdded.allUnsubscribe();
-        this.onRemoteTransceiverAdded.allUnsubscribe();
-        this.onIceCandidate.allUnsubscribe();
+        // 公開 Event を完了させ、購読者・クロージャが PeerConnection を保持し続けないようにする
+        this.completePeerEvents();
         log("peerConnection closed");
     }
+    completePeerEvents() {
+        const events = [
+            this.onDataChannel,
+            this.iceGatheringStateChange,
+            this.iceConnectionStateChange,
+            this.signalingStateChange,
+            this.connectionStateChange,
+            this.onTransceiverAdded,
+            this.onRemoteTransceiverAdded,
+            this.onIceCandidate,
+            this.onNegotiationneeded,
+        ];
+        for (const event of events) {
+            if (!event.ended) {
+                event.complete();
+            }
+        }
+    }
 }
 exports.RTCPeerConnection = RTCPeerConnection;
 const findCodecByMimeType = (codecs, target) => codecs.find((localCodec) => localCodec.mimeType.toLowerCase() === target.mimeType.toLowerCase())