@pickleball/expo-sdk 0.1.1 → 0.2.0

package/src/match/remote/types.ts

@@ -2,7 +2,7 @@ export const BTHOME_SERVICE_UUID = "FCD2" as const;
 
 export type RemoteButtonAction = "single" | "double" | "long";
 export type RemoteInputMode = "bthome" | "hidVolume" | "both";
-export type RemoteMappedAction = "left" | "right" | "undo" | "none";
+export type RemoteMappedAction = "left" | "right" | "undo" | "announce" | "none";
 export interface RemoteActionMapping {
   readonly volumeUp: RemoteMappedAction;
   readonly volumeDown: RemoteMappedAction;
@@ -19,17 +19,19 @@ export interface RemoteHidVolumeEvent {
   readonly timestamp: number;
 }
 
-export type RemoteHidGesture = "single" | "double" | "hold";
+export type RemoteHidGesture = "single" | "double" | "triple" | "quadruple" | "hold";
 
 export interface RemoteHidGestureMapping {
-  /** Raw HID direction emitted by the calibrated remote button. */
-  readonly direction: RemoteHidVolumeEvent["direction"];
+  /** Raw HID direction emitted by the calibrated remote button, or "any" for single-button remotes that alternate directions. */
+  readonly direction: RemoteHidVolumeEvent["direction"] | "any";
   /** Quiet window used to close one physical gesture burst. */
   readonly settleMs: number;
   /** Repeated volume changes required to classify a hold before the burst ends. */
   readonly holdEventCount: number;
   readonly single: RemoteMappedAction;
   readonly double: RemoteMappedAction;
+  readonly triple?: RemoteMappedAction;
+  readonly quadruple?: RemoteMappedAction;
   readonly hold: RemoteMappedAction;
 }
 

package/src/match/voice/scheduler.ts

@@ -75,6 +75,7 @@ export class LatestAnnouncementScheduler {
     ]);
     if (generation !== this.generation) return;
 
+    let neuralFailure: unknown = null;
     try {
       const avail = await this.options.engine.availability();
       if (avail === "available") {
@@ -89,17 +90,21 @@ export class LatestAnnouncementScheduler {
       }
     } catch (error) {
       if (controller.signal.aborted || generation !== this.generation) return;
-      this.report(error);
+      // Đọc bằng WAV offline vẫn chạy được — chỉ báo lỗi TTS khi fallback cũng hỏng.
+      neuralFailure = error;
     }
 
+    let fallbackPlayed = false;
     for (const source of planBundledFallback(plan)) {
       if (generation !== this.generation || controller.signal.aborted) return;
       try {
         await this.options.audio.play(source);
+        fallbackPlayed = true;
       } catch (error) {
         this.report(error);
       }
     }
+    if (neuralFailure && !fallbackPlayed) this.report(neuralFailure);
   }
 
   async replayLast(): Promise<void> {

package/src/match/voice/service.ts

@@ -56,11 +56,13 @@ export function createDefaultMatchVoiceService(
     (options.tts
       ? createGeminiVoiceEngine({ ...options.tts, generatedRoot: generatedDirectory() })
       : createUnavailableVoiceEngine());
+  let errorEpoch = 0;
   const scheduler = new LatestAnnouncementScheduler({
     engine,
     audio,
     onError(error) {
       lastError = error;
+      errorEpoch += 1;
       enqueueNotify();
     },
   });
@@ -118,10 +120,20 @@ export function createDefaultMatchVoiceService(
     subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
     announce(previous, current, event) {
       if (!stillActive()) return;
-      void scheduler.enqueue(buildVietnameseAnnouncement(previous, current, event)).catch((error) => {
-        lastError = error instanceof Error ? error : new Error("Announcement failed");
-        notify();
-      });
+      const epochBefore = errorEpoch;
+      void scheduler.enqueue(buildVietnameseAnnouncement(previous, current, event)).then(
+        () => {
+          // Lần đọc trọn vẹn (không lỗi mới nào bị báo) xoá lỗi voice cũ khỏi UI thay vì hiển thị mãi.
+          if (lastError && errorEpoch === epochBefore && stillActive()) {
+            lastError = null;
+            notify();
+          }
+        },
+        (error) => {
+          lastError = error instanceof Error ? error : new Error("Announcement failed");
+          notify();
+        },
+      );
     },
     replayAnnouncement: () => stillActive() ? scheduler.replayLast() : Promise.resolve(),
     testSpeaker: () => stillActive() ? scheduler.testSpeaker() : Promise.resolve(),

package/src/native-runtime.ts

@@ -1,5 +1,6 @@
 import type { EngineDependencies, SdkNetwork, SdkRuntime, SdkStorage, TelemetrySink } from "./engine";
 import { LiveKitRoomAdapter, type NativeLiveKitBindings } from "./livekit-room-adapter";
+import { RtmpRoomAdapter, type NativeRtmpBindings } from "./rtmp-room-adapter";
 import { UnsupportedRuntimeError } from "./errors";
 
 declare const require: (name: string) => any;
@@ -89,11 +90,29 @@ export function createDefaultRuntime(): SdkRuntime {
 }
 
 export function createDefaultStorage(): SdkStorage {
-  require("expo-sqlite/localStorage/install");
+  // Cài localStorage của expo-sqlite ở LẦN DÙNG ĐẦU, không phải lúc gọi factory:
+  // app thường tạo storage ở module scope (root layout), và static-render web
+  // của expo-router nạp module đó trong Node nơi expo-sqlite không resolve được.
+  // Không có lời gọi get/set/remove nào khi render tĩnh nên require không chạy.
+  let installed = false;
+  const install = () => {
+    if (installed) return;
+    require("expo-sqlite/localStorage/install");
+    installed = true;
+  };
   return {
-    getItem: async (key) => globalThis.localStorage.getItem(key),
-    setItem: async (key, value) => globalThis.localStorage.setItem(key, value),
-    removeItem: async (key) => globalThis.localStorage.removeItem(key),
+    getItem: async (key) => {
+      install();
+      return globalThis.localStorage.getItem(key);
+    },
+    setItem: async (key, value) => {
+      install();
+      globalThis.localStorage.setItem(key, value);
+    },
+    removeItem: async (key) => {
+      install();
+      globalThis.localStorage.removeItem(key);
+    },
   };
 }
 
@@ -159,6 +178,37 @@ export function createDefaultRoomFactory(): EngineDependencies["roomFactory"] {
   return () => new LiveKitRoomAdapter(createNativeLiveKitBindings());
 }
 
+/**
+ * Bindings cho mode device-rtmp. `require` động giống LiveKit ở trên: app nào
+ * không cài @pickleball/rtmp-native thì chỉ lỗi khi thật sự chọn mode này,
+ * không gãy lúc import SDK.
+ */
+export function createNativeRtmpBindings(): NativeRtmpBindings {
+  const native = require("@pickleball/rtmp-native").default;
+  return {
+    prepare: (options) => native.prepare(options),
+    isLandscape() {
+      const { width, height } = require("react-native").Dimensions.get("window");
+      return width > height;
+    },
+    connect: (options) => native.connect(options),
+    setPublishing: (enabled) => native.setPublishing(enabled),
+    disconnect: () => native.disconnect(),
+    switchCamera: () => native.switchCamera(),
+    listCameras: () => native.listCameras(),
+    selectCamera: (deviceId, facing) => native.selectCamera(deviceId, facing),
+    setMicrophoneEnabled: (enabled) => native.setMicrophoneEnabled(enabled),
+    setVideoBitrate: (bps) => native.setVideoBitrate(bps),
+    dispose: () => native.dispose(),
+    addStatusListener: (listener) => native.addListener("onStatusChanged", listener),
+  };
+}
+
+/** roomFactory cho mode device-rtmp (thiết bị đẩy RTMP, không dùng LiveKit). */
+export function createRtmpRoomFactory(): EngineDependencies["roomFactory"] {
+  return () => new RtmpRoomAdapter(createNativeRtmpBindings());
+}
+
 /**
  * Thu chỉ số thiết bị cho heartbeat. Mỗi nguồn là optional — thiếu package
  * (expo-battery/expo-device/expo-file-system) thì bỏ qua trường đó thay vì lỗi.

package/src/plugin.ts

@@ -16,19 +16,27 @@ export interface PickleballLivePluginProps {
   microphonePermission?: string;
   bluetoothPermission?: string;
   consumeHidVolumeKeys?: boolean;
+  /**
+   * Tắt phần cấu hình native của module không dùng để app gọn hơn:
+   * - remote: false → bỏ permission Bluetooth (Android + iOS usage string) và
+   *   không patch MainActivity nhận phím HID. Dùng khi app không import
+   *   "@pickleball/expo-sdk/match/remote".
+   * - voice: false → hiện chưa gate gì trong plugin (mic thuộc livestream);
+   *   nhận trước để tương thích về sau. Muốn loại hẳn native khỏi binary, thêm
+   *   expo.autolinking.exclude trong package.json của app (xem README).
+   */
+  modules?: {
+    remote?: boolean;
+    voice?: boolean;
+  };
   liveKit?: {
     android?: { audioType?: string; enableScreenShareService?: boolean };
     ios?: { enableMultitaskingCameraAccess?: boolean };
   };
 }
 
-const ANDROID_PERMISSIONS = [
+const CORE_ANDROID_PERMISSIONS = [
   "android.permission.ACCESS_NETWORK_STATE",
-  "android.permission.BLUETOOTH",
-  "android.permission.BLUETOOTH_ADMIN",
-  "android.permission.BLUETOOTH_SCAN",
-  "android.permission.BLUETOOTH_CONNECT",
-  "android.permission.ACCESS_FINE_LOCATION",
   "android.permission.CAMERA",
   "android.permission.INTERNET",
   "android.permission.MODIFY_AUDIO_SETTINGS",
@@ -36,6 +44,15 @@ const ANDROID_PERMISSIONS = [
   "android.permission.WAKE_LOCK",
 ] as const;
 
+// Chỉ cần cho remote BLE/HID (@pickleball/expo-sdk/match/remote)
+const REMOTE_ANDROID_PERMISSIONS = [
+  "android.permission.BLUETOOTH",
+  "android.permission.BLUETOOTH_ADMIN",
+  "android.permission.BLUETOOTH_SCAN",
+  "android.permission.BLUETOOTH_CONNECT",
+  "android.permission.ACCESS_FINE_LOCATION",
+] as const;
+
 export function injectHidVolumeMainActivity(source: string): string {
   if (source.includes("PickleballRemoteHidDispatcher.dispatch(event)")) return source;
   if (!/class\s+MainActivity\s*:\s*ReactActivity\(\)\s*\{/.test(source)) {
@@ -76,6 +93,10 @@ const withPickleballLive: ConfigPlugin<PickleballLivePluginProps | undefined> =
   const bluetoothPermission =
     props?.bluetoothPermission ??
     "Cho phép $(PRODUCT_NAME) dùng Bluetooth để nhận thao tác từ nút điều khiển trên sân.";
+  const remoteEnabled = props?.modules?.remote !== false;
+  const androidPermissions = remoteEnabled
+    ? [...CORE_ANDROID_PERMISSIONS, ...REMOTE_ANDROID_PERMISSIONS]
+    : [...CORE_ANDROID_PERMISSIONS];
 
   config = withPlugins(config, [
     ["@livekit/react-native-expo-plugin", props?.liveKit],
@@ -84,12 +105,12 @@ const withPickleballLive: ConfigPlugin<PickleballLivePluginProps | undefined> =
   config = withInfoPlist(config, (mod) => {
     mod.modResults.NSCameraUsageDescription = cameraPermission;
     mod.modResults.NSMicrophoneUsageDescription = microphonePermission;
-    mod.modResults.NSBluetoothAlwaysUsageDescription = bluetoothPermission;
+    if (remoteEnabled) {
+      mod.modResults.NSBluetoothAlwaysUsageDescription = bluetoothPermission;
+    }
     return mod;
   });
-  config = AndroidConfig.Permissions.withPermissions(config, [
-    ...ANDROID_PERMISSIONS,
-  ]);
+  config = AndroidConfig.Permissions.withPermissions(config, androidPermissions);
   config = withAndroidManifest(config, (mod) => {
     const manifest = mod.modResults.manifest;
     const existing = manifest["uses-permission"] ?? [];
@@ -106,7 +127,7 @@ const withPickleballLive: ConfigPlugin<PickleballLivePluginProps | undefined> =
       const name = entry.$?.["android:name"];
       if (name && !byName.has(name)) byName.set(name, entry);
     }
-    for (const permission of ANDROID_PERMISSIONS) {
+    for (const permission of androidPermissions) {
       const entry = byName.get(permission) ?? { $: { "android:name": permission } };
       entry.$ = {
         "android:name": permission,
@@ -114,17 +135,17 @@ const withPickleballLive: ConfigPlugin<PickleballLivePluginProps | undefined> =
       };
       byName.set(permission, entry);
     }
-    const requiredNames = new Set<string>(ANDROID_PERMISSIONS);
+    const requiredNames = new Set<string>(androidPermissions);
     manifest["uses-permission"] = [
       ...existing.filter((entry) => {
         const name = entry.$?.["android:name"];
         return !name || !requiredNames.has(name);
       }),
-      ...ANDROID_PERMISSIONS.map((name) => byName.get(name)!),
+      ...androidPermissions.map((name) => byName.get(name)!),
     ];
     return mod;
   });
-  if (props?.consumeHidVolumeKeys !== false) {
+  if (remoteEnabled && props?.consumeHidVolumeKeys !== false) {
     config = withDangerousMod(config, ["android", async (mod) => {
       const root = join(mod.modRequest.platformProjectRoot, "app", "src", "main", "java");
       const path = await findMainActivity(root);

package/src/provider.tsx

@@ -75,6 +75,28 @@ export interface PickleballLiveProviderProps {
   onError?: (error: PickleballExpoError) => void;
 }
 
+/**
+ * Context nội bộ cho các module opt-in (VD PickleballDeviceAgent) cần truy cập
+ * engine trực tiếp — export qua "./advanced", không thuộc API tích hợp cơ bản.
+ */
+export interface LivestreamHostContextValue {
+  engine: LivestreamEngine;
+  bootstrapInput: BootstrapInput;
+  deviceMetrics: NonNullable<EngineDependencies["deviceMetrics"]>;
+}
+
+const LivestreamHostContext = React.createContext<LivestreamHostContextValue | null>(null);
+
+export function useLivestreamHost(): LivestreamHostContextValue {
+  const value = React.use(LivestreamHostContext);
+  if (!value) {
+    throw new ExpoSdkConfigurationError(
+      "useLivestreamHost must be used inside PickleballLiveProvider",
+    );
+  }
+  return value;
+}
+
 export interface LivestreamContextValue extends LivestreamSnapshot {
   locale: "vi" | "en";
   theme: LivestreamTheme;
@@ -99,8 +121,10 @@ const LivestreamContext = React.createContext<LivestreamContextValue | null>(nul
 
 export function PickleballLiveProvider(props: PickleballLiveProviderProps) {
   const engineRef = useRef<LivestreamEngine | null>(null);
+  const hostRef = useRef<LivestreamHostContextValue | null>(null);
   const effectGenerationRef = useRef(0);
   if (!engineRef.current) {
+    const deviceMetrics = props.deviceMetrics ?? createDefaultDeviceMetrics();
     const dependencies: EngineDependencies = {
       sessionProvider: props.sessionProvider,
       bootstrapInput: props.bootstrapInput,
@@ -108,10 +132,15 @@ export function PickleballLiveProvider(props: PickleballLiveProviderProps) {
       storage: props.storage ?? createDefaultStorage(),
       network: props.network ?? createDefaultNetwork(),
       telemetry: props.telemetry ?? createDefaultTelemetry(),
-      deviceMetrics: props.deviceMetrics ?? createDefaultDeviceMetrics(),
+      deviceMetrics,
       roomFactory: props.roomFactory ?? createDefaultRoomFactory(),
     };
     engineRef.current = new LivestreamEngine(dependencies);
+    hostRef.current = {
+      engine: engineRef.current,
+      bootstrapInput: props.bootstrapInput,
+      deviceMetrics,
+    };
   }
   const engine = engineRef.current;
   const snapshot = useSyncExternalStore(
@@ -159,9 +188,11 @@ export function PickleballLiveProvider(props: PickleballLiveProviderProps) {
     selectCamera: (deviceId) => engine.selectCamera(deviceId),
   };
   return (
-    <LivestreamContext.Provider value={value}>
-      {props.children}
-    </LivestreamContext.Provider>
+    <LivestreamHostContext.Provider value={hostRef.current}>
+      <LivestreamContext.Provider value={value}>
+        {props.children}
+      </LivestreamContext.Provider>
+    </LivestreamHostContext.Provider>
   );
 }
 

package/src/rtmp-room-adapter.ts

@@ -0,0 +1,196 @@
+import type {
+  CameraDeviceInfo,
+  CaptureOrientation,
+  RoomAdapter,
+  RoomConnection,
+  RoomEvent,
+} from "./engine";
+
+/**
+ * Trạng thái từ tầng RTMP native (trùng NativeRtmpStatus của @pickleball/rtmp-native).
+ */
+export type RtmpStatus =
+  | { readonly status: "idle" | "connecting" | "connected" | "publishing" }
+  | { readonly status: "disconnected"; readonly reason?: string }
+  | { readonly status: "error"; readonly code: string; readonly message: string };
+
+/**
+ * Dấu hiệu để UI biết render nguồn nào. LiveKit trả về một track object; RTMP
+ * không có "track" ở JS (khung hình đi thẳng trong native), nên trả marker này
+ * — nếu trả undefined thì UI tưởng chưa có preview và vẽ màn TỐI ĐEN.
+ */
+export interface RtmpPreviewMarker {
+  readonly kind: "rtmp";
+}
+
+/** Bề mặt native mà adapter cần — tiêm vào để test được không cần thiết bị thật. */
+export interface NativeRtmpBindings {
+  prepare(options: { quality: 720 | 1080; landscape: boolean }): Promise<void>;
+  /** Hướng cầm máy hiện tại — cùng nguồn mà LiveKitRoomAdapter dùng. */
+  isLandscape?(): boolean;
+  connect(options: {
+    url: string;
+    videoBitrate: number;
+    publish: boolean;
+  }): Promise<void>;
+  setPublishing(enabled: boolean): Promise<void>;
+  disconnect(): Promise<void>;
+  switchCamera(): Promise<void>;
+  listCameras(): Array<{ deviceId: string; label: string; facing: string }>;
+  selectCamera(deviceId: string, facing: string): Promise<void>;
+  setMicrophoneEnabled(enabled: boolean): Promise<void>;
+  setVideoBitrate(bitsPerSecond: number): Promise<void>;
+  dispose(): Promise<void>;
+  addStatusListener(listener: (event: RtmpStatus) => void): { remove(): void };
+}
+
+/**
+ * Bitrate theo mức chất lượng — nằm trong khoảng TikTok khuyến nghị cho live
+ * (720p 3–6 Mbps, 1080p 6–9 Mbps). Thấp hơn khoảng này thì thể thao chuyển động
+ * nhanh như pickleball bị bể khối rất rõ.
+ */
+const VIDEO_BITRATE: Record<720 | 1080, number> = {
+  720: 3_500_000,
+  1080: 6_000_000,
+};
+
+/**
+ * Adapter cho mode deliveryMode="device-rtmp".
+ *
+ * Thiết bị mã hoá H.264 bằng phần cứng MỘT lần rồi đẩy thẳng RTMP; server chỉ
+ * remux sang HLS. Không có phòng LiveKit, không egress → $0 transcode.
+ *
+ * Khác LiveKitRoomAdapter ở một điểm quan trọng: RTMP **không có kênh dữ liệu**,
+ * nên adapter này không bao giờ phát RoomEvent "command". Lệnh điều khiển từ
+ * dashboard đi đường khác (deviceControl trên Convex) — xem device-agent.
+ */
+export class RtmpRoomAdapter implements RoomAdapter {
+  private readonly listeners = new Set<(event: RoomEvent) => void>();
+  private nativeSubscription?: { remove(): void };
+  private quality: 720 | 1080 = 1080;
+  private connected = false;
+
+  constructor(private readonly bindings: NativeRtmpBindings) {}
+
+  async preparePreview(quality: 720 | 1080): Promise<RtmpPreviewMarker> {
+    this.quality = quality;
+    // Mặc định ngang khi binding không cài: sân pickleball quay ngang là chính,
+    // và đó cũng là kích thước capture mặc định của HaishinKit.
+    await this.bindings.prepare({
+      quality,
+      landscape: this.bindings.isLandscape?.() ?? true,
+    });
+    // Khung hình do PickleballRtmpPreviewView vẽ ở tầng native; JS chỉ cần biết
+    // "đã có preview và là nguồn RTMP" để chọn đúng component hiển thị.
+    return { kind: "rtmp" };
+  }
+
+  async connect(input: RoomConnection) {
+    // Chặn lệch mode: nếu app chọn adapter RTMP nhưng phiên phía server lại là
+    // LiveKit thì serverUrl sẽ là wss://. Không kiểm ở đây thì HaishinKit nhận
+    // URL vô nghĩa và hỏng câm lặng, rất khó truy ngược.
+    if (!/^rtmps?:\/\//i.test(input.serverUrl)) {
+      throw new Error(
+        `Mode device-rtmp cần endpoint rtmp:// nhưng phiên trả về "${input.serverUrl}". ` +
+          "Kiểm tra deliveryMode của app trên server (partnerApps.deliveryMode).",
+      );
+    }
+    // Backend cấp rtmpsUrl kết thúc bằng "/" và rtmpsStreamKey riêng; ghép lại
+    // thành URL publish đầy đủ. Stream key đóng vai trò bearer token của phiên.
+    const url = `${input.serverUrl}${input.participantToken}`;
+    await this.bindings.setMicrophoneEnabled(input.microphoneEnabled);
+    await this.bindings.connect({
+      url,
+      videoBitrate: VIDEO_BITRATE[this.quality],
+      // publish !== false → mặc định phát ngay; false = vào standby.
+      publish: input.publish !== false,
+    });
+    this.connected = true;
+  }
+
+  async setPublishing(enabled: boolean) {
+    await this.bindings.setPublishing(enabled);
+  }
+
+  async disconnect(_stopTracks?: boolean) {
+    if (!this.connected) return;
+    this.connected = false;
+    await this.bindings.disconnect();
+  }
+
+  async switchCamera() {
+    await this.bindings.switchCamera();
+  }
+
+  /** Ống kính vật lý (0.5x siêu rộng · 1x · tele) — không có thì UI kẹt ở mặc định. */
+  async listCameras(): Promise<CameraDeviceInfo[]> {
+    return this.bindings.listCameras().map((camera) => ({
+      deviceId: camera.deviceId,
+      label: camera.label,
+      facing:
+        camera.facing === "front" || camera.facing === "environment"
+          ? camera.facing
+          : "unknown",
+    }));
+  }
+
+  async selectCamera(deviceId: string, facing: CameraDeviceInfo["facing"]) {
+    await this.bindings.selectCamera(deviceId, facing);
+  }
+
+  async setMicrophoneEnabled(enabled: boolean) {
+    await this.bindings.setMicrophoneEnabled(enabled);
+  }
+
+  /** Hạ chất lượng khi mạng yếu — thay cho BWE mà WebRTC cho sẵn. */
+  async setVideoBitrate(bitsPerSecond: number) {
+    await this.bindings.setVideoBitrate(bitsPerSecond);
+  }
+
+  async setCaptureOrientation(_orientation: CaptureOrientation) {
+    // Khung hình do camera quyết định; không đổi giữa luồng RTMP vì sẽ buộc
+    // khởi động lại encoder và làm thủng segment HLS.
+  }
+
+  subscribe(listener: (event: RoomEvent) => void) {
+    this.listeners.add(listener);
+    if (!this.nativeSubscription) {
+      this.nativeSubscription = this.bindings.addStatusListener((event) => {
+        const mapped = mapStatus(event);
+        if (mapped) this.emit(mapped);
+      });
+    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  async dispose() {
+    this.nativeSubscription?.remove();
+    this.nativeSubscription = undefined;
+    this.listeners.clear();
+    this.connected = false;
+    await this.bindings.dispose();
+  }
+
+  private emit(event: RoomEvent) {
+    for (const listener of this.listeners) listener(event);
+  }
+}
+
+/** Trạng thái native → RoomEvent của engine. `null` = không cần báo lên. */
+export function mapStatus(event: RtmpStatus): RoomEvent | null {
+  switch (event.status) {
+    case "error":
+      return { type: "media-error", error: new Error(event.message) };
+    case "disconnected":
+      return { type: "disconnected", reason: event.reason };
+    case "connecting":
+      return { type: "reconnecting" };
+    case "publishing":
+      return { type: "reconnected" };
+    // "idle"/"connected" là bước trung gian, engine không cần biết.
+    default:
+      return null;
+  }
+}

package/dist/chunk-VHLUJQG5.js

@@ -1,17 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// package.json
-var version = "0.1.1";
-
-// src/version.ts
-var PICKLEBALL_EXPO_SDK_VERSION = version;
-
-export {
-  __require,
-  PICKLEBALL_EXPO_SDK_VERSION
-};