oysterun 1.5.7-beta.7 → 1.5.7-beta.8

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

@@ -0,0 +1,14 @@
+export type InternalConnectivityStatus = {
+  matrix: "Connected" | "Reconnecting" | "Error" | "Offline";
+  activePath: "WebRTC" | "Bootstrap" | "Direct" | "None";
+  promotion: "Idle" | `Attempt ${number}/4` | "Quiesced" | "Not applicable";
+};
+
+export const INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT: 4;
+export function deriveInternalConnectivityStatus(input?: {
+  syncState?: string | null;
+  transportStatus?: Record<string, unknown>;
+}): InternalConnectivityStatus;
+export function internalConnectivityStatusText(
+  status: InternalConnectivityStatus,
+): string;

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

@@ -0,0 +1,59 @@
+const MATRIX_STATUS = Object.freeze({
+  ERROR: "Error",
+  CATCHUP: "Reconnecting",
+  RECONNECTING: "Reconnecting",
+  PREPARED: "Connected",
+  SYNCING: "Connected",
+  STOPPED: "Offline",
+});
+
+const ACTIVE_PATH_STATUS = Object.freeze({
+  webrtc: "WebRTC",
+  bootstrap: "Bootstrap",
+  direct_host: "Direct",
+});
+
+export const INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT = 4;
+
+function finiteNonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : 0;
+}
+
+export function deriveInternalConnectivityStatus({
+  syncState = null,
+  transportStatus = {},
+} = {}) {
+  const browserOffline = transportStatus.browser_online === false;
+  const transportConnectionState = transportStatus.connection_state;
+  const matrix = browserOffline
+    ? "Offline"
+    : MATRIX_STATUS[syncState] ||
+      (transportConnectionState === "recovering" ||
+      transportConnectionState === "disconnected"
+        ? "Reconnecting"
+        : transportConnectionState === "connected"
+          ? "Connected"
+          : "Offline");
+  const activePath =
+    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,
+    );
+    promotion =
+      transportStatus.retry_quiesced === true
+        ? "Quiesced"
+        : attempt > 0
+          ? `Attempt ${attempt}/${INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT}`
+          : "Idle";
+  }
+
+  return Object.freeze({ matrix, activePath, promotion });
+}
+
+export function internalConnectivityStatusText(status) {
+  return `Debug Network Connection Status · Matrix: ${status.matrix} · Active path: ${status.activePath} · WebRTC promotion: ${status.promotion}`;
+}

package/dev/client/connectivity/logical-host-connection.mjs

@@ -16,7 +16,9 @@ async function withTimeout(promise, timeoutMs, message) {
   const timeout = new Promise((_, reject) => {
     timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
   });
-  return Promise.race([promise, timeout]).finally(() => clearTimeout(timeoutId));
+  return Promise.race([promise, timeout]).finally(() =>
+    clearTimeout(timeoutId)
+  );
 }
 
 function headersToObject(headers) {
@@ -84,13 +86,22 @@ async function fetchWithDeadline(fetchImpl, url, options, timeoutMs) {
 }
 
 export class BootstrapFetchTransport {
-  constructor({ fetchImpl = globalThis.fetch, origin = "", diagnostic } = {}) {
+  constructor({
+    fetchImpl = globalThis.fetch,
+    origin = "",
+    diagnostic,
+    responseGuard = null,
+  } = {}) {
     if (typeof fetchImpl !== "function") {
       throw new Error("Bootstrap fetch implementation is required");
     }
+    if (responseGuard !== null && typeof responseGuard !== "function") {
+      throw new Error("Bootstrap response guard must be a function");
+    }
     this.fetchImpl = fetchImpl;
     this.origin = origin.replace(/\/+$/, "");
     this.diagnostic = diagnostic;
+    this.responseGuard = responseGuard;
     this.pathKind = "bootstrap";
   }
 
@@ -109,6 +120,7 @@ export class BootstrapFetchTransport {
       },
       request.timeoutMs
     );
+    await this.responseGuard?.(response);
     const body = new Uint8Array(await response.arrayBuffer());
     this.diagnostic?.({
       event_type: "bootstrap_request_completed",
@@ -279,12 +291,7 @@ export class OysterunLogicalHostConnection {
     return retirePromise;
   }
 
-  changeActiveTransport({
-    transport,
-    pathKind,
-    connectionId,
-    reason,
-  }) {
+  changeActiveTransport({ transport, pathKind, connectionId, reason }) {
     const previousTransport = this.activeTransport;
     const previousPathKind = this.activePathKind;
     if (
@@ -310,10 +317,7 @@ export class OysterunLogicalHostConnection {
       reason,
     });
 
-    if (
-      previousPathKind === "webrtc" &&
-      previousTransport !== transport
-    ) {
+    if (previousPathKind === "webrtc" && previousTransport !== transport) {
       return this.retireTransport(previousTransport, {
         transitionGeneration,
         reason,
@@ -329,6 +333,7 @@ export class OysterunLogicalHostConnection {
       requestId = createConnectivityRandomId(),
       syncOwnerId = null,
       timeoutMs = undefined,
+      onUploadProgress = null,
     } = {}
   ) {
     if (this.closed) throw new Error("Logical Host connection is closed");
@@ -356,6 +361,7 @@ export class OysterunLogicalHostConnection {
       const result = await transport.request(request, {
         requestId,
         signal: request.signal || null,
+        onUploadProgress,
         timeoutMs,
       });
       this.emitDiagnostic({
@@ -417,8 +423,9 @@ export class OysterunLogicalHostConnection {
       active_connection_id: this.activeConnectionId,
       transition_generation: this.transitionGeneration,
       transition_state: this.transitionState,
-      active_in_flight_request_count:
-        this.ensureTransportState(this.activeTransport).inFlight,
+      active_in_flight_request_count: this.ensureTransportState(
+        this.activeTransport
+      ).inFlight,
       retiring_transport_count: this.retiringTransports.size,
       matrix_sync_owner_id: this.syncOwnerId,
       closed: this.closed,

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

@@ -43,6 +43,26 @@ export function managedHostFetch(
   input: RequestInfo | URL,
   init?: RequestInit
 ): Promise<Response>;
+export function managedRequest(
+  input: RequestInfo | URL,
+  init?: RequestInit
+): Promise<Response>;
+export type ManagedBlobUploadInit = Omit<RequestInit, "body"> & {
+  body: Blob | ArrayBuffer | Uint8Array | FormData;
+  onProgress?: ((progress: { loaded: number; total: number }) => void) | null;
+};
+export function managedBlobUpload(
+  input: RequestInfo | URL,
+  init: ManagedBlobUploadInit
+): Promise<Response>;
+export function managedBlobDownload(
+  input: RequestInfo | URL,
+  init?: RequestInit
+): Promise<Response>;
+export function managedMediaObjectUrl(
+  input: RequestInfo | URL,
+  init?: RequestInit
+): Promise<{ blob: Blob; url: string; revoke(): void }>;
 export function waitForManagedHostAvailability(): Promise<boolean>;
 export function getManagedHostConnectionStatus(): Record<string, unknown>;
 export function subscribeManagedHostConnectionStatus(

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

@@ -16,12 +16,18 @@ const BOOTSTRAP_MATRIX_SYNC_TIMEOUT_MS = 45_000;
 const PRESENCE_WAIT_SECONDS = 55;
 const PRESENCE_REQUEST_TIMEOUT_MS = 60_000;
 const PRESENCE_FALLBACK_PROBE_MS = 30_000;
+const PRESENCE_HEALTH_RECOVERY_DELAYS_MS = Object.freeze([
+  250, 500, 1_000, 2_000,
+]);
+const PRESENCE_HEALTH_RECOVERY_MAX_TOTAL_MS = 10_000;
 const BACKGROUND_PROMOTION_ATTEMPT_LIMIT = 4;
 const BACKGROUND_PROMOTION_WINDOW_MS = 30 * 60 * 1000;
 const HOST_UNAVAILABLE_BODY_MAX_BYTES = 16 * 1024;
 const HOST_UNAVAILABLE_MARKER =
   '<meta name="oysterun-route-state" content="host-unavailable">';
-const MAX_CONTROL_REQUEST_BODY_BYTES = 512 * 1024;
+const HOST_UNAVAILABLE_RESPONSE_ERROR =
+  "managed_host_route_unavailable_response";
+const BULK_REQUEST_TIMEOUT_MS = 120_000;
 const MATRIX_SYNC_PATH = /^\/_matrix\/client\/[^/]+\/sync(?:\?|$)/;
 const SIGNALING_PATH_PREFIX = "/connectivity/webrtc/";
 const MANAGED_ENDPOINT_HOSTNAME = /^h-([a-z2-7]{16})\.tunnel\.oysterun\.com$/i;
@@ -370,6 +376,14 @@ function managedHostUnavailableError() {
   return error;
 }
 
+function managedHostRouteUnavailableResponseError() {
+  const error = new Error(
+    "Managed Oysterun Relay reported that the Host route is unavailable"
+  );
+  error.code = HOST_UNAVAILABLE_RESPONSE_ERROR;
+  return error;
+}
+
 function managedHostConnectionClosedError() {
   const error = new Error("Managed Oysterun Host browser connection is closed");
   error.code = "managed_host_connection_closed";
@@ -460,17 +474,6 @@ function withTimeout(promise, timeoutMs, message) {
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
 
-function bytesToBase64(bytes) {
-  let binary = "";
-  const chunkBytes = 0x8000;
-  for (let offset = 0; offset < bytes.byteLength; offset += chunkBytes) {
-    binary += String.fromCharCode(
-      ...bytes.subarray(offset, Math.min(bytes.byteLength, offset + chunkBytes))
-    );
-  }
-  return btoa(binary);
-}
-
 function base64ToBytes(value) {
   const binary = atob(value);
   const bytes = new Uint8Array(binary.length);
@@ -811,7 +814,7 @@ export class DirectHostBrowserConnection {
     this.notifyStatusListeners();
   }
 
-  async fetch(input, init = {}) {
+  async fetch(input, init = {}, _options = {}) {
     const path = normalizeHostPath(input);
     if (path) recordTransportRequest(this.accounting, "direct", path);
     try {
@@ -885,6 +888,7 @@ export class ManagedHostBrowserConnection {
     ticketProvider = null,
     bootstrapSafeRequestTimeoutMs = BOOTSTRAP_SAFE_REQUEST_TIMEOUT_MS,
     bootstrapMatrixSyncTimeoutMs = BOOTSTRAP_MATRIX_SYNC_TIMEOUT_MS,
+    presenceHealthRecoveryDelaysMs = PRESENCE_HEALTH_RECOVERY_DELAYS_MS,
   } = {}) {
     this.origin = origin.replace(/\/+$/, "");
     this.fetchImpl = fetchImpl;
@@ -898,13 +902,36 @@ export class ManagedHostBrowserConnection {
     ) {
       throw new Error("Managed Bootstrap request timeouts must be positive");
     }
+    if (
+      !Array.isArray(presenceHealthRecoveryDelaysMs) ||
+      presenceHealthRecoveryDelaysMs.length === 0 ||
+      presenceHealthRecoveryDelaysMs.some(
+        (delayMs) => !Number.isInteger(delayMs) || delayMs <= 0
+      ) ||
+      presenceHealthRecoveryDelaysMs.reduce(
+        (totalMs, delayMs) => totalMs + delayMs,
+        0
+      ) > PRESENCE_HEALTH_RECOVERY_MAX_TOTAL_MS
+    ) {
+      throw new Error(
+        "Managed Host presence health recovery delays must be positive integers totaling at most 10000ms"
+      );
+    }
     this.bootstrapSafeRequestTimeoutMs = bootstrapSafeRequestTimeoutMs;
     this.bootstrapMatrixSyncTimeoutMs = bootstrapMatrixSyncTimeoutMs;
+    this.presenceHealthRecoveryDelaysMs = Object.freeze([
+      ...presenceHealthRecoveryDelaysMs,
+    ]);
     this.clientInstanceId = getClientInstanceId();
     this.bootstrapTransport = new BootstrapFetchTransport({
       origin: this.origin,
       fetchImpl,
       diagnostic: (event) => this.emitDiagnostic(event),
+      responseGuard: async (response) => {
+        if (await isRelayHostUnavailableResponse(response)) {
+          throw managedHostRouteUnavailableResponseError();
+        }
+      },
     });
     this.logicalConnection = new OysterunLogicalHostConnection({
       bootstrapTransport: this.bootstrapTransport,
@@ -1918,13 +1945,36 @@ export class ManagedHostBrowserConnection {
     return this.immediateRecoveryPromise;
   }
 
+  async attemptBoundedDataPlaneRecovery() {
+    for (const delayMs of this.presenceHealthRecoveryDelaysMs) {
+      await sleep(delayMs);
+      if (
+        !this.routeUnavailable ||
+        this.closed ||
+        globalThis.navigator?.onLine === false
+      ) {
+        return false;
+      }
+      if (await this.probeManagedHealth()) {
+        this.completePresenceRecovery();
+        return true;
+      }
+    }
+    return false;
+  }
+
   async monitorPresenceRecovery() {
     while (this.routeUnavailable && !this.closed) {
       try {
         const presence = await this.fetchPresence();
-        if (presence.route_available && (await this.probeManagedHealth())) {
-          this.completePresenceRecovery();
-          return;
+        if (presence.route_available) {
+          if (await this.probeManagedHealth()) {
+            this.completePresenceRecovery();
+            return;
+          }
+          if (await this.attemptBoundedDataPlaneRecovery()) {
+            return;
+          }
         }
         const waited = await this.fetchPresence("/wait", {
           after_revision: presence.presence_revision,
@@ -2049,6 +2099,16 @@ export class ManagedHostBrowserConnection {
             : null,
         });
       } catch (error) {
+        if (error?.code === HOST_UNAVAILABLE_RESPONSE_ERROR) {
+          const activated = await this.activateHostUnavailable();
+          if (activated) {
+            if (!isSafeRecoveryMethod(method)) {
+              throw managedHostUnavailableError();
+            }
+            await this.waitForPresenceRecovery(requestSignal(input, init));
+            return this.performFetch(input, init, recovery);
+          }
+        }
         const currentPathKind =
           this.logicalConnection.status().active_path_kind;
         if (
@@ -2081,16 +2141,6 @@ export class ManagedHostBrowserConnection {
         logicalResultBodyByteLength(result),
         path
       );
-      if (await isRelayHostUnavailableResponse(response)) {
-        const activated = await this.activateHostUnavailable();
-        if (activated) {
-          if (!isSafeRecoveryMethod(method)) {
-            throw managedHostUnavailableError();
-          }
-          await this.waitForPresenceRecovery(requestSignal(input, init));
-          return this.performFetch(input, init, recovery);
-        }
-      }
       return response;
     }
 
@@ -2099,13 +2149,6 @@ export class ManagedHostBrowserConnection {
       request.method === "GET" || request.method === "HEAD"
         ? null
         : new Uint8Array(await request.arrayBuffer());
-    if (body && body.byteLength > MAX_CONTROL_REQUEST_BODY_BYTES) {
-      recordFallbackReason(this.accounting, "request_body_requires_bootstrap");
-      recordTransportRequest(this.accounting, "bootstrap", path);
-      const response = await this.fetchImpl(input, init);
-      recordNativeResponseBytes(this.accounting, "bootstrap", path, response);
-      return response;
-    }
     if (request.signal.aborted) {
       throw new DOMException("The operation was aborted.", "AbortError");
     }
@@ -2113,14 +2156,18 @@ export class ManagedHostBrowserConnection {
       method: request.method,
       path,
       headers: Object.fromEntries(request.headers.entries()),
-      ...(body ? { body_base64: bytesToBase64(body) } : {}),
+      signal: request.signal,
+      ...(body ? { body } : {}),
     };
     const result = await this.logicalConnection.request(requestPayload, {
       requestId: createConnectivityRandomId(),
       syncOwnerId: MATRIX_SYNC_PATH.test(path) ? this.ensureSyncOwner() : null,
       timeoutMs: MATRIX_SYNC_PATH.test(path)
         ? this.bootstrapMatrixSyncTimeoutMs
+        : body?.byteLength > 0
+        ? BULK_REQUEST_TIMEOUT_MS
         : undefined,
+      onUploadProgress: recovery.onUploadProgress || null,
     });
     recordTransportRequest(this.accounting, "datachannel", path);
     recordTransportResponseBytes(
@@ -2224,6 +2271,53 @@ export function managedHostFetch(input, init) {
   return getManagedHostBrowserConnection().fetch(input, init);
 }
 
+export function managedRequest(input, init) {
+  return managedHostFetch(input, init);
+}
+
+export function managedBlobUpload(
+  input,
+  { body, onProgress = null, ...init } = {}
+) {
+  if (
+    !(body instanceof Blob) &&
+    !(body instanceof ArrayBuffer) &&
+    !(body instanceof Uint8Array) &&
+    !(body instanceof FormData)
+  ) {
+    throw new TypeError(
+      "Managed blob upload requires Blob, bytes, or FormData"
+    );
+  }
+  return getManagedHostBrowserConnection().fetch(
+    input,
+    { ...init, body },
+    { onUploadProgress: onProgress }
+  );
+}
+
+export function managedBlobDownload(input, init = {}) {
+  return managedHostFetch(input, { ...init, method: init.method || "GET" });
+}
+
+export async function managedMediaObjectUrl(input, init = {}) {
+  const response = await managedBlobDownload(input, init);
+  if (!response.ok) {
+    throw new Error(
+      `Managed media download failed with HTTP ${response.status}`
+    );
+  }
+  const blob = await response.blob();
+  const url = URL.createObjectURL(blob);
+  return {
+    blob,
+    url,
+    revoke() {
+      URL.revokeObjectURL(url);
+    },
+  };
+}
+
 export function waitForManagedHostAvailability() {
   const connection = getManagedHostBrowserConnection();
   if (