@pickleball/expo-sdk 0.1.1 → 1.0.0

package/dist/chunk-IUIRVKJI.cjs

@@ -0,0 +1,2290 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+
+var _chunk7OX2DSKIcjs = require('./chunk-7OX2DSKI.cjs');
+
+// src/contracts.ts
+var SDK_TELEMETRY_EVENT_NAMES = [
+  "state_changed",
+  "connection_quality",
+  "reconnect",
+  "error",
+  "heartbeat",
+  "session_ended"
+];
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+var CONFIG_DURATION_LIMITS = {
+  reconnectTimeoutMs: 10 * 6e4,
+  backgroundGraceMs: 10 * 6e4,
+  telemetryIntervalMs: 60 * 6e4,
+  maxSessionDurationMs: 24 * 60 * 6e4
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPositiveDuration(value, maximum) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 && value <= maximum;
+}
+function isSdkRemoteConfig(value) {
+  return isRecord(value) && typeof value.enabled === "boolean" && value.protocolVersion === 1 && typeof value.minSdkVersion === "string" && SEMVER.test(value.minSdkVersion) && typeof value.recommendedSdkVersion === "string" && SEMVER.test(value.recommendedSdkVersion) && (value.videoQuality === 720 || value.videoQuality === 1080) && isPositiveDuration(
+    value.reconnectTimeoutMs,
+    CONFIG_DURATION_LIMITS.reconnectTimeoutMs
+  ) && isPositiveDuration(
+    value.backgroundGraceMs,
+    CONFIG_DURATION_LIMITS.backgroundGraceMs
+  ) && isPositiveDuration(
+    value.telemetryIntervalMs,
+    CONFIG_DURATION_LIMITS.telemetryIntervalMs
+  ) && isPositiveDuration(
+    value.maxSessionDurationMs,
+    CONFIG_DURATION_LIMITS.maxSessionDurationMs
+  );
+}
+function compareSemver(left, right) {
+  const a = SEMVER.exec(left);
+  const b = SEMVER.exec(right);
+  if (!a || !b) throw new TypeError("Invalid semantic version");
+  for (let index = 1; index < 4; index += 1) {
+    const av = BigInt(a[index]);
+    const bv = BigInt(b[index]);
+    if (av < bv) return -1;
+    if (av > bv) return 1;
+  }
+  return 0;
+}
+function isSdkVersionSupported(version, minimum) {
+  try {
+    return compareSemver(version, minimum) >= 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/errors.ts
+var PickleballExpoError = class extends Error {
+  constructor(message, code, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "PickleballExpoError";
+  }
+};
+function namedError(name, code, fallback) {
+  return class extends PickleballExpoError {
+    constructor(message = fallback, options) {
+      super(message, code, options);
+      this.name = name;
+    }
+  };
+}
+var PermissionDeniedError = class extends namedError(
+  "PermissionDeniedError",
+  "PERMISSION_DENIED",
+  "Camera and microphone permissions are required"
+) {
+};
+var NetworkUnavailableError = class extends namedError(
+  "NetworkUnavailableError",
+  "NETWORK_UNAVAILABLE",
+  "A network connection is required"
+) {
+};
+var TokenExpiredError = class extends namedError(
+  "TokenExpiredError",
+  "TOKEN_EXPIRED",
+  "The livestream token expired"
+) {
+};
+var UnsupportedSdkError = class extends namedError(
+  "UnsupportedSdkError",
+  "SDK_UPGRADE_REQUIRED",
+  "This SDK version is no longer supported"
+) {
+};
+var UnsupportedRuntimeError = class extends namedError(
+  "UnsupportedRuntimeError",
+  "UNSUPPORTED_RUNTIME",
+  "Pickleball Live requires an iOS or Android Expo Development Build; Expo Go and web are unsupported"
+) {
+};
+var SessionConflictError = class extends namedError(
+  "SessionConflictError",
+  "SESSION_CONFLICT",
+  "This livestream session conflicts with an active session"
+) {
+};
+var RecordingFailureError = class extends namedError(
+  "RecordingFailureError",
+  "RECORDING_FAILED",
+  "The server recording could not be created"
+) {
+};
+var ConsentRequiredError = class extends namedError(
+  "ConsentRequiredError",
+  "CONSENT_REQUIRED",
+  "Recording consent is required"
+) {
+};
+var SdkDisabledError = class extends namedError(
+  "SdkDisabledError",
+  "SDK_DISABLED",
+  "Livestreaming is disabled for this app"
+) {
+};
+var ExpoSdkConfigurationError = class extends namedError(
+  "ExpoSdkConfigurationError",
+  "CONFIGURATION_ERROR",
+  "The Expo SDK is not configured correctly"
+) {
+};
+var InvalidResponseError = class extends namedError(
+  "InvalidResponseError",
+  "INVALID_RESPONSE",
+  "The session server returned an invalid response"
+) {
+};
+var ExpoSdkTimeoutError = class extends namedError(
+  "ExpoSdkTimeoutError",
+  "TIMEOUT",
+  "The request timed out"
+) {
+};
+var UnknownSdkError = class extends namedError(
+  "UnknownSdkError",
+  "UNKNOWN",
+  "An unknown livestream error occurred"
+) {
+};
+var known = {
+  PERMISSION_DENIED: PermissionDeniedError,
+  NETWORK_UNAVAILABLE: NetworkUnavailableError,
+  TOKEN_EXPIRED: TokenExpiredError,
+  SDK_UPGRADE_REQUIRED: UnsupportedSdkError,
+  SESSION_CONFLICT: SessionConflictError,
+  RECORDING_FAILED: RecordingFailureError,
+  CONSENT_REQUIRED: ConsentRequiredError,
+  SDK_DISABLED: SdkDisabledError,
+  UNKNOWN: UnknownSdkError
+};
+function errorFromCode(code, message) {
+  const Constructor = _nullishCoalesce(known[code], () => ( UnknownSdkError));
+  return new Constructor(message);
+}
+function normalizeError(error) {
+  if (error instanceof PickleballExpoError) return error;
+  if (error instanceof Error) {
+    const code = error.code;
+    if (code) return errorFromCode(code, error.message);
+    if (error instanceof TypeError) {
+      return new NetworkUnavailableError(void 0, { cause: error });
+    }
+    return new UnknownSdkError(error.message, { cause: error });
+  }
+  return new UnknownSdkError();
+}
+function isSessionGoneError(error) {
+  return typeof error === "object" && error !== null && error.httpStatus === 404;
+}
+
+// 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",
+  "reconnecting"
+]);
+var inMemorySessionStates = /* @__PURE__ */ new Set([
+  "connecting",
+  "standby",
+  "live",
+  "reconnecting",
+  "ending"
+]);
+var StaleOperationError = class extends Error {
+};
+var LEGAL_LIVESTREAM_TRANSITIONS = {
+  idle: ["preparing"],
+  preparing: ["preview", "ending", "error"],
+  preview: ["connecting", "preparing", "ending", "error"],
+  connecting: ["standby", "live", "ending", "error"],
+  standby: ["live", "reconnecting", "ending", "error"],
+  live: ["standby", "reconnecting", "ending", "error"],
+  reconnecting: ["standby", "live", "ending", "error"],
+  ending: ["ended", "error"],
+  ended: ["preparing"],
+  error: ["preparing", "reconnecting", "ending", "ended"]
+};
+var LivestreamEngine = (_class = class {
+  constructor(dependencies) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);_class.prototype.__init12.call(this);_class.prototype.__init13.call(this);_class.prototype.__init14.call(this);_class.prototype.__init15.call(this);_class.prototype.__init16.call(this);_class.prototype.__init17.call(this);_class.prototype.__init18.call(this);_class.prototype.__init19.call(this);_class.prototype.__init20.call(this);_class.prototype.__init21.call(this);_class.prototype.__init22.call(this);
+    this.dependencies = dependencies;
+    this.now = _nullishCoalesce(dependencies.now, () => ( Date.now));
+    this.snapshot = {
+      state: "idle",
+      error: null,
+      config: null,
+      sessionId: null,
+      previewTrack: null,
+      isMicrophoneEnabled: true,
+      // Camera SAU mặc định: thiết bị quay sân luôn dùng camera sau, bắt người
+      // dùng bấm đổi mỗi buổi là thừa. Phải khớp với mặc định của MỌI adapter
+      // (LiveKitRoomAdapter.isFront, module RTMP cameraPosition) — lệch một chỗ
+      // là nhãn UI và hình thực tế ngược nhau vĩnh viễn.
+      isCameraFront: false,
+      captureOrientation: null,
+      deviceMetrics: null,
+      cameras: [],
+      selectedCameraId: null,
+      elapsedMs: 0,
+      isOnline: dependencies.network.isOnline(),
+      adoptableSessionId: null
+    };
+  }
+  
+  
+  
+  __init() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  
+  
+  
+  
+  
+  
+  __init2() {this.startupRecovered = false}
+  
+  
+  __init3() {this.commandTail = Promise.resolve()}
+  __init4() {this.commandCount = 0}
+  __init5() {this.roomUnsubscribe = () => void 0}
+  __init6() {this.networkUnsubscribe = () => void 0}
+  __init7() {this.networkSubscribed = false}
+  __init8() {this.latestAppState = "active"}
+  
+  
+  
+  
+  /** Đang trong vòng quay số lại — xem doRetry() để biết vì sao cần cờ này. */
+  __init9() {this.redialing = false}
+  
+  
+  
+  
+  
+  /** Huỷ subscription websocket lệnh của phiên hiện tại (nếu đang mở). */
+  
+  /** Khoá phiên+token đang subscribe — đổi thì resubscribe (token refresh/đổi phiên). */
+  
+  /** Websocket đã đẩy được ít nhất một lần → coi là sống, cho phép hạ nhịp poll. */
+  __init10() {this.commandSubscriptionActive = false}
+  /** issuedAt của lệnh cuối đã xử lý — server chỉ trả lệnh mới hơn mốc này. */
+  __init11() {this.commandCursor = 0}
+  __init12() {this.commandPollBackoffMs = 0}
+  
+  
+  /** Đang publish track (live) hay chỉ ngồi trong phòng (standby). */
+  __init13() {this.publishing = false}
+  /** Tổng thời gian đã phát trước lần tạm dừng gần nhất. */
+  __init14() {this.pausedElapsedMs = 0}
+  
+  __init15() {this.refreshRetryAttempt = 0}
+  __init16() {this.operationGeneration = 0}
+  __init17() {this.liveTimersStarted = false}
+  __init18() {this.keepAwakeActive = false}
+  
+  
+  __init19() {this.sessionTerminations = /* @__PURE__ */ new Map()}
+  
+  __init20() {this.disposed = false}
+  __init21() {this.getSnapshot = () => this.snapshot}
+  __init22() {this.subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }}
+  async initialize() {
+    if (this.disposed) return;
+    this.ensureNetworkSubscription();
+    if (this.startupRecovered) {
+      try {
+        await this.replayPendingEnd();
+      } catch (error) {
+        this.pendingReplayError = error;
+      }
+      return;
+    }
+    if (!this.startupRecoveryPromise) {
+      this.startupRecoveryPromise = this.recoverStartupSession().catch((error) => {
+        this.pendingReplayError = error;
+      }).finally(() => {
+        this.startupRecovered = true;
+        this.startupRecoveryPromise = void 0;
+      });
+    }
+    await this.startupRecoveryPromise;
+  }
+  prepare() {
+    if (this.preparePromise) return this.preparePromise;
+    if (this.snapshot.state === "preview") return Promise.resolve();
+    if (["connecting", "live", "reconnecting", "ending"].includes(
+      this.snapshot.state
+    ) || this.snapshot.state === "error" && this.snapshot.sessionId) {
+      return Promise.reject(
+        new SessionConflictError("Cannot prepare while a session is active")
+      );
+    }
+    this.preparePromise = this.enqueueLifecycle(() => this.doPrepare()).finally(() => {
+      this.preparePromise = void 0;
+    });
+    return this.preparePromise;
+  }
+  async doPrepare() {
+    const generation = this.operationGeneration;
+    this.ensureNotDisposed();
+    this.transition("preparing");
+    try {
+      await this.ensurePendingEndResolved();
+      this.ensureOperation(generation);
+      this.dependencies.runtime.assertSupported();
+      const bootstrap = await this.dependencies.sessionProvider.bootstrap(
+        this.dependencies.bootstrapInput
+      );
+      this.ensureOperation(generation);
+      if (!isSdkRemoteConfig(bootstrap.config)) {
+        throw new InvalidResponseError(
+          "The session provider returned invalid SDK config"
+        );
+      }
+      if (!bootstrap.config.enabled || !bootstrap.rolloutEnabled) {
+        throw new SdkDisabledError(bootstrap.message);
+      }
+      if (!isSdkVersionSupported(
+        this.dependencies.bootstrapInput.sdkVersion,
+        bootstrap.config.minSdkVersion
+      )) {
+        throw new UnsupportedSdkError();
+      }
+      this.update({ config: bootstrap.config });
+      const room = this.ensureRoom();
+      const permitted = room.requestPermissions ? await room.requestPermissions() : await this.dependencies.runtime.requestPermissions();
+      this.ensureOperation(generation);
+      if (!permitted) {
+        throw new PermissionDeniedError();
+      }
+      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 _optionalChain([room, 'access', _ => _.setCaptureOrientation, 'optionalCall', _2 => _2(this.snapshot.captureOrientation)]);
+      }
+      const previewTrack = await room.preparePreview(
+        bootstrap.config.videoQuality
+      );
+      if (!this.isOperationCurrent(generation)) {
+        await this.releaseRoom();
+        throw new StaleOperationError();
+      }
+      let cameras = [];
+      try {
+        cameras = await _asyncNullishCoalesce(await _optionalChain([room, 'access', _3 => _3.listCameras, 'optionalCall', _4 => _4()]), async () => ( []));
+      } catch (e2) {
+      }
+      if (!this.isOperationCurrent(generation)) {
+        await this.releaseRoom();
+        throw new StaleOperationError();
+      }
+      this.update({ previewTrack, cameras });
+      this.transition("preview");
+    } catch (error) {
+      if (!this.isOperationCurrent(generation) || error instanceof StaleOperationError) {
+        return;
+      }
+      this.fail(error);
+    }
+  }
+  start(input, options) {
+    if (this.startPromise) return this.startPromise;
+    if (this.snapshot.state === "live" || this.snapshot.state === "standby") {
+      return Promise.resolve();
+    }
+    if (this.snapshot.state !== "preview" && !this.preparePromise) {
+      return Promise.reject(
+        new SessionConflictError("Livestream preview is not ready")
+      );
+    }
+    this.startPromise = this.enqueueLifecycle(
+      () => this.doStart(input, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _5 => _5.autoPublish]), () => ( true)))
+    ).finally(() => {
+      this.startPromise = void 0;
+    });
+    return this.startPromise;
+  }
+  async doStart(input, autoPublish) {
+    const generation = this.operationGeneration;
+    let activeGrant;
+    this.ensureNotDisposed();
+    this.ensureState("preview");
+    if (!input.consentVersion.trim()) throw new ConsentRequiredError();
+    if (!input.externalSessionId.trim() || !input.title.trim()) {
+      const error = new ConsentRequiredError("Session ID and title are required");
+      this.fail(error);
+    }
+    if (!this.dependencies.network.isOnline()) {
+      this.fail(new NetworkUnavailableError());
+    }
+    this.transition("connecting");
+    this.ensureBackgroundGraceTimer();
+    try {
+      await this.ensurePendingEndResolved(input.externalSessionId);
+      this.ensureOperation(generation);
+    } catch (error) {
+      if (!this.isOperationCurrent(generation) || error instanceof StaleOperationError) {
+        return;
+      }
+      this.fail(error);
+    }
+    try {
+      const grant = await this.dependencies.sessionProvider.start({
+        ...input,
+        standby: !autoPublish
+      });
+      activeGrant = grant;
+      if (!this.isOperationCurrent(generation)) {
+        await this.abandonGrant(grant);
+        return;
+      }
+      if (!isSdkRemoteConfig(grant.config)) {
+        await this.abandonGrant(grant);
+        throw new InvalidResponseError(
+          "The session provider returned invalid SDK config"
+        );
+      }
+      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;
+      this.pausedElapsedMs = 0;
+      this.update({
+        config: grant.config,
+        sessionId: grant.sessionId,
+        elapsedMs: 0
+      });
+      await this.dependencies.storage.setItem(
+        PENDING_END_KEY,
+        JSON.stringify({ sessionId: grant.sessionId, pendingEnd: null })
+      );
+      if (!this.isOperationCurrent(generation)) {
+        await this.abandonGrant(grant);
+        return;
+      }
+      await this.requireRoom().connect({
+        serverUrl: grant.serverUrl,
+        participantToken: grant.participantToken,
+        microphoneEnabled: this.snapshot.isMicrophoneEnabled,
+        publish: autoPublish
+      });
+      if (!this.isOperationCurrent(generation)) {
+        await this.abandonGrant(grant);
+        return;
+      }
+      await this.enterSession(generation, autoPublish);
+    } catch (error) {
+      if (!this.isOperationCurrent(generation) || error instanceof StaleOperationError) {
+        if (activeGrant) await this.abandonGrant(activeGrant);
+        return;
+      }
+      this.fail(error);
+    }
+  }
+  stop(reason = "user") {
+    if (this.stopPromise) return this.stopPromise;
+    if (this.snapshot.state === "ended" || this.snapshot.state === "idle") {
+      return Promise.resolve();
+    }
+    this.stopPromise = this.enqueueLifecycle(() => this.doStop(reason)).finally(() => {
+      this.stopPromise = void 0;
+    });
+    return this.stopPromise;
+  }
+  async doStop(reason) {
+    if (this.disposed) return;
+    const sessionId = this.ownedSessionId;
+    const termination = sessionId ? this.ensureSessionTermination(sessionId, reason) : void 0;
+    this.transition("ending");
+    this.clearTimers();
+    const roomCleanup = this.releaseRoom(_optionalChain([termination, 'optionalAccess', _6 => _6.markerReady]));
+    await Promise.allSettled([
+      roomCleanup,
+      this.dependencies.runtime.deactivateKeepAwake()
+    ]);
+    this.keepAwakeActive = false;
+    if (sessionId) {
+      await _optionalChain([termination, 'optionalAccess', _7 => _7.completion]);
+      void this.sendTelemetry("session_ended", { reason });
+    }
+    this.grant = void 0;
+    this.ownedSessionId = void 0;
+    this.startedAt = void 0;
+    this.publishing = false;
+    this.pausedElapsedMs = 0;
+    this.update({ previewTrack: null, sessionId: null });
+    this.transition("ended");
+  }
+  retry() {
+    if (this.retryPromise) return this.retryPromise;
+    this.retryPromise = this.enqueueLifecycle(() => this.doRetry()).finally(() => {
+      this.retryPromise = void 0;
+    });
+    return this.retryPromise;
+  }
+  async doRetry() {
+    const generation = this.operationGeneration;
+    this.ensureNotDisposed();
+    if (this.snapshot.state === "error" && !this.snapshot.sessionId) {
+      this.update({ error: null });
+      return this.prepare();
+    }
+    if (this.snapshot.state === "error" && this.snapshot.sessionId) {
+      this.transition("reconnecting");
+    }
+    this.ensureState("reconnecting");
+    const sessionId = this.snapshot.sessionId;
+    if (!sessionId || !this.grant) throw new Error("Missing session grant");
+    const activeGrant = this.grant;
+    try {
+      const expiresAt = _nullishCoalesce(_optionalChain([this, 'access', _8 => _8.grant, 'optionalAccess', _9 => _9.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,
+        participantToken: this.grant.participantToken,
+        microphoneEnabled: this.snapshot.isMicrophoneEnabled,
+        publish: this.publishing
+      });
+      this.ensureOperation(generation);
+      this.clearReconnectTimer();
+      await this.enterSession(generation, this.publishing);
+    } catch (error) {
+      if (!this.isOperationCurrent(generation) || error instanceof StaleOperationError) {
+        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);
+    }
+  }
+  async switchCamera() {
+    if (!this.snapshot.previewTrack) return;
+    const generation = this.operationGeneration;
+    await this.requireRoom().switchCamera();
+    if (!this.isOperationCurrent(generation)) return;
+    this.update({
+      isCameraFront: !this.snapshot.isCameraFront,
+      selectedCameraId: null
+    });
+  }
+  /** Chọn một ống kính cụ thể từ snapshot.cameras. */
+  async selectCamera(deviceId) {
+    if (!this.snapshot.previewTrack) return;
+    if (deviceId === this.snapshot.selectedCameraId) return;
+    const camera = this.snapshot.cameras.find(
+      (item) => item.deviceId === deviceId
+    );
+    if (!camera) return;
+    const room = this.requireRoom();
+    if (!room.selectCamera) return;
+    const generation = this.operationGeneration;
+    await room.selectCamera(camera.deviceId, camera.facing);
+    if (!this.isOperationCurrent(generation)) return;
+    this.update({
+      selectedCameraId: camera.deviceId,
+      ...camera.facing === "unknown" ? {} : { isCameraFront: camera.facing === "front" }
+    });
+  }
+  /** Chọn kiểu quay trước khi live; không đổi khi phiên đang hoạt động. */
+  async setCaptureOrientation(orientation) {
+    if (orientation === this.snapshot.captureOrientation) return;
+    if (this.snapshot.sessionId || activeStates.has(this.snapshot.state)) {
+      return;
+    }
+    const generation = this.operationGeneration;
+    if (this.snapshot.previewTrack) {
+      await _optionalChain([this, 'access', _10 => _10.requireRoom, 'call', _11 => _11(), 'access', _12 => _12.setCaptureOrientation, 'optionalCall', _13 => _13(orientation)]);
+      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;
+    await this.requireRoom().setMicrophoneEnabled(enabled);
+    if (!this.isOperationCurrent(generation)) return;
+    this.update({ isMicrophoneEnabled: enabled });
+  }
+  handleRoomEvent(event) {
+    if (this.disposed) return;
+    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" });
+      if (_optionalChain([this, 'access', _14 => _14.room, 'optionalAccess', _15 => _15.needsManualReconnect])) {
+        this.clearReconnectTimer();
+        this.scheduleRedial(0);
+        return;
+      }
+      const configured = _nullishCoalesce(_optionalChain([this, 'access', _16 => _16.snapshot, 'access', _17 => _17.config, 'optionalAccess', _18 => _18.reconnectTimeoutMs]), () => ( 3e4));
+      this.clearReconnectTimer();
+      this.reconnectTimer = setTimeout(() => {
+        void this.stop("network_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") {
+      if (_optionalChain([this, 'access', _19 => _19.room, 'optionalAccess', _20 => _20.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" });
+    }
+  }
+  handleAppState(state) {
+    if (this.disposed) return;
+    this.latestAppState = state;
+    if (state === "active") {
+      if (this.backgroundTimer) clearTimeout(this.backgroundTimer);
+      this.backgroundTimer = void 0;
+      return;
+    }
+    this.ensureBackgroundGraceTimer();
+  }
+  ensureBackgroundGraceTimer() {
+    if (this.latestAppState === "active" || !["connecting", "standby", "live", "reconnecting"].includes(
+      this.snapshot.state
+    ) || this.backgroundTimer) {
+      return;
+    }
+    const grace = _nullishCoalesce(_optionalChain([this, 'access', _21 => _21.snapshot, 'access', _22 => _22.config, 'optionalAccess', _23 => _23.backgroundGraceMs]), () => ( 15e3));
+    this.backgroundTimer = setTimeout(() => {
+      this.backgroundTimer = void 0;
+      if (this.latestAppState !== "active") {
+        void this.stop("background_timeout");
+      }
+    }, grace);
+  }
+  /**
+   * `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 = _optionalChain([options, 'optionalAccess', _24 => _24.keepSession]) === true ? void 0 : this.ownedSessionId;
+    let releaseEnd = () => void 0;
+    const endBarrier = new Promise((resolve) => {
+      releaseEnd = resolve;
+    });
+    const termination = sessionId ? this.ensureSessionTermination(sessionId, "error", endBarrier) : void 0;
+    const roomCleanup = this.releaseRoom(_optionalChain([termination, 'optionalAccess', _25 => _25.markerReady]));
+    this.clearTimers();
+    _optionalChain([this, 'access', _26 => _26.dependencies, 'access', _27 => _27.telemetry, 'optionalAccess', _28 => _28.dispose, 'optionalCall', _29 => _29()]);
+    _optionalChain([this, 'access', _30 => _30.dependencies, 'access', _31 => _31.commandChannel, 'optionalAccess', _32 => _32.dispose, 'optionalCall', _33 => _33()]);
+    this.pendingCriticalTelemetry = void 0;
+    this.networkUnsubscribe();
+    this.listeners.clear();
+    this.keepAwakeActive = false;
+    this.grant = void 0;
+    this.ownedSessionId = void 0;
+    this.disposePromise = (async () => {
+      await _optionalChain([termination, 'optionalAccess', _34 => _34.markerReady]);
+      await Promise.allSettled([
+        roomCleanup,
+        this.dependencies.runtime.deactivateKeepAwake()
+      ]);
+      releaseEnd();
+      await _optionalChain([termination, 'optionalAccess', _35 => _35.completion]);
+    })();
+    return this.disposePromise;
+  }
+  async replayPendingEnd() {
+    if (this.ownsInMemorySession()) return;
+    if (this.pendingReplayPromise) return this.pendingReplayPromise;
+    this.pendingReplayPromise = this.doReplayPendingEnd().finally(() => {
+      this.pendingReplayPromise = void 0;
+    });
+    return this.pendingReplayPromise;
+  }
+  async doReplayPendingEnd() {
+    const pending = await this.readPendingEnd();
+    if (!pending || pending.pendingEnd === null) return;
+    if (!this.dependencies.network.isOnline()) return;
+    await this.dependencies.sessionProvider.end({
+      sessionId: pending.sessionId,
+      reason: _nullishCoalesce(pending.pendingEnd, () => ( "error"))
+    });
+    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 (e3) {
+    }
+    this.update({ adoptableSessionId: null });
+  }
+  async recoverStartupSession() {
+    let pending = await this.readPendingEnd();
+    if (!pending || this.ownsInMemorySession()) return;
+    if (pending.pendingEnd === null) {
+      const keep = await _optionalChain([this, 'access', _36 => _36.dependencies, 'access', _37 => _37.keepSessionOnRestart, 'optionalCall', _38 => _38()]) === 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,
+        JSON.stringify(pending)
+      );
+    }
+    if (!this.dependencies.network.isOnline()) return;
+    try {
+      await this.dependencies.sessionProvider.end({
+        sessionId: pending.sessionId,
+        reason: _nullishCoalesce(pending.pendingEnd, () => ( "error"))
+      });
+    } catch (error) {
+      if (!isSessionGoneError(error)) throw error;
+    }
+    await this.dependencies.storage.removeItem(PENDING_END_KEY);
+    this.pendingReplayError = void 0;
+  }
+  /**
+   * 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"
+      );
+    }
+    if (this.pendingReplayError instanceof TypeError) {
+      throw new NetworkUnavailableError(void 0, {
+        cause: this.pendingReplayError
+      });
+    }
+    if (this.snapshot.state === "connecting" && !this.ownedSessionId && pending.pendingEnd !== null) {
+      try {
+        await this.dependencies.sessionProvider.end({
+          sessionId: pending.sessionId,
+          reason: pending.pendingEnd
+        });
+        await this.dependencies.storage.removeItem(PENDING_END_KEY);
+        this.pendingReplayError = void 0;
+        return;
+      } catch (error) {
+        this.pendingReplayError = error;
+        if (error instanceof TypeError) {
+          throw new NetworkUnavailableError(void 0, { cause: error });
+        }
+      }
+    }
+    throw new SessionConflictError(
+      pending.pendingEnd === null ? "Another livestream session is still active" : "The previous livestream is still pending end"
+    );
+  }
+  async readPendingEnd() {
+    const raw = await this.dependencies.storage.getItem(PENDING_END_KEY);
+    if (!raw) return null;
+    try {
+      const value = JSON.parse(raw);
+      if (typeof value.sessionId !== "string") throw new TypeError();
+      if (value.pendingEnd === null) {
+        return { sessionId: value.sessionId, pendingEnd: null };
+      }
+      if ([
+        "user",
+        "background_timeout",
+        "network_timeout",
+        "standby_timeout",
+        "error"
+      ].includes(String(value.pendingEnd))) {
+        return {
+          sessionId: value.sessionId,
+          pendingEnd: value.pendingEnd
+        };
+      }
+    } catch (e4) {
+    }
+    await this.dependencies.storage.removeItem(PENDING_END_KEY);
+    return null;
+  }
+  ownsInMemorySession() {
+    return Boolean(this.ownedSessionId) || inMemorySessionStates.has(this.snapshot.state);
+  }
+  startTimers() {
+    if (this.liveTimersStarted) return;
+    this.liveTimersStarted = true;
+    const interval = Math.max(
+      1e4,
+      _nullishCoalesce(_optionalChain([this, 'access', _39 => _39.snapshot, 'access', _40 => _40.config, 'optionalAccess', _41 => _41.telemetryIntervalMs]), () => ( 6e4))
+    );
+    this.heartbeatTimer = setInterval(() => {
+      void this.sendHeartbeat();
+    }, interval);
+    _optionalChain([this, 'access', _42 => _42.heartbeatTimer, 'access', _43 => _43.unref, 'optionalCall', _44 => _44()]);
+    this.elapsedTimer = setInterval(() => {
+      if (this.startedAt !== void 0) {
+        this.update({ elapsedMs: this.now() - this.startedAt });
+      }
+    }, 1e3);
+    _optionalChain([this, 'access', _45 => _45.elapsedTimer, 'access', _46 => _46.unref, 'optionalCall', _47 => _47()]);
+    this.scheduleTokenRefresh();
+    this.scheduleMaxSessionDuration();
+  }
+  clearTimers() {
+    if (this.backgroundTimer) clearTimeout(this.backgroundTimer);
+    this.clearStandbyTimer();
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.elapsedTimer) clearInterval(this.elapsedTimer);
+    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;
+    this.tokenRefreshTimer = void 0;
+    this.maxSessionTimer = void 0;
+    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 || _optionalChain([this, 'access', _48 => _48.grant, 'optionalAccess', _49 => _49.sessionId]) !== sessionId) return;
+        this.commandSubscriptionActive = true;
+        this.applyCommands(commands);
+      },
+      () => {
+        this.commandSubscriptionActive = false;
+      }
+    );
+  }
+  stopCommandSubscription() {
+    if (this.commandUnsubscribe) {
+      try {
+        this.commandUnsubscribe();
+      } catch (e5) {
+      }
+    }
+    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);
+    _optionalChain([this, 'access', _50 => _50.commandPollTimer, 'access', _51 => _51.unref, 'optionalCall', _52 => _52()]);
+  }
+  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 = _optionalChain([error, 'optionalAccess', _53 => _53.status]);
+      if (status === 401) {
+        void this.refreshCredentials().catch(() => void 0);
+      }
+      if (status === 409 && _optionalChain([this, 'access', _54 => _54.grant, 'optionalAccess', _55 => _55.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 || _optionalChain([this, 'access', _56 => _56.grant, 'optionalAccess', _57 => _57.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;
+    try {
+      metrics = await _asyncNullishCoalesce(await _optionalChain([this, 'access', _58 => _58.dependencies, 'access', _59 => _59.deviceMetrics, 'optionalCall', _60 => _60()]), async () => ( null));
+    } catch (e6) {
+      metrics = null;
+    }
+    if (this.disposed) return;
+    if (metrics) this.update({ deviceMetrics: metrics });
+    return this.sendTelemetry(
+      "heartbeat",
+      metrics ? { ...metrics } : void 0
+    );
+  }
+  async sendTelemetry(name, data) {
+    if (this.disposed || !this.dependencies.telemetry || !this.grant) return;
+    const grant = this.grant;
+    const pending = {
+      credentials: grant.telemetry,
+      event: {
+        sessionId: grant.sessionId,
+        at: this.now(),
+        name,
+        ...data ? { data } : {}
+      }
+    };
+    if (this.telemetryInFlight) {
+      if (name === "session_ended" && !this.pendingCriticalTelemetry) {
+        this.pendingCriticalTelemetry = pending;
+      }
+      return this.telemetryInFlight;
+    }
+    return this.startTelemetrySend(pending);
+  }
+  startTelemetrySend(pending) {
+    const operation = (async () => {
+      try {
+        await _optionalChain([this, 'access', _61 => _61.dependencies, 'access', _62 => _62.telemetry, 'optionalAccess', _63 => _63.send, 'call', _64 => _64(pending.credentials, [
+          pending.event
+        ])]);
+      } catch (error) {
+        if (_optionalChain([error, 'optionalAccess', _65 => _65.status]) === 401) {
+          try {
+            await this.refreshCredentials();
+            if (this.grant) {
+              await _optionalChain([this, 'access', _66 => _66.dependencies, 'access', _67 => _67.telemetry, 'optionalAccess', _68 => _68.send, 'call', _69 => _69(this.grant.telemetry, [
+                pending.event
+              ])]);
+            }
+          } catch (e7) {
+          }
+        }
+      }
+    })();
+    const tracked = operation.finally(() => {
+      if (this.telemetryInFlight !== tracked) return;
+      this.telemetryInFlight = void 0;
+      const critical = this.pendingCriticalTelemetry;
+      this.pendingCriticalTelemetry = void 0;
+      if (critical && !this.disposed) this.startTelemetrySend(critical);
+    });
+    this.telemetryInFlight = tracked;
+    return this.telemetryInFlight;
+  }
+  refreshCredentials(generation = this.operationGeneration) {
+    if (this.credentialRefreshPromise) return this.credentialRefreshPromise;
+    const sessionId = this.snapshot.sessionId;
+    if (!sessionId || !this.grant) return Promise.resolve();
+    this.credentialRefreshPromise = this.dependencies.sessionProvider.refresh(sessionId).then((refreshed) => {
+      this.ensureOperation(generation);
+      if (!isSdkRemoteConfig(refreshed.config)) {
+        throw new InvalidResponseError(
+          "The session provider returned invalid SDK config"
+        );
+      }
+      if (!this.grant || this.snapshot.sessionId !== sessionId || !activeStates.has(this.snapshot.state)) {
+        return;
+      }
+      this.grant = {
+        ...this.grant,
+        participantToken: _nullishCoalesce(refreshed.participantToken, () => ( this.grant.participantToken)),
+        tokenExpiresAt: _nullishCoalesce(refreshed.tokenExpiresAt, () => ( this.grant.tokenExpiresAt)),
+        telemetry: _nullishCoalesce(refreshed.telemetry, () => ( this.grant.telemetry)),
+        config: refreshed.config
+      };
+      this.syncCommandSubscription();
+      this.update({ config: refreshed.config });
+      this.refreshRetryAttempt = 0;
+      if (this.liveTimersStarted) {
+        this.restartHeartbeat();
+        this.scheduleTokenRefresh();
+        this.scheduleMaxSessionDuration();
+      }
+    }).finally(() => {
+      this.credentialRefreshPromise = void 0;
+    });
+    return this.credentialRefreshPromise;
+  }
+  transition(state) {
+    const previous = this.snapshot.state;
+    if (previous === state) return;
+    if (!LEGAL_LIVESTREAM_TRANSITIONS[previous].includes(state)) {
+      throw new SessionConflictError(
+        `Illegal livestream transition: ${previous} -> ${state}`
+      );
+    }
+    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 });
+    }
+  }
+  startStandbyTimer() {
+    this.clearStandbyTimer();
+    const timeout = _nullishCoalesce(_optionalChain([this, 'access', _70 => _70.snapshot, 'access', _71 => _71.config, 'optionalAccess', _72 => _72.standbyTimeoutMs]), () => ( DEFAULT_STANDBY_TIMEOUT_MS));
+    this.standbyTimer = setTimeout(() => {
+      this.standbyTimer = void 0;
+      if (this.snapshot.state === "standby") {
+        void this.stop("standby_timeout");
+      }
+    }, timeout);
+    _optionalChain([this, 'access', _73 => _73.standbyTimer, 'access', _74 => _74.unref, 'optionalCall', _75 => _75()]);
+  }
+  clearStandbyTimer() {
+    if (this.standbyTimer) clearTimeout(this.standbyTimer);
+    this.standbyTimer = void 0;
+  }
+  fail(error) {
+    const normalized = this.recordError(error);
+    throw normalized;
+  }
+  recordError(error) {
+    const normalized = normalizeError(error);
+    const state = this.snapshot.state;
+    if (state !== "error" && !LEGAL_LIVESTREAM_TRANSITIONS[state].includes("error")) {
+      return normalized;
+    }
+    this.update({ error: normalized });
+    this.transition("error");
+    void this.sendTelemetry("error", { code: normalized.code });
+    return normalized;
+  }
+  update(patch) {
+    if (this.disposed) return;
+    this.snapshot = { ...this.snapshot, ...patch };
+    for (const listener of this.listeners) listener();
+  }
+  ensureState(expected) {
+    if (this.snapshot.state !== expected) {
+      throw new Error(`Expected livestream state ${expected}`);
+    }
+  }
+  ensureNotDisposed() {
+    if (this.disposed) throw new Error("Livestream engine has been disposed");
+  }
+  ensureRoom() {
+    if (!this.room) {
+      this.room = this.dependencies.roomFactory();
+      this.roomUnsubscribe = this.room.subscribe(
+        (event) => this.handleRoomEvent(event)
+      );
+    }
+    return this.room;
+  }
+  ensureNetworkSubscription() {
+    if (this.networkSubscribed || this.disposed) return;
+    this.networkSubscribed = true;
+    this.networkUnsubscribe = this.dependencies.network.subscribe((online) => {
+      if (this.disposed) return;
+      this.update({ isOnline: online });
+      if (online && this.startupRecovered) {
+        void this.replayPendingEnd().catch((error) => {
+          this.pendingReplayError = error;
+        });
+      }
+      if (online && _optionalChain([this, 'access', _76 => _76.room, 'optionalAccess', _77 => _77.needsManualReconnect])) {
+        const s = this.snapshot.state;
+        if (s === "reconnecting" || s === "error" && this.snapshot.sessionId) {
+          this.scheduleRedial(0);
+        }
+      }
+    });
+  }
+  requireRoom() {
+    if (!this.room) throw new Error("Livestream Room has not been prepared");
+    return this.room;
+  }
+  releaseRoom(beforeDispose = Promise.resolve()) {
+    const unsubscribe = this.roomUnsubscribe;
+    this.roomUnsubscribe = () => void 0;
+    const room = this.room;
+    this.room = void 0;
+    try {
+      unsubscribe();
+    } catch (e8) {
+    }
+    if (!room) return Promise.resolve();
+    return beforeDispose.then(() => room.dispose());
+  }
+  enqueueLifecycle(command) {
+    this.commandCount += 1;
+    let result;
+    if (this.commandCount === 1) {
+      try {
+        result = Promise.resolve(command());
+      } catch (error) {
+        result = Promise.reject(error);
+      }
+    } else {
+      result = this.commandTail.then(command, command);
+    }
+    this.commandTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result.finally(() => {
+      this.commandCount -= 1;
+    });
+  }
+  scheduleTokenRefresh(delayOverride) {
+    if (this.tokenRefreshTimer) clearTimeout(this.tokenRefreshTimer);
+    this.tokenRefreshTimer = void 0;
+    if (!this.grant || !this.snapshot.sessionId) return;
+    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 = _nullishCoalesce(delayOverride, () => ( Math.max(1e3, remaining - 6e4)));
+    this.tokenRefreshTimer = setTimeout(() => {
+      void this.refreshCredentials().catch(() => {
+        if (this.disposed) return;
+        const retryDelay = Math.min(
+          3e4,
+          1e3 * 2 ** Math.min(this.refreshRetryAttempt, 5)
+        );
+        this.refreshRetryAttempt += 1;
+        this.scheduleTokenRefresh(retryDelay);
+      });
+    }, delay);
+    _optionalChain([this, 'access', _78 => _78.tokenRefreshTimer, 'access', _79 => _79.unref, 'optionalCall', _80 => _80()]);
+  }
+  scheduleMaxSessionDuration() {
+    if (this.startedAt === void 0 || !this.snapshot.config) return;
+    const proposed = this.startedAt + this.snapshot.config.maxSessionDurationMs;
+    this.sessionDeadline = Math.min(_nullishCoalesce(this.sessionDeadline, () => ( proposed)), proposed);
+    if (this.maxSessionTimer) clearTimeout(this.maxSessionTimer);
+    const delay = Math.max(0, this.sessionDeadline - this.now());
+    this.maxSessionTimer = setTimeout(() => {
+      void this.stop("error");
+    }, delay);
+    _optionalChain([this, 'access', _81 => _81.maxSessionTimer, 'access', _82 => _82.unref, 'optionalCall', _83 => _83()]);
+  }
+  restartHeartbeat() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    const interval = Math.max(
+      1e4,
+      _nullishCoalesce(_optionalChain([this, 'access', _84 => _84.snapshot, 'access', _85 => _85.config, 'optionalAccess', _86 => _86.telemetryIntervalMs]), () => ( 6e4))
+    );
+    this.heartbeatTimer = setInterval(() => {
+      void this.sendHeartbeat();
+    }, interval);
+    _optionalChain([this, 'access', _87 => _87.heartbeatTimer, 'access', _88 => _88.unref, 'optionalCall', _89 => _89()]);
+  }
+  async enterSession(generation, publish) {
+    this.ensureOperation(generation);
+    if (!this.keepAwakeActive) {
+      await this.dependencies.runtime.activateKeepAwake();
+      if (!this.isOperationCurrent(generation)) {
+        await this.dependencies.runtime.deactivateKeepAwake();
+        throw new StaleOperationError();
+      }
+      this.keepAwakeActive = true;
+    }
+    this.publishing = publish;
+    if (publish && this.startedAt === void 0) {
+      this.startedAt = this.now() - this.pausedElapsedMs;
+      this.sessionDeadline = void 0;
+      this.update({ elapsedMs: this.pausedElapsedMs });
+    }
+    this.startTimers();
+    this.transition(publish ? "live" : "standby");
+    this.ensureBackgroundGraceTimer();
+  }
+  /** Bắt đầu phát khi đang standby (từ nút trên app hoặc lệnh dashboard). */
+  async startPublishing() {
+    if (this.disposed || this.snapshot.state !== "standby") return;
+    const generation = this.operationGeneration;
+    try {
+      const grant = this.grant;
+      if (grant && this.dependencies.sessionProvider.publish) {
+        await this.dependencies.sessionProvider.publish(grant.sessionId);
+        if (!this.isOperationCurrent(generation) || this.snapshot.state !== "standby") {
+          return;
+        }
+      }
+      const room = this.requireRoom();
+      if (room.setPublishing) {
+        await room.setPublishing(true);
+      } else if (this.grant) {
+        await room.connect({
+          serverUrl: this.grant.serverUrl,
+          participantToken: this.grant.participantToken,
+          microphoneEnabled: this.snapshot.isMicrophoneEnabled,
+          publish: true
+        });
+      }
+      if (!this.isOperationCurrent(generation)) return;
+      this.publishing = true;
+      this.startedAt = this.now() - this.pausedElapsedMs;
+      this.update({ elapsedMs: this.pausedElapsedMs });
+      this.transition("live");
+      void this.sendTelemetry("state_changed", { state: "live" });
+    } catch (error) {
+      if (!this.isOperationCurrent(generation) || error instanceof StaleOperationError) {
+        return;
+      }
+      this.recordError(error);
+    }
+  }
+  /** Tạm dừng phát: ngắt kết nối LiveKit hoàn toàn về standby, KHÔNG kết thúc phiên. */
+  async stopPublishing() {
+    if (this.disposed || this.snapshot.state !== "live") return;
+    const generation = this.operationGeneration;
+    const room = this.requireRoom();
+    if (room.setPublishing) {
+      await room.setPublishing(false);
+    } else {
+      await room.disconnect(false);
+    }
+    if (!this.isOperationCurrent(generation)) return;
+    this.publishing = false;
+    this.pausedElapsedMs = this.startedAt !== void 0 ? this.now() - this.startedAt : 0;
+    this.startedAt = void 0;
+    this.update({ elapsedMs: this.pausedElapsedMs });
+    this.transition("standby");
+    void this.sendTelemetry("state_changed", { state: "standby" });
+    const grant = this.grant;
+    if (grant && this.dependencies.sessionProvider.unpublish) {
+      await this.dependencies.sessionProvider.unpublish(grant.sessionId).catch(() => void 0);
+    }
+  }
+  ensureSessionTermination(sessionId, reason, beforeEnd = Promise.resolve()) {
+    const existing = this.sessionTerminations.get(sessionId);
+    if (existing) return existing;
+    let markerReady;
+    try {
+      markerReady = Promise.resolve(
+        this.dependencies.storage.setItem(
+          PENDING_END_KEY,
+          JSON.stringify({ sessionId, pendingEnd: reason })
+        )
+      ).catch(() => {
+      });
+    } catch (e9) {
+      markerReady = Promise.resolve();
+    }
+    const completion = Promise.all([markerReady, beforeEnd]).then(async () => {
+      try {
+        await this.dependencies.sessionProvider.end({ sessionId, reason });
+        await this.dependencies.storage.removeItem(PENDING_END_KEY);
+      } catch (e10) {
+      }
+    });
+    const termination = { markerReady, completion };
+    this.sessionTerminations.set(sessionId, termination);
+    return termination;
+  }
+  async abandonGrant(grant) {
+    if (this.ownedSessionId === grant.sessionId) {
+      this.ownedSessionId = void 0;
+      this.grant = void 0;
+    }
+    const termination = this.ensureSessionTermination(grant.sessionId, "error");
+    const roomCleanup = this.releaseRoom(termination.markerReady);
+    await termination.markerReady;
+    if (this.disposed) {
+      await Promise.allSettled([roomCleanup, termination.completion]);
+      return;
+    }
+    await Promise.allSettled([
+      roomCleanup,
+      this.dependencies.runtime.deactivateKeepAwake(),
+      termination.completion
+    ]);
+  }
+  isOperationCurrent(generation) {
+    return !this.disposed && generation === this.operationGeneration;
+  }
+  ensureOperation(generation) {
+    if (!this.isOperationCurrent(generation)) throw new StaleOperationError();
+  }
+}, _class);
+
+// 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 = _optionalChain([_chunk7OX2DSKIcjs.__require.call(void 0, "expo/fetch"), 'optionalAccess', _90 => _90.fetch]);
+    if (typeof expoFetch === "function") return expoFetch;
+  } catch (e11) {
+  }
+  return globalThis.fetch;
+}
+async function runUplinkCheck(options) {
+  const fetchImplementation = resolveFetch(options.fetch);
+  const uploadUrl = _nullishCoalesce(options.uploadUrl, () => ( DEFAULT_UPLOAD_URL));
+  const measureMs = _nullishCoalesce(options.measureMs, () => ( 6e3));
+  const totalTimeoutMs = _nullishCoalesce(options.totalTimeoutMs, () => ( 25e3));
+  const chunkBytes = _nullishCoalesce(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);
+    }
+  }
+  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 (e12) {
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    return best;
+  }
+  const deadline = Date.now() + totalTimeoutMs;
+  const requiredMbps = requiredMbpsFor(options);
+  const isAbort = (error) => _optionalChain([error, 'optionalAccess', _91 => _91.name]) === "AbortError";
+  const warmupBytes = Math.min(WARMUP_BYTES, chunkBytes);
+  const warmupStarted = Date.now();
+  try {
+    await post(chunk(warmupBytes), _nullishCoalesce(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 = 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 = (_class2 = class {
+  constructor(bindings, options = {}) {;_class2.prototype.__init23.call(this);_class2.prototype.__init24.call(this);_class2.prototype.__init25.call(this);_class2.prototype.__init26.call(this);_class2.prototype.__init27.call(this);
+    this.bindings = bindings;
+    this.options = options;
+    const request = _optionalChain([bindings, 'access', _92 => _92.requestPermissions, 'optionalAccess', _93 => _93.bind, 'call', _94 => _94(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).
+   */
+  __init23() {this.needsManualReconnect = true}
+  __init24() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  
+  __init25() {this.quality = 1080}
+  __init26() {this.connected = false}
+  __init27() {this.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. */
+  
+  
+  /**
+   * 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.
+   */
+  
+  /**
+   * 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.captureOrientation ? this.captureOrientation === "landscape" : _nullishCoalesce(_optionalChain([this, 'access', _95 => _95.bindings, 'access', _96 => _96.isLandscape, 'optionalCall', _97 => _97()]), () => ( true)),
+      ...this.prepareOverrides()
+    });
+    this.prepared = true;
+    return { kind: "rtmp" };
+  }
+  async connect(input) {
+    if (!/^rtmps?:\/\//i.test(input.serverUrl)) {
+      throw new Error(
+        `Mode device-rtmp c\u1EA7n endpoint rtmp:// nh\u01B0ng phi\xEAn tr\u1EA3 v\u1EC1 "${input.serverUrl}". Ki\u1EC3m tra deliveryMode c\u1EE7a app tr\xEAn server (partnerApps.deliveryMode).`
+      );
+    }
+    const url = `${input.serverUrl}${input.participantToken}`;
+    await this.bindings.setMicrophoneEnabled(input.microphoneEnabled);
+    await this.bindings.connect({
+      url,
+      videoBitrate: VIDEO_BITRATE[this.quality],
+      // publish !== false → mặc định phát ngay; false = vào standby.
+      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);
+  }
+  async disconnect(_stopTracks) {
+    if (!this.connected) return;
+    this.connected = false;
+    this.bitrateState = void 0;
+    await this.bindings.disconnect();
+  }
+  async switchCamera() {
+    await this.bindings.switchCamera();
+  }
+  /** Ống kính vật lý (0.5x siêu rộng · 1x · tele) — không có thì UI kẹt ở mặc định. */
+  async listCameras() {
+    return this.bindings.listCameras().map((camera) => ({
+      deviceId: camera.deviceId,
+      label: camera.label,
+      facing: camera.facing === "front" || camera.facing === "environment" ? camera.facing : "unknown"
+    }));
+  }
+  async selectCamera(deviceId, facing) {
+    await this.bindings.selectCamera(deviceId, facing);
+  }
+  async setMicrophoneEnabled(enabled) {
+    await this.bindings.setMicrophoneEnabled(enabled);
+  }
+  /** Hạ chất lượng khi mạng yếu — thay cho BWE mà WebRTC cho sẵn. */
+  async setVideoBitrate(bitsPerSecond) {
+    await this.bindings.setVideoBitrate(bitsPerSecond);
+  }
+  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);
+    if (!this.nativeSubscription) {
+      this.nativeSubscription = this.bindings.addStatusListener((event) => {
+        const mapped = mapStatus(event);
+        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);
+    };
+  }
+  async dispose() {
+    _optionalChain([this, 'access', _98 => _98.nativeSubscription, 'optionalAccess', _99 => _99.remove, 'call', _100 => _100()]);
+    this.nativeSubscription = void 0;
+    _optionalChain([this, 'access', _101 => _101.bandwidthSubscription, 'optionalAccess', _102 => _102.remove, 'call', _103 => _103()]);
+    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);
+  }
+}, _class2);
+function mapStatus(event) {
+  switch (event.status) {
+    case "error":
+      return { type: "media-error", error: new Error(event.message) };
+    case "disconnected":
+      return { type: "disconnected", reason: event.reason };
+    case "connecting":
+      return { type: "reconnecting" };
+    case "publishing":
+      return { type: "reconnected" };
+    // "idle"/"connected" là bước trung gian, engine không cần biết.
+    default:
+      return null;
+  }
+}
+
+// src/native-runtime.ts
+function createRtmpRuntime() {
+  const { Platform, PermissionsAndroid } = _chunk7OX2DSKIcjs.__require.call(void 0, "react-native");
+  return {
+    assertSupported() {
+      if (Platform.OS !== "ios" && Platform.OS !== "android") {
+        throw new UnsupportedRuntimeError();
+      }
+      try {
+        _chunk7OX2DSKIcjs.__require.call(void 0, "@pickleball/rtmp-native");
+      } catch (e13) {
+        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 (e14) {
+          return false;
+        }
+      }
+      try {
+        const native = _chunk7OX2DSKIcjs.__require.call(void 0, "@pickleball/rtmp-native").default;
+        if (typeof _optionalChain([native, 'optionalAccess', _104 => _104.requestPermissions]) === "function") {
+          return await native.requestPermissions() !== false;
+        }
+      } catch (e15) {
+      }
+      return true;
+    },
+    activateKeepAwake: () => Promise.resolve(
+      _chunk7OX2DSKIcjs.__require.call(void 0, "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(
+        _chunk7OX2DSKIcjs.__require.call(void 0, "expo-keep-awake").deactivateKeepAwake("@pickleball/expo-sdk")
+      ).catch(() => void 0);
+    }
+  };
+}
+var createDefaultRuntime = createRtmpRuntime;
+function createDefaultStorage() {
+  let installed = false;
+  const install = () => {
+    if (installed) return;
+    _chunk7OX2DSKIcjs.__require.call(void 0, "expo-sqlite/localStorage/install");
+    installed = true;
+  };
+  return {
+    getItem: async (key) => {
+      install();
+      return globalThis.localStorage.getItem(key);
+    },
+    setItem: async (key, value) => {
+      install();
+      globalThis.localStorage.setItem(key, value);
+    },
+    removeItem: async (key) => {
+      install();
+      globalThis.localStorage.removeItem(key);
+    }
+  };
+}
+function createDefaultNetwork() {
+  const NetInfo = _chunk7OX2DSKIcjs.__require.call(void 0, "@react-native-community/netinfo").default;
+  let online = true;
+  void NetInfo.fetch().then((state) => {
+    online = state.isConnected !== false;
+  });
+  return {
+    isOnline: () => online,
+    subscribe(listener) {
+      return NetInfo.addEventListener((state) => {
+        online = state.isConnected !== false;
+        listener(online);
+      });
+    }
+  };
+}
+function createDefaultTelemetry(fetchImplementation = globalThis.fetch, timeoutMs = 1e4) {
+  const controllers = /* @__PURE__ */ new Set();
+  return {
+    async send(credentials, events) {
+      const body = JSON.stringify(events.slice(0, 20));
+      if (body.length > 24 * 1024) return;
+      const controller = new AbortController();
+      controllers.add(controller);
+      const timeout = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const response = await fetchImplementation(credentials.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${credentials.token}`
+          },
+          body,
+          signal: controller.signal,
+          redirect: "error"
+        });
+        if (typeof response.text === "function") await response.text();
+        if (!response.ok) {
+          throw Object.assign(new Error("Telemetry rejected"), {
+            status: response.status
+          });
+        }
+      } finally {
+        clearTimeout(timeout);
+        controllers.delete(controller);
+      }
+    },
+    dispose() {
+      for (const controller of controllers) controller.abort();
+      controllers.clear();
+    }
+  };
+}
+function createDefaultRoomFactory() {
+  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(_optionalChain([envelope, 'optionalAccess', _105 => _105.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 = _chunk7OX2DSKIcjs.__require.call(void 0, "@pickleball/rtmp-native").default;
+  const { Platform, PermissionsAndroid } = _chunk7OX2DSKIcjs.__require.call(void 0, "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 } = _chunk7OX2DSKIcjs.__require.call(void 0, "react-native").Dimensions.get("window");
+      return width > height;
+    },
+    connect: (options) => native.connect(options),
+    setPublishing: (enabled) => native.setPublishing(enabled),
+    disconnect: () => native.disconnect(),
+    switchCamera: () => native.switchCamera(),
+    listCameras: () => native.listCameras(),
+    selectCamera: (deviceId, facing) => native.selectCamera(deviceId, facing),
+    setMicrophoneEnabled: (enabled) => native.setMicrophoneEnabled(enabled),
+    setVideoBitrate: (bps) => native.setVideoBitrate(bps),
+    dispose: () => native.dispose(),
+    addStatusListener: (listener) => native.addListener("onStatusChanged", listener),
+    addBandwidthListener: (listener) => native.addListener("onBandwidth", listener)
+  };
+}
+function createRtmpRoomFactory(options) {
+  return () => new RtmpRoomAdapter(createNativeRtmpBindings(), options);
+}
+function createDefaultDeviceMetrics() {
+  return async () => {
+    const metrics = {};
+    const notes = [];
+    try {
+      const Battery = _chunk7OX2DSKIcjs.__require.call(void 0, "expo-battery");
+      const level = await Battery.getBatteryLevelAsync();
+      if (typeof level === "number" && level >= 0) {
+        metrics.batteryPct = Math.round(level * 100);
+      } else {
+        notes.push(`battery level=${String(level)}`);
+      }
+      const state = await Battery.getBatteryStateAsync();
+      if (typeof state === "number") metrics.charging = state === 2 || state === 3;
+    } catch (error) {
+      notes.push(`battery require/call: ${String(error)}`);
+    }
+    try {
+      let FileSystem;
+      try {
+        FileSystem = _chunk7OX2DSKIcjs.__require.call(void 0, "expo-file-system/legacy");
+      } catch (e16) {
+        FileSystem = _chunk7OX2DSKIcjs.__require.call(void 0, "expo-file-system");
+      }
+      if (FileSystem.getFreeDiskStorageAsync) {
+        const freeBytes = await FileSystem.getFreeDiskStorageAsync();
+        metrics.storageFreeGb = Math.round(freeBytes / 1e8) / 10;
+      } else {
+        notes.push("filesystem: getFreeDiskStorageAsync missing");
+      }
+    } catch (error) {
+      notes.push(`filesystem: ${String(error)}`);
+    }
+    try {
+      const Device = _chunk7OX2DSKIcjs.__require.call(void 0, "expo-device");
+      if (typeof Device.totalMemory === "number") {
+        metrics.ramTotalMb = Math.round(Device.totalMemory / 1048576);
+      }
+    } catch (e17) {
+    }
+    try {
+      const native = _chunk7OX2DSKIcjs.__require.call(void 0, "@pickleball/rtmp-native").default;
+      const health = await native.getDeviceHealth();
+      if (typeof _optionalChain([health, 'optionalAccess', _106 => _106.thermal]) === "number") metrics.thermal = health.thermal;
+      if (typeof _optionalChain([health, 'optionalAccess', _107 => _107.batteryTempC]) === "number") {
+        metrics.batteryTempC = Math.round(health.batteryTempC * 10) / 10;
+      }
+    } catch (error) {
+      notes.push(`device health: ${String(error)}`);
+    }
+    try {
+      const NetInfo = _chunk7OX2DSKIcjs.__require.call(void 0, "@react-native-community/netinfo").default;
+      const status = await NetInfo.fetch();
+      if (_optionalChain([status, 'optionalAccess', _108 => _108.type])) {
+        metrics.netType = status.type === "wifi" ? "WiFi" : status.type === "cellular" ? String(
+          _nullishCoalesce(_optionalChain([status, 'access', _109 => _109.details, 'optionalAccess', _110 => _110.cellularGeneration]), () => ( "cellular"))
+        ).toUpperCase() : status.type;
+      }
+      const details = _optionalChain([status, 'optionalAccess', _111 => _111.details]);
+      if (typeof _optionalChain([details, 'optionalAccess', _112 => _112.ipAddress]) === "string" && details.ipAddress) {
+        metrics.localIp = details.ipAddress;
+      }
+      if (typeof _optionalChain([details, 'optionalAccess', _113 => _113.strength]) === "number" && Number.isFinite(details.strength)) {
+        metrics.signalPct = Math.round(details.strength);
+      }
+      if (typeof _optionalChain([details, 'optionalAccess', _114 => _114.linkSpeed]) === "number" && Number.isFinite(details.linkSpeed)) {
+        metrics.linkMbps = Math.round(details.linkSpeed);
+      }
+      if (typeof _optionalChain([details, 'optionalAccess', _115 => _115.frequency]) === "number" && Number.isFinite(details.frequency) && details.frequency > 0) {
+        metrics.freqMhz = Math.round(details.frequency);
+      }
+    } catch (e18) {
+    }
+    if (notes.length > 0) console.log("[pickleball] metrics notes:", notes.join(" | "));
+    return Object.keys(metrics).length > 0 ? metrics : null;
+  };
+}
+
+// src/provider.tsx
+var _react = require('react'); var _react2 = _interopRequireDefault(_react);
+var _reactnative = require('react-native');
+var _jsxruntime = require('react/jsx-runtime');
+var defaultLivestreamTheme = {
+  background: "#0a0a0b",
+  foreground: "#f5f6f7",
+  accent: "#b4ff39",
+  danger: "#fb7185",
+  muted: "#6c7079",
+  overlay: "rgba(10,10,11,0.82)",
+  radius: 14,
+  surface: "#131417",
+  elevated: "#1b1d21",
+  hairline: "rgba(255,255,255,0.09)",
+  ink: "#0a0a0b",
+  textSecondary: "#a7abb3",
+  radiusSm: 6
+};
+var LivestreamHostContext = _react2.default.createContext(null);
+function useLivestreamHost() {
+  const value = _react2.default.use(LivestreamHostContext);
+  if (!value) {
+    throw new ExpoSdkConfigurationError(
+      "useLivestreamHost must be used inside PickleballLiveProvider"
+    );
+  }
+  return value;
+}
+var LivestreamContext = _react2.default.createContext(null);
+function PickleballLiveProvider(props) {
+  const engineRef = _react.useRef.call(void 0, null);
+  const keepSessionRef = _react.useRef.call(void 0, props.keepSessionOnRestart);
+  keepSessionRef.current = props.keepSessionOnRestart;
+  const resolvedKeepRef = _react.useRef.call(void 0, typeof props.keepSessionOnRestart === "function");
+  _react.useEffect.call(void 0, () => {
+    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 = _react.useRef.call(void 0, null);
+  const effectGenerationRef = _react.useRef.call(void 0, 0);
+  if (!engineRef.current) {
+    const deviceMetrics = _nullishCoalesce(props.deviceMetrics, () => ( createDefaultDeviceMetrics()));
+    const dependencies = {
+      sessionProvider: props.sessionProvider,
+      bootstrapInput: props.bootstrapInput,
+      runtime: _nullishCoalesce(props.runtime, () => ( createDefaultRuntime())),
+      storage: _nullishCoalesce(props.storage, () => ( createDefaultStorage())),
+      network: _nullishCoalesce(props.network, () => ( createDefaultNetwork())),
+      telemetry: _nullishCoalesce(props.telemetry, () => ( createDefaultTelemetry())),
+      commandChannel: _nullishCoalesce(props.commandChannel, () => ( createDefaultCommandChannel())),
+      ...props.commandSubscription ? { commandSubscription: props.commandSubscription } : {},
+      deviceMetrics,
+      roomFactory: _nullishCoalesce(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 = {
+      engine: engineRef.current,
+      bootstrapInput: props.bootstrapInput,
+      deviceMetrics
+    };
+  }
+  const engine = engineRef.current;
+  const snapshot = _react.useSyncExternalStore.call(void 0, 
+    engine.subscribe,
+    engine.getSnapshot,
+    engine.getSnapshot
+  );
+  _react.useEffect.call(void 0, () => {
+    const effectGeneration = ++effectGenerationRef.current;
+    void engine.initialize();
+    const subscription = _reactnative.AppState.addEventListener("change", (state) => {
+      engine.handleAppState(
+        state === "active" ? "active" : state === "background" ? "background" : "inactive"
+      );
+    });
+    return () => {
+      subscription.remove();
+      queueMicrotask(() => {
+        if (effectGenerationRef.current === effectGeneration) {
+          void engine.dispose({ keepSession: resolvedKeepRef.current });
+        }
+      });
+    };
+  }, [engine]);
+  _react.useEffect.call(void 0, () => {
+    if (snapshot.error) _optionalChain([props, 'access', _116 => _116.onError, 'optionalCall', _117 => _117(snapshot.error)]);
+  }, [props.onError, snapshot.error]);
+  const actions = _react.useMemo.call(void 0, 
+    () => ({
+      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 = _nullishCoalesce(props.locale, () => ( "vi"));
+  const theme = _react.useMemo.call(void 0, 
+    () => ({ ...defaultLivestreamTheme, ...props.theme }),
+    [props.theme]
+  );
+  const value = _react.useMemo.call(void 0, 
+    () => ({ ...snapshot, locale, theme, ...actions }),
+    [snapshot, locale, theme, actions]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, LivestreamHostContext.Provider, { value: hostRef.current, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, LivestreamContext.Provider, { value, children: props.children }) });
+}
+function useLivestream() {
+  const value = _react2.default.use(LivestreamContext);
+  if (!value) {
+    throw new ExpoSdkConfigurationError(
+      "useLivestream must be used inside PickleballLiveProvider"
+    );
+  }
+  return value;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.SDK_TELEMETRY_EVENT_NAMES = SDK_TELEMETRY_EVENT_NAMES; exports.isSdkRemoteConfig = isSdkRemoteConfig; exports.compareSemver = compareSemver; exports.isSdkVersionSupported = isSdkVersionSupported; exports.PickleballExpoError = PickleballExpoError; exports.PermissionDeniedError = PermissionDeniedError; exports.NetworkUnavailableError = NetworkUnavailableError; exports.TokenExpiredError = TokenExpiredError; exports.UnsupportedSdkError = UnsupportedSdkError; exports.UnsupportedRuntimeError = UnsupportedRuntimeError; exports.SessionConflictError = SessionConflictError; exports.RecordingFailureError = RecordingFailureError; exports.ConsentRequiredError = ConsentRequiredError; exports.SdkDisabledError = SdkDisabledError; exports.ExpoSdkConfigurationError = ExpoSdkConfigurationError; exports.InvalidResponseError = InvalidResponseError; exports.ExpoSdkTimeoutError = ExpoSdkTimeoutError; exports.UnknownSdkError = UnknownSdkError; exports.errorFromCode = errorFromCode; exports.normalizeError = normalizeError; exports.isSessionGoneError = isSessionGoneError; exports.PENDING_END_KEY = PENDING_END_KEY; exports.LEGAL_LIVESTREAM_TRANSITIONS = LEGAL_LIVESTREAM_TRANSITIONS; exports.LivestreamEngine = LivestreamEngine; exports.VIDEO_BITRATE_BPS = VIDEO_BITRATE_BPS; exports.AUDIO_BITRATE_BPS = AUDIO_BITRATE_BPS; exports.DEFAULT_UPLOAD_URL = DEFAULT_UPLOAD_URL; exports.requiredMbpsFor = requiredMbpsFor; exports.verdictFor = verdictFor; exports.runUplinkCheck = runUplinkCheck; exports.RtmpRoomAdapter = RtmpRoomAdapter; exports.createRtmpRuntime = createRtmpRuntime; exports.createDefaultRuntime = createDefaultRuntime; exports.createDefaultStorage = createDefaultStorage; exports.createDefaultNetwork = createDefaultNetwork; exports.createDefaultTelemetry = createDefaultTelemetry; exports.createDefaultRoomFactory = createDefaultRoomFactory; exports.createNativeRtmpBindings = createNativeRtmpBindings; exports.createRtmpRoomFactory = createRtmpRoomFactory; exports.createDefaultDeviceMetrics = createDefaultDeviceMetrics; exports.defaultLivestreamTheme = defaultLivestreamTheme; exports.useLivestreamHost = useLivestreamHost; exports.PickleballLiveProvider = PickleballLiveProvider; exports.useLivestream = useLivestream;