@pickleball/expo-sdk 0.2.0 → 1.0.0

package/dist/device-agent/index.cjs

@@ -1,13 +1,17 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunk6YE5BL3Acjs = require('../chunk-6YE5BL3A.cjs');
 
 
 
 
 
 
-var _chunkTBPR2QNDcjs = require('../chunk-TBPR2QND.cjs');
+
+
+
+var _chunkIUIRVKJIcjs = require('../chunk-IUIRVKJI.cjs');
 
 
 
@@ -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 = _chunk7OX2DSKIcjs.__esm.call(void 0, {
   }
 });
 
+// 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 = _nullishCoalesce(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 } = _chunk7OX2DSKIcjs.__require.call(void 0, "react-native");
@@ -121,23 +150,44 @@ 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 = class {
   
   __init() {this.running = false}
   __init2() {this.registered = false}
   __init3() {this.foreground = true}
   __init4() {this.heartbeatIntervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS}
+  /** Nhịp server gợi ý ở beat gần nhất — undefined = server chưa nói gì → 12s. */
+  
   __init5() {this.timer = null}
   __init6() {this.beatInFlight = false}
   __init7() {this.registerAttempt = 0}
   __init8() {this.unsubscribeAppState = null}
   __init9() {this.heartbeatFailures = 0}
-  __init10() {this.controlChannel = null}
-  __init11() {this.controlSessionId = null}
-  __init12() {this.controlUnsubscribers = []}
-  __init13() {this.executing = false}
-  __init14() {this.handledCommandIds = /* @__PURE__ */ new Set()}
-  constructor(options) {;_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);
+  /** Metrics đã gửi lần gần nhất + mốc thời gian, để lọc "chỉ gửi khi đổi". */
+  
+  __init10() {this.lastMetricsSentAt = 0}
+  __init11() {this.controlChannel = null}
+  __init12() {this.controlSessionId = null}
+  __init13() {this.controlUnsubscribers = []}
+  __init14() {this.executing = false}
+  __init15() {this.handledCommandIds = /* @__PURE__ */ new Set()}
+  constructor(options) {;_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);
     this.options = options;
   }
   start() {
@@ -167,6 +217,28 @@ var DeviceAgent = (_class = 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 _nullishCoalesce(_optionalChain([this, 'access', _3 => _3.options, 'access', _4 => _4.mqttHealth, 'optionalCall', _5 => _5()]), () => ( null));
+      } catch (e) {
+        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 = class {
         if (!this.registered) return;
       }
       await this.heartbeat();
-      this.schedule(this.heartbeatIntervalMs);
+      this.schedule(this.nextBeatDelay());
     } finally {
       this.beatInFlight = false;
     }
@@ -199,7 +271,7 @@ var DeviceAgent = (_class = class {
       }
       this.registered = true;
       this.registerAttempt = 0;
-    } catch (e) {
+    } catch (e2) {
       const delay = Math.min(
         REGISTER_RETRY_BASE_MS * 2 ** this.registerAttempt,
         REGISTER_RETRY_MAX_MS
@@ -208,24 +280,51 @@ var DeviceAgent = (_class = 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;
     try {
-      metrics = pickMetrics(await _asyncNullishCoalesce(await _optionalChain([this, 'access', _3 => _3.options, 'access', _4 => _4.deviceMetrics, 'optionalCall', _5 => _5()]), async () => ( null)));
-    } catch (e2) {
+      metrics = pickMetrics(await _asyncNullishCoalesce(await _optionalChain([this, 'access', _6 => _6.options, 'access', _7 => _7.deviceMetrics, 'optionalCall', _8 => _8()]), async () => ( null)));
+    } catch (e3) {
       metrics = void 0;
     }
+    const metricsToSend = this.selectMetricsForHeartbeat(metrics);
+    let extras = {};
+    try {
+      extras = _nullishCoalesce(_optionalChain([this, 'access', _9 => _9.options, 'access', _10 => _10.heartbeatExtras, 'optionalCall', _11 => _11()]), () => ( {}));
+    } catch (e4) {
+      extras = {};
+    }
     let result;
     try {
       result = await this.options.transport.heartbeat({
         ...this.options.bootstrapInput,
         agentState: snapshot.state,
         currentSessionId: snapshot.sessionId,
-        ..._optionalChain([this, 'access', _6 => _6.options, 'access', _7 => _7.deviceInfo, 'optionalAccess', _8 => _8.appVersion]) ? { appVersion: this.options.deviceInfo.appVersion } : {},
-        ...metrics ? { metrics } : {}
+        ..._optionalChain([this, 'access', _12 => _12.options, 'access', _13 => _13.deviceInfo, 'optionalAccess', _14 => _14.appVersion]) ? { appVersion: this.options.deviceInfo.appVersion } : {},
+        ...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 (e3) {
+    } catch (e5) {
       this.heartbeatFailures += 1;
       if (this.heartbeatFailures >= 3) {
         this.registered = false;
@@ -234,6 +333,7 @@ var DeviceAgent = (_class = 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);
     }
@@ -244,7 +344,7 @@ var DeviceAgent = (_class = class {
       channel = (_nullishCoalesce(this.options.createControlChannel, () => ( defaultCreateControlChannel)))(
         grant.convexUrl
       );
-    } catch (e4) {
+    } catch (e6) {
       return;
     }
     this.controlChannel = channel;
@@ -269,13 +369,13 @@ var DeviceAgent = (_class = class {
     for (const unsubscribe of this.controlUnsubscribers) {
       try {
         unsubscribe();
-      } catch (e5) {
+      } catch (e7) {
       }
     }
     this.controlUnsubscribers = [];
     try {
-      _optionalChain([this, 'access', _9 => _9.controlChannel, 'optionalAccess', _10 => _10.close, 'call', _11 => _11()]);
-    } catch (e6) {
+      _optionalChain([this, 'access', _15 => _15.controlChannel, 'optionalAccess', _16 => _16.close, 'call', _17 => _17()]);
+    } catch (e8) {
     }
     this.controlChannel = null;
     this.controlSessionId = null;
@@ -316,7 +416,13 @@ var DeviceAgent = (_class = class {
           void 0,
           _nullishCoalesce(sessionId, () => ( void 0))
         );
-        if (sessionId) _optionalChain([this, 'access', _12 => _12.options, 'access', _13 => _13.onRemoteSessionStarted, 'optionalCall', _14 => _14(sessionId)]);
+        if (sessionId) _optionalChain([this, 'access', _18 => _18.options, 'access', _19 => _19.onRemoteSessionStarted, 'optionalCall', _20 => _20(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");
@@ -327,7 +433,7 @@ var DeviceAgent = (_class = class {
         grant,
         command.id,
         "failed",
-        _chunkTBPR2QNDcjs.normalizeError.call(void 0, error).message
+        _chunkIUIRVKJIcjs.normalizeError.call(void 0, error).message
       );
     }
   }
@@ -341,13 +447,19 @@ var DeviceAgent = (_class = class {
       await engine.prepare();
     }
     const remote = this.options.remoteStart;
+    const courtRef = _optionalChain([command, 'access', _21 => _21.payload, 'access', _22 => _22.courtRef, 'optionalAccess', _23 => _23.trim, 'call', _24 => _24()]);
     await engine.start(
       {
         externalSessionId: `remote-${command.id}`,
-        title: _optionalChain([command, 'access', _15 => _15.payload, 'access', _16 => _16.title, 'optionalAccess', _17 => _17.trim, 'call', _18 => _18()]) || remote.defaultTitle || "Livestream",
+        title: _optionalChain([command, 'access', _25 => _25.payload, 'access', _26 => _26.title, 'optionalAccess', _27 => _27.trim, 'call', _28 => _28()]) || remote.defaultTitle || "Livestream",
         visibility: _nullishCoalesce(_nullishCoalesce(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 = 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 = _optionalChain([engine, 'access', _29 => _29.getSnapshot, 'call', _30 => _30(), 'access', _31 => _31.error, 'optionalAccess', _32 => _32.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({
@@ -369,7 +511,7 @@ var DeviceAgent = (_class = class {
         ...errorMessage !== void 0 ? { errorMessage } : {},
         ...resultSessionId !== void 0 ? { resultSessionId } : {}
       });
-    } catch (e7) {
+    } catch (e9) {
     }
   }
 }, _class);
@@ -382,11 +524,11 @@ var defaultPaths = {
 function createHttpDeviceAgentTransport(options) {
   const baseUrl = options.baseUrl.replace(/\/+$/, "");
   if (baseUrl === "") {
-    throw new (0, _chunkTBPR2QNDcjs.ExpoSdkConfigurationError)("baseUrl must be a non-empty string");
+    throw new (0, _chunkIUIRVKJIcjs.ExpoSdkConfigurationError)("baseUrl must be a non-empty string");
   }
   const fetchImplementation = _nullishCoalesce(options.fetch, () => ( globalThis.fetch));
   if (typeof fetchImplementation !== "function") {
-    throw new (0, _chunkTBPR2QNDcjs.ExpoSdkConfigurationError)("A Fetch API implementation is required");
+    throw new (0, _chunkIUIRVKJIcjs.ExpoSdkConfigurationError)("A Fetch API implementation is required");
   }
   const paths = { ...defaultPaths, ...options.paths };
   async function post(path, body) {
@@ -405,18 +547,18 @@ function createHttpDeviceAgentTransport(options) {
         }
       );
       const envelope = await response.json().catch(() => {
-        throw new (0, _chunkTBPR2QNDcjs.InvalidResponseError)();
+        throw new (0, _chunkIUIRVKJIcjs.InvalidResponseError)();
       });
       if (!response.ok) throw parseProxyError(envelope);
       if (!isRecord(envelope) || !("data" in envelope)) {
-        throw new (0, _chunkTBPR2QNDcjs.InvalidResponseError)();
+        throw new (0, _chunkIUIRVKJIcjs.InvalidResponseError)();
       }
       return envelope.data;
     } catch (error) {
-      if (controller.signal.aborted) throw new (0, _chunkTBPR2QNDcjs.ExpoSdkTimeoutError)();
-      if (error instanceof _chunkTBPR2QNDcjs.PickleballExpoError) throw error;
+      if (controller.signal.aborted) throw new (0, _chunkIUIRVKJIcjs.ExpoSdkTimeoutError)();
+      if (error instanceof _chunkIUIRVKJIcjs.PickleballExpoError) throw error;
       if (error instanceof TypeError) {
-        throw new (0, _chunkTBPR2QNDcjs.NetworkUnavailableError)(void 0, { cause: error });
+        throw new (0, _chunkIUIRVKJIcjs.NetworkUnavailableError)(void 0, { cause: error });
       }
       throw error;
     } finally {
@@ -427,8 +569,9 @@ function createHttpDeviceAgentTransport(options) {
     async register(input) {
       const data = await post(paths.register, input);
       if (!isRecord(data) || typeof data.deviceId !== "string" || typeof data.heartbeatIntervalMs !== "number" || !Number.isFinite(data.heartbeatIntervalMs)) {
-        throw new (0, _chunkTBPR2QNDcjs.InvalidResponseError)();
+        throw new (0, _chunkIUIRVKJIcjs.InvalidResponseError)();
       }
+      _optionalChain([options, 'access', _33 => _33.onData, 'optionalCall', _34 => _34("register", data)]);
       return {
         deviceId: data.deviceId,
         heartbeatIntervalMs: data.heartbeatIntervalMs
@@ -436,42 +579,349 @@ function createHttpDeviceAgentTransport(options) {
     },
     async heartbeat(input) {
       const data = await post(paths.heartbeat, input);
-      if (!isRecord(data)) throw new (0, _chunkTBPR2QNDcjs.InvalidResponseError)();
+      if (!isRecord(data)) throw new (0, _chunkIUIRVKJIcjs.InvalidResponseError)();
+      _optionalChain([options, 'access', _35 => _35.onData, 'optionalCall', _36 => _36("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 (0, _chunkTBPR2QNDcjs.InvalidResponseError)();
+        throw new (0, _chunkIUIRVKJIcjs.InvalidResponseError)();
       }
       return {
         controlSession: {
           id: grant.id,
           token: grant.token,
           convexUrl: grant.convexUrl
-        }
+        },
+        ...beatIntervalMs
       };
     }
   };
 }
 function parseProxyError(envelope) {
   if (isRecord(envelope) && isRecord(envelope.error) && typeof envelope.error.code === "string") {
-    return _chunkTBPR2QNDcjs.errorFromCode.call(void 0, 
+    return _chunkIUIRVKJIcjs.errorFromCode.call(void 0, 
       envelope.error.code,
       typeof envelope.error.message === "string" ? envelope.error.message : void 0
     );
   }
-  return new (0, _chunkTBPR2QNDcjs.InvalidResponseError)();
+  return new (0, _chunkIUIRVKJIcjs.InvalidResponseError)();
 }
 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 = (_class2 = class {
+  constructor(options) {;_class2.prototype.__init16.call(this);_class2.prototype.__init17.call(this);_class2.prototype.__init18.call(this);_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);
+    this.options = options;
+    this.engine = options.engine;
+  }
+  
+  __init16() {this.armed = false}
+  __init17() {this.courtRef = null}
+  __init18() {this.lastError = null}
+  __init19() {this.attemptInFlight = false}
+  __init20() {this.retryAttempt = 0}
+  __init21() {this.retryTimer = null}
+  /** Mốc hết nhường cho engine tự cứu phiên; null = đang không trong pha đó. */
+  __init22() {this.recoveryDeadline = null}
+  __init23() {this.unsubscribe = null}
+  __init24() {this.disposed = false}
+  /** Tăng mỗi lần arm/disarm — huỷ attempt cũ đang chạy dở. */
+  __init25() {this.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 _asyncNullishCoalesce(await _optionalChain([this, 'access', _37 => _37.options, 'access', _38 => _38.storage, 'optionalAccess', _39 => _39.load, 'call', _40 => _40()]), async () => ( null));
+    } catch (e10) {
+      return;
+    }
+    if (_optionalChain([saved, 'optionalAccess', _41 => _41.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 _optionalChain([this, 'access', _42 => _42.options, 'access', _43 => _43.storage, 'optionalAccess', _44 => _44.save, 'call', _45 => _45({ courtRef: normalized })]);
+    } catch (e11) {
+    }
+    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 _optionalChain([this, 'access', _46 => _46.options, 'access', _47 => _47.storage, 'optionalAccess', _48 => _48.save, 'call', _49 => _49(null)]);
+    } catch (e12) {
+    }
+    const snapshot = this.engine.getSnapshot();
+    if (snapshot.sessionId && snapshot.state === "standby") {
+      try {
+        await this.engine.stop("user");
+      } catch (e13) {
+      }
+    }
+    this.emit();
+  }
+  dispose() {
+    this.disposed = true;
+    this.armed = false;
+    this.clearRetry();
+    _optionalChain([this, 'access', _50 => _50.unsubscribe, 'optionalCall', _51 => _51()]);
+    this.unsubscribe = null;
+  }
+  emit() {
+    _optionalChain([this, 'access', _52 => _52.options, 'access', _53 => _53.onStateChange, 'optionalCall', _54 => _54(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 = (_nullishCoalesce(this.options.now, () => ( Date.now)))();
+    if (this.recoveryDeadline === null) {
+      this.recoveryDeadline = now + (_nullishCoalesce(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 = _nullishCoalesce(this.options.rearmBaseDelayMs, () => ( 2e3));
+    const max = _nullishCoalesce(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 (e14) {
+        }
+      }
+      if (this.engine.getSnapshot().state !== "preview") {
+        await this.engine.prepare();
+      }
+      if (!this.armed || this.armGeneration !== generation) return;
+      const start = this.options.standbyStart;
+      const now = _nullishCoalesce(this.options.now, () => ( Date.now));
+      await this.engine.start(
+        {
+          externalSessionId: `tournament-${courtRef}-${now()}`,
+          title: _nullishCoalesce(_optionalChain([start, 'access', _55 => _55.titleFor, 'optionalCall', _56 => _56(courtRef)]), () => ( `${courtRef} \u2014 ch\u1EDD tr\u1EADn`)),
+          visibility: _nullishCoalesce(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();
+  }
+}, _class2);
+
 // 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 = _nullishCoalesce(options.now, () => ( Date.now));
+  const timeoutMs = _nullishCoalesce(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
+        );
+        _optionalChain([options, 'access', _57 => _57.onData, 'optionalCall', _58 => _58("heartbeat", data)]);
+        return {
+          controlSession: parseControlSession(data.controlSession),
+          ...typeof data.beatIntervalMs === "number" && Number.isFinite(data.beatIntervalMs) ? { beatIntervalMs: data.beatIntervalMs } : {}
+        };
+      } catch (e15) {
+        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);
+    _optionalChain([timer, 'access', _59 => _59.unref, 'optionalCall', _60 => _60()]);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+
 // src/device-agent/component.tsx
 var _react = require('react');
 function PickleballDeviceAgent(props) {
-  const host = _chunkTBPR2QNDcjs.useLivestreamHost.call(void 0, );
+  const host = _chunkIUIRVKJIcjs.useLivestreamHost.call(void 0, );
   const propsRef = _react.useRef.call(void 0, props);
   propsRef.current = props;
   _react.useEffect.call(void 0, () => {
@@ -483,7 +933,9 @@ function PickleballDeviceAgent(props) {
       remoteStart: propsRef.current.remoteStart,
       deviceInfo: propsRef.current.deviceInfo,
       createControlChannel: propsRef.current.createControlChannel,
-      onRemoteSessionStarted: (sessionId) => _optionalChain([propsRef, 'access', _19 => _19.current, 'access', _20 => _20.onRemoteSessionStarted, 'optionalCall', _21 => _21(sessionId)])
+      onRemoteSessionStarted: (sessionId) => _optionalChain([propsRef, 'access', _61 => _61.current, 'access', _62 => _62.onRemoteSessionStarted, 'optionalCall', _63 => _63(sessionId)]),
+      heartbeatExtras: () => _optionalChain([propsRef, 'access', _64 => _64.current, 'access', _65 => _65.heartbeatExtras, 'optionalCall', _66 => _66()]),
+      mqttHealth: () => _nullishCoalesce(_optionalChain([propsRef, 'access', _67 => _67.current, 'access', _68 => _68.mqttHealth, 'optionalCall', _69 => _69()]), () => ( null))
     });
     agent.start();
     return () => agent.stop();
@@ -491,8 +943,485 @@ function PickleballDeviceAgent(props) {
   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: _nullishCoalesce(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 = _nullishCoalesce(deps.createSocket, () => ( ((url, protocols) => new WebSocket(url, protocols))));
+  const setTimer = _nullishCoalesce(deps.setTimeout, () => ( ((fn, ms) => setTimeout(fn, ms))));
+  const clearTimer = _nullishCoalesce(deps.clearTimeout, () => ( ((h) => clearTimeout(h))));
+  const now = _nullishCoalesce(deps.now, () => ( (() => Date.now())));
+  const random = _nullishCoalesce(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;
+    _optionalChain([o, 'access', _70 => _70.onConnectionChange, 'optionalCall', _71 => _71(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 (e16) {
+      teardown(true);
+      return false;
+    }
+  };
+  const scheduleReconnect = (delayMs) => {
+    if (stopped || reconnectTimer !== null) return;
+    const base = _nullishCoalesce(_nullishCoalesce(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 (e17) {
+      }
+    }
+    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 = _nullishCoalesce(CONNACK_REASON[p.returnCode], () => ( `m\xE3 ${p.returnCode}`));
+          _optionalChain([o, 'access', _72 => _72.onAuthRejected, 'optionalCall', _73 => _73(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));
+        _optionalChain([o, 'access', _74 => _74.onMessage, 'optionalCall', _75 => _75(p.topic, p.payload)]);
+        return;
+      }
+      default:
+        return;
+    }
+  };
+  const open = () => {
+    if (stopped || socket) return;
+    let s;
+    try {
+      s = createSocket(o.url, ["mqtt"]);
+    } catch (e18) {
+      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 = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _76 => _76.qos]), () => ( 0));
+      return send(
+        encodePublish({
+          topic,
+          payload,
+          qos,
+          retain: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _77 => _77.retain]), () => ( false)),
+          ...qos === 1 ? { packetId: nextPacketId() } : {}
+        })
+      );
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
 
 
 
 
-exports.DeviceAgent = DeviceAgent; exports.PickleballDeviceAgent = PickleballDeviceAgent; exports.createConvexControlChannel = createConvexControlChannel; exports.createHttpDeviceAgentTransport = createHttpDeviceAgentTransport;
+exports.BEAT_FAST_MS = BEAT_FAST_MS; exports.BEAT_SLOW_MS = BEAT_SLOW_MS; exports.DeviceAgent = DeviceAgent; exports.PickleballDeviceAgent = PickleballDeviceAgent; exports.TournamentController = TournamentController; exports.createConvexCommandSubscription = _chunk6YE5BL3Acjs.createConvexCommandSubscription; exports.createConvexControlChannel = createConvexControlChannel; exports.createConvexDeviceRealtime = _chunk6YE5BL3Acjs.createConvexDeviceRealtime; exports.createHttpDeviceAgentTransport = createHttpDeviceAgentTransport; exports.createMqttChannel = createMqttChannel; exports.metricsCrossedThreshold = metricsCrossedThreshold; exports.mqttBeatHealthy = mqttBeatHealthy; exports.nextBeatDelayMs = nextBeatDelayMs; exports.withConvexBeat = withConvexBeat;