@glassly/engine 0.1.0-dev.1 → 0.1.0-dev.100

package/src/facades/pairing.ts

@@ -10,9 +10,10 @@
 // target hint) lives on the full surface, not the public entry (same reason
 // the glasses facade imports internal).
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
-import type {ConnectOptions, Device, PairFailureEvent, GlassesNotReadyEvent} from "@glassly/bluetooth-sdk"
+import type {ConnectOptions, Device, DeviceModel, PairFailureEvent, GlassesNotReadyEvent} from "@glassly/bluetooth-sdk"
 import {useCoreStore} from "../stores/core"
 import {useGlassesStore} from "../stores/glasses"
+import {SETTINGS, useSettingsStore} from "../stores/settings"
 import {hasDefaultDevice} from "../services/DeviceStoreHydration"
 import {
   markPendingSelection,
@@ -20,18 +21,14 @@ import {
   subscribePairingIdentity,
   type IdentitySnapshot,
 } from "../services/PairingIdentity"
-import {
-  isGlassesConnected,
-  isGlassesLinkLayerBusy,
-  isGlassesReady,
-  waitForGlassesReady,
-} from "../services/GlassesReadiness"
+import {isGlassesConnected, isGlassesLinkLayerBusy, isGlassesReady} from "../services/GlassesReadiness"
 import {
   logAutomaticReportSubmissionStatus,
   toAutomaticReportSubmissionStatus,
   type AutomaticReportSubmissionStatus,
 } from "../services/AutomaticReportResult"
 import {pushAllBluetoothSettings} from "../services/GlassesSettingsSync"
+import {ControllerTypes} from "../types"
 import {submitAutomaticReport} from "./reports"
 
 export type {IdentitySnapshot} from "../services/PairingIdentity"
@@ -60,6 +57,82 @@ function projectReadiness() {
   }
 }
 
+function projectTargetReady(options: Pick<PairingReadyWaitOptions, "deviceModel" | "deviceName">): boolean {
+  const {deviceModel, deviceName} = options
+  const glasses = useGlassesStore.getState()
+
+  if (deviceModel === ControllerTypes.R1) {
+    if (!glasses.controllerConnected || !glasses.controllerFullyBooted) return false
+    const settings = useSettingsStore.getState()
+    const pairedModel = settings.getSetting(SETTINGS.default_controller.key)
+    const pairedName = settings.getSetting(SETTINGS.controller_device_name.key)
+    return (!deviceModel || pairedModel === deviceModel) && (!deviceName || pairedName === deviceName)
+  }
+
+  if (!isGlassesReady(glasses.connection)) return false
+  const identity = projectPairingIdentity()
+  if (!deviceModel && !deviceName) return true
+  return (
+    identity.kind === "paired" &&
+    (!deviceModel || identity.model === deviceModel) &&
+    (!deviceName || identity.name === deviceName)
+  )
+}
+
+function subscribeTargetReady(
+  options: Pick<PairingReadyWaitOptions, "deviceModel" | "deviceName">,
+  cb: (ready: boolean) => void,
+): () => void {
+  let last = projectTargetReady(options)
+  const notify = () => {
+    const ready = projectTargetReady(options)
+    if (ready === last) return
+    last = ready
+    cb(ready)
+  }
+  const unsubscribeGlasses = useGlassesStore.subscribe(notify)
+  const unsubscribeSettings = useSettingsStore.subscribe(notify)
+  return () => {
+    unsubscribeGlasses()
+    unsubscribeSettings()
+  }
+}
+
+async function waitForTargetReady(options: PairingReadyWaitOptions, timeoutMs: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    if (options.signal?.aborted) {
+      resolve(false)
+      return
+    }
+    if (projectTargetReady(options)) {
+      resolve(true)
+      return
+    }
+
+    let settled = false
+    let timeout: ReturnType<typeof setTimeout> | null = null
+    let unsubscribe: (() => void) | null = null
+    let onAbort: (() => void) | null = null
+    const finish = (ready: boolean) => {
+      if (settled) return
+      settled = true
+      if (timeout) clearTimeout(timeout)
+      if (unsubscribe) unsubscribe()
+      if (onAbort && options.signal) options.signal.removeEventListener("abort", onAbort)
+      resolve(ready)
+    }
+
+    unsubscribe = subscribeTargetReady(options, (ready) => {
+      if (ready) finish(true)
+    })
+    if (options.signal) {
+      onAbort = () => finish(false)
+      options.signal.addEventListener("abort", onAbort)
+    }
+    timeout = setTimeout(() => finish(projectTargetReady(options)), timeoutMs)
+  })
+}
+
 export type PairingReadinessSnapshot = ReturnType<typeof projectReadiness>
 
 export async function submitPairingBootTimeoutReport(params: {
@@ -108,12 +181,7 @@ async function waitForReadyDuringPairing(options: PairingReadyWaitOptions = {}):
   })
 
   try {
-    const ready = await waitForGlassesReady({
-      getConnection: () => useGlassesStore.getState().connection,
-      subscribe: (listener) => useGlassesStore.subscribe((state) => state.connection, listener),
-      timeoutMs,
-      signal: options.signal,
-    })
+    const ready = await waitForTargetReady(options, timeoutMs)
 
     if (!ready && !options.signal?.aborted) {
       void submitPairingBootTimeoutReport({
@@ -193,6 +261,14 @@ export const pairing = {
       cb(snap)
     })
   },
+  /** Whether the exact wearable or controller selected on the scan screen is ready. */
+  targetReady: (options: Pick<PairingReadyWaitOptions, "deviceModel" | "deviceName">): boolean =>
+    projectTargetReady(options),
+  /** Subscribe to readiness for the exact selected target, excluding stale devices. */
+  onTargetReady: (
+    options: Pick<PairingReadyWaitOptions, "deviceModel" | "deviceName">,
+    cb: (ready: boolean) => void,
+  ): (() => void) => subscribeTargetReady(options, cb),
 
   // --- pairing-identity lifecycle (the PairingIdentity read-model + the JS-owned
   // identity writes; promotion to `paired` only ever happens natively) ---
@@ -206,7 +282,7 @@ export const pairing = {
   markPendingSelection: (model: string) => markPendingSelection(model),
 
   /** Start scanning for nearby glasses. Results land on `searchResults()`/`onFound()`. */
-  scan: (...args: Parameters<typeof BluetoothSdk.startScan>) => BluetoothSdk.startScan(...args),
+  scan: (model: DeviceModel): Promise<void> => BluetoothSdk.startScan(model),
   /** Whether a scan is currently in progress. */
   scanning: (): boolean => useCoreStore.getState().searching,
   /** Subscribe to scan-in-progress changes; fires only when it changes. Returns an unsubscribe. */
@@ -226,7 +302,7 @@ export const pairing = {
   // leak as mutable references into the store.
   searchResults: () => useCoreStore.getState().searchResults.map((result) => ({...result})),
   /** Subscribe to scan-result changes; fires only when they change. Returns an unsubscribe. */
-  onFound: (cb: (results: ReturnType<typeof useCoreStore.getState>["searchResults"]) => void): (() => void) => {
+  onFound: (cb: (results: Device[]) => void): (() => void) => {
     let last = JSON.stringify(useCoreStore.getState().searchResults)
     return useCoreStore.subscribe(() => {
       const results = useCoreStore.getState().searchResults
@@ -250,7 +326,7 @@ export const pairing = {
     return BluetoothSdk.connect(device, {...options, saveAsDefault: false})
   },
   /** Set a device as the default for subsequent `glasses.connectDefault()`. */
-  setDefault: (...args: Parameters<typeof BluetoothSdk.setDefaultDevice>) => BluetoothSdk.setDefaultDevice(...args),
+  setDefault: (device: Device | null): Promise<void> => BluetoothSdk.setDefaultDevice(device),
   /**
    * Prime the native Bluetooth Classic audio watcher with the picked device.
    * The iOS Mentra Live flow pairs Classic audio BEFORE any BLE connect
@@ -291,25 +367,29 @@ export const pairing = {
       await BluetoothSdk.stopScan()
       return
     }
-    await BluetoothSdk.disconnect()
     if (projectPairingIdentity().kind === "paired") {
       // The persisted settings describe a COMPLETE pairing: restore it to
       // native (the attempt's connect-by-name overwrote the native
       // device_name; and if native somehow lost its default entirely, this
       // repairs the divergence instead of forgetting a real pairing).
       console.log("PairingIdentity: abandonAttempt — preserving pairing; attempt cancelled, native identity re-seeded")
+      await BluetoothSdk.disconnect()
       await pushAllBluetoothSettings()
-    } else if (nativeHasDefault) {
+      return
+    }
+    if (nativeHasDefault) {
       // Mid-relay: native promoted and its echoes are still landing — the
       // incomplete JS snapshot must not be pushed over the fresher native
       // identity (the on-connect replay's race). Native holds the truth.
       console.log("PairingIdentity: abandonAttempt — preserving pairing; JS identity mid-relay, native kept as-is")
-    } else {
-      // Forgetting requires CONSENSUS: no native default AND no complete
-      // persisted pairing — a genuinely partial attempt.
-      console.log("PairingIdentity: abandonAttempt — no pairing on either layer; forgetting the partial attempt")
-      await BluetoothSdk.forget()
+      await BluetoothSdk.disconnect()
+      return
     }
+    // Partial attempt: forget owns teardown. Do NOT disconnect() first — that
+    // nulls the MentraLive SGC and used to skip Classic removeBond, leaving
+    // IBRT ACL up so glasses never re-advertise for the next scan.
+    console.log("PairingIdentity: abandonAttempt — no pairing on either layer; forgetting the partial attempt")
+    await BluetoothSdk.forget()
   },
 
   /** Subscribe to pairing failures; returns an unsubscribe. */

package/src/facades/phoneNotifications.ts

@@ -1,25 +1,40 @@
 /**
  * phoneNotifications facade — `engine.phoneNotifications`: forward phone
- * notifications to the glasses, with a per-app blocklist. Android-only (the
- * NotificationListenerService); the getters return sensible defaults on iOS.
+ * notifications to the glasses, with a per-app blocklist.
  *
- * The per-app blocklist is an engine setting (auto-synced to the native
- * listener); the installed-apps list + listener permission are CrustModule.
- * Capture itself is controlled only by Android notification access and the
- * hidden operational kill switch.
+ * Android: apps come from the NotificationListenerService's installed-apps
+ * enumeration and the blocklist filters capture phone-side.
+ * iOS: apps are the seeded catalog plus what the glasses' ANCS client has
+ * reported posting notifications (`ios_notification_seen_apps`); the blocklist
+ * is mapped onto the G2's on-glass allowlist by PhoneNotificationsSync.
+ * Capture itself is controlled by Android notification access / iOS ANCS
+ * authorization (`glasses.ancsAuthorized`), not by this facade.
  */
 import {Platform} from "react-native"
 import CrustModule from "@glassly/crust"
 import {useSettingsStore, SETTINGS} from "../stores/settings"
+import {useGlassesStore} from "../stores/glasses"
+import {getKnownNotificationApps} from "../services/PhoneNotificationsSync"
 
 export const phoneNotifications = {
-  /** The phone's installed apps (package, name, icon). (empty on iOS) */
+  /**
+   * Apps to show in the notification filter UI (package/bundle id, name, icon).
+   * Android: installed apps. iOS: seeded catalog ∪ glasses-reported apps
+   * (icons unavailable — iOS offers no cross-app icon lookup).
+   */
   installedApps: (): Promise<Array<{packageName: string; appName: string; icon: string | null}>> => {
-    if (Platform.OS !== "android") return Promise.resolve([])
-    return CrustModule.getInstalledApps()
+    if (Platform.OS === "android") return CrustModule.getInstalledApps()
+    if (Platform.OS !== "ios") return Promise.resolve([])
+    return Promise.resolve(
+      getKnownNotificationApps().map((app) => ({
+        packageName: app.appId,
+        appName: app.displayName,
+        icon: null,
+      })),
+    )
   },
 
-  /** The per-app blocklist (package names whose notifications are NOT forwarded). */
+  /** The per-app blocklist (package/bundle ids whose notifications are NOT forwarded). */
   blocklist: (): string[] => {
     const b = useSettingsStore.getState().getSetting(SETTINGS.notifications_blocklist.key)
     return Array.isArray(b) ? b : []
@@ -38,4 +53,11 @@ export const phoneNotifications = {
     if (Platform.OS !== "android") return
     return CrustModule.openNotificationListenerSettings()
   },
+
+  /**
+   * iOS: whether the connected glasses may read the phone's ANCS notification
+   * stream (the "Share System Notifications" Bluetooth consent). Always false
+   * on Android — Android capture is the notification listener instead.
+   */
+  ancsAuthorized: (): boolean => Boolean(useGlassesStore.getState().ancsAuthorized),
 }

package/src/facades/speakers.ts

@@ -13,7 +13,7 @@
  * store push back to native happens via SpeakerIdSync.
  */
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
-import type {SpeakerEnrollProgressEvent, SpeakerEnrollResultEvent} from "@glassly/bluetooth-sdk/internal"
+import type {SpeakerEnrollProgressEvent, SpeakerEnrollResultEvent} from "@glassly/bluetooth-sdk"
 
 import speakerIdModelManager, {type SpeakerIdModelProgress} from "../services/SpeakerIdModelManager"
 import type {SpeakerProfile} from "../services/SpeakerProfileStore"

package/src/facades/speech.ts

@@ -7,25 +7,39 @@
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
 import sttModelManager from "../services/STTModelManager"
 import ttsModelManager from "../services/TTSModelManager"
-import offlineSpeechModelService from "../services/OfflineSpeechModelService"
+import offlineSpeechModelService, {
+  type DownloadStatus as OfflineModelDownloadStatus,
+} from "../services/OfflineSpeechModelService"
 import sonioxDirectService from "../services/soniox/SonioxDirectService"
+import type {
+  DownloadProgress as SttDownloadProgress,
+  ExtractionProgress as SttExtractionProgress,
+  LanguageConfig as SttLanguageConfig,
+  LanguageInfo as SttLanguageInfo,
+} from "../services/STTModelManager"
 
 export const speech = {
   /** Restart the glasses' on-device transcriber (e.g. after switching STT language). */
   restartTranscriber: (): Promise<void> => BluetoothSdk.restartTranscriber(),
   stt: {
     currentLanguage: () => sttModelManager.getCurrentLanguage(),
-    languages: () => sttModelManager.getAvailableLanguages(),
-    languageInfo: () => sttModelManager.getAllLanguageInfo(),
-    download: (...args: Parameters<typeof sttModelManager.downloadModel>) => sttModelManager.downloadModel(...args),
+    languages: (): SttLanguageConfig[] => sttModelManager.getAvailableLanguages(),
+    languageInfo: (): Promise<SttLanguageInfo[]> => sttModelManager.getAllLanguageInfo(),
+    download: (
+      ...args: [
+        code?: string,
+        onProgress?: (progress: SttDownloadProgress) => void,
+        onExtractionProgress?: (progress: SttExtractionProgress) => void,
+      ]
+    ): Promise<void> => sttModelManager.downloadModel(...args),
     activate: (code: string) => sttModelManager.setCurrentLanguage(code),
     cancelDownload: () => sttModelManager.cancelDownload(),
     deleteModel: (...args: Parameters<typeof sttModelManager.deleteModel>) => sttModelManager.deleteModel(...args),
     /** Current auto-download status of the offline STT model. */
-    status: () => offlineSpeechModelService.getStatus(),
+    status: (): OfflineModelDownloadStatus | null => offlineSpeechModelService.getStatus(),
     /** Subscribe to auto-download status changes; returns an unsubscribe. */
-    onStatusChanged: (...args: Parameters<typeof offlineSpeechModelService.subscribe>) =>
-      offlineSpeechModelService.subscribe(...args),
+    onStatusChanged: (listener: (status: OfflineModelDownloadStatus | null) => void): (() => void) =>
+      offlineSpeechModelService.subscribe(listener),
   },
   /** Phone → Soniox direct transcription (user-supplied API key, Settings > Keys). */
   sonioxDirect: {

package/src/generated/releaseMetadata.ts

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

package/src/index.ts

@@ -6,8 +6,7 @@
  * renders with (decision functions, sort/order helpers, policy constants,
  * capability tables, timers). Judgment rule: read models, commands, pure
  * functions and types belong here; anything that mutates runtime state or
- * exposes a raw store/service lives on `@glassly/engine/internal`
- * (migration-era surface) or `@glassly/engine/devtools` (debug-only) instead.
+ * exposes a raw store/service remains private to the GlasslyOS host.
  * See cloud-v2/docs/issues/020-glasses-status-boundary/integration-review.md §D.
  */
 
@@ -43,6 +42,13 @@ export type {
 // device-model key helpers. The raw useSettingsStore stays internal;
 // imperative access goes through engine.settings.
 export {SETTINGS, useSetting} from "./stores/settings"
+export {
+  isCustomDashboardEligible,
+  normalizeDashboardWidgets,
+  DASHBOARD_WIDGET_IDS,
+  type DashboardWidgetId,
+  type DashboardWidgetSetting,
+} from "./services/CustomDashboardModel"
 
 // AI tier registry: the curated per-tier model dropdown options and helpers
 // the Settings > AI Models screen renders. Resolution itself runs inside
@@ -103,6 +109,7 @@ export {
   GLOBAL_OTA_TIMEOUT_MS,
   PING_INTERVAL_MS,
   QUERY_REPLY_TIMEOUT_MS,
+  BES_RESTART_TIMEOUT_MS,
   OtaProgressMessages,
 } from "./services/otaInstallPolicy"
 export {deriveDisplayState} from "./services/otaDisplayState"
@@ -112,9 +119,28 @@ export type {
   OtaProgressStatus,
   OtaStatus,
   OtaUpdateInfo,
+  ReleaseChangelog,
   OtaSnapshot,
   OtaInstallSnapshot,
 } from "./facades/ota"
+export {
+  beginOtaAutoChain,
+  clearOtaAutoChainReconnectWait,
+  isOtaAutoChainActive,
+  otaAutoChainFingerprint,
+  otaAutoChainReconnectWaitRemaining,
+  stopOtaAutoChain,
+  tryAdvanceOtaAutoChain,
+  MAX_OTA_AUTO_CHAIN_PASSES,
+  OTA_AUTO_CHAIN_RECONNECT_TIMEOUT_MS,
+} from "./services/OtaAutoChain"
+export type {OtaAutoChainAdvanceResult} from "./services/OtaAutoChain"
+export {
+  BES_INSTALL_RESTART_MESSAGE,
+  getOtaErrorMessage,
+  shouldRequireGlassesRebootForBesFailure,
+  shouldShowChangeWifiForOtaDownloadFailure,
+} from "./services/OtaErrorMapping"
 
 // Gallery read models: engine.gallery.onNotice payload types, the media
 // permission helper + display-name derivation host gallery UI uses, and the
@@ -134,7 +160,7 @@ export type {
 
 // Bluetooth SDK event types host UI subscribes to via engine facades (the
 // BluetoothSdk singleton passthrough itself is internal).
-export type {PairFailureEvent, GlassesNotReadyEvent} from "@glassly/bluetooth-sdk/internal"
+export type {PairFailureEvent, GlassesNotReadyEvent} from "@glassly/bluetooth-sdk"
 
 // Cloud connection status enum (read model; the connection store is internal).
 export {WebSocketStatus} from "./stores/connection"
@@ -179,7 +205,7 @@ export {
 export {HardwareCompatibility, type CompatibilityResult} from "./utils/hardware"
 export {BgTimer, throttle, debounce} from "./utils/timers"
 
-// Types (hardware requirement types are canonical in @glassly/miniapp; the rest are engine-owned)
+// Hardware types and capability profiles.
 export {
   HardwareType,
   HardwareRequirementLevel,
@@ -191,9 +217,9 @@ export {
   evenRealitiesG1,
   evenRealitiesG2,
   mentraLive,
+  nimo,
   vuzixZ100,
   mentraDisplay,
-  nimo,
 } from "./types"
 export type {
   HardwareRequirement,