livekit-client 2.20.1 → 2.21.0

package/src/room/participant/RemoteParticipant.ts

@@ -1,8 +1,9 @@
-import type {
-  ParticipantInfo,
-  SubscriptionError,
-  UpdateSubscription,
-  UpdateTrackSettings,
+import {
+  ClientInfo_Capability,
+  type ParticipantInfo,
+  type SubscriptionError,
+  type UpdateSubscription,
+  type UpdateTrackSettings,
 } from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
 import { DeferrableMap } from '../../utils/deferrable-map';
@@ -47,6 +48,16 @@ export default class RemoteParticipant extends Participant {
    **/
   clientProtocol: number;
 
+  /** The client capabilities the remote participant advertises (e.g. deflate-raw compression
+   * support). Used to decide which peer-to-peer features can be used when sending to them.
+   *
+   * Differs from clientProtocol in that these are truely optional "additions" which can be used
+   * or not depending on client specific attributes rather than protocol level invariants.
+   *
+   * @internal
+   **/
+  capabilities: Array<ClientInfo_Capability>;
+
   private volumeMap: Map<Track.Source, number>;
 
   private audioOutput?: AudioOutputOptions;
@@ -72,6 +83,7 @@ export default class RemoteParticipant extends Participant {
         return new RemoteDataTrack(info, manager, { publisherIdentity: pi.identity });
       }),
       pi.clientProtocol,
+      pi.capabilities,
     );
   }
 
@@ -95,6 +107,7 @@ export default class RemoteParticipant extends Participant {
     kind: ParticipantKind = ParticipantKind.STANDARD,
     remoteDataTracks: Array<RemoteDataTrack> = [],
     clientProtocol: number = CLIENT_PROTOCOL_DEFAULT,
+    capabilities: Array<ClientInfo_Capability> = [],
   ) {
     super(sid, identity || '', name, metadata, attributes, loggerOptions, kind);
     this.signalClient = signalClient;
@@ -108,6 +121,7 @@ export default class RemoteParticipant extends Participant {
     );
     this.volumeMap = new Map();
     this.clientProtocol = clientProtocol;
+    this.capabilities = capabilities;
   }
 
   protected addTrackPublication(publication: RemoteTrackPublication) {

package/src/room/participant/publishUtils.ts

@@ -19,7 +19,6 @@ import {
   isSVCCodec,
   isSafariBased,
   isSafariSvcApi,
-  unwrapConstraint,
 } from '../utils';
 
 /** @internal */
@@ -468,16 +467,20 @@ export class ScalabilityMode {
   }
 }
 
+/**
+ * Returns the appropriate degradation preference for a video track based on its source.
+ *
+ * - Camera: 'maintain-framerate' (smoother video for real-time communication)
+ * - Screen share: 'maintain-resolution' (clarity is critical for reading text/UI)
+ * - Other/unknown: 'balanced'
+ */
 export function getDefaultDegradationPreference(track: LocalVideoTrack): RTCDegradationPreference {
-  // a few of reasons we have different default paths:
-  // 1. without this, Chrome seems to aggressively resize the SVC video stating `quality-limitation: bandwidth` even when BW isn't an issue
-  // 2. since we are overriding contentHint to motion (to workaround L1T3 publishing), it overrides the default degradationPreference to `balanced`
-  if (
-    track.source === Track.Source.ScreenShare ||
-    (track.constraints.height && unwrapConstraint(track.constraints.height) >= 1080)
-  ) {
-    return 'maintain-resolution';
-  } else {
-    return 'balanced';
+  switch (track.source) {
+    case Track.Source.Camera:
+      return 'maintain-framerate';
+    case Track.Source.ScreenShare:
+      return 'maintain-resolution';
+    default:
+      return 'balanced';
   }
 }

package/src/room/rpc/client/RpcClientManager.test.ts

@@ -16,6 +16,8 @@ describe('RpcClientManager', () => {
       const outgoingDataStreamManager = new OutgoingDataStreamManager(
         {} as unknown as RTCEngine,
         log,
+        (_identity) => CLIENT_PROTOCOL_DEFAULT,
+        () => [],
       );
 
       rpcClientManager = new RpcClientManager(
@@ -132,19 +134,13 @@ describe('RpcClientManager', () => {
 
   describe('v2 -> v2', () => {
     let rpcClientManager: RpcClientManager;
-    let mockStreamTextWriter: {
-      write: ReturnType<typeof vi.fn>;
-      close: ReturnType<typeof vi.fn>;
-    };
+    let sendTextMock: ReturnType<typeof vi.fn>;
     let mockOutgoingDataStreamManager: OutgoingDataStreamManager;
 
     beforeEach(() => {
-      mockStreamTextWriter = {
-        write: vi.fn().mockResolvedValue(undefined),
-        close: vi.fn().mockResolvedValue(undefined),
-      };
+      sendTextMock = vi.fn().mockResolvedValue(undefined);
       mockOutgoingDataStreamManager = {
-        streamText: vi.fn().mockResolvedValue(mockStreamTextWriter),
+        sendText: sendTextMock,
       } as unknown as OutgoingDataStreamManager;
 
       rpcClientManager = new RpcClientManager(
@@ -171,7 +167,8 @@ describe('RpcClientManager', () => {
       });
 
       // Verify the data stream was used with correct attributes
-      expect(mockOutgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+      expect(mockOutgoingDataStreamManager.sendText).toHaveBeenCalledWith(
+        'request-payload',
         expect.objectContaining({
           topic: RPC_REQUEST_DATA_STREAM_TOPIC,
           destinationIdentities: ['destination-identity'],
@@ -182,8 +179,6 @@ describe('RpcClientManager', () => {
           }),
         }),
       );
-      expect(mockStreamTextWriter.write).toHaveBeenCalledWith('request-payload');
-      expect(mockStreamTextWriter.close).toHaveBeenCalled();
 
       // No packet should have been emitted
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
@@ -213,7 +208,8 @@ describe('RpcClientManager', () => {
       });
 
       // Verify the data stream was used with correct attributes
-      expect(mockOutgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+      expect(mockOutgoingDataStreamManager.sendText).toHaveBeenCalledWith(
+        longPayload,
         expect.objectContaining({
           topic: RPC_REQUEST_DATA_STREAM_TOPIC,
           destinationIdentities: ['destination-identity'],
@@ -224,8 +220,6 @@ describe('RpcClientManager', () => {
           }),
         }),
       );
-      expect(mockStreamTextWriter.write).toHaveBeenCalledWith(longPayload);
-      expect(mockStreamTextWriter.close).toHaveBeenCalled();
 
       // No packet should have been emitted
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
@@ -337,14 +331,14 @@ describe('RpcClientManager', () => {
     });
 
     it('should not drop ack and response that arrive before publish completes', async () => {
-      // Hold the publish path open by blocking writer.close() until we explicitly resolve it.
-      let resolveClose!: () => void;
-      const closeBlocked = new Promise<void>((resolve) => {
-        resolveClose = resolve;
+      // Hold the publish path open by blocking sendText() until we explicitly resolve it.
+      let resolveSend!: () => void;
+      const sendBlocked = new Promise<void>((resolve) => {
+        resolveSend = resolve;
       });
-      mockStreamTextWriter.close = vi.fn().mockReturnValue(closeBlocked);
+      sendTextMock.mockReturnValue(sendBlocked);
 
-      // Start performRpc but don't await its return yet. The synchronous prefix runs streamText.
+      // Start performRpc but don't await its return yet. The synchronous prefix runs sendText.
       const performRpcPromise = rpcClientManager.performRpc({
         destinationIdentity: 'destination-identity',
         method: 'test-method',
@@ -352,11 +346,10 @@ describe('RpcClientManager', () => {
         responseTimeout: 200,
       });
 
-      // streamText was called synchronously; pull the request id out of the attributes.
-      const streamTextCalls = (mockOutgoingDataStreamManager.streamText as ReturnType<typeof vi.fn>)
-        .mock.calls;
-      expect(streamTextCalls.length).toBe(1);
-      const requestId = streamTextCalls[0][0].attributes[RpcRequestAttrs.RPC_REQUEST_ID];
+      // sendText was called synchronously; pull the request id out of the attributes.
+      const sendTextCalls = sendTextMock.mock.calls;
+      expect(sendTextCalls.length).toBe(1);
+      const requestId = sendTextCalls[0][1].attributes[RpcRequestAttrs.RPC_REQUEST_ID];
 
       // Deliver ack and response BEFORE close() unblocks - the publish has not yet returned.
       rpcClientManager.handleIncomingRpcAck(requestId);
@@ -367,7 +360,7 @@ describe('RpcClientManager', () => {
       );
 
       // Now allow the publish path to complete.
-      resolveClose();
+      resolveSend();
 
       const [, completionPromise] = await performRpcPromise;
       await expect(completionPromise).resolves.toStrictEqual('response-payload');

package/src/room/rpc/client/RpcClientManager.ts

@@ -145,7 +145,7 @@ export default class RpcClientManager extends (EventEmitter as new () => TypedEm
   ) {
     if (remoteClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
       // Send payload as a data stream - a "version 2" rpc request.
-      const writer = await this.outgoingDataStreamManager.streamText({
+      await this.outgoingDataStreamManager.sendText(payload, {
         topic: RPC_REQUEST_DATA_STREAM_TOPIC,
         destinationIdentities: [destinationIdentity],
         attributes: {
@@ -155,9 +155,6 @@ export default class RpcClientManager extends (EventEmitter as new () => TypedEm
           [RpcRequestAttrs.RPC_REQUEST_VERSION]: `${RPC_VERSION_V2}`,
         },
       });
-
-      await writer.write(payload);
-      await writer.close();
       return;
     }
 

package/src/room/rpc/server/RpcServerManager.test.ts

@@ -2,7 +2,11 @@ import { RpcRequest } from '@livekit/protocol';
 import { assert, beforeEach, describe, expect, it, vi } from 'vitest';
 import log from '../../../logger';
 import { subscribeToEvents } from '../../../utils/subscribeToEvents';
-import { CLIENT_PROTOCOL_DATA_STREAM_RPC, CLIENT_PROTOCOL_DEFAULT } from '../../../version';
+import {
+  CLIENT_PROTOCOL_DATA_STREAM_RPC,
+  CLIENT_PROTOCOL_DATA_STREAM_V2,
+  CLIENT_PROTOCOL_DEFAULT,
+} from '../../../version';
 import type RTCEngine from '../../RTCEngine';
 import OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
 import { RPC_RESPONSE_DATA_STREAM_TOPIC, RpcError, RpcRequestAttrs } from '../utils';
@@ -17,6 +21,8 @@ describe('RpcServerManager', () => {
       const outgoingDataStreamManager = new OutgoingDataStreamManager(
         {} as unknown as RTCEngine,
         log,
+        (_identity) => CLIENT_PROTOCOL_DEFAULT,
+        () => [],
       );
 
       rpcServerManager = new RpcServerManager(
@@ -184,22 +190,17 @@ describe('RpcServerManager', () => {
   describe('v2 -> v2', () => {
     let rpcServerManager: RpcServerManager;
     let outgoingDataStreamManager: OutgoingDataStreamManager;
-    let mockStreamTextWriter: {
-      write: ReturnType<typeof vi.fn>;
-      close: ReturnType<typeof vi.fn>;
-    };
 
     beforeEach(() => {
-      outgoingDataStreamManager = new OutgoingDataStreamManager({} as unknown as RTCEngine, log);
-
-      mockStreamTextWriter = {
-        write: vi.fn().mockResolvedValue(undefined),
-        close: vi.fn().mockResolvedValue(undefined),
-      };
-      vi.spyOn(outgoingDataStreamManager, 'streamText').mockResolvedValue(
-        mockStreamTextWriter as any,
+      outgoingDataStreamManager = new OutgoingDataStreamManager(
+        {} as unknown as RTCEngine,
+        log,
+        (_identity) => CLIENT_PROTOCOL_DATA_STREAM_V2,
+        () => [],
       );
 
+      vi.spyOn(outgoingDataStreamManager, 'sendText').mockResolvedValue(undefined as any);
+
       rpcServerManager = new RpcServerManager(
         log,
         outgoingDataStreamManager,
@@ -243,15 +244,14 @@ describe('RpcServerManager', () => {
 
       // The response should have been sent via data stream, not packet
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
-      expect(outgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+      expect(outgoingDataStreamManager.sendText).toHaveBeenCalledWith(
+        'response payload',
         expect.objectContaining({
           topic: RPC_RESPONSE_DATA_STREAM_TOPIC,
           destinationIdentities: ['caller-identity'],
           attributes: { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
         }),
       );
-      expect(mockStreamTextWriter.write).toHaveBeenCalledWith('response payload');
-      expect(mockStreamTextWriter.close).toHaveBeenCalled();
     });
 
     it('should receive a large rpc request (> 15kb) and send a large response via data stream from a participant', async () => {
@@ -277,15 +277,14 @@ describe('RpcServerManager', () => {
 
       // The response should have been sent via data stream, not packet
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
-      expect(outgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+      expect(outgoingDataStreamManager.sendText).toHaveBeenCalledWith(
+        new Array(20_000).fill('B').join(''),
         expect.objectContaining({
           topic: RPC_RESPONSE_DATA_STREAM_TOPIC,
           destinationIdentities: ['caller-identity'],
           attributes: { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
         }),
       );
-      expect(mockStreamTextWriter.write).toHaveBeenCalledWith(new Array(20_000).fill('B').join(''));
-      expect(mockStreamTextWriter.close).toHaveBeenCalled();
     });
 
     it('should register an RPC method handler', async () => {
@@ -317,7 +316,7 @@ describe('RpcServerManager', () => {
 
       // Response goes via data stream, not packet
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
-      expect(outgoingDataStreamManager.streamText).toHaveBeenCalled();
+      expect(outgoingDataStreamManager.sendText).toHaveBeenCalled();
     });
 
     it('should catch and transform unhandled errors in the RPC method handler', async () => {
@@ -414,7 +413,7 @@ describe('RpcServerManager', () => {
       const errorResponse = errorEvent.packet.value.value.value.value;
       expect(errorResponse.code).toStrictEqual(RpcError.ErrorCode.UNSUPPORTED_METHOD);
 
-      expect(outgoingDataStreamManager.streamText).not.toHaveBeenCalled();
+      expect(outgoingDataStreamManager.sendText).not.toHaveBeenCalled();
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
     });
   });
@@ -424,8 +423,10 @@ describe('RpcServerManager', () => {
       const outgoingDataStreamManager = new OutgoingDataStreamManager(
         {} as unknown as RTCEngine,
         log,
+        (_identity) => CLIENT_PROTOCOL_DEFAULT,
+        () => [],
       );
-      const streamTextSpy = vi.spyOn(outgoingDataStreamManager, 'streamText');
+      const sendTextSpy = vi.spyOn(outgoingDataStreamManager, 'sendText');
 
       const rpcServerManager = new RpcServerManager(
         log,
@@ -457,7 +458,7 @@ describe('RpcServerManager', () => {
       assert(ackEvent.packet.value.case === 'rpcAck');
 
       // Response should be a v1 RpcResponse packet, not a data stream
-      expect(streamTextSpy).not.toHaveBeenCalled();
+      expect(sendTextSpy).not.toHaveBeenCalled();
       const responseEvent = await managerEvents.waitFor('sendDataPacket');
       assert(responseEvent.packet.value.case === 'rpcResponse');
       const rpcResponse = responseEvent.packet.value.value;

package/src/room/rpc/server/RpcServerManager.ts

@@ -263,13 +263,11 @@ export default class RpcServerManager extends (EventEmitter as new () => TypedEm
 
     if (callerClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
       // Send response as a data stream
-      const writer = await this.outgoingDataStreamManager.streamText({
+      await this.outgoingDataStreamManager.sendText(payload, {
         topic: RPC_RESPONSE_DATA_STREAM_TOPIC,
         destinationIdentities: [destinationIdentity],
         attributes: { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
       });
-      await writer.write(payload);
-      await writer.close();
       return;
     }
 

package/src/room/track/LocalAudioTrack.ts

@@ -103,6 +103,22 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
     await this.restart(constraints);
   }
 
+  async applyConstraints(
+    constraints: Pick<
+      AudioCaptureOptions,
+      'autoGainControl' | 'noiseSuppression' | 'echoCancellation' | 'voiceIsolation'
+    >,
+  ): Promise<void> {
+    const unlock = await this.trackChangeLock.lock();
+    try {
+      const res = await this._mediaStreamTrack.applyConstraints(constraints);
+      this._constraints = { ...this._constraints, ...constraints };
+      return res;
+    } finally {
+      unlock();
+    }
+  }
+
   protected async restart(
     constraints?: MediaTrackConstraints,
     isUnmuting?: boolean,

package/src/room/track/Track.ts

@@ -60,6 +60,9 @@ export abstract class Track<
 
   /** @internal */
   setStreamState(value: Track.StreamState) {
+    if (this._streamState !== value) {
+      this.log.debug(`stream state changed: ${this._streamState} -> ${value}`);
+    }
     this._streamState = value;
   }
 
@@ -90,8 +93,8 @@ export abstract class Track<
     loggerOptions: LoggerOptions = {},
   ) {
     super();
-    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.Track);
     this.loggerContextCb = loggerOptions.loggerContextCb;
+    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.Track, () => this.logContext);
 
     this.setMaxListeners(100);
     this.kind = kind;
@@ -185,11 +188,11 @@ export abstract class Track<
           this.emit(hasAudio ? TrackEvent.AudioPlaybackFailed : TrackEvent.VideoPlaybackFailed, e);
         } else if (e.name === 'AbortError') {
           // commonly triggered by another `play` request, only log for debugging purposes
-          log.debug(
+          this.log.debug(
             `${hasAudio ? 'audio' : 'video'} playback aborted, likely due to new play request`,
           );
         } else {
-          log.warn(`could not playback ${hasAudio ? 'audio' : 'video'}`, e);
+          this.log.warn(`could not playback ${hasAudio ? 'audio' : 'video'}`, { error: e });
         }
         // If audio playback isn't allowed make sure we still play back the video
         if (
@@ -252,6 +255,7 @@ export abstract class Track<
   }
 
   stop() {
+    this.log.debug('stopping track');
     this.stopMonitor();
     this._mediaStreamTrack.stop();
   }
@@ -279,12 +283,12 @@ export abstract class Track<
 
   /** @internal */
   updateLoggerOptions(loggerOptions: LoggerOptions) {
-    if (loggerOptions.loggerName) {
-      this.log = getLogger(loggerOptions.loggerName);
-    }
     if (loggerOptions.loggerContextCb) {
       this.loggerContextCb = loggerOptions.loggerContextCb;
     }
+    if (loggerOptions.loggerName) {
+      this.log = getLogger(loggerOptions.loggerName, () => this.logContext);
+    }
   }
 
   private recycleElement(element: HTMLMediaElement) {

package/src/room/track/options.ts

@@ -84,7 +84,17 @@ export interface TrackPublishDefaults {
   scalabilityMode?: ScalabilityMode;
 
   /**
-   * degradation preference
+   * Controls how the encoder trades off between resolution and framerate
+   * when bandwidth is constrained.
+   *
+   * - 'maintain-framerate': Prioritizes framerate, reduces resolution if needed
+   * - 'maintain-resolution': Prioritizes resolution, drops frames if needed
+   * - 'balanced': Balances between both
+   *
+   * If not set, the SDK uses defaults based on track source:
+   * - Camera: 'maintain-framerate' (smoother video for real-time communication)
+   * - Screen share: 'maintain-resolution' (clarity is critical for text/UI)
+   * - Other/unknown: 'balanced'
    */
   degradationPreference?: RTCDegradationPreference;
 

package/src/room/types.ts

@@ -21,6 +21,21 @@ export interface SendTextOptions {
   attachments?: Array<File>;
   onProgress?: (progress: number) => void;
   attributes?: Record<string, string>;
+  /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+   * when every recipient supports data streams v2 and the runtime can compress. */
+  compress?: boolean;
+}
+
+export interface SendBytesOptions {
+  topic?: string;
+  destinationIdentities?: Array<string>;
+  attributes?: Record<string, string>;
+  onProgress?: (progress: number) => void;
+  /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+   * when every recipient supports data streams v2 and the runtime can compress. */
+  compress?: boolean;
+  name?: string;
+  mimeType?: string;
 }
 
 export interface StreamTextOptions {
@@ -51,6 +66,9 @@ export type SendFileOptions = Pick<
 > & {
   onProgress?: (progress: number) => void;
   encryptionType?: Encryption_Type.NONE;
+  /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+   * when every recipient supports data streams v2 and the runtime can compress. */
+  compress?: boolean;
 };
 
 export type DataPublishOptions = {

package/src/room/utils.ts

@@ -781,6 +781,73 @@ export function splitUtf8(s: string, n: number): NonSharedUint8Array[] {
   return result;
 }
 
+/** Wraps a byte array in a `ReadableStream` that yields it as a single chunk and then closes. */
+export function readableFromBytes(bytes: NonSharedUint8Array): ReadableStream<NonSharedUint8Array> {
+  return new ReadableStream<NonSharedUint8Array>({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    },
+  });
+}
+
+/**
+ * Re-chunks a byte stream into pieces of exactly `chunkSize` bytes (the final piece may be
+ * smaller), coalescing or splitting the source's pieces as needed. Memory use is bounded to roughly
+ * `chunkSize` plus one source read, so it never buffers the whole stream — used to pack
+ * `CompressionStream`/`file.stream()` output into MTU-sized data-stream chunks.
+ */
+export async function* readBytesInChunks(
+  source: ReadableStream<NonSharedUint8Array>,
+  chunkSize: number,
+): AsyncGenerator<NonSharedUint8Array> {
+  const reader = source.getReader();
+  let buffer = new Uint8Array(0);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value.byteLength === 0) {
+        continue;
+      }
+      const merged = new Uint8Array(buffer.byteLength + value.byteLength);
+      merged.set(buffer);
+      merged.set(value, buffer.byteLength);
+      buffer = merged;
+      while (buffer.byteLength >= chunkSize) {
+        yield buffer.slice(0, chunkSize);
+        buffer = buffer.slice(chunkSize);
+      }
+    }
+    if (buffer.byteLength > 0) {
+      yield buffer;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/** Encodes a byte array as a base64 string (suitable for embedding binary data in a string field). */
+export function encodeBase64(bytes: Uint8Array): string {
+  let binary = '';
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]!);
+  }
+  return btoa(binary);
+}
+
+/** Decodes a base64 string (as produced by {@link encodeBase64}) back into a byte array. */
+export function decodeBase64(base64: string): Uint8Array {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
 export function extractMaxAgeFromRequestHeaders(headers: Headers): number | undefined {
   const cacheControl = headers.get('Cache-Control');
   if (cacheControl) {