@pickleball/expo-sdk 0.2.0 → 1.0.0

package/dist/chunk-62YV3PCD.cjs

@@ -0,0 +1,139 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return 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 _chunkIUIRVKJIcjs = require('./chunk-IUIRVKJI.cjs');
+
+// src/session-grant.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isBootstrap(value) {
+  return isRecord(value) && _chunkIUIRVKJIcjs.isSdkRemoteConfig.call(void 0, value.config) && isFiniteNumber(value.serverTime) && typeof value.rolloutEnabled === "boolean" && (value.message === void 0 || typeof value.message === "string");
+}
+function isTelemetryCredentials(value) {
+  return isRecord(value) && typeof value.endpoint === "string" && /^https:\/\//.test(value.endpoint) && typeof value.token === "string" && value.token.length > 0 && isFiniteNumber(value.expiresAt);
+}
+function isSessionGrant(value) {
+  return isRecord(value) && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.serverUrl === "string" && /^rtmps?:\/\//i.test(value.serverUrl) && typeof value.participantToken === "string" && value.participantToken.length > 0 && (value.playbackUrl === null || typeof value.playbackUrl === "string") && isFiniteNumber(value.tokenExpiresAt) && isTelemetryCredentials(value.telemetry) && _chunkIUIRVKJIcjs.isSdkRemoteConfig.call(void 0, value.config);
+}
+function optionalNullableString(value) {
+  return value === void 0 || value === null || typeof value === "string";
+}
+function isCameraGrant(value) {
+  return isSessionGrant(value) && /^rtmps?:\/\//i.test(value.serverUrl) && (value.status === "scheduled" || value.status === "live") && optionalNullableString(value.matchRef) && optionalNullableString(value.courtRef) && optionalNullableString(value.watchUrl) && optionalNullableString(value.convexUrl);
+}
+function isSessionRefresh(value) {
+  if (!isRecord(value) || !_chunkIUIRVKJIcjs.isSdkRemoteConfig.call(void 0, value.config)) return false;
+  if (value.participantToken !== void 0 && (typeof value.participantToken !== "string" || !value.participantToken)) {
+    return false;
+  }
+  if (value.tokenExpiresAt !== void 0 && !isFiniteNumber(value.tokenExpiresAt)) {
+    return false;
+  }
+  return value.telemetry === void 0 || isTelemetryCredentials(value.telemetry);
+}
+function isSessionStatus(value) {
+  return isRecord(value) && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.status === "string" && value.status.length > 0;
+}
+function sessionApiBaseFromTelemetryEndpoint(endpoint) {
+  if (!/^https:\/\//.test(endpoint) || !endpoint.endsWith("/telemetry")) {
+    throw new (0, _chunkIUIRVKJIcjs.InvalidResponseError)("The telemetry endpoint must be an HTTPS \u2026/telemetry URL");
+  }
+  return endpoint.slice(0, -"/telemetry".length);
+}
+var PRIVATE_LAN_HOST = /^(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})$/;
+function normalizeBaseUrl(value) {
+  try {
+    const url = new URL(value);
+    const loopbackHosts = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+    const secure = url.protocol === "https:";
+    const localDevelopment = url.protocol === "http:" && loopbackHosts.has(url.hostname);
+    const devPrivateLan = typeof __DEV__ !== "undefined" && __DEV__ === true && url.protocol === "http:" && PRIVATE_LAN_HOST.test(url.hostname);
+    if (!secure && !localDevelopment && !devPrivateLan || url.username || url.password) {
+      throw new Error();
+    }
+    return value.replace(/\/+$/, "");
+  } catch (e) {
+    throw new (0, _chunkIUIRVKJIcjs.ExpoSdkConfigurationError)(
+      "baseUrl must use HTTPS (HTTP is allowed only for localhost loopback)"
+    );
+  }
+}
+function joinUrl(base, path) {
+  return `${base}/${path.replace(/^\/+/, "")}`;
+}
+function parseEnvelopeError(envelope, httpStatus) {
+  const body = isRecord(envelope) && isRecord(envelope.error) ? envelope.error : null;
+  const error = body && typeof body.code === "string" ? _chunkIUIRVKJIcjs.errorFromCode.call(void 0, body.code, typeof body.message === "string" ? body.message : void 0) : new (0, _chunkIUIRVKJIcjs.InvalidResponseError)();
+  return Object.assign(
+    error,
+    { httpStatus },
+    body && typeof body.reason === "string" ? { reason: body.reason } : {},
+    body && typeof body.retryAfterMs === "number" ? { retryAfterMs: body.retryAfterMs } : {}
+  );
+}
+function createJsonPoster(options = {}) {
+  const fetchImplementation = _nullishCoalesce(options.fetch, () => ( globalThis.fetch));
+  if (typeof fetchImplementation !== "function") {
+    throw new (0, _chunkIUIRVKJIcjs.ExpoSdkConfigurationError)("A Fetch API implementation is required");
+  }
+  const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( 1e4));
+  return async function post(url, body, headers = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetchImplementation(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+        redirect: "error"
+      });
+      const envelope = await response.json().catch(() => {
+        throw new (0, _chunkIUIRVKJIcjs.InvalidResponseError)();
+      });
+      if (!response.ok) throw parseEnvelopeError(envelope, response.status);
+      if (!isRecord(envelope) || !("data" in envelope)) {
+        throw new (0, _chunkIUIRVKJIcjs.InvalidResponseError)();
+      }
+      return envelope.data;
+    } catch (error) {
+      if (controller.signal.aborted) throw new (0, _chunkIUIRVKJIcjs.ExpoSdkTimeoutError)();
+      if (error instanceof _chunkIUIRVKJIcjs.PickleballExpoError) throw error;
+      if (error instanceof TypeError) {
+        throw new (0, _chunkIUIRVKJIcjs.NetworkUnavailableError)(void 0, { cause: error });
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+}
+function httpStatusOf(error) {
+  const status = _optionalChain([error, 'optionalAccess', _ => _.httpStatus]);
+  return typeof status === "number" ? status : void 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.isRecord = isRecord; exports.isFiniteNumber = isFiniteNumber; exports.isBootstrap = isBootstrap; exports.isTelemetryCredentials = isTelemetryCredentials; exports.isSessionGrant = isSessionGrant; exports.isCameraGrant = isCameraGrant; exports.isSessionRefresh = isSessionRefresh; exports.isSessionStatus = isSessionStatus; exports.sessionApiBaseFromTelemetryEndpoint = sessionApiBaseFromTelemetryEndpoint; exports.normalizeBaseUrl = normalizeBaseUrl; exports.joinUrl = joinUrl; exports.createJsonPoster = createJsonPoster; exports.httpStatusOf = httpStatusOf;

package/dist/chunk-6F3HN6US.js

@@ -0,0 +1,50 @@
+// src/device-agent/convex-command-subscription.ts
+import { ConvexClient } from "convex/browser";
+import { anyApi } from "convex/server";
+function createConvexCommandSubscription(convexUrl) {
+  return createConvexDeviceRealtime(convexUrl).commandSubscription;
+}
+function createConvexDeviceRealtime(convexUrl) {
+  const client = new ConvexClient(convexUrl);
+  return {
+    commandSubscription: {
+      subscribe(credentials, sessionId, onCommands, onError) {
+        return client.onUpdate(
+          anyApi.sessionCommands.pendingForSession,
+          { sessionId, token: credentials.token, after: 0 },
+          (value) => onCommands(toCommands(value)),
+          (error) => onError?.(error)
+        );
+      },
+      // Client dùng chung với beat — đóng ở dispose() của cả cụm, không ở đây.
+      dispose() {
+      }
+    },
+    async beat(args) {
+      const result = await client.mutation(anyApi.deviceApp.beat, args);
+      return result !== null && typeof result === "object" && !Array.isArray(result) ? result : {};
+    },
+    dispose() {
+      void client.close();
+    }
+  };
+}
+function toCommands(value) {
+  if (value === null || typeof value !== "object") return [];
+  const commands = value.commands;
+  if (!Array.isArray(commands)) return [];
+  const out = [];
+  for (const item of commands) {
+    if (item === null || typeof item !== "object") continue;
+    const record = item;
+    if (typeof record.id === "string" && (record.action === "start" || record.action === "stop" || record.action === "end") && typeof record.issuedAt === "number" && Number.isFinite(record.issuedAt)) {
+      out.push({ id: record.id, action: record.action, issuedAt: record.issuedAt });
+    }
+  }
+  return out;
+}
+
+export {
+  createConvexCommandSubscription,
+  createConvexDeviceRealtime
+};

package/dist/chunk-6YE5BL3A.cjs

@@ -0,0 +1,50 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// src/device-agent/convex-command-subscription.ts
+var _browser = require('convex/browser');
+var _server = require('convex/server');
+function createConvexCommandSubscription(convexUrl) {
+  return createConvexDeviceRealtime(convexUrl).commandSubscription;
+}
+function createConvexDeviceRealtime(convexUrl) {
+  const client = new (0, _browser.ConvexClient)(convexUrl);
+  return {
+    commandSubscription: {
+      subscribe(credentials, sessionId, onCommands, onError) {
+        return client.onUpdate(
+          _server.anyApi.sessionCommands.pendingForSession,
+          { sessionId, token: credentials.token, after: 0 },
+          (value) => onCommands(toCommands(value)),
+          (error) => _optionalChain([onError, 'optionalCall', _ => _(error)])
+        );
+      },
+      // Client dùng chung với beat — đóng ở dispose() của cả cụm, không ở đây.
+      dispose() {
+      }
+    },
+    async beat(args) {
+      const result = await client.mutation(_server.anyApi.deviceApp.beat, args);
+      return result !== null && typeof result === "object" && !Array.isArray(result) ? result : {};
+    },
+    dispose() {
+      void client.close();
+    }
+  };
+}
+function toCommands(value) {
+  if (value === null || typeof value !== "object") return [];
+  const commands = value.commands;
+  if (!Array.isArray(commands)) return [];
+  const out = [];
+  for (const item of commands) {
+    if (item === null || typeof item !== "object") continue;
+    const record = item;
+    if (typeof record.id === "string" && (record.action === "start" || record.action === "stop" || record.action === "end") && typeof record.issuedAt === "number" && Number.isFinite(record.issuedAt)) {
+      out.push({ id: record.id, action: record.action, issuedAt: record.issuedAt });
+    }
+  }
+  return out;
+}
+
+
+
+
+exports.createConvexCommandSubscription = createConvexCommandSubscription; exports.createConvexDeviceRealtime = createConvexDeviceRealtime;

package/dist/chunk-7Z7TN5N3.js

@@ -0,0 +1,318 @@
+import {
+  createDefaultStorage,
+  createRtmpRoomFactory,
+  useLivestream,
+  useLivestreamHost
+} from "./chunk-XGP2MN5R.js";
+import {
+  __require
+} from "./chunk-KFQGP6VL.js";
+
+// src/resume-policy.ts
+function classifyResumeStatus(status) {
+  if (status === 404 || status === 409 || status === 410) return "gone";
+  if (status >= 200 && status < 300) return "ok";
+  return "retry";
+}
+var RESUME_RETRY_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 15e3];
+function resumeRetryDelayMs(attempt) {
+  const index = Math.min(Math.max(attempt, 0), RESUME_RETRY_DELAYS_MS.length - 1);
+  return RESUME_RETRY_DELAYS_MS[index];
+}
+function resumeBlocksArm(input) {
+  if (input.engineSessionId !== null) return false;
+  return input.adoptableSessionId !== null || input.serverSessionId !== null;
+}
+function resumeExternalSessionId(sessionId) {
+  return `resume-${sessionId}`;
+}
+function resumeGrantMatches(externalSessionId, grantSessionId) {
+  return externalSessionId === resumeExternalSessionId(grantSessionId);
+}
+
+// src/auto-resume.tsx
+import { useEffect, useRef, useState } from "react";
+function useLatest(value) {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+function PickleballAutoResume(props) {
+  const {
+    provider,
+    resumeInput,
+    enabled = true,
+    sessionIdHint = null,
+    retryDelayMs = resumeRetryDelayMs,
+    onAttempt
+  } = props;
+  const live = useLivestream();
+  const { engine } = useLivestreamHost();
+  const goneRef = useRef(null);
+  const attemptRef = useRef(0);
+  const [retryTick, setRetryTick] = useState(0);
+  const { state, sessionId, adoptableSessionId } = live;
+  const resumeId = adoptableSessionId ?? sessionIdHint;
+  const liveRef = useLatest(live);
+  const onAttemptRef = useLatest(onAttempt);
+  const resumeInputRef = useLatest(resumeInput);
+  const retryDelayRef = useLatest(retryDelayMs);
+  useEffect(() => {
+    if (!enabled) return;
+    if (!resumeId || sessionId !== null || state !== "preview") return;
+    if (goneRef.current === resumeId) return;
+    let cancelled = false;
+    let timer;
+    const scheduleRetry = () => {
+      const delay = retryDelayRef.current(attemptRef.current);
+      attemptRef.current += 1;
+      timer = setTimeout(() => {
+        if (!cancelled) setRetryTick((tick) => tick + 1);
+      }, delay);
+    };
+    void (async () => {
+      const result = await provider.resume(resumeId);
+      if (cancelled) return;
+      onAttemptRef.current?.(resumeId, result.kind);
+      if (result.kind === "gone") {
+        goneRef.current = resumeId;
+        attemptRef.current = 0;
+        void engine.abandonAdoptableSession(resumeId).catch(() => void 0);
+        return;
+      }
+      if (result.kind === "retry") {
+        scheduleRetry();
+        return;
+      }
+      attemptRef.current = 0;
+      provider.adoptResumeGrant(result.grant);
+      const resumeInput2 = resumeInputRef.current;
+      await liveRef.current.start(
+        {
+          externalSessionId: resumeExternalSessionId(resumeId),
+          title: resumeInput2.titleFor?.(resumeId) ?? "Phi\xEAn \u0111ang kh\xF4i ph\u1EE5c",
+          consentVersion: resumeInput2.consentVersion,
+          visibility: resumeInput2.visibility ?? "public",
+          ...resumeInput2.metadata ? { metadata: resumeInput2.metadata } : {}
+        },
+        // Trạng thái lấy từ chính phản hồi refresh, KHÔNG đoán: gán cứng "live" là
+        // camera tự lên sóng khi chủ nó chỉ đang trực sân (18/08/2026).
+        { autoPublish: result.live }
+      ).catch(() => {
+        onAttemptRef.current?.(resumeId, "start_failed");
+        if (!cancelled) scheduleRetry();
+      });
+    })();
+    return () => {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+    };
+  }, [enabled, provider, resumeId, sessionId, state, retryTick, engine, liveRef, onAttemptRef, resumeInputRef, retryDelayRef]);
+  useEffect(() => {
+    if (!enabled || state !== "error" || sessionId === null) return;
+    const timer = setTimeout(() => {
+      onAttemptRef.current?.(sessionId, "publish_retry");
+      void liveRef.current.retry().catch(() => void 0);
+    }, retryDelayRef.current(attemptRef.current++));
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, liveRef, onAttemptRef, retryDelayRef]);
+  useEffect(() => {
+    if (!enabled || state !== "error" || sessionId !== null || !adoptableSessionId) return;
+    const timer = setTimeout(() => {
+      onAttemptRef.current?.(adoptableSessionId, "reprepare");
+      void liveRef.current.prepare().catch(() => void 0);
+    }, 2e3);
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, adoptableSessionId, liveRef, onAttemptRef]);
+  useEffect(() => {
+    if (state === "live" || state === "standby") attemptRef.current = 0;
+  }, [state]);
+  return null;
+}
+function PickleballAutoPrepare(props) {
+  const { enabled = true, captureOrientation } = props;
+  const live = useLivestream();
+  const { state } = live;
+  const liveRef = useLatest(live);
+  const orientedRef = useRef(false);
+  useEffect(() => {
+    if (!enabled || !captureOrientation || orientedRef.current) return;
+    orientedRef.current = true;
+    void liveRef.current.setCaptureOrientation(captureOrientation).catch(() => void 0);
+  }, [enabled, captureOrientation, liveRef]);
+  useEffect(() => {
+    if (!enabled) return;
+    if (state !== "idle" && state !== "ended") return;
+    void liveRef.current.prepare().catch(() => void 0);
+  }, [enabled, state, liveRef]);
+  return null;
+}
+function useStandbySession(options) {
+  const { input, enabled = true, resumeSessionId = null } = options;
+  const live = useLivestream();
+  const { state, sessionId, adoptableSessionId } = live;
+  const liveRef = useLatest(live);
+  const armedForRef = useRef(null);
+  const inputRef = useLatest(input);
+  const externalSessionId = input.externalSessionId;
+  const armed = sessionId !== null && armedForRef.current === externalSessionId;
+  useEffect(() => {
+    if (!enabled) return;
+    if (state !== "preview" || sessionId !== null) return;
+    if (armedForRef.current === externalSessionId) return;
+    if (resumeBlocksArm({
+      adoptableSessionId,
+      serverSessionId: resumeSessionId,
+      engineSessionId: sessionId
+    })) {
+      return;
+    }
+    armedForRef.current = externalSessionId;
+    void liveRef.current.start(inputRef.current, { autoPublish: false }).catch(() => {
+      armedForRef.current = null;
+    });
+  }, [enabled, state, sessionId, adoptableSessionId, resumeSessionId, externalSessionId, liveRef, inputRef]);
+  return { armed };
+}
+
+// src/camera-settings.ts
+import { useSyncExternalStore } from "react";
+var CAMERA_SETTINGS_STORAGE_KEY = "@pickleball/expo-sdk/camera-settings";
+var DEFAULT_CAMERA_SETTINGS = Object.freeze({
+  resolution: 720,
+  fps: 30,
+  antiFlicker: "50hz",
+  cameraId: null
+});
+function parseCameraSettings(raw, defaults = DEFAULT_CAMERA_SETTINGS) {
+  if (!raw) return { ...defaults };
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object") return { ...defaults };
+    return {
+      resolution: parsed.resolution === 1080 ? 1080 : parsed.resolution === 720 ? 720 : defaults.resolution,
+      fps: parsed.fps === 24 || parsed.fps === 30 || parsed.fps === 60 ? parsed.fps : defaults.fps,
+      antiFlicker: parsed.antiFlicker === "auto" || parsed.antiFlicker === "60hz" || parsed.antiFlicker === "50hz" ? parsed.antiFlicker : defaults.antiFlicker,
+      cameraId: typeof parsed.cameraId === "string" ? parsed.cameraId : null
+    };
+  } catch {
+    return { ...defaults };
+  }
+}
+function createCameraSettingsStore(options = {}) {
+  const storage = options.storage ?? createDefaultStorage();
+  const key = options.key ?? CAMERA_SETTINGS_STORAGE_KEY;
+  const defaults = { ...DEFAULT_CAMERA_SETTINGS, ...options.defaults };
+  let settings = { ...defaults };
+  let restored = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    for (const listener of listeners) listener();
+  };
+  return {
+    key,
+    get: () => settings,
+    set(patch) {
+      settings = { ...settings, ...patch };
+      void storage.setItem(key, JSON.stringify(settings)).catch(() => void 0);
+      emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    async restore() {
+      const raw = await storage.getItem(key).catch(() => null);
+      settings = parseCameraSettings(raw, defaults);
+      restored = true;
+      emit();
+    },
+    isRestored: () => restored
+  };
+}
+function useCameraSettings(store) {
+  return useSyncExternalStore(store.subscribe, store.get, store.get);
+}
+function cameraSettingsKey(settings) {
+  return `${settings.resolution}:${settings.fps}:${settings.cameraId ?? "default"}`;
+}
+function rtmpRoomFactoryFor(settings) {
+  return createRtmpRoomFactory({
+    frameRate: settings.fps,
+    ...settings.cameraId ? { cameraId: settings.cameraId } : {}
+  });
+}
+
+// src/camera-controls.ts
+function nativeModule() {
+  try {
+    const loaded = __require("@pickleball/rtmp-native");
+    const candidate = loaded?.default ?? loaded;
+    return candidate && typeof candidate === "object" ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+async function callOptional(name, invoke, fallback) {
+  const native = nativeModule();
+  if (!native || typeof native[name] !== "function") return fallback;
+  try {
+    const result = await invoke(native);
+    return result === void 0 ? fallback : result;
+  } catch {
+    return fallback;
+  }
+}
+function getCameraCapabilities() {
+  return callOptional("getCameraCapabilities", (n) => n.getCameraCapabilities?.(), null);
+}
+function setZoom(factor) {
+  return callOptional("setZoom", (n) => n.setZoom?.(factor), void 0);
+}
+function setExposureBias(ev) {
+  return callOptional("setExposureBias", (n) => n.setExposureBias?.(ev), void 0);
+}
+function setFocusLocked(locked) {
+  return callOptional("setFocusLocked", (n) => n.setFocusLocked?.(locked), void 0);
+}
+function setExposureLocked(locked) {
+  return callOptional("setExposureLocked", (n) => n.setExposureLocked?.(locked), void 0);
+}
+function setTorch(enabled) {
+  return callOptional("setTorch", (n) => n.setTorch?.(enabled), void 0);
+}
+function applyAntiFlicker(mode) {
+  return callOptional("setAntiFlicker", (n) => n.setAntiFlicker?.(mode), void 0);
+}
+function requestNativePermissions() {
+  return callOptional("requestPermissions", (n) => n.requestPermissions?.(), null);
+}
+
+export {
+  classifyResumeStatus,
+  RESUME_RETRY_DELAYS_MS,
+  resumeRetryDelayMs,
+  resumeBlocksArm,
+  resumeExternalSessionId,
+  resumeGrantMatches,
+  PickleballAutoResume,
+  PickleballAutoPrepare,
+  useStandbySession,
+  CAMERA_SETTINGS_STORAGE_KEY,
+  DEFAULT_CAMERA_SETTINGS,
+  parseCameraSettings,
+  createCameraSettingsStore,
+  useCameraSettings,
+  cameraSettingsKey,
+  rtmpRoomFactoryFor,
+  getCameraCapabilities,
+  setZoom,
+  setExposureBias,
+  setFocusLocked,
+  setExposureLocked,
+  setTorch,
+  applyAntiFlicker,
+  requestNativePermissions
+};

package/dist/{chunk-TRLASNPQ.cjs → chunk-GXQYMPHE.cjs}

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});// package.json
-var version = "0.2.0";
+var version = "1.0.0";
 
 // src/version.ts
 var PICKLEBALL_EXPO_SDK_VERSION = version;