livekit-client 2.22.3 → 2.23.0

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

@@ -9,6 +9,10 @@ import {
   Encryption_Type,
 } from '@livekit/protocol';
 import { describe, expect, it } from 'vitest';
+import {
+  stubMissingCompressionStreams,
+  stubMissingDeflateRawSupport,
+} from '../../../test/compressionStreamStubs';
 import { deflateRawCompress } from '../compression';
 import { STREAM_CHUNK_SIZE_BYTES } from '../constants';
 import IncomingDataStreamManager from './IncomingDataStreamManager';
@@ -675,6 +679,37 @@ describe('IncomingDataStreamManager', () => {
         'Participant alice unexpectedly disconnected in the middle of sending data',
       );
     });
+
+    it('should error in flight streams when the controllers are cleared on room disconnect', async () => {
+      const manager = new IncomingDataStreamManager();
+      manager.setConnected(true);
+
+      const textReaderPromise = new Promise<TextStreamReader>((resolve) => {
+        manager.registerTextStreamHandler('my-topic', (reader) => resolve(reader));
+      });
+      const byteReaderPromise = new Promise<ByteStreamReader>((resolve) => {
+        manager.registerByteStreamHandler('my-topic', (reader) => resolve(reader));
+      });
+
+      manager.handleDataStreamPacket(headerPacket('text-1', 'textHeader'), Encryption_Type.NONE);
+      manager.handleDataStreamPacket(
+        chunkPacket('text-1', 0, new Uint8Array([0x68, 0x69])),
+        Encryption_Type.NONE,
+      );
+      manager.handleDataStreamPacket(headerPacket('byte-1', 'byteHeader'), Encryption_Type.NONE);
+      manager.handleDataStreamPacket(
+        chunkPacket('byte-1', 0, new Uint8Array([0x01])),
+        Encryption_Type.NONE,
+      );
+
+      // Room#handleDisconnect calls this while the streams are still open
+      manager.clearControllers();
+
+      const textReader = await textReaderPromise;
+      const byteReader = await byteReaderPromise;
+      await expect(textReader.readAll()).rejects.toThrow('Room disconnected');
+      await expect(byteReader.readAll()).rejects.toThrow('Room disconnected');
+    });
   });
 
   describe('Receiving v2 data streams', () => {
@@ -907,18 +942,15 @@ describe('IncomingDataStreamManager', () => {
       expect(await reader.readAll()).toStrictEqual(text);
     });
 
-    it(`should ignore a v2 TEXT data stream with compression if DecompressionStream doesn't exist`, async () => {
+    it.each([
+      [`DecompressionStream doesn't exist`, stubMissingCompressionStreams],
+      [`deflate-raw isn't a supported format`, stubMissingDeflateRawSupport],
+    ])(`should ignore a v2 TEXT data stream with compression if %s`, async (_label, stub) => {
       const text = 'hello world';
       const compressed = await deflateRawCompress(new TextEncoder().encode(text));
 
-      let originalCompressionStream: typeof CompressionStream,
-        originalDecompressionStream: typeof DecompressionStream;
+      const restoreCompressionStreams = stub();
       try {
-        originalCompressionStream = CompressionStream;
-        (globalThis as any).CompressionStream = undefined;
-        originalDecompressionStream = DecompressionStream;
-        (globalThis as any).DecompressionStream = undefined;
-
         const manager = new IncomingDataStreamManager();
         manager.setConnected(true);
 
@@ -977,23 +1009,19 @@ describe('IncomingDataStreamManager', () => {
           Promise.race([readerPromise, Promise.resolve('still pending')]),
         ).resolves.toStrictEqual('still pending');
       } finally {
-        (globalThis as any).CompressionStream = originalCompressionStream!;
-        (globalThis as any).DecompressionStream = originalDecompressionStream!;
+        restoreCompressionStreams();
       }
     });
 
-    it(`should ignore a v2 BYTES data stream with compression if DecompressionStream doesn't exist`, async () => {
+    it.each([
+      [`DecompressionStream doesn't exist`, stubMissingCompressionStreams],
+      [`deflate-raw isn't a supported format`, stubMissingDeflateRawSupport],
+    ])(`should ignore a v2 BYTES data stream with compression if %s`, async (_label, stub) => {
       const bytes = new Uint8Array([0x01, 0x02, 0x03]);
       const compressed = await deflateRawCompress(bytes);
 
-      let originalCompressionStream: typeof CompressionStream,
-        originalDecompressionStream: typeof DecompressionStream;
+      const restoreCompressionStreams = stub();
       try {
-        originalCompressionStream = CompressionStream;
-        (globalThis as any).CompressionStream = undefined;
-        originalDecompressionStream = DecompressionStream;
-        (globalThis as any).DecompressionStream = undefined;
-
         const manager = new IncomingDataStreamManager();
         manager.setConnected(true);
 
@@ -1052,8 +1080,7 @@ describe('IncomingDataStreamManager', () => {
           Promise.race([readerPromise, Promise.resolve('still pending')]),
         ).resolves.toStrictEqual('still pending');
       } finally {
-        (globalThis as any).CompressionStream = originalCompressionStream!;
-        (globalThis as any).DecompressionStream = originalDecompressionStream!;
+        restoreCompressionStreams();
       }
     });
 

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

@@ -10,7 +10,7 @@ import log from '../../../logger';
 import { type NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
 import { DataStreamError, DataStreamErrorReason } from '../../errors';
 import { type ByteStreamInfo, type StreamController, type TextStreamInfo } from '../../types';
-import { bigIntToNumber, isCompressionStreamSupported, numberToBigInt } from '../../utils';
+import { bigIntToNumber, isDeflateRawCompressionSupported, numberToBigInt } from '../../utils';
 import { deflateRawDecompress, inflateRawTransform } from '../compression';
 import { DEFAULT_MAX_PAYLOAD_BYTE_LENGTH } from '../constants';
 import {
@@ -87,6 +87,17 @@ export default class IncomingDataStreamManager {
   }
 
   clearControllers() {
+    // Error any in flight streams so readers do not wait forever for chunks that can no longer arrive.
+    const abnormalEndError = new DataStreamError(
+      'Room disconnected in the middle of receiving data',
+      DataStreamErrorReason.AbnormalEnd,
+    );
+    for (const { controller } of this.byteStreamControllers.values()) {
+      controller.error(abnormalEndError);
+    }
+    for (const { controller } of this.textStreamControllers.values()) {
+      controller.error(abnormalEndError);
+    }
     this.byteStreamControllers.clear();
     this.textStreamControllers.clear();
     this.bufferedPackets = [];
@@ -174,11 +185,11 @@ export default class IncomingDataStreamManager {
         let compressed;
         switch (streamHeader.compression) {
           case DataStream_CompressionType.DEFLATE_RAW:
-            if (!isCompressionStreamSupported()) {
+            if (!isDeflateRawCompressionSupported()) {
               // NOTE: this shouldn't really ever happen, if this warning is logged then the sender
               // isn't properly abiding by the data streams v2 protocol.
               log.warn(
-                `Data stream ${streamHeader.streamId} received with deflate-raw compression, but this browser does not have support for DecompressionStream. Dropping...`,
+                `Data stream ${streamHeader.streamId} received with deflate-raw compression, but this browser does not support deflate-raw decompression. Dropping...`,
               );
               return;
             }
@@ -279,11 +290,11 @@ export default class IncomingDataStreamManager {
         let compressed;
         switch (streamHeader.compression) {
           case DataStream_CompressionType.DEFLATE_RAW:
-            if (!isCompressionStreamSupported()) {
+            if (!isDeflateRawCompressionSupported()) {
               // NOTE: this shouldn't really ever happen, if this warning is logged then the sender
               // isn't properly abiding by the data streams v2 protocol.
               log.warn(
-                `Data stream ${streamHeader.streamId} received with deflate-raw compression, but this browser does not have support for DecompressionStream. Dropping...`,
+                `Data stream ${streamHeader.streamId} received with deflate-raw compression, but this browser does not support deflate-raw decompression. Dropping...`,
               );
               return;
             }

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

@@ -5,14 +5,19 @@ import {
   DataStream_CompressionType,
   type DataStream_TextHeader,
 } from '@livekit/protocol';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import log from '../../../logger';
+import {
+  stubMissingCompressionStreams,
+  stubMissingDeflateRawSupport,
+} from '../../../test/compressionStreamStubs';
 import {
   CLIENT_PROTOCOL_DATA_STREAM_RPC,
   CLIENT_PROTOCOL_DATA_STREAM_V2,
   CLIENT_PROTOCOL_DEFAULT,
 } from '../../../version';
 import type RTCEngine from '../../RTCEngine';
+import { STREAM_CHUNK_SIZE_BYTES } from '../constants';
 import OutgoingDataStreamManager from './OutgoingDataStreamManager';
 
 /** Builds a low quality random string of the given length. */
@@ -1195,7 +1200,7 @@ describe('OutgoingDataStreamManager', () => {
       // The split backs off below the MTU rather than bisecting the emoji, so each chunk decodes
       // independently.
       expect(first.content).toHaveLength(14_999);
-      const decode = (bytes: Uint8Array) => new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+      const decode = (bytes: Uint8Array) => new TextDecoder('utf-8').decode(bytes);
       expect(() => decode(first.content)).not.toThrow();
       expect(() => decode(second.content)).not.toThrow();
       expect(decode(first.content) + decode(second.content)).toStrictEqual(text);
@@ -1243,50 +1248,66 @@ describe('OutgoingDataStreamManager', () => {
     });
   });
 
-  describe('runtime without CompressionStream', () => {
+  describe.each([
+    ['a runtime without CompressionStream', stubMissingCompressionStreams],
+    ['a runtime without deflate-raw support', stubMissingDeflateRawSupport],
+  ])('on %s', (_label, stub) => {
+    let restoreCompressionStreams: () => void;
+
+    beforeEach(() => {
+      restoreCompressionStreams = stub();
+    });
+
+    afterEach(() => {
+      restoreCompressionStreams();
+    });
+
     it('should send raw inline even to compression-capable recipients when the runtime cannot compress', async () => {
-      const originalCompressionStream = CompressionStream;
-      try {
-        (globalThis as any).CompressionStream = undefined;
+      const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
+      await manager.sendText('hello hello compressible world', {
+        topic: 'my-topic',
+        destinationIdentities: ['alice'],
+      });
 
-        const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
-        await manager.sendText('hello hello compressible world', {
-          topic: 'my-topic',
-          destinationIdentities: ['alice'],
-        });
+      // Compression eligibility also requires a local compressor; without one, inline still
+      // applies but the payload is sent raw.
+      expect(sentPackets).toHaveLength(1);
+      const header = headerOf(sentPackets[0]);
+      expect(header.compression).toBe(DataStream_CompressionType.NONE);
+      expect(header.inlineContent).toStrictEqual(
+        new TextEncoder().encode('hello hello compressible world'),
+      );
+    });
 
-        // Compression eligibility also requires a local compressor; without one, inline still
-        // applies but the payload is sent raw.
-        expect(sentPackets).toHaveLength(1);
-        const header = headerOf(sentPackets[0]);
-        expect(header.compression).toBe(DataStream_CompressionType.NONE);
-        expect(header.inlineContent).toStrictEqual(
-          new TextEncoder().encode('hello hello compressible world'),
-        );
-      } finally {
-        (globalThis as any).CompressionStream = originalCompressionStream;
-      }
+    it('should send BYTES uncompressed when the runtime cannot compress', async () => {
+      const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
+      // Larger than the inline budget, so this takes the chunked path rather than riding along in
+      // the header.
+      const bytes = new Uint8Array(20_000).fill(0x07);
+      await manager.sendBytes(bytes, {
+        topic: 'my-topic',
+        destinationIdentities: ['alice'],
+      });
+
+      expect(sentPackets).toHaveLength(4);
+      const header = headerOf(sentPackets[0]);
+      expect(header.compression).toBe(DataStream_CompressionType.NONE);
+      expect(chunkOf(sentPackets[1]).content).toHaveLength(STREAM_CHUNK_SIZE_BYTES);
+      expect(chunkOf(sentPackets[2]).content).toHaveLength(20_000 - STREAM_CHUNK_SIZE_BYTES);
     });
 
     it('should send a FILE uncompressed when the runtime cannot compress', async () => {
-      const originalCompressionStream = CompressionStream;
-      try {
-        (globalThis as any).CompressionStream = undefined;
-
-        const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
-        const bytes = new Uint8Array(10_000).fill(0x07);
-        await manager.sendFile(new File([bytes as NonSharedUint8Array], 'text.txt'), {
-          topic: 'my-topic',
-          destinationIdentities: ['alice'],
-        });
+      const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
+      const bytes = new Uint8Array(10_000).fill(0x07);
+      await manager.sendFile(new File([bytes as NonSharedUint8Array], 'text.txt'), {
+        topic: 'my-topic',
+        destinationIdentities: ['alice'],
+      });
 
-        expect(sentPackets).toHaveLength(3);
-        const header = headerOf(sentPackets[0]);
-        expect(header.compression).toBe(DataStream_CompressionType.NONE);
-        expect(chunkOf(sentPackets[1]).content).toHaveLength(10_000);
-      } finally {
-        (globalThis as any).CompressionStream = originalCompressionStream;
-      }
+      expect(sentPackets).toHaveLength(3);
+      const header = headerOf(sentPackets[0]);
+      expect(header.compression).toBe(DataStream_CompressionType.NONE);
+      expect(chunkOf(sentPackets[1]).content).toHaveLength(10_000);
     });
   });
 });

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

@@ -24,7 +24,7 @@ import type {
   TextStreamInfo,
 } from '../../types';
 import {
-  isCompressionStreamSupported,
+  isDeflateRawCompressionSupported,
   numberToBigInt,
   readBytesInChunks,
   readableFromBytes,
@@ -101,7 +101,7 @@ export default class OutgoingDataStreamManager {
 
     const compressEligible =
       compress &&
-      isCompressionStreamSupported() &&
+      isDeflateRawCompressionSupported() &&
       this.allRecipientsSupportV2(options?.destinationIdentities) &&
       this.allRecipientsSupportCompression(options?.destinationIdentities);
     let compressedStream = compressEligible
@@ -239,7 +239,7 @@ export default class OutgoingDataStreamManager {
 
     const compressEligible =
       compress &&
-      isCompressionStreamSupported() &&
+      isDeflateRawCompressionSupported() &&
       this.allRecipientsSupportV2(destinationIdentities) &&
       this.allRecipientsSupportCompression(destinationIdentities);
     let compressedStream = compressEligible
@@ -463,7 +463,7 @@ export default class OutgoingDataStreamManager {
     const destinationIdentities = options?.destinationIdentities;
     const compress =
       (options?.compress ?? true) &&
-      isCompressionStreamSupported() &&
+      isDeflateRawCompressionSupported() &&
       this.allRecipientsSupportV2(destinationIdentities) &&
       this.allRecipientsSupportCompression(destinationIdentities);
 

package/src/room/defaults.ts

@@ -47,6 +47,7 @@ export const roomOptionDefaults: InternalRoomOptions = {
 
 export const roomConnectOptionDefaults: InternalRoomConnectOptions = {
   autoSubscribe: true,
+  disableIceLite: false,
   maxRetries: 1,
   peerConnectionTimeout: 15_000,
   websocketTimeout: 15_000,

package/src/room/errors.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { ConnectionError, canFailOverToAnotherRegion } from './errors';
+
+describe('canFailOverToAnotherRegion', () => {
+  it('allows failover on 403, which LiveKit Cloud uses to signal region pinning', () => {
+    // The RTC paths 403 when the project is not allowed in the region the client geo-routed to.
+    // `/settings/regions` stays reachable so the client can discover where it is allowed.
+    expect(
+      canFailOverToAnotherRegion(
+        ConnectionError.notAllowed('project not allowed in this region.', 403),
+      ),
+    ).toBe(true);
+  });
+
+  it('does not allow failover on 401 — no other region will accept the same token', () => {
+    expect(canFailOverToAnotherRegion(ConnectionError.notAllowed('unauthorized', 401))).toBe(false);
+  });
+
+  it('does not allow failover when the room does not exist, reported as NotAllowed with 404', () => {
+    expect(
+      canFailOverToAnotherRegion(ConnectionError.notAllowed('requested room does not exist', 404)),
+    ).toBe(false);
+  });
+
+  it('does not allow failover on a cancelled attempt', () => {
+    expect(canFailOverToAnotherRegion(ConnectionError.cancelled('aborted'))).toBe(false);
+  });
+
+  it.each([
+    ['server unreachable', ConnectionError.serverUnreachable('unreachable')],
+    ['timeout', ConnectionError.timeout('timed out')],
+    ['internal', ConnectionError.internal('internal')],
+  ])('allows failover on a %s error', (_name, error) => {
+    expect(canFailOverToAnotherRegion(error)).toBe(true);
+  });
+});

package/src/room/errors.ts

@@ -188,6 +188,33 @@ export class ConnectionError<
   }
 }
 
+/**
+ * Whether a failed connection attempt may be retried against a different LiveKit Cloud region.
+ *
+ * LiveKit Cloud signals project-level region pinning by returning 403 on the RTC paths when the
+ * project is not allowed in the region the client geo-routed to. `/settings/regions` is
+ * deliberately left reachable so the client can discover its allowed regions and connect there, so
+ * a 403 must not be treated as terminal.
+ *
+ * A 401 stays terminal: no other region will accept a token this one rejected. So does the 404
+ * "requested room does not exist" case, which is also reported as `NotAllowed`.
+ *
+ * We key on the status rather than the server's error message because that message is an
+ * unversioned human-readable string; matching it would let a copy edit break already-shipped
+ * clients. If a 403 really was a permissions failure rather than region pinning, every region
+ * attempt fails the same way and the original error still surfaces — at the cost of one extra
+ * region lookup.
+ */
+export function canFailOverToAnotherRegion(error: ConnectionError): boolean {
+  if (error.reason === ConnectionErrorReason.Cancelled) {
+    return false;
+  }
+  if (error.reason === ConnectionErrorReason.NotAllowed) {
+    return error.status === 403;
+  }
+  return true;
+}
+
 export class DeviceUnsupportedError extends LivekitError {
   readonly name = 'DeviceUnsupportedError';
 

package/src/room/events.ts

@@ -225,7 +225,7 @@ export enum RoomEvent {
    * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
    * All participants in the room will receive the messages sent to the room.
    *
-   * args: (payload: NonSharedUint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]], topic?: string)
+   * args: (payload: NonSharedUint8Array, participant: [[Participant]] | undefined, kind: [[DataPacket_Kind]], topic?: string, encryptionType?: Encryption_Type, participantIdentity?: string)
    */
   DataReceived = 'dataReceived',
 
@@ -633,6 +633,7 @@ export enum EngineEvent {
   Joined = 'joined',
   TokenRefreshed = 'tokenRefreshed',
   ServerRegionsReported = 'serverRegionsReported',
+  RequestSubscribedCodecRefresh = 'requestSubscribedCodecRefresh',
 }
 
 export enum TrackEvent {

package/src/room/participant/LocalParticipant.test.ts

@@ -1,6 +1,12 @@
-import { PacketTrailerFeature } from '@livekit/protocol';
+import {
+  type AddTrackRequest,
+  Encryption_Type,
+  PacketTrailerFeature,
+  VideoQuality,
+} from '@livekit/protocol';
 import { describe, expect, it, vi } from 'vitest';
 import type LocalTrack from '../track/LocalTrack';
+import type LocalVideoTrack from '../track/LocalVideoTrack';
 import { Track } from '../track/Track';
 import type { TrackPublishOptions } from '../track/options';
 import LocalParticipant from './LocalParticipant';
@@ -79,3 +85,132 @@ describe('LocalParticipant frame metadata publish options', () => {
     expect(participant.log.warn).toHaveBeenCalledOnce();
   });
 });
+
+type BackupCodecTestParticipant = {
+  encryptionType: Encryption_Type;
+  trackPublications: Map<string, { track: LocalVideoTrack }>;
+  roomOptions: { publishDefaults: TrackPublishOptions };
+  engine: {
+    isClosed: boolean;
+    addTrack: ReturnType<typeof vi.fn>;
+    createSimulcastSender: ReturnType<typeof vi.fn>;
+    negotiate: ReturnType<typeof vi.fn>;
+  };
+  log: { warn: ReturnType<typeof vi.fn>; debug: ReturnType<typeof vi.fn> };
+  publishAdditionalCodecForTrack: LocalParticipant['publishAdditionalCodecForTrack'];
+};
+
+// a resizing processor makes mediaStreamTrack (processed) and dimensions (raw capture) differ
+function makeBackupCodecTrack(
+  settings: MediaTrackSettings,
+  source = Track.Source.Camera,
+  captureSettings = settings,
+) {
+  return {
+    isLocal: true,
+    kind: Track.Kind.Video,
+    sid: 'TR_video',
+    source,
+    isMuted: false,
+    mediaStreamID: 'stream-id',
+    mediaStreamTrack: { enabled: true, id: 'primary-cid', getSettings: () => settings },
+    get dimensions() {
+      const { width, height } = captureSettings;
+      return width && height ? { width, height } : undefined;
+    },
+    addSimulcastTrack: () => ({ mediaStreamTrack: { id: 'backup-cid' } }),
+  } as unknown as LocalVideoTrack;
+}
+
+function makeBackupCodecParticipant(track: LocalVideoTrack) {
+  const participant = Object.create(LocalParticipant.prototype) as BackupCodecTestParticipant;
+  // Object.create runs no field initializers, so without this the encryption guard sees
+  // undefined and the method returns before publishing anything.
+  participant.encryptionType = Encryption_Type.NONE;
+  participant.trackPublications = new Map([['TR_video', { track }]]);
+  participant.roomOptions = {
+    publishDefaults: { videoCodec: 'vp9', backupCodec: { codec: 'vp8' }, simulcast: true },
+  };
+  participant.engine = {
+    isClosed: false,
+    addTrack: vi.fn(async () => ({})),
+    createSimulcastSender: vi.fn(async () => {}),
+    negotiate: vi.fn(async () => {}),
+  };
+  participant.log = { warn: vi.fn(), debug: vi.fn() };
+  return participant;
+}
+
+function capturedRequest(participant: BackupCodecTestParticipant): AddTrackRequest {
+  expect(participant.engine.addTrack).toHaveBeenCalledOnce();
+  return participant.engine.addTrack.mock.calls[0][0] as AddTrackRequest;
+}
+
+describe('LocalParticipant.publishAdditionalCodecForTrack', () => {
+  it('sets the capture dimensions and the backup codec layers', async () => {
+    const track = makeBackupCodecTrack({ width: 1280, height: 720 });
+    const participant = makeBackupCodecParticipant(track);
+
+    await participant.publishAdditionalCodecForTrack(track, 'vp8');
+
+    const req = capturedRequest(participant);
+    expect(req.width).toBe(1280);
+    expect(req.height).toBe(720);
+    expect(req.layers.length).toBeGreaterThan(0);
+    for (const layer of req.layers) {
+      expect(layer.width).toBeGreaterThan(0);
+      expect(layer.height).toBeGreaterThan(0);
+    }
+    expect(Math.max(...req.layers.map((layer) => layer.width))).toBe(1280);
+    expect(req.simulcastCodecs[0].codec).toBe('vp8');
+    expect(req.simulcastCodecs[0].layers).toEqual(req.layers);
+    expect(participant.log.warn).not.toHaveBeenCalled();
+  });
+
+  // screenshare disables simulcast for the backup codec, which collapses the encodings to a
+  // single unconstrained one and so to a single full size layer
+  it('sends one full size layer for a screenshare track', async () => {
+    const track = makeBackupCodecTrack({ width: 1280, height: 720 }, Track.Source.ScreenShare);
+    const participant = makeBackupCodecParticipant(track);
+
+    await participant.publishAdditionalCodecForTrack(track, 'vp8');
+
+    const req = capturedRequest(participant);
+    expect(req.layers).toHaveLength(1);
+    expect(req.layers[0].width).toBe(1280);
+    expect(req.layers[0].height).toBe(720);
+    expect(req.layers[0].quality).toBe(VideoQuality.HIGH);
+    expect(req.simulcastCodecs[0].layers).toEqual(req.layers);
+    expect(participant.log.warn).not.toHaveBeenCalled();
+  });
+
+  it('sizes layers from the processed track when a processor resizes', async () => {
+    const track = makeBackupCodecTrack({ width: 640, height: 360 }, Track.Source.Camera, {
+      width: 1280,
+      height: 720,
+    });
+    const participant = makeBackupCodecParticipant(track);
+
+    await participant.publishAdditionalCodecForTrack(track, 'vp8');
+
+    const req = capturedRequest(participant);
+    expect(req.width).toBe(640);
+    expect(req.height).toBe(360);
+    expect(Math.max(...req.layers.map((layer) => layer.width))).toBe(640);
+    expect(req.simulcastCodecs[0].layers).toEqual(req.layers);
+  });
+
+  it('omits layers when the capture dimensions are unknown', async () => {
+    const track = makeBackupCodecTrack({});
+    const participant = makeBackupCodecParticipant(track);
+
+    await participant.publishAdditionalCodecForTrack(track, 'vp8');
+
+    const req = capturedRequest(participant);
+    expect(req.width).toBe(0);
+    expect(req.height).toBe(0);
+    expect(req.layers).toEqual([]);
+    expect(req.simulcastCodecs[0].layers).toEqual([]);
+    expect(participant.log.warn).toHaveBeenCalledOnce();
+  });
+});