@pickleball/expo-sdk 0.2.0 → 1.0.0

package/dist/{chunk-FODE2W2H.js → chunk-XGP2MN5R.js}

@@ -186,7 +186,13 @@ function isSessionGoneError(error) {
 
 // src/engine.ts
 var PENDING_END_KEY = "@pickleball/expo-sdk/pending-end";
+var CAPTURE_ORIENTATION_KEY = "@pickleball/expo-sdk/capture-orientation";
 var DEFAULT_STANDBY_TIMEOUT_MS = 15 * 6e4;
+var TOKEN_REFRESH_MARGIN_MS = 2 * 6e4;
+var COMMAND_POLL_STANDBY_MS = 2e3;
+var COMMAND_POLL_LIVE_MS = 4e3;
+var COMMAND_POLL_MAX_BACKOFF_MS = 3e4;
+var COMMAND_POLL_RECONCILE_MS = 3e4;
 var activeStates = /* @__PURE__ */ new Set([
   "standby",
   "live",
@@ -234,7 +240,8 @@ var LivestreamEngine = class {
       cameras: [],
       selectedCameraId: null,
       elapsedMs: 0,
-      isOnline: dependencies.network.isOnline()
+      isOnline: dependencies.network.isOnline(),
+      adoptableSessionId: null
     };
   }
   room;
@@ -260,10 +267,23 @@ var LivestreamEngine = class {
   backgroundTimer;
   standbyTimer;
   reconnectTimer;
+  redialTimer;
+  /** Đang trong vòng quay số lại — xem doRetry() để biết vì sao cần cờ này. */
+  redialing = false;
   heartbeatTimer;
   elapsedTimer;
   tokenRefreshTimer;
   maxSessionTimer;
+  commandPollTimer;
+  /** Huỷ subscription websocket lệnh của phiên hiện tại (nếu đang mở). */
+  commandUnsubscribe;
+  /** Khoá phiên+token đang subscribe — đổi thì resubscribe (token refresh/đổi phiên). */
+  commandSubscriptionKey;
+  /** Websocket đã đẩy được ít nhất một lần → coi là sống, cho phép hạ nhịp poll. */
+  commandSubscriptionActive = false;
+  /** issuedAt của lệnh cuối đã xử lý — server chỉ trả lệnh mới hơn mốc này. */
+  commandCursor = 0;
+  commandPollBackoffMs = 0;
   grant;
   startedAt;
   /** Đang publish track (live) hay chỉ ngồi trong phòng (standby). */
@@ -348,12 +368,19 @@ var LivestreamEngine = class {
         throw new UnsupportedSdkError();
       }
       this.update({ config: bootstrap.config });
-      const permitted = await this.dependencies.runtime.requestPermissions();
+      const room = this.ensureRoom();
+      const permitted = room.requestPermissions ? await room.requestPermissions() : await this.dependencies.runtime.requestPermissions();
       this.ensureOperation(generation);
       if (!permitted) {
         throw new PermissionDeniedError();
       }
-      const room = this.ensureRoom();
+      if (!this.snapshot.captureOrientation) {
+        const stored = await this.dependencies.storage.getItem(CAPTURE_ORIENTATION_KEY).catch(() => null);
+        this.ensureOperation(generation);
+        if (stored === "portrait" || stored === "landscape") {
+          this.update({ captureOrientation: stored });
+        }
+      }
       if (this.snapshot.captureOrientation) {
         await room.setCaptureOrientation?.(this.snapshot.captureOrientation);
       }
@@ -415,7 +442,7 @@ var LivestreamEngine = class {
     this.transition("connecting");
     this.ensureBackgroundGraceTimer();
     try {
-      await this.ensurePendingEndResolved();
+      await this.ensurePendingEndResolved(input.externalSessionId);
       this.ensureOperation(generation);
     } catch (error) {
       if (!this.isOperationCurrent(generation) || error instanceof StaleOperationError) {
@@ -440,7 +467,12 @@ var LivestreamEngine = class {
         );
       }
       this.ownedSessionId = grant.sessionId;
+      if (this.snapshot.adoptableSessionId === grant.sessionId) {
+        this.update({ adoptableSessionId: null });
+      }
       this.grant = grant;
+      this.commandCursor = 0;
+      this.commandPollBackoffMs = 0;
       this.liveTimersStarted = false;
       this.keepAwakeActive = false;
       this.publishing = autoPublish;
@@ -533,7 +565,11 @@ var LivestreamEngine = class {
     if (!sessionId || !this.grant) throw new Error("Missing session grant");
     const activeGrant = this.grant;
     try {
-      await this.refreshCredentials(generation);
+      const expiresAt = this.grant?.tokenExpiresAt ?? 0;
+      const tokenStillFresh = expiresAt > 0 && expiresAt - Date.now() >= TOKEN_REFRESH_MARGIN_MS;
+      if (!this.redialing || !tokenStillFresh) {
+        await this.refreshCredentials(generation);
+      }
       this.ensureOperation(generation);
       await this.requireRoom().connect({
         serverUrl: this.grant.serverUrl,
@@ -549,6 +585,16 @@ var LivestreamEngine = class {
         await this.abandonGrant(activeGrant);
         return;
       }
+      const httpStatus = error.httpStatus;
+      if (httpStatus === 404 || httpStatus === 409) {
+        this.stopRedialing();
+        void this.stop("user");
+        return;
+      }
+      if (this.redialing && this.snapshot.sessionId) {
+        this.update({ error: normalizeError(error) });
+        return;
+      }
       this.fail(error);
     }
   }
@@ -592,6 +638,7 @@ var LivestreamEngine = class {
       if (!this.isOperationCurrent(generation)) return;
     }
     this.update({ captureOrientation: orientation });
+    void this.dependencies.storage.setItem(CAPTURE_ORIENTATION_KEY, orientation).catch(() => void 0);
   }
   async setMicrophoneEnabled(enabled) {
     const generation = this.operationGeneration;
@@ -604,25 +651,38 @@ var LivestreamEngine = class {
     if (event.type === "command") {
       if (event.action === "start") void this.startPublishing();
       else if (event.action === "stop") void this.stopPublishing();
+      else if (event.action === "end") void this.stop("user");
       return;
     }
     if (event.type === "reconnecting" && (this.snapshot.state === "live" || this.snapshot.state === "standby")) {
       this.transition("reconnecting");
       void this.sendTelemetry("reconnect", { phase: "started" });
-      const timeout = this.snapshot.config?.reconnectTimeoutMs ?? 3e4;
+      if (this.room?.needsManualReconnect) {
+        this.clearReconnectTimer();
+        this.scheduleRedial(0);
+        return;
+      }
+      const configured = this.snapshot.config?.reconnectTimeoutMs ?? 3e4;
       this.clearReconnectTimer();
       this.reconnectTimer = setTimeout(() => {
         void this.stop("network_timeout");
-      }, timeout);
+      }, configured);
       return;
     }
     if (event.type === "reconnected" && this.snapshot.state === "reconnecting") {
       this.clearReconnectTimer();
+      this.stopRedialing();
       this.transition(this.publishing ? "live" : "standby");
       void this.sendTelemetry("reconnect", { phase: "recovered" });
       return;
     }
-    if (event.type === "media-error") this.recordError(event.error);
+    if (event.type === "media-error") {
+      if (this.room?.needsManualReconnect && activeStates.has(this.snapshot.state)) {
+        this.handleRoomEvent({ type: "reconnecting" });
+        return;
+      }
+      this.recordError(event.error);
+    }
     if (event.type === "disconnected" && activeStates.has(this.snapshot.state)) {
       this.handleRoomEvent({ type: "reconnecting" });
     }
@@ -651,12 +711,21 @@ var LivestreamEngine = class {
       }
     }, grace);
   }
-  dispose() {
+  /**
+   * `keepSession` = engine bị tháo nhưng phiên phải sống tiếp để lần mở app sau
+   * nhận lại. Mặc định false: giữ NGUYÊN hành vi cũ cho mọi SDK đối tác.
+   *
+   * Lưu ý dispose KHÔNG BAO GIỜ là đường của "người dùng bấm dừng" — nút dừng đi
+   * qua doStop, mà doStop xoá ownedSessionId trước, nên tới đây sessionId đã là
+   * undefined. Vì vậy nhánh end ở đây luôn là teardown NGOÀI Ý MUỐN (app bị giết,
+   * component remount), đúng chỗ cần giữ phiên.
+   */
+  dispose(options) {
     if (this.disposePromise) return this.disposePromise;
     if (this.disposed) return Promise.resolve();
     this.disposed = true;
     this.operationGeneration += 1;
-    const sessionId = this.ownedSessionId;
+    const sessionId = options?.keepSession === true ? void 0 : this.ownedSessionId;
     let releaseEnd = () => void 0;
     const endBarrier = new Promise((resolve) => {
       releaseEnd = resolve;
@@ -665,6 +734,7 @@ var LivestreamEngine = class {
     const roomCleanup = this.releaseRoom(termination?.markerReady);
     this.clearTimers();
     this.dependencies.telemetry?.dispose?.();
+    this.dependencies.commandChannel?.dispose?.();
     this.pendingCriticalTelemetry = void 0;
     this.networkUnsubscribe();
     this.listeners.clear();
@@ -701,10 +771,36 @@ var LivestreamEngine = class {
     await this.dependencies.storage.removeItem(PENDING_END_KEY);
     this.pendingReplayError = void 0;
   }
+  /**
+   * Phiên tưởng đáng nhận lại hoá ra đã chết phía server → BỎ dấu để máy arm
+   * phiên mới được.
+   *
+   * Thiếu hàm này là máy kẹt cứng: dấu vẫn nằm đó chặn mọi lượt start (đúng vai
+   * trò chống phiên song song của nó), mà lượt start duy nhất được cho qua lại là
+   * lượt nhận lại chính cái phiên đã chết — không bao giờ thành công. Đã dính
+   * thật 18/08/2026: lưới standby 30 phút kết thúc phiên trong lúc máy ngủ, mở
+   * lại thì app đứng ở "error" vĩnh viễn.
+   */
+  async abandonAdoptableSession(sessionId) {
+    if (this.snapshot.adoptableSessionId !== sessionId) return;
+    try {
+      await this.dependencies.storage.removeItem(PENDING_END_KEY);
+    } catch {
+    }
+    this.update({ adoptableSessionId: null });
+  }
   async recoverStartupSession() {
     let pending = await this.readPendingEnd();
     if (!pending || this.ownsInMemorySession()) return;
     if (pending.pendingEnd === null) {
+      const keep = await this.dependencies.keepSessionOnRestart?.() === true;
+      console.warn(
+        `[picklive] khoi dong: phien ${pending.sessionId} chua duoc dung co chu y -> ${keep ? "GIU de nhan lai" : "ket thuc"}`
+      );
+      if (keep) {
+        this.update({ adoptableSessionId: pending.sessionId });
+        return;
+      }
       pending = { sessionId: pending.sessionId, pendingEnd: "error" };
       await this.dependencies.storage.setItem(
         PENDING_END_KEY,
@@ -723,10 +819,21 @@ var LivestreamEngine = class {
     await this.dependencies.storage.removeItem(PENDING_END_KEY);
     this.pendingReplayError = void 0;
   }
-  async ensurePendingEndResolved() {
+  /**
+   * Dấu phiên cũ chặn thao tác mới cho tới khi nó được giải quyết.
+   *
+   * `externalSessionId` = id lượt start đang xin đi qua; bỏ trống nghĩa là
+   * prepare (mở camera), vốn phải luôn được phép khi đang định nhận lại — không
+   * mở được camera thì không nhận lại được, và đó chính là bẫy làm máy kẹt cứng ở
+   * màn lỗi "The previous livestream is still pending end".
+   */
+  async ensurePendingEndResolved(externalSessionId) {
     await this.initialize();
     const pending = await this.readPendingEnd();
     if (!pending) return;
+    if (pending.pendingEnd === null && this.snapshot.adoptableSessionId === pending.sessionId && (externalSessionId === void 0 || externalSessionId === `resume-${pending.sessionId}`)) {
+      return;
+    }
     if (!this.dependencies.network.isOnline()) {
       throw new NetworkUnavailableError(
         "Connect to the network to finish the previous livestream"
@@ -814,6 +921,8 @@ var LivestreamEngine = class {
     if (this.tokenRefreshTimer) clearTimeout(this.tokenRefreshTimer);
     if (this.maxSessionTimer) clearTimeout(this.maxSessionTimer);
     this.clearReconnectTimer();
+    this.stopCommandPolling();
+    this.stopCommandSubscription();
     this.backgroundTimer = void 0;
     this.heartbeatTimer = void 0;
     this.elapsedTimer = void 0;
@@ -822,10 +931,179 @@ var LivestreamEngine = class {
     this.sessionDeadline = void 0;
     this.liveTimersStarted = false;
   }
+  /**
+   * Quay số lại với backoff cho adapter cần reconnect thủ công. Mỗi nhịp gọi
+   * retry() (refresh credentials + room.connect + enterSession). Thành công →
+   * enterSession phát "publishing" → nhánh "reconnected" dọn cả hai timer.
+   * Thất bại → doRetry() đưa state về "error" (vẫn còn sessionId) và nhịp sau
+   * retry() lại kéo về "reconnecting" — lặp tới khi doom timer 30s kết liễu.
+   * Backoff thưa dần để không dội server khi ingest thật sự sập.
+   */
+  scheduleRedial(attempt) {
+    this.clearRedialTimer();
+    this.redialing = true;
+    if (!this.dependencies.network.isOnline()) return;
+    const delays = [0, 1e3, 2e3, 4e3, 8e3, 15e3, 3e4];
+    const delay = delays[Math.min(attempt, delays.length - 1)];
+    this.redialTimer = setTimeout(() => {
+      if (this.disposed) return;
+      const s = this.snapshot.state;
+      if (s !== "reconnecting" && !(s === "error" && this.snapshot.sessionId)) {
+        return;
+      }
+      void this.retry().catch(() => {
+      }).finally(() => {
+        if (this.disposed) return;
+        const after = this.snapshot.state;
+        if (after === "reconnecting" || after === "error" && this.snapshot.sessionId) {
+          this.scheduleRedial(attempt + 1);
+        }
+      });
+    }, delay);
+  }
+  clearRedialTimer() {
+    if (this.redialTimer) clearTimeout(this.redialTimer);
+    this.redialTimer = void 0;
+  }
+  stopRedialing() {
+    this.redialing = false;
+    this.clearRedialTimer();
+  }
   clearReconnectTimer() {
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
     this.reconnectTimer = void 0;
   }
+  /**
+   * Poll lệnh chỉ khi phiên là device-rtmp (grant rtmp://) và đang standby/
+   * live. Ngoài hai trạng thái đó không có gì để điều khiển: connecting chưa
+   * có phiên chạy, reconnecting đã có reconnect timer lo, ending/ended thì thôi.
+   */
+  commandPollingWanted() {
+    const grant = this.grant;
+    return Boolean(
+      this.dependencies.commandChannel && grant && /^rtmps?:\/\//i.test(grant.serverUrl) && // "reconnecting" PHẢI có trong danh sách này. Sau khi bỏ trần 75 giây,
+      // máy có thể quay số hàng giờ; nếu trong lúc đó trọng tài kết thúc trận
+      // hoặc nhả sân, đây là đường duy nhất để máy biết mà thôi quay số vào một
+      // phiên đã chết (poll trả status "ended" → nhánh ở pollSessionCommands).
+      // Trước đây chỉ poll ở standby/live nên máy mất mạng là mù hoàn toàn.
+      activeStates.has(this.snapshot.state)
+    );
+  }
+  syncCommandPolling() {
+    if (this.disposed || !this.commandPollingWanted()) {
+      this.stopCommandPolling();
+      this.stopCommandSubscription();
+      return;
+    }
+    this.syncCommandSubscription();
+    if (!this.commandPollTimer) this.scheduleCommandPoll(0);
+  }
+  /**
+   * Mở/đổi websocket nhận lệnh cho phiên hiện tại. Chỉ máy first-party có
+   * dependency này (đối tác qua proxy thì undefined → chỉ poll). Resubscribe
+   * khi đổi phiên HOẶC token (refresh) vì cả hai đi vào khoá.
+   */
+  syncCommandSubscription() {
+    const subscription = this.dependencies.commandSubscription;
+    const grant = this.grant;
+    if (!subscription || !grant) return;
+    const key = `${grant.sessionId}:${grant.telemetry.token}`;
+    if (this.commandSubscriptionKey === key) return;
+    this.stopCommandSubscription();
+    this.commandSubscriptionKey = key;
+    const sessionId = grant.sessionId;
+    this.commandUnsubscribe = subscription.subscribe(
+      grant.telemetry,
+      sessionId,
+      (commands) => {
+        if (this.disposed || this.grant?.sessionId !== sessionId) return;
+        this.commandSubscriptionActive = true;
+        this.applyCommands(commands);
+      },
+      () => {
+        this.commandSubscriptionActive = false;
+      }
+    );
+  }
+  stopCommandSubscription() {
+    if (this.commandUnsubscribe) {
+      try {
+        this.commandUnsubscribe();
+      } catch {
+      }
+    }
+    this.commandUnsubscribe = void 0;
+    this.commandSubscriptionKey = void 0;
+    this.commandSubscriptionActive = false;
+  }
+  stopCommandPolling() {
+    if (this.commandPollTimer) clearTimeout(this.commandPollTimer);
+    this.commandPollTimer = void 0;
+    this.commandPollBackoffMs = 0;
+  }
+  scheduleCommandPoll(delayMs) {
+    this.commandPollTimer = setTimeout(() => {
+      this.commandPollTimer = void 0;
+      void this.pollSessionCommands();
+    }, delayMs);
+    this.commandPollTimer.unref?.();
+  }
+  commandPollInterval() {
+    if (this.commandSubscriptionActive) return COMMAND_POLL_RECONCILE_MS;
+    return this.snapshot.state === "live" ? COMMAND_POLL_LIVE_MS : COMMAND_POLL_STANDBY_MS;
+  }
+  /**
+   * Áp lệnh từ poll HOẶC subscription vào cùng một state machine. Subscription
+   * trả cả lệnh CŨ (after:0) nên phải lọc theo con trỏ ở đây; poll đã lọc
+   * server-side (after=cursor) nên bước lọc này vô hại với nó.
+   */
+  applyCommands(commands) {
+    for (const command of commands) {
+      if (command.issuedAt <= this.commandCursor) continue;
+      this.commandCursor = command.issuedAt;
+      this.handleRoomEvent({ type: "command", action: command.action });
+    }
+  }
+  async pollSessionCommands() {
+    if (!this.commandPollingWanted()) return;
+    const channel = this.dependencies.commandChannel;
+    const grant = this.grant;
+    if (!channel || !grant) return;
+    const sessionId = grant.sessionId;
+    let result = null;
+    try {
+      result = await channel.poll(grant.telemetry, this.commandCursor);
+      this.commandPollBackoffMs = 0;
+    } catch (error) {
+      const status = error?.status;
+      if (status === 401) {
+        void this.refreshCredentials().catch(() => void 0);
+      }
+      if (status === 409 && this.grant?.sessionId === sessionId) {
+        void this.stop("user");
+        return;
+      }
+      this.commandPollBackoffMs = Math.min(
+        COMMAND_POLL_MAX_BACKOFF_MS,
+        Math.max(this.commandPollInterval(), this.commandPollBackoffMs * 2)
+      );
+    }
+    if (this.disposed || this.grant?.sessionId !== sessionId) return;
+    if (result) {
+      this.applyCommands(result.commands);
+      if (result.commands.length === 0) {
+        if (result.status === "ended" && activeStates.has(this.snapshot.state)) {
+          void this.stop("user");
+        } else if (result.status === "live" && this.snapshot.state === "standby") {
+          void this.startPublishing();
+        }
+      }
+    }
+    if (!this.commandPollingWanted() || this.commandPollTimer) return;
+    this.scheduleCommandPoll(
+      this.commandPollBackoffMs || this.commandPollInterval()
+    );
+  }
   /** Heartbeat kèm chỉ số thiết bị (nếu collector được cung cấp). */
   async sendHeartbeat() {
     let metrics = null;
@@ -912,6 +1190,7 @@ var LivestreamEngine = class {
         telemetry: refreshed.telemetry ?? this.grant.telemetry,
         config: refreshed.config
       };
+      this.syncCommandSubscription();
       this.update({ config: refreshed.config });
       this.refreshRetryAttempt = 0;
       if (this.liveTimersStarted) {
@@ -935,6 +1214,7 @@ var LivestreamEngine = class {
     this.update({ state, error: state === "error" ? this.snapshot.error : null });
     if (state === "standby") this.startStandbyTimer();
     else this.clearStandbyTimer();
+    this.syncCommandPolling();
     if (this.snapshot.sessionId) {
       void this.sendTelemetry("state_changed", { from: previous, to: state });
     }
@@ -1002,6 +1282,12 @@ var LivestreamEngine = class {
           this.pendingReplayError = error;
         });
       }
+      if (online && this.room?.needsManualReconnect) {
+        const s = this.snapshot.state;
+        if (s === "reconnecting" || s === "error" && this.snapshot.sessionId) {
+          this.scheduleRedial(0);
+        }
+      }
     });
   }
   requireRoom() {
@@ -1044,7 +1330,10 @@ var LivestreamEngine = class {
     if (this.tokenRefreshTimer) clearTimeout(this.tokenRefreshTimer);
     this.tokenRefreshTimer = void 0;
     if (!this.grant || !this.snapshot.sessionId) return;
-    const delay = delayOverride ?? Math.max(1e3, this.grant.tokenExpiresAt - this.now() - 6e4);
+    const horizon = Math.min(this.grant.tokenExpiresAt, this.grant.telemetry.expiresAt);
+    const remaining = horizon - this.now();
+    if (delayOverride === void 0 && remaining <= 6e4) return;
+    const delay = delayOverride ?? Math.max(1e3, remaining - 6e4);
     this.tokenRefreshTimer = setTimeout(() => {
       void this.refreshCredentials().catch(() => {
         if (this.disposed) return;
@@ -1210,287 +1499,180 @@ var LivestreamEngine = class {
   }
 };
 
-// src/livekit-room-adapter.ts
-var LiveKitRoomAdapter = class {
-  constructor(bindings) {
-    this.bindings = bindings;
-    bindings.registerGlobals();
-    this.room = bindings.createRoom();
-    this.nativeListeners = [
-      [bindings.events.reconnecting, () => this.emit({ type: "reconnecting" })],
-      [bindings.events.reconnected, () => this.emit({ type: "reconnected" })],
-      [bindings.events.disconnected, (reason) => {
-        this.published = false;
-        this.emit({ type: "disconnected", reason: String(reason ?? "") });
-      }],
-      [bindings.events.mediaDevicesError, (error) => this.emit({ type: "media-error", error })]
-    ];
-    if (bindings.events.dataReceived) {
-      this.nativeListeners.push([
-        bindings.events.dataReceived,
-        (payload) => {
-          try {
-            const text = new TextDecoder().decode(payload);
-            const parsed = JSON.parse(text);
-            if (parsed?.type === "cmd" && typeof parsed.action === "string") {
-              this.emit({ type: "command", action: parsed.action });
-            }
-          } catch {
-          }
-        }
-      ]);
-    }
-    for (const [event, listener] of this.nativeListeners) {
-      this.room.on(event, listener);
-    }
-  }
-  room;
-  listeners = /* @__PURE__ */ new Set();
-  tracks = [];
-  videoTrack;
-  audioTrack;
-  preview;
-  // Khớp engine (isCameraFront: false) — xem ghi chú ở engine.ts.
-  isFront = false;
-  orientationOverride = null;
-  deviceOverride = null;
-  published = false;
-  disposed = false;
-  quality = 720;
-  nativeListeners;
-  async preparePreview(quality) {
-    this.ensureNotDisposed();
-    this.quality = quality;
-    await this.ensurePreparedTracks();
-    this.ensureNotDisposed();
-    return this.preview;
-  }
-  async connect(input) {
-    this.ensureNotDisposed();
-    if (!/^wss?:\/\//i.test(input.serverUrl)) {
-      throw new Error(
-        `Mode LiveKit c\u1EA7n endpoint wss:// nh\u01B0ng phi\xEAn tr\u1EA3 v\u1EC1 "${input.serverUrl}". App tr\xEAn server \u0111ang \u0111\u1EB7t deliveryMode kh\xE1c \u2014 \u0111\u1ED5i mode trong app cho kh\u1EDBp.`
-      );
-    }
-    if (!this.preview) throw new Error("Preview must be prepared before connecting");
-    if (this.room.state !== "disconnected") await this.disconnect(false);
-    await this.ensurePreparedTracks();
-    if (!this.videoTrack || !this.audioTrack || !this.preview) {
-      throw new Error("Camera and microphone tracks are unavailable");
-    }
-    await this.bindings.startAudioSession();
-    await this.room.connect(input.serverUrl, input.participantToken, {
-      autoSubscribe: false
-    });
-    this.published = false;
-    if (input.microphoneEnabled) await this.audioTrack.unmute?.();
-    else await this.audioTrack.mute?.();
-    if (input.publish !== false) {
-      await this.setPublishing(true);
-    }
-  }
-  /** Bật/tắt publish track khi đã trong phòng — standby ↔ live. */
-  async setPublishing(enabled) {
-    this.ensureNotDisposed();
-    if (enabled === this.published) return;
-    if (!this.videoTrack || !this.audioTrack || !this.preview) {
-      throw new Error("Camera and microphone tracks are unavailable");
-    }
-    if (enabled) {
-      const publication = await this.room.localParticipant.publishTrack(
-        this.videoTrack,
-        this.videoPublishOptions()
-      );
-      await this.room.localParticipant.publishTrack(this.audioTrack);
-      this.preview.trackRef = {
-        participant: this.room.localParticipant,
-        publication,
-        source: this.bindings.cameraSource
-      };
-      this.published = true;
-      return;
-    }
-    await this.room.localParticipant.unpublishTrack?.(this.videoTrack, false);
-    await this.room.localParticipant.unpublishTrack?.(this.audioTrack, false);
-    delete this.preview.trackRef;
-    this.published = false;
-  }
-  async disconnect(stopTracks = true) {
-    this.ensureNotDisposed();
-    await this.room.disconnect(stopTracks);
-    this.published = false;
-    if (this.preview) delete this.preview.trackRef;
-    await this.bindings.stopAudioSession();
-    if (stopTracks) this.releaseTracks(true);
-  }
-  captureResolution() {
-    const [long, short] = this.quality === 1080 ? [1920, 1080] : [1280, 720];
-    return { width: long, height: short, frameRate: 30 };
-  }
-  /**
-   * Tùy chọn publish video. Mặc định của livekit-client (VP8, không encoding,
-   * không degradation preference) khiến uplink yếu bóp bitrate xuống ~600kbps
-   * mà VẪN giữ 1080 @ ~10fps → khối bể nát, tệ hơn 720p sạch.
-   *
-   * - videoCodec H.264: HW-encode trên Android, hiệu quả hơn VP8 ở bitrate thấp,
-   *   trùng preset egress (H264_*) nên bỏ được 1 lần transcode phía egress.
-   * - simulcast tắt: viewer chỉ xem HLS do egress xuất; egress subscribe đúng
-   *   1 lớp đã publish, nên simulcast chỉ thêm tải/bất ổn encoder (H.264 simulcast
-   *   kém tin cậy trên Android) mà không lợi gì cho người xem ở kiến trúc này.
-   * - maintain-framerate: pickleball chuyển động nhanh; khi uplink không gánh nổi
-   *   mức đích thì HẠ ĐỘ PHÂN GIẢI (giữ nét-trên-điểm-ảnh) thay vì đóng băng fps.
-   * - maxBitrate: trần theo mức chất lượng; BWE vẫn tự hạ dưới trần khi mạng yếu.
-   */
-  videoPublishOptions() {
-    return {
-      source: this.bindings.cameraSource,
-      simulcast: false,
-      videoCodec: "h264",
-      degradationPreference: "maintain-framerate",
-      videoEncoding: {
-        maxBitrate: this.quality === 1080 ? 45e5 : 25e5,
-        maxFramerate: 30
-      }
-    };
-  }
-  async setCaptureOrientation(orientation) {
-    this.ensureNotDisposed();
-    this.orientationOverride = orientation;
-  }
-  /**
-   * livekit-client restart() chỉ giữ deviceId/facingMode khi gọi getUserMedia
-   * (vứt width/height/frameRate) nên track mới rơi về format mặc định
-   * 640x480. Native applyConstraints thì ngược lại: chỉ xử lý
-   * width/height/frameRate. Sau mỗi restartTrack phải nắn lại format trên
-   * track mới bằng applyConstraints.
-   */
-  async reapplyCaptureFormat() {
-    const nativeTrack = this.videoTrack?.mediaStreamTrack;
-    if (nativeTrack?.applyConstraints) {
-      await nativeTrack.applyConstraints(this.captureResolution());
-    }
-  }
-  async switchCamera() {
-    this.ensureNotDisposed();
-    const facingMode = this.isFront ? "environment" : "user";
-    const nativeTrack = this.videoTrack?.mediaStreamTrack;
-    if (typeof this.videoTrack?.restartTrack === "function") {
-      await this.videoTrack.restartTrack({ facingMode });
-      await this.reapplyCaptureFormat();
-    } else if (typeof nativeTrack?._switchCamera === "function") {
-      nativeTrack._switchCamera();
-    } else if (nativeTrack?.applyConstraints) {
-      await nativeTrack.applyConstraints({ facingMode });
-    } else {
-      throw new Error("Camera switching is unavailable");
-    }
-    this.deviceOverride = null;
-    this.isFront = !this.isFront;
-  }
-  async listCameras() {
-    this.ensureNotDisposed();
-    return await this.bindings.listCameras?.() ?? [];
-  }
-  async selectCamera(deviceId, facing) {
-    this.ensureNotDisposed();
-    if (typeof this.videoTrack?.restartTrack !== "function") {
-      throw new Error("Camera selection is unavailable");
-    }
-    await this.videoTrack.restartTrack({ deviceId });
-    await this.reapplyCaptureFormat();
-    this.deviceOverride = deviceId;
-    if (facing !== "unknown") this.isFront = facing === "front";
-  }
-  async setMicrophoneEnabled(enabled) {
-    this.ensureNotDisposed();
-    if (!this.audioTrack) return;
-    if (enabled) await this.audioTrack.unmute?.();
-    else await this.audioTrack.mute?.();
-  }
-  subscribe(listener) {
-    this.ensureNotDisposed();
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
+// src/uplink-check.ts
+var VIDEO_BITRATE_BPS = Object.freeze({
+  720: 35e5,
+  1080: 6e6
+});
+var AUDIO_BITRATE_BPS = 128e3;
+var DEFAULT_UPLOAD_URL = "https://speed.cloudflare.com/__up";
+var WARMUP_BYTES = 512 * 1024;
+function requiredMbpsFor(settings) {
+  return (VIDEO_BITRATE_BPS[settings.resolution] + AUDIO_BITRATE_BPS) / 1e6;
+}
+function verdictFor(uploadMbps, requiredMbps) {
+  if (uploadMbps >= requiredMbps * 1.8) return "good";
+  if (uploadMbps >= requiredMbps * 1.25) return "ok";
+  return "low";
+}
+function chunk(bytes) {
+  const buffer = new Uint8Array(bytes);
+  for (let i = 0; i < bytes; i += 977) buffer[i] = i & 255;
+  return buffer;
+}
+function resolveFetch(explicit) {
+  if (explicit) return explicit;
+  try {
+    const expoFetch = __require("expo/fetch")?.fetch;
+    if (typeof expoFetch === "function") return expoFetch;
+  } catch {
   }
-  async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    for (const [event, listener] of this.nativeListeners) {
-      this.room.off(event, listener);
+  return globalThis.fetch;
+}
+async function runUplinkCheck(options) {
+  const fetchImplementation = resolveFetch(options.fetch);
+  const uploadUrl = options.uploadUrl ?? DEFAULT_UPLOAD_URL;
+  const measureMs = options.measureMs ?? 6e3;
+  const totalTimeoutMs = options.totalTimeoutMs ?? 25e3;
+  const chunkBytes = options.chunkBytes ?? 2 * 1024 * 1024;
+  async function post(body2, timeoutMs) {
+    const abort = new AbortController();
+    const timer = setTimeout(() => abort.abort(), timeoutMs);
+    try {
+      const response = await fetchImplementation(uploadUrl, {
+        method: "POST",
+        body: body2,
+        signal: abort.signal
+      });
+      await response.text().catch(() => void 0);
+    } finally {
+      clearTimeout(timer);
     }
-    await this.room.disconnect(true);
-    await this.bindings.stopAudioSession();
-    this.releaseTracks(true);
-    this.listeners.clear();
   }
-  releaseTracks(clearPreview) {
-    for (const track of this.tracks) track.stop();
-    this.tracks = [];
-    this.videoTrack = void 0;
-    this.audioTrack = void 0;
-    if (clearPreview) this.preview = void 0;
-    else if (this.preview) delete this.preview.trackRef;
-  }
-  async ensurePreparedTracks() {
-    this.ensureNotDisposed();
-    const tracksReady = this.videoTrack?.mediaStreamTrack?.readyState !== "ended" && this.audioTrack?.mediaStreamTrack?.readyState !== "ended" && Boolean(this.videoTrack && this.audioTrack);
-    if (tracksReady) return;
-    if (this.tracks.length) this.releaseTracks(false);
-    const resolution = this.captureResolution();
-    const tracks = await this.bindings.createLocalTracks({
-      audio: true,
-      video: {
-        ...this.deviceOverride ? { deviceId: this.deviceOverride } : { facingMode: this.isFront ? "user" : "environment" },
-        resolution
+  async function measurePing(url) {
+    let best = null;
+    for (let i = 0; i < 3; i += 1) {
+      const abort = new AbortController();
+      const timer = setTimeout(() => abort.abort(), 4e3);
+      const started2 = Date.now();
+      try {
+        await fetchImplementation(url, { method: "HEAD", signal: abort.signal });
+        const elapsed = Date.now() - started2;
+        if (best === null || elapsed < best) best = elapsed;
+      } catch {
+      } finally {
+        clearTimeout(timer);
       }
-    });
-    if (this.disposed) {
-      for (const track of tracks) track.stop();
-      throw new Error("LiveKit room adapter has been disposed");
-    }
-    this.tracks = tracks;
-    this.videoTrack = this.tracks.find((track) => track.kind === "video");
-    this.audioTrack = this.tracks.find((track) => track.kind === "audio");
-    if (!this.videoTrack || !this.audioTrack) {
-      this.releaseTracks(true);
-      throw new Error("LiveKit did not create camera and microphone tracks");
-    }
-    if (this.preview) {
-      this.preview.videoTrack = this.videoTrack;
-      delete this.preview.trackRef;
-    } else {
-      this.preview = { videoTrack: this.videoTrack };
     }
+    return best;
   }
-  emit(event) {
-    for (const listener of this.listeners) listener(event);
-  }
-  ensureNotDisposed() {
-    if (this.disposed) {
-      throw new Error("LiveKit room adapter has been disposed");
+  const deadline = Date.now() + totalTimeoutMs;
+  const requiredMbps = requiredMbpsFor(options);
+  const isAbort = (error) => error?.name === "AbortError";
+  const warmupBytes = Math.min(WARMUP_BYTES, chunkBytes);
+  const warmupStarted = Date.now();
+  try {
+    await post(chunk(warmupBytes), options.warmupTimeoutMs ?? 1e4);
+  } catch (error) {
+    if (!isAbort(error)) throw error;
+    const seconds = Math.max(1, (Date.now() - warmupStarted) / 1e3);
+    const uploadMbps2 = warmupBytes * 8 / seconds / 1e6;
+    return { uploadMbps: uploadMbps2, pingMs: null, requiredMbps, verdict: "low" };
+  }
+  const body = chunk(chunkBytes);
+  let sentBytes = 0;
+  const started = Date.now();
+  while (Date.now() - started < measureMs && Date.now() < deadline) {
+    try {
+      await post(body, Math.max(3e3, deadline - Date.now()));
+    } catch (error) {
+      if (!isAbort(error)) throw error;
+      break;
     }
+    sentBytes += body.byteLength;
   }
-};
+  const elapsedSeconds = Math.max((Date.now() - started) / 1e3, 1e-3);
+  const uploadMbps = sentBytes * 8 / elapsedSeconds / 1e6;
+  return {
+    uploadMbps,
+    pingMs: options.pingUrl ? await measurePing(options.pingUrl) : null,
+    requiredMbps,
+    verdict: verdictFor(uploadMbps, requiredMbps)
+  };
+}
 
 // src/rtmp-room-adapter.ts
-var VIDEO_BITRATE = {
-  720: 35e5,
-  1080: 6e6
-};
+var VIDEO_BITRATE = VIDEO_BITRATE_BPS;
+var BITRATE_FLOOR = 8e5;
+var DEGRADE_FACTOR = 0.7;
+var RECOVER_FACTOR = 1.15;
+var RECOVER_AFTER_SUFFICIENT = 5;
+function nextBitrateState(state, event) {
+  if (!event.sufficient) {
+    return {
+      ...state,
+      current: Math.max(BITRATE_FLOOR, Math.round(state.current * DEGRADE_FACTOR)),
+      sufficientStreak: 0
+    };
+  }
+  const streak = state.sufficientStreak + 1;
+  if (streak < RECOVER_AFTER_SUFFICIENT || state.current >= state.ceiling) {
+    return { ...state, sufficientStreak: Math.min(streak, RECOVER_AFTER_SUFFICIENT) };
+  }
+  return {
+    ...state,
+    current: Math.min(state.ceiling, Math.round(state.current * RECOVER_FACTOR)),
+    sufficientStreak: 0
+  };
+}
 var RtmpRoomAdapter = class {
-  constructor(bindings) {
+  constructor(bindings, options = {}) {
     this.bindings = bindings;
+    this.options = options;
+    const request = bindings.requestPermissions?.bind(bindings);
+    if (request) this.requestPermissions = request;
   }
+  /**
+   * RTMP không tự hồi: native chỉ phát hiện đứt (watchdog iOS / onDisconnect
+   * Android) và báo "disconnected" — không tự quay số lại. Engine thấy cờ này
+   * là chạy vòng redial backoff. Thiếu cờ: phiên ngồi chờ "reconnected" không
+   * bao giờ tới rồi chết network_timeout sau 30s (prod 17/08/2026).
+   */
+  needsManualReconnect = true;
   listeners = /* @__PURE__ */ new Set();
   nativeSubscription;
+  bandwidthSubscription;
   quality = 1080;
   connected = false;
+  prepared = false;
+  /** Khung người dùng chọn trên UI (9:16/16:9) — ưu tiên hơn hướng cầm máy. */
+  captureOrientation;
+  bitrateState;
+  /**
+   * Chỉ tồn tại khi bindings hỗ trợ — engine kiểm tra truthiness để quyết định
+   * fallback về runtime.requestPermissions() (getUserMedia), nên KHÔNG được
+   * khai báo method luôn-có rồi tự fallback bên trong.
+   */
+  requestPermissions;
+  /**
+   * Phần tuỳ chọn của prepare(). Giữ dạng spread có điều kiện: truyền
+   * `frameRate: undefined` xuống Expo Record là ghi đè mặc định của native
+   * bằng null chứ không phải "bỏ qua trường".
+   */
+  prepareOverrides() {
+    return {
+      ...this.options.frameRate !== void 0 ? { frameRate: this.options.frameRate } : {},
+      ...this.options.cameraId !== void 0 ? { cameraId: this.options.cameraId } : {}
+    };
+  }
   async preparePreview(quality) {
     this.quality = quality;
     await this.bindings.prepare({
       quality,
-      landscape: this.bindings.isLandscape?.() ?? true
+      landscape: this.captureOrientation ? this.captureOrientation === "landscape" : this.bindings.isLandscape?.() ?? true,
+      ...this.prepareOverrides()
     });
+    this.prepared = true;
     return { kind: "rtmp" };
   }
   async connect(input) {
@@ -1508,6 +1690,11 @@ var RtmpRoomAdapter = class {
       publish: input.publish !== false
     });
     this.connected = true;
+    this.bitrateState = {
+      current: VIDEO_BITRATE[this.quality],
+      ceiling: VIDEO_BITRATE[this.quality],
+      sufficientStreak: 0
+    };
   }
   async setPublishing(enabled) {
     await this.bindings.setPublishing(enabled);
@@ -1515,6 +1702,7 @@ var RtmpRoomAdapter = class {
   async disconnect(_stopTracks) {
     if (!this.connected) return;
     this.connected = false;
+    this.bitrateState = void 0;
     await this.bindings.disconnect();
   }
   async switchCamera() {
@@ -1538,7 +1726,15 @@ var RtmpRoomAdapter = class {
   async setVideoBitrate(bitsPerSecond) {
     await this.bindings.setVideoBitrate(bitsPerSecond);
   }
-  async setCaptureOrientation(_orientation) {
+  async setCaptureOrientation(orientation) {
+    this.captureOrientation = orientation;
+    if (this.prepared && !this.connected) {
+      await this.bindings.prepare({
+        quality: this.quality,
+        landscape: orientation === "landscape",
+        ...this.prepareOverrides()
+      });
+    }
   }
   subscribe(listener) {
     this.listeners.add(listener);
@@ -1548,6 +1744,11 @@ var RtmpRoomAdapter = class {
         if (mapped) this.emit(mapped);
       });
     }
+    if (!this.bandwidthSubscription && this.bindings.addBandwidthListener) {
+      this.bandwidthSubscription = this.bindings.addBandwidthListener(
+        (event) => this.handleBandwidth(event)
+      );
+    }
     return () => {
       this.listeners.delete(listener);
     };
@@ -1555,10 +1756,22 @@ var RtmpRoomAdapter = class {
   async dispose() {
     this.nativeSubscription?.remove();
     this.nativeSubscription = void 0;
+    this.bandwidthSubscription?.remove();
+    this.bandwidthSubscription = void 0;
     this.listeners.clear();
     this.connected = false;
+    this.bitrateState = void 0;
     await this.bindings.dispose();
   }
+  handleBandwidth(event) {
+    const state = this.bitrateState;
+    if (!this.connected || !state) return;
+    const next = nextBitrateState(state, event);
+    this.bitrateState = next;
+    if (next.current !== state.current) {
+      void this.bindings.setVideoBitrate(next.current).catch(() => void 0);
+    }
+  }
   emit(event) {
     for (const listener of this.listeners) listener(event);
   }
@@ -1580,74 +1793,55 @@ function mapStatus(event) {
 }
 
 // src/native-runtime.ts
-var globalsRegistered = false;
-function createNativeLiveKitBindings() {
-  const reactNativeLiveKit = __require("@livekit/react-native");
-  const liveKit = __require("livekit-client");
-  return {
-    registerGlobals() {
-      if (!globalsRegistered) {
-        reactNativeLiveKit.registerGlobals();
-        globalsRegistered = true;
-      }
-    },
-    createRoom: () => new liveKit.Room({ adaptiveStream: false, dynacast: false }),
-    createLocalTracks: liveKit.createLocalTracks,
-    startAudioSession: () => reactNativeLiveKit.AudioSession.startAudioSession(),
-    stopAudioSession: () => reactNativeLiveKit.AudioSession.stopAudioSession(),
-    isLandscape() {
-      const { width, height } = __require("react-native").Dimensions.get("window");
-      return width > height;
-    },
-    async listCameras() {
-      const { mediaDevices } = __require("@livekit/react-native-webrtc");
-      const devices = await mediaDevices.enumerateDevices();
-      return devices.filter((device) => device.kind === "videoinput" && device.deviceId).map((device) => ({
-        deviceId: String(device.deviceId),
-        label: String(device.label ?? ""),
-        facing: device.facing === "front" || device.facing === "environment" ? device.facing : "unknown"
-      }));
-    },
-    cameraSource: liveKit.Track.Source.Camera,
-    events: {
-      reconnecting: liveKit.RoomEvent.Reconnecting,
-      reconnected: liveKit.RoomEvent.Reconnected,
-      disconnected: liveKit.RoomEvent.Disconnected,
-      mediaDevicesError: liveKit.RoomEvent.MediaDevicesError,
-      dataReceived: liveKit.RoomEvent.DataReceived
-    }
-  };
-}
-function createDefaultRuntime() {
-  const { NativeModules, Platform } = __require("react-native");
+function createRtmpRuntime() {
+  const { Platform, PermissionsAndroid } = __require("react-native");
   return {
     assertSupported() {
-      if (Platform.OS !== "ios" && Platform.OS !== "android" || !NativeModules.LivekitReactNativeModule) {
+      if (Platform.OS !== "ios" && Platform.OS !== "android") {
         throw new UnsupportedRuntimeError();
       }
+      try {
+        __require("@pickleball/rtmp-native");
+      } catch {
+        throw new UnsupportedRuntimeError(
+          "@pickleball/rtmp-native is required: install it and rebuild the Development Build"
+        );
+      }
     },
     async requestPermissions() {
+      if (Platform.OS === "android") {
+        try {
+          const granted = await PermissionsAndroid.requestMultiple([
+            PermissionsAndroid.PERMISSIONS.CAMERA,
+            PermissionsAndroid.PERMISSIONS.RECORD_AUDIO
+          ]);
+          return granted[PermissionsAndroid.PERMISSIONS.CAMERA] === PermissionsAndroid.RESULTS.GRANTED && granted[PermissionsAndroid.PERMISSIONS.RECORD_AUDIO] === PermissionsAndroid.RESULTS.GRANTED;
+        } catch {
+          return false;
+        }
+      }
       try {
-        const { mediaDevices } = __require("@livekit/react-native-webrtc");
-        const stream = await mediaDevices.getUserMedia({ audio: true, video: true });
-        for (const track of stream.getTracks()) track.stop();
-        return true;
+        const native = __require("@pickleball/rtmp-native").default;
+        if (typeof native?.requestPermissions === "function") {
+          return await native.requestPermissions() !== false;
+        }
       } catch {
-        return false;
       }
+      return true;
     },
-    activateKeepAwake() {
-      return __require("expo-keep-awake").activateKeepAwakeAsync(
-        "@pickleball/expo-sdk"
-      );
-    },
-    deactivateKeepAwake() {
-      return __require("expo-keep-awake").deactivateKeepAwake(
-        "@pickleball/expo-sdk"
-      );
+    activateKeepAwake: () => Promise.resolve(
+      __require("expo-keep-awake").activateKeepAwakeAsync("@pickleball/expo-sdk")
+    ).catch(() => void 0),
+    // deactivate trả promise và REJECT khi activity đã chết (sau crash/reload) —
+    // không catch là thêm một "Uncaught (in promise)" gây nhiễu log.
+    deactivateKeepAwake: () => {
+      void Promise.resolve(
+        __require("expo-keep-awake").deactivateKeepAwake("@pickleball/expo-sdk")
+      ).catch(() => void 0);
     }
   };
 }
+var createDefaultRuntime = createRtmpRuntime;
 function createDefaultStorage() {
   let installed = false;
   const install = () => {
@@ -1724,12 +1918,90 @@ function createDefaultTelemetry(fetchImplementation = globalThis.fetch, timeoutM
   };
 }
 function createDefaultRoomFactory() {
-  return () => new LiveKitRoomAdapter(createNativeLiveKitBindings());
+  return createRtmpRoomFactory();
+}
+function createDefaultCommandChannel(fetchImplementation = globalThis.fetch, timeoutMs = 1e4) {
+  const controllers = /* @__PURE__ */ new Set();
+  return {
+    async poll(credentials, after) {
+      const endpoint = credentials.endpoint.replace(/\/telemetry$/, "/commands");
+      const controller = new AbortController();
+      controllers.add(controller);
+      const timeout = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const response = await fetchImplementation(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${credentials.token}`
+          },
+          body: JSON.stringify({ after }),
+          signal: controller.signal,
+          redirect: "error"
+        });
+        if (!response.ok) {
+          if (typeof response.text === "function") await response.text();
+          throw Object.assign(new Error("Command poll rejected"), {
+            status: response.status
+          });
+        }
+        const envelope = await response.json();
+        return parseCommandPollResult(envelope?.data);
+      } finally {
+        clearTimeout(timeout);
+        controllers.delete(controller);
+      }
+    },
+    dispose() {
+      for (const controller of controllers) controller.abort();
+      controllers.clear();
+    }
+  };
+}
+function parseCommandPollResult(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Command poll returned an invalid payload");
+  }
+  const record = value;
+  const status = record.status;
+  if (status !== "scheduled" && status !== "live" && status !== "ended") {
+    throw new Error("Command poll returned an invalid status");
+  }
+  const commands = [];
+  if (Array.isArray(record.commands)) {
+    for (const item of record.commands) {
+      if (item === null || typeof item !== "object") continue;
+      const command = item;
+      if (typeof command.id !== "string" || command.action !== "start" && command.action !== "stop" && command.action !== "end" || typeof command.issuedAt !== "number" || !Number.isFinite(command.issuedAt)) {
+        continue;
+      }
+      commands.push({
+        id: command.id,
+        action: command.action,
+        issuedAt: command.issuedAt
+      });
+    }
+  }
+  return { commands, status };
 }
 function createNativeRtmpBindings() {
   const native = __require("@pickleball/rtmp-native").default;
+  const { Platform, PermissionsAndroid } = __require("react-native");
   return {
     prepare: (options) => native.prepare(options),
+    // Android: xin quyền THUẦN, không mở camera như getUserMedia của WebRTC.
+    // Máy MediaTek (Xiaomi tanzanite) chỉ cho một camera mở cùng lúc — camera
+    // WebRTC chưa nhả (~400ms) là HaishinKit dính "Too many users (-87)" và
+    // preview đen. iOS không có giới hạn đó nên để engine fallback getUserMedia.
+    ...Platform.OS === "android" ? {
+      async requestPermissions() {
+        const granted = await PermissionsAndroid.requestMultiple([
+          PermissionsAndroid.PERMISSIONS.CAMERA,
+          PermissionsAndroid.PERMISSIONS.RECORD_AUDIO
+        ]);
+        return granted[PermissionsAndroid.PERMISSIONS.CAMERA] === PermissionsAndroid.RESULTS.GRANTED && granted[PermissionsAndroid.PERMISSIONS.RECORD_AUDIO] === PermissionsAndroid.RESULTS.GRANTED;
+      }
+    } : {},
     isLandscape() {
       const { width, height } = __require("react-native").Dimensions.get("window");
       return width > height;
@@ -1743,11 +2015,12 @@ function createNativeRtmpBindings() {
     setMicrophoneEnabled: (enabled) => native.setMicrophoneEnabled(enabled),
     setVideoBitrate: (bps) => native.setVideoBitrate(bps),
     dispose: () => native.dispose(),
-    addStatusListener: (listener) => native.addListener("onStatusChanged", listener)
+    addStatusListener: (listener) => native.addListener("onStatusChanged", listener),
+    addBandwidthListener: (listener) => native.addListener("onBandwidth", listener)
   };
 }
-function createRtmpRoomFactory() {
-  return () => new RtmpRoomAdapter(createNativeRtmpBindings());
+function createRtmpRoomFactory(options) {
+  return () => new RtmpRoomAdapter(createNativeRtmpBindings(), options);
 }
 function createDefaultDeviceMetrics() {
   return async () => {
@@ -1789,6 +2062,16 @@ function createDefaultDeviceMetrics() {
       }
     } catch {
     }
+    try {
+      const native = __require("@pickleball/rtmp-native").default;
+      const health = await native.getDeviceHealth();
+      if (typeof health?.thermal === "number") metrics.thermal = health.thermal;
+      if (typeof health?.batteryTempC === "number") {
+        metrics.batteryTempC = Math.round(health.batteryTempC * 10) / 10;
+      }
+    } catch (error) {
+      notes.push(`device health: ${String(error)}`);
+    }
     try {
       const NetInfo = __require("@react-native-community/netinfo").default;
       const status = await NetInfo.fetch();
@@ -1797,6 +2080,19 @@ function createDefaultDeviceMetrics() {
           status.details?.cellularGeneration ?? "cellular"
         ).toUpperCase() : status.type;
       }
+      const details = status?.details;
+      if (typeof details?.ipAddress === "string" && details.ipAddress) {
+        metrics.localIp = details.ipAddress;
+      }
+      if (typeof details?.strength === "number" && Number.isFinite(details.strength)) {
+        metrics.signalPct = Math.round(details.strength);
+      }
+      if (typeof details?.linkSpeed === "number" && Number.isFinite(details.linkSpeed)) {
+        metrics.linkMbps = Math.round(details.linkSpeed);
+      }
+      if (typeof details?.frequency === "number" && Number.isFinite(details.frequency) && details.frequency > 0) {
+        metrics.freqMhz = Math.round(details.frequency);
+      }
     } catch {
     }
     if (notes.length > 0) console.log("[pickleball] metrics notes:", notes.join(" | "));
@@ -1805,7 +2101,7 @@ function createDefaultDeviceMetrics() {
 }
 
 // src/provider.tsx
-import React, { useEffect, useRef, useSyncExternalStore } from "react";
+import React, { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
 import { AppState } from "react-native";
 import { jsx } from "react/jsx-runtime";
 var defaultLivestreamTheme = {
@@ -1836,6 +2132,24 @@ function useLivestreamHost() {
 var LivestreamContext = React.createContext(null);
 function PickleballLiveProvider(props) {
   const engineRef = useRef(null);
+  const keepSessionRef = useRef(props.keepSessionOnRestart);
+  keepSessionRef.current = props.keepSessionOnRestart;
+  const resolvedKeepRef = useRef(typeof props.keepSessionOnRestart === "function");
+  useEffect(() => {
+    const value2 = props.keepSessionOnRestart;
+    if (typeof value2 !== "function") {
+      resolvedKeepRef.current = value2 === true;
+      return;
+    }
+    resolvedKeepRef.current = true;
+    let cancelled = false;
+    void Promise.resolve().then(() => value2()).then((keep) => {
+      if (!cancelled) resolvedKeepRef.current = keep === true;
+    }).catch(() => void 0);
+    return () => {
+      cancelled = true;
+    };
+  }, [props.keepSessionOnRestart]);
   const hostRef = useRef(null);
   const effectGenerationRef = useRef(0);
   if (!engineRef.current) {
@@ -1847,8 +2161,17 @@ function PickleballLiveProvider(props) {
       storage: props.storage ?? createDefaultStorage(),
       network: props.network ?? createDefaultNetwork(),
       telemetry: props.telemetry ?? createDefaultTelemetry(),
+      commandChannel: props.commandChannel ?? createDefaultCommandChannel(),
+      ...props.commandSubscription ? { commandSubscription: props.commandSubscription } : {},
       deviceMetrics,
-      roomFactory: props.roomFactory ?? createDefaultRoomFactory()
+      roomFactory: props.roomFactory ?? createDefaultRoomFactory(),
+      // Đọc qua ref để engine luôn thấy giá trị MỚI NHẤT: engine chỉ dựng một lần
+      // (engineRef), còn prop thì đổi theo việc máy được gán/gỡ sân. Prop dạng
+      // hàm được gọi xuyên qua (engine tự await) — đường cho app đọc thẳng đĩa.
+      keepSessionOnRestart: () => {
+        const value2 = keepSessionRef.current;
+        return typeof value2 === "function" ? value2() : value2 === true;
+      }
     };
     engineRef.current = new LivestreamEngine(dependencies);
     hostRef.current = {
@@ -1875,7 +2198,7 @@ function PickleballLiveProvider(props) {
       subscription.remove();
       queueMicrotask(() => {
         if (effectGenerationRef.current === effectGeneration) {
-          void engine.dispose();
+          void engine.dispose({ keepSession: resolvedKeepRef.current });
         }
       });
     };
@@ -1883,21 +2206,30 @@ function PickleballLiveProvider(props) {
   useEffect(() => {
     if (snapshot.error) props.onError?.(snapshot.error);
   }, [props.onError, snapshot.error]);
-  const value = {
-    ...snapshot,
-    locale: props.locale ?? "vi",
-    theme: { ...defaultLivestreamTheme, ...props.theme },
-    prepare: () => engine.prepare(),
-    start: (input, options) => engine.start(input, options),
-    startPublishing: () => engine.startPublishing(),
-    stopPublishing: () => engine.stopPublishing(),
-    stop: (reason) => engine.stop(reason),
-    retry: () => engine.retry(),
-    switchCamera: () => engine.switchCamera(),
-    setMicrophoneEnabled: (enabled) => engine.setMicrophoneEnabled(enabled),
-    setCaptureOrientation: (orientation) => engine.setCaptureOrientation(orientation),
-    selectCamera: (deviceId) => engine.selectCamera(deviceId)
-  };
+  const actions = useMemo(
+    () => ({
+      prepare: () => engine.prepare(),
+      start: (input, options) => engine.start(input, options),
+      startPublishing: () => engine.startPublishing(),
+      stopPublishing: () => engine.stopPublishing(),
+      stop: (reason) => engine.stop(reason),
+      retry: () => engine.retry(),
+      switchCamera: () => engine.switchCamera(),
+      setMicrophoneEnabled: (enabled) => engine.setMicrophoneEnabled(enabled),
+      setCaptureOrientation: (orientation) => engine.setCaptureOrientation(orientation),
+      selectCamera: (deviceId) => engine.selectCamera(deviceId)
+    }),
+    [engine]
+  );
+  const locale = props.locale ?? "vi";
+  const theme = useMemo(
+    () => ({ ...defaultLivestreamTheme, ...props.theme }),
+    [props.theme]
+  );
+  const value = useMemo(
+    () => ({ ...snapshot, locale, theme, ...actions }),
+    [snapshot, locale, theme, actions]
+  );
   return /* @__PURE__ */ jsx(LivestreamHostContext.Provider, { value: hostRef.current, children: /* @__PURE__ */ jsx(LivestreamContext.Provider, { value, children: props.children }) });
 }
 function useLivestream() {
@@ -1935,9 +2267,14 @@ export {
   PENDING_END_KEY,
   LEGAL_LIVESTREAM_TRANSITIONS,
   LivestreamEngine,
-  LiveKitRoomAdapter,
+  VIDEO_BITRATE_BPS,
+  AUDIO_BITRATE_BPS,
+  DEFAULT_UPLOAD_URL,
+  requiredMbpsFor,
+  verdictFor,
+  runUplinkCheck,
   RtmpRoomAdapter,
-  createNativeLiveKitBindings,
+  createRtmpRuntime,
   createDefaultRuntime,
   createDefaultStorage,
   createDefaultNetwork,