livekit-client 2.17.3 → 2.18.1

package/src/room/data-track/outgoing/OutgoingDataTrackManager.ts

@@ -1,25 +1,27 @@
 import { EventEmitter } from 'events';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import type TypedEmitter from 'typed-emitter';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
 import { LoggerNames, getLogger } from '../../../logger';
-import type { Throws } from '../../../utils/throws';
+import { abortSignalAny, abortSignalTimeout } from '../../../utils/abort-signal-polyfill';
 import { Future } from '../../utils';
-import { type EncryptionProvider } from '../e2ee';
-import type { DataTrackFrame } from '../frame';
+import LocalDataTrack from '../LocalDataTrack';
+import type { DataTrackFrameInternal } from '../frame';
 import { DataTrackHandle, DataTrackHandleAllocator } from '../handle';
-import { DataTrackExtensions } from '../packet/extensions';
-import { type DataTrackInfo, LocalDataTrack } from '../track';
+import { type DataTrackInfo } from '../types';
 import {
   DataTrackPublishError,
-  DataTrackPublishErrorReason,
   DataTrackPushFrameError,
   DataTrackPushFrameErrorReason,
 } from './errors';
 import DataTrackOutgoingPipeline from './pipeline';
 import {
   type DataTrackOptions,
-  type OutputEventPacketsAvailable,
-  type OutputEventSfuPublishRequest,
-  type OutputEventSfuUnpublishRequest,
+  type EventPacketAvailable,
+  type EventSfuPublishRequest,
+  type EventSfuUnpublishRequest,
+  type EventTrackPublished,
+  type EventTrackUnpublished,
   type SfuPublishResponseResult,
 } from './types';
 
@@ -27,20 +29,15 @@ const log = getLogger(LoggerNames.DataTracks);
 
 export type PendingDescriptor = {
   type: 'pending';
-  completionFuture: Future<
-    LocalDataTrack,
-    | DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>
-    | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>
-    | DataTrackPublishError<DataTrackPublishErrorReason.Timeout>
-    | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>
-    | DataTrackPublishError<DataTrackPublishErrorReason.Disconnected>
-    | DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>
-  >;
+  /** Resolves when the descriptor is fully published. */
+  completionFuture: Future<void, DataTrackPublishError>;
 };
 export type ActiveDescriptor = {
   type: 'active';
   info: DataTrackInfo;
 
+  publishState: 'published' | 'republishing' | 'unpublished';
+
   pipeline: DataTrackOutgoingPipeline;
 
   /** Resolves when the descriptor is unpublished. */
@@ -55,11 +52,12 @@ export const Descriptor = {
       completionFuture: new Future(),
     };
   },
-  active(info: DataTrackInfo, encryptionProvider: EncryptionProvider | null): ActiveDescriptor {
+  active(info: DataTrackInfo, e2eeManager: BaseE2EEManager | null): ActiveDescriptor {
     return {
       type: 'active',
       info,
-      pipeline: new DataTrackOutgoingPipeline({ info, encryptionProvider }),
+      publishState: 'published',
+      pipeline: new DataTrackOutgoingPipeline({ info, e2eeManager }),
       unpublishingFuture: new Future(),
     };
   },
@@ -67,35 +65,39 @@ export const Descriptor = {
 
 export type DataTrackOutgoingManagerCallbacks = {
   /** Request sent to the SFU to publish a track. */
-  sfuPublishRequest: (event: OutputEventSfuPublishRequest) => void;
+  sfuPublishRequest: (event: EventSfuPublishRequest) => void;
   /** Request sent to the SFU to unpublish a track. */
-  sfuUnpublishRequest: (event: OutputEventSfuUnpublishRequest) => void;
-  /** Serialized packets are ready to be sent over the transport. */
-  packetsAvailable: (event: OutputEventPacketsAvailable) => void;
+  sfuUnpublishRequest: (event: EventSfuUnpublishRequest) => void;
+  /** A serialized packet is ready to be sent over the transport. */
+  packetAvailable: (event: EventPacketAvailable) => void;
+  /** A new {@link LocalDataTrack} has been published */
+  trackPublished: (event: EventTrackPublished) => void;
+  /** A {@link LocalDataTrack} has been unpublished */
+  trackUnpublished: (event: EventTrackUnpublished) => void;
 };
 
-type DataTrackLocalManagerOptions = {
+type OutgoingDataTrackManagerOptions = {
   /**
    * Provider to use for encrypting outgoing frame payloads.
    *
-   * If none, end-to-end encryption will be disabled for all published tracks.
+   * If null, end-to-end encryption will be disabled for all published tracks.
    */
-  encryptionProvider?: EncryptionProvider;
+  e2eeManager?: BaseE2EEManager;
 };
 
 /** How long to wait when attempting to publish before timing out. */
 const PUBLISH_TIMEOUT_MILLISECONDS = 10_000;
 
 export default class OutgoingDataTrackManager extends (EventEmitter as new () => TypedEmitter<DataTrackOutgoingManagerCallbacks>) {
-  private encryptionProvider: EncryptionProvider | null;
+  private e2eeManager: BaseE2EEManager | null;
 
   private handleAllocator = new DataTrackHandleAllocator();
 
   private descriptors = new Map<DataTrackHandle, Descriptor>();
 
-  constructor(options?: DataTrackLocalManagerOptions) {
+  constructor(options?: OutgoingDataTrackManagerOptions) {
     super();
-    this.encryptionProvider = options?.encryptionProvider ?? null;
+    this.e2eeManager = options?.e2eeManager ?? null;
   }
 
   static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>) {
@@ -104,6 +106,18 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     return manager;
   }
 
+  /** @internal */
+  updateE2eeManager(e2eeManager: BaseE2EEManager | null) {
+    this.e2eeManager = e2eeManager;
+
+    // Propegate downwards to all pre-existing pipelines
+    for (const descriptor of this.descriptors.values()) {
+      if (descriptor.type === 'active') {
+        descriptor.pipeline.updateE2eeManager(e2eeManager);
+      }
+    }
+  }
+
   /**
    * Used by attached {@link LocalDataTrack} instances to query their associated descriptor info.
    * @internal
@@ -112,39 +126,35 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     return this.descriptors.get(handle) ?? null;
   }
 
-  createLocalDataTrack(handle: DataTrackHandle) {
-    const descriptor = this.getDescriptor(handle);
-    if (descriptor?.type !== 'active') {
-      return null;
-    }
-    return new LocalDataTrack(descriptor.info, this);
-  }
-
   /** Used by attached {@link LocalDataTrack} instances to broadcast data track packets to other
    * subscribers.
    * @internal
    */
-  tryProcessAndSend(
+  async tryProcessAndSend(
     handle: DataTrackHandle,
-    payload: Uint8Array,
-  ): Throws<
-    void,
-    | DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>
-    | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>
+    frame: DataTrackFrameInternal,
+  ): Promise<
+    Throws<
+      void,
+      | DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>
+      | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>
+    >
   > {
     const descriptor = this.getDescriptor(handle);
     if (descriptor?.type !== 'active') {
       throw DataTrackPushFrameError.trackUnpublished();
     }
 
-    const frame: DataTrackFrame = {
-      payload,
-      extensions: new DataTrackExtensions(),
-    };
+    if (descriptor.publishState === 'unpublished') {
+      throw DataTrackPushFrameError.trackUnpublished();
+    }
+    if (descriptor.publishState === 'republishing') {
+      throw DataTrackPushFrameError.dropped('Data track republishing');
+    }
 
     try {
-      for (const packet of descriptor.pipeline.processFrame(frame)) {
-        this.emit('packetsAvailable', { bytes: packet.toBinary() });
+      for await (const packet of descriptor.pipeline.processFrame(frame)) {
+        this.emit('packetAvailable', { bytes: packet.toBinary() });
       }
     } catch (err) {
       // NOTE: In the rust implementation this "dropped" error means something different (not enough room
@@ -153,15 +163,25 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     }
   }
 
-  /** Client requested to publish a track. */
-  async publishRequest(options: DataTrackOptions, signal?: AbortSignal) {
+  /**
+   * Client requested to publish a track.
+   *
+   * If the LiveKit server is too old and doesn't support data tracks, a
+   * {@link DataTrackPublishError#timeout} will be thrown.
+   *
+   * @internal
+   **/
+  async publishRequest(
+    options: DataTrackOptions,
+    signal?: AbortSignal,
+  ): Promise<Throws<DataTrackHandle, DataTrackPublishError>> {
     const handle = this.handleAllocator.get();
     if (!handle) {
       throw DataTrackPublishError.limitReached();
     }
 
-    const timeoutSignal = AbortSignal.timeout(PUBLISH_TIMEOUT_MILLISECONDS);
-    const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+    const timeoutSignal = abortSignalTimeout(PUBLISH_TIMEOUT_MILLISECONDS);
+    const combinedSignal = signal ? abortSignalAny([signal, timeoutSignal]) : timeoutSignal;
 
     if (this.descriptors.has(handle)) {
       // @throws-transformer ignore - this should be treated as a "panic" and not be caught
@@ -191,21 +211,35 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
         );
       }
     };
+    if (combinedSignal.aborted) {
+      onAbort(); // NOTE: this rejects `completionFuture`; the next line just returns the rejection
+      return descriptor.completionFuture.promise.then(
+        () => handle /* no-op, makes typescript happy */,
+      );
+    }
     combinedSignal.addEventListener('abort', onAbort);
 
     this.emit('sfuPublishRequest', {
       handle,
       name: options.name,
-      usesE2ee: this.encryptionProvider !== null,
+      usesE2ee: this.e2eeManager !== null,
     });
 
-    const localDataTrack = await descriptor.completionFuture.promise;
+    await descriptor.completionFuture.promise;
     combinedSignal.removeEventListener('abort', onAbort);
-    return localDataTrack;
+
+    this.emit('trackPublished', {
+      track: LocalDataTrack.withExplicitHandle(options, this, handle),
+    });
+
+    return handle;
   }
 
-  /** Get information about all currently published tracks. */
-  async queryPublished() {
+  /**
+   * Get information about all currently published tracks.
+   * @internal
+   **/
+  queryPublished() {
     const descriptorInfos = Array.from(this.descriptors.values())
       .filter((descriptor): descriptor is ActiveDescriptor => descriptor.type === 'active')
       .map((descriptor) => descriptor.info);
@@ -213,7 +247,10 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     return descriptorInfos;
   }
 
-  /** Client request to unpublish a track. */
+  /**
+   * Client request to unpublish a track.
+   * @internal
+   **/
   async unpublishRequest(handle: DataTrackHandle) {
     const descriptor = this.descriptors.get(handle);
     if (!descriptor) {
@@ -228,9 +265,14 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     this.emit('sfuUnpublishRequest', { handle });
 
     await descriptor.unpublishingFuture.promise;
+
+    this.emit('trackUnpublished', { sid: descriptor.info.sid });
   }
 
-  /** SFU responded to a request to publish a data track. */
+  /**
+   * SFU responded to a request to publish a data track.
+   * @internal
+   **/
   receivedSfuPublishResponse(handle: DataTrackHandle, result: SfuPublishResponseResult) {
     const descriptor = this.descriptors.get(handle);
     if (!descriptor) {
@@ -239,32 +281,41 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     }
     this.descriptors.delete(handle);
 
-    if (descriptor.type !== 'pending') {
-      log.warn(`Track ${handle} already active`);
-      return;
-    }
-
-    if (result.type === 'ok') {
-      const info = result.data;
-
-      const encryptionProvider = info.usesE2ee ? this.encryptionProvider : null;
-      this.descriptors.set(info.pubHandle, Descriptor.active(info, encryptionProvider));
-
-      const localDataTrack = this.createLocalDataTrack(info.pubHandle);
-      if (!localDataTrack) {
-        // @throws-transformer ignore - this should be treated as a "panic" and not be caught
-        throw new Error(
-          'DataTrackOutgoingManager.handleSfuPublishResponse: localDataTrack was not created after active descriptor stored.',
-        );
+    switch (descriptor.type) {
+      case 'pending': {
+        if (result.type === 'ok') {
+          const info = result.data;
+          const e2eeManager = info.usesE2ee ? this.e2eeManager : null;
+          this.descriptors.set(info.pubHandle, Descriptor.active(info, e2eeManager));
+
+          descriptor.completionFuture.resolve?.();
+        } else {
+          descriptor.completionFuture.reject?.(result.error);
+        }
+        return;
+      }
+      case 'active': {
+        if (descriptor.publishState !== 'republishing') {
+          log.warn(`Track ${handle} already active`);
+          return;
+        }
+        if (result.type === 'error') {
+          log.warn(`Republish failed for track ${handle}`);
+          return;
+        }
+
+        log.debug(`Track ${handle} republished`);
+        descriptor.info.sid = result.data.sid;
+        descriptor.publishState = 'published';
+        this.descriptors.set(descriptor.info.pubHandle, descriptor);
       }
-
-      descriptor.completionFuture.resolve?.(localDataTrack);
-    } else {
-      descriptor.completionFuture.reject?.(result.error);
     }
   }
 
-  /** SFU notification that a track has been unpublished. */
+  /**
+   * SFU notification that a track has been unpublished.
+   * @internal
+   **/
   receivedSfuUnpublishResponse(handle: DataTrackHandle) {
     const descriptor = this.descriptors.get(handle);
     if (!descriptor) {
@@ -278,10 +329,40 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
       return;
     }
 
+    descriptor.publishState = 'unpublished';
     descriptor.unpublishingFuture.resolve?.();
   }
 
-  /** Shuts down the manager and all associated tracks. */
+  /** Republish all tracks.
+   *
+   * This must be sent after a full reconnect in order for existing publications
+   * to be recognized by the SFU. Each republished track will be assigned a new SID.
+   * @internal
+   */
+  sfuWillRepublishTracks() {
+    for (const [handle, descriptor] of this.descriptors.entries()) {
+      switch (descriptor.type) {
+        case 'pending':
+          // TODO: support republish for pending publications
+          this.descriptors.delete(handle);
+          descriptor.completionFuture.reject?.(DataTrackPublishError.disconnected());
+          break;
+        case 'active':
+          descriptor.publishState = 'republishing';
+
+          this.emit('sfuPublishRequest', {
+            handle: descriptor.info.pubHandle,
+            name: descriptor.info.name,
+            usesE2ee: descriptor.info.usesE2ee,
+          });
+      }
+    }
+  }
+
+  /**
+   * Shuts down the manager and all associated tracks.
+   * @internal
+   **/
   async shutdown() {
     for (const descriptor of this.descriptors.values()) {
       switch (descriptor.type) {

package/src/room/data-track/outgoing/errors.ts

@@ -1,5 +1,5 @@
 import { LivekitReasonedError } from '../../errors';
-import { DataTrackPacketizerError, DataTrackPacketizerReason } from '../packetizer';
+import { DataTrackPacketizerError } from '../packetizer';
 
 export enum DataTrackPublishErrorReason {
   /**
@@ -23,10 +23,17 @@ export enum DataTrackPublishErrorReason {
 
   // NOTE: this was introduced by web / there isn't a corresponding case in the rust version.
   Cancelled = 5,
+
+  /** The name requested is not able to be used when creating the data track. */
+  InvalidName = 6,
+
+  /** There was an error publishing, but it was not something that could be sorted into a known
+   * category. */
+  Unknown = 7,
 }
 
 export class DataTrackPublishError<
-  Reason extends DataTrackPublishErrorReason,
+  Reason extends DataTrackPublishErrorReason = DataTrackPublishErrorReason,
 > extends LivekitReasonedError<Reason> {
   readonly name = 'DataTrackPublishError';
 
@@ -34,37 +41,59 @@ export class DataTrackPublishError<
 
   reasonName: string;
 
-  constructor(message: string, reason: Reason, options?: { cause?: unknown }) {
+  /** Underling message from the SFU, if one was provided */
+  rawMessage?: string;
+
+  constructor(message: string, reason: Reason, options?: { rawMessage?: string; cause?: unknown }) {
     super(21, message, options);
     this.reason = reason;
     this.reasonName = DataTrackPublishErrorReason[reason];
+    this.rawMessage = options?.rawMessage;
   }
 
-  static notAllowed() {
+  static notAllowed(rawMessage?: string) {
     return new DataTrackPublishError(
       'Data track publishing unauthorized',
       DataTrackPublishErrorReason.NotAllowed,
+      { rawMessage },
     );
   }
 
-  static duplicateName() {
+  static duplicateName(rawMessage?: string) {
     return new DataTrackPublishError(
       'Track name already taken',
       DataTrackPublishErrorReason.DuplicateName,
+      { rawMessage },
+    );
+  }
+
+  static invalidName(rawMessage?: string) {
+    return new DataTrackPublishError(
+      'Track name is invalid',
+      DataTrackPublishErrorReason.InvalidName,
+      { rawMessage },
     );
   }
 
   static timeout() {
     return new DataTrackPublishError(
-      'Publish data track timed-out',
+      'Publish data track timed-out. Does the LiveKit server support data tracks?',
       DataTrackPublishErrorReason.Timeout,
     );
   }
 
-  static limitReached() {
+  static limitReached(rawMessage?: string) {
     return new DataTrackPublishError(
       'Data track publication limit reached',
       DataTrackPublishErrorReason.LimitReached,
+      { rawMessage },
+    );
+  }
+
+  static unknown(reason: number, message: string) {
+    return new DataTrackPublishError(
+      `Received RequestResponse for publishDataTrack, but reason was unrecognised (${reason}, ${message})`,
+      DataTrackPublishErrorReason.Unknown,
     );
   }
 
@@ -91,7 +120,7 @@ export enum DataTrackPushFrameErrorReason {
 }
 
 export class DataTrackPushFrameError<
-  Reason extends DataTrackPushFrameErrorReason,
+  Reason extends DataTrackPushFrameErrorReason = DataTrackPushFrameErrorReason,
 > extends LivekitReasonedError<Reason> {
   readonly name = 'DataTrackPushFrameError';
 
@@ -112,7 +141,7 @@ export class DataTrackPushFrameError<
     );
   }
 
-  static dropped(cause: unknown) {
+  static dropped(cause?: unknown) {
     return new DataTrackPushFrameError('Frame was dropped', DataTrackPushFrameErrorReason.Dropped, {
       cause,
     });
@@ -125,7 +154,7 @@ export enum DataTrackOutgoingPipelineErrorReason {
 }
 
 export class DataTrackOutgoingPipelineError<
-  Reason extends DataTrackOutgoingPipelineErrorReason,
+  Reason extends DataTrackOutgoingPipelineErrorReason = DataTrackOutgoingPipelineErrorReason,
 > extends LivekitReasonedError<Reason> {
   readonly name = 'DataTrackOutgoingPipelineError';
 
@@ -139,7 +168,7 @@ export class DataTrackOutgoingPipelineError<
     this.reasonName = DataTrackOutgoingPipelineErrorReason[reason];
   }
 
-  static packetizer(cause: DataTrackPacketizerError<DataTrackPacketizerReason.MtuTooShort>) {
+  static packetizer(cause: DataTrackPacketizerError) {
     return new DataTrackOutgoingPipelineError(
       'Error packetizing frame',
       DataTrackOutgoingPipelineErrorReason.Packetizer,

package/src/room/data-track/outgoing/pipeline.ts

@@ -1,20 +1,20 @@
-import { type Throws } from '../../../utils/throws';
-import { type EncryptedPayload, type EncryptionProvider } from '../e2ee';
-import { type DataTrackFrame } from '../frame';
+import { type Throws } from '@livekit/throws-transformer/throws';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
+import { type DataTrackFrameInternal } from '../frame';
 import { DataTrackPacket } from '../packet';
 import { DataTrackE2eeExtension } from '../packet/extensions';
 import DataTrackPacketizer, { DataTrackPacketizerError } from '../packetizer';
-import type { DataTrackInfo } from '../track';
+import type { DataTrackInfo } from '../types';
 import { DataTrackOutgoingPipelineError, DataTrackOutgoingPipelineErrorReason } from './errors';
 
 type Options = {
   info: DataTrackInfo;
-  encryptionProvider: EncryptionProvider | null;
+  e2eeManager: BaseE2EEManager | null;
 };
 
 /** Processes outgoing frames into final packets for distribution to the SFU. */
 export default class DataTrackOutgoingPipeline {
-  private encryptionProvider: EncryptionProvider | null;
+  private e2eeManager: BaseE2EEManager | null;
 
   private packetizer: DataTrackPacketizer;
 
@@ -22,21 +22,21 @@ export default class DataTrackOutgoingPipeline {
   private static TRANSPORT_MTU_BYTES = 16_000;
 
   constructor(options: Options) {
-    this.encryptionProvider = options.encryptionProvider;
+    this.e2eeManager = options.e2eeManager;
     this.packetizer = new DataTrackPacketizer(
       options.info.pubHandle,
       DataTrackOutgoingPipeline.TRANSPORT_MTU_BYTES,
     );
   }
 
-  *processFrame(
-    frame: DataTrackFrame,
-  ): Throws<
-    Generator<DataTrackPacket>,
-    | DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Packetizer>
-    | DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>
-  > {
-    const encryptedFrame = this.encryptIfNeeded(frame);
+  updateE2eeManager(e2eeManager: BaseE2EEManager | null) {
+    this.e2eeManager = e2eeManager;
+  }
+
+  async *processFrame(
+    frame: DataTrackFrameInternal,
+  ): Throws<AsyncGenerator<DataTrackPacket>, DataTrackOutgoingPipelineError> {
+    const encryptedFrame = await this.encryptIfNeeded(frame);
 
     try {
       yield* this.packetizer.packetize(encryptedFrame);
@@ -48,19 +48,21 @@ export default class DataTrackOutgoingPipeline {
     }
   }
 
-  encryptIfNeeded(
-    frame: DataTrackFrame,
-  ): Throws<
-    DataTrackFrame,
-    DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>
+  async encryptIfNeeded(
+    frame: DataTrackFrameInternal,
+  ): Promise<
+    Throws<
+      DataTrackFrameInternal,
+      DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>
+    >
   > {
-    if (!this.encryptionProvider) {
+    if (!this.e2eeManager) {
       return frame;
     }
 
-    let encryptedResult: EncryptedPayload;
+    let encryptedResult;
     try {
-      encryptedResult = this.encryptionProvider.encrypt(frame.payload);
+      encryptedResult = await this.e2eeManager.encryptData(frame.payload);
     } catch (err) {
       throw DataTrackOutgoingPipelineError.encryption(err);
     }

package/src/room/data-track/outgoing/types.ts

@@ -1,5 +1,6 @@
+import type LocalDataTrack from '../LocalDataTrack';
 import { type DataTrackHandle } from '../handle';
-import { type DataTrackInfo } from '../track';
+import { type DataTrackInfo, type DataTrackSid } from '../types';
 import { type DataTrackPublishError, type DataTrackPublishErrorReason } from './errors';
 
 /** Options for publishing a data track. */
@@ -15,23 +16,30 @@ export type SfuPublishResponseResult =
       error:
         | DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>
         | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>
+        | DataTrackPublishError<DataTrackPublishErrorReason.InvalidName>
         | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
     };
 
 /** Request sent to the SFU to publish a track. */
-export type OutputEventSfuPublishRequest = {
+export type EventSfuPublishRequest = {
   handle: DataTrackHandle;
   name: string;
   usesE2ee: boolean;
 };
 
 /** Request sent to the SFU to unpublish a track. */
-export type OutputEventSfuUnpublishRequest = {
+export type EventSfuUnpublishRequest = {
   handle: DataTrackHandle;
 };
 
-/** Serialized packets are ready to be sent over the transport. */
-export type OutputEventPacketsAvailable = {
+/** A serialized packet is ready to be sent over the transport. */
+export type EventPacketAvailable = {
   bytes: Uint8Array;
-  signal?: AbortSignal;
 };
+
+/** A track has been created by a local participant and is available to be
+ * subscribed to. */
+export type EventTrackPublished = { track: LocalDataTrack };
+
+/** A track has been unpublished by a remote participant and can no longer be subscribed to. */
+export type EventTrackUnpublished = { sid: DataTrackSid };