@glassly/engine 0.3.5 → 0.3.6-beta.851

package/src/facades/ai.ts

@@ -2,8 +2,8 @@
  * ai facade — `engine.ai.local`: the on-device LLM model that serves
  * session.ai calls routed to the phone (forceLocal / localFallback). Thin
  * passthrough over LocalLlmModelManager and LocalLlmProvider so Settings >
- * AI Models can list, pick, download, and delete models without reaching
- * into engine internals.
+ * Offline Models can list, pick, download, and delete models without
+ * reaching into engine internals.
  */
 import localLlmModelManager, {
   LocalLlmModelManager,
@@ -17,7 +17,7 @@ export const ai = {
   local: {
     /** The catalog, in dropdown order. */
     models: (): LocalLlmModelConfig[] => localLlmModelManager.models(),
-    /** The Settings > AI Models pick. */
+    /** The Settings > Offline Models pick. */
     selectedModelId: (): LocalLlmModelId => localLlmModelManager.selectedModelId(),
     select: (id: LocalLlmModelId): Promise<void> => localLlmModelManager.select(id),
     isDownloaded: (id?: LocalLlmModelId): Promise<boolean> => localLlmModelManager.isModelAvailable(id),

package/src/facades/glasses.ts

@@ -12,6 +12,7 @@
 // standalone build); jest moduleNameMapper + tsconfig both resolve it.
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
 import type {
+  AppleWatchAvailability,
   ButtonPressEvent,
   ConnectOptions,
   ControllerStatus,
@@ -26,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"
@@ -42,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.
@@ -69,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() {
@@ -88,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,
@@ -190,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(),
@@ -283,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),
@@ -329,6 +346,12 @@ export const glasses = {
     setHand: (id: string, hand: "left" | "right"): Promise<void> => BluetoothSdk.neuralBandSetHand(id, hand),
   },
 
+  // --- Apple Watch (iOS): pairs through the Glassly watch app over WatchConnectivity ---
+  appleWatch: {
+    /** Whether this iPhone has a paired watch and the Glassly watch app is on it. */
+    availability: (): Promise<AppleWatchAvailability> => BluetoothSdk.appleWatchAvailability(),
+  },
+
   // --- audio (glasses media-volume, own-app playback hint, live mic level) ---
   audio: {
     /** Read the glasses' current media volume. */

package/src/facades/memory.ts

@@ -4,9 +4,10 @@
  * purge everything; the full timeline surface (lines, sessions, summaries)
  * is what miniapps reach through session.memory with the MEMORY permission.
  */
-import type {MemoryEntry, MemorySession} from "@glassly/miniapp"
+import type {MemoryEntry, MemoryExportResult, MemoryImportResult, MemorySession} from "@glassly/miniapp"
 
-import type {MemoryStats} from "../services/MemoryStore"
+import {exportMemoryFile, importMemoryFile} from "../services/memoryBackupFile"
+import {MemoryBackupError, type MemoryStats} from "../services/MemoryStore"
 import {memoryStore} from "../services/memoryStoreInstance"
 
 export const memory = {
@@ -30,6 +31,14 @@ export const memory = {
   stats: (): Promise<MemoryStats> => memoryStore.stats(),
   /** Drop the entire timeline: every entry and every summary. */
   clearAll: (): Promise<void> => memoryStore.clear(),
+  /** Share the whole timeline as a JSON backup file. */
+  exportFile: (): Promise<MemoryExportResult> => exportMemoryFile(),
+  /**
+   * Pick a backup file and merge it in, skipping what's already stored.
+   * Resolves null on cancel; rejects with a MemoryBackupError for a non-backup file.
+   */
+  importFile: (): Promise<MemoryImportResult | null> => importMemoryFile(),
+  isBackupError: (err: unknown): boolean => err instanceof MemoryBackupError,
   /** Subscribe to store mutations (from miniapps or Settings). */
   onChanged: (listener: () => void): (() => void) => memoryStore.onChanged(listener),
 }

package/src/facades/miniapps.ts

@@ -64,6 +64,9 @@ export const miniapps = {
     useAppStatusStore.getState().setHiddenStatus(...args),
   /** Mark a miniapp Always On (starts at launch, stops only from the switcher pill), persisted for the next boot. */
   setAlwaysOn: (...args: Parameters<AppsState["setAlwaysOn"]>) => useAppStatusStore.getState().setAlwaysOn(...args),
+  /** Whether a tap expands one of the miniapp's `EX` widgets to the full screen, persisted. */
+  setWidgetExpand: (...args: Parameters<AppsState["setWidgetExpand"]>) =>
+    useAppStatusStore.getState().setWidgetExpand(...args),
 
   /** Installed dashboard miniapps (manifest type "dashboard"); one runs at a time. */
   dashboards: (): ClientApp[] => useAppStatusStore.getState().apps.filter((app) => app.type === "dashboard"),

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/facades/providerKeys.ts

@@ -1,11 +1,12 @@
 /**
- * providerKeys facade — `engine.providerKeys.{anthropic,gemini,elevenlabs}`:
+ * providerKeys facade — `engine.providerKeys.{anthropic,gemini,openai,deepseek,elevenlabs}`:
  * validate-before-save probes for the user-supplied AI/voice provider keys
  * (Settings > API Keys). Same per-provider shape as `engine.maps.mapbox` /
  * `engine.speech.sonioxDirect` so the Keys screen treats providers uniformly.
  */
 import {
   validateAnthropicApiKey,
+  validateDeepSeekApiKey,
   validateElevenLabsApiKey,
   validateGeminiApiKey,
   validateOpenAiApiKey,
@@ -24,6 +25,10 @@ export const providerKeys = {
     /** Probe a key against the OpenAI API without saving it. */
     validateKey: (...args: Parameters<typeof validateOpenAiApiKey>) => validateOpenAiApiKey(...args),
   },
+  deepseek: {
+    /** Probe a key against the DeepSeek API without saving it. */
+    validateKey: (...args: Parameters<typeof validateDeepSeekApiKey>) => validateDeepSeekApiKey(...args),
+  },
   elevenlabs: {
     /** Probe a key against the ElevenLabs API without saving it. */
     validateKey: (...args: Parameters<typeof validateElevenLabsApiKey>) => validateElevenLabsApiKey(...args),

package/src/generated/releaseMetadata.ts

@@ -11,10 +11,10 @@ export interface EngineReleaseMetadata {
 
 export const ENGINE_RELEASE_METADATA: Readonly<EngineReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
-  "familyBaseVersion": "0.3.5",
-  "releaseIdentity": "0.3.5",
-  "releaseSetId": "glassly-0.3.5",
-  "sourceCommit": "dd27c8bbc0536d3479bdb50a288c2d63f2542290",
+  "familyBaseVersion": "0.3.6",
+  "releaseIdentity": "0.3.6-beta.851",
+  "releaseSetId": "glassly-0.3.6-beta.851",
+  "sourceCommit": "32a360c04986135f30d9d8886199d1e78f54f278",
   "otaManifestUrl": null,
   "otaManifestSha256": null
 })

package/src/services/AiTierResolution.ts

@@ -11,7 +11,7 @@
  */
 
 export type AiTier = "quick" | "balanced" | "frontier"
-export type AiTierProvider = "anthropic" | "gemini" | "openai"
+export type AiTierProvider = "anthropic" | "gemini" | "openai" | "deepseek"
 
 export const AI_TIERS: readonly AiTier[] = ["quick", "balanced", "frontier"]
 
@@ -27,23 +27,27 @@ export interface TierModelOption {
  * Curated per-tier model registry — the only place model ids live on the
  * phone. Order within a tier is the "auto" preference order: first entry
  * whose provider has a saved key wins. Anthropic leads (matching the cloud's
- * default provider), then Gemini (the pre-tier quick default), then OpenAI.
+ * default provider), then Gemini (the pre-tier quick default), then OpenAI,
+ * then DeepSeek.
  */
 export const TIER_MODEL_OPTIONS: Record<AiTier, TierModelOption[]> = {
   quick: [
     {provider: "anthropic", model: "claude-haiku-4-5", label: "Claude Haiku 4.5"},
     {provider: "gemini", model: "gemini-3.5-flash-lite", label: "Gemini 3.5 Flash Lite"},
     {provider: "openai", model: "gpt-5-mini", label: "GPT-5 mini"},
+    {provider: "deepseek", model: "deepseek-chat", label: "DeepSeek Chat"},
   ],
   balanced: [
     {provider: "anthropic", model: "claude-haiku-4-5", label: "Claude Haiku 4.5"},
     {provider: "gemini", model: "gemini-3.5-flash", label: "Gemini 3.5 Flash"},
     {provider: "openai", model: "gpt-5.1", label: "GPT-5.1"},
+    {provider: "deepseek", model: "deepseek-chat", label: "DeepSeek Chat"},
   ],
   frontier: [
     {provider: "anthropic", model: "claude-sonnet-5", label: "Claude Sonnet 5"},
     {provider: "gemini", model: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro"},
     {provider: "openai", model: "gpt-5.1", label: "GPT-5.1"},
+    {provider: "deepseek", model: "deepseek-reasoner", label: "DeepSeek Reasoner"},
   ],
 }
 
@@ -82,7 +86,9 @@ export function parseTierSetting(value: unknown): {provider: AiTierProvider; mod
   const stored = value.slice(sep + 1).trim()
   if (!stored) return null
   const model = RETIRED_MODELS[stored] ?? stored
-  if (provider !== "anthropic" && provider !== "gemini" && provider !== "openai") return null
+  if (provider !== "anthropic" && provider !== "gemini" && provider !== "openai" && provider !== "deepseek") {
+    return null
+  }
   return {provider, model}
 }
 

package/src/services/AppRegistry.ts

@@ -22,7 +22,7 @@ import {unzip} from "react-native-zip-archive"
 import semver from "semver"
 import {AsyncResult, Result, result as Res} from "typesafe-ts"
 
-import type {AppletPermission, AppPermissionType, AppletType, ClientApp} from "../types/applet"
+import type {AppletPermission, AppPermissionType, AppletType, ClientApp, DeclaredWidget} from "../types/applet"
 import {HardwareRequirement, HardwareRequirementLevel, HardwareType} from "../types"
 import {configuredDevHost} from "../utils/configuredDevHost"
 import {storage} from "../utils/storage/storage"
@@ -776,7 +776,7 @@ class AppRegistry {
 
         // Declared actions (for session.miniapps.list + invoke gating).
         const actions = normalizeManifestActions(manifest?.actions)
-        const widgets = normalizeManifestWidgets(manifest?.widgets)
+        const widgets = withWidgetExpandChoices(lmaInfo.packageName, normalizeManifestWidgets(manifest?.widgets))
 
         // Dev miniapps live in the same lmas/ tree as installed ones, but
         // their version directory name starts with "dev-".
@@ -864,7 +864,9 @@ class AppRegistry {
         permissions,
         hardwareRequirements,
         actions: normalizeManifestActions(rec.actions),
-        ...(normalizeManifestWidgets(rec.widgets).length > 0 ? {widgets: normalizeManifestWidgets(rec.widgets)} : {}),
+        ...(normalizeManifestWidgets(rec.widgets).length > 0
+          ? {widgets: withWidgetExpandChoices(rec.packageName, normalizeManifestWidgets(rec.widgets))}
+          : {}),
         isMiniappDev: true,
         devUrl: rec.devUrl,
         devPort: rec.devPort,
@@ -948,6 +950,19 @@ export function saveAlwaysOnOverride(packageName: string, status: boolean): void
   storage.save(`${packageName}_always_on`, status)
 }
 
+/** Applies the wearer's tap-to-expand choice to each expandable widget; expansion is on until they turn it off. */
+export function withWidgetExpandChoices(packageName: string, widgets: DeclaredWidget[]): DeclaredWidget[] {
+  return widgets.map((widget) => {
+    if (!widget.expandable) return widget
+    const res = storage.load<boolean>(`${packageName}_widget_expand_${widget.id}`)
+    return {...widget, expandOnTap: res.is_ok() ? res.value !== false : true}
+  })
+}
+
+export function saveWidgetExpandChoice(packageName: string, widgetId: string, expandOnTap: boolean): void {
+  storage.save(`${packageName}_widget_expand_${widgetId}`, expandOnTap)
+}
+
 export function getLocalAppScreenshot(packageName: string): string | undefined {
   const key = `${packageName}_screenshot`
   const res = storage.load<string>(key)

package/src/services/BlobStore.ts

@@ -383,7 +383,7 @@ export class BlobStore {
           return
         }
         up.handle.offset = payload.offset
-        up.handle.writeBytes(bytes)
+        up.handle.writeBytesSync(bytes)
         up.handle.offset = up.bytes // restore append position
         this.hooks.sendResult(packageName, requestId, true, {bytesWritten: up.bytes})
         return
@@ -397,7 +397,7 @@ export class BlobStore {
         return
       }
       up.handle.offset = up.bytes
-      up.handle.writeBytes(bytes)
+      up.handle.writeBytesSync(bytes)
       up.bytes += bytes.length
       this.hooks.sendResult(packageName, requestId, true, {bytesWritten: up.bytes})
     } catch (err) {
@@ -633,7 +633,7 @@ export class BlobStore {
     }
     try {
       const want = Math.max(0, Math.min(Number(payload.maxBytes) || 1024 * 1024, reader.remaining))
-      const bytes = want > 0 ? reader.handle.readBytes(want) : new Uint8Array(0)
+      const bytes = want > 0 ? reader.handle.readBytesSync(want) : new Uint8Array(0)
       reader.remaining -= bytes.length
       const done = reader.remaining <= 0
       const base64 = bytes.length

package/src/services/BluetoothRestoreLaunch.ts

@@ -0,0 +1,37 @@
+/**
+ * Reconnect the glasses when iOS relaunched the app for a preserved link.
+ *
+ * With CoreBluetooth state restoration, iOS keeps the lens connections after
+ * it terminates the app and relaunches it in the background on the next
+ * peripheral event. No screen mounts on that launch, so the host's usual
+ * "connect on the home screen" never runs; the engine asks native whether this
+ * is such a launch and connects the default wearable itself.
+ */
+import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
+
+type Deps = {
+  launchedForRestore: () => Promise<boolean>
+  connectDefault: () => Promise<void>
+}
+
+export async function reconnectAfterBluetoothRestoreLaunch(deps: Deps): Promise<boolean> {
+  let launched = false
+  try {
+    launched = await deps.launchedForRestore()
+  } catch (error) {
+    console.warn("BluetoothRestoreLaunch: restore-launch query failed:", error instanceof Error ? error.message : error)
+    return false
+  }
+  if (!launched) return false
+  console.log("BluetoothRestoreLaunch: relaunched for a preserved glasses link; reconnecting")
+  try {
+    await deps.connectDefault()
+  } catch (error) {
+    console.warn("BluetoothRestoreLaunch: reconnect failed:", error instanceof Error ? error.message : error)
+  }
+  return true
+}
+
+export function nativeRestoreLaunchQuery(): () => Promise<boolean> {
+  return () => BluetoothSdk.consumeBluetoothRestoreLaunch()
+}

package/src/services/ForegroundLocationPermission.ts

@@ -13,7 +13,7 @@ export interface ForegroundLocationPermissionClient {
  */
 export async function resolveForegroundLocationPermission(
   client: ForegroundLocationPermissionClient,
-  getAppState: () => string,
+  getAppState: () => string | null | undefined,
 ): Promise<ForegroundLocationPermissionResponse> {
   const current = await client.getForegroundPermissionsAsync()
   if (current.status === "granted" || getAppState() !== "active") {

package/src/services/GestureDotsService.ts

@@ -132,7 +132,8 @@ class GestureDotsService {
    * `controllerId` keeps two controllers' fingers apart.
    */
   noteGesture(gestureName: string, claimed = false, fingerIndex?: number, controllerId?: string): void {
-    if (!this.started || !this.enabled()) return
+    // A ring's scroll steps ride beside their stroke's one swipe, which already flashed.
+    if (!this.started || !this.enabled() || gestureName === "scroll_up" || gestureName === "scroll_down") return
     this.applyGesture(gestureName, claimed, fingerIndex, controllerId)
     this.trace("input", {gestureName, claimed})
   }