livekit-client 2.17.3 → 2.18.1

package/src/room/Room.ts

@@ -47,7 +47,7 @@ import TypedPromise from '../utils/TypedPromise';
 import { getBrowser } from '../utils/browserParser';
 import { BackOffStrategy } from './BackOffStrategy';
 import DeviceManager from './DeviceManager';
-import RTCEngine from './RTCEngine';
+import RTCEngine, { DataChannelKind } from './RTCEngine';
 import { RegionUrlProvider } from './RegionUrlProvider';
 import IncomingDataStreamManager from './data-stream/incoming/IncomingDataStreamManager';
 import {
@@ -55,6 +55,11 @@ import {
   type TextStreamHandler,
 } from './data-stream/incoming/StreamReader';
 import OutgoingDataStreamManager from './data-stream/outgoing/OutgoingDataStreamManager';
+import type LocalDataTrack from './data-track/LocalDataTrack';
+import type RemoteDataTrack from './data-track/RemoteDataTrack';
+import IncomingDataTrackManager from './data-track/incoming/IncomingDataTrackManager';
+import OutgoingDataTrackManager from './data-track/outgoing/OutgoingDataTrackManager';
+import { DataTrackInfo, type DataTrackSid } from './data-track/types';
 import {
   audioDefaults,
   publishDefaults,
@@ -70,7 +75,7 @@ import {
 } from './errors';
 import { EngineEvent, ParticipantEvent, RoomEvent, TrackEvent } from './events';
 import LocalParticipant from './participant/LocalParticipant';
-import type Participant from './participant/Participant';
+import Participant from './participant/Participant';
 import { type ConnectionQuality, ParticipantKind } from './participant/Participant';
 import RemoteParticipant from './participant/RemoteParticipant';
 import { MAX_PAYLOAD_BYTES, RpcError, type RpcInvocationData, byteLength } from './rpc';
@@ -205,6 +210,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private outgoingDataStreamManager: OutgoingDataStreamManager;
 
+  private incomingDataTrackManager: IncomingDataTrackManager;
+
+  private outgoingDataTrackManager: OutgoingDataTrackManager;
+
   private rpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>> = new Map();
 
   get hasE2EESetup(): boolean {
@@ -243,6 +252,46 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.incomingDataStreamManager = new IncomingDataStreamManager();
     this.outgoingDataStreamManager = new OutgoingDataStreamManager(this.engine, this.log);
 
+    this.incomingDataTrackManager = new IncomingDataTrackManager({ e2eeManager: this.e2eeManager });
+    this.incomingDataTrackManager
+      .on('sfuUpdateSubscription', (event) => {
+        this.engine.client.sendUpdateDataSubscription(event.sid, event.subscribe);
+      })
+      .on('trackPublished', (event) => {
+        if (event.track.publisherIdentity === this.localParticipant.identity) {
+          // Only advertize tracks from other participants
+          return;
+        }
+        this.emit(RoomEvent.DataTrackPublished, event.track);
+        this.remoteParticipants.get(event.track.publisherIdentity)?.addRemoteDataTrack(event.track);
+      })
+      .on('trackUnpublished', (event) => {
+        if (event.publisherIdentity === this.localParticipant.identity) {
+          // Only advertize tracks from other participants
+          return;
+        }
+        this.emit(RoomEvent.DataTrackUnpublished, event.sid);
+        this.remoteParticipants.get(event.publisherIdentity)?.removeRemoteDataTrack(event.sid);
+      });
+
+    this.outgoingDataTrackManager = new OutgoingDataTrackManager({ e2eeManager: this.e2eeManager });
+    this.outgoingDataTrackManager
+      .on('sfuPublishRequest', (event) => {
+        this.engine.client.sendPublishDataTrackRequest(event.handle, event.name, event.usesE2ee);
+      })
+      .on('sfuUnpublishRequest', (event) => {
+        this.engine.client.sendUnPublishDataTrackRequest(event.handle);
+      })
+      .on('trackPublished', (event) => {
+        this.emit(RoomEvent.LocalDataTrackPublished, event.track);
+      })
+      .on('trackUnpublished', (event) => {
+        this.emit(RoomEvent.LocalDataTrackUnpublished, event.sid);
+      })
+      .on('packetAvailable', ({ bytes }) => {
+        this.engine.sendLossyBytes(bytes, DataChannelKind.DATA_TRACK_LOSSY, 'wait');
+      });
+
     this.disconnectLock = new Mutex();
 
     this.localParticipant = new LocalParticipant(
@@ -252,6 +301,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.options,
       this.rpcHandlers,
       this.outgoingDataStreamManager,
+      this.outgoingDataTrackManager,
     );
 
     if (this.options.e2ee || this.options.encryption) {
@@ -259,6 +309,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
 
     this.engine.e2eeManager = this.e2eeManager;
+    this.incomingDataTrackManager.updateE2eeManager(this.e2eeManager ?? null);
+    this.outgoingDataTrackManager.updateE2eeManager(this.e2eeManager ?? null);
 
     if (this.options.videoCaptureDefaults.deviceId) {
       this.localParticipant.activeDeviceMap.set(
@@ -406,7 +458,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       room: this.name,
       roomID: this.roomInfo?.sid,
       participant: this.localParticipant.identity,
-      pID: this.localParticipant.sid,
+      participantID: this.localParticipant.sid,
     };
   }
 
@@ -464,7 +516,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private maybeCreateEngine() {
-    if (this.engine && !this.engine.isClosed) {
+    if (this.engine && (this.engine.isNewlyCreated || !this.engine.isClosed)) {
       return;
     }
 
@@ -515,6 +567,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         }
       })
       .on(EngineEvent.Restarting, this.handleRestarting)
+      .on(EngineEvent.Restarted, this.handleRestarted)
       .on(EngineEvent.SignalRestarted, this.handleSignalRestarted)
       .on(EngineEvent.Offline, () => {
         if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
@@ -560,6 +613,66 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         } else {
           this.handleParticipantUpdates(roomMoved.otherParticipants);
         }
+      })
+      .on(EngineEvent.PublishDataTrackResponse, (event) => {
+        if (!event.info) {
+          this.log.warn(
+            `received PublishDataTrackResponse, but event.info was ${event.info}, so skipping.`,
+            this.logContext,
+          );
+          return;
+        }
+
+        this.outgoingDataTrackManager.receivedSfuPublishResponse(event.info.pubHandle, {
+          type: 'ok',
+          data: {
+            sid: event.info.sid,
+            pubHandle: event.info.pubHandle,
+            name: event.info.name,
+            usesE2ee: event.info.encryption !== Encryption_Type.NONE,
+          },
+        });
+      })
+      .on(EngineEvent.UnPublishDataTrackResponse, (event) => {
+        if (!event.info) {
+          this.log.warn(
+            `received UnPublishDataTrackResponse, but event.info was ${event.info}, so skipping.`,
+            this.logContext,
+          );
+          return;
+        }
+
+        this.outgoingDataTrackManager.receivedSfuUnpublishResponse(event.info.pubHandle);
+      })
+      .on(EngineEvent.DataTrackSubscriberHandles, (event) => {
+        const handleToSidMapping = new Map(
+          Object.entries(event.subHandles).map(([key, value]) => {
+            return [parseInt(key, 10), value.trackSid];
+          }),
+        );
+
+        this.incomingDataTrackManager.receivedSfuSubscriberHandles(handleToSidMapping);
+      })
+      .on(EngineEvent.DataTrackPacketReceived, (packetBytes) => {
+        try {
+          this.incomingDataTrackManager.packetReceived(packetBytes);
+        } catch (err) {
+          // NOTE: wrapping in the bare try/catch like this means that the Throws<...> type doesn't
+          // propagate upwards into the public interface.
+          throw err;
+        }
+      })
+      .on(EngineEvent.Joined, (joinResponse) => {
+        // Ingest data track publication updates into data tracks infrastructure
+        const mapped = new Map(
+          joinResponse.otherParticipants.map((participant) => {
+            return [
+              participant.identity,
+              participant.dataTracks.map((info) => DataTrackInfo.from(info)),
+            ];
+          }),
+        );
+        this.incomingDataTrackManager.receiveSfuPublicationUpdates(mapped);
       });
 
     if (this.localParticipant) {
@@ -1456,10 +1569,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     ) as RemoteParticipant | undefined;
 
     if (!participant) {
-      this.log.error(
-        `Tried to add a track for a participant, that's not present. Sid: ${participantSid}`,
-        this.logContext,
-      );
+      // server could require extra media sections to accelerate subscription.
+      if (participantSid.startsWith('PA')) {
+        this.log.error(
+          `Tried to add a track for a participant, that's not present. Sid: ${participantSid}`,
+          this.logContext,
+        );
+      }
       return;
     }
 
@@ -1481,7 +1597,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (!trackId.startsWith('TR')) {
       this.log.warn(
         `Tried to add a track whose 'sid' could not be determined for a participant, that's not present. Sid: ${participantSid}, streamId: ${streamId}, trackId: ${trackId}`,
-        { ...this.logContext, rpID: participantSid, streamId, trackId },
+        { ...this.logContext, remoteParticipantID: participantSid, streamId, trackId },
       );
     }
 
@@ -1527,6 +1643,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   };
 
+  private handleRestarted = () => {
+    this.outgoingDataTrackManager.sfuWillRepublishTracks();
+    this.incomingDataTrackManager.resendSubscriptionUpdates();
+  };
+
   private handleSignalRestarted = async (joinResponse: JoinResponse) => {
     this.log.debug(`signal reconnected to server, region ${joinResponse.serverRegion}`, {
       ...this.logContext,
@@ -1640,10 +1761,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private handleParticipantUpdates = (participantInfos: ParticipantInfo[]) => {
     // handle changes to participant state, and send events
-    participantInfos.forEach((info) => {
+    for (const info of participantInfos) {
       if (info.identity === this.localParticipant.identity) {
         this.localParticipant.updateInfo(info);
-        return;
+        continue;
       }
 
       // LiveKit server doesn't send identity info prior to version 1.5.2 in disconnect updates
@@ -1661,7 +1782,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         // create participant if doesn't exist
         remoteParticipant = this.getOrCreateParticipant(info.identity, info);
       }
-    });
+    }
+
+    // Ingest data track publication updates into data tracks infrastructure
+    const mapped = new Map(
+      participantInfos
+        .filter((p) => p.identity !== this.localParticipant.identity)
+        .map((info) => {
+          return [info.identity, info.dataTracks.map((dataTrack) => DataTrackInfo.from(dataTrack))];
+        }),
+    );
+    this.incomingDataTrackManager.receiveSfuPublicationUpdates(mapped);
   };
 
   private handleParticipantDisconnected(identity: string, participant?: RemoteParticipant) {
@@ -1672,6 +1803,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
 
     this.incomingDataStreamManager.validateParticipantHasNoActiveDataStreams(identity);
+    this.incomingDataTrackManager.handleRemoteParticipantDisconnected(identity);
 
     participant.trackPublications.forEach((publication) => {
       participant.unpublishTrack(publication.trackSid, true);
@@ -2192,7 +2324,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
             track.on(TrackEvent.VideoPlaybackFailed, this.handleVideoPlaybackFailed);
             track.on(TrackEvent.VideoPlaybackStarted, this.handleVideoPlaybackStarted);
           }
-          this.emit(RoomEvent.TrackSubscribed, track, publication, participant);
+          this.emitWhenConnected(RoomEvent.TrackSubscribed, track, publication, participant);
         },
       )
       .on(ParticipantEvent.TrackUnpublished, (publication: RemoteTrackPublication) => {
@@ -2270,7 +2402,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       return acc;
     }, [] as RemoteTrackPublication[]);
     const localTracks = this.localParticipant.getTrackPublications() as LocalTrackPublication[]; // FIXME would be nice to have this return LocalTrackPublications directly instead of the type cast
-    this.engine.sendSyncState(remoteTracks, localTracks);
+    const localDataTrackInfos = this.outgoingDataTrackManager.queryPublished();
+    this.engine.sendSyncState(remoteTracks, localTracks, localDataTrackInfos);
   }
 
   /**
@@ -2732,10 +2865,14 @@ export type RoomEventCallbacks = {
   recordingStatusChanged: (recording: boolean) => void;
   participantEncryptionStatusChanged: (encrypted: boolean, participant?: Participant) => void;
   encryptionError: (error: Error, participant?: Participant) => void;
-  dcBufferStatusChanged: (isLow: boolean, kind: DataPacket_Kind) => void;
+  dcBufferStatusChanged: (isLow: boolean, kind: DataChannelKind) => void;
   activeDeviceChanged: (kind: MediaDeviceKind, deviceId: string) => void;
   chatMessage: (message: ChatMessage, participant?: RemoteParticipant | LocalParticipant) => void;
   localTrackSubscribed: (publication: LocalTrackPublication, participant: LocalParticipant) => void;
   metricsReceived: (metrics: MetricsBatch, participant?: Participant) => void;
   participantActive: (participant: Participant) => void;
+  dataTrackPublished: (track: RemoteDataTrack) => void;
+  dataTrackUnpublished: (sid: DataTrackSid) => void;
+  localDataTrackPublished: (track: LocalDataTrack) => void;
+  localDataTrackUnpublished: (sid: DataTrackSid) => void;
 };

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

@@ -1,7 +1,6 @@
 import { Mutex } from '@livekit/mutex';
 import {
   DataPacket,
-  DataPacket_Kind,
   DataStream_ByteHeader,
   DataStream_Chunk,
   DataStream_Header,
@@ -12,6 +11,7 @@ import {
 } from '@livekit/protocol';
 import { type StructuredLogger } from '../../../logger';
 import type RTCEngine from '../../RTCEngine';
+import { DataChannelKind } from '../../RTCEngine';
 import { EngineEvent } from '../../events';
 import type {
   ByteStreamInfo,
@@ -114,7 +114,7 @@ export default class OutgoingDataStreamManager {
       mimeType: info.mimeType,
       topic: info.topic,
       timestamp: numberToBigInt(info.timestamp),
-      totalLength: numberToBigInt(options?.totalSize),
+      totalLength: numberToBigInt(info.size),
       attributes: info.attributes,
       contentHeader: {
         case: 'textHeader',
@@ -137,7 +137,7 @@ export default class OutgoingDataStreamManager {
         value: header,
       },
     });
-    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    await this.engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
 
     let chunkId = 0;
     const engine = this.engine;
@@ -158,7 +158,7 @@ export default class OutgoingDataStreamManager {
               value: chunk,
             },
           });
-          await engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
+          await engine.sendDataPacket(chunkPacket, DataChannelKind.RELIABLE);
 
           chunkId += 1;
         }
@@ -174,7 +174,7 @@ export default class OutgoingDataStreamManager {
             value: trailer,
           },
         });
-        await engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+        await engine.sendDataPacket(trailerPacket, DataChannelKind.RELIABLE);
       },
       abort(err) {
         console.log('Sink error:', err);
@@ -240,7 +240,7 @@ export default class OutgoingDataStreamManager {
     };
 
     const header = new DataStream_Header({
-      totalLength: numberToBigInt(info.size ?? 0),
+      totalLength: numberToBigInt(info.size),
       mimeType: info.mimeType,
       streamId,
       topic: info.topic,
@@ -262,7 +262,7 @@ export default class OutgoingDataStreamManager {
       },
     });
 
-    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    await this.engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
 
     let chunkId = 0;
     const writeMutex = new Mutex();
@@ -288,7 +288,7 @@ export default class OutgoingDataStreamManager {
                 }),
               },
             });
-            await engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
+            await engine.sendDataPacket(chunkPacket, DataChannelKind.RELIABLE);
             chunkId += 1;
             byteOffset += subChunk.byteLength;
           }
@@ -307,7 +307,7 @@ export default class OutgoingDataStreamManager {
             value: trailer,
           },
         });
-        await engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+        await engine.sendDataPacket(trailerPacket, DataChannelKind.RELIABLE);
       },
       abort(err) {
         logLocal.error('Sink error:', err);

package/src/room/data-track/LocalDataTrack.ts

@@ -0,0 +1,126 @@
+import log, { LoggerNames, type StructuredLogger, getLogger } from '../../logger';
+import { type DataTrackFrame, DataTrackFrameInternal } from './frame';
+import type { DataTrackHandle } from './handle';
+import type OutgoingDataTrackManager from './outgoing/OutgoingDataTrackManager';
+import { DataTrackPushFrameError } from './outgoing/errors';
+import type { DataTrackOptions } from './outgoing/types';
+import {
+  DataTrackSymbol,
+  type IDataTrack,
+  type ILocalTrack,
+  TrackSymbol,
+} from './track-interfaces';
+import type { DataTrackInfo } from './types';
+
+export default class LocalDataTrack implements ILocalTrack, IDataTrack {
+  readonly trackSymbol = TrackSymbol;
+
+  readonly isLocal = true;
+
+  readonly typeSymbol = DataTrackSymbol;
+
+  protected options: DataTrackOptions;
+
+  /** Represents the currently active {@link DataTrackHandle} for the publication. */
+  protected handle: DataTrackHandle | null = null;
+
+  protected manager: OutgoingDataTrackManager;
+
+  protected log: StructuredLogger = log;
+
+  /** @internal */
+  constructor(options: DataTrackOptions, manager: OutgoingDataTrackManager) {
+    this.options = options;
+    this.manager = manager;
+
+    this.log = getLogger(LoggerNames.DataTracks);
+  }
+
+  /** @internal */
+  static withExplicitHandle(
+    options: DataTrackOptions,
+    manager: OutgoingDataTrackManager,
+    handle: DataTrackHandle,
+  ) {
+    const track = new LocalDataTrack(options, manager);
+    track.handle = handle;
+    return track;
+  }
+
+  /** Metrics about the data track publication. */
+  get info() {
+    const descriptor = this.descriptor;
+    if (descriptor?.type === 'active') {
+      return descriptor.info;
+    } else {
+      return undefined;
+    }
+  }
+
+  /** The raw descriptor from the manager containing the internal state for this local track. */
+  protected get descriptor() {
+    return this.handle ? this.manager.getDescriptor(this.handle) : null;
+  }
+
+  /**
+   * Publish the track to the SFU. This must be done before calling {@link tryPush} for the first time.
+   * @internal
+   * */
+  async publish(signal?: AbortSignal) {
+    try {
+      this.handle = await this.manager.publishRequest(this.options, signal);
+    } catch (err) {
+      // NOTE: Rethrow errors to break Throws<...> type boundary
+      throw err;
+    }
+  }
+
+  isPublished(): this is { info: DataTrackInfo } {
+    // NOTE: a track which is internally in the "resubscribing" state is still considered
+    // published from the public API perspective.
+    return this.descriptor?.type === 'active' && this.descriptor.publishState !== 'unpublished';
+  }
+
+  /** Try pushing a frame to subscribers of the track.
+   *
+   * Pushing a frame can fail for several reasons:
+   *
+   * - The track has been unpublished by the local participant or SFU
+   * - The room is no longer connected
+   */
+  tryPush(frame: DataTrackFrame) {
+    if (!this.handle) {
+      throw DataTrackPushFrameError.trackUnpublished();
+    }
+
+    const internalFrame = DataTrackFrameInternal.from(frame);
+
+    try {
+      return this.manager.tryProcessAndSend(this.handle, internalFrame);
+    } catch (err) {
+      // NOTE: wrapping in the bare try/catch like this means that the Throws<...> type doesn't
+      // propagate upwards into the public interface.
+      throw err;
+    }
+  }
+
+  /**
+   * Unpublish the track from the SFU. Once this is called, any further calls to {@link tryPush}
+   * will fail.
+   * */
+  async unpublish() {
+    if (!this.handle) {
+      log.warn(
+        `Data track "${this.options.name}" is not published, so unpublishing has no effect.`,
+      );
+      return;
+    }
+
+    try {
+      await this.manager.unpublishRequest(this.handle);
+    } catch (err) {
+      // NOTE: Rethrow errors to break Throws<...> type boundary
+      throw err;
+    }
+  }
+}

package/src/room/data-track/RemoteDataTrack.ts

@@ -0,0 +1,80 @@
+import type Participant from '../participant/Participant';
+import { type DataTrackFrame } from './frame';
+import type IncomingDataTrackManager from './incoming/IncomingDataTrackManager';
+import {
+  DataTrackSymbol,
+  type IDataTrack,
+  type IRemoteTrack,
+  TrackSymbol,
+} from './track-interfaces';
+import { type DataTrackInfo } from './types';
+
+type RemoteDataTrackOptions = {
+  publisherIdentity: Participant['identity'];
+};
+
+export type DataTrackSubscribeOptions = {
+  signal?: AbortSignal;
+
+  /** The number of {@link DataTrackFrame}s to hold in the ReadableStream before disgarding extra
+   * frames. Defaults to 16, but this may not be good enough for especially high frequency data. */
+  bufferSize?: number;
+};
+
+export default class RemoteDataTrack implements IRemoteTrack, IDataTrack {
+  readonly trackSymbol = TrackSymbol;
+
+  readonly isLocal = false;
+
+  readonly typeSymbol = DataTrackSymbol;
+
+  info: DataTrackInfo;
+
+  publisherIdentity: Participant['identity'];
+
+  protected manager: IncomingDataTrackManager;
+
+  /** @internal */
+  constructor(
+    info: DataTrackInfo,
+    manager: IncomingDataTrackManager,
+    options: RemoteDataTrackOptions,
+  ) {
+    this.info = info;
+    this.manager = manager;
+    this.publisherIdentity = options.publisherIdentity;
+  }
+
+  /** Subscribes to the data track to receive frames.
+   *
+   * # Returns
+   *
+   * A stream that yields {@link DataTrackFrame}s as they arrive.
+   *
+   * # Multiple Subscriptions
+   *
+   * An application may call `subscribe` more than once to process frames in
+   * multiple places. For example, one async task might plot values on a graph
+   * while another writes them to a file.
+   *
+   * Internally, only the first call to `subscribe` communicates with the SFU and
+   * allocates the resources required to receive frames. Additional subscriptions
+   * reuse the same underlying pipeline and do not trigger additional signaling.
+   *
+   * Note that newly created subscriptions only receive frames published after
+   * the initial subscription is established.
+   */
+  subscribe(options?: DataTrackSubscribeOptions): ReadableStream<DataTrackFrame> {
+    try {
+      const [stream] = this.manager.openSubscriptionStream(
+        this.info.sid,
+        options?.signal,
+        options?.bufferSize,
+      );
+      return stream;
+    } catch (err) {
+      // NOTE: Rethrow errors to break Throws<...> type boundary
+      throw err;
+    }
+  }
+}