@pickleball/expo-sdk 0.1.1 → 1.0.0

package/dist/device-agent/index.js

@@ -0,0 +1,1427 @@
+import {
+  createConvexCommandSubscription,
+  createConvexDeviceRealtime
+} from "../chunk-6F3HN6US.js";
+import {
+  ExpoSdkConfigurationError,
+  ExpoSdkTimeoutError,
+  InvalidResponseError,
+  NetworkUnavailableError,
+  PickleballExpoError,
+  errorFromCode,
+  normalizeError,
+  useLivestreamHost
+} from "../chunk-XGP2MN5R.js";
+import {
+  __esm,
+  __export,
+  __require,
+  __toCommonJS
+} from "../chunk-KFQGP6VL.js";
+
+// src/device-agent/convex-control-channel.ts
+var convex_control_channel_exports = {};
+__export(convex_control_channel_exports, {
+  createConvexControlChannel: () => createConvexControlChannel
+});
+import { ConvexClient } from "convex/browser";
+import { anyApi } from "convex/server";
+function createConvexControlChannel(convexUrl) {
+  const client = new ConvexClient(convexUrl);
+  const deviceControl = anyApi.deviceControl;
+  function toCommands(value) {
+    if (!Array.isArray(value)) return [];
+    const commands = [];
+    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" && 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 : {};
+      commands.push({
+        id: record.id,
+        type: record.type,
+        payload: {
+          ...typeof payload.title === "string" ? { title: payload.title } : {},
+          ...payload.visibility === "public" || payload.visibility === "private" ? { visibility: payload.visibility } : {},
+          ...typeof payload.courtRef === "string" && payload.courtRef.trim() !== "" ? { courtRef: payload.courtRef } : {}
+        },
+        expiresAt: record.expiresAt
+      });
+    }
+    return commands;
+  }
+  return {
+    async attach(controlSessionId, token) {
+      await client.mutation(deviceControl.deviceAttach, { controlSessionId, token });
+    },
+    onCommands(controlSessionId, token, callback) {
+      return client.onUpdate(
+        deviceControl.pendingCommands,
+        { controlSessionId, token },
+        (value) => callback(toCommands(value))
+      );
+    },
+    onState(controlSessionId, token, callback) {
+      return client.onUpdate(
+        deviceControl.controlSessionState,
+        { controlSessionId, token },
+        (value) => {
+          const status = value !== null && typeof value === "object" && typeof value.status === "string" ? value.status : "ended";
+          callback({ status });
+        }
+      );
+    },
+    async ack(input) {
+      await client.mutation(deviceControl.ackCommand, { ...input });
+    },
+    close() {
+      void client.close();
+    }
+  };
+}
+var init_convex_control_channel = __esm({
+  "src/device-agent/convex-control-channel.ts"() {
+    "use strict";
+  }
+});
+
+// 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",
+  "storageFreeGb",
+  "batteryPct",
+  "batteryTempC",
+  "thermal",
+  "netType",
+  "linkMbps",
+  "rssi",
+  "connQuality",
+  "signalPct",
+  "localIp"
+];
+function defaultSubscribeAppState(listener) {
+  const { AppState } = __require("react-native");
+  const subscription = AppState.addEventListener("change", (state) => {
+    listener(
+      state === "active" ? "active" : state === "background" ? "background" : "inactive"
+    );
+  });
+  return () => subscription.remove();
+}
+function defaultCreateControlChannel(convexUrl) {
+  const { createConvexControlChannel: createConvexControlChannel2 } = (init_convex_control_channel(), __toCommonJS(convex_control_channel_exports));
+  return createConvexControlChannel2(convexUrl);
+}
+function pickMetrics(sample) {
+  if (!sample) return void 0;
+  const metrics = {};
+  for (const field of METRIC_FIELDS) {
+    const value = sample[field];
+    if (typeof value === "number" && Number.isFinite(value)) metrics[field] = value;
+    else if (typeof value === "string" && value.trim() !== "") metrics[field] = value;
+  }
+  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 = [];
+  executing = false;
+  handledCommandIds = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.options = options;
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.unsubscribeAppState = (this.options.subscribeAppState ?? defaultSubscribeAppState)((state) => this.handleAppState(state));
+    this.schedule(0);
+  }
+  stop() {
+    this.running = false;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    this.unsubscribeAppState?.();
+    this.unsubscribeAppState = null;
+    this.closeControlChannel();
+  }
+  handleAppState(state) {
+    const wasForeground = this.foreground;
+    this.foreground = state === "active";
+    if (!this.running) return;
+    if (this.foreground && !wasForeground) {
+      this.schedule(0);
+    }
+    if (!this.foreground) {
+      if (this.timer) clearTimeout(this.timer);
+      this.timer = null;
+      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);
+    this.timer = setTimeout(() => {
+      void this.beat();
+    }, delayMs);
+  }
+  async beat() {
+    if (!this.running || !this.foreground || this.beatInFlight) return;
+    this.beatInFlight = true;
+    try {
+      if (!this.registered) {
+        await this.register();
+        if (!this.registered) return;
+      }
+      await this.heartbeat();
+      this.schedule(this.nextBeatDelay());
+    } finally {
+      this.beatInFlight = false;
+    }
+  }
+  async register() {
+    try {
+      const result = await this.options.transport.register({
+        ...this.options.bootstrapInput,
+        ...this.options.deviceInfo
+      });
+      if (result.heartbeatIntervalMs > 0) {
+        this.heartbeatIntervalMs = result.heartbeatIntervalMs;
+      }
+      this.registered = true;
+      this.registerAttempt = 0;
+    } catch {
+      const delay = Math.min(
+        REGISTER_RETRY_BASE_MS * 2 ** this.registerAttempt,
+        REGISTER_RETRY_MAX_MS
+      );
+      this.registerAttempt += 1;
+      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 this.options.deviceMetrics?.() ?? null);
+    } 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({
+        ...this.options.bootstrapInput,
+        agentState: snapshot.state,
+        currentSessionId: snapshot.sessionId,
+        ...this.options.deviceInfo?.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 {
+      this.heartbeatFailures += 1;
+      if (this.heartbeatFailures >= 3) {
+        this.registered = false;
+        this.heartbeatFailures = 0;
+      }
+      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);
+    }
+  }
+  openControlChannel(grant) {
+    let channel;
+    try {
+      channel = (this.options.createControlChannel ?? defaultCreateControlChannel)(
+        grant.convexUrl
+      );
+    } catch {
+      return;
+    }
+    this.controlChannel = channel;
+    this.controlSessionId = grant.id;
+    void channel.attach(grant.id, grant.token).then(() => {
+      if (this.controlChannel !== channel) return;
+      this.controlUnsubscribers.push(
+        channel.onCommands(grant.id, grant.token, (commands) => {
+          void this.executeCommands(channel, grant, commands);
+        }),
+        channel.onState(grant.id, grant.token, (state) => {
+          if (state.status === "ended" || state.status === "expired") {
+            this.closeControlChannel();
+          }
+        })
+      );
+    }).catch(() => {
+      if (this.controlChannel === channel) this.closeControlChannel();
+    });
+  }
+  closeControlChannel() {
+    for (const unsubscribe of this.controlUnsubscribers) {
+      try {
+        unsubscribe();
+      } catch {
+      }
+    }
+    this.controlUnsubscribers = [];
+    try {
+      this.controlChannel?.close();
+    } catch {
+    }
+    this.controlChannel = null;
+    this.controlSessionId = null;
+    this.handledCommandIds.clear();
+  }
+  async executeCommands(channel, grant, commands) {
+    for (const command of commands) {
+      if (this.controlChannel !== channel) return;
+      if (this.handledCommandIds.has(command.id)) continue;
+      this.handledCommandIds.add(command.id);
+      if (this.executing) {
+        await this.safeAck(channel, grant, command.id, "failed", "Thi\u1EBFt b\u1ECB \u0111ang b\u1EADn");
+        continue;
+      }
+      this.executing = true;
+      try {
+        await this.executeCommand(channel, grant, command);
+      } finally {
+        this.executing = false;
+      }
+    }
+  }
+  async executeCommand(channel, grant, command) {
+    if (command.expiresAt <= Date.now()) {
+      await this.safeAck(channel, grant, command.id, "failed", "L\u1EC7nh \u0111\xE3 h\u1EBFt h\u1EA1n");
+      return;
+    }
+    await this.safeAck(channel, grant, command.id, "acked");
+    try {
+      if (command.type === "start_livestream") {
+        await this.runStartLivestream(command);
+        const sessionId = this.options.engine.getSnapshot().sessionId;
+        await this.safeAck(
+          channel,
+          grant,
+          command.id,
+          "completed",
+          void 0,
+          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");
+      }
+    } catch (error) {
+      await this.safeAck(
+        channel,
+        grant,
+        command.id,
+        "failed",
+        normalizeError(error).message
+      );
+    }
+  }
+  async runStartLivestream(command) {
+    const engine = this.options.engine;
+    const state = engine.getSnapshot().state;
+    if (state !== "idle" && state !== "ended" && state !== "preview") {
+      throw new Error(`Thi\u1EBFt b\u1ECB kh\xF4ng s\u1EB5n s\xE0ng (tr\u1EA1ng th\xE1i ${state})`);
+    }
+    if (state !== "preview") {
+      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,
+          // courtRef trong metadata → server đậu phiên standby vào sân
+          ...courtRef ? { courtRef } : {}
+        },
+        standby: true
+      },
+      { autoPublish: false }
+    );
+  }
+  async runStopLivestream() {
+    const engine = this.options.engine;
+    if (engine.getSnapshot().sessionId) {
+      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({
+        controlSessionId: grant.id,
+        token: grant.token,
+        commandId,
+        status,
+        ...errorMessage !== void 0 ? { errorMessage } : {},
+        ...resultSessionId !== void 0 ? { resultSessionId } : {}
+      });
+    } catch {
+    }
+  }
+};
+
+// src/device-agent/http-transport.ts
+var defaultPaths = {
+  register: "/devices/register",
+  heartbeat: "/devices/heartbeat"
+};
+function createHttpDeviceAgentTransport(options) {
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  if (baseUrl === "") {
+    throw new ExpoSdkConfigurationError("baseUrl must be a non-empty string");
+  }
+  const fetchImplementation = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImplementation !== "function") {
+    throw new ExpoSdkConfigurationError("A Fetch API implementation is required");
+  }
+  const paths = { ...defaultPaths, ...options.paths };
+  async function post(path, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 1e4);
+    try {
+      const extraHeaders = typeof options.headers === "function" ? await options.headers() : options.headers ?? {};
+      const response = await fetchImplementation(
+        `${baseUrl}/${path.replace(/^\/+/, "")}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...extraHeaders },
+          body: JSON.stringify(body),
+          signal: controller.signal,
+          redirect: "error"
+        }
+      );
+      const envelope = await response.json().catch(() => {
+        throw new InvalidResponseError();
+      });
+      if (!response.ok) throw parseProxyError(envelope);
+      if (!isRecord(envelope) || !("data" in envelope)) {
+        throw new InvalidResponseError();
+      }
+      return envelope.data;
+    } catch (error) {
+      if (controller.signal.aborted) throw new ExpoSdkTimeoutError();
+      if (error instanceof PickleballExpoError) throw error;
+      if (error instanceof TypeError) {
+        throw new NetworkUnavailableError(void 0, { cause: error });
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  return {
+    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 InvalidResponseError();
+      }
+      options.onData?.("register", data);
+      return {
+        deviceId: data.deviceId,
+        heartbeatIntervalMs: data.heartbeatIntervalMs
+      };
+    },
+    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, ...beatIntervalMs };
+      }
+      if (!isRecord(grant) || typeof grant.id !== "string" || typeof grant.token !== "string" || typeof grant.convexUrl !== "string" || grant.convexUrl === "") {
+        throw new 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 errorFromCode(
+      envelope.error.code,
+      typeof envelope.error.message === "string" ? envelope.error.message : void 0
+    );
+  }
+  return new 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 = 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) {
+  const host = useLivestreamHost();
+  const propsRef = useRef(props);
+  propsRef.current = props;
+  useEffect(() => {
+    const agent = new DeviceAgent({
+      engine: host.engine,
+      bootstrapInput: host.bootstrapInput,
+      deviceMetrics: host.deviceMetrics,
+      transport: propsRef.current.transport,
+      remoteStart: propsRef.current.remoteStart,
+      deviceInfo: propsRef.current.deviceInfo,
+      createControlChannel: propsRef.current.createControlChannel,
+      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,
+  createConvexDeviceRealtime,
+  createHttpDeviceAgentTransport,
+  createMqttChannel,
+  metricsCrossedThreshold,
+  mqttBeatHealthy,
+  nextBeatDelayMs,
+  withConvexBeat
+};