livekit-client 2.18.7 → 2.18.8

package/dist/ts4.2/room/PCTransportManager.d.ts

@@ -1,5 +1,7 @@
 import { SignalTarget } from '@livekit/protocol';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import PCTransport from './PCTransport';
+import { NegotiationError } from './errors';
 import type { LoggerOptions } from './types';
 export declare enum PCTransportState {
     NEW = 0,
@@ -43,7 +45,7 @@ export declare class PCTransportManager {
     createSubscriberAnswerFromOffer(sd: RTCSessionDescriptionInit, offerId: number): Promise<RTCSessionDescriptionInit | undefined>;
     updateConfiguration(config: RTCConfiguration, iceRestart?: boolean): void;
     ensurePCTransportConnection(abortController?: AbortController, timeout?: number): Promise<void>;
-    negotiate(abortController: AbortController): Promise<void>;
+    negotiate(abortController: AbortController): Promise<Throws<void, NegotiationError | Error>>;
     addPublisherTransceiver(track: MediaStreamTrack, transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
     addPublisherTransceiverOfKind(kind: 'audio' | 'video', transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
     getMidForReceiver(receiver: RTCRtpReceiver): string | null | undefined;

package/dist/ts4.2/room/data-track/LocalDataTrack.d.ts

@@ -1,4 +1,5 @@
 import type { StructuredLogger } from '../../logger';
+import { Future } from '../utils';
 import type { DataTrackFrame } from './frame';
 import type { DataTrackHandle } from './handle';
 import type OutgoingDataTrackManager from './outgoing/OutgoingDataTrackManager';
@@ -15,8 +16,12 @@ export default class LocalDataTrack implements ILocalTrack, IDataTrack {
     protected handle: DataTrackHandle | null;
     protected manager: OutgoingDataTrackManager;
     protected log: StructuredLogger;
+    /** Resolves once the data track has sent all pending packets the rtc data channel buffer. */
+    protected flushedFuture: Future<void, never>;
     /** @internal */
     constructor(options: DataTrackOptions, manager: OutgoingDataTrackManager);
+    private handleManagerReset;
+    private handleManagerPacketsFlushed;
     /** @internal */
     static withExplicitHandle(options: DataTrackOptions, manager: OutgoingDataTrackManager, handle: DataTrackHandle): LocalDataTrack;
     /** Metrics about the data track publication. */
@@ -39,6 +44,32 @@ export default class LocalDataTrack implements ILocalTrack, IDataTrack {
      * - The room is no longer connected
      */
     tryPush(frame: DataTrackFrame): Promise<import("@livekit/throws-transformer/throws").Throws<void, DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.TrackUnpublished> | DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.Dropped>>>;
+    /**
+     * When called, waits for all in flight packets to be sent before resolving.
+     *
+     * Use this to:
+     *
+     * 1. Send frames exactly in order:
+     * ```ts
+     * await track.tryPush(/* ... *\/);
+     * await track.flush();
+     * await track.tryPush(/* ... *\/);
+     * await track.flush();
+     * // ... etc ...
+     * ```
+     *
+     * 2. Wait for frames to all be delivered before unpublishing a local data track:
+     *
+     * ```ts
+     * await track.tryPush(/* ... *\/);
+     * await track.tryPush(/* ... *\/);
+     * await track.tryPush(/* ... *\/);
+     * // ... etc ...
+     * await track.flush();
+     * await track.unpublish();
+     * ```
+     **/
+    flush(): Promise<void>;
     /**
      * Unpublish the track from the SFU. Once this is called, any further calls to {@link tryPush}
      * will fail.

package/dist/ts4.2/room/data-track/handle.d.ts

@@ -22,5 +22,6 @@ export declare class DataTrackHandleAllocator {
     value: number;
     /** Returns a unique track handle for the next publication, if one can be obtained. */
     get(): DataTrackHandle | null;
+    reset(): void;
 }
 //# sourceMappingURL=handle.d.ts.map

package/dist/ts4.2/room/data-track/incoming/IncomingDataTrackManager.d.ts

@@ -34,7 +34,7 @@ export default class IncomingDataTrackManager extends IncomingDataTrackManager_b
      *
      * This is an index that allows track descriptors to be looked up
      * by subscriber handle in O(1) time, to make routing incoming packets
-     * a (hot code path) faster.
+     * (a hot code path) faster.
      */
     private subscriptionHandles;
     constructor(options?: IncomingDataTrackManagerOptions);
@@ -107,8 +107,9 @@ export default class IncomingDataTrackManager extends IncomingDataTrackManager_b
     /** Called when a remote participant is disconnected so that any pending data tracks can be
      * cancelled. */
     handleRemoteParticipantDisconnected(remoteParticipantIdentity: RemoteParticipant['identity']): void;
-    /** Shutdown the manager, ending any subscriptions. */
-    shutdown(): void;
+    /** Resets the manager, ending any subscriptions, and getting it ready for the next room
+     * connection.  */
+    reset(): void;
 }
 export {};
 //# sourceMappingURL=IncomingDataTrackManager.d.ts.map

package/dist/ts4.2/room/data-track/outgoing/OutgoingDataTrackManager.d.ts

@@ -7,7 +7,7 @@ import { DataTrackHandle } from '../handle';
 import type { DataTrackInfo } from '../types';
 import { DataTrackPublishError, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
 import DataTrackOutgoingPipeline from './pipeline';
-import type { DataTrackOptions, EventPacketAvailable, EventSfuPublishRequest, EventSfuUnpublishRequest, EventTrackPublished, EventTrackUnpublished, SfuPublishResponseResult } from './types';
+import type { DataTrackOptions, EventPacketAvailable, EventPacketsFlushed, EventSfuPublishRequest, EventSfuUnpublishRequest, EventTrackPublished, EventTrackUnpublished, SfuPublishResponseResult } from './types';
 export type PendingDescriptor = {
     type: 'pending';
     /** Resolves when the descriptor is fully published. */
@@ -37,6 +37,11 @@ export type DataTrackOutgoingManagerCallbacks = {
     trackPublished: (event: EventTrackPublished) => void;
     /** A {@link LocalDataTrack} has been unpublished */
     trackUnpublished: (event: EventTrackUnpublished) => void;
+    /** A {@link LocalDataTrack} has had all of its in flight packets sent via the rtc data channel. */
+    packetsFlushed: (event: EventPacketsFlushed) => void;
+    /** The manager has been reset and all state has been cleared in preparation for the next room
+     * connection. */
+    reset: () => void;
 };
 type OutgoingDataTrackManagerOptions = {
     /**
@@ -51,6 +56,10 @@ export default class OutgoingDataTrackManager extends OutgoingDataTrackManager_b
     private e2eeManager;
     private handleAllocator;
     private descriptors;
+    /** Number of packets for each data track which have been emitted via the `packetAvailable` event
+     * and which have not yet been sent via the rtc data channel yet. Once this goes to 0, then
+     * all in flight packets have been delivered, and the data tracks is "flushed". */
+    private inFlightPacketCounter;
     constructor(options?: OutgoingDataTrackManagerOptions);
     static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>): OutgoingDataTrackManager;
     /** @internal */
@@ -65,6 +74,11 @@ export default class OutgoingDataTrackManager extends OutgoingDataTrackManager_b
      * @internal
      */
     tryProcessAndSend(handle: DataTrackHandle, frame: DataTrackFrameInternal): Promise<Throws<void, DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped> | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>>>;
+    /** The client has sent a packet over the rtc data channel. This signal is used for determining
+     * once all packets are sent and a data track has been "flushed".
+     *
+     * @internal */
+    handlePacketSendComplete(handle: DataTrackHandle): void;
     /**
      * Client requested to publish a track.
      *
@@ -102,10 +116,11 @@ export default class OutgoingDataTrackManager extends OutgoingDataTrackManager_b
      */
     sfuWillRepublishTracks(): void;
     /**
-     * Shuts down the manager and all associated tracks.
+     * Reset's the state of the manager and all associated tracks. Run on room disconnect to get
+     * the manager ready for the next room connection.
      * @internal
      **/
-    shutdown(): Promise<void>;
+    reset(): Promise<void>;
 }
 export {};
 //# sourceMappingURL=OutgoingDataTrackManager.d.ts.map

package/dist/ts4.2/room/data-track/outgoing/types.d.ts

@@ -26,6 +26,8 @@ export type EventSfuUnpublishRequest = {
 };
 /** A serialized packet is ready to be sent over the transport. */
 export type EventPacketAvailable = {
+    /** The handle associated with the data track which this packet bytes belong to. */
+    handle: DataTrackHandle;
     bytes: Uint8Array;
 };
 /** A track has been created by a local participant and is available to be
@@ -37,4 +39,8 @@ export type EventTrackPublished = {
 export type EventTrackUnpublished = {
     sid: DataTrackSid;
 };
+/** A track has had all of its in flight packets sent via the rtc data channel. */
+export type EventPacketsFlushed = {
+    handle: DataTrackHandle;
+};
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.18.7",
+  "version": "2.18.8",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",

package/src/api/SignalClient.ts

@@ -247,8 +247,8 @@ export class SignalClient {
   private useV0SignalPath = false;
 
   constructor(useJSON: boolean = false, loggerOptions: LoggerOptions = {}) {
-    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.Signal);
     this.loggerContextCb = loggerOptions.loggerContextCb;
+    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.Signal, () => this.logContext);
     this.useJSON = useJSON;
     this.requestQueue = new AsyncQueue();
     this.queuedRequests = [];
@@ -284,10 +284,7 @@ export class SignalClient {
     reason?: ReconnectReason,
   ): Promise<ReconnectResponse | undefined> {
     if (!this.options) {
-      this.log.warn(
-        'attempted to reconnect without signal options being set, ignoring',
-        this.logContext,
-      );
+      this.log.warn('attempted to reconnect without signal options being set, ignoring');
       return;
     }
     this.state = SignalConnectionState.RECONNECTING;
@@ -377,10 +374,9 @@ export class SignalClient {
         if (redactedUrl.searchParams.has('access_token')) {
           redactedUrl.searchParams.set('access_token', '<redacted>');
         }
-        this.log.debug(`connecting to ${redactedUrl}`, {
+        this.log.info(`signal connecting to ${redactedUrl}`, {
           reconnect: opts.reconnect,
           reconnectReason: opts.reconnectReason,
-          ...this.logContext,
         });
         if (this.ws) {
           await this.close(false);
@@ -399,7 +395,6 @@ export class SignalClient {
               }
               if (closeInfo.closeCode !== 1000) {
                 this.log.warn(`websocket closed`, {
-                  ...this.logContext,
                   reason: closeInfo.reason,
                   code: closeInfo.closeCode,
                   wasClean: closeInfo.closeCode === 1000,
@@ -466,7 +461,6 @@ export class SignalClient {
 
             if (this.pingTimeoutDuration && this.pingTimeoutDuration > 0) {
               this.log.debug('ping config', {
-                ...this.logContext,
                 timeout: this.pingTimeoutDuration,
                 interval: this.pingIntervalDuration,
               });
@@ -555,7 +549,7 @@ export class SignalClient {
         await Promise.race([closePromise, sleep(MAX_WS_CLOSE_TIME)]);
       }
     } catch (e) {
-      this.log.debug('websocket error while closing', { ...this.logContext, error: e });
+      this.log.debug('websocket error while closing', { error: e });
     } finally {
       if (updateState) {
         this.state = SignalConnectionState.DISCONNECTED;
@@ -566,7 +560,7 @@ export class SignalClient {
 
   // initial offer after joining
   sendOffer(offer: RTCSessionDescriptionInit, offerId: number) {
-    this.log.debug('sending offer', { ...this.logContext, offerSdp: offer.sdp });
+    this.log.debug('sending offer', { offerSdp: offer.sdp });
     this.sendRequest({
       case: 'offer',
       value: toProtoSessionDescription(offer, offerId),
@@ -575,7 +569,7 @@ export class SignalClient {
 
   // answer a server-initiated offer
   sendAnswer(answer: RTCSessionDescriptionInit, offerId: number) {
-    this.log.debug('sending answer', { ...this.logContext, answerSdp: answer.sdp });
+    this.log.debug('sending answer', { answerSdp: answer.sdp });
     return this.sendRequest({
       case: 'answer',
       value: toProtoSessionDescription(answer, offerId),
@@ -583,7 +577,7 @@ export class SignalClient {
   }
 
   sendIceCandidate(candidate: RTCIceCandidateInit, target: SignalTarget) {
-    this.log.debug('sending ice candidate', { ...this.logContext, candidate });
+    this.log.debug('sending ice candidate', { candidate });
     return this.sendRequest({
       case: 'trickle',
       value: new TrickleRequest({
@@ -768,10 +762,7 @@ export class SignalClient {
       return;
     }
     if (!this.streamWriter) {
-      this.log.error(
-        `cannot send signal request before connected, type: ${message?.case}`,
-        this.logContext,
-      );
+      this.log.error(`cannot send signal request before connected, type: ${message?.case}`);
       return;
     }
     const req = new SignalRequest({ message });
@@ -783,14 +774,14 @@ export class SignalClient {
         await this.streamWriter.write(req.toBinary());
       }
     } catch (e) {
-      this.log.error('error sending signal message', { ...this.logContext, error: e });
+      this.log.error('error sending signal message', { error: e });
     }
   }
 
   private handleSignalResponse(res: SignalResponse) {
     const msg = res.message;
     if (msg == undefined) {
-      this.log.debug('received unsupported message', this.logContext);
+      this.log.debug('received unsupported message');
       return;
     }
 
@@ -899,7 +890,7 @@ export class SignalClient {
         this.onDataTrackSubscriberHandles(msg.value);
       }
     } else {
-      this.log.debug('unsupported message', { ...this.logContext, msgCase: msg.case });
+      this.log.debug('unsupported message', { msgCase: msg.case });
     }
 
     if (!pingHandled) {
@@ -920,14 +911,14 @@ export class SignalClient {
     if (this.state === SignalConnectionState.DISCONNECTED) return;
     const onCloseCallback = this.onClose;
     await this.close(undefined, reason);
-    this.log.debug(`websocket connection closed: ${reason}`, { ...this.logContext, reason });
+    this.log.info(`websocket connection closed: ${reason}`, { reason });
     if (onCloseCallback) {
       onCloseCallback(reason);
     }
   }
 
   private handleWSError(error: unknown) {
-    this.log.error('websocket error', { ...this.logContext, error });
+    this.log.error('websocket error', { error });
   }
 
   /**
@@ -937,7 +928,7 @@ export class SignalClient {
   private resetPingTimeout() {
     this.clearPingTimeout();
     if (!this.pingTimeoutDuration) {
-      this.log.warn('ping timeout duration not set', this.logContext);
+      this.log.warn('ping timeout duration not set');
       return;
     }
     this.pingTimeout = CriticalTimers.setTimeout(() => {
@@ -945,7 +936,6 @@ export class SignalClient {
         `ping timeout triggered. last pong received at: ${new Date(
           Date.now() - this.pingTimeoutDuration! * 1000,
         ).toUTCString()}`,
-        this.logContext,
       );
       this.handleOnClose('ping timeout');
     }, this.pingTimeoutDuration * 1000);
@@ -964,17 +954,17 @@ export class SignalClient {
     this.clearPingInterval();
     this.resetPingTimeout();
     if (!this.pingIntervalDuration) {
-      this.log.warn('ping interval duration not set', this.logContext);
+      this.log.warn('ping interval duration not set');
       return;
     }
-    this.log.debug('start ping interval', this.logContext);
+    this.log.debug('start ping interval');
     this.pingInterval = CriticalTimers.setInterval(() => {
       this.sendPing();
     }, this.pingIntervalDuration * 1000);
   }
 
   private clearPingInterval() {
-    this.log.debug('clearing ping interval', this.logContext);
+    this.log.debug('clearing ping interval');
     this.clearPingTimeout();
     if (this.pingInterval) {
       CriticalTimers.clearInterval(this.pingInterval);
@@ -994,6 +984,7 @@ export class SignalClient {
     firstMessage?: SignalResponse,
   ) {
     this.state = SignalConnectionState.CONNECTED;
+    this.log.info('signal connected');
     clearTimeout(timeoutHandle);
     this.startPingInterval();
     this.startReadingLoop(connection.readable.getReader(), firstMessage);
@@ -1031,10 +1022,7 @@ export class SignalClient {
         };
       } else {
         // in reconnecting, any message received means signal reconnected and we still need to process it
-        this.log.debug(
-          'declaring signal reconnected without reconnect response received',
-          this.logContext,
-        );
+        this.log.debug('declaring signal reconnected without reconnect response received');
         return {
           isValid: true,
           response: undefined,

package/src/logger.test.ts

@@ -0,0 +1,61 @@
+import * as loglevel from 'loglevel';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  type LogExtension,
+  LogLevel,
+  LoggerNames,
+  type StructuredLogger,
+  getLogger,
+  setLogExtension,
+  setLogLevel,
+} from './logger';
+
+describe('getLogger with context provider', () => {
+  afterEach(() => {
+    setLogLevel(LogLevel.info);
+  });
+
+  const hookBase = (name: LoggerNames, extension: LogExtension) => {
+    const base = loglevel.getLogger(name) as StructuredLogger;
+    setLogExtension(extension, base);
+  };
+
+  it('omits the prefix when the bound context has no display keys', () => {
+    const extension = vi.fn<LogExtension>();
+    hookBase(LoggerNames.Room, extension);
+    setLogLevel(LogLevel.info, LoggerNames.Room);
+
+    const log = getLogger(LoggerNames.Room, () => ({ irrelevant: 'x' }));
+    log.info('plain');
+
+    expect(extension).toHaveBeenCalledWith(LogLevel.info, 'plain', { irrelevant: 'x' });
+  });
+
+  it('reflects dynamic changes to the bound context on every call', () => {
+    const extension = vi.fn<LogExtension>();
+    hookBase(LoggerNames.Engine, extension);
+    setLogLevel(LogLevel.info, LoggerNames.Engine);
+
+    let current: Record<string, string> = { room: 'r1' };
+    const log = getLogger(LoggerNames.Engine, () => current);
+
+    log.info('first');
+    current = { room: 'r2', participant: 'bob' };
+    log.info('second');
+
+    const infos = extension.mock.calls.filter((c) => c[0] === LogLevel.info);
+    expect(infos[0][2]).toEqual({ room: 'r1' });
+    expect(infos[1][2]).toEqual({ room: 'r2', participant: 'bob' });
+  });
+
+  it('returns an unwrapped logger when no context provider is supplied', () => {
+    const extension = vi.fn<LogExtension>();
+    hookBase(LoggerNames.Signal, extension);
+    setLogLevel(LogLevel.info, LoggerNames.Signal);
+
+    const log = getLogger(LoggerNames.Signal);
+    log.info('raw');
+
+    expect(extension).toHaveBeenCalledWith(LogLevel.info, 'raw', undefined);
+  });
+});

package/src/logger.ts

@@ -37,7 +37,9 @@ export type StructuredLogger = log.Logger & {
   getLevel: () => number;
 };
 
-let livekitLogger = log.getLogger('livekit');
+export type ContextProvider = () => object | undefined;
+
+let livekitLogger = log.getLogger(LoggerNames.Default);
 const livekitLoggers = Object.values(LoggerNames).map((name) => log.getLogger(name));
 
 livekitLogger.setDefaultLevel(LogLevel.info);
@@ -46,11 +48,43 @@ export default livekitLogger as StructuredLogger;
 
 /**
  * @internal
+ *
+ * Get a named logger. When `ctxFn` is supplied, every log call
+ * automatically:
+ * 1. prepends a `[key=value ...]` prefix derived from `ctxFn()` to the
+ *    message string, so identifiers are visible in browser devtools
+ *    without expanding the structured context object, and
+ * 2. merges `ctxFn()` into the structured context passed to any
+ *    `setLogExtension` consumer, so ingestion pipelines continue to
+ *    receive the full metadata unchanged.
  */
-export function getLogger(name: string) {
+export function getLogger(name: string, ctxFn?: ContextProvider) {
   const logger = log.getLogger(name);
   logger.setDefaultLevel(livekitLogger.getLevel());
-  return logger as StructuredLogger;
+  if (!ctxFn) {
+    return logger as StructuredLogger;
+  }
+  return wrapWithContext(logger as StructuredLogger, ctxFn);
+}
+
+function wrapWithContext(base: StructuredLogger, ctxFn: ContextProvider): StructuredLogger {
+  type LogMethod = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+  // Resolve the underlying method on every call so that later
+  // setLogExtension installations (which replace the base logger's
+  // methods via loglevel's methodFactory) are picked up.
+  const wrap = (method: LogMethod) => (msg: string, extra?: object) => {
+    const ctx = ctxFn();
+    const merged = ctx || extra ? { ...ctx, ...extra } : undefined;
+    base[method](msg, merged);
+  };
+
+  const proxy = Object.create(base) as StructuredLogger;
+  proxy.trace = wrap('trace');
+  proxy.debug = wrap('debug');
+  proxy.info = wrap('info');
+  proxy.warn = wrap('warn');
+  proxy.error = wrap('error');
+  return proxy;
 }
 
 export function setLogLevel(level: LogLevel | LogLevelString, loggerName?: LoggerNames) {
@@ -93,4 +127,4 @@ export function setLogExtension(extension: LogExtension, logger?: StructuredLogg
   });
 }
 
-export const workerLogger = log.getLogger('lk-e2ee') as StructuredLogger;
+export const workerLogger = log.getLogger(LoggerNames.E2EE) as StructuredLogger;

package/src/room/PCTransport.ts

@@ -1,7 +1,8 @@
 import { Mutex } from '@livekit/mutex';
 import { EventEmitter } from 'events';
 import { parse, write } from 'sdp-transform';
-import type { MediaDescription, SessionDescription } from 'sdp-transform';
+import type { MediaAttributes, MediaDescription, SessionDescription } from 'sdp-transform';
+import type TypedEmitter from 'typed-emitter';
 import log, { LoggerNames, getLogger } from '../logger';
 import { debounce } from './debounce';
 import { NegotiationError, UnexpectedConnectionState } from './errors';
@@ -29,11 +30,16 @@ const debounceInterval = 20;
 export const PCEvents = {
   NegotiationStarted: 'negotiationStarted',
   NegotiationComplete: 'negotiationComplete',
+  // Fired with the offerId for every successful publisher answer application,
+  // including answers that immediately recurse into another offer via
+  // `renegotiate`. Use this rather than NegotiationComplete to know that a
+  // specific offer has been negotiated end-to-end.
+  OfferAnswered: 'offerAnswered',
   RTPVideoPayloadTypes: 'rtpVideoPayloadTypes',
 } as const;
 
 /** @internal */
-export default class PCTransport extends EventEmitter {
+export default class PCTransport extends (EventEmitter as new () => TypedEmitter<PCTransportEventCallbacks>) {
   private _pc: RTCPeerConnection | null;
 
   private get pc() {
@@ -51,7 +57,9 @@ export default class PCTransport extends EventEmitter {
 
   private ddExtID = 0;
 
-  private latestOfferId: number = 0;
+  latestOfferId: number = 0;
+
+  latestAcknowledgedOfferId: number = 0;
 
   private offerLock: Mutex;
 
@@ -236,6 +244,14 @@ export default class PCTransport extends EventEmitter {
     this.pendingCandidates = [];
     this.restartingIce = false;
 
+    // Fire OfferAnswered for every successfully applied answer, including the
+    // ones that recurse into another offer via `renegotiate`. Callers waiting
+    // on a specific offerId can resolve as soon as their offer's answer is in.
+    if (sd.type === 'answer') {
+      this.latestAcknowledgedOfferId = offerId;
+      this.emit(PCEvents.OfferAnswered, offerId);
+    }
+
     if (this.renegotiate) {
       this.renegotiate = false;
       await this.createAndSendOffer();
@@ -737,3 +753,10 @@ function ensureIPAddrMatchVersion(media: MediaDescription) {
 function getMidString(mid: string | number) {
   return typeof mid === 'number' ? mid.toFixed(0) : mid;
 }
+
+type PCTransportEventCallbacks = {
+  negotiationStarted: () => void;
+  negotiationComplete: () => void;
+  offerAnswered: (offerId: number) => void;
+  rtpVideoPayloadTypes: (attributes: MediaAttributes['rtp']) => void;
+};