@reactor-team/js-sdk 2.5.0 → 2.6.0

package/dist/index.js

@@ -79,15 +79,17 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AbortError: () => AbortError,
   ConflictError: () => ConflictError,
-  PROD_COORDINATOR_URL: () => PROD_COORDINATOR_URL,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
   Reactor: () => Reactor,
   ReactorController: () => ReactorController,
   ReactorProvider: () => ReactorProvider,
   ReactorView: () => ReactorView,
   WebcamStream: () => WebcamStream,
   audio: () => audio,
-  fetchInsecureJwtToken: () => fetchInsecureJwtToken,
+  fetchInsecureToken: () => fetchInsecureToken,
+  isAbortError: () => isAbortError,
   useReactor: () => useReactor,
   useReactorInternalMessage: () => useReactorInternalMessage,
   useReactorMessage: () => useReactorMessage,
@@ -109,6 +111,14 @@ var ConflictError = class extends Error {
     super(message);
   }
 };
+var AbortError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+function isAbortError(error) {
+  return error instanceof AbortError || error instanceof Error && error.name === "AbortError";
+}
 
 // src/core/types.ts
 var import_zod = require("zod");
@@ -168,6 +178,7 @@ var IceServersResponseSchema = import_zod.z.object({
 // src/utils/webrtc.ts
 var DEFAULT_DATA_CHANNEL_LABEL = "data";
 var FORCE_RELAY_MODE = false;
+var DEFAULT_MAX_MESSAGE_BYTES = 256 * 1024;
 function createPeerConnection(config) {
   return new RTCPeerConnection({
     iceServers: config.iceServers,
@@ -214,13 +225,17 @@ function rewriteMids(sdp, trackNames) {
 function createOffer(pc, trackNames) {
   return __async(this, null, function* () {
     const offer = yield pc.createOffer();
+    let needsAnswerRestore = false;
     if (trackNames && trackNames.length > 0 && offer.sdp) {
       const munged = rewriteMids(offer.sdp, trackNames);
-      const mungedOffer = new RTCSessionDescription({
-        type: "offer",
-        sdp: munged
-      });
-      yield pc.setLocalDescription(mungedOffer);
+      try {
+        yield pc.setLocalDescription(
+          new RTCSessionDescription({ type: "offer", sdp: munged })
+        );
+      } catch (e) {
+        yield pc.setLocalDescription(offer);
+        needsAnswerRestore = true;
+      }
     } else {
       yield pc.setLocalDescription(offer);
     }
@@ -229,9 +244,49 @@ function createOffer(pc, trackNames) {
     if (!localDescription) {
       throw new Error("Failed to create local description");
     }
-    return localDescription.sdp;
+    let sdp = localDescription.sdp;
+    if (needsAnswerRestore && trackNames && trackNames.length > 0) {
+      sdp = rewriteMids(sdp, trackNames);
+    }
+    return { sdp, needsAnswerRestore };
   });
 }
+function buildMidMapping(transceivers) {
+  var _a;
+  const localToRemote = /* @__PURE__ */ new Map();
+  const remoteToLocal = /* @__PURE__ */ new Map();
+  for (const entry of transceivers) {
+    const mid = (_a = entry.transceiver) == null ? void 0 : _a.mid;
+    if (mid) {
+      localToRemote.set(mid, entry.name);
+      remoteToLocal.set(entry.name, mid);
+    }
+  }
+  return { localToRemote, remoteToLocal };
+}
+function restoreAnswerMids(sdp, remoteToLocal) {
+  const lines = sdp.split("\r\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith("a=mid:")) {
+      const remoteMid = lines[i].substring("a=mid:".length);
+      const localMid = remoteToLocal.get(remoteMid);
+      if (localMid !== void 0) {
+        lines[i] = `a=mid:${localMid}`;
+      }
+    }
+    if (lines[i].startsWith("a=group:BUNDLE ")) {
+      const parts = lines[i].split(" ");
+      for (let j = 1; j < parts.length; j++) {
+        const localMid = remoteToLocal.get(parts[j]);
+        if (localMid !== void 0) {
+          parts[j] = localMid;
+        }
+      }
+      lines[i] = parts.join(" ");
+    }
+  }
+  return lines.join("\r\n");
+}
 function setRemoteDescription(pc, sdp) {
   return __async(this, null, function* () {
     const sessionDescription = new RTCSessionDescription({
@@ -280,14 +335,21 @@ function waitForIceGathering(pc, timeoutMs = 5e3) {
     }, timeoutMs);
   });
 }
-function sendMessage(channel, command, data, scope = "application") {
+function sendMessage(channel, command, data, scope = "application", maxBytes = DEFAULT_MAX_MESSAGE_BYTES) {
   if (channel.readyState !== "open") {
     throw new Error(`Data channel not open: ${channel.readyState}`);
   }
   const jsonData = typeof data === "string" ? JSON.parse(data) : data;
   const inner = { type: command, data: jsonData };
   const payload = { scope, data: inner };
-  channel.send(JSON.stringify(payload));
+  const serialized = JSON.stringify(payload);
+  const byteLength = new TextEncoder().encode(serialized).byteLength;
+  if (byteLength > maxBytes) {
+    throw new Error(
+      `Data channel message too large: ${byteLength} bytes exceeds limit of ${maxBytes} bytes (command: "${command}")`
+    );
+  }
+  channel.send(serialized);
 }
 function parseMessage(data) {
   if (typeof data === "string") {
@@ -359,6 +421,22 @@ var CoordinatorClient = class {
     this.baseUrl = options.baseUrl;
     this.jwtToken = options.jwtToken;
     this.model = options.model;
+    this.abortController = new AbortController();
+  }
+  /**
+   * Aborts any in-flight HTTP requests and polling loops.
+   * A fresh AbortController is created so the client remains reusable.
+   */
+  abort() {
+    this.abortController.abort();
+    this.abortController = new AbortController();
+  }
+  /**
+   * The current abort signal, passed to every fetch() and sleep() call.
+   * Protected so subclasses can forward it to their own fetch calls.
+   */
+  get signal() {
+    return this.abortController.signal;
   }
   /**
    * Returns the authorization header with JWT Bearer token
@@ -379,7 +457,8 @@ var CoordinatorClient = class {
         `${this.baseUrl}/ice_servers?model=${this.model}`,
         {
           method: "GET",
-          headers: this.getAuthHeaders()
+          headers: this.getAuthHeaders(),
+          signal: this.signal
         }
       );
       if (!response.ok) {
@@ -413,7 +492,8 @@ var CoordinatorClient = class {
         headers: __spreadProps(__spreadValues({}, this.getAuthHeaders()), {
           "Content-Type": "application/json"
         }),
-        body: JSON.stringify(requestBody)
+        body: JSON.stringify(requestBody),
+        signal: this.signal
       });
       if (!response.ok) {
         const errorText = yield response.text();
@@ -447,7 +527,8 @@ var CoordinatorClient = class {
         `${this.baseUrl}/sessions/${this.currentSessionId}`,
         {
           method: "GET",
-          headers: this.getAuthHeaders()
+          headers: this.getAuthHeaders(),
+          signal: this.signal
         }
       );
       if (!response.ok) {
@@ -460,12 +541,13 @@ var CoordinatorClient = class {
   }
   /**
    * Terminates the current session by sending a DELETE request to the coordinator.
-   * @throws Error if no active session exists or if the request fails (except for 404)
+   * No-op if no session has been created yet.
+   * @throws Error if the request fails (except for 404, which clears local state)
    */
   terminateSession() {
     return __async(this, null, function* () {
       if (!this.currentSessionId) {
-        throw new Error("No active session. Call createSession() first.");
+        return;
       }
       console.debug(
         "[CoordinatorClient] Terminating session:",
@@ -475,7 +557,8 @@ var CoordinatorClient = class {
         `${this.baseUrl}/sessions/${this.currentSessionId}`,
         {
           method: "DELETE",
-          headers: this.getAuthHeaders()
+          headers: this.getAuthHeaders(),
+          signal: this.signal
         }
       );
       if (response.ok) {
@@ -525,7 +608,8 @@ var CoordinatorClient = class {
           headers: __spreadProps(__spreadValues({}, this.getAuthHeaders()), {
             "Content-Type": "application/json"
           }),
-          body: JSON.stringify(requestBody)
+          body: JSON.stringify(requestBody),
+          signal: this.signal
         }
       );
       if (response.status === 200) {
@@ -561,6 +645,9 @@ var CoordinatorClient = class {
       let backoffMs = INITIAL_BACKOFF_MS;
       let attempt = 0;
       while (true) {
+        if (this.signal.aborted) {
+          throw new AbortError("SDP polling aborted");
+        }
         if (attempt >= maxAttempts) {
           throw new Error(
             `SDP polling exceeded maximum attempts (${maxAttempts}) for session ${sessionId}`
@@ -576,13 +663,14 @@ var CoordinatorClient = class {
             method: "GET",
             headers: __spreadProps(__spreadValues({}, this.getAuthHeaders()), {
               "Content-Type": "application/json"
-            })
+            }),
+            signal: this.signal
           }
         );
         if (response.status === 200) {
           const answerData = yield response.json();
           console.debug("[CoordinatorClient] Received SDP answer via polling");
-          return answerData.sdp_answer;
+          return { sdpAnswer: answerData.sdp_answer, attempts: attempt };
         }
         if (response.status === 202) {
           console.warn(
@@ -606,7 +694,7 @@ var CoordinatorClient = class {
    * @param sessionId - The session ID to connect to
    * @param sdpOffer - Optional SDP offer from the local WebRTC peer connection
    * @param maxAttempts - Optional maximum number of polling attempts before giving up
-   * @returns The SDP answer from the server
+   * @returns The SDP answer and the number of polling attempts made (0 if answered immediately via PUT)
    */
   connect(sessionId, sdpOffer, maxAttempts) {
     return __async(this, null, function* () {
@@ -614,17 +702,34 @@ var CoordinatorClient = class {
       if (sdpOffer) {
         const answer = yield this.sendSdpOffer(sessionId, sdpOffer);
         if (answer !== null) {
-          return answer;
+          return { sdpAnswer: answer, sdpPollingAttempts: 0 };
         }
       }
-      return this.pollSdpAnswer(sessionId, maxAttempts);
+      const result = yield this.pollSdpAnswer(sessionId, maxAttempts);
+      return { sdpAnswer: result.sdpAnswer, sdpPollingAttempts: result.attempts };
     });
   }
   /**
-   * Utility function to sleep for a given number of milliseconds
+   * Abort-aware sleep. Resolves after `ms` milliseconds unless the
+   * abort signal fires first, in which case it rejects with AbortError.
    */
   sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve, reject) => {
+      const { signal } = this;
+      if (signal.aborted) {
+        reject(new AbortError("Sleep aborted"));
+        return;
+      }
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new AbortError("Sleep aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
   }
 };
 
@@ -646,7 +751,8 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
     return __async(this, null, function* () {
       console.debug("[LocalCoordinatorClient] Fetching ICE servers...");
       const response = yield fetch(`${this.localBaseUrl}/ice_servers`, {
-        method: "GET"
+        method: "GET",
+        signal: this.signal
       });
       if (!response.ok) {
         throw new Error("Failed to get ICE servers from local coordinator.");
@@ -670,7 +776,8 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
       console.debug("[LocalCoordinatorClient] Creating local session...");
       this.sdpOffer = sdpOffer;
       const response = yield fetch(`${this.localBaseUrl}/start_session`, {
-        method: "POST"
+        method: "POST",
+        signal: this.signal
       });
       if (!response.ok) {
         throw new Error("Failed to send local start session command.");
@@ -681,9 +788,10 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
   }
   /**
    * Connects to the local session by posting SDP params to /sdp_params.
+   * Local connections are always immediate (no polling).
    * @param sessionId - The session ID (ignored for local)
    * @param sdpMessage - The SDP offer from the local WebRTC peer connection
-   * @returns The SDP answer from the server
+   * @returns The SDP answer and polling attempts (always 0 for local)
    */
   connect(sessionId, sdpMessage) {
     return __async(this, null, function* () {
@@ -698,7 +806,8 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify(sdpBody)
+        body: JSON.stringify(sdpBody),
+        signal: this.signal
       });
       if (!response.ok) {
         if (response.status === 409) {
@@ -708,14 +817,15 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
       }
       const sdpAnswer = yield response.json();
       console.debug("[LocalCoordinatorClient] Received SDP answer");
-      return sdpAnswer.sdp;
+      return { sdpAnswer: sdpAnswer.sdp, sdpPollingAttempts: 0 };
     });
   }
   terminateSession() {
     return __async(this, null, function* () {
       console.debug("[LocalCoordinatorClient] Stopping local session...");
       yield fetch(`${this.localBaseUrl}/stop_session`, {
-        method: "POST"
+        method: "POST",
+        signal: this.signal
       });
     });
   }
@@ -790,12 +900,21 @@ var GPUMachineClient = class {
         );
       }
       const trackNames = entries.map((e) => e.name);
-      const offer = yield createOffer(this.peerConnection, trackNames);
+      const { sdp, needsAnswerRestore } = yield createOffer(
+        this.peerConnection,
+        trackNames
+      );
+      if (needsAnswerRestore) {
+        this.midMapping = buildMidMapping(entries);
+      } else {
+        this.midMapping = void 0;
+      }
       console.debug(
         "[GPUMachineClient] Created SDP offer with MIDs:",
-        trackNames
+        trackNames,
+        needsAnswerRestore ? "(needs answer restore)" : "(native munging)"
       );
-      return offer;
+      return sdp;
     });
   }
   /**
@@ -843,8 +962,18 @@ var GPUMachineClient = class {
         );
       }
       this.setStatus("connecting");
+      this.iceStartTime = performance.now();
+      this.iceNegotiationMs = void 0;
+      this.dataChannelMs = void 0;
       try {
-        yield setRemoteDescription(this.peerConnection, sdpAnswer);
+        let answer = sdpAnswer;
+        if (this.midMapping) {
+          answer = restoreAnswerMids(
+            answer,
+            this.midMapping.remoteToLocal
+          );
+        }
+        yield setRemoteDescription(this.peerConnection, answer);
         console.debug("[GPUMachineClient] Remote description set");
       } catch (error) {
         console.error("[GPUMachineClient] Failed to connect:", error);
@@ -872,8 +1001,10 @@ var GPUMachineClient = class {
         this.peerConnection = void 0;
       }
       this.transceiverMap.clear();
+      this.midMapping = void 0;
       this.peerConnected = false;
       this.dataChannelOpen = false;
+      this.resetConnectionTimings();
       this.setStatus("disconnected");
       console.debug("[GPUMachineClient] Disconnected");
     });
@@ -898,6 +1029,14 @@ var GPUMachineClient = class {
   // ─────────────────────────────────────────────────────────────────────────────
   // Messaging
   // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Returns the negotiated SCTP max message size (bytes) if available,
+   * otherwise `undefined` so `sendMessage` falls back to its built-in default.
+   */
+  get maxMessageBytes() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.peerConnection) == null ? void 0 : _a.sctp) == null ? void 0 : _b.maxMessageSize) != null ? _c : void 0;
+  }
   /**
    * Sends a command to the GPU machine via the data channel.
    * @param command The command to send
@@ -909,7 +1048,13 @@ var GPUMachineClient = class {
       throw new Error("[GPUMachineClient] Data channel not available");
     }
     try {
-      sendMessage(this.dataChannel, command, data, scope);
+      sendMessage(
+        this.dataChannel,
+        command,
+        data,
+        scope,
+        this.maxMessageBytes
+      );
     } catch (error) {
       console.warn("[GPUMachineClient] Failed to send message:", error);
     }
@@ -1037,6 +1182,24 @@ var GPUMachineClient = class {
   getStats() {
     return this.stats;
   }
+  /**
+   * Returns the ICE/data-channel durations recorded during the last connect(),
+   * or undefined if no connection has completed yet.
+   */
+  getConnectionTimings() {
+    if (this.iceNegotiationMs == null || this.dataChannelMs == null) {
+      return void 0;
+    }
+    return {
+      iceNegotiationMs: this.iceNegotiationMs,
+      dataChannelMs: this.dataChannelMs
+    };
+  }
+  resetConnectionTimings() {
+    this.iceStartTime = void 0;
+    this.iceNegotiationMs = void 0;
+    this.dataChannelMs = void 0;
+  }
   startStatsPolling() {
     this.stopStatsPolling();
     this.statsInterval = setInterval(() => __async(this, null, function* () {
@@ -1080,6 +1243,9 @@ var GPUMachineClient = class {
       if (state) {
         switch (state) {
           case "connected":
+            if (this.iceStartTime != null && this.iceNegotiationMs == null) {
+              this.iceNegotiationMs = performance.now() - this.iceStartTime;
+            }
             this.peerConnected = true;
             this.checkFullyConnected();
             break;
@@ -1096,13 +1262,19 @@ var GPUMachineClient = class {
       }
     };
     this.peerConnection.ontrack = (event) => {
-      var _a;
-      const mid = event.transceiver.mid;
-      const trackName = mid != null ? mid : `unknown-${event.track.id}`;
+      var _a, _b;
+      let trackName;
+      for (const [name, entry] of this.transceiverMap) {
+        if (entry.transceiver === event.transceiver) {
+          trackName = name;
+          break;
+        }
+      }
+      trackName != null ? trackName : trackName = (_a = event.transceiver.mid) != null ? _a : `unknown-${event.track.id}`;
       console.debug(
-        `[GPUMachineClient] Track received: "${trackName}" (${event.track.kind}, mid=${mid})`
+        `[GPUMachineClient] Track received: "${trackName}" (${event.track.kind}, mid=${event.transceiver.mid})`
       );
-      const stream = (_a = event.streams[0]) != null ? _a : new MediaStream([event.track]);
+      const stream = (_b = event.streams[0]) != null ? _b : new MediaStream([event.track]);
       this.emit("trackReceived", trackName, event.track, stream);
     };
     this.peerConnection.onicecandidate = (event) => {
@@ -1123,6 +1295,9 @@ var GPUMachineClient = class {
     if (!this.dataChannel) return;
     this.dataChannel.onopen = () => {
       console.debug("[GPUMachineClient] Data channel open");
+      if (this.iceStartTime != null && this.dataChannelMs == null) {
+        this.dataChannelMs = performance.now() - this.iceStartTime;
+      }
       this.dataChannelOpen = true;
       this.startPing();
       this.checkFullyConnected();
@@ -1162,13 +1337,13 @@ var GPUMachineClient = class {
 // src/core/Reactor.ts
 var import_zod2 = require("zod");
 var LOCAL_COORDINATOR_URL = "http://localhost:8080";
-var PROD_COORDINATOR_URL = "https://api.reactor.inc";
+var DEFAULT_BASE_URL = "https://api.reactor.inc";
 var TrackConfigSchema = import_zod2.z.object({
   name: import_zod2.z.string(),
   kind: import_zod2.z.enum(["audio", "video"])
 });
 var OptionsSchema = import_zod2.z.object({
-  coordinatorUrl: import_zod2.z.string().default(PROD_COORDINATOR_URL),
+  apiUrl: import_zod2.z.string().default(DEFAULT_BASE_URL),
   modelName: import_zod2.z.string(),
   local: import_zod2.z.boolean().default(false),
   /**
@@ -1193,12 +1368,12 @@ var Reactor = class {
     // Generic event map
     this.eventListeners = /* @__PURE__ */ new Map();
     const validatedOptions = OptionsSchema.parse(options);
-    this.coordinatorUrl = validatedOptions.coordinatorUrl;
+    this.coordinatorUrl = validatedOptions.apiUrl;
     this.model = validatedOptions.modelName;
     this.local = validatedOptions.local;
     this.receive = validatedOptions.receive;
     this.send = validatedOptions.send;
-    if (this.local && options.coordinatorUrl === void 0) {
+    if (this.local && options.apiUrl === void 0) {
       this.coordinatorUrl = LOCAL_COORDINATOR_URL;
     }
   }
@@ -1319,14 +1494,14 @@ var Reactor = class {
         receive: this.receive
       });
       try {
-        const sdpAnswer = yield this.coordinatorClient.connect(
+        const { sdpAnswer } = yield this.coordinatorClient.connect(
           this.sessionId,
           sdpOffer,
           options == null ? void 0 : options.maxAttempts
         );
         yield this.machineClient.connect(sdpAnswer);
-        this.setStatus("ready");
       } catch (error) {
+        if (isAbortError(error)) return;
         let recoverable = false;
         if (error instanceof ConflictError) {
           recoverable = true;
@@ -1336,7 +1511,7 @@ var Reactor = class {
         this.createError(
           "RECONNECTION_FAILED",
           `Failed to reconnect: ${error}`,
-          "coordinator",
+          "api",
           true
         );
       }
@@ -1359,6 +1534,7 @@ var Reactor = class {
         throw new Error("Already connected or connecting");
       }
       this.setStatus("connecting");
+      this.connectStartTime = performance.now();
       try {
         console.debug(
           "[Reactor] Connecting to coordinator with authenticated URL"
@@ -1376,20 +1552,33 @@ var Reactor = class {
           send: this.send,
           receive: this.receive
         });
+        const tSession = performance.now();
         const sessionId = yield this.coordinatorClient.createSession(sdpOffer);
+        const sessionCreationMs = performance.now() - tSession;
         this.setSessionId(sessionId);
-        const sdpAnswer = yield this.coordinatorClient.connect(
+        const tSdp = performance.now();
+        const { sdpAnswer, sdpPollingAttempts } = yield this.coordinatorClient.connect(
           sessionId,
           void 0,
           options == null ? void 0 : options.maxAttempts
         );
+        const sdpPollingMs = performance.now() - tSdp;
+        this.connectionTimings = {
+          sessionCreationMs,
+          sdpPollingMs,
+          sdpPollingAttempts,
+          iceNegotiationMs: 0,
+          dataChannelMs: 0,
+          totalMs: 0
+        };
         yield this.machineClient.connect(sdpAnswer);
       } catch (error) {
+        if (isAbortError(error)) return;
         console.error("[Reactor] Connection failed:", error);
         this.createError(
           "CONNECTION_FAILED",
           `Connection failed: ${error}`,
-          "coordinator",
+          "api",
           true
         );
         try {
@@ -1406,19 +1595,28 @@ var Reactor = class {
   }
   /**
    * Sets up event handlers for the machine client.
+   *
+   * Each handler captures the client reference at registration time and
+   * ignores events if this.machineClient has since changed (e.g. after
+   * disconnect + reconnect), preventing stale WebRTC teardown events from
+   * interfering with a new connection.
    */
   setupMachineClientHandlers() {
     if (!this.machineClient) return;
-    this.machineClient.on("message", (message, scope) => {
+    const client = this.machineClient;
+    client.on("message", (message, scope) => {
+      if (this.machineClient !== client) return;
       if (scope === "application") {
         this.emit("message", message);
       } else if (scope === "runtime") {
         this.emit("runtimeMessage", message);
       }
     });
-    this.machineClient.on("statusChanged", (status) => {
+    client.on("statusChanged", (status) => {
+      if (this.machineClient !== client) return;
       switch (status) {
         case "connected":
+          this.finalizeConnectionTimings(client);
           this.setStatus("ready");
           break;
         case "disconnected":
@@ -1435,14 +1633,18 @@ var Reactor = class {
           break;
       }
     });
-    this.machineClient.on(
+    client.on(
       "trackReceived",
       (name, track, stream) => {
+        if (this.machineClient !== client) return;
         this.emit("trackReceived", name, track, stream);
       }
     );
-    this.machineClient.on("statsUpdate", (stats) => {
-      this.emit("statsUpdate", stats);
+    client.on("statsUpdate", (stats) => {
+      if (this.machineClient !== client) return;
+      this.emit("statsUpdate", __spreadProps(__spreadValues({}, stats), {
+        connectionTimings: this.connectionTimings
+      }));
     });
   }
   /**
@@ -1451,10 +1653,12 @@ var Reactor = class {
    */
   disconnect(recoverable = false) {
     return __async(this, null, function* () {
+      var _a;
       if (this.status === "disconnected" && !this.sessionId) {
         console.warn("[Reactor] Already disconnected");
         return;
       }
+      (_a = this.coordinatorClient) == null ? void 0 : _a.abort();
       if (this.coordinatorClient && !recoverable) {
         try {
           yield this.coordinatorClient.terminateSession();
@@ -1474,6 +1678,7 @@ var Reactor = class {
         }
       }
       this.setStatus("disconnected");
+      this.resetConnectionTimings();
       if (!recoverable) {
         this.setSessionExpiration(void 0);
         this.setSessionId(void 0);
@@ -1536,7 +1741,23 @@ var Reactor = class {
   }
   getStats() {
     var _a;
-    return (_a = this.machineClient) == null ? void 0 : _a.getStats();
+    const stats = (_a = this.machineClient) == null ? void 0 : _a.getStats();
+    if (!stats) return void 0;
+    return __spreadProps(__spreadValues({}, stats), { connectionTimings: this.connectionTimings });
+  }
+  resetConnectionTimings() {
+    this.connectStartTime = void 0;
+    this.connectionTimings = void 0;
+  }
+  finalizeConnectionTimings(client) {
+    var _a, _b;
+    if (!this.connectionTimings || this.connectStartTime == null) return;
+    const webrtcTimings = client.getConnectionTimings();
+    this.connectionTimings.iceNegotiationMs = (_a = webrtcTimings == null ? void 0 : webrtcTimings.iceNegotiationMs) != null ? _a : 0;
+    this.connectionTimings.dataChannelMs = (_b = webrtcTimings == null ? void 0 : webrtcTimings.dataChannelMs) != null ? _b : 0;
+    this.connectionTimings.totalMs = performance.now() - this.connectStartTime;
+    this.connectStartTime = void 0;
+    console.debug("[Reactor] Connection timings:", this.connectionTimings);
   }
   /**
    * Create and store an error
@@ -1576,7 +1797,7 @@ var initReactorStore = (props) => {
 };
 var createReactorStore = (initProps, publicState = defaultInitState) => {
   console.debug("[ReactorStore] Creating store", {
-    coordinatorUrl: initProps.coordinatorUrl,
+    apiUrl: initProps.apiUrl,
     jwtToken: initProps.jwtToken,
     initialState: publicState
   });
@@ -1744,7 +1965,7 @@ function ReactorProvider(_a) {
     console.debug("[ReactorProvider] Reactor store created successfully");
   }
   const _a2 = connectOptions != null ? connectOptions : {}, { autoConnect = false } = _a2, pollingOptions = __objRest(_a2, ["autoConnect"]);
-  const { coordinatorUrl, modelName, local, receive, send } = props;
+  const { apiUrl, modelName, local, receive, send } = props;
   const maxAttempts = pollingOptions.maxAttempts;
   (0, import_react3.useEffect)(() => {
     const handleBeforeUnload = () => {
@@ -1797,7 +2018,7 @@ function ReactorProvider(_a) {
     console.debug("[ReactorProvider] Updating reactor store");
     storeRef.current = createReactorStore(
       initReactorStore({
-        coordinatorUrl,
+        apiUrl,
         modelName,
         local,
         receive,
@@ -1829,7 +2050,7 @@ function ReactorProvider(_a) {
       });
     };
   }, [
-    coordinatorUrl,
+    apiUrl,
     modelName,
     autoConnect,
     local,
@@ -2658,12 +2879,12 @@ function WebcamStream({
 }
 
 // src/utils/tokens.ts
-function fetchInsecureJwtToken(_0) {
-  return __async(this, arguments, function* (apiKey, coordinatorUrl = PROD_COORDINATOR_URL) {
+function fetchInsecureToken(_0) {
+  return __async(this, arguments, function* (apiKey, apiUrl = DEFAULT_BASE_URL) {
     console.warn(
-      "[Reactor] \u26A0\uFE0F SECURITY WARNING: fetchInsecureJwtToken() exposes your API key in client-side code. This should ONLY be used for local development or testing. In production, fetch tokens from your server instead."
+      "[Reactor] \u26A0\uFE0F SECURITY WARNING: fetchInsecureToken() exposes your API key in client-side code. This should ONLY be used for local development or testing. In production, fetch tokens from your server instead."
     );
-    const response = yield fetch(`${coordinatorUrl}/tokens`, {
+    const response = yield fetch(`${apiUrl}/tokens`, {
       method: "GET",
       headers: {
         "X-API-Key": apiKey
@@ -2679,15 +2900,17 @@ function fetchInsecureJwtToken(_0) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AbortError,
   ConflictError,
-  PROD_COORDINATOR_URL,
+  DEFAULT_BASE_URL,
   Reactor,
   ReactorController,
   ReactorProvider,
   ReactorView,
   WebcamStream,
   audio,
-  fetchInsecureJwtToken,
+  fetchInsecureToken,
+  isAbortError,
   useReactor,
   useReactorInternalMessage,
   useReactorMessage,