oysterun 1.5.7-beta.8 → 1.5.7

package/bin/oysterun.mjs

@@ -29,6 +29,11 @@ const serviceCommands = new Map([
   ["service:start", "start"],
   ["service:stop", "stop"],
   ["service:restart", "restart"],
+  ["service:update", "update"],
+  ["service:complete-update", "complete-update"],
+  ["service:repair", "repair"],
+  ["service:restore", "restore"],
+  ["service:lifecycle-status", "lifecycle-status"],
   ["service:status", "status"],
   ["service:logs", "logs"],
   ["service:uninstall", "uninstall"],
@@ -55,7 +60,21 @@ function runSetup(args = []) {
 }
 
 function runService(command, args = []) {
-  run(releaseServiceScript, [command, ...args]);
+  const result = spawnSync(releaseServiceScript, [command, ...args], {
+    cwd: repoRoot,
+    env: {
+      ...process.env,
+      OYSTERUN_BOOTSTRAP_NODE_BIN: process.execPath,
+    },
+    stdio: "inherit",
+  });
+  if (result.error) {
+    console.error(
+      `oysterun: failed to run ${releaseServiceScript}: ${result.error.message}`
+    );
+    process.exit(1);
+  }
+  process.exit(result.status ?? 0);
 }
 
 function parseUninstallArgs(args = []) {
@@ -181,6 +200,11 @@ Usage:
   oysterun service:start
   oysterun service:stop
   oysterun service:restart [--restore-sessions]
+  oysterun service:update --channel latest|beta
+  oysterun service:complete-update
+  oysterun service:repair
+  oysterun service:restore
+  oysterun service:lifecycle-status
   oysterun service:status
   oysterun service:logs [--follow]
   oysterun service:uninstall [--stack production|staging|all]

package/dev/client/connectivity/internal-connectivity-status.d.mts

@@ -1,6 +1,14 @@
 export type InternalConnectivityStatus = {
   matrix: "Connected" | "Reconnecting" | "Error" | "Offline";
-  activePath: "WebRTC" | "Bootstrap" | "Direct" | "None";
+  activePath:
+    | "WebRTC"
+    | "WebRTC (LAN)"
+    | "WebRTC (STUN Direct)"
+    | "WebRTC (TURN)"
+    | "WebRTC (IPv6 Direct)"
+    | "Bootstrap"
+    | "Direct"
+    | "None";
   promotion: "Idle" | `Attempt ${number}/4` | "Quiesced" | "Not applicable";
 };
 
@@ -10,5 +18,5 @@ export function deriveInternalConnectivityStatus(input?: {
   transportStatus?: Record<string, unknown>;
 }): InternalConnectivityStatus;
 export function internalConnectivityStatusText(
-  status: InternalConnectivityStatus,
+  status: InternalConnectivityStatus
 ): string;

package/dev/client/connectivity/internal-connectivity-status.mjs

@@ -13,6 +13,14 @@ const ACTIVE_PATH_STATUS = Object.freeze({
   direct_host: "Direct",
 });
 
+const WEBRTC_SELECTED_PATH_STATUS = Object.freeze({
+  lan: "WebRTC (LAN)",
+  stun_direct: "WebRTC (STUN Direct)",
+  turn_udp: "WebRTC (TURN)",
+  turn_tcp_tls: "WebRTC (TURN)",
+  ipv6: "WebRTC (IPv6 Direct)",
+});
+
 export const INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT = 4;
 
 function finiteNonNegativeInteger(value) {
@@ -32,23 +40,26 @@ export function deriveInternalConnectivityStatus({
       transportConnectionState === "disconnected"
         ? "Reconnecting"
         : transportConnectionState === "connected"
-          ? "Connected"
-          : "Offline");
+        ? "Connected"
+        : "Offline");
   const activePath =
-    ACTIVE_PATH_STATUS[transportStatus.active_path_kind] || "None";
+    transportStatus.active_path_kind === "webrtc"
+      ? WEBRTC_SELECTED_PATH_STATUS[transportStatus.webrtc_selected_path] ||
+        ACTIVE_PATH_STATUS.webrtc
+      : ACTIVE_PATH_STATUS[transportStatus.active_path_kind] || "None";
 
   let promotion = "Not applicable";
   if (transportStatus.managed_transport_enabled === true) {
     const attempt = Math.min(
       finiteNonNegativeInteger(transportStatus.promotion_attempt_count),
-      INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT,
+      INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT
     );
     promotion =
       transportStatus.retry_quiesced === true
         ? "Quiesced"
         : attempt > 0
-          ? `Attempt ${attempt}/${INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT}`
-          : "Idle";
+        ? `Attempt ${attempt}/${INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT}`
+        : "Idle";
   }
 
   return Object.freeze({ matrix, activePath, promotion });

package/dev/client/connectivity/managed-host-browser.d.mts

@@ -5,7 +5,8 @@ export class ManagedHostBrowserConnection {
   close(): Promise<void>;
   setTicketProvider(ticketProvider: ManagedHostTicketProvider | null): void;
   subscribeStatus(
-    listener: (status: Record<string, unknown>) => void
+    listener: (status: Record<string, unknown>) => void,
+    options?: { includeSelectedWebRtcPath?: boolean }
   ): () => void;
 }
 
@@ -15,7 +16,8 @@ export class DirectHostBrowserConnection {
   status(): Record<string, unknown>;
   close(): Promise<void>;
   subscribeStatus(
-    listener: (status: Record<string, unknown>) => void
+    listener: (status: Record<string, unknown>) => void,
+    options?: { includeSelectedWebRtcPath?: boolean }
   ): () => void;
 }
 
@@ -32,6 +34,19 @@ export function classifyManagedHostBrowserOrigin(value?: string | URL): {
   kind: "managed_endpoint" | "direct_host";
   managed_transport_enabled: boolean;
 };
+export type ManagedWebRtcSelectedPath =
+  | "lan"
+  | "stun_direct"
+  | "turn_udp"
+  | "turn_tcp_tls"
+  | "ipv6";
+export function normalizeManagedWebRtcSelectedPath(
+  value: unknown
+): ManagedWebRtcSelectedPath | null;
+export function readManagedWebRtcSelectedPath(
+  hostStatus: unknown,
+  connectionId: string
+): ManagedWebRtcSelectedPath | null;
 export function getManagedHostBrowserConnection():
   | ManagedHostBrowserConnection
   | DirectHostBrowserConnection;
@@ -66,5 +81,6 @@ export function managedMediaObjectUrl(
 export function waitForManagedHostAvailability(): Promise<boolean>;
 export function getManagedHostConnectionStatus(): Record<string, unknown>;
 export function subscribeManagedHostConnectionStatus(
-  listener: (status: Record<string, unknown>) => void
+  listener: (status: Record<string, unknown>) => void,
+  options?: { includeSelectedWebRtcPath?: boolean }
 ): () => void;

package/dev/client/connectivity/managed-host-browser.mjs

@@ -11,6 +11,7 @@ const REQUIRED_CHANNELS = Object.freeze(["control", "events", "bulk"]);
 const SUPPORTED_TRANSPORT_PROTOCOL_VERSIONS = Object.freeze([1]);
 const MANAGED_TRANSPORT_CONTRACT = "oysterun.managed_webrtc.v1";
 const SIGNALING_TIMEOUT_MS = 20_000;
+const MANAGED_ICE_CANDIDATE_SETTLE_MS = 100;
 const BOOTSTRAP_SAFE_REQUEST_TIMEOUT_MS = 12_000;
 const BOOTSTRAP_MATRIX_SYNC_TIMEOUT_MS = 45_000;
 const PRESENCE_WAIT_SECONDS = 55;
@@ -30,6 +31,13 @@ const HOST_UNAVAILABLE_RESPONSE_ERROR =
 const BULK_REQUEST_TIMEOUT_MS = 120_000;
 const MATRIX_SYNC_PATH = /^\/_matrix\/client\/[^/]+\/sync(?:\?|$)/;
 const SIGNALING_PATH_PREFIX = "/connectivity/webrtc/";
+const MANAGED_WEBRTC_SELECTED_PATHS = new Set([
+  "lan",
+  "stun_direct",
+  "turn_udp",
+  "turn_tcp_tls",
+  "ipv6",
+]);
 const MANAGED_ENDPOINT_HOSTNAME = /^h-([a-z2-7]{16})\.tunnel\.oysterun\.com$/i;
 const SESSION_SNAPSHOT_PATH = /^\/session\/snapshot(?:\?|$)/;
 const TRANSPORT_PATH_KINDS = Object.freeze([
@@ -354,6 +362,7 @@ function browserConnectionStatusKey(status) {
     status.last_request_failed,
     status.browser_online,
     status.active_path_kind,
+    status.webrtc_selected_path,
     status.transition_state,
     status.transition_generation,
     status.browser_peer_state,
@@ -368,6 +377,30 @@ function browserConnectionStatusKey(status) {
   ]);
 }
 
+export function normalizeManagedWebRtcSelectedPath(value) {
+  return MANAGED_WEBRTC_SELECTED_PATHS.has(value) ? value : null;
+}
+
+export function readManagedWebRtcSelectedPath(hostStatus, connectionId) {
+  if (
+    !hostStatus ||
+    typeof hostStatus !== "object" ||
+    !Array.isArray(hostStatus.peers) ||
+    typeof connectionId !== "string" ||
+    !connectionId
+  ) {
+    return null;
+  }
+  const matchingPeers = hostStatus.peers.filter(
+    (peer) =>
+      peer &&
+      typeof peer === "object" &&
+      peer.connection_id === connectionId
+  );
+  if (matchingPeers.length !== 1) return null;
+  return normalizeManagedWebRtcSelectedPath(matchingPeers[0].selected_path);
+}
+
 function managedHostUnavailableError() {
   const error = new Error(
     "Managed Oysterun Host is unavailable; the request was not sent"
@@ -521,20 +554,161 @@ function fingerprintFromSdp(sdp) {
   return compact;
 }
 
-function waitForIceGatheringComplete(peer) {
-  if (peer.iceGatheringState === "complete") return Promise.resolve();
-  return withTimeout(
-    new Promise((resolve) => {
-      const handleChange = () => {
-        if (peer.iceGatheringState !== "complete") return;
-        peer.removeEventListener("icegatheringstatechange", handleChange);
-        resolve();
-      };
-      peer.addEventListener("icegatheringstatechange", handleChange);
-    }),
-    SIGNALING_TIMEOUT_MS,
-    "Browser ICE candidate gathering timed out"
-  );
+function managedWebRtcAttemptError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function signalingCandidateToJson(candidate) {
+  if (
+    !candidate ||
+    typeof candidate.candidate !== "string" ||
+    !candidate.candidate.trim()
+  ) {
+    return null;
+  }
+  return candidateToJson(candidate);
+}
+
+function createManagedIceCandidateReadiness(
+  peer,
+  {
+    assertCurrentAttempt,
+    settleMs = MANAGED_ICE_CANDIDATE_SETTLE_MS,
+    timeoutMs = SIGNALING_TIMEOUT_MS,
+  } = {}
+) {
+  if (typeof assertCurrentAttempt !== "function") {
+    throw new Error("Managed ICE readiness requires an attempt owner");
+  }
+  const candidates = [];
+  const readiness = deferred();
+  let waitStarted = false;
+  let settled = false;
+  let settleTimer = null;
+  let timeoutTimer = null;
+
+  // A candidate or peer-close callback can reject between setLocalDescription
+  // and wait(). Keep that attempt-owned rejection observed until the caller
+  // reaches the browser_ice_gathering stage.
+  void readiness.promise.catch(() => {});
+
+  const cleanup = () => {
+    if (settleTimer !== null) {
+      clearTimeout(settleTimer);
+      settleTimer = null;
+    }
+    if (timeoutTimer !== null) {
+      clearTimeout(timeoutTimer);
+      timeoutTimer = null;
+    }
+    peer.removeEventListener("icecandidate", handleCandidate);
+    peer.removeEventListener("icegatheringstatechange", handleGatheringChange);
+    peer.removeEventListener("connectionstatechange", handleConnectionChange);
+  };
+  const reject = (error) => {
+    if (settled) return false;
+    settled = true;
+    cleanup();
+    readiness.reject(error);
+    return true;
+  };
+  const resolve = () => {
+    if (settled) return false;
+    try {
+      assertCurrentAttempt(peer);
+    } catch (error) {
+      return reject(error);
+    }
+    if (candidates.length === 0) return false;
+    settled = true;
+    cleanup();
+    readiness.resolve(candidates);
+    return true;
+  };
+  const startSettle = () => {
+    if (settled || settleTimer !== null) return;
+    settleTimer = setTimeout(resolve, settleMs);
+  };
+  function handleCandidate(event) {
+    if (settled) return;
+    try {
+      assertCurrentAttempt(peer);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const candidate = signalingCandidateToJson(event.candidate);
+    if (!candidate) return;
+    candidates.push(candidate);
+    if (peer.iceGatheringState === "complete") {
+      resolve();
+      return;
+    }
+    startSettle();
+  }
+  function handleGatheringChange() {
+    if (settled || peer.iceGatheringState !== "complete") return;
+    resolve();
+  }
+  function handleConnectionChange() {
+    if (settled || peer.connectionState !== "closed") return;
+    reject(
+      managedWebRtcAttemptError(
+        "managed_webrtc_attempt_cancelled",
+        "Managed WebRTC connect attempt was cancelled"
+      )
+    );
+  }
+
+  peer.addEventListener("icecandidate", handleCandidate);
+  peer.addEventListener("icegatheringstatechange", handleGatheringChange);
+  peer.addEventListener("connectionstatechange", handleConnectionChange);
+
+  return {
+    peer,
+    candidates,
+    wait() {
+      if (!waitStarted) {
+        waitStarted = true;
+        try {
+          assertCurrentAttempt(peer);
+        } catch (error) {
+          reject(error);
+          return readiness.promise;
+        }
+        if (peer.iceGatheringState === "complete" && candidates.length > 0) {
+          resolve();
+        } else if (!settled) {
+          timeoutTimer = setTimeout(
+            () =>
+              reject(
+                new Error("Browser ICE candidate gathering timed out")
+              ),
+            timeoutMs
+          );
+        }
+      }
+      return readiness.promise;
+    },
+    cancel(error) {
+      reject(
+        error ||
+          managedWebRtcAttemptError(
+            "managed_webrtc_attempt_cancelled",
+            "Managed WebRTC connect attempt was cancelled"
+          )
+      );
+    },
+    dispose() {
+      if (!settled) {
+        this.cancel();
+      } else {
+        cleanup();
+      }
+    },
+  };
 }
 
 function waitForPeerReady(peer, channels) {
@@ -939,6 +1113,7 @@ export class ManagedHostBrowserConnection {
     });
     this.peer = null;
     this.connectingPeer = null;
+    this.pendingIceCandidateReadiness = null;
     this.webRtcTransport = null;
     this.activeConnection = null;
     this.iceTransportPolicy = "all";
@@ -962,7 +1137,12 @@ export class ManagedHostBrowserConnection {
     this.immediateRecoveryPromise = null;
     this.presenceAbortControllers = new Set();
     this.statusListeners = new Set();
+    this.selectedPathStatusListeners = new Set();
     this.lastNotifiedStatusKey = "";
+    this.webrtcSelectedPath = null;
+    this.webrtcSelectedPathConnectionId = null;
+    this.selectedPathStatusReadConnectionId = null;
+    this.selectedPathStatusReadPromise = null;
     this.lastRequestFailed = false;
     this.accounting = createTransportAccounting();
     this.reconciliationOwner = new EpochBoundTransportReconciliationOwner({
@@ -994,16 +1174,29 @@ export class ManagedHostBrowserConnection {
     this.ticketProvider = ticketProvider;
   }
 
-  subscribeStatus(listener) {
+  subscribeStatus(listener, { includeSelectedWebRtcPath = false } = {}) {
     if (typeof listener !== "function") {
       throw new Error("Managed Host status listener must be a function");
     }
     this.statusListeners.add(listener);
+    if (includeSelectedWebRtcPath === true) {
+      this.selectedPathStatusListeners.add(listener);
+    }
     const status = this.status();
     this.lastNotifiedStatusKey = browserConnectionStatusKey(status);
     listener(status);
+    if (
+      includeSelectedWebRtcPath === true &&
+      status.active_path_kind === "webrtc" &&
+      this.activeConnection?.connectionId
+    ) {
+      void this.refreshSelectedWebRtcPath(
+        this.activeConnection.connectionId
+      );
+    }
     return () => {
       this.statusListeners.delete(listener);
+      this.selectedPathStatusListeners.delete(listener);
     };
   }
 
@@ -1109,6 +1302,70 @@ export class ManagedHostBrowserConnection {
     return data;
   }
 
+  refreshSelectedWebRtcPath(connectionId) {
+    if (
+      this.selectedPathStatusListeners.size === 0 ||
+      typeof connectionId !== "string" ||
+      !connectionId ||
+      this.activeConnection?.connectionId !== connectionId ||
+      this.logicalConnection.status().active_path_kind !== "webrtc"
+    ) {
+      return Promise.resolve(null);
+    }
+    if (this.selectedPathStatusReadConnectionId === connectionId) {
+      return (
+        this.selectedPathStatusReadPromise ||
+        Promise.resolve(this.webrtcSelectedPath)
+      );
+    }
+
+    this.selectedPathStatusReadConnectionId = connectionId;
+    this.webrtcSelectedPath = null;
+    this.webrtcSelectedPathConnectionId = connectionId;
+    const readPromise = this.nativeJson(SIGNALING_PATH_PREFIX + "status", {})
+      .then((hostStatus) => {
+        const selectedPath = readManagedWebRtcSelectedPath(
+          hostStatus,
+          connectionId
+        );
+        if (
+          this.selectedPathStatusListeners.size === 0 ||
+          this.activeConnection?.connectionId !== connectionId ||
+          this.logicalConnection.status().active_path_kind !== "webrtc"
+        ) {
+          return null;
+        }
+        this.webrtcSelectedPath = selectedPath;
+        this.webrtcSelectedPathConnectionId = connectionId;
+        this.emitDiagnostic({
+          event_type: "managed_webrtc_selected_path_resolved",
+          selected_path: selectedPath || "unknown",
+        });
+        this.notifyStatusListeners();
+        return selectedPath;
+      })
+      .catch((error) => {
+        if (
+          this.activeConnection?.connectionId === connectionId &&
+          this.logicalConnection.status().active_path_kind === "webrtc"
+        ) {
+          this.emitDiagnostic({
+            event_type: "managed_webrtc_selected_path_status_failed",
+            error_code:
+              error?.code || "managed_webrtc_selected_path_status_failed",
+          });
+        }
+        return null;
+      })
+      .finally(() => {
+        if (this.selectedPathStatusReadPromise === readPromise) {
+          this.selectedPathStatusReadPromise = null;
+        }
+      });
+    this.selectedPathStatusReadPromise = readPromise;
+    return readPromise;
+  }
+
   ensureSyncOwner() {
     if (this.syncOwnerId) return this.syncOwnerId;
     this.syncOwnerId = "routec-matrix-client";
@@ -1196,6 +1453,15 @@ export class ManagedHostBrowserConnection {
     reconciliationEpoch = this.reconciliationOwner.status().epoch,
     lifecycleReason = "initial_start",
   } = {}) {
+    if (this.pendingIceCandidateReadiness) {
+      this.pendingIceCandidateReadiness.cancel(
+        managedWebRtcAttemptError(
+          "managed_webrtc_stale_connect_attempt",
+          "Managed WebRTC connect attempt was replaced"
+        )
+      );
+      this.pendingIceCandidateReadiness = null;
+    }
     const connectionGeneration = ++this.connectionGeneration;
     const connectionAttemptId = createConnectivityRandomId();
     const attempt = {
@@ -1250,6 +1516,7 @@ export class ManagedHostBrowserConnection {
       iceTransportPolicy,
     });
     this.connectingPeer = peer;
+    let iceCandidateReadiness = null;
     try {
       const channels = Object.fromEntries(
         REQUIRED_CHANNELS.map((name) => [
@@ -1260,19 +1527,20 @@ export class ManagedHostBrowserConnection {
       for (const channel of Object.values(channels)) {
         channel.binaryType = "arraybuffer";
       }
-      const localCandidates = [];
-      peer.addEventListener("icecandidate", (event) => {
-        if (event.candidate) {
-          localCandidates.push(candidateToJson(event.candidate));
-        }
+      iceCandidateReadiness = createManagedIceCandidateReadiness(peer, {
+        assertCurrentAttempt,
       });
+      this.pendingIceCandidateReadiness = iceCandidateReadiness;
       await this.runConnectionStage("browser_offer", attempt, async () => {
         const offer = await peer.createOffer();
         await peer.setLocalDescription(offer);
       });
       await this.runConnectionStage("browser_ice_gathering", attempt, () =>
-        waitForIceGatheringComplete(peer)
+        iceCandidateReadiness.wait()
       );
+      if (this.pendingIceCandidateReadiness === iceCandidateReadiness) {
+        this.pendingIceCandidateReadiness = null;
+      }
       assertCurrentAttempt(peer);
       const localDescription = peer.localDescription;
       if (!localDescription) {
@@ -1301,6 +1569,7 @@ export class ManagedHostBrowserConnection {
                 client_authority_kind: "host_owner_browser",
               }
       );
+      assertCurrentAttempt(peer);
       if (
         !ticket ||
         typeof ticket.credential !== "string" ||
@@ -1325,7 +1594,7 @@ export class ManagedHostBrowserConnection {
               type: localDescription.type,
               sdp: localDescription.sdp,
             },
-            candidates: localCandidates,
+            candidates: iceCandidateReadiness.candidates,
           })
       );
       assertCurrentAttempt(peer);
@@ -1385,6 +1654,12 @@ export class ManagedHostBrowserConnection {
       );
       assertCurrentAttempt(peer);
       this.lastRequestFailed = false;
+      this.webrtcSelectedPath = null;
+      this.webrtcSelectedPathConnectionId = answer.connection_id;
+      this.notifyStatusListeners();
+      if (this.selectedPathStatusListeners.size > 0) {
+        void this.refreshSelectedWebRtcPath(answer.connection_id);
+      }
       this.emitDiagnostic({
         event_type: "managed_webrtc_connected",
         connection_id: answer.connection_id,
@@ -1397,6 +1672,11 @@ export class ManagedHostBrowserConnection {
       if (this.connectingPeer === peer) this.connectingPeer = null;
       peer.close();
       throw error;
+    } finally {
+      if (this.pendingIceCandidateReadiness === iceCandidateReadiness) {
+        this.pendingIceCandidateReadiness = null;
+      }
+      iceCandidateReadiness?.dispose();
     }
   }
 
@@ -1530,6 +1810,15 @@ export class ManagedHostBrowserConnection {
     this.connectionGeneration += 1;
     const connectingPeer = this.connectingPeer;
     this.connectingPeer = null;
+    if (this.pendingIceCandidateReadiness?.peer === connectingPeer) {
+      this.pendingIceCandidateReadiness.cancel(
+        managedWebRtcAttemptError(
+          "managed_webrtc_stale_connect_attempt",
+          "Managed WebRTC connect attempt was replaced"
+        )
+      );
+      this.pendingIceCandidateReadiness = null;
+    }
     connectingPeer?.close();
     const peer = this.peer;
     const connection = this.activeConnection;
@@ -1537,6 +1826,9 @@ export class ManagedHostBrowserConnection {
     this.peer = null;
     this.webRtcTransport = null;
     this.activeConnection = null;
+    this.webrtcSelectedPath = null;
+    this.webrtcSelectedPathConnectionId = null;
+    this.selectedPathStatusReadConnectionId = null;
     if (this.logicalConnection.status().active_path_kind === "webrtc") {
       await this.logicalConnection.activateBootstrap({ reason });
       this.emitDiagnostic({
@@ -2191,6 +2483,12 @@ export class ManagedHostBrowserConnection {
       relay_only_debug_enabled: this.iceTransportPolicy === "relay",
       connection_id: this.activeConnection?.connectionId || null,
       connection_attempt_id: this.activeConnection?.connectionAttemptId || null,
+      webrtc_selected_path:
+        logicalStatus.active_path_kind === "webrtc" &&
+        this.webrtcSelectedPathConnectionId ===
+          this.activeConnection?.connectionId
+          ? this.webrtcSelectedPath
+          : null,
       page_visibility_state: document.visibilityState,
       browser_online: browserOnline,
       retry_count: this.retryCount,
@@ -2234,6 +2532,7 @@ export class ManagedHostBrowserConnection {
     await this.closePeer("browser_connection_closed");
     this.routeUnavailable = false;
     this.statusListeners.clear();
+    this.selectedPathStatusListeners.clear();
     this.abortPresenceRequests();
     this.presenceRecovery?.resolve();
     this.presenceRecovery = null;
@@ -2345,10 +2644,10 @@ export function getManagedHostConnectionStatus() {
   return getManagedHostBrowserConnection().status();
 }
 
-export function subscribeManagedHostConnectionStatus(listener) {
+export function subscribeManagedHostConnectionStatus(listener, options = {}) {
   const connection = getManagedHostBrowserConnection();
   if (typeof connection.subscribeStatus === "function") {
-    return connection.subscribeStatus(listener);
+    return connection.subscribeStatus(listener, options);
   }
   listener(connection.status());
   return () => {};