@glassly/engine 0.3.5-dev.842 → 0.3.5-dev.844

package/src/facades/glasses.ts

@@ -27,6 +27,13 @@ import {useSettingsStore, SETTINGS} from "../stores/settings"
 import {hasDefaultDevice} from "../services/DeviceStoreHydration"
 import micStateCoordinator from "../services/MicStateCoordinator"
 import {projectPairingIdentity} from "../services/PairingIdentity"
+import {
+  fixtureControllerList,
+  fixtureControllerStatuses,
+  fixtureInfo,
+  fixtureStatus,
+  isScreenshotMode,
+} from "../services/ScreenshotFixture"
 import {isGlassesConnected, isGlassesReady} from "../services/GlassesReadiness"
 import {pushAllBluetoothSettings} from "../services/GlassesSettingsSync"
 import {isControllerReady, pairedControllersFrom, readyControllers} from "../services/controllers"
@@ -43,25 +50,33 @@ import {glassesSettings} from "./glassesSettings"
 
 let micLevelSubscriptions = 0
 
+// The screenshot fixture (ScreenshotFixture.ts) dresses these read-models
+// while the identity is the simulated device; it is a no-op outside that build.
 function projectStatus() {
   const s = useGlassesStore.getState()
-  return {
-    state: s.connection.state,
-    fullyBooted: isGlassesReady(s.connection),
-    battery: s.batteryLevel,
-    charging: s.charging,
-    case: {battery: s.caseBatteryLevel, charging: s.caseCharging, open: s.caseOpen, removed: s.caseRemoved},
-    signal: s.signalStrength,
-    micEnabled: s.micEnabled,
-    vadEnabled: s.voiceActivityDetectionEnabled,
-    btClassic: s.bluetoothClassicConnected,
-    // iOS: glasses may read the phone's ANCS stream ("Share System Notifications").
-    ancsAuthorized: Boolean(s.ancsAuthorized),
-  }
+  return fixtureStatus(
+    {
+      state: s.connection.state,
+      fullyBooted: isGlassesReady(s.connection),
+      battery: s.batteryLevel,
+      charging: s.charging,
+      case: {battery: s.caseBatteryLevel, charging: s.caseCharging, open: s.caseOpen, removed: s.caseRemoved},
+      signal: s.signalStrength,
+      micEnabled: s.micEnabled,
+      vadEnabled: s.voiceActivityDetectionEnabled,
+      btClassic: s.bluetoothClassicConnected,
+      // iOS: glasses may read the phone's ANCS stream ("Share System Notifications").
+      ancsAuthorized: Boolean(s.ancsAuthorized),
+    },
+    projectPairingIdentity(),
+  )
 }
 
 function projectControllerList(): PairedController[] {
-  return pairedControllersFrom(useSettingsStore.getState().getSetting(SETTINGS.controllers.key))
+  return fixtureControllerList(
+    pairedControllersFrom(useSettingsStore.getState().getSetting(SETTINGS.controllers.key)),
+    projectPairingIdentity(),
+  )
 }
 
 // Copies: snapshots must not hand callers mutable references into the store.
@@ -70,7 +85,27 @@ function projectControllerStatuses(): Record<string, ControllerStatus> {
   for (const [id, status] of Object.entries(useGlassesStore.getState().controllers ?? {})) {
     statuses[id] = {...status}
   }
-  return statuses
+  return fixtureControllerStatuses(statuses, projectPairingIdentity())
+}
+
+// Dedupe on the projected snapshot: the store updates on many fields; fire
+// only when the projection changes. The fixture's read-models also follow the
+// identity (a settings key), so that build watches the settings store too.
+function subscribeProjection<T>(project: () => T, cb: (snapshot: T) => void): () => void {
+  let last = JSON.stringify(project())
+  const notify = () => {
+    const snap = project()
+    const key = JSON.stringify(snap)
+    if (key === last) return
+    last = key
+    cb(snap)
+  }
+  const unsubscribeGlasses = useGlassesStore.subscribe(notify)
+  const unsubscribeSettings = isScreenshotMode() ? useSettingsStore.subscribe(notify) : () => {}
+  return () => {
+    unsubscribeGlasses()
+    unsubscribeSettings()
+  }
 }
 
 function projectKeyboardStatus() {
@@ -89,6 +124,10 @@ function projectKeyboardStatus() {
 
 function projectInfo() {
   const s = useGlassesStore.getState()
+  return fixtureInfo(projectRawInfo(s), projectPairingIdentity())
+}
+
+function projectRawInfo(s: ReturnType<typeof useGlassesStore.getState>) {
   return {
     model: s.deviceModel,
     style: s.style,
@@ -191,29 +230,9 @@ export const glasses = {
 
   // --- read-model (projected from the engine-owned glasses store) ---
   status: (): GlassesStatusSnapshot => projectStatus(),
-  onStatus: (cb: (status: GlassesStatusSnapshot) => void): (() => void) => {
-    // Dedupe: the glasses store updates on many fields; only fire when the
-    // projected status snapshot actually changes.
-    let last = JSON.stringify(projectStatus())
-    return useGlassesStore.subscribe(() => {
-      const snap = projectStatus()
-      const key = JSON.stringify(snap)
-      if (key === last) return
-      last = key
-      cb(snap)
-    })
-  },
+  onStatus: (cb: (status: GlassesStatusSnapshot) => void): (() => void) => subscribeProjection(projectStatus, cb),
   info: (): GlassesInfoSnapshot => projectInfo(),
-  onInfo: (cb: (info: GlassesInfoSnapshot) => void): (() => void) => {
-    let last = JSON.stringify(projectInfo())
-    return useGlassesStore.subscribe(() => {
-      const snap = projectInfo()
-      const key = JSON.stringify(snap)
-      if (key === last) return
-      last = key
-      cb(snap)
-    })
-  },
+  onInfo: (cb: (info: GlassesInfoSnapshot) => void): (() => void) => subscribeProjection(projectInfo, cb),
   capabilities: () => getModelCapabilities(useGlassesStore.getState().deviceModel as DeviceTypes),
   /** Ask the glasses to report fresh firmware/version info (updates the store). */
   requestVersionInfo: () => BluetoothSdk.requestVersionInfo(),
@@ -284,14 +303,11 @@ export const glasses = {
     statuses: (): Record<string, ControllerStatus> => projectControllerStatuses(),
     status: (id: string): ControllerStatus | undefined => projectControllerStatuses()[id],
     onStatus: (cb: (statuses: Record<string, ControllerStatus>) => void): (() => void) =>
-      useGlassesStore.subscribe(
-        (s) => s.controllers,
-        () => cb(projectControllerStatuses()),
-      ),
+      subscribeProjection(projectControllerStatuses, cb),
     /** Controllers delivering input (linked, route or claim done). */
     connected: (): ControllerStatus[] => readyControllers(projectControllerStatuses()),
     isConnected: (model?: string): boolean =>
-      Object.values(useGlassesStore.getState().controllers ?? {}).some(
+      Object.values(projectControllerStatuses()).some(
         (status) => isControllerReady(status) && (model === undefined || status.model === model),
       ),
     connect: (id: string): Promise<void> => BluetoothSdk.connectController(id),

package/src/facades/pairing.ts

@@ -21,6 +21,7 @@ import {
   subscribePairingIdentity,
   type IdentitySnapshot,
 } from "../services/PairingIdentity"
+import {fixtureIdentity} from "../services/ScreenshotFixture"
 import {isGlassesConnected, isGlassesLinkLayerBusy, isGlassesReady} from "../services/GlassesReadiness"
 import {
   logAutomaticReportSubmissionStatus,
@@ -278,10 +279,11 @@ export const pairing = {
   // --- pairing-identity lifecycle (the PairingIdentity read-model + the JS-owned
   // identity writes; promotion to `paired` only ever happens natively) ---
   /** The identity lifecycle snapshot: none | pending (chosen, never paired) | paired. */
-  identity: (): IdentitySnapshot => projectPairingIdentity(),
+  identity: (): IdentitySnapshot => fixtureIdentity(projectPairingIdentity()),
   /** Subscribe to identity changes; fires only when the projected snapshot changes.
    * Returns an unsubscribe. */
-  onIdentity: (cb: (identity: IdentitySnapshot) => void): (() => void) => subscribePairingIdentity(cb),
+  onIdentity: (cb: (identity: IdentitySnapshot) => void): (() => void) =>
+    subscribePairingIdentity((identity) => cb(fixtureIdentity(identity))),
   /** Mark the chosen model as the pending selection (the scan-entry write); the
    * host renders it as a finish-pairing affordance until pairing succeeds. */
   markPendingSelection: (model: string) => markPendingSelection(model),

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface EngineReleaseMetadata {
 export const ENGINE_RELEASE_METADATA: Readonly<EngineReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "0.3.5",
-  "releaseIdentity": "0.3.5-dev.842",
-  "releaseSetId": "glassly-0.3.5-dev.842",
-  "sourceCommit": "900eb91605db1aba9979aa5e6d960274ab9f6c91",
+  "releaseIdentity": "0.3.5-dev.844",
+  "releaseSetId": "glassly-0.3.5-dev.844",
+  "sourceCommit": "12cbc9656d02c3499e9014c86d19325018d6da4c",
   "otaManifestUrl": null,
   "otaManifestSha256": null
 })

package/src/services/ScreenshotFixture.ts

@@ -0,0 +1,113 @@
+/**
+ * Screenshot fixture — dresses Phone Mode up as a paired Even Realities G2
+ * with a Meta Neural Band and an R1 ring, for the store-screenshot build only
+ * (EXPO_PUBLIC_SCREENSHOT_MODE=1, set by scripts/maestro-screenshots-*.mjs
+ * for its own Release build and never by a shipped one).
+ *
+ * The fixture is applied where hosts READ — engine.pairing.identity and
+ * engine.glasses.status/info/controllers.* — not where native writes: the
+ * Simulated driver keeps running underneath (so the mirror has frames),
+ * nothing is persisted, and native never learns of the fixture, so no
+ * reconnect, demotion or driver path can act on it. It is active only while
+ * the underlying identity is the simulated device: home enters Phone Mode as
+ * usual (identity `none` passes through untouched), the simulated pairing
+ * then flips the read-models to the fixture, and real glasses on a fixture
+ * build stay real.
+ */
+import type {ControllerStatus, PairedController} from "@glassly/bluetooth-sdk"
+
+import {ControllerTypes, DeviceTypes} from "../types/enums"
+import type {IdentitySnapshot} from "./PairingIdentity"
+
+export function isScreenshotMode(): boolean {
+  return process.env.EXPO_PUBLIC_SCREENSHOT_MODE === "1"
+}
+
+export const FIXTURE_GLASSES = {
+  model: DeviceTypes.G2,
+  name: "Even G2_7F3A",
+  battery: 87,
+  caseBattery: 100,
+  signal: -58,
+} as const
+
+interface FixtureController extends PairedController {
+  batteryLevel: number
+}
+
+// The R1's id is its ring id (from the BLE name); the band's is an opaque
+// peripheral id. Both are stable fixtures so flows can target
+// `controller-tile-<id>`.
+export const FIXTURE_CONTROLLERS: readonly FixtureController[] = [
+  {id: "7C1A2B9E", model: ControllerTypes.NEURAL_BAND, name: "Meta Neural Band", batteryLevel: 73},
+  {id: "CEC5BA", model: ControllerTypes.R1, name: "CEC5BA", batteryLevel: 58},
+]
+
+/** The fixture dresses Phone Mode only. */
+export function fixtureActive(identity: IdentitySnapshot): boolean {
+  return isScreenshotMode() && identity.kind === "paired" && identity.model.includes(DeviceTypes.SIMULATED)
+}
+
+export function fixtureIdentity(identity: IdentitySnapshot): IdentitySnapshot {
+  if (!fixtureActive(identity)) return identity
+  return {kind: "paired", model: FIXTURE_GLASSES.model, name: FIXTURE_GLASSES.name}
+}
+
+interface StatusLike {
+  battery: number
+  charging: boolean
+  case: {battery: number; charging: boolean; open: boolean; removed: boolean}
+  signal: number
+}
+
+export function fixtureStatus<T extends StatusLike>(status: T, identity: IdentitySnapshot): T {
+  if (!fixtureActive(identity)) return status
+  return {
+    ...status,
+    battery: FIXTURE_GLASSES.battery,
+    charging: false,
+    case: {battery: FIXTURE_GLASSES.caseBattery, charging: false, open: false, removed: false},
+    signal: FIXTURE_GLASSES.signal,
+  }
+}
+
+interface InfoLike {
+  model: string
+  firmwareUpdateAvailable: boolean
+}
+
+export function fixtureInfo<T extends InfoLike>(info: T, identity: IdentitySnapshot): T {
+  if (!fixtureActive(identity)) return info
+  return {...info, model: FIXTURE_GLASSES.model, firmwareUpdateAvailable: false}
+}
+
+/** Fixture controllers first, then any real records that are not the fixture's. */
+export function fixtureControllerList(list: PairedController[], identity: IdentitySnapshot): PairedController[] {
+  if (!fixtureActive(identity)) return list
+  const fixture = FIXTURE_CONTROLLERS.map(({id, model, name}) => ({id, model, name}))
+  const ids = new Set(fixture.map((record) => record.id))
+  return [...fixture, ...list.filter((record) => !ids.has(record.id))]
+}
+
+export function fixtureControllerStatuses(
+  statuses: Record<string, ControllerStatus>,
+  identity: IdentitySnapshot,
+): Record<string, ControllerStatus> {
+  if (!fixtureActive(identity)) return statuses
+  const result = {...statuses}
+  for (const {id, model, name, batteryLevel} of FIXTURE_CONTROLLERS) {
+    result[id] = {
+      id,
+      model,
+      name,
+      connected: true,
+      fullyBooted: true,
+      searching: false,
+      batteryLevel,
+      charging: false,
+      macAddress: "",
+      signalStrength: -62,
+    }
+  }
+  return result
+}

package/src/stores/settings.ts

@@ -3,6 +3,7 @@ import {AsyncResult, result as Res, Result} from "typesafe-ts"
 import {create} from "zustand"
 import {subscribeWithSelector} from "zustand/middleware"
 
+import {isScreenshotMode} from "../services/ScreenshotFixture"
 import {storage} from "../utils/storage"
 import {getBluetoothSettingKeysForDevice, nativeMenuApps} from "./bluetoothSettingKeys"
 import {useGlassesStore} from "./glasses"
@@ -144,6 +145,8 @@ export const SETTINGS: Record<string, Setting> = {
   home_mirror: {
     key: "home_mirror",
     defaultValue: () => true,
+    // The store-screenshot build always shows the mirror under its fixture G2.
+    override: () => (isScreenshotMode() ? true : undefined),
     writable: true,
     saveOnServer: true,
     persist: true,