@pickleball/expo-sdk 0.1.1 → 0.2.0

package/dist/chunk-TBPR2QND.cjs

@@ -0,0 +1,1953 @@
+"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 _class3;
+
+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 DEFAULT_STANDBY_TIMEOUT_MS = 15 * 6e4;
+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);
+    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()
+    };
+  }
+  
+  
+  
+  __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 publish track (live) hay chỉ ngồi trong phòng (standby). */
+  __init9() {this.publishing = false}
+  /** Tổng thời gian đã phát trước lần tạm dừng gần nhất. */
+  __init10() {this.pausedElapsedMs = 0}
+  
+  __init11() {this.refreshRetryAttempt = 0}
+  __init12() {this.operationGeneration = 0}
+  __init13() {this.liveTimersStarted = false}
+  __init14() {this.keepAwakeActive = false}
+  
+  
+  __init15() {this.sessionTerminations = /* @__PURE__ */ new Map()}
+  
+  __init16() {this.disposed = false}
+  __init17() {this.getSnapshot = () => this.snapshot}
+  __init18() {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 permitted = await this.dependencies.runtime.requestPermissions();
+      this.ensureOperation(generation);
+      if (!permitted) {
+        throw new PermissionDeniedError();
+      }
+      const room = this.ensureRoom();
+      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();
+      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;
+      this.grant = grant;
+      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 {
+      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;
+      }
+      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', _8 => _8.requireRoom, 'call', _9 => _9(), 'access', _10 => _10.setCaptureOrientation, 'optionalCall', _11 => _11(orientation)]);
+      if (!this.isOperationCurrent(generation)) return;
+    }
+    this.update({ captureOrientation: orientation });
+  }
+  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();
+      return;
+    }
+    if (event.type === "reconnecting" && (this.snapshot.state === "live" || this.snapshot.state === "standby")) {
+      this.transition("reconnecting");
+      void this.sendTelemetry("reconnect", { phase: "started" });
+      const timeout = _nullishCoalesce(_optionalChain([this, 'access', _12 => _12.snapshot, 'access', _13 => _13.config, 'optionalAccess', _14 => _14.reconnectTimeoutMs]), () => ( 3e4));
+      this.clearReconnectTimer();
+      this.reconnectTimer = setTimeout(() => {
+        void this.stop("network_timeout");
+      }, timeout);
+      return;
+    }
+    if (event.type === "reconnected" && this.snapshot.state === "reconnecting") {
+      this.clearReconnectTimer();
+      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 === "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', _15 => _15.snapshot, 'access', _16 => _16.config, 'optionalAccess', _17 => _17.backgroundGraceMs]), () => ( 15e3));
+    this.backgroundTimer = setTimeout(() => {
+      this.backgroundTimer = void 0;
+      if (this.latestAppState !== "active") {
+        void this.stop("background_timeout");
+      }
+    }, grace);
+  }
+  dispose() {
+    if (this.disposePromise) return this.disposePromise;
+    if (this.disposed) return Promise.resolve();
+    this.disposed = true;
+    this.operationGeneration += 1;
+    const sessionId = 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', _18 => _18.markerReady]));
+    this.clearTimers();
+    _optionalChain([this, 'access', _19 => _19.dependencies, 'access', _20 => _20.telemetry, 'optionalAccess', _21 => _21.dispose, 'optionalCall', _22 => _22()]);
+    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', _23 => _23.markerReady]);
+      await Promise.allSettled([
+        roomCleanup,
+        this.dependencies.runtime.deactivateKeepAwake()
+      ]);
+      releaseEnd();
+      await _optionalChain([termination, 'optionalAccess', _24 => _24.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;
+  }
+  async recoverStartupSession() {
+    let pending = await this.readPendingEnd();
+    if (!pending || this.ownsInMemorySession()) return;
+    if (pending.pendingEnd === null) {
+      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;
+  }
+  async ensurePendingEndResolved() {
+    await this.initialize();
+    const pending = await this.readPendingEnd();
+    if (!pending) 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 (e3) {
+    }
+    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', _25 => _25.snapshot, 'access', _26 => _26.config, 'optionalAccess', _27 => _27.telemetryIntervalMs]), () => ( 6e4))
+    );
+    this.heartbeatTimer = setInterval(() => {
+      void this.sendHeartbeat();
+    }, interval);
+    _optionalChain([this, 'access', _28 => _28.heartbeatTimer, 'access', _29 => _29.unref, 'optionalCall', _30 => _30()]);
+    this.elapsedTimer = setInterval(() => {
+      if (this.startedAt !== void 0) {
+        this.update({ elapsedMs: this.now() - this.startedAt });
+      }
+    }, 1e3);
+    _optionalChain([this, 'access', _31 => _31.elapsedTimer, 'access', _32 => _32.unref, 'optionalCall', _33 => _33()]);
+    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.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;
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = void 0;
+  }
+  /** 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', _34 => _34.dependencies, 'access', _35 => _35.deviceMetrics, 'optionalCall', _36 => _36()]), async () => ( null));
+    } catch (e4) {
+      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', _37 => _37.dependencies, 'access', _38 => _38.telemetry, 'optionalAccess', _39 => _39.send, 'call', _40 => _40(pending.credentials, [
+          pending.event
+        ])]);
+      } catch (error) {
+        if (_optionalChain([error, 'optionalAccess', _41 => _41.status]) === 401) {
+          try {
+            await this.refreshCredentials();
+            if (this.grant) {
+              await _optionalChain([this, 'access', _42 => _42.dependencies, 'access', _43 => _43.telemetry, 'optionalAccess', _44 => _44.send, 'call', _45 => _45(this.grant.telemetry, [
+                pending.event
+              ])]);
+            }
+          } catch (e5) {
+          }
+        }
+      }
+    })();
+    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.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();
+    if (this.snapshot.sessionId) {
+      void this.sendTelemetry("state_changed", { from: previous, to: state });
+    }
+  }
+  startStandbyTimer() {
+    this.clearStandbyTimer();
+    const timeout = _nullishCoalesce(_optionalChain([this, 'access', _46 => _46.snapshot, 'access', _47 => _47.config, 'optionalAccess', _48 => _48.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', _49 => _49.standbyTimer, 'access', _50 => _50.unref, 'optionalCall', _51 => _51()]);
+  }
+  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;
+        });
+      }
+    });
+  }
+  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 (e6) {
+    }
+    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 delay = _nullishCoalesce(delayOverride, () => ( Math.max(1e3, this.grant.tokenExpiresAt - this.now() - 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', _52 => _52.tokenRefreshTimer, 'access', _53 => _53.unref, 'optionalCall', _54 => _54()]);
+  }
+  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', _55 => _55.maxSessionTimer, 'access', _56 => _56.unref, 'optionalCall', _57 => _57()]);
+  }
+  restartHeartbeat() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    const interval = Math.max(
+      1e4,
+      _nullishCoalesce(_optionalChain([this, 'access', _58 => _58.snapshot, 'access', _59 => _59.config, 'optionalAccess', _60 => _60.telemetryIntervalMs]), () => ( 6e4))
+    );
+    this.heartbeatTimer = setInterval(() => {
+      void this.sendHeartbeat();
+    }, interval);
+    _optionalChain([this, 'access', _61 => _61.heartbeatTimer, 'access', _62 => _62.unref, 'optionalCall', _63 => _63()]);
+  }
+  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 (e7) {
+      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 (e8) {
+      }
+    });
+    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/livekit-room-adapter.ts
+var LiveKitRoomAdapter = (_class2 = class {
+  constructor(bindings) {;_class2.prototype.__init19.call(this);_class2.prototype.__init20.call(this);_class2.prototype.__init21.call(this);_class2.prototype.__init22.call(this);_class2.prototype.__init23.call(this);_class2.prototype.__init24.call(this);_class2.prototype.__init25.call(this);_class2.prototype.__init26.call(this);
+    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(_nullishCoalesce(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 (_optionalChain([parsed, 'optionalAccess', _64 => _64.type]) === "cmd" && typeof parsed.action === "string") {
+              this.emit({ type: "command", action: parsed.action });
+            }
+          } catch (e9) {
+          }
+        }
+      ]);
+    }
+    for (const [event, listener] of this.nativeListeners) {
+      this.room.on(event, listener);
+    }
+  }
+  
+  __init19() {this.listeners = /* @__PURE__ */ new Set()}
+  __init20() {this.tracks = []}
+  
+  
+  
+  // Khớp engine (isCameraFront: false) — xem ghi chú ở engine.ts.
+  __init21() {this.isFront = false}
+  __init22() {this.orientationOverride = null}
+  __init23() {this.deviceOverride = null}
+  __init24() {this.published = false}
+  __init25() {this.disposed = false}
+  __init26() {this.quality = 720}
+  
+  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 _optionalChain([this, 'access', _65 => _65.audioTrack, 'access', _66 => _66.unmute, 'optionalCall', _67 => _67()]);
+    else await _optionalChain([this, 'access', _68 => _68.audioTrack, 'access', _69 => _69.mute, 'optionalCall', _70 => _70()]);
+    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 _optionalChain([this, 'access', _71 => _71.room, 'access', _72 => _72.localParticipant, 'access', _73 => _73.unpublishTrack, 'optionalCall', _74 => _74(this.videoTrack, false)]);
+    await _optionalChain([this, 'access', _75 => _75.room, 'access', _76 => _76.localParticipant, 'access', _77 => _77.unpublishTrack, 'optionalCall', _78 => _78(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 = _optionalChain([this, 'access', _79 => _79.videoTrack, 'optionalAccess', _80 => _80.mediaStreamTrack]);
+    if (_optionalChain([nativeTrack, 'optionalAccess', _81 => _81.applyConstraints])) {
+      await nativeTrack.applyConstraints(this.captureResolution());
+    }
+  }
+  async switchCamera() {
+    this.ensureNotDisposed();
+    const facingMode = this.isFront ? "environment" : "user";
+    const nativeTrack = _optionalChain([this, 'access', _82 => _82.videoTrack, 'optionalAccess', _83 => _83.mediaStreamTrack]);
+    if (typeof _optionalChain([this, 'access', _84 => _84.videoTrack, 'optionalAccess', _85 => _85.restartTrack]) === "function") {
+      await this.videoTrack.restartTrack({ facingMode });
+      await this.reapplyCaptureFormat();
+    } else if (typeof _optionalChain([nativeTrack, 'optionalAccess', _86 => _86._switchCamera]) === "function") {
+      nativeTrack._switchCamera();
+    } else if (_optionalChain([nativeTrack, 'optionalAccess', _87 => _87.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 _asyncNullishCoalesce(await _optionalChain([this, 'access', _88 => _88.bindings, 'access', _89 => _89.listCameras, 'optionalCall', _90 => _90()]), async () => ( []));
+  }
+  async selectCamera(deviceId, facing) {
+    this.ensureNotDisposed();
+    if (typeof _optionalChain([this, 'access', _91 => _91.videoTrack, 'optionalAccess', _92 => _92.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 _optionalChain([this, 'access', _93 => _93.audioTrack, 'access', _94 => _94.unmute, 'optionalCall', _95 => _95()]);
+    else await _optionalChain([this, 'access', _96 => _96.audioTrack, 'access', _97 => _97.mute, 'optionalCall', _98 => _98()]);
+  }
+  subscribe(listener) {
+    this.ensureNotDisposed();
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const [event, listener] of this.nativeListeners) {
+      this.room.off(event, listener);
+    }
+    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 = _optionalChain([this, 'access', _99 => _99.videoTrack, 'optionalAccess', _100 => _100.mediaStreamTrack, 'optionalAccess', _101 => _101.readyState]) !== "ended" && _optionalChain([this, 'access', _102 => _102.audioTrack, 'optionalAccess', _103 => _103.mediaStreamTrack, 'optionalAccess', _104 => _104.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
+      }
+    });
+    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 };
+    }
+  }
+  emit(event) {
+    for (const listener of this.listeners) listener(event);
+  }
+  ensureNotDisposed() {
+    if (this.disposed) {
+      throw new Error("LiveKit room adapter has been disposed");
+    }
+  }
+}, _class2);
+
+// src/rtmp-room-adapter.ts
+var VIDEO_BITRATE = {
+  720: 35e5,
+  1080: 6e6
+};
+var RtmpRoomAdapter = (_class3 = class {
+  constructor(bindings) {;_class3.prototype.__init27.call(this);_class3.prototype.__init28.call(this);_class3.prototype.__init29.call(this);
+    this.bindings = bindings;
+  }
+  __init27() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  __init28() {this.quality = 1080}
+  __init29() {this.connected = false}
+  async preparePreview(quality) {
+    this.quality = quality;
+    await this.bindings.prepare({
+      quality,
+      landscape: _nullishCoalesce(_optionalChain([this, 'access', _105 => _105.bindings, 'access', _106 => _106.isLandscape, 'optionalCall', _107 => _107()]), () => ( 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;
+  }
+  async setPublishing(enabled) {
+    await this.bindings.setPublishing(enabled);
+  }
+  async disconnect(_stopTracks) {
+    if (!this.connected) return;
+    this.connected = false;
+    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) {
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    if (!this.nativeSubscription) {
+      this.nativeSubscription = this.bindings.addStatusListener((event) => {
+        const mapped = mapStatus(event);
+        if (mapped) this.emit(mapped);
+      });
+    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async dispose() {
+    _optionalChain([this, 'access', _108 => _108.nativeSubscription, 'optionalAccess', _109 => _109.remove, 'call', _110 => _110()]);
+    this.nativeSubscription = void 0;
+    this.listeners.clear();
+    this.connected = false;
+    await this.bindings.dispose();
+  }
+  emit(event) {
+    for (const listener of this.listeners) listener(event);
+  }
+}, _class3);
+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
+var globalsRegistered = false;
+function createNativeLiveKitBindings() {
+  const reactNativeLiveKit = _chunk7OX2DSKIcjs.__require.call(void 0, "@livekit/react-native");
+  const liveKit = _chunk7OX2DSKIcjs.__require.call(void 0, "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 } = _chunk7OX2DSKIcjs.__require.call(void 0, "react-native").Dimensions.get("window");
+      return width > height;
+    },
+    async listCameras() {
+      const { mediaDevices } = _chunk7OX2DSKIcjs.__require.call(void 0, "@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(_nullishCoalesce(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 } = _chunk7OX2DSKIcjs.__require.call(void 0, "react-native");
+  return {
+    assertSupported() {
+      if (Platform.OS !== "ios" && Platform.OS !== "android" || !NativeModules.LivekitReactNativeModule) {
+        throw new UnsupportedRuntimeError();
+      }
+    },
+    async requestPermissions() {
+      try {
+        const { mediaDevices } = _chunk7OX2DSKIcjs.__require.call(void 0, "@livekit/react-native-webrtc");
+        const stream = await mediaDevices.getUserMedia({ audio: true, video: true });
+        for (const track of stream.getTracks()) track.stop();
+        return true;
+      } catch (e10) {
+        return false;
+      }
+    },
+    activateKeepAwake() {
+      return _chunk7OX2DSKIcjs.__require.call(void 0, "expo-keep-awake").activateKeepAwakeAsync(
+        "@pickleball/expo-sdk"
+      );
+    },
+    deactivateKeepAwake() {
+      return _chunk7OX2DSKIcjs.__require.call(void 0, "expo-keep-awake").deactivateKeepAwake(
+        "@pickleball/expo-sdk"
+      );
+    }
+  };
+}
+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 () => new LiveKitRoomAdapter(createNativeLiveKitBindings());
+}
+function createNativeRtmpBindings() {
+  const native = _chunk7OX2DSKIcjs.__require.call(void 0, "@pickleball/rtmp-native").default;
+  return {
+    prepare: (options) => native.prepare(options),
+    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)
+  };
+}
+function createRtmpRoomFactory() {
+  return () => new RtmpRoomAdapter(createNativeRtmpBindings());
+}
+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 (e11) {
+        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 (e12) {
+    }
+    try {
+      const NetInfo = _chunk7OX2DSKIcjs.__require.call(void 0, "@react-native-community/netinfo").default;
+      const status = await NetInfo.fetch();
+      if (_optionalChain([status, 'optionalAccess', _111 => _111.type])) {
+        metrics.netType = status.type === "wifi" ? "WiFi" : status.type === "cellular" ? String(
+          _nullishCoalesce(_optionalChain([status, 'access', _112 => _112.details, 'optionalAccess', _113 => _113.cellularGeneration]), () => ( "cellular"))
+        ).toUpperCase() : status.type;
+      }
+    } catch (e13) {
+    }
+    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 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())),
+      deviceMetrics,
+      roomFactory: _nullishCoalesce(props.roomFactory, () => ( createDefaultRoomFactory()))
+    };
+    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();
+        }
+      });
+    };
+  }, [engine]);
+  _react.useEffect.call(void 0, () => {
+    if (snapshot.error) _optionalChain([props, 'access', _114 => _114.onError, 'optionalCall', _115 => _115(snapshot.error)]);
+  }, [props.onError, snapshot.error]);
+  const value = {
+    ...snapshot,
+    locale: _nullishCoalesce(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)
+  };
+  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.LiveKitRoomAdapter = LiveKitRoomAdapter; exports.RtmpRoomAdapter = RtmpRoomAdapter; exports.createNativeLiveKitBindings = createNativeLiveKitBindings; 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;