livekit-client 2.15.8 → 2.15.10

package/src/api/WebSocketStream.ts

@@ -0,0 +1,118 @@
+// https://github.com/CarterLi/websocketstream-polyfill
+import { sleep } from '../room/utils';
+
+export interface WebSocketConnection<T extends ArrayBuffer | string = ArrayBuffer | string> {
+  readable: ReadableStream<T>;
+  writable: WritableStream<T>;
+  protocol: string;
+  extensions: string;
+}
+
+export interface WebSocketCloseInfo {
+  closeCode?: number;
+  reason?: string;
+}
+
+export interface WebSocketStreamOptions {
+  protocols?: string[];
+  signal?: AbortSignal;
+}
+
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+export class WebSocketStream<T extends ArrayBuffer | string = ArrayBuffer | string> {
+  readonly url: string;
+
+  readonly opened: Promise<WebSocketConnection<T>>;
+
+  readonly closed: Promise<WebSocketCloseInfo>;
+
+  readonly close: (closeInfo?: WebSocketCloseInfo) => void;
+
+  get readyState(): number {
+    return this.ws.readyState;
+  }
+
+  private ws: WebSocket;
+
+  constructor(url: string, options: WebSocketStreamOptions = {}) {
+    if (options.signal?.aborted) {
+      throw new DOMException('This operation was aborted', 'AbortError');
+    }
+
+    this.url = url;
+
+    const ws = new WebSocket(url, options.protocols ?? []);
+    ws.binaryType = 'arraybuffer';
+    this.ws = ws;
+
+    const closeWithInfo = ({ closeCode: code, reason }: WebSocketCloseInfo = {}) =>
+      ws.close(code, reason);
+
+    this.opened = new Promise((resolve, reject) => {
+      ws.onopen = () => {
+        resolve({
+          readable: new ReadableStream<T>({
+            start(controller) {
+              ws.onmessage = ({ data }) => controller.enqueue(data);
+              ws.onerror = (e) => controller.error(e);
+            },
+            cancel: closeWithInfo,
+          }),
+          writable: new WritableStream<T>({
+            write(chunk) {
+              ws.send(chunk);
+            },
+            abort() {
+              ws.close();
+            },
+            close: closeWithInfo,
+          }),
+          protocol: ws.protocol,
+          extensions: ws.extensions,
+        });
+        ws.removeEventListener('error', reject);
+      };
+      ws.addEventListener('error', reject);
+    });
+
+    this.closed = new Promise<WebSocketCloseInfo>((resolve, reject) => {
+      const rejectHandler = async () => {
+        const closePromise = new Promise<CloseEvent>((res) => {
+          if (ws.readyState === WebSocket.CLOSED) return;
+          else {
+            ws.addEventListener(
+              'close',
+              (closeEv: CloseEvent) => {
+                res(closeEv);
+              },
+              { once: true },
+            );
+          }
+        });
+        const reason = await Promise.race([sleep(250), closePromise]);
+        if (!reason) {
+          reject(new Error('Encountered unspecified websocket error without a timely close event'));
+        } else {
+          // if we can infer the close reason from the close event then resolve the promise, we don't need to throw
+          resolve(reason);
+        }
+      };
+      ws.onclose = ({ code, reason }) => {
+        resolve({ closeCode: code, reason });
+        ws.removeEventListener('error', rejectHandler);
+      };
+
+      ws.addEventListener('error', rejectHandler);
+    });
+
+    if (options.signal) {
+      options.signal.onabort = () => ws.close();
+    }
+
+    this.close = closeWithInfo;
+  }
+}

package/src/api/utils.ts

@@ -1,3 +1,4 @@
+import { SignalResponse } from '@livekit/protocol';
 import { toHttpUrl, toWebsocketUrl } from '../room/utils';
 
 export function createRtcUrl(url: string, searchParams: URLSearchParams) {
@@ -21,3 +22,12 @@ function appendUrlPath(urlObj: URL, path: string) {
   urlObj.pathname = `${ensureTrailingSlash(urlObj.pathname)}${path}`;
   return urlObj.toString();
 }
+
+export function parseSignalResponse(value: ArrayBuffer | string) {
+  if (typeof value === 'string') {
+    return SignalResponse.fromJson(JSON.parse(value), { ignoreUnknownFields: true });
+  } else if (value instanceof ArrayBuffer) {
+    return SignalResponse.fromBinary(new Uint8Array(value));
+  }
+  throw new Error(`could not decode websocket message: ${typeof value}`);
+}

package/src/connectionHelper/checks/turn.ts

@@ -13,6 +13,7 @@ export class TURNCheck extends Checker {
       maxRetries: 0,
       e2eeEnabled: false,
       websocketTimeout: 15_000,
+      singlePeerConnection: false,
     });
 
     let hasTLS = false;

package/src/connectionHelper/checks/webrtc.ts

@@ -38,7 +38,7 @@ export class WebRTCCheck extends Checker {
         }
       };
 
-      if (this.room.engine.pcManager) {
+      if (this.room.engine.pcManager?.subscriber) {
         this.room.engine.pcManager.subscriber.onIceCandidateError = (ev) => {
           if (ev instanceof RTCPeerConnectionIceErrorEvent) {
             this.appendWarning(

package/src/connectionHelper/checks/websocket.ts

@@ -18,6 +18,7 @@ export class WebSocketCheck extends Checker {
       maxRetries: 0,
       e2eeEnabled: false,
       websocketTimeout: 15_000,
+      singlePeerConnection: false,
     });
     this.appendMessage(`Connected to server, version ${joinRes.serverVersion}.`);
     if (joinRes.serverInfo?.edition === ServerInfo_Edition.Cloud && joinRes.serverInfo?.region) {

package/src/index.ts

@@ -50,6 +50,7 @@ import {
   isVideoTrack,
   supportsAV1,
   supportsAdaptiveStream,
+  supportsAudioOutputSelection,
   supportsDynacast,
   supportsVP9,
 } from './room/utils';
@@ -121,6 +122,7 @@ export {
   setLogLevel,
   supportsAV1,
   supportsAdaptiveStream,
+  supportsAudioOutputSelection,
   supportsDynacast,
   supportsVP9,
   Mutex,

package/src/options.ts

@@ -99,6 +99,13 @@ export interface InternalRoomOptions {
   encryption?: E2EEOptions;
 
   loggerName?: string;
+
+  /**
+   * @experimental
+   * only supported on LiveKit Cloud
+   * and LiveKit OSS >= 1.9.2
+   */
+  singlePeerConnection: boolean;
 }
 
 /**

package/src/room/PCTransport.ts

@@ -167,7 +167,7 @@ export default class PCTransport extends EventEmitter {
       sdpParsed.media.forEach((media) => {
         const mid = getMidString(media.mid!);
         if (media.type === 'audio') {
-          // mung sdp for opus bitrate settings
+          // munge sdp for opus bitrate settings
           this.trackBitrates.some((trackbr): boolean => {
             if (!trackbr.transceiver || mid != trackbr.transceiver.mid) {
               return false;
@@ -297,7 +297,7 @@ export default class PCTransport extends EventEmitter {
       sdpParsed.media.forEach((media) => {
         ensureIPAddrMatchVersion(media);
         if (media.type === 'audio') {
-          ensureAudioNackAndStereo(media, [], []);
+          ensureAudioNackAndStereo(media, ['all'], []);
         } else if (media.type === 'video') {
           this.trackBitrates.some((trackbr): boolean => {
             if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
@@ -380,6 +380,10 @@ export default class PCTransport extends EventEmitter {
     return this.pc.addTransceiver(mediaStreamTrack, transceiverInit);
   }
 
+  addTransceiverOfKind(kind: 'audio' | 'video', transceiverInit: RTCRtpTransceiverInit) {
+    return this.pc.addTransceiver(kind, transceiverInit);
+  }
+
   addTrack(track: MediaStreamTrack) {
     if (!this._pc) {
       throw new UnexpectedConnectionState('PC closed, cannot add track');
@@ -623,7 +627,7 @@ function ensureAudioNackAndStereo(
       });
     }
 
-    if (stereoMids.includes(mid)) {
+    if (stereoMids.includes(mid) || (stereoMids.length === 1 && stereoMids[0] === 'all')) {
       media.fmtp.some((fmtp): boolean => {
         if (fmtp.payload === opusPayload) {
           if (!fmtp.config.includes('stereo=1')) {

package/src/room/PCTransportManager.ts

@@ -17,10 +17,11 @@ export enum PCTransportState {
   CLOSED,
 }
 
+type PCMode = 'subscriber-primary' | 'publisher-primary' | 'publisher-only';
 export class PCTransportManager {
   public publisher: PCTransport;
 
-  public subscriber: PCTransport;
+  public subscriber?: PCTransport;
 
   public peerConnectionTimeout: number = roomConnectOptionDefaults.peerConnectionTimeout;
 
@@ -39,7 +40,7 @@ export class PCTransportManager {
   public onStateChange?: (
     state: PCTransportState,
     pubState: RTCPeerConnectionState,
-    subState: RTCPeerConnectionState,
+    subState?: RTCPeerConnectionState,
   ) => void;
 
   public onIceCandidate?: (ev: RTCIceCandidate, target: SignalTarget) => void;
@@ -64,38 +65,40 @@ export class PCTransportManager {
 
   private loggerOptions: LoggerOptions;
 
-  constructor(
-    rtcConfig: RTCConfiguration,
-    subscriberPrimary: boolean,
-    loggerOptions: LoggerOptions,
-  ) {
+  constructor(rtcConfig: RTCConfiguration, mode: PCMode, loggerOptions: LoggerOptions) {
     this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.PCManager);
     this.loggerOptions = loggerOptions;
 
-    this.isPublisherConnectionRequired = !subscriberPrimary;
-    this.isSubscriberConnectionRequired = subscriberPrimary;
+    this.isPublisherConnectionRequired = mode !== 'subscriber-primary';
+    this.isSubscriberConnectionRequired = mode === 'subscriber-primary';
     this.publisher = new PCTransport(rtcConfig, loggerOptions);
-    this.subscriber = new PCTransport(rtcConfig, loggerOptions);
+    if (mode !== 'publisher-only') {
+      this.subscriber = new PCTransport(rtcConfig, loggerOptions);
+      this.subscriber.onConnectionStateChange = this.updateState;
+      this.subscriber.onIceConnectionStateChange = this.updateState;
+      this.subscriber.onSignalingStatechange = this.updateState;
+      this.subscriber.onIceCandidate = (candidate) => {
+        this.onIceCandidate?.(candidate, SignalTarget.SUBSCRIBER);
+      };
+      // in subscriber primary mode, server side opens sub data channels.
+      this.subscriber.onDataChannel = (ev) => {
+        this.onDataChannel?.(ev);
+      };
+      this.subscriber.onTrack = (ev) => {
+        this.onTrack?.(ev);
+      };
+    }
 
     this.publisher.onConnectionStateChange = this.updateState;
-    this.subscriber.onConnectionStateChange = this.updateState;
     this.publisher.onIceConnectionStateChange = this.updateState;
-    this.subscriber.onIceConnectionStateChange = this.updateState;
     this.publisher.onSignalingStatechange = this.updateState;
-    this.subscriber.onSignalingStatechange = this.updateState;
     this.publisher.onIceCandidate = (candidate) => {
       this.onIceCandidate?.(candidate, SignalTarget.PUBLISHER);
     };
-    this.subscriber.onIceCandidate = (candidate) => {
-      this.onIceCandidate?.(candidate, SignalTarget.SUBSCRIBER);
-    };
-    // in subscriber primary mode, server side opens sub data channels.
-    this.subscriber.onDataChannel = (ev) => {
-      this.onDataChannel?.(ev);
-    };
-    this.subscriber.onTrack = (ev) => {
+    this.publisher.onTrack = (ev) => {
       this.onTrack?.(ev);
     };
+
     this.publisher.onOffer = (offer, offerId) => {
       this.onPublisherOffer?.(offer, offerId);
     };
@@ -117,11 +120,6 @@ export class PCTransportManager {
     this.updateState();
   }
 
-  requireSubscriber(require = true) {
-    this.isSubscriberConnectionRequired = require;
-    this.updateState();
-  }
-
   createAndSendPublisherOffer(options?: RTCOfferOptions) {
     return this.publisher.createAndSendOffer(options);
   }
@@ -148,12 +146,14 @@ export class PCTransportManager {
         }
       }
     }
-    await Promise.all([this.publisher.close(), this.subscriber.close()]);
+    await Promise.all([this.publisher.close(), this.subscriber?.close()]);
     this.updateState();
   }
 
   async triggerIceRestart() {
-    this.subscriber.restartingIce = true;
+    if (this.subscriber) {
+      this.subscriber.restartingIce = true;
+    }
     // only restart publisher if it's needed
     if (this.needsPublisher) {
       await this.createAndSendPublisherOffer({ iceRestart: true });
@@ -164,7 +164,7 @@ export class PCTransportManager {
     if (target === SignalTarget.PUBLISHER) {
       await this.publisher.addIceCandidate(candidate);
     } else {
-      await this.subscriber.addIceCandidate(candidate);
+      await this.subscriber?.addIceCandidate(candidate);
     }
   }
 
@@ -173,17 +173,17 @@ export class PCTransportManager {
       ...this.logContext,
       RTCSdpType: sd.type,
       sdp: sd.sdp,
-      signalingState: this.subscriber.getSignallingState().toString(),
+      signalingState: this.subscriber?.getSignallingState().toString(),
     });
     const unlock = await this.remoteOfferLock.lock();
     try {
-      const success = await this.subscriber.setRemoteDescription(sd, offerId);
+      const success = await this.subscriber?.setRemoteDescription(sd, offerId);
       if (!success) {
         return undefined;
       }
 
       // answer the offer
-      const answer = await this.subscriber.createAndSetAnswer();
+      const answer = await this.subscriber?.createAndSetAnswer();
       return answer;
     } finally {
       unlock();
@@ -192,7 +192,7 @@ export class PCTransportManager {
 
   updateConfiguration(config: RTCConfiguration, iceRestart?: boolean) {
     this.publisher.setConfiguration(config);
-    this.subscriber.setConfiguration(config);
+    this.subscriber?.setConfiguration(config);
     if (iceRestart) {
       this.triggerIceRestart();
     }
@@ -252,6 +252,10 @@ export class PCTransportManager {
     return this.publisher.addTransceiver(track, transceiverInit);
   }
 
+  addPublisherTransceiverOfKind(kind: 'audio' | 'video', transceiverInit: RTCRtpTransceiverInit) {
+    return this.publisher.addTransceiverOfKind(kind, transceiverInit);
+  }
+
   addPublisherTrack(track: MediaStreamTrack) {
     return this.publisher.addTrack(track);
   }
@@ -277,7 +281,7 @@ export class PCTransportManager {
     if (this.isPublisherConnectionRequired) {
       transports.push(this.publisher);
     }
-    if (this.isSubscriberConnectionRequired) {
+    if (this.isSubscriberConnectionRequired && this.subscriber) {
       transports.push(this.subscriber);
     }
     return transports;
@@ -311,7 +315,7 @@ export class PCTransportManager {
       this.onStateChange?.(
         this.state,
         this.publisher.getConnectionState(),
-        this.subscriber.getConnectionState(),
+        this.subscriber?.getConnectionState(),
       );
     }
   };

package/src/room/RTCEngine.ts

@@ -15,6 +15,7 @@ import {
   type JoinResponse,
   type LeaveRequest,
   LeaveRequest_Action,
+  MediaSectionsRequirement,
   ParticipantInfo,
   ReconnectReason,
   type ReconnectResponse,
@@ -425,7 +426,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     this.pcManager = new PCTransportManager(
       rtcConfig,
-      joinResponse.subscriberPrimary,
+      this.options.singlePeerConnection
+        ? 'publisher-only'
+        : joinResponse.subscriberPrimary
+          ? 'subscriber-primary'
+          : 'publisher-primary',
       this.loggerOptions,
     );
 
@@ -481,6 +486,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
     };
     this.pcManager.onTrack = (ev: RTCTrackEvent) => {
+      // this fires after the underlying transceiver is stopped and potentially
+      // peer connection closed, so do not bubble up if there are no streams
+      if (ev.streams.length === 0) return;
       this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
     };
 
@@ -495,7 +503,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       if (!this.pcManager) {
         return;
       }
-      this.log.debug('received server answer', { ...this.logContext, RTCSdpType: sd.type });
+      this.log.debug('received server answer', {
+        ...this.logContext,
+        RTCSdpType: sd.type,
+        sdp: sd.sdp,
+      });
       await this.pcManager.setPublisherAnswer(sd, offerId);
     };
 
@@ -566,6 +578,18 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.emit(EngineEvent.RoomMoved, res);
     };
 
+    this.client.onMediaSectionsRequirement = (requirement: MediaSectionsRequirement) => {
+      const transceiverInit: RTCRtpTransceiverInit = { direction: 'recvonly' };
+      for (let i: number = 0; i < requirement.numAudios; i++) {
+        this.pcManager?.addPublisherTransceiverOfKind('audio', transceiverInit);
+      }
+      for (let i: number = 0; i < requirement.numVideos; i++) {
+        this.pcManager?.addPublisherTransceiverOfKind('video', transceiverInit);
+      }
+
+      this.negotiate();
+    };
+
     this.client.onClose = () => {
       this.handleDisconnect('signal', ReconnectReason.RR_SIGNAL_DISCONNECTED);
     };
@@ -734,6 +758,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         const decryptedPacket = EncryptedPacketPayload.fromBinary(decryptedData.payload);
         const newDp = new DataPacket({
           value: decryptedPacket.value,
+          participantIdentity: dp.participantIdentity,
+          participantSid: dp.participantSid,
         });
         if (newDp.value?.case === 'user') {
           // compatibility
@@ -1478,8 +1504,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.log.warn('sync state cannot be sent without peer connection setup', this.logContext);
       return;
     }
-    const previousAnswer = this.pcManager.subscriber.getLocalDescription();
-    const previousOffer = this.pcManager.subscriber.getRemoteDescription();
+    const previousPublisherOffer = this.pcManager.publisher.getLocalDescription();
+    const previousPublisherAnswer = this.pcManager.publisher.getRemoteDescription();
+    const previousSubscriberOffer = this.pcManager.subscriber?.getRemoteDescription();
+    const previousSubscriberAnswer = this.pcManager.subscriber?.getLocalDescription();
 
     /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
           in this case, we send unsub tracks, so server add all tracks to this
@@ -1501,18 +1529,32 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     this.client.sendSyncState(
       new SyncState({
-        answer: previousAnswer
-          ? toProtoSessionDescription({
-              sdp: previousAnswer.sdp,
-              type: previousAnswer.type,
-            })
-          : undefined,
-        offer: previousOffer
-          ? toProtoSessionDescription({
-              sdp: previousOffer.sdp,
-              type: previousOffer.type,
-            })
-          : undefined,
+        answer: this.options.singlePeerConnection
+          ? previousPublisherAnswer
+            ? toProtoSessionDescription({
+                sdp: previousPublisherAnswer.sdp,
+                type: previousPublisherAnswer.type,
+              })
+            : undefined
+          : previousSubscriberAnswer
+            ? toProtoSessionDescription({
+                sdp: previousSubscriberAnswer.sdp,
+                type: previousSubscriberAnswer.type,
+              })
+            : undefined,
+        offer: this.options.singlePeerConnection
+          ? previousPublisherOffer
+            ? toProtoSessionDescription({
+                sdp: previousPublisherOffer.sdp,
+                type: previousPublisherOffer.type,
+              })
+            : undefined
+          : previousSubscriberOffer
+            ? toProtoSessionDescription({
+                sdp: previousSubscriberOffer.sdp,
+                type: previousSubscriberOffer.type,
+              })
+            : undefined,
         subscription: new UpdateSubscription({
           trackSids,
           subscribe: !autoSubscribe,
@@ -1609,7 +1651,7 @@ export type EngineEventCallbacks = {
   activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void;
   dataPacketReceived: (packet: DataPacket, encryptionType: Encryption_Type) => void;
   transcriptionReceived: (transcription: Transcription) => void;
-  transportsCreated: (publisher: PCTransport, subscriber: PCTransport) => void;
+  transportsCreated: (publisher: PCTransport, subscriber?: PCTransport) => void;
   /** @internal */
   trackSenderAdded: (track: Track, sender: RTCRtpSender) => void;
   rtpVideoMapUpdate: (rtpMap: Map<number, VideoCodec>) => void;

package/src/room/Room.ts

@@ -370,6 +370,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (e2eeOptions) {
       if ('e2eeManager' in e2eeOptions) {
         this.e2eeManager = e2eeOptions.e2eeManager;
+        this.e2eeManager.isDataChannelEncryptionEnabled = dcEncryptionEnabled;
       } else {
         this.e2eeManager = new E2EEManager(e2eeOptions, dcEncryptionEnabled);
       }
@@ -761,6 +762,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         maxRetries: connectOptions.maxRetries,
         e2eeEnabled: !!this.e2eeManager,
         websocketTimeout: connectOptions.websocketTimeout,
+        singlePeerConnection: roomOptions.singlePeerConnection,
       },
       abortController.signal,
     );
@@ -939,8 +941,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.isResuming
       ) {
         // try aborting pending connection attempt
-        this.log.warn('abort connection attempt', this.logContext);
-        this.abortController?.abort();
+        const msg = 'Abort connection attempt due to user initiated disconnect';
+        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),

package/src/room/defaults.ts

@@ -42,6 +42,7 @@ export const roomOptionDefaults: InternalRoomOptions = {
   reconnectPolicy: new DefaultReconnectPolicy(),
   disconnectOnPageLeave: true,
   webAudioMix: false,
+  singlePeerConnection: false,
 } as const;
 
 export const roomConnectOptionDefaults: InternalRoomConnectOptions = {

package/src/room/participant/LocalParticipant.ts

@@ -1771,9 +1771,9 @@ export default class LocalParticipant extends Participant {
     destinationIdentity,
     method,
     payload,
-    responseTimeout = 10000,
+    responseTimeout = 15000,
   }: PerformRpcParams): Promise<string> {
-    const maxRoundTripLatency = 2000;
+    const maxRoundTripLatency = 7000;
 
     return new Promise(async (resolve, reject) => {
       if (byteLength(payload) > MAX_PAYLOAD_BYTES) {

package/src/room/token-source/TokenSource.ts

@@ -11,7 +11,7 @@ import {
   TokenSourceFixed,
   type TokenSourceResponseObject,
 } from './types';
-import { decodeTokenPayload, isResponseExpired } from './utils';
+import { decodeTokenPayload, isResponseTokenValid } from './utils';
 
 /** A TokenSourceCached is a TokenSource which caches the last {@link TokenSourceResponseObject} value and returns it
  * until a) it expires or b) the {@link TokenSourceFetchOptions} provided to .fetch(...) change. */
@@ -56,7 +56,7 @@ abstract class TokenSourceCached extends TokenSourceConfigurable {
     if (!this.cachedResponse) {
       return false;
     }
-    if (isResponseExpired(this.cachedResponse)) {
+    if (!isResponseTokenValid(this.cachedResponse)) {
       return false;
     }
     if (this.isSameAsCachedFetchOptions(fetchOptions)) {