@pickleball/expo-sdk 0.2.0 → 1.0.0

package/dist/device-agent/index.js

@@ -1,3 +1,7 @@
+import {
+  createConvexCommandSubscription,
+  createConvexDeviceRealtime
+} from "../chunk-6F3HN6US.js";
 import {
   ExpoSdkConfigurationError,
   ExpoSdkTimeoutError,
@@ -7,7 +11,7 @@ import {
   errorFromCode,
   normalizeError,
   useLivestreamHost
-} from "../chunk-FODE2W2H.js";
+} from "../chunk-XGP2MN5R.js";
 import {
   __esm,
   __export,
@@ -31,7 +35,7 @@ function createConvexControlChannel(convexUrl) {
     for (const item of value) {
       if (item === null || typeof item !== "object") continue;
       const record = item;
-      if (typeof record.id !== "string" || record.type !== "start_livestream" && record.type !== "stop_livestream" || typeof record.expiresAt !== "number") {
+      if (typeof record.id !== "string" || record.type !== "start_livestream" && record.type !== "stop_livestream" && record.type !== "publish_livestream" && record.type !== "unpublish_livestream" || typeof record.expiresAt !== "number") {
         continue;
       }
       const payload = record.payload !== null && typeof record.payload === "object" && !Array.isArray(record.payload) ? record.payload : {};
@@ -40,7 +44,8 @@ function createConvexControlChannel(convexUrl) {
         type: record.type,
         payload: {
           ...typeof payload.title === "string" ? { title: payload.title } : {},
-          ...payload.visibility === "public" || payload.visibility === "private" ? { visibility: payload.visibility } : {}
+          ...payload.visibility === "public" || payload.visibility === "private" ? { visibility: payload.visibility } : {},
+          ...typeof payload.courtRef === "string" && payload.courtRef.trim() !== "" ? { courtRef: payload.courtRef } : {}
         },
         expiresAt: record.expiresAt
       });
@@ -82,10 +87,32 @@ var init_convex_control_channel = __esm({
   }
 });
 
+// src/device-agent/beat-policy.ts
+var BEAT_SLOW_MS = 6e4;
+var BEAT_FAST_MS = 12e3;
+var MQTT_HEALTHY_SILENCE_MS = 45e3;
+var MQTT_HEALTHY_HOLD_MS = 12e4;
+function mqttBeatHealthy(h, now) {
+  if (!h.connected || !h.subscribed) return false;
+  if (h.lastInboundAt <= 0 || now - h.lastInboundAt >= MQTT_HEALTHY_SILENCE_MS) return false;
+  if (h.healthySince <= 0 || now - h.healthySince < MQTT_HEALTHY_HOLD_MS) return false;
+  return true;
+}
+function nextBeatDelayMs(input) {
+  const hint = input.serverHintMs ?? BEAT_FAST_MS;
+  if (input.busy || !input.health) return BEAT_FAST_MS;
+  const local = mqttBeatHealthy(input.health, input.now) ? BEAT_SLOW_MS : BEAT_FAST_MS;
+  return Math.min(local, hint);
+}
+
 // src/device-agent/agent.ts
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 12e3;
+var IDLE_HEARTBEAT_INTERVAL_MS = 12e3;
 var REGISTER_RETRY_BASE_MS = 2e3;
 var REGISTER_RETRY_MAX_MS = 6e4;
+var METRICS_BASELINE_MS = 5 * 6e4;
+var METRICS_BATTERY_LOW_PCT = 10;
+var METRICS_BATTERY_DELTA_PCT = 5;
 var METRIC_FIELDS = [
   "ramFreeMb",
   "ramTotalMb",
@@ -96,7 +123,9 @@ var METRIC_FIELDS = [
   "netType",
   "linkMbps",
   "rssi",
-  "connQuality"
+  "connQuality",
+  "signalPct",
+  "localIp"
 ];
 function defaultSubscribeAppState(listener) {
   const { AppState } = __require("react-native");
@@ -121,17 +150,38 @@ function pickMetrics(sample) {
   }
   return Object.keys(metrics).length > 0 ? metrics : void 0;
 }
+function metricsCrossedThreshold(last, next) {
+  if (!last) return true;
+  const b0 = typeof last.batteryPct === "number" ? last.batteryPct : void 0;
+  const b1 = typeof next.batteryPct === "number" ? next.batteryPct : void 0;
+  if (b1 !== void 0) {
+    if (b1 < METRICS_BATTERY_LOW_PCT && (b0 === void 0 || b0 >= METRICS_BATTERY_LOW_PCT)) {
+      return true;
+    }
+    if (b0 !== void 0 && Math.abs(b1 - b0) >= METRICS_BATTERY_DELTA_PCT) {
+      return true;
+    }
+  }
+  if (next.thermal !== last.thermal) return true;
+  if (next.netType !== last.netType) return true;
+  return false;
+}
 var DeviceAgent = class {
   options;
   running = false;
   registered = false;
   foreground = true;
   heartbeatIntervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS;
+  /** Nhịp server gợi ý ở beat gần nhất — undefined = server chưa nói gì → 12s. */
+  serverBeatHintMs;
   timer = null;
   beatInFlight = false;
   registerAttempt = 0;
   unsubscribeAppState = null;
   heartbeatFailures = 0;
+  /** Metrics đã gửi lần gần nhất + mốc thời gian, để lọc "chỉ gửi khi đổi". */
+  lastSentMetrics;
+  lastMetricsSentAt = 0;
   controlChannel = null;
   controlSessionId = null;
   controlUnsubscribers = [];
@@ -167,6 +217,28 @@ var DeviceAgent = class {
       this.closeControlChannel();
     }
   }
+  /**
+   * Đang có phiên hoặc đã mở kênh điều khiển = lệnh tới qua kênh, nhịp thường
+   * là đủ. Rảnh và chưa có kênh = đang chờ lệnh, đập nhanh cho kịp dashboard.
+   */
+  nextBeatDelay() {
+    const base = this.controlChannel ? this.heartbeatIntervalMs : this.options.engine.getSnapshot().sessionId ? this.heartbeatIntervalMs : Math.min(IDLE_HEARTBEAT_INTERVAL_MS, this.heartbeatIntervalMs);
+    const health = (() => {
+      try {
+        return this.options.mqttHealth?.() ?? null;
+      } catch {
+        return null;
+      }
+    })();
+    const adaptive = nextBeatDelayMs({
+      health,
+      now: Date.now(),
+      serverHintMs: this.serverBeatHintMs,
+      // Đang chạy lệnh / đang mở kênh điều khiển = có người chờ kết quả.
+      busy: this.executing || this.controlChannel !== null
+    });
+    return Math.max(base, adaptive);
+  }
   schedule(delayMs) {
     if (!this.running || !this.foreground) return;
     if (this.timer) clearTimeout(this.timer);
@@ -183,7 +255,7 @@ var DeviceAgent = class {
         if (!this.registered) return;
       }
       await this.heartbeat();
-      this.schedule(this.heartbeatIntervalMs);
+      this.schedule(this.nextBeatDelay());
     } finally {
       this.beatInFlight = false;
     }
@@ -208,6 +280,21 @@ var DeviceAgent = class {
       this.schedule(delay);
     }
   }
+  /**
+   * Lọc metrics cho heartbeat: chỉ trả (và ghi nhớ) khi vượt ngưỡng
+   * (metricsCrossedThreshold) hoặc đã quá METRICS_BASELINE_MS kể từ lần gửi.
+   * Trả undefined = nhịp này không kèm metrics.
+   */
+  selectMetricsForHeartbeat(metrics) {
+    if (!metrics) return void 0;
+    const now = Date.now();
+    const crossed = metricsCrossedThreshold(this.lastSentMetrics, metrics);
+    const baselineDue = now - this.lastMetricsSentAt >= METRICS_BASELINE_MS;
+    if (!crossed && !baselineDue) return void 0;
+    this.lastSentMetrics = metrics;
+    this.lastMetricsSentAt = now;
+    return metrics;
+  }
   async heartbeat() {
     const snapshot = this.options.engine.getSnapshot();
     let metrics;
@@ -216,6 +303,13 @@ var DeviceAgent = class {
     } catch {
       metrics = void 0;
     }
+    const metricsToSend = this.selectMetricsForHeartbeat(metrics);
+    let extras = {};
+    try {
+      extras = this.options.heartbeatExtras?.() ?? {};
+    } catch {
+      extras = {};
+    }
     let result;
     try {
       result = await this.options.transport.heartbeat({
@@ -223,7 +317,12 @@ var DeviceAgent = class {
         agentState: snapshot.state,
         currentSessionId: snapshot.sessionId,
         ...this.options.deviceInfo?.appVersion ? { appVersion: this.options.deviceInfo.appVersion } : {},
-        ...metrics ? { metrics } : {}
+        ...metricsToSend ? { metrics: metricsToSend } : {},
+        ...extras.recentExits && extras.recentExits.length > 0 ? { recentExits: extras.recentExits } : {},
+        ...extras.powerState !== void 0 ? { powerState: extras.powerState } : {},
+        // Chỉ gửi khi TRUE. Server đọc doc tỉ số mỗi nhịp có cờ này, nên gửi
+        // `false` cũng vô hại nhưng phí một field trên mọi beat của mọi máy.
+        ...extras.wantScore ? { wantScore: true } : {}
       });
     } catch {
       this.heartbeatFailures += 1;
@@ -234,6 +333,7 @@ var DeviceAgent = class {
       return;
     }
     this.heartbeatFailures = 0;
+    this.serverBeatHintMs = typeof result.beatIntervalMs === "number" && result.beatIntervalMs > 0 ? result.beatIntervalMs : void 0;
     if (result.controlSession && !this.controlChannel) {
       this.openControlChannel(result.controlSession);
     }
@@ -317,6 +417,12 @@ var DeviceAgent = class {
           sessionId ?? void 0
         );
         if (sessionId) this.options.onRemoteSessionStarted?.(sessionId);
+      } else if (command.type === "publish_livestream") {
+        await this.runPublish();
+        await this.safeAck(channel, grant, command.id, "completed");
+      } else if (command.type === "unpublish_livestream") {
+        await this.runUnpublish();
+        await this.safeAck(channel, grant, command.id, "completed");
       } else {
         await this.runStopLivestream();
         await this.safeAck(channel, grant, command.id, "completed");
@@ -341,13 +447,19 @@ var DeviceAgent = class {
       await engine.prepare();
     }
     const remote = this.options.remoteStart;
+    const courtRef = command.payload.courtRef?.trim();
     await engine.start(
       {
         externalSessionId: `remote-${command.id}`,
         title: command.payload.title?.trim() || remote.defaultTitle || "Livestream",
         visibility: command.payload.visibility ?? remote.visibility ?? "public",
         consentVersion: remote.consentVersion,
-        metadata: { ...remote.metadata, deviceCommandId: command.id },
+        metadata: {
+          ...remote.metadata,
+          deviceCommandId: command.id,
+          // courtRef trong metadata → server đậu phiên standby vào sân
+          ...courtRef ? { courtRef } : {}
+        },
         standby: true
       },
       { autoPublish: false }
@@ -359,6 +471,36 @@ var DeviceAgent = class {
       await engine.stop("user");
     }
   }
+  /**
+   * standby → live theo lệnh dashboard. startPublishing() NUỐT lỗi (recordError
+   * vào snapshot thay vì throw) nên phải kiểm state sau khi gọi — không kiểm là
+   * lệnh được ack "completed" dù thiết bị chưa hề phát.
+   */
+  async runPublish() {
+    const engine = this.options.engine;
+    const state = engine.getSnapshot().state;
+    if (state === "live") return;
+    if (state !== "standby") {
+      throw new Error(`Thi\u1EBFt b\u1ECB kh\xF4ng \u1EDF ch\u1EBF \u0111\u1ED9 ch\u1EDD (tr\u1EA1ng th\xE1i ${state})`);
+    }
+    await engine.startPublishing();
+    if (engine.getSnapshot().state !== "live") {
+      const message = engine.getSnapshot().error?.message;
+      throw new Error(message ? `Kh\xF4ng ph\xE1t \u0111\u01B0\u1EE3c: ${message}` : "Kh\xF4ng ph\xE1t \u0111\u01B0\u1EE3c");
+    }
+  }
+  async runUnpublish() {
+    const engine = this.options.engine;
+    const state = engine.getSnapshot().state;
+    if (state === "standby") return;
+    if (state !== "live") {
+      throw new Error(`Thi\u1EBFt b\u1ECB kh\xF4ng \u0111ang ph\xE1t (tr\u1EA1ng th\xE1i ${state})`);
+    }
+    await engine.stopPublishing();
+    if (engine.getSnapshot().state !== "standby") {
+      throw new Error("Kh\xF4ng d\u1EEBng ph\xE1t \u0111\u01B0\u1EE3c");
+    }
+  }
   async safeAck(channel, grant, commandId, status, errorMessage, resultSessionId) {
     try {
       await channel.ack({
@@ -429,6 +571,7 @@ function createHttpDeviceAgentTransport(options) {
       if (!isRecord(data) || typeof data.deviceId !== "string" || typeof data.heartbeatIntervalMs !== "number" || !Number.isFinite(data.heartbeatIntervalMs)) {
         throw new InvalidResponseError();
       }
+      options.onData?.("register", data);
       return {
         deviceId: data.deviceId,
         heartbeatIntervalMs: data.heartbeatIntervalMs
@@ -437,8 +580,12 @@ function createHttpDeviceAgentTransport(options) {
     async heartbeat(input) {
       const data = await post(paths.heartbeat, input);
       if (!isRecord(data)) throw new InvalidResponseError();
+      options.onData?.("heartbeat", data);
+      const beatIntervalMs = typeof data.beatIntervalMs === "number" && Number.isFinite(data.beatIntervalMs) ? { beatIntervalMs: data.beatIntervalMs } : {};
       const grant = data.controlSession;
-      if (grant === null || grant === void 0) return { controlSession: null };
+      if (grant === null || grant === void 0) {
+        return { controlSession: null, ...beatIntervalMs };
+      }
       if (!isRecord(grant) || typeof grant.id !== "string" || typeof grant.token !== "string" || typeof grant.convexUrl !== "string" || grant.convexUrl === "") {
         throw new InvalidResponseError();
       }
@@ -447,7 +594,8 @@ function createHttpDeviceAgentTransport(options) {
           id: grant.id,
           token: grant.token,
           convexUrl: grant.convexUrl
-        }
+        },
+        ...beatIntervalMs
       };
     }
   };
@@ -465,9 +613,311 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/device-agent/tournament.ts
+var ACTIVE_ENGINE_STATES = /* @__PURE__ */ new Set([
+  "preparing",
+  "connecting",
+  "standby",
+  "live",
+  "reconnecting",
+  "ending"
+]);
+var RECOVERY_CHECK_MS = 5e3;
+var DEFAULT_RECOVERY_GRACE_MS = 9e4;
+var TournamentController = class {
+  constructor(options) {
+    this.options = options;
+    this.engine = options.engine;
+  }
+  engine;
+  armed = false;
+  courtRef = null;
+  lastError = null;
+  attemptInFlight = false;
+  retryAttempt = 0;
+  retryTimer = null;
+  /** Mốc hết nhường cho engine tự cứu phiên; null = đang không trong pha đó. */
+  recoveryDeadline = null;
+  unsubscribe = null;
+  disposed = false;
+  /** Tăng mỗi lần arm/disarm — huỷ attempt cũ đang chạy dở. */
+  armGeneration = 0;
+  getState() {
+    const engineState = this.engine.getSnapshot().state;
+    let phase;
+    if (!this.armed) phase = "disarmed";
+    else if (engineState === "live") phase = "live";
+    else if (engineState === "standby") phase = "standby";
+    else if (this.retryTimer) phase = "retry_wait";
+    else phase = "arming";
+    return {
+      armed: this.armed,
+      courtRef: this.courtRef,
+      phase,
+      lastError: this.lastError
+    };
+  }
+  /** Khôi phục sau khi app mở lại (reboot giữa giải) — gọi sau engine.initialize(). */
+  async restore() {
+    if (this.disposed || this.armed) return;
+    let saved = null;
+    try {
+      saved = await this.options.storage?.load() ?? null;
+    } catch {
+      return;
+    }
+    if (saved?.courtRef) await this.arm(saved.courtRef);
+  }
+  async arm(courtRef) {
+    if (this.disposed) return;
+    const normalized = courtRef.trim();
+    if (!normalized) throw new Error("courtRef kh\xF4ng \u0111\u01B0\u1EE3c \u0111\u1EC3 tr\u1ED1ng");
+    this.armed = true;
+    this.courtRef = normalized;
+    this.lastError = null;
+    this.retryAttempt = 0;
+    this.armGeneration += 1;
+    this.recoveryDeadline = null;
+    this.clearRetry();
+    try {
+      await this.options.storage?.save({ courtRef: normalized });
+    } catch {
+    }
+    if (!this.unsubscribe) {
+      this.unsubscribe = this.engine.subscribe(() => this.handleEngineChange());
+    }
+    this.emit();
+    await this.ensureStandby();
+  }
+  /**
+   * Tắt chế độ giải đấu. Phiên standby đang chờ được nhả (stop); phiên đang
+   * LIVE là trận do đối tác điều khiển — không cắt, chỉ ngừng re-arm.
+   */
+  async disarm() {
+    this.armed = false;
+    this.courtRef = null;
+    this.armGeneration += 1;
+    this.recoveryDeadline = null;
+    this.clearRetry();
+    try {
+      await this.options.storage?.save(null);
+    } catch {
+    }
+    const snapshot = this.engine.getSnapshot();
+    if (snapshot.sessionId && snapshot.state === "standby") {
+      try {
+        await this.engine.stop("user");
+      } catch {
+      }
+    }
+    this.emit();
+  }
+  dispose() {
+    this.disposed = true;
+    this.armed = false;
+    this.clearRetry();
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+  }
+  emit() {
+    this.options.onStateChange?.(this.getState());
+  }
+  clearRetry() {
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+  }
+  /** Engine còn đang tự cứu CHÍNH phiên này → nhường, đừng cắt để arm phiên mới. */
+  isEngineRecovering(state, sessionId) {
+    if (state !== "error" || !sessionId) return false;
+    const now = (this.options.now ?? Date.now)();
+    if (this.recoveryDeadline === null) {
+      this.recoveryDeadline = now + (this.options.recoveryGraceMs ?? DEFAULT_RECOVERY_GRACE_MS);
+    }
+    return now < this.recoveryDeadline;
+  }
+  scheduleRecoveryCheck() {
+    if (this.retryTimer || this.attemptInFlight || !this.armed) {
+      this.emit();
+      return;
+    }
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.ensureStandby();
+    }, RECOVERY_CHECK_MS);
+    this.emit();
+  }
+  handleEngineChange() {
+    if (!this.armed || this.disposed) return;
+    const snapshot = this.engine.getSnapshot();
+    const state = snapshot.state;
+    if (this.isEngineRecovering(state, snapshot.sessionId)) {
+      this.scheduleRecoveryCheck();
+      return;
+    }
+    if (state === "standby" || state === "live") this.recoveryDeadline = null;
+    if (state === "ended" || state === "idle" || state === "error") {
+      this.scheduleRearm();
+      return;
+    }
+    if (state === "preview" && !snapshot.sessionId && !this.attemptInFlight) {
+      this.scheduleRearm();
+      return;
+    }
+    if (state === "standby" || state === "live") {
+      this.retryAttempt = 0;
+      this.lastError = null;
+    }
+    this.emit();
+  }
+  scheduleRearm() {
+    if (this.retryTimer || this.attemptInFlight || !this.armed) {
+      this.emit();
+      return;
+    }
+    const base = this.options.rearmBaseDelayMs ?? 2e3;
+    const max = this.options.rearmMaxDelayMs ?? 6e4;
+    const delay = Math.min(base * 2 ** this.retryAttempt, max);
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.ensureStandby();
+    }, delay);
+    this.emit();
+  }
+  async ensureStandby() {
+    if (!this.armed || this.disposed || this.attemptInFlight) return;
+    const courtRef = this.courtRef;
+    if (!courtRef) return;
+    const generation = this.armGeneration;
+    const engineState = this.engine.getSnapshot().state;
+    if (engineState === "standby" || engineState === "live") {
+      this.recoveryDeadline = null;
+      return;
+    }
+    if (ACTIVE_ENGINE_STATES.has(engineState)) {
+      this.scheduleRearm();
+      return;
+    }
+    if (this.isEngineRecovering(engineState, this.engine.getSnapshot().sessionId)) {
+      this.scheduleRecoveryCheck();
+      return;
+    }
+    this.attemptInFlight = true;
+    this.emit();
+    let failed = false;
+    try {
+      if (this.engine.getSnapshot().state === "error") {
+        try {
+          await this.engine.stop("error");
+        } catch {
+        }
+      }
+      if (this.engine.getSnapshot().state !== "preview") {
+        await this.engine.prepare();
+      }
+      if (!this.armed || this.armGeneration !== generation) return;
+      const start = this.options.standbyStart;
+      const now = this.options.now ?? Date.now;
+      await this.engine.start(
+        {
+          externalSessionId: `tournament-${courtRef}-${now()}`,
+          title: start.titleFor?.(courtRef) ?? `${courtRef} \u2014 ch\u1EDD tr\u1EADn`,
+          visibility: start.visibility ?? "public",
+          consentVersion: start.consentVersion,
+          metadata: { ...start.metadata, courtRef }
+        },
+        { autoPublish: false }
+      );
+      this.retryAttempt = 0;
+      this.lastError = null;
+    } catch (error) {
+      this.lastError = error instanceof Error ? error.message : String(error);
+      this.retryAttempt += 1;
+      failed = true;
+    } finally {
+      this.attemptInFlight = false;
+    }
+    if (failed && this.armed && this.armGeneration === generation) {
+      this.scheduleRearm();
+    }
+    this.emit();
+  }
+};
+
 // src/device-agent/index.ts
 init_convex_control_channel();
 
+// src/device-agent/convex-beat-transport.ts
+var WS_BEAT_RETRY_MS = 6e4;
+var WS_BEAT_TIMEOUT_MS = 1e4;
+function withConvexBeat(base, realtime, options) {
+  const now = options.now ?? Date.now;
+  const timeoutMs = options.timeoutMs ?? WS_BEAT_TIMEOUT_MS;
+  let wsBrokenUntil = 0;
+  return {
+    register(input) {
+      return base.register(input);
+    },
+    async heartbeat(input) {
+      const deviceToken = options.getDeviceToken();
+      if (!deviceToken || now() < wsBrokenUntil) {
+        return base.heartbeat(input);
+      }
+      try {
+        const data = await withTimeout(
+          realtime.beat({
+            deviceToken,
+            // Server tra máy theo token — bootstrapInput (installationId…) chỉ
+            // đường HTTP cần. Chỉ gửi đúng phần mutation beat nhận.
+            agentState: input.agentState,
+            currentSessionId: input.currentSessionId,
+            ...input.appVersion !== void 0 ? { appVersion: input.appVersion } : {},
+            ...input.metrics !== void 0 ? { metrics: input.metrics } : {},
+            ...input.recentExits !== void 0 && input.recentExits.length > 0 ? { recentExits: input.recentExits } : {},
+            ...input.powerState !== void 0 ? { powerState: input.powerState } : {}
+          }),
+          timeoutMs
+        );
+        options.onData?.("heartbeat", data);
+        return {
+          controlSession: parseControlSession(data.controlSession),
+          ...typeof data.beatIntervalMs === "number" && Number.isFinite(data.beatIntervalMs) ? { beatIntervalMs: data.beatIntervalMs } : {}
+        };
+      } catch {
+        wsBrokenUntil = now() + WS_BEAT_RETRY_MS;
+        return base.heartbeat(input);
+      }
+    }
+  };
+}
+function parseControlSession(grant) {
+  if (grant === null || grant === void 0) return null;
+  if (grant === null || typeof grant !== "object" || typeof grant.id !== "string" || typeof grant.token !== "string" || typeof grant.convexUrl !== "string" || grant.convexUrl === "") {
+    throw new Error("Invalid controlSession in beat response");
+  }
+  const record = grant;
+  return {
+    id: record.id,
+    token: record.token,
+    convexUrl: record.convexUrl
+  };
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("beat timeout")), ms);
+    timer.unref?.();
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+
 // src/device-agent/component.tsx
 import { useEffect, useRef } from "react";
 function PickleballDeviceAgent(props) {
@@ -483,16 +933,495 @@ function PickleballDeviceAgent(props) {
       remoteStart: propsRef.current.remoteStart,
       deviceInfo: propsRef.current.deviceInfo,
       createControlChannel: propsRef.current.createControlChannel,
-      onRemoteSessionStarted: (sessionId) => propsRef.current.onRemoteSessionStarted?.(sessionId)
+      onRemoteSessionStarted: (sessionId) => propsRef.current.onRemoteSessionStarted?.(sessionId),
+      heartbeatExtras: () => propsRef.current.heartbeatExtras?.(),
+      mqttHealth: () => propsRef.current.mqttHealth?.() ?? null
     });
     agent.start();
     return () => agent.stop();
   }, [host]);
   return null;
 }
+
+// src/device-agent/mqtt-codec.ts
+var PACKET = {
+  CONNECT: 1,
+  CONNACK: 2,
+  PUBLISH: 3,
+  PUBACK: 4,
+  SUBSCRIBE: 8,
+  SUBACK: 9,
+  PINGREQ: 12,
+  PINGRESP: 13,
+  DISCONNECT: 14
+};
+var CONNACK_REASON = {
+  0: "ch\u1EA5p nh\u1EADn",
+  1: "sai phi\xEAn b\u1EA3n giao th\u1EE9c",
+  2: "clientId b\u1ECB t\u1EEB ch\u1ED1i",
+  3: "broker kh\xF4ng s\u1EB5n s\xE0ng",
+  4: "sai username/password",
+  5: "kh\xF4ng \u0111\u01B0\u1EE3c ph\xE9p (auth hook t\u1EEB ch\u1ED1i)"
+};
+function utf8Encode(s) {
+  const out = [];
+  for (let i = 0; i < s.length; i++) {
+    let code = s.charCodeAt(i);
+    if (code >= 55296 && code <= 56319 && i + 1 < s.length) {
+      const next = s.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        code = (code - 55296 << 10) + (next - 56320) + 65536;
+        i++;
+      }
+    }
+    if (code < 128) out.push(code);
+    else if (code < 2048) out.push(192 | code >> 6, 128 | code & 63);
+    else if (code < 65536)
+      out.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+    else
+      out.push(
+        240 | code >> 18,
+        128 | code >> 12 & 63,
+        128 | code >> 6 & 63,
+        128 | code & 63
+      );
+  }
+  return Uint8Array.from(out);
+}
+function utf8Decode(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; ) {
+    const b = bytes[i];
+    let code;
+    if (b < 128) {
+      code = b;
+      i += 1;
+    } else if (b < 224) {
+      code = (b & 31) << 6 | bytes[i + 1] & 63;
+      i += 2;
+    } else if (b < 240) {
+      code = (b & 15) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63;
+      i += 3;
+    } else {
+      code = (b & 7) << 18 | (bytes[i + 1] & 63) << 12 | (bytes[i + 2] & 63) << 6 | bytes[i + 3] & 63;
+      i += 4;
+    }
+    if (code > 65535) {
+      code -= 65536;
+      out += String.fromCharCode(55296 + (code >> 10), 56320 + (code & 1023));
+    } else {
+      out += String.fromCharCode(code);
+    }
+  }
+  return out;
+}
+function encodeString(s) {
+  const bytes = utf8Encode(s);
+  if (bytes.length > 65535) throw new Error("Chu\u1ED7i MQTT v\u01B0\u1EE3t 65535 byte");
+  return [bytes.length >> 8, bytes.length & 255, ...bytes];
+}
+function encodeRemainingLength(n) {
+  if (n < 0 || n > 268435455) throw new Error(`\u0110\u1ED9 d\xE0i MQTT kh\xF4ng h\u1EE3p l\u1EC7: ${n}`);
+  const out = [];
+  let value = n;
+  do {
+    let byte = value % 128;
+    value = Math.floor(value / 128);
+    if (value > 0) byte |= 128;
+    out.push(byte);
+  } while (value > 0);
+  return out;
+}
+function decodeRemainingLength(bytes, offset) {
+  let multiplier = 1;
+  let value = 0;
+  for (let i = 0; i < 4; i++) {
+    const idx = offset + i;
+    if (idx >= bytes.length) return null;
+    const byte = bytes[idx];
+    value += (byte & 127) * multiplier;
+    if ((byte & 128) === 0) return { value, bytesUsed: i + 1 };
+    multiplier *= 128;
+  }
+  throw new Error("Remaining Length h\u1ECFng (qu\xE1 4 byte)");
+}
+function frame(type, flags, body) {
+  return Uint8Array.from([
+    type << 4 | flags,
+    ...encodeRemainingLength(body.length),
+    ...body
+  ]);
+}
+function encodeConnect(o) {
+  let flags = 0;
+  if (o.cleanSession) flags |= 2;
+  if (o.will) {
+    flags |= 4;
+    flags |= (o.will.qos & 3) << 3;
+    if (o.will.retain) flags |= 32;
+  }
+  if (o.password !== void 0) flags |= 64;
+  if (o.username !== void 0) flags |= 128;
+  const body = [
+    ...encodeString("MQTT"),
+    4,
+    // protocol level 4 = MQTT 3.1.1
+    flags,
+    o.keepaliveS >> 8 & 255,
+    o.keepaliveS & 255,
+    ...encodeString(o.clientId)
+  ];
+  if (o.will) {
+    body.push(...encodeString(o.will.topic));
+    const payload = utf8Encode(o.will.payload);
+    body.push(payload.length >> 8, payload.length & 255, ...payload);
+  }
+  if (o.username !== void 0) body.push(...encodeString(o.username));
+  if (o.password !== void 0) body.push(...encodeString(o.password));
+  return frame(PACKET.CONNECT, 0, body);
+}
+function encodeSubscribe(packetId, filters) {
+  const body = [packetId >> 8, packetId & 255];
+  for (const f of filters) {
+    body.push(...encodeString(f.topic), f.qos);
+  }
+  return frame(PACKET.SUBSCRIBE, 2, body);
+}
+function encodePublish(o) {
+  let flags = 0;
+  if (o.retain) flags |= 1;
+  flags |= (o.qos & 3) << 1;
+  const body = [...encodeString(o.topic)];
+  if (o.qos > 0) {
+    if (o.packetId === void 0) throw new Error("PUBLISH QoS1 thi\u1EBFu packetId");
+    body.push(o.packetId >> 8, o.packetId & 255);
+  }
+  body.push(...utf8Encode(o.payload));
+  return frame(PACKET.PUBLISH, flags, body);
+}
+function encodePuback(packetId) {
+  return frame(PACKET.PUBACK, 0, [packetId >> 8, packetId & 255]);
+}
+function encodePingReq() {
+  return frame(PACKET.PINGREQ, 0, []);
+}
+function encodeDisconnect() {
+  return frame(PACKET.DISCONNECT, 0, []);
+}
+function decodePackets(buffer) {
+  const packets = [];
+  let offset = 0;
+  for (; ; ) {
+    if (offset >= buffer.length) break;
+    const header = buffer[offset];
+    const len = decodeRemainingLength(buffer, offset + 1);
+    if (!len) break;
+    const start = offset + 1 + len.bytesUsed;
+    const end = start + len.value;
+    if (end > buffer.length) break;
+    const type = header >> 4;
+    const flags = header & 15;
+    const body = buffer.subarray(start, end);
+    packets.push(decodeBody(type, flags, body));
+    offset = end;
+  }
+  return { packets, rest: buffer.subarray(offset) };
+}
+function readString(body, offset) {
+  const len = body[offset] << 8 | body[offset + 1];
+  const start = offset + 2;
+  return { value: utf8Decode(body.subarray(start, start + len)), next: start + len };
+}
+function decodeBody(type, flags, body) {
+  switch (type) {
+    case PACKET.CONNACK:
+      return {
+        type: "connack",
+        sessionPresent: (body[0] & 1) === 1,
+        returnCode: body[1] ?? 0
+      };
+    case PACKET.SUBACK:
+      return {
+        type: "suback",
+        packetId: body[0] << 8 | body[1],
+        codes: Array.from(body.subarray(2))
+      };
+    case PACKET.PUBLISH: {
+      const qos = flags >> 1 & 3;
+      const topic = readString(body, 0);
+      let next = topic.next;
+      let packetId;
+      if (qos > 0) {
+        packetId = body[next] << 8 | body[next + 1];
+        next += 2;
+      }
+      return {
+        type: "publish",
+        topic: topic.value,
+        payload: utf8Decode(body.subarray(next)),
+        qos,
+        retain: (flags & 1) === 1,
+        ...packetId !== void 0 ? { packetId } : {}
+      };
+    }
+    case PACKET.PUBACK:
+      return { type: "puback", packetId: body[0] << 8 | body[1] };
+    case PACKET.PINGRESP:
+      return { type: "pingresp" };
+    default:
+      return { type: "other", packetType: type };
+  }
+}
+
+// src/device-agent/mqtt-channel.ts
+var AUTH_RETRY_MS = 5 * 6e4;
+function createMqttChannel(o, deps = {}) {
+  const createSocket = deps.createSocket ?? ((url, protocols) => new WebSocket(url, protocols));
+  const setTimer = deps.setTimeout ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimer = deps.clearTimeout ?? ((h) => clearTimeout(h));
+  const now = deps.now ?? (() => Date.now());
+  const random = deps.random ?? Math.random;
+  let socket = null;
+  let buffer = new Uint8Array(0);
+  let connected = false;
+  let stopped = true;
+  let attempt = 0;
+  let packetId = 0;
+  let reconnectTimer = null;
+  let pingTimer = null;
+  let lastInboundAt = 0;
+  let subscribed = false;
+  let healthySince = 0;
+  const nextPacketId = () => {
+    packetId = packetId % 65535 + 1;
+    return packetId;
+  };
+  const setConnected = (value) => {
+    if (connected === value) return;
+    connected = value;
+    o.onConnectionChange?.(value);
+  };
+  const clearTimers = () => {
+    if (reconnectTimer !== null) {
+      clearTimer(reconnectTimer);
+      reconnectTimer = null;
+    }
+    if (pingTimer !== null) {
+      clearTimer(pingTimer);
+      pingTimer = null;
+    }
+  };
+  const send = (bytes) => {
+    if (!socket) return false;
+    try {
+      socket.send(bytes);
+      return true;
+    } catch {
+      teardown(true);
+      return false;
+    }
+  };
+  const scheduleReconnect = (delayMs) => {
+    if (stopped || reconnectTimer !== null) return;
+    const base = delayMs ?? o.reconnectDelaysMs[Math.min(attempt, o.reconnectDelaysMs.length - 1)] ?? 3e4;
+    const jitter = base === 0 ? 0 : base * 0.2 * (random() * 2 - 1);
+    attempt += 1;
+    reconnectTimer = setTimer(() => {
+      reconnectTimer = null;
+      open();
+    }, Math.max(0, Math.round(base + jitter)));
+  };
+  const teardown = (reconnect, delayMs) => {
+    clearTimers();
+    setConnected(false);
+    subscribed = false;
+    healthySince = 0;
+    buffer = new Uint8Array(0);
+    const dead = socket;
+    socket = null;
+    if (dead) {
+      dead.onopen = null;
+      dead.onmessage = null;
+      dead.onerror = null;
+      dead.onclose = null;
+      try {
+        dead.close();
+      } catch {
+      }
+    }
+    if (reconnect) scheduleReconnect(delayMs);
+  };
+  const armPing = () => {
+    if (pingTimer !== null) clearTimer(pingTimer);
+    pingTimer = setTimer(() => {
+      pingTimer = null;
+      if (!socket) return;
+      if (now() - lastInboundAt > o.keepaliveS * 1500) {
+        teardown(true);
+        return;
+      }
+      send(encodePingReq());
+      armPing();
+    }, Math.max(1e3, Math.round(o.keepaliveS * 750)));
+  };
+  const handlePacket = (p) => {
+    switch (p.type) {
+      case "connack": {
+        if (p.returnCode !== 0) {
+          const reason = CONNACK_REASON[p.returnCode] ?? `m\xE3 ${p.returnCode}`;
+          o.onAuthRejected?.(reason);
+          teardown(true, p.returnCode === 4 || p.returnCode === 5 ? AUTH_RETRY_MS : void 0);
+          return;
+        }
+        attempt = 0;
+        setConnected(true);
+        send(
+          encodePublish({
+            topic: o.topics.status,
+            payload: o.statusPayload(true),
+            qos: 1,
+            retain: true,
+            packetId: nextPacketId()
+          })
+        );
+        send(
+          encodeSubscribe(nextPacketId(), [
+            { topic: o.topics.cmd, qos: 1 },
+            { topic: o.topics.cfg, qos: 1 },
+            // Tỉ số trận đang ghi (retained) — reconnect là nhận ngay bản mới nhất.
+            { topic: o.topics.score, qos: 1 }
+          ])
+        );
+        armPing();
+        return;
+      }
+      case "suback": {
+        if (p.codes.every((c) => c < 128)) {
+          subscribed = true;
+          if (healthySince === 0) healthySince = now();
+        }
+        return;
+      }
+      case "publish": {
+        if (p.qos === 1 && p.packetId !== void 0) send(encodePuback(p.packetId));
+        o.onMessage?.(p.topic, p.payload);
+        return;
+      }
+      default:
+        return;
+    }
+  };
+  const open = () => {
+    if (stopped || socket) return;
+    let s;
+    try {
+      s = createSocket(o.url, ["mqtt"]);
+    } catch {
+      scheduleReconnect();
+      return;
+    }
+    socket = s;
+    s.binaryType = "arraybuffer";
+    lastInboundAt = now();
+    s.onopen = () => {
+      if (socket !== s) return;
+      send(
+        encodeConnect({
+          clientId: o.deviceId,
+          username: o.deviceId,
+          password: o.deviceToken,
+          keepaliveS: o.keepaliveS,
+          cleanSession: true,
+          will: {
+            topic: o.topics.status,
+            payload: o.statusPayload(false),
+            qos: 1,
+            retain: true
+          }
+        })
+      );
+    };
+    s.onmessage = (event) => {
+      if (socket !== s) return;
+      const data = event.data;
+      let chunk = null;
+      if (data instanceof ArrayBuffer) {
+        chunk = new Uint8Array(data);
+      } else if (ArrayBuffer.isView(data)) {
+        chunk = Uint8Array.from(data);
+      }
+      if (!chunk) return;
+      lastInboundAt = now();
+      const merged = new Uint8Array(buffer.length + chunk.length);
+      merged.set(buffer, 0);
+      merged.set(chunk, buffer.length);
+      const { packets, rest } = decodePackets(merged);
+      buffer = Uint8Array.from(rest);
+      for (const p of packets) handlePacket(p);
+    };
+    s.onerror = () => {
+      if (socket !== s) return;
+      teardown(true);
+    };
+    s.onclose = () => {
+      if (socket !== s) return;
+      teardown(true);
+    };
+  };
+  return {
+    start() {
+      if (!stopped) return;
+      stopped = false;
+      attempt = 0;
+      open();
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      if (socket && connected) {
+        send(
+          encodePublish({
+            topic: o.topics.status,
+            payload: o.statusPayload(false),
+            qos: 1,
+            retain: true,
+            packetId: nextPacketId()
+          })
+        );
+        send(encodeDisconnect());
+      }
+      teardown(false);
+    },
+    isConnected: () => connected,
+    health: () => ({ connected, subscribed, lastInboundAt, healthySince }),
+    publish(topic, payload, opts) {
+      if (!connected) return false;
+      const qos = opts?.qos ?? 0;
+      return send(
+        encodePublish({
+          topic,
+          payload,
+          qos,
+          retain: opts?.retain ?? false,
+          ...qos === 1 ? { packetId: nextPacketId() } : {}
+        })
+      );
+    }
+  };
+}
 export {
+  BEAT_FAST_MS,
+  BEAT_SLOW_MS,
   DeviceAgent,
   PickleballDeviceAgent,
+  TournamentController,
+  createConvexCommandSubscription,
   createConvexControlChannel,
-  createHttpDeviceAgentTransport
+  createConvexDeviceRealtime,
+  createHttpDeviceAgentTransport,
+  createMqttChannel,
+  metricsCrossedThreshold,
+  mqttBeatHealthy,
+  nextBeatDelayMs,
+  withConvexBeat
 };