werift 0.22.8 → 0.22.9

package/lib/index.mjs

@@ -229,6 +229,105 @@ var BitStream = class {
   }
 };
 
+// ../common/src/crc.ts
+var POLY_CRC32 = 3988292384;
+var POLY_CRC32C = 2197175160;
+function isBufferLike(input) {
+  return typeof input !== "string";
+}
+function generateCRCTable(polynomial) {
+  const table = new Array(256);
+  let c = 0;
+  for (let n = 0; n < 256; ++n) {
+    c = n;
+    c = c & 1 ? polynomial ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? polynomial ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? polynomial ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? polynomial ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? polynomial ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? polynomial ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? polynomial ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? polynomial ^ c >>> 1 : c >>> 1;
+    table[n] = c;
+  }
+  return new Int32Array(table);
+}
+function generateSliceBy16Tables(table0) {
+  const table = new Int32Array(4096);
+  let c = 0;
+  let v = 0;
+  let n = 0;
+  for (n = 0; n < 256; ++n) table[n] = table0[n];
+  for (n = 0; n < 256; ++n) {
+    v = table0[n];
+    for (c = 256 + n; c < 4096; c += 256) {
+      v = table[c] = v >>> 8 ^ table0[v & 255];
+    }
+  }
+  const out = [];
+  for (n = 1; n < 16; ++n) {
+    out[n - 1] = table.subarray(n * 256, n * 256 + 256);
+  }
+  return out;
+}
+function crcGenericString(value, seed, table0) {
+  let crc = seed ^ -1;
+  let i = 0;
+  const len = value.length;
+  let c = 0;
+  let d = 0;
+  while (i < len) {
+    c = value.charCodeAt(i++);
+    if (c < 128) {
+      crc = crc >>> 8 ^ table0[(crc ^ c) & 255];
+    } else if (c < 2048) {
+      crc = crc >>> 8 ^ table0[(crc ^ (192 | c >> 6 & 31)) & 255];
+      crc = crc >>> 8 ^ table0[(crc ^ (128 | c & 63)) & 255];
+    } else if (c >= 55296 && c < 57344) {
+      c = (c & 1023) + 64;
+      d = value.charCodeAt(i++) & 1023;
+      crc = crc >>> 8 ^ table0[(crc ^ (240 | c >> 8 & 7)) & 255];
+      crc = crc >>> 8 ^ table0[(crc ^ (128 | c >> 2 & 63)) & 255];
+      crc = crc >>> 8 ^ table0[(crc ^ (128 | d >> 6 & 15 | (c & 3) << 4)) & 255];
+      crc = crc >>> 8 ^ table0[(crc ^ (128 | d & 63)) & 255];
+    } else {
+      crc = crc >>> 8 ^ table0[(crc ^ (224 | c >> 12 & 15)) & 255];
+      crc = crc >>> 8 ^ table0[(crc ^ (128 | c >> 6 & 63)) & 255];
+      crc = crc >>> 8 ^ table0[(crc ^ (128 | c & 63)) & 255];
+    }
+  }
+  return ~crc >>> 0;
+}
+function crcBuffer(value, seed, table0, tables16) {
+  const [t1, t2, t3, t4, t5, t6, t7, t8, t9, ta, tb, tc, td, te, tf] = tables16;
+  let crc = seed ^ -1;
+  let i = 0;
+  let len = value.length - 15;
+  while (i < len) {
+    crc = tf[value[i++] ^ crc & 255] ^ te[value[i++] ^ crc >>> 8 & 255] ^ td[value[i++] ^ crc >>> 16 & 255] ^ tc[value[i++] ^ crc >>> 24] ^ tb[value[i++]] ^ ta[value[i++]] ^ t9[value[i++]] ^ t8[value[i++]] ^ t7[value[i++]] ^ t6[value[i++]] ^ t5[value[i++]] ^ t4[value[i++]] ^ t3[value[i++]] ^ t2[value[i++]] ^ t1[value[i++]] ^ table0[value[i++]];
+  }
+  for (len += 15; i < len; ) {
+    crc = crc >>> 8 ^ table0[(crc ^ value[i++]) & 255];
+  }
+  return ~crc >>> 0;
+}
+var table32 = generateCRCTable(POLY_CRC32);
+var tables32By16 = generateSliceBy16Tables(table32);
+var table32c = generateCRCTable(POLY_CRC32C);
+var tables32cBy16 = generateSliceBy16Tables(table32c);
+function crc32(input, seed = 0) {
+  if (isBufferLike(input)) {
+    return crcBuffer(input, seed, table32, tables32By16);
+  }
+  return crcGenericString(input, seed, table32);
+}
+function crc32c(input, seed = 0) {
+  if (isBufferLike(input)) {
+    return crcBuffer(input, seed, table32c, tables32cBy16);
+  }
+  return crcGenericString(input, seed, table32c);
+}
+
 // ../common/src/number.ts
 function uint8Add(a, b) {
   return a + b & 255;
@@ -6320,7 +6419,6 @@ var methods = /* @__PURE__ */ ((methods2) => {
 
 // ../ice/src/stun/message.ts
 import { createHmac as createHmac4 } from "crypto";
-import crc32 from "buffer-crc32";
 
 // ../ice/src/helper.ts
 import { randomBytes as randomBytes5 } from "crypto";
@@ -6330,19 +6428,6 @@ function randomString(length) {
 function randomTransactionId() {
   return randomBytes5(12);
 }
-function bufferXor2(a, b) {
-  if (a.length !== b.length) {
-    throw new TypeError(
-      "[webrtc-stun] You can not XOR buffers which length are different"
-    );
-  }
-  const length = a.length;
-  const buffer2 = Buffer.allocUnsafe(length);
-  for (let i = 0; i < length; i++) {
-    buffer2[i] = a[i] ^ b[i];
-  }
-  return buffer2;
-}
 var PQueue = class {
   queue = [];
   wait = new Event();
@@ -6676,11 +6761,7 @@ function messageFingerprint(data) {
     data,
     data.length - HEADER_LENGTH + FINGERPRINT_LENGTH
   );
-  const crc32Buf = crc32(checkData);
-  const xorBuf = Buffer.alloc(4);
-  xorBuf.writeInt32BE(FINGERPRINT_XOR, 0);
-  const fingerprint2 = bufferXor2(crc32Buf, xorBuf);
-  return fingerprint2.readUInt32BE(0);
+  return (crc32(checkData) ^ FINGERPRINT_XOR) >>> 0;
 }
 function messageIntegrity(data, key) {
   const checkData = setBodyLength(
@@ -10173,7 +10254,6 @@ import { createHmac as createHmac5, randomBytes as randomBytes7 } from "crypto";
 import { jspack as jspack5 } from "@shinyoshiaki/jspack";
 
 // ../sctp/src/chunk.ts
-import crc32c from "turbo-crc32/crc32c.js";
 var Chunk = class _Chunk {
   constructor(flags = 0, _body = Buffer.from("")) {
     this.flags = flags;
@@ -10737,6 +10817,8 @@ var SCTP_RTO_INITIAL = 3;
 var SCTP_RTO_MIN = 1;
 var SCTP_RTO_MAX = 60;
 var SCTP_TSN_MODULO = 2 ** 32;
+var SCTP_SACK_DELAY_MS = 200;
+var SCTP_HEARTBEAT_INTERVAL = 30;
 var RECONFIG_MAX_STREAMS = 135;
 var SCTP_STATE_COOKIE = 7;
 var SCTP_SUPPORTED_CHUNK_EXT = 32776;
@@ -10768,6 +10850,8 @@ var SCTP = class _SCTP {
   started = false;
   state = "new";
   isServer = true;
+  isStopping = false;
+  isClosed = false;
   hmacKey = randomBytes7(16);
   localPartialReliability = true;
   localPort;
@@ -10779,6 +10863,10 @@ var SCTP = class _SCTP {
   // inbound
   advertisedRwnd = 1024 * 1024;
   // Receiver Window
+  peerAdvertisedRwnd = this.advertisedRwnd;
+  get peerRwnd() {
+    return Math.max(0, this.peerAdvertisedRwnd - this.flightSize);
+  }
   inboundStreams = {};
   _inboundStreamsCount = 0;
   _inboundStreamsMax = MAX_STREAMS;
@@ -10787,6 +10875,9 @@ var SCTP = class _SCTP {
   sackDuplicates = [];
   sackMisOrdered = /* @__PURE__ */ new Set();
   sackNeeded = false;
+  sackPacketCount = 0;
+  sackHasNewDataInPacket = false;
+  sackImmediate = false;
   sackTimeout;
   // # outbound
   cwnd = 3 * USERDATA_MAX_LENGTH;
@@ -10805,6 +10896,8 @@ var SCTP = class _SCTP {
   // acknowledgement
   partialBytesAcked = 0;
   sentQueue = [];
+  transmitting = false;
+  transmitRequested = false;
   // # reconfiguration
   /**初期TSNと同じ値に初期化される単調に増加する数です. これは、新しいre-configuration requestパラメーターを送信するたびに1ずつ増加します */
   reconfigRequestSeq = this.localTsn;
@@ -10830,8 +10923,13 @@ var SCTP = class _SCTP {
   /**Re-configuration Timer */
   timerReconfigHandle;
   timerReconfigFailures = 0;
+  timerHeartbeatHandle;
+  heartbeatInterval = SCTP_HEARTBEAT_INTERVAL;
   // etc
   ssthresh;
+  get isStopped() {
+    return this.isStopping || this.isClosed;
+  }
   get maxChannels() {
     if (this._inboundStreamsCount > 0) {
       return Math.min(this._inboundStreamsCount, this._outboundStreamsCount);
@@ -10850,6 +10948,7 @@ var SCTP = class _SCTP {
   }
   // call from dtls transport
   async handleData(data) {
+    if (this.isStopped) return;
     let expectedTag;
     const [, , verificationTag, chunks] = parsePacket2(data);
     const initChunk = chunks.filter((v) => v.type === InitChunk.type).length;
@@ -10864,17 +10963,41 @@ var SCTP = class _SCTP {
     if (verificationTag !== expectedTag) {
       return;
     }
+    this.sackHasNewDataInPacket = false;
     for (const chunk of chunks) {
       await this.receiveChunk(chunk);
     }
     if (this.sackNeeded) {
+      if (this.sackHasNewDataInPacket) {
+        this.sackPacketCount++;
+      }
+      if (this.sackPacketCount >= 2) {
+        this.sackImmediate = true;
+      }
+      await this.scheduleSack();
+    }
+  }
+  async scheduleSack() {
+    if (this.isStopped) return;
+    if (!this.sackNeeded) return;
+    if (this.sackImmediate) {
+      if (this.sackTimeout) {
+        clearTimeout(this.sackTimeout);
+        this.sackTimeout = void 0;
+      }
       await this.sendSack();
+      return;
     }
+    if (this.sackTimeout) return;
+    this.sackTimeout = setTimeout(() => {
+      this.sackTimeout = void 0;
+      this.sendSack().catch((err5) => {
+        log29("send delayed sack failed", err5.message);
+      });
+    }, SCTP_SACK_DELAY_MS);
   }
   async sendSack() {
-    if (this.sackTimeout) return;
-    await new Promise((r) => this.sackTimeout = setImmediate(r));
-    this.sackTimeout = void 0;
+    if (this.isStopped) return;
     if (!this.sackNeeded) return;
     const gaps = [];
     let gapNext;
@@ -10897,6 +11020,8 @@ var SCTP = class _SCTP {
     });
     this.sackDuplicates = [];
     this.sackNeeded = false;
+    this.sackPacketCount = 0;
+    this.sackImmediate = false;
   }
   async receiveChunk(chunk) {
     switch (chunk.type) {
@@ -10914,6 +11039,7 @@ var SCTP = class _SCTP {
           this.reconfigResponseSeq = tsnMinusOne(init.initialTsn);
           this.remoteVerificationTag = init.initiateTag;
           this.ssthresh = init.advertisedRwnd;
+          this.peerAdvertisedRwnd = init.advertisedRwnd;
           this.getExtensions(init.params);
           this._inboundStreamsCount = Math.min(
             init.outboundStreams,
@@ -10952,6 +11078,7 @@ var SCTP = class _SCTP {
           this.reconfigResponseSeq = tsnMinusOne(initAck.initialTsn);
           this.remoteVerificationTag = initAck.initiateTag;
           this.ssthresh = initAck.advertisedRwnd;
+          this.peerAdvertisedRwnd = initAck.advertisedRwnd;
           this.getExtensions(initAck.params);
           this._inboundStreamsCount = Math.min(
             initAck.outboundStreams,
@@ -11149,7 +11276,18 @@ var SCTP = class _SCTP {
   }
   receiveDataChunk(chunk) {
     this.sackNeeded = true;
-    if (this.markReceived(chunk.tsn)) return;
+    if (this.markReceived(chunk.tsn)) {
+      this.sackImmediate = true;
+      return;
+    }
+    this.sackHasNewDataInPacket = true;
+    this.sackImmediate = true;
+    if ((chunk.flags & SCTP_DATA_LAST_FRAG) === 0) {
+      this.sackImmediate = true;
+    }
+    if (this.sackMisOrdered.size > 0) {
+      this.sackImmediate = true;
+    }
     const inboundStream = this.getInboundStream(chunk.streamId);
     inboundStream.addChunk(chunk);
     this.advertisedRwnd -= chunk.userData.length;
@@ -11248,12 +11386,14 @@ var SCTP = class _SCTP {
     } else if (done > 0) {
       this.timer3Restart();
     }
+    this.peerAdvertisedRwnd = chunk.advertisedRwnd;
     this.updateAdvancedPeerAckPoint();
     await this.onSackReceived();
     await this.transmit();
   }
   receiveForwardTsnChunk(chunk) {
     this.sackNeeded = true;
+    this.sackImmediate = true;
     if (uint32Gte(this.lastReceivedTsn, chunk.cumulativeTsn)) {
       return;
     }
@@ -11360,17 +11500,29 @@ var SCTP = class _SCTP {
     if (ordered) {
       this.outboundStreamSeq[streamId] = uint16Add(streamSeqNum, 1);
     }
-    if (!this.timer3Handle) {
-      await this.transmit();
-    } else {
-      if (this.outboundQueue.length) {
-        await this.flush.asPromise();
-      } else {
-        await new Promise((r) => setImmediate(r));
-      }
+    await this.transmit();
+    while (this.outboundQueue.length) {
+      await this.flush.asPromise();
     }
   };
   async transmit() {
+    if (this.isStopped) return;
+    if (this.transmitting) {
+      this.transmitRequested = true;
+      return;
+    }
+    this.transmitting = true;
+    try {
+      do {
+        this.transmitRequested = false;
+        await this.transmitOnce();
+      } while (this.transmitRequested);
+    } finally {
+      this.transmitting = false;
+    }
+  }
+  async transmitOnce() {
+    if (this.isStopped) return;
     if (this.forwardTsnChunk) {
       await this.sendChunk(this.forwardTsnChunk).catch((err5) => {
         log29("send forwardTsn failed", err5.message);
@@ -11388,7 +11540,7 @@ var SCTP = class _SCTP {
         if (this.fastRecoveryTransmit) {
           this.fastRecoveryTransmit = false;
         } else if (this.flightSize >= cwnd) {
-          return;
+          break;
         }
         this.flightSizeIncrease(dataChunk);
         dataChunk.misses = 0;
@@ -11403,9 +11555,13 @@ var SCTP = class _SCTP {
       }
       retransmitEarliest = false;
     }
-    while (this.outboundQueue.length > 0) {
+    while (this.outboundQueue.length > 0 && this.flightSize < cwnd && this.peerRwnd > 0) {
       const chunk = this.outboundQueue.shift();
-      if (!chunk) return;
+      if (!chunk) break;
+      if (chunk.bookSize > this.peerRwnd && this.flightSize > 0) {
+        this.outboundQueue.unshift(chunk);
+        break;
+      }
       this.sentQueue.push(chunk);
       this.flightSizeIncrease(chunk);
       chunk.sentCount++;
@@ -11417,7 +11573,9 @@ var SCTP = class _SCTP {
         this.timer3Start();
       }
     }
-    this.outboundQueue = [];
+    if (!this.outboundQueue.length) {
+      this.outboundQueue = [];
+    }
     this.flush.execute();
   }
   async transmitReconfigRequest() {
@@ -11470,16 +11628,19 @@ var SCTP = class _SCTP {
     this.timer1Handle = setTimeout(this.timer1Expired, this.rto * 1e3);
   }
   timer1Expired = () => {
+    if (this.isStopped) return;
     this.timer1Failures++;
     this.timer1Handle = void 0;
     if (this.timer1Failures > SCTP_MAX_INIT_RETRANS) {
       this.setState(1 /* CLOSED */);
     } else {
       setImmediate(() => {
+        if (this.isStopped) return;
         this.sendChunk(this.timer1Chunk).catch((err5) => {
           log29("send timer1 chunk failed", err5.message);
         });
       });
+      if (this.isStopped) return;
       this.timer1Handle = setTimeout(this.timer1Expired, this.rto * 1e3);
     }
   };
@@ -11498,16 +11659,19 @@ var SCTP = class _SCTP {
     this.timer2Handle = setTimeout(this.timer2Expired, this.rto * 1e3);
   }
   timer2Expired = () => {
+    if (this.isStopped) return;
     this.timer2Failures++;
     this.timer2Handle = void 0;
     if (this.timer2Failures > SCTP_MAX_ASSOCIATION_RETRANS) {
       this.setState(1 /* CLOSED */);
     } else {
       setImmediate(() => {
+        if (this.isStopped) return;
         this.sendChunk(this.timer2Chunk).catch((err5) => {
           log29("send timer2Chunk failed", err5.message);
         });
       });
+      if (this.isStopped) return;
       this.timer2Handle = setTimeout(this.timer2Expired, this.rto * 1e3);
     }
   };
@@ -11520,14 +11684,17 @@ var SCTP = class _SCTP {
   }
   /**t3 is wait for data sack */
   timer3Start() {
+    if (this.isStopped) return;
     if (this.timer3Handle) throw new Error();
     this.timer3Handle = setTimeout(this.timer3Expired, this.rto * 1e3);
   }
   timer3Restart() {
+    if (this.isStopped) return;
     this.timer3Cancel();
-    this.timer3Handle = setTimeout(this.timer3Expired, this.rto);
+    this.timer3Handle = setTimeout(this.timer3Expired, this.rto * 1e3);
   }
   timer3Expired = () => {
+    if (this.isStopped) return;
     this.timer3Handle = void 0;
     this.sentQueue.forEach((chunk) => {
       if (!this.maybeAbandon(chunk)) {
@@ -11553,6 +11720,7 @@ var SCTP = class _SCTP {
   }
   /**Re-configuration Timer */
   timerReconfigHandleStart() {
+    if (this.isStopped) return;
     if (this.timerReconfigHandle) return;
     log29("timerReconfigHandleStart", { rto: this.rto });
     this.timerReconfigFailures = 0;
@@ -11562,6 +11730,7 @@ var SCTP = class _SCTP {
     );
   }
   timerReconfigHandleExpired = async () => {
+    if (this.isStopped) return;
     this.timerReconfigFailures++;
     this.rto = Math.ceil(this.rto * 1.5);
     if (this.timerReconfigFailures > SCTP_MAX_ASSOCIATION_RETRANS) {
@@ -11571,6 +11740,7 @@ var SCTP = class _SCTP {
     } else if (this.reconfigRequest) {
       log29("timerReconfigHandleExpired", this.timerReconfigFailures, this.rto);
       await this.sendReconfigParam(this.reconfigRequest);
+      if (this.isStopped) return;
       this.timerReconfigHandle = setTimeout(
         this.timerReconfigHandleExpired,
         this.rto * 1e3
@@ -11585,6 +11755,47 @@ var SCTP = class _SCTP {
       this.timerReconfigFailures = 0;
     }
   }
+  heartbeatStart() {
+    if (this.timerHeartbeatHandle || this.associationState !== 4 /* ESTABLISHED */) {
+      return;
+    }
+    this.timerHeartbeatHandle = setTimeout(
+      this.timerHeartbeatExpired,
+      (this.rto + this.heartbeatInterval) * 1e3
+    );
+  }
+  heartbeatRestart() {
+    this.heartbeatCancel();
+    this.heartbeatStart();
+  }
+  heartbeatCancel() {
+    if (this.timerHeartbeatHandle) {
+      clearTimeout(this.timerHeartbeatHandle);
+      this.timerHeartbeatHandle = void 0;
+    }
+  }
+  timerHeartbeatExpired = async () => {
+    this.timerHeartbeatHandle = void 0;
+    if (this.associationState !== 4 /* ESTABLISHED */) return;
+    if (this.flightSize === 0 && this.outboundQueue.length === 0) {
+      const heartbeat = new HeartbeatChunk();
+      heartbeat.params.push([
+        1,
+        Buffer.from(jspack5.Pack("!L", [Math.floor(Date.now() / 1e3)]))
+      ]);
+      await this.sendChunk(heartbeat).catch((err5) => {
+        log29("send heartbeat failed", err5.message);
+      });
+    }
+    this.heartbeatStart();
+  };
+  setHeartbeatInterval(interval) {
+    if (interval <= 0) {
+      throw new Error("heartbeat interval must be > 0");
+    }
+    this.heartbeatInterval = interval;
+    this.heartbeatRestart();
+  }
   updateAdvancedPeerAckPoint() {
     if (uint32Gt(this.lastSackedTsn, this.advancedPeerAckTsn)) {
       this.advancedPeerAckTsn = this.lastSackedTsn;
@@ -11696,12 +11907,21 @@ var SCTP = class _SCTP {
       this.associationState = state;
     }
     if (state === 4 /* ESTABLISHED */) {
+      this.isStopping = false;
+      this.isClosed = false;
       this.setConnectionState("connected");
+      this.heartbeatStart();
     } else if (state === 1 /* CLOSED */) {
+      this.isClosed = true;
       this.timer1Cancel();
       this.timer2Cancel();
       this.timer3Cancel();
       this.timerReconfigCancel();
+      this.heartbeatCancel();
+      if (this.sackTimeout) {
+        clearTimeout(this.sackTimeout);
+        this.sackTimeout = void 0;
+      }
       this.setConnectionState("closed");
       this.removeAllListeners();
     }
@@ -11712,6 +11932,16 @@ var SCTP = class _SCTP {
     this.stateChanged[state].execute();
   }
   async stop() {
+    if (this.isStopped) {
+      this.setState(1 /* CLOSED */);
+      return;
+    }
+    this.isStopping = true;
+    this.transport.onData = void 0;
+    if (this.sackTimeout) {
+      clearTimeout(this.sackTimeout);
+      this.sackTimeout = void 0;
+    }
     if (this.associationState !== 1 /* CLOSED */) {
       await this.abort();
     }
@@ -11720,6 +11950,8 @@ var SCTP = class _SCTP {
     clearTimeout(this.timer2Handle);
     clearTimeout(this.timer3Handle);
     clearTimeout(this.timerReconfigHandle);
+    clearTimeout(this.timerHeartbeatHandle);
+    clearTimeout(this.sackTimeout);
   }
   async abort() {
     const abort = new AbortChunk();
@@ -12045,7 +12277,6 @@ var RTCSctpTransport = class {
   }
   async dataChannelFlush() {
     if (this.sctp.associationState != 4 /* ESTABLISHED */) return;
-    if (this.sctp.outboundQueue.length > 0) return;
     while (this.dataChannelQueue.length > 0) {
       const [channel, protocol, userData] = this.dataChannelQueue.shift();
       let streamId = channel.id;
@@ -15680,6 +15911,8 @@ export {
   codecParametersFromString,
   codecParametersToString,
   compactNtp,
+  crc32,
+  crc32c,
   createBufferWriter,
   createSelfSignedCertificate,
   createStunOverTurnClient,