@stream-io/video-client 1.11.3 → 1.11.5

package/dist/src/StreamVideoClient.d.ts

@@ -21,8 +21,7 @@ export declare class StreamVideoClient {
     protected readonly writeableStateStore: StreamVideoWriteableStateStore;
     streamClient: StreamClient;
     protected eventHandlersToUnregister: Array<() => void>;
-    protected connectionPromise: Promise<void | ConnectedEvent> | undefined;
-    protected disconnectionPromise: Promise<void> | undefined;
+    private readonly connectionConcurrencyTag;
     private static _instanceMap;
     /**
      * You should create only one instance of `StreamVideoClient`.
@@ -159,5 +158,5 @@ export declare class StreamVideoClient {
      * @param user the user to connect.
      * @param tokenOrProvider a token or a function that returns a token.
      */
-    protected connectAnonymousUser: (user: UserWithId, tokenOrProvider: TokenOrProvider) => Promise<void | ConnectedEvent>;
+    protected connectAnonymousUser: (user: UserWithId, tokenOrProvider: TokenOrProvider) => Promise<void>;
 }

package/dist/src/coordinator/connection/client.d.ts

@@ -4,7 +4,7 @@ import { TokenManager } from './token_manager';
 import { WSConnectionFallback } from './connection_fallback';
 import { AllClientEvents, AllClientEventTypes, APIErrorResponse, ClientEventListener, ConnectAPIResponse, ErrorFromResponse, Logger, StreamClientOptions, StreamVideoEvent, TokenOrProvider, User, UserWithId } from './types';
 import { InsightMetrics } from './insights';
-import { CreateGuestResponse } from '../../gen/coordinator';
+import { ConnectedEvent, CreateGuestResponse } from '../../gen/coordinator';
 export declare class StreamClient {
     _user?: UserWithId;
     anonymous: boolean;
@@ -28,14 +28,14 @@ export declare class StreamClient {
     wsBaseURL?: string;
     wsConnection: StableWSConnection | null;
     wsFallback?: WSConnectionFallback;
-    wsPromise: ConnectAPIResponse | null;
+    private wsPromiseSafe;
     consecutiveFailures: number;
     insightMetrics: InsightMetrics;
     defaultWSTimeoutWithFallback: number;
     defaultWSTimeout: number;
     resolveConnectionId?: Function;
     rejectConnectionId?: Function;
-    connectionIdPromise?: Promise<string | undefined>;
+    private connectionIdPromiseSafe?;
     guestUserCreatePromise?: Promise<CreateGuestResponse>;
     /**
      * Initialize a client.
@@ -64,7 +64,7 @@ export declare class StreamClient {
      *
      * @return {ConnectAPIResponse} Returns a promise that resolves when the connection is setup
      */
-    connectUser: (user: UserWithId, userTokenOrProvider: TokenOrProvider) => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
+    connectUser: (user: UserWithId, userTokenOrProvider: TokenOrProvider) => Promise<void | ConnectedEvent>;
     _setToken: (user: UserWithId, userTokenOrProvider: TokenOrProvider, isAnonymous: boolean) => Promise<void>;
     _setUser: (user: UserWithId) => void;
     /**
@@ -84,7 +84,7 @@ export declare class StreamClient {
     /**
      * Creates a new WebSocket connection with the current user. Returns empty promise, if there is an active connection
      */
-    openConnection: () => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
+    openConnection: () => Promise<ConnectedEvent | undefined>;
     /**
      * Disconnects the websocket and removes the user from client.
      *
@@ -94,7 +94,7 @@ export declare class StreamClient {
     disconnectUser: (timeout?: number) => Promise<void>;
     connectGuestUser: (user: User & {
         type: "guest";
-    }) => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
+    }) => Promise<void | ConnectedEvent>;
     /**
      * connectAnonymousUser - Set an anonymous user and open a WebSocket connection
      */
@@ -117,7 +117,10 @@ export declare class StreamClient {
     /**
      * sets up the this.connectionIdPromise
      */
-    _setupConnectionIdPromise: () => Promise<void>;
+    _setupConnectionIdPromise: () => void;
+    get connectionIdPromise(): Promise<string | undefined> | undefined;
+    get isConnectionIsPromisePending(): boolean;
+    get wsPromise(): Promise<ConnectedEvent | undefined> | undefined;
     _logApiRequest: (type: string, url: string, data: unknown, config: AxiosRequestConfig & {
         config?: AxiosRequestConfig & {
             maxBodyLength?: number;
@@ -143,7 +146,7 @@ export declare class StreamClient {
     /**
      * @private
      */
-    connect: () => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
+    connect: () => Promise<ConnectedEvent | undefined>;
     /**
      * Check the connectivity with server for warmup purpose.
      *

package/dist/src/coordinator/connection/connection.d.ts

@@ -1,6 +1,6 @@
 import WebSocket from 'isomorphic-ws';
 import { StreamClient } from './client';
-import type { ConnectAPIResponse, LogLevel, UR } from './types';
+import type { LogLevel, UR } from './types';
 import type { ConnectedEvent } from '../../gen/coordinator';
 /**
  * StableWSConnection - A WS connection that reconnects upon failure.
@@ -21,7 +21,7 @@ import type { ConnectedEvent } from '../../gen/coordinator';
  */
 export declare class StableWSConnection {
     connectionID?: string;
-    connectionOpen?: ConnectAPIResponse;
+    private connectionOpenSafe?;
     authenticationSent: boolean;
     consecutiveFailures: number;
     pingInterval: number;
@@ -52,13 +52,13 @@ export declare class StableWSConnection {
      * the default 15s timeout allows between 2~3 tries
      * @return {ConnectAPIResponse<ConnectedEvent>} Promise that completes once the first health check message is received
      */
-    connect(timeout?: number): Promise<void | ConnectedEvent>;
+    connect(timeout?: number): Promise<ConnectedEvent | undefined>;
     /**
      * _waitForHealthy polls the promise connection to see if its resolved until it times out
      * the default 15s timeout allows between 2~3 tries
      * @param timeout duration(ms)
      */
-    _waitForHealthy(timeout?: number): Promise<void | ConnectedEvent>;
+    _waitForHealthy(timeout?: number): Promise<ConnectedEvent | undefined>;
     /**
      * Builds and returns the url for websocket.
      * @private
@@ -126,6 +126,7 @@ export declare class StableWSConnection {
      * _setupPromise - sets up the this.connectOpen promise
      */
     _setupConnectionPromise: () => void;
+    get connectionOpen(): Promise<ConnectedEvent> | undefined;
     /**
      * Schedules a next health check ping for websocket.
      */

package/dist/src/helpers/promise.d.ts

@@ -0,0 +1,18 @@
+export interface SafePromise<T> {
+    (): Promise<T>;
+    checkPending(): boolean;
+}
+/**
+ * Saving a long-lived reference to a promise that can reject can be unsafe,
+ * since rejecting the promise causes an unhandled rejection error (even if the
+ * rejection is handled everywhere promise result is expected).
+ *
+ * To avoid that, we add both resolution and rejection handlers to the promise.
+ * That way, the saved promise never rejects. A callback is provided as return
+ * value to build a *new* promise, that resolves and rejects along with
+ * the original promise.
+ * @param promise Promise to wrap, which possibly rejects
+ * @returns Callback to build a new promise, which resolves and rejects along
+ * with the original promise
+ */
+export declare function makeSafePromise<T>(promise: Promise<T>): SafePromise<T>;

package/dist/src/helpers/sdp-munging.d.ts

@@ -2,6 +2,10 @@
  * Returns an SDP with DTX enabled or disabled.
  */
 export declare const toggleDtx: (sdp: string, enable: boolean) => string;
+/**
+ * Returns and SDP with all the codecs except the given codec removed.
+ */
+export declare const preserveCodec: (sdp: string, mid: string, codec: RTCRtpCodec) => string;
 /**
  * Enables high-quality audio through SDP munging for the given trackMid.
  *

package/dist/src/rtc/Publisher.d.ts

@@ -124,6 +124,7 @@ export declare class Publisher {
      * @param options the optional offer options to use.
      */
     private negotiate;
+    private removeUnpreferredCodecs;
     private enableHighQualityAudio;
     /**
      * Returns a list of tracks that are currently being published.

package/dist/src/types.d.ts

@@ -129,6 +129,12 @@ export type PublishOptions = {
      * Use with caution.
      */
     forceCodec?: PreferredCodec;
+    /**
+     * When using a preferred codec, force the use of a single codec.
+     * Enabling this, it will remove all other supported codecs from the SDP.
+     * Defaults to false.
+     */
+    forceSingleCodec?: boolean;
     /**
      * The preferred scalability to use when publishing the video stream.
      * Applicable only for SVC codecs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.11.3",
+  "version": "1.11.5",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/StreamVideoClient.ts

@@ -30,6 +30,7 @@ import {
 import { getLogger, logToConsole, setLogger } from './logger';
 import { getSdkInfo } from './client-details';
 import { SdkType } from './gen/video/sfu/models/models';
+import { withoutConcurrency } from './helpers/concurrency';
 
 /**
  * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
@@ -51,8 +52,9 @@ export class StreamVideoClient {
   streamClient: StreamClient;
 
   protected eventHandlersToUnregister: Array<() => void> = [];
-  protected connectionPromise: Promise<void | ConnectedEvent> | undefined;
-  protected disconnectionPromise: Promise<void> | undefined;
+  private readonly connectionConcurrencyTag = Symbol(
+    'connectionConcurrencyTag',
+  );
 
   private static _instanceMap: Map<string, StreamVideoClient> = new Map();
 
@@ -209,12 +211,11 @@ export class StreamVideoClient {
         return this.streamClient.connectGuestUser(user);
       };
     }
-    this.connectionPromise = this.disconnectionPromise
-      ? this.disconnectionPromise.then(() => connectUser())
-      : connectUser();
 
-    this.connectionPromise?.finally(() => (this.connectionPromise = undefined));
-    const connectUserResponse = await this.connectionPromise;
+    const connectUserResponse = await withoutConcurrency(
+      this.connectionConcurrencyTag,
+      () => connectUser(),
+    );
     // connectUserResponse will be void if connectUser called twice for the same user
     if (connectUserResponse?.me) {
       this.writeableStateStore.setConnectedUser(connectUserResponse.me);
@@ -316,19 +317,15 @@ export class StreamVideoClient {
    *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
    */
   disconnectUser = async (timeout?: number) => {
-    if (!this.streamClient.user && !this.connectionPromise) {
+    if (!this.streamClient.user) {
       return;
     }
     const userId = this.streamClient.user?.id;
     const apiKey = this.streamClient.key;
     const disconnectUser = () => this.streamClient.disconnectUser(timeout);
-    this.disconnectionPromise = this.connectionPromise
-      ? this.connectionPromise.then(() => disconnectUser())
-      : disconnectUser();
-    this.disconnectionPromise.finally(
-      () => (this.disconnectionPromise = undefined),
+    await withoutConcurrency(this.connectionConcurrencyTag, () =>
+      disconnectUser(),
     );
-    await this.disconnectionPromise;
     if (userId) {
       StreamVideoClient._instanceMap.delete(apiKey + userId);
     }
@@ -556,10 +553,8 @@ export class StreamVideoClient {
   ) => {
     const connectAnonymousUser = () =>
       this.streamClient.connectAnonymousUser(user, tokenOrProvider);
-    this.connectionPromise = this.disconnectionPromise
-      ? this.disconnectionPromise.then(() => connectAnonymousUser())
-      : connectAnonymousUser();
-    this.connectionPromise.finally(() => (this.connectionPromise = undefined));
-    return this.connectionPromise;
+    return await withoutConcurrency(this.connectionConcurrencyTag, () =>
+      connectAnonymousUser(),
+    );
   };
 }

package/src/__tests__/Call.test.ts

@@ -271,8 +271,8 @@ describe('muting logic', () => {
       .mockImplementation(() => Promise.resolve({ duration: '0ms' }));
   });
 
-  it('should mute self', () => {
-    call.muteSelf('audio');
+  it('should mute self', async () => {
+    await call.muteSelf('audio');
 
     expect(spy).toHaveBeenCalledWith(userId, 'audio');
   });

package/src/coordinator/connection/client.ts

@@ -38,7 +38,12 @@ import {
 } from './types';
 import { InsightMetrics, postInsights } from './insights';
 import { getLocationHint } from './location';
-import { CreateGuestRequest, CreateGuestResponse } from '../../gen/coordinator';
+import {
+  ConnectedEvent,
+  CreateGuestRequest,
+  CreateGuestResponse,
+} from '../../gen/coordinator';
+import { makeSafePromise, type SafePromise } from '../../helpers/promise';
 
 export class StreamClient {
   _user?: UserWithId;
@@ -67,14 +72,14 @@ export class StreamClient {
   wsBaseURL?: string;
   wsConnection: StableWSConnection | null;
   wsFallback?: WSConnectionFallback;
-  wsPromise: ConnectAPIResponse | null;
+  private wsPromiseSafe: SafePromise<ConnectedEvent | undefined> | null;
   consecutiveFailures: number;
   insightMetrics: InsightMetrics;
   defaultWSTimeoutWithFallback: number;
   defaultWSTimeout: number;
   resolveConnectionId?: Function;
   rejectConnectionId?: Function;
-  connectionIdPromise?: Promise<string | undefined>;
+  private connectionIdPromiseSafe?: SafePromise<string | undefined>;
   guestUserCreatePromise?: Promise<CreateGuestResponse>;
 
   /**
@@ -155,7 +160,7 @@ export class StreamClient {
 
     // WS connection is initialized when setUser is called
     this.wsConnection = null;
-    this.wsPromise = null;
+    this.wsPromiseSafe = null;
     this.setUserPromise = null;
 
     // mapping between channel groups and configs
@@ -340,12 +345,13 @@ export class StreamClient {
       );
     }
 
-    if (this.wsConnection?.isConnecting && this.wsPromise) {
+    const wsPromise = this.wsPromiseSafe?.();
+    if (this.wsConnection?.isConnecting && wsPromise) {
       this.logger(
         'info',
         'client:openConnection() - connection already in progress',
       );
-      return this.wsPromise;
+      return await wsPromise;
     }
 
     if (
@@ -357,14 +363,15 @@ export class StreamClient {
         'client:openConnection() - openConnection called twice, healthy connection already exists',
       );
 
-      return Promise.resolve();
+      return;
     }
 
     this._setupConnectionIdPromise();
 
     this.clientID = `${this.userID}--${randomId()}`;
-    this.wsPromise = this.connect();
-    return this.wsPromise;
+    const newWsPromise = this.connect();
+    this.wsPromiseSafe = makeSafePromise(newWsPromise);
+    return await newWsPromise;
   };
 
   /**
@@ -388,7 +395,7 @@ export class StreamClient {
 
     this.tokenManager.reset();
 
-    this.connectionIdPromise = undefined;
+    this.connectionIdPromiseSafe = undefined;
     this.rejectConnectionId = undefined;
     this.resolveConnectionId = undefined;
   };
@@ -481,16 +488,28 @@ export class StreamClient {
   /**
    * sets up the this.connectionIdPromise
    */
-  _setupConnectionIdPromise = async () => {
+  _setupConnectionIdPromise = () => {
     /** a promise that is resolved once connection id is set */
-    this.connectionIdPromise = new Promise<string | undefined>(
-      (resolve, reject) => {
+    this.connectionIdPromiseSafe = makeSafePromise(
+      new Promise<string | undefined>((resolve, reject) => {
         this.resolveConnectionId = resolve;
         this.rejectConnectionId = reject;
-      },
+      }),
     );
   };
 
+  get connectionIdPromise() {
+    return this.connectionIdPromiseSafe?.();
+  }
+
+  get isConnectionIsPromisePending() {
+    return this.connectionIdPromiseSafe?.checkPending() ?? false;
+  }
+
+  get wsPromise() {
+    return this.wsPromiseSafe?.();
+  }
+
   _logApiRequest = (
     type: string,
     url: string,

package/src/coordinator/connection/connection.ts

@@ -8,20 +8,15 @@ import {
 import {
   addConnectionEventListeners,
   convertErrorToJson,
-  isPromisePending,
   KnownCodes,
   randomId,
   removeConnectionEventListeners,
   retryInterval,
   sleep,
 } from './utils';
-import type {
-  ConnectAPIResponse,
-  LogLevel,
-  StreamVideoEvent,
-  UR,
-} from './types';
+import type { LogLevel, StreamVideoEvent, UR } from './types';
 import type { ConnectedEvent, WSAuthMessage } from '../../gen/coordinator';
+import { makeSafePromise, type SafePromise } from '../../helpers/promise';
 
 // Type guards to check WebSocket error type
 const isCloseEvent = (
@@ -54,7 +49,7 @@ const isErrorEvent = (
 export class StableWSConnection {
   // local vars
   connectionID?: string;
-  connectionOpen?: ConnectAPIResponse;
+  private connectionOpenSafe?: SafePromise<ConnectedEvent>;
   authenticationSent: boolean;
   consecutiveFailures: number;
   pingInterval: number;
@@ -338,13 +333,7 @@ export class StableWSConnection {
         await this.client.tokenManager.loadToken();
       }
 
-      let mustSetupConnectionIdPromise = true;
-      if (this.client.connectionIdPromise) {
-        if (await isPromisePending(this.client.connectionIdPromise)) {
-          mustSetupConnectionIdPromise = false;
-        }
-      }
-      if (mustSetupConnectionIdPromise) {
+      if (!this.client.isConnectionIsPromisePending) {
         this.client._setupConnectionIdPromise();
       }
       this._setupConnectionPromise();
@@ -747,12 +736,18 @@ export class StableWSConnection {
   _setupConnectionPromise = () => {
     this.isResolved = false;
     /** a promise that is resolved once ws.open is called */
-    this.connectionOpen = new Promise<ConnectedEvent>((resolve, reject) => {
-      this.resolvePromise = resolve;
-      this.rejectPromise = reject;
-    });
+    this.connectionOpenSafe = makeSafePromise(
+      new Promise<ConnectedEvent>((resolve, reject) => {
+        this.resolvePromise = resolve;
+        this.rejectPromise = reject;
+      }),
+    );
   };
 
+  get connectionOpen() {
+    return this.connectionOpenSafe?.();
+  }
+
   /**
    * Schedules a next health check ping for websocket.
    */

package/src/helpers/__tests__/sdp-munging.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from 'vitest';
-import { enableHighQualityAudio, toggleDtx } from '../sdp-munging';
+import {
+  enableHighQualityAudio,
+  preserveCodec,
+  toggleDtx,
+} from '../sdp-munging';
 import { initialSdp as HQAudioSDP } from './hq-audio-sdp';
 
 describe('sdp-munging', () => {
@@ -21,4 +25,167 @@ a=maxptime:40`;
     expect(sdpWithHighQualityAudio).toContain('maxaveragebitrate=510000');
     expect(sdpWithHighQualityAudio).toContain('stereo=1');
   });
+
+  it('preserves the preferred codec', () => {
+    const sdp = `v=0
+o=- 8608371809202407637 2 IN IP4 127.0.0.1
+s=-
+t=0 0
+a=extmap-allow-mixed
+a=msid-semantic: WMS 52fafc21-b8bb-4f4f-8072-86a29cb6590e
+a=group:BUNDLE 0
+m=video 9 UDP/TLS/RTP/SAVPF 98 100 99 101
+c=IN IP4 0.0.0.0
+a=rtpmap:98 VP9/90000
+a=rtpmap:99 rtx/90000
+a=rtpmap:100 VP9/90000
+a=rtpmap:101 rtx/90000
+a=fmtp:98 profile-id=0
+a=fmtp:99 apt=98
+a=fmtp:100 profile-id=2
+a=fmtp:101 apt=100
+a=rtcp:9 IN IP4 0.0.0.0
+a=rtcp-fb:98 goog-remb
+a=rtcp-fb:98 transport-cc
+a=rtcp-fb:98 ccm fir
+a=rtcp-fb:98 nack
+a=rtcp-fb:98 nack pli
+a=rtcp-fb:100 goog-remb
+a=rtcp-fb:100 transport-cc
+a=rtcp-fb:100 ccm fir
+a=rtcp-fb:100 nack
+a=rtcp-fb:100 nack pli
+a=extmap:1 urn:ietf:params:rtp-hdrext:toffset
+a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time
+a=extmap:3 urn:3gpp:video-orientation
+a=extmap:4 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
+a=extmap:5 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay
+a=extmap:6 http://www.webrtc.org/experiments/rtp-hdrext/video-content-type
+a=extmap:7 http://www.webrtc.org/experiments/rtp-hdrext/video-timing
+a=extmap:8 http://www.webrtc.org/experiments/rtp-hdrext/color-space
+a=extmap:9 urn:ietf:params:rtp-hdrext:sdes:mid
+a=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id
+a=extmap:11 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id
+a=extmap:12 https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension
+a=extmap:14 http://www.webrtc.org/experiments/rtp-hdrext/video-layers-allocation00
+a=setup:actpass
+a=mid:0
+a=msid:52fafc21-b8bb-4f4f-8072-86a29cb6590e 1bd1c5c2-d3cc-4490-ac0c-70b187242232
+a=sendonly
+a=ice-ufrag:LvRk
+a=ice-pwd:IpBRr2Rrg9TkOgayjYqALhPY
+a=fingerprint:sha-256 18:DE:8F:ED:E6:A2:0C:99:A8:25:AB:C9:F8:3D:91:4C:3E:9F:B4:1F:22:87:A7:3C:85:8F:F3:51:09:A7:E3:FA
+a=ice-options:trickle
+a=ssrc:3192778601 cname:yYSN5R+RG2j3luO7
+a=ssrc:3192778601 msid:52fafc21-b8bb-4f4f-8072-86a29cb6590e 1bd1c5c2-d3cc-4490-ac0c-70b187242232
+a=ssrc:283365205 cname:yYSN5R+RG2j3luO7
+a=ssrc:283365205 msid:52fafc21-b8bb-4f4f-8072-86a29cb6590e 1bd1c5c2-d3cc-4490-ac0c-70b187242232
+a=ssrc-group:FID 3192778601 283365205
+a=rtcp-mux
+a=rtcp-rsize`;
+    const target = preserveCodec(sdp, '0', {
+      mimeType: 'video/VP9',
+      clockRate: 90000,
+      sdpFmtpLine: 'profile-id=0',
+    });
+    expect(target).toContain('VP9');
+    expect(target).not.toContain('profile-id=2');
+  });
+
+  it('handles ios munging', () => {
+    const sdp = `v=0
+o=- 525780719364332676 2 IN IP4 127.0.0.1
+s=-
+t=0 0
+a=group:BUNDLE 0
+a=extmap-allow-mixed
+a=msid-semantic: WMS BF3AFE62-88F8-4189-99D7-7CAE159205E3
+m=video 9 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 127 103 35 36 104 105 106
+c=IN IP4 0.0.0.0
+a=rtcp:9 IN IP4 0.0.0.0
+a=ice-ufrag:SAkq
+a=ice-pwd:FYHHro0VWRO8CjI/M1VG5vRw
+a=ice-options:trickle renomination
+a=fingerprint:sha-256 03:5B:16:0E:E1:7B:FE:4F:9A:5C:AC:CF:08:21:4B:49:CE:53:79:E6:97:AE:4E:73:F8:43:34:C3:11:F7:6D:E7
+a=setup:actpass
+a=mid:0
+a=extmap:1 urn:ietf:params:rtp-hdrext:toffset
+a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time
+a=extmap:3 urn:3gpp:video-orientation
+a=extmap:4 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
+a=extmap:5 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay
+a=extmap:6 http://www.webrtc.org/experiments/rtp-hdrext/video-content-type
+a=extmap:7 http://www.webrtc.org/experiments/rtp-hdrext/video-timing
+a=extmap:8 http://www.webrtc.org/experiments/rtp-hdrext/color-space
+a=extmap:9 urn:ietf:params:rtp-hdrext:sdes:mid
+a=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id
+a=extmap:11 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id
+a=extmap:12 https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension
+a=extmap:14 http://www.webrtc.org/experiments/rtp-hdrext/video-layers-allocation00
+a=sendonly
+a=msid:BF3AFE62-88F8-4189-99D7-7CAE159205E3 6013DC02-A0A5-43A9-9D41-9D4A89648A42
+a=rtcp-mux
+a=rtcp-rsize
+a=rtpmap:96 H264/90000
+a=rtcp-fb:96 goog-remb
+a=rtcp-fb:96 transport-cc
+a=rtcp-fb:96 ccm fir
+a=rtcp-fb:96 nack
+a=rtcp-fb:96 nack pli
+a=fmtp:96 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=640c29
+a=rtpmap:97 rtx/90000
+a=fmtp:97 apt=96
+a=rtpmap:98 H264/90000
+a=rtcp-fb:98 goog-remb
+a=rtcp-fb:98 transport-cc
+a=rtcp-fb:98 ccm fir
+a=rtcp-fb:98 nack
+a=rtcp-fb:98 nack pli
+a=fmtp:98 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e029
+a=rtpmap:99 rtx/90000
+a=fmtp:99 apt=98
+a=rtpmap:100 VP8/90000
+a=rtcp-fb:100 goog-remb
+a=rtcp-fb:100 transport-cc
+a=rtcp-fb:100 ccm fir
+a=rtcp-fb:100 nack
+a=rtcp-fb:100 nack pli
+a=rtpmap:101 rtx/90000
+a=fmtp:101 apt=100
+a=rtpmap:127 VP9/90000
+a=rtcp-fb:127 goog-remb
+a=rtcp-fb:127 transport-cc
+a=rtcp-fb:127 ccm fir
+a=rtcp-fb:127 nack
+a=rtcp-fb:127 nack pli
+a=rtpmap:103 rtx/90000
+a=fmtp:103 apt=127
+a=rtpmap:35 AV1/90000
+a=rtcp-fb:35 goog-remb
+a=rtcp-fb:35 transport-cc
+a=rtcp-fb:35 ccm fir
+a=rtcp-fb:35 nack
+a=rtcp-fb:35 nack pli
+a=rtpmap:36 rtx/90000
+a=fmtp:36 apt=35
+a=rtpmap:104 red/90000
+a=rtpmap:105 rtx/90000
+a=fmtp:105 apt=104
+a=rtpmap:106 ulpfec/90000
+a=rid:q send
+a=rid:h send
+a=rid:f send
+a=simulcast:send q;h;f`;
+    const target = preserveCodec(sdp, '0', {
+      mimeType: 'video/H264',
+      clockRate: 90000,
+      sdpFmtpLine:
+        'profile-level-id=42e029;packetization-mode=1;level-asymmetry-allowed=1',
+    });
+    expect(target).toContain('H264');
+    expect(target).toContain('profile-level-id=42e029');
+    expect(target).not.toContain('profile-level-id=640c29');
+    expect(target).not.toContain('VP9');
+    expect(target).not.toContain('AV1');
+  });
 });