livekit-client 2.15.16 → 2.16.1

package/src/room/RegionUrlProvider.test.ts

@@ -1,5 +1,5 @@
-import type { RegionInfo, RegionSettings } from '@livekit/protocol';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { RegionInfo, RegionSettings } from '@livekit/protocol';
 import { RegionUrlProvider } from './RegionUrlProvider';
 import { ConnectionError, ConnectionErrorReason } from './errors';
 
@@ -180,8 +180,9 @@ describe('RegionUrlProvider', () => {
       const provider = new RegionUrlProvider('wss://test.livekit.cloud', 'token');
       fetchMock.mockResolvedValue(createMockResponse(401));
 
-      await expect(provider.fetchRegionSettings()).rejects.toThrow(ConnectionError);
-      await expect(provider.fetchRegionSettings()).rejects.toMatchObject({
+      const error = await provider.fetchRegionSettings().catch((e) => e);
+      expect(error).toBeInstanceOf(ConnectionError);
+      expect(error).toMatchObject({
         reason: ConnectionErrorReason.NotAllowed,
         status: 401,
       });
@@ -191,11 +192,9 @@ describe('RegionUrlProvider', () => {
       const provider = new RegionUrlProvider('wss://test.livekit.cloud', 'token');
       fetchMock.mockResolvedValue(createMockResponse(500));
 
-      await expect(provider.fetchRegionSettings()).rejects.toThrow(ConnectionError);
-      await expect(provider.fetchRegionSettings()).rejects.toMatchObject({
-        reason: ConnectionErrorReason.InternalError,
-        status: 500,
-      });
+      const error = await provider.fetchRegionSettings().catch((e) => e);
+      expect(error).toBeInstanceOf(ConnectionError);
+      expect(error.reason).toBe(ConnectionErrorReason.InternalError);
     });
 
     it('extracts max-age from Cache-Control header', async () => {
@@ -725,7 +724,7 @@ describe('RegionUrlProvider', () => {
 
       expect(error).toBeInstanceOf(ConnectionError);
       expect(error.reason).toBe(ConnectionErrorReason.ServerUnreachable);
-      expect(error.status).toBe(500);
+      expect(error.status).toBe(undefined);
       expect(error.message).toContain('Failed to fetch');
     });
 
@@ -828,4 +827,179 @@ describe('RegionUrlProvider', () => {
       expect(region2).toBeNull(); // Filtered out because same URL was already attempted
     });
   });
+
+  describe('connection tracking and auto-refetch cleanup', () => {
+    beforeEach(() => {
+      // Reset connection tracking maps
+      // @ts-ignore - accessing private static field for testing
+      RegionUrlProvider.connectionTrackers = new Map();
+    });
+
+    it('stops auto-refetch 30s after last connection disconnects', async () => {
+      const provider = new RegionUrlProvider('wss://test.livekit.cloud', 'token');
+      const mockSettings = createMockRegionSettings([
+        { region: 'us-west', url: 'wss://us-west.livekit.cloud' },
+      ]);
+
+      fetchMock.mockResolvedValue(
+        createMockResponse(200, mockSettings, { 'Cache-Control': 'max-age=100' }),
+      );
+
+      // Initial fetch to start auto-refetch
+      await provider.getNextBestRegionUrl();
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+
+      const hostname = provider.getServerUrl().hostname;
+
+      // Simulate connection
+      provider.notifyConnected();
+
+      // Verify auto-refetch is running
+      const timersBeforeDisconnect = vi.getTimerCount();
+      expect(timersBeforeDisconnect).toBeGreaterThan(0);
+
+      // Simulate disconnect
+      provider.notifyDisconnected();
+
+      // Should schedule cleanup timeout (30s)
+      // Advance time by 29s - refetch should still be running
+      vi.advanceTimersByTime(29000);
+      expect(fetchMock).toHaveBeenCalledTimes(1); // No additional fetches
+
+      // Advance by 1 more second (total 30s) - cleanup should trigger
+      await vi.advanceTimersByTimeAsync(1000);
+
+      // Auto-refetch should be stopped, so no new timers for refetch
+      // @ts-ignore - accessing private static field for testing
+      const refetchTimeout = RegionUrlProvider.settingsTimeouts.get(hostname);
+      expect(refetchTimeout).toBeUndefined();
+    });
+
+    it('cancels cleanup when reconnecting before 30s delay', async () => {
+      const provider = new RegionUrlProvider('wss://test.livekit.cloud', 'token');
+      const mockSettings = createMockRegionSettings([
+        { region: 'us-west', url: 'wss://us-west.livekit.cloud' },
+      ]);
+
+      fetchMock.mockResolvedValue(
+        createMockResponse(200, mockSettings, { 'Cache-Control': 'max-age=100' }),
+      );
+
+      await provider.getNextBestRegionUrl();
+      const hostname = provider.getServerUrl().hostname;
+
+      // Connect and disconnect
+      provider.notifyConnected();
+      provider.notifyDisconnected();
+
+      // Advance time by 15s (less than 30s)
+      vi.advanceTimersByTime(15000);
+
+      // Reconnect before cleanup triggers
+      provider.notifyConnected();
+
+      // @ts-ignore - accessing private static field for testing
+      const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+      expect(tracker?.cleanupTimeout).toBeUndefined(); // Cleanup should be cancelled
+
+      // Advance past the original 30s mark
+      vi.advanceTimersByTime(20000);
+
+      // Auto-refetch should still be running
+      // @ts-ignore - accessing private static field for testing
+      const refetchTimeout = RegionUrlProvider.settingsTimeouts.get(hostname);
+      expect(refetchTimeout).toBeDefined();
+    });
+
+    it('tracks multiple connections correctly', async () => {
+      const provider = new RegionUrlProvider('wss://test.livekit.cloud', 'token');
+      const mockSettings = createMockRegionSettings([
+        { region: 'us-west', url: 'wss://us-west.livekit.cloud' },
+      ]);
+
+      fetchMock.mockResolvedValue(
+        createMockResponse(200, mockSettings, { 'Cache-Control': 'max-age=100' }),
+      );
+
+      await provider.getNextBestRegionUrl();
+      const hostname = provider.getServerUrl().hostname;
+
+      // Simulate 3 connections
+      provider.notifyConnected();
+      provider.notifyConnected();
+      provider.notifyConnected();
+
+      // @ts-ignore - accessing private static field for testing
+      const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+      expect(tracker?.connectionCount).toBe(3);
+
+      // Disconnect first connection
+      provider.notifyDisconnected();
+
+      // @ts-ignore - accessing private static field for testing
+      expect(tracker?.connectionCount).toBe(2);
+
+      // Should NOT schedule cleanup yet (still have active connections)
+      expect(tracker?.cleanupTimeout).toBeUndefined();
+
+      // Disconnect second connection
+      provider.notifyDisconnected();
+      // @ts-ignore - accessing private static field for testing
+      expect(tracker?.connectionCount).toBe(1);
+
+      // Disconnect last connection
+      provider.notifyDisconnected();
+      // @ts-ignore - accessing private static field for testing
+      expect(tracker?.connectionCount).toBe(0);
+
+      // NOW cleanup should be scheduled
+      expect(tracker?.cleanupTimeout).toBeDefined();
+    });
+
+    it('handles disconnect without prior connect gracefully', () => {
+      const provider = new RegionUrlProvider('wss://test.livekit.cloud', 'token');
+      const hostname = provider.getServerUrl().hostname;
+
+      // Disconnect without connect should not throw
+      expect(() => {
+        provider.notifyDisconnected();
+      }).not.toThrow();
+
+      // Should not create a tracker
+      // @ts-ignore - accessing private static field for testing
+      const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+      expect(tracker).toBeUndefined();
+    });
+
+    it('clears cleanup timeout when scheduling new cleanup', async () => {
+      const provider = new RegionUrlProvider('wss://test.livekit.cloud', 'token');
+      const mockSettings = createMockRegionSettings([
+        { region: 'us-west', url: 'wss://us-west.livekit.cloud' },
+      ]);
+
+      fetchMock.mockResolvedValue(
+        createMockResponse(200, mockSettings, { 'Cache-Control': 'max-age=100' }),
+      );
+
+      await provider.getNextBestRegionUrl();
+      const hostname = provider.getServerUrl().hostname;
+
+      // Connect and disconnect (schedules cleanup)
+      provider.notifyConnected();
+      provider.notifyDisconnected();
+
+      // @ts-ignore - accessing private static field for testing
+      const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+      const firstCleanupTimeout = tracker?.cleanupTimeout;
+      expect(firstCleanupTimeout).toBeDefined();
+
+      // Reconnect and disconnect again (should cancel first and schedule new)
+      provider.notifyConnected();
+      provider.notifyDisconnected();
+
+      const secondCleanupTimeout = tracker?.cleanupTimeout;
+      expect(secondCleanupTimeout).toBeDefined();
+      expect(secondCleanupTimeout).not.toBe(firstCleanupTimeout);
+    });
+  });
 });

package/src/room/RegionUrlProvider.ts

@@ -5,6 +5,7 @@ import { ConnectionError, ConnectionErrorReason } from './errors';
 import { extractMaxAgeFromRequestHeaders, isCloud } from './utils';
 
 export const DEFAULT_MAX_AGE_MS = 5_000;
+export const STOP_REFETCH_DELAY_MS = 30_000;
 
 type CachedRegionSettings = {
   regionSettings: RegionSettings;
@@ -12,11 +13,18 @@ type CachedRegionSettings = {
   maxAgeInMs: number;
 };
 
+type ConnectionTracker = {
+  connectionCount: number;
+  cleanupTimeout?: ReturnType<typeof setTimeout>;
+};
+
 export class RegionUrlProvider {
   private static readonly cache: Map<string, CachedRegionSettings> = new Map();
 
   private static settingsTimeouts: Map<string, ReturnType<typeof setTimeout>> = new Map();
 
+  private static connectionTrackers: Map<string, ConnectionTracker> = new Map();
+
   private static fetchLock = new Mutex();
 
   private static async fetchRegionSettings(
@@ -37,26 +45,27 @@ export class RegionUrlProvider {
         const regionSettings = (await regionSettingsResponse.json()) as RegionSettings;
         return { regionSettings, updatedAtInMs: Date.now(), maxAgeInMs };
       } else {
-        throw new ConnectionError(
-          `Could not fetch region settings: ${regionSettingsResponse.statusText}`,
-          regionSettingsResponse.status === 401
-            ? ConnectionErrorReason.NotAllowed
-            : ConnectionErrorReason.InternalError,
-          regionSettingsResponse.status,
-        );
+        if (regionSettingsResponse.status === 401) {
+          throw ConnectionError.notAllowed(
+            `Could not fetch region settings: ${regionSettingsResponse.statusText}`,
+            regionSettingsResponse.status,
+          );
+        } else {
+          throw ConnectionError.internal(
+            `Could not fetch region settings: ${regionSettingsResponse.statusText}`,
+          );
+        }
       }
     } catch (e: unknown) {
       if (e instanceof ConnectionError) {
         // rethrow connection errors
         throw e;
       } else if (signal?.aborted) {
-        throw new ConnectionError(`Region fetching was aborted`, ConnectionErrorReason.Cancelled);
+        throw ConnectionError.cancelled(`Region fetching was aborted`);
       } else {
-        // wrap other errors as connection errors (e.g. timeouts)
-        throw new ConnectionError(
+        // wrap other errors as connection errors
+        throw ConnectionError.serverUnreachable(
           `Could not fetch region settings, ${e instanceof Error ? `${e.name}: ${e.message}` : e}`,
-          ConnectionErrorReason.ServerUnreachable,
-          500, // using 500 as a catch-all manually set error code here
         );
       }
     } finally {
@@ -74,6 +83,13 @@ export class RegionUrlProvider {
           const newSettings = await RegionUrlProvider.fetchRegionSettings(url, token);
           RegionUrlProvider.updateCachedRegionSettings(url, token, newSettings);
         } catch (error: unknown) {
+          if (
+            error instanceof ConnectionError &&
+            error.reason === ConnectionErrorReason.NotAllowed
+          ) {
+            log.debug('token is not valid, cancelling auto region refresh');
+            return;
+          }
           log.debug('auto refetching of region settings failed', { error });
           // continue retrying with the same max age
           RegionUrlProvider.scheduleRefetch(url, token, maxAgeInMs);
@@ -91,6 +107,75 @@ export class RegionUrlProvider {
     RegionUrlProvider.scheduleRefetch(url, token, settings.maxAgeInMs);
   }
 
+  private static stopRefetch(hostname: string) {
+    const timeout = RegionUrlProvider.settingsTimeouts.get(hostname);
+    if (timeout) {
+      clearTimeout(timeout);
+      RegionUrlProvider.settingsTimeouts.delete(hostname);
+    }
+  }
+
+  private static scheduleCleanup(hostname: string) {
+    let tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+    if (!tracker) {
+      return;
+    }
+
+    // Cancel any existing cleanup timeout
+    if (tracker.cleanupTimeout) {
+      clearTimeout(tracker.cleanupTimeout);
+    }
+
+    // Schedule cleanup to stop refetch after delay
+    tracker.cleanupTimeout = setTimeout(() => {
+      const currentTracker = RegionUrlProvider.connectionTrackers.get(hostname);
+      if (currentTracker && currentTracker.connectionCount === 0) {
+        log.debug('stopping region refetch after disconnect delay', { hostname });
+        RegionUrlProvider.stopRefetch(hostname);
+      }
+      if (currentTracker) {
+        currentTracker.cleanupTimeout = undefined;
+      }
+    }, STOP_REFETCH_DELAY_MS);
+  }
+
+  private static cancelCleanup(hostname: string) {
+    const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+    if (tracker?.cleanupTimeout) {
+      clearTimeout(tracker.cleanupTimeout);
+      tracker.cleanupTimeout = undefined;
+    }
+  }
+
+  notifyConnected() {
+    const hostname = this.serverUrl.hostname;
+    let tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+    if (!tracker) {
+      tracker = { connectionCount: 0 };
+      RegionUrlProvider.connectionTrackers.set(hostname, tracker);
+    }
+
+    tracker.connectionCount++;
+
+    // Cancel any scheduled cleanup since we have an active connection
+    RegionUrlProvider.cancelCleanup(hostname);
+  }
+
+  notifyDisconnected() {
+    const hostname = this.serverUrl.hostname;
+    const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+    if (!tracker) {
+      return;
+    }
+
+    tracker.connectionCount = Math.max(0, tracker.connectionCount - 1);
+
+    // If no more connections, schedule cleanup
+    if (tracker.connectionCount === 0) {
+      RegionUrlProvider.scheduleCleanup(hostname);
+    }
+  }
+
   private serverUrl: URL;
 
   private token: string;

package/src/room/Room.ts

@@ -31,8 +31,9 @@ import {
   protoInt64,
 } from '@livekit/protocol';
 import { EventEmitter } from 'events';
-import type TypedEmitter from 'typed-emitter';
 import 'webrtc-adapter';
+import type TypedEmitter from 'typed-emitter';
+import { ensureTrailingSlash } from '../api/utils';
 import { EncryptionEvent } from '../e2ee';
 import { type BaseE2EEManager, E2EEManager } from '../e2ee/E2eeManager';
 import log, { LoggerNames, getLogger } from '../logger';
@@ -169,7 +170,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   private abortController?: AbortController;
 
   /** future holding client initiated connection attempt */
-  private connectFuture?: Future<void>;
+  private connectFuture?: Future<void, Error>;
 
   private disconnectLock: Mutex;
 
@@ -644,7 +645,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
 
     this.setAndEmitConnectionState(ConnectionState.Connecting);
-    if (this.regionUrlProvider?.getServerUrl().toString() !== url) {
+    if (this.regionUrlProvider?.getServerUrl().toString() !== ensureTrailingSlash(url)) {
       this.regionUrl = undefined;
       this.regionUrlProvider = undefined;
     }
@@ -686,7 +687,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       try {
         await BackOffStrategy.getInstance().getBackOffPromise(url);
         if (abortController.signal.aborted) {
-          throw new ConnectionError('Connection attempt aborted', ConnectionErrorReason.Cancelled);
+          throw ConnectionError.cancelled('Connection attempt aborted');
         }
         await this.attemptConnection(regionUrl ?? url, token, opts, abortController);
         this.abortController = undefined;
@@ -894,12 +895,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     } catch (err) {
       await this.engine.close();
       this.recreateEngine();
-      const resultingError = new ConnectionError(
-        `could not establish signal connection`,
-        abortController.signal.aborted
-          ? ConnectionErrorReason.Cancelled
-          : ConnectionErrorReason.ServerUnreachable,
-      );
+
+      const resultingError = abortController.signal.aborted
+        ? ConnectionError.cancelled('Signal connection aborted')
+        : ConnectionError.serverUnreachable('could not establish signal connection');
+
       if (err instanceof Error) {
         resultingError.message = `${resultingError.message}: ${err.message}`;
       }
@@ -917,7 +917,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (abortController.signal.aborted) {
       await this.engine.close();
       this.recreateEngine();
-      throw new ConnectionError(`Connection attempt aborted`, ConnectionErrorReason.Cancelled);
+      throw ConnectionError.cancelled(`Connection attempt aborted`);
     }
 
     try {
@@ -938,12 +938,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       window.addEventListener('beforeunload', this.onPageLeave);
     }
     if (isWeb()) {
-      document.addEventListener('freeze', this.onPageLeave);
+      window.addEventListener('freeze', this.onPageLeave);
     }
     this.setAndEmitConnectionState(ConnectionState.Connected);
     this.emit(RoomEvent.Connected);
     BackOffStrategy.getInstance().resetFailedConnectionAttempts(url);
     this.registerConnectionReconcile();
+
+    // Notify region provider about successful connection
+    if (this.regionUrlProvider) {
+      this.regionUrlProvider.notifyConnected();
+    }
   };
 
   /**
@@ -969,9 +974,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.log.warn(msg, this.logContext);
         this.abortController?.abort(msg);
         // in case the abort controller didn't manage to cancel the connection attempt, reject the connect promise explicitly
-        this.connectFuture?.reject?.(
-          new ConnectionError('Client initiated disconnect', ConnectionErrorReason.Cancelled),
-        );
+        this.connectFuture?.reject?.(ConnectionError.cancelled('Client initiated disconnect'));
         this.connectFuture = undefined;
       }
 
@@ -1557,6 +1560,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
     this.regionUrl = undefined;
 
+    // Notify region provider about disconnect to potentially stop auto-refetch
+    if (this.regionUrlProvider) {
+      this.regionUrlProvider.notifyDisconnected();
+    }
+
     try {
       this.remoteParticipants.forEach((p) => {
         p.trackPublications.forEach((pub) => {
@@ -1915,7 +1923,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       });
       if (byteLength(response) > MAX_PAYLOAD_BYTES) {
         responseError = RpcError.builtIn('RESPONSE_PAYLOAD_TOO_LARGE');
-        console.warn(`RPC Response payload too large for ${method}`);
+        this.log.warn(`RPC Response payload too large for ${method}`);
       } else {
         responsePayload = response;
       }
@@ -1923,7 +1931,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       if (error instanceof RpcError) {
         responseError = error;
       } else {
-        console.warn(
+        this.log.warn(
           `Uncaught error returned by RPC handler for ${method}. Returning APPLICATION_ERROR instead.`,
           error,
         );

package/src/room/data-stream/incoming/IncomingDataStreamManager.ts

@@ -121,7 +121,7 @@ export default class IncomingDataStreamManager {
       }
 
       let streamController: ReadableStreamDefaultController<DataStream_Chunk>;
-      const outOfBandFailureRejectingFuture = new Future<never>();
+      const outOfBandFailureRejectingFuture = new Future<never, Error>();
       outOfBandFailureRejectingFuture.promise.catch((err) => {
         this.log.error(err);
       });
@@ -178,7 +178,7 @@ export default class IncomingDataStreamManager {
       }
 
       let streamController: ReadableStreamDefaultController<DataStream_Chunk>;
-      const outOfBandFailureRejectingFuture = new Future<never>();
+      const outOfBandFailureRejectingFuture = new Future<never, Error>();
       outOfBandFailureRejectingFuture.promise.catch((err) => {
         this.log.error(err);
       });

package/src/room/data-stream/incoming/StreamReader.ts

@@ -17,7 +17,7 @@ abstract class BaseStreamReader<T extends BaseStreamInfo> {
 
   protected bytesReceived: number;
 
-  protected outOfBandFailureRejectingFuture?: Future<never>;
+  protected outOfBandFailureRejectingFuture?: Future<never, Error>;
 
   get info() {
     return this._info;
@@ -46,7 +46,7 @@ abstract class BaseStreamReader<T extends BaseStreamInfo> {
     info: T,
     stream: ReadableStream<DataStream_Chunk>,
     totalByteSize?: number,
-    outOfBandFailureRejectingFuture?: Future<never>,
+    outOfBandFailureRejectingFuture?: Future<never, Error>,
   ) {
     this.reader = stream;
     this.totalByteSize = totalByteSize;
@@ -80,7 +80,7 @@ export class ByteStreamReader extends BaseStreamReader<ByteStreamInfo> {
   [Symbol.asyncIterator]() {
     const reader = this.reader.getReader();
 
-    let rejectingSignalFuture = new Future<never>();
+    let rejectingSignalFuture = new Future<never, Error>();
     let activeSignal: AbortSignal | null = null;
     let onAbort: (() => void) | null = null;
     if (this.signal) {
@@ -175,7 +175,7 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
     info: TextStreamInfo,
     stream: ReadableStream<DataStream_Chunk>,
     totalChunkCount?: number,
-    outOfBandFailureRejectingFuture?: Future<never>,
+    outOfBandFailureRejectingFuture?: Future<never, Error>,
   ) {
     super(info, stream, totalChunkCount, outOfBandFailureRejectingFuture);
     this.receivedChunks = new Map();
@@ -213,7 +213,7 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
     const reader = this.reader.getReader();
     const decoder = new TextDecoder('utf-8', { fatal: true });
 
-    let rejectingSignalFuture = new Future<never>();
+    let rejectingSignalFuture = new Future<never, Error>();
     let activeSignal: AbortSignal | null = null;
     let onAbort: (() => void) | null = null;
     if (this.signal) {

package/src/room/data-stream/outgoing/OutgoingDataStreamManager.ts

@@ -93,7 +93,6 @@ export default class OutgoingDataStreamManager {
 
   /**
    * @internal
-   * @experimental CAUTION, might get removed in a minor release
    */
   async streamText(options?: StreamTextOptions): Promise<TextStreamWriter> {
     const streamId = options?.streamId ?? crypto.randomUUID();
@@ -146,7 +145,6 @@ export default class OutgoingDataStreamManager {
       // Implement the sink
       async write(text) {
         for (const textByteChunk of splitUtf8(text, STREAM_CHUNK_SIZE)) {
-          await engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
           const chunk = new DataStream_Chunk({
             content: textByteChunk,
             streamId,
@@ -278,7 +276,6 @@ export default class OutgoingDataStreamManager {
         try {
           while (byteOffset < chunk.byteLength) {
             const subChunk = chunk.slice(byteOffset, byteOffset + STREAM_CHUNK_SIZE);
-            await engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
             const chunkPacket = new DataPacket({
               destinationIdentities,
               value: {