@glassly/bluetooth-sdk 0.1.0-dev.26

package/src/_private/LocalNetworkModule.ts

@@ -0,0 +1,50 @@
+import {NativeModule, requireOptionalNativeModule} from "expo"
+
+export type LocalNetworkResponse = {
+  status: number
+  headers: Record<string, string>
+  bodyBase64: string
+}
+
+export type LocalNetworkDownloadResult = {
+  statusCode: number
+  bytesWritten: number
+  headers: Record<string, string>
+}
+
+export type LocalNetworkDownloadProgress = {
+  requestId: string
+  bytesWritten: number
+  contentLength: number
+  statusCode?: number
+  headers?: Record<string, string>
+}
+
+type LocalNetworkEvents = {
+  downloadProgress: (event: LocalNetworkDownloadProgress) => void
+  networkLost: (event: {ssid: string}) => void
+}
+
+declare class LocalNetworkNativeModule extends NativeModule<LocalNetworkEvents> {
+  connect(ssid: string, password: string): Promise<{connected: boolean; ssid: string; localAddress?: string}>
+  request(
+    requestId: string,
+    url: string,
+    method: string,
+    headers: Record<string, string>,
+    body: string | null,
+    timeoutMs: number,
+  ): Promise<LocalNetworkResponse>
+  download(
+    requestId: string,
+    url: string,
+    destination: string,
+    headers: Record<string, string>,
+    connectionTimeoutMs: number,
+    readTimeoutMs: number,
+  ): Promise<LocalNetworkDownloadResult>
+  cancel(requestId: string): Promise<void>
+  disconnect(): Promise<void>
+}
+
+export default requireOptionalNativeModule<LocalNetworkNativeModule>("LocalNetwork")

package/src/_private/cameraRequestPayload.ts

@@ -0,0 +1,34 @@
+import type {WarmUpCameraParams} from "../BluetoothSdk.types"
+import {normalizePhotoSizeTier} from "./photoRequestPayload"
+
+function nonBlankString(value?: string | null): string | undefined {
+  const trimmed = value?.trim()
+  return trimmed && trimmed.length > 0 ? trimmed : undefined
+}
+
+/** Expo Android bridge rejects null values in Map<String, Any> — omit optional nullish fields. */
+export function warmUpCameraParamsForNative(params: WarmUpCameraParams): Record<string, string | number | boolean> {
+  const payload: Record<string, string | number | boolean> = {
+    size: normalizePhotoSizeTier(params.size),
+    mode: params.mode ?? "photo",
+  }
+  const requestId = nonBlankString(params.requestId)
+  if (requestId != null) {
+    payload.requestId = requestId
+  }
+  const exposureTimeNs = params.exposureTimeNs
+  if (exposureTimeNs != null && Number.isFinite(exposureTimeNs) && exposureTimeNs > 0) {
+    payload.exposureTimeNs = exposureTimeNs
+  }
+  const durationMs = params.durationMs
+  if (durationMs != null && Number.isFinite(durationMs) && durationMs > 0) {
+    payload.durationMs = Math.round(durationMs)
+  }
+  if (params.mfnr != null) {
+    payload.mfnr = params.mfnr
+  }
+  if (params.zsl != null) {
+    payload.zsl = params.zsl
+  }
+  return payload
+}

package/src/_private/photoRequestPayload.ts

@@ -0,0 +1,90 @@
+import type {PhotoRequestParams, PhotoSize, PhotoTransferMethod} from "../BluetoothSdk.types"
+
+const PHOTO_TRANSFER_METHODS = new Set<PhotoTransferMethod>(["auto", "direct", "ble"])
+
+function photoTransferMethodForNative(value: unknown): PhotoTransferMethod {
+  if (value === undefined) return "auto"
+  if (typeof value === "string" && PHOTO_TRANSFER_METHODS.has(value as PhotoTransferMethod)) {
+    return value as PhotoTransferMethod
+  }
+  throw new TypeError(`Invalid transferMethod ${JSON.stringify(value)}. Expected "auto", "direct", or "ble".`)
+}
+
+/** Maps unknown/legacy size strings to the current wire format. */
+export function normalizePhotoSizeTier(size: string | undefined): PhotoSize {
+  switch (size) {
+    case "small":
+      return "low"
+    case "large":
+      return "high"
+    case "full":
+      return "max"
+    case "low":
+    case "medium":
+    case "high":
+    case "max":
+      return size
+    default:
+      return "medium"
+  }
+}
+
+function nonBlankString(value?: string | null): string | undefined {
+  const trimmed = value?.trim()
+  return trimmed && trimmed.length > 0 ? trimmed : undefined
+}
+
+/** Expo Android bridge rejects null values in Map<String, Any> — omit optional nullish fields. */
+export function photoRequestParamsForNative(params: PhotoRequestParams): Record<string, string | number | boolean> {
+  const payload: Record<string, string | number | boolean> = {
+    size: normalizePhotoSizeTier(params.size),
+    mode: params.mode ?? "photo",
+    transferMethod: photoTransferMethodForNative(params.transferMethod),
+    webhookUrl: params.webhookUrl ?? "",
+    compress: params.compress,
+    sound: params.sound,
+  }
+  const requestId = nonBlankString(params.requestId)
+  if (requestId != null) {
+    payload.requestId = requestId
+  }
+  if (params.save != null) {
+    payload.save = params.save
+  }
+  if (params.authToken != null && params.authToken.length > 0) {
+    payload.authToken = params.authToken
+  }
+  const exposureTimeNs = params.exposureTimeNs
+  const hasManualExposure = exposureTimeNs != null && Number.isFinite(exposureTimeNs) && exposureTimeNs > 0
+  if (hasManualExposure) {
+    payload.exposureTimeNs = exposureTimeNs
+  }
+  if (hasManualExposure && params.iso != null && Number.isFinite(params.iso) && params.iso > 0) {
+    payload.iso = Math.round(params.iso)
+  }
+  if (params.aeExposureDivisor != null && params.aeExposureDivisor > 1) {
+    payload.aeExposureDivisor = Math.round(params.aeExposureDivisor)
+  }
+  if (params.isoCap != null && params.isoCap > 0) {
+    payload.isoCap = Math.round(params.isoCap)
+  }
+  if (params.noiseReduction != null) {
+    payload.noiseReduction = params.noiseReduction
+  }
+  if (params.edgeEnhancement != null) {
+    payload.edgeEnhancement = params.edgeEnhancement
+  }
+  if (params.mfnr != null) {
+    payload.mfnr = params.mfnr
+  }
+  if (params.zsl != null) {
+    payload.zsl = params.zsl
+  }
+  if (params.ispDigitalGain != null) {
+    payload.ispDigitalGain = Math.round(params.ispDigitalGain)
+  }
+  if (params.ispAnalogGain != null && params.ispAnalogGain.length > 0) {
+    payload.ispAnalogGain = params.ispAnalogGain
+  }
+  return payload
+}

package/src/_private/sdkOtaManifest.ts

@@ -0,0 +1,18 @@
+/**
+ * Release CI embeds one immutable OTA manifest URL into every SDK distribution.
+ * Source builds remain unpinned and must opt in through the debug configuration API.
+ */
+
+import {BLUETOOTH_SDK_RELEASE_METADATA} from "../generated/releaseMetadata"
+
+const packageJson = require("../../package.json") as {version?: string}
+
+/** This Bluetooth SDK package's own version, as published. */
+export const BLUETOOTH_SDK_VERSION: string = (packageJson.version ?? "").trim()
+
+/**
+ * The immutable manifest URL embedded by release CI, or null for an unpinned source build.
+ */
+export function sdkPinnedOtaManifestUrl(): string | null {
+  return BLUETOOTH_SDK_RELEASE_METADATA.otaManifestUrl
+}

package/src/changelogs.ts

@@ -0,0 +1,46 @@
+import type {ReleaseChangelog} from "./BluetoothSdk.types"
+import {GENERATED_RELEASE_CHANGELOGS} from "./generated/changelogCatalog"
+import {BLUETOOTH_SDK_RELEASE_METADATA} from "./generated/releaseMetadata"
+
+const BASE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:[-+].*)?$/
+
+function baseVersion(version: string, label: string): string {
+  const match = BASE_VERSION_PATTERN.exec(version.trim())
+  if (!match) throw new Error(`${label} must be a semantic version such as 3.1.0, 3.1.0-dev.4, or 3.1.0-beta.2`)
+  return `${match[1]}.${match[2]}.${match[3]}`
+}
+
+function compareVersions(left: string, right: string): number {
+  const a = left.split(".").map(Number)
+  const b = right.split(".").map(Number)
+  for (let index = 0; index < 3; index += 1) {
+    const left = a[index] ?? 0
+    const right = b[index] ?? 0
+    if (left !== right) return left - right
+  }
+  return 0
+}
+
+/**
+ * Return authored release notes crossed between two product versions, newest first.
+ * The target release is always included, including transitions within one base train.
+ */
+export function getReleaseChangelogs(fromVersion?: string | null, toVersion?: string | null): ReleaseChangelog[] {
+  const fallbackTarget = BLUETOOTH_SDK_RELEASE_METADATA.familyBaseVersion ?? GENERATED_RELEASE_CHANGELOGS[0]?.version
+  if (!fallbackTarget && !toVersion) return []
+  const target = baseVersion(toVersion ?? fallbackTarget, "toVersion")
+  if (!GENERATED_RELEASE_CHANGELOGS.some(({version}) => version === target)) {
+    throw new Error(`No changelog is bundled for target version ${target}`)
+  }
+  if (!fromVersion) {
+    return GENERATED_RELEASE_CHANGELOGS.filter(({version}) => version === target).map((entry) => ({...entry}))
+  }
+
+  const source = baseVersion(fromVersion, "fromVersion")
+  const direction = compareVersions(target, source)
+  return GENERATED_RELEASE_CHANGELOGS.filter(({version}) => {
+    if (direction === 0) return version === target
+    if (direction > 0) return compareVersions(version, source) > 0 && compareVersions(version, target) <= 0
+    return compareVersions(version, source) < 0 && compareVersions(version, target) >= 0
+  }).map((entry) => ({...entry}))
+}

package/src/debug.ts

@@ -0,0 +1,9 @@
+import PrivateBluetoothSdkModule from "./_private/BluetoothSdkModule"
+
+export function setOtaVersionUrl(otaVersionUrl: string): void {
+  PrivateBluetoothSdkModule.setOtaVersionUrl(otaVersionUrl)
+}
+
+export function getOtaVersionUrl(): string {
+  return PrivateBluetoothSdkModule.getOtaVersionUrl()
+}

package/src/generated/changelogCatalog.ts

@@ -0,0 +1,13 @@
+/** Generated from /changelogs. Do not edit directly. */
+export const GENERATED_RELEASE_CHANGELOGS = Object.freeze(
+[
+  {
+    "version": "3.1.0",
+    "markdown": "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- GlasslyOS, Glassly Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."
+  },
+  {
+    "version": "0.1.0",
+    "markdown": "First coordinated Glassly release: the app, Glassly Engine, and the Bluetooth SDK now ship one shared release version.\n\n- The Glassly App, Glassly Engine, and the Bluetooth SDK are versioned and published together.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."
+  }
+] as const,
+)

package/src/generated/releaseMetadata.ts

@@ -0,0 +1,20 @@
+/** Generated by release CI. Do not edit in a release checkout. */
+export interface BluetoothSdkReleaseMetadata {
+  schemaVersion: 1
+  familyBaseVersion: string | null
+  releaseIdentity: string | null
+  releaseSetId: string | null
+  sourceCommit: string | null
+  otaManifestUrl: string | null
+  otaManifestSha256: string | null
+}
+
+export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
+  "schemaVersion": 1,
+  "familyBaseVersion": "0.1.0",
+  "releaseIdentity": "0.1.0-dev.26",
+  "releaseSetId": "glassly-0.1.0-dev.26",
+  "sourceCommit": "b63f66924c61de31540b5093d05ff036c756ed74",
+  "otaManifestUrl": null,
+  "otaManifestSha256": null
+})

package/src/index.ts

@@ -0,0 +1,321 @@
+import PrivateBluetoothSdkModule from "./_private/BluetoothSdkModule"
+import type {
+  BluetoothSdkEventListener,
+  BluetoothSdkEventName,
+  BluetoothSdkPublicModule,
+  PublicBluetoothStatus,
+  PublicGlassesStatus,
+  VideoRecordingDefaults,
+} from "./BluetoothSdk.types"
+import {getReleaseChangelogs} from "./changelogs"
+
+const PUBLIC_EVENT_NAMES = new Set<BluetoothSdkEventName>([
+  "log",
+  "device_discovered",
+  "default_device_changed",
+  "glasses_not_ready",
+  "button_press",
+  "touch_event",
+  "accel_event",
+  "head_up",
+  "voice_activity_detection_status",
+  "speaking_status",
+  "battery_status",
+  "local_transcription",
+  "wifi_status_change",
+  "wifi_scan_result",
+  "hotspot_status_change",
+  "hotspot_error",
+  "photo_response",
+  "photo_status",
+  "camera_status",
+  "video_recording_status",
+  "media_success",
+  "media_error",
+  "gallery_status",
+  "compatible_glasses_search_stop",
+  "swipe_volume_status",
+  "switch_status",
+  "rgb_led_control_response",
+  "settings_ack",
+  "pair_failure",
+  "pairing_info",
+  "entering_pairing_mode",
+  "owner_replaced",
+  "audio_pairing_needed",
+  "audio_connected",
+  "audio_disconnected",
+  "mic_pcm",
+  "mic_lc3",
+  "mic_health",
+  "stream_status",
+  "mtk_update_complete",
+  "glasses_session_changed",
+  "ota_start_ack",
+  "ota_status",
+  "ar99_ota_status",
+  "g2_firmware_flash_progress",
+  "version_info",
+  "extraction_progress",
+])
+
+const addListener: BluetoothSdkPublicModule["addListener"] = (eventName, listener) => {
+  if (!PUBLIC_EVENT_NAMES.has(eventName)) {
+    throw new Error(`Unsupported BluetoothSdk event "${eventName}". Use @glassly/bluetooth-sdk/react for status state.`)
+  }
+  return PrivateBluetoothSdkModule.addListener(eventName, listener as BluetoothSdkEventListener<BluetoothSdkEventName>)
+}
+
+const startOtaUpdate: BluetoothSdkPublicModule["startOtaUpdate"] = (otaVersionUrl) => {
+  return PrivateBluetoothSdkModule.startOtaUpdate(otaVersionUrl)
+}
+
+const queryOtaStatus: BluetoothSdkPublicModule["queryOtaStatus"] = () => {
+  return PrivateBluetoothSdkModule.sendOtaQueryStatus()
+}
+
+const bindPublicMethod = <K extends keyof BluetoothSdkPublicModule>(name: K): BluetoothSdkPublicModule[K] => {
+  const method = (PrivateBluetoothSdkModule as unknown as Record<string, unknown>)[name]
+  if (typeof method === "function") {
+    return method.bind(PrivateBluetoothSdkModule) as BluetoothSdkPublicModule[K]
+  }
+
+  return (async () => {
+    throw new Error(`BluetoothSdk.${String(name)} is not available in this native build. Rebuild the app.`)
+  }) as unknown as BluetoothSdkPublicModule[K]
+}
+
+export const BluetoothSdk: BluetoothSdkPublicModule = Object.freeze({
+  addListener,
+  getGlassesStatus: bindPublicMethod("getGlassesStatus"),
+  getBluetoothStatus: bindPublicMethod("getBluetoothStatus"),
+  subscribeGlassesStatus: (listener: (changed: Partial<PublicGlassesStatus>) => void) =>
+    PrivateBluetoothSdkModule.onGlassesStatus(listener),
+  subscribeBluetoothStatus: (listener: (changed: Partial<PublicBluetoothStatus>) => void) =>
+    PrivateBluetoothSdkModule.onBluetoothStatus(listener),
+  getDefaultDevice: bindPublicMethod("getDefaultDevice"),
+  setDefaultDevice: bindPublicMethod("setDefaultDevice"),
+  clearDefaultDevice: bindPublicMethod("clearDefaultDevice"),
+  startScan: bindPublicMethod("startScan"),
+  stopScan: bindPublicMethod("stopScan"),
+  scan: bindPublicMethod("scan") as BluetoothSdkPublicModule["scan"],
+  connect: bindPublicMethod("connect"),
+  connectDefault: bindPublicMethod("connectDefault"),
+  cancelConnectionAttempt: bindPublicMethod("cancelConnectionAttempt"),
+  disconnect: bindPublicMethod("disconnect"),
+  forget: bindPublicMethod("forget"),
+  displayText: bindPublicMethod("displayText"),
+  clearDisplay: bindPublicMethod("clearDisplay"),
+  showDashboard: bindPublicMethod("showDashboard"),
+  toggleHeadUp: bindPublicMethod("toggleHeadUp"),
+  showNativeNotificationPanel: bindPublicMethod("showNativeNotificationPanel"),
+  setDashboardPosition: bindPublicMethod("setDashboardPosition"),
+  setHeadUpAngle: bindPublicMethod("setHeadUpAngle"),
+  setImuEnabled: bindPublicMethod("setImuEnabled"),
+  setScreenDisabled: bindPublicMethod("setScreenDisabled"),
+  ping: bindPublicMethod("ping"),
+  requestWifiScan: bindPublicMethod("requestWifiScan"),
+  sendWifiCredentials: bindPublicMethod("sendWifiCredentials"),
+  forgetWifiNetwork: bindPublicMethod("forgetWifiNetwork"),
+  setHotspotState: bindPublicMethod("setHotspotState"),
+  setSystemTime: bindPublicMethod("setSystemTime"),
+  setWifiAdbState: bindPublicMethod("setWifiAdbState"),
+  setGalleryModeEnabled: bindPublicMethod("setGalleryModeEnabled"),
+  setVoiceActivityDetectionEnabled: bindPublicMethod("setVoiceActivityDetectionEnabled"),
+  setLoudnessGateEnabled: bindPublicMethod("setLoudnessGateEnabled"),
+  /**
+   * @deprecated Sticky action-button photo presets are deprecated. Prefer per-request
+   * `requestPhoto(...)` options (e.g. `mode: "text"` for text sensor size/crop, or explicit per-shot
+   * fields). Still functional until removed in a future release.
+   */
+  setPhotoCaptureDefaults: bindPublicMethod("setPhotoCaptureDefaults"),
+  setVideoRecordingDefaults: ({width, height, fps}: VideoRecordingDefaults) => {
+    const method = (PrivateBluetoothSdkModule as unknown as Record<string, unknown>).setVideoRecordingDefaults
+    if (typeof method !== "function") {
+      return Promise.reject(
+        new Error("BluetoothSdk.setVideoRecordingDefaults is not available in this native build. Rebuild the app."),
+      )
+    }
+    return PrivateBluetoothSdkModule.setVideoRecordingDefaults(width, height, fps)
+  },
+  setMaxVideoRecordingDuration: bindPublicMethod("setMaxVideoRecordingDuration"),
+  setCameraFov: bindPublicMethod("setCameraFov"),
+  setLegacyCameraFov: bindPublicMethod("setLegacyCameraFov"),
+  setCameraFovOverride: bindPublicMethod("setCameraFovOverride"),
+  releaseCameraFovOverride: bindPublicMethod("releaseCameraFovOverride"),
+  setCameraTuningConfig: bindPublicMethod("setCameraTuningConfig"),
+  queryGalleryStatus: bindPublicMethod("queryGalleryStatus"),
+  requestPhoto: bindPublicMethod("requestPhoto"),
+  warmUpCamera: bindPublicMethod("warmUpCamera"),
+  stopCameraWarmUp: bindPublicMethod("stopCameraWarmUp"),
+  startVideoRecording: bindPublicMethod("startVideoRecording"),
+  stopVideoRecording: bindPublicMethod("stopVideoRecording"),
+  queryVideoRecordingStatus: bindPublicMethod("queryVideoRecordingStatus"),
+  startStream: bindPublicMethod("startStream"),
+  stopStream: bindPublicMethod("stopStream"),
+  setMicState: bindPublicMethod("setMicState"),
+  setPreferredMic: bindPublicMethod("setPreferredMic"),
+  setOwnAppAudioPlaying: bindPublicMethod("setOwnAppAudioPlaying"),
+  getGlassesMediaVolume: bindPublicMethod("getGlassesMediaVolume"),
+  setGlassesMediaVolume: bindPublicMethod("setGlassesMediaVolume"),
+  rgbLedControl: bindPublicMethod("rgbLedControl"),
+  requestVersionInfo: bindPublicMethod("requestVersionInfo"),
+  availableG2FirmwareArtifacts: bindPublicMethod("availableG2FirmwareArtifacts"),
+  startG2FirmwareFlash: bindPublicMethod("startG2FirmwareFlash"),
+  setOtaVersionUrl: bindPublicMethod("setOtaVersionUrl"),
+  getOtaVersionUrl: bindPublicMethod("getOtaVersionUrl"),
+  checkForOtaUpdate: bindPublicMethod("checkForOtaUpdate"),
+  getReleaseChangelogs,
+  startOtaUpdate,
+  queryOtaStatus,
+  startAr99OtaFromFile: bindPublicMethod("startAr99OtaFromFile"),
+  cancelAr99Ota: bindPublicMethod("cancelAr99Ota"),
+  sendAr99FactoryReset: bindPublicMethod("sendAr99FactoryReset"),
+  buildAr99OtaSignature: bindPublicMethod("buildAr99OtaSignature"),
+  setSttModelDetails: bindPublicMethod("setSttModelDetails"),
+  getSttModelPath: bindPublicMethod("getSttModelPath"),
+  checkSttModelAvailable: bindPublicMethod("checkSttModelAvailable"),
+  validateSttModel: bindPublicMethod("validateSttModel"),
+  extractTarBz2: bindPublicMethod("extractTarBz2"),
+  restartTranscriber: bindPublicMethod("restartTranscriber"),
+  setTtsModelDetails: bindPublicMethod("setTtsModelDetails"),
+  getTtsModelPath: bindPublicMethod("getTtsModelPath"),
+  getTtsModelLanguage: bindPublicMethod("getTtsModelLanguage"),
+  checkTtsModelAvailable: bindPublicMethod("checkTtsModelAvailable"),
+  validateTtsModel: bindPublicMethod("validateTtsModel"),
+  generateTtsAudio: bindPublicMethod("generateTtsAudio"),
+})
+
+export default BluetoothSdk
+
+export {
+  CAMERA_FOV_DEFAULT,
+  CAMERA_FOV_MAX,
+  CAMERA_FOV_MIN,
+  DeviceModels,
+  isBusyGlassesConnectionStatus,
+  isConnectedGlassesConnectionStatus,
+  isConnectedWifiStatus,
+  isEnabledHotspotStatus,
+  isReadyGlassesConnectionStatus,
+} from "./BluetoothSdk.types"
+
+export type {
+  AccelEvent,
+  Ar99OtaStatusEvent,
+  AudioConnectedEvent,
+  AudioDisconnectedEvent,
+  AudioPairingNeededEvent,
+  BatteryStatusEvent,
+  BluetoothSdkEvent,
+  BluetoothSdkEventListener,
+  BluetoothSdkEventMap,
+  BluetoothSdkEventName,
+  BluetoothSdkPublicModule as BluetoothSdkModule,
+  BluetoothSdkSubscription,
+  ButtonPhotoSize,
+  PhotoCaptureDefaults,
+  ButtonPressEvent,
+  CameraFovPreset,
+  CameraFovRequest,
+  CameraFovResult,
+  CameraRoiPosition,
+  CompatibleGlassesSearchStopEvent,
+  ConnectOptions,
+  ConnectedGlassesConnectionStatus,
+  ConnectedWifiStatus,
+  Device,
+  DeviceModel,
+  EnabledHotspotStatus,
+  GalleryStatusEvent,
+  G2FirmwareArtifact,
+  G2FirmwareFlashProgressEvent,
+  G2FirmwareFlashResult,
+  G2FirmwareTarget,
+  GlassesConnectionStatus,
+  GlassesMediaVolumeGetResult,
+  GlassesMediaVolumeSetResult,
+  GlassesNotReadyEvent,
+  HeadUpEvent,
+  HotspotErrorEvent,
+  HotspotStatus,
+  HotspotStatusChangeEvent,
+  GlassesSessionChangedEvent,
+  KeepAliveAckEvent,
+  LocalTranscriptionEvent,
+  LogEvent,
+  MicLc3Event,
+  MicHealthEvent,
+  MicMode,
+  MicPcmEvent,
+  MicPreference,
+  OtaStartAckEvent,
+  OtaProgress,
+  OtaProgressStatus,
+  OtaStage,
+  OtaStatus,
+  OtaStatusEvent,
+  OtaQueryResult,
+  OtaUpdateInfo,
+  ReleaseChangelog,
+  SpeakerEnrollProgressEvent,
+  SpeakerEnrollResultEvent,
+  MtkUpdateCompleteEvent,
+  PairFailureEvent,
+  PairingInfoEvent,
+  EnteringPairingModeEvent,
+  OwnerReplacedEvent,
+  PhotoCaptureMetadata,
+  PhotoResolvedConfig,
+  PhotoCompression,
+  PhotoFpsRange,
+  PhotoMeteredPreview,
+  PhotoMode,
+  PublicBluetoothStatus,
+  PublicGlassesStatus,
+  PhotoTransferMethod,
+  PhotoResponseEvent,
+  PhotoRequestedCaptureConfig,
+  PhotoRequestParams,
+  PhotoSize,
+  PhotoStatusEvent,
+  PhotoStatusState,
+  PhotoSuccessResponseEvent,
+  RgbLedAction,
+  RgbLedColor,
+  RgbLedControlResponseEvent,
+  RgbLedControlSuccessResponseEvent,
+  ScanModelOptions,
+  ScanOptions,
+  ScanResultsCallback,
+  SpeakingStatusEvent,
+  SettingsAckEvent,
+  SettingsAckSetting,
+  SettingsAckSuccessEvent,
+  SettingsAckSuccessStatus,
+  SettingsAckStatus,
+  StreamAudioConfig,
+  StreamResolvedConfig,
+  StreamStartRequest,
+  StreamStatusEvent,
+  StreamStatusLifecycleState,
+  StreamStatusReconnectState,
+  StreamStatusState,
+  StreamVideoConfig,
+  SwipeVolumeStatusEvent,
+  SwitchStatusEvent,
+  TouchEvent,
+  VideoRecordingDefaults,
+  VideoRecordingStartedStatusEvent,
+  VideoRecordingStatusEvent,
+  VideoRecordingStatusState,
+  VideoRecordingStoppedStatusEvent,
+  VideoRecordingSuccessStatusEvent,
+  VersionInfoEvent,
+  VersionInfoResult,
+  WifiScanResultEvent,
+  VoiceActivityDetectionStatusEvent,
+  WifiSearchResult,
+  WifiStatus,
+  WifiStatusChangeEvent,
+} from "./BluetoothSdk.types"

package/src/ota-server/OtaServer.types.ts

@@ -0,0 +1,10 @@
+export type OtaServerResult = {
+  baseUrl: string
+  host: string
+  manifestUrl: string
+  port: number
+}
+
+export type OtaServerModuleEvents = {
+  artifactDownloadProgress: (event: {destination: string; bytesWritten: number; contentLength: number}) => void
+}

package/src/ota-server/OtaServerModule.ts

@@ -0,0 +1,23 @@
+import {NativeModule, requireNativeModule} from "expo"
+
+import type {OtaServerModuleEvents, OtaServerResult} from "./OtaServer.types"
+
+declare class OtaServerModule extends NativeModule<OtaServerModuleEvents> {
+  /**
+   * Serve `manifestJson` at /version.json and `artifactPaths` (sha256 -> local file path)
+   * at /artifacts/<sha256>. Pass `host` when the caller knows the authoritative local
+   * address (e.g. from the scoped hotspot network); omit to fall back to interface
+   * scanning. Returns the URLs to hand to the glasses via ota_start.
+   */
+  startOtaServer(
+    manifestJson: string,
+    artifactPaths: Record<string, string>,
+    host?: string | null,
+  ): Promise<OtaServerResult>
+  stopOtaServer(): Promise<void>
+  /** Wait for iPhone Wi-Fi (`en0`) to acquire an address on the glasses gateway subnet. */
+  waitForWifiAddress(gateway: string, timeoutMs: number): Promise<string>
+  downloadArtifact(source: string, destination: string): Promise<{statusCode: number; bytesWritten: number}>
+}
+
+export default requireNativeModule<OtaServerModule>("OtaServer")

package/src/ota-server/OtaServerModule.web.ts

@@ -0,0 +1,17 @@
+import {NativeModule, registerWebModule} from "expo"
+
+import type {OtaServerModuleEvents, OtaServerResult} from "./OtaServer.types"
+
+class OtaServerModule extends NativeModule<OtaServerModuleEvents> {
+  async startOtaServer(): Promise<OtaServerResult> {
+    throw new Error("The OTA server is only available in native apps.")
+  }
+
+  async stopOtaServer(): Promise<void> {}
+
+  async waitForWifiAddress(): Promise<string> {
+    throw new Error("The OTA server is only available in native apps.")
+  }
+}
+
+export default registerWebModule(OtaServerModule, "OtaServer")

package/src/ota-server/index.ts

@@ -0,0 +1,2 @@
+export {default} from "./OtaServerModule"
+export * from "./OtaServer.types"