@glassly/engine 0.3.7 → 0.3.8-beta.1013

package/src/services/OfflineActivity.ts

@@ -0,0 +1,131 @@
+/**
+ * What the phone is running on-device right now (transcription, translation,
+ * LLM) and why, for the home offline card. Producers push in; it imports
+ * nothing at runtime so their test stubs stay unaffected.
+ */
+import type {LocalLlmReason} from "./LlmRouting"
+import type {LocalSttFallbackReason} from "./LocalSttFallbackCoordinator"
+
+export type OfflineActivityReason = LocalSttFallbackReason | LocalLlmReason
+
+export interface OfflineTranscriptionActivity {
+  reason: LocalSttFallbackReason
+  model: string
+}
+
+export interface OfflineTranslationPair {
+  source: string
+  target: string
+}
+
+export interface OfflineTranslationActivity {
+  reason: OfflineActivityReason
+  pairs: OfflineTranslationPair[]
+}
+
+export interface OfflineLlmActivity {
+  reason: LocalLlmReason
+  model: string
+  requests: number
+}
+
+export interface OfflineActivity {
+  transcription: OfflineTranscriptionActivity | null
+  translation: OfflineTranslationActivity | null
+  llm: OfflineLlmActivity | null
+}
+
+export interface ServedTranslationPair extends OfflineTranslationPair {
+  forceLocal: boolean
+}
+
+const EMPTY: OfflineActivity = {transcription: null, translation: null, llm: null}
+
+class OfflineActivityTracker {
+  private transcription: OfflineTranscriptionActivity | null = null
+  private llmRuns: Array<{reason: LocalLlmReason; model: string}> = []
+  private translationSource: (() => ServedTranslationPair[]) | null = null
+  private snapshot: OfflineActivity = EMPTY
+  private snapshotKey = JSON.stringify(EMPTY)
+  private listeners = new Set<(activity: OfflineActivity) => void>()
+
+  current(): OfflineActivity {
+    return this.snapshot
+  }
+
+  subscribe(listener: (activity: OfflineActivity) => void): () => void {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  setTranscription(transcription: OfflineTranscriptionActivity | null): void {
+    this.transcription = transcription
+    this.refresh()
+  }
+
+  beginLlm(reason: LocalLlmReason, model: string): () => void {
+    const run = {reason, model}
+    this.llmRuns.push(run)
+    this.refresh()
+    let ended = false
+    return () => {
+      if (ended) return
+      ended = true
+      this.llmRuns = this.llmRuns.filter((r) => r !== run)
+      this.refresh()
+    }
+  }
+
+  setTranslationSource(source: (() => ServedTranslationPair[]) | null): void {
+    this.translationSource = source
+    this.refresh()
+  }
+
+  refresh(): void {
+    const next: OfflineActivity = {
+      transcription: this.transcription,
+      translation: this.translation(),
+      llm: this.llm(),
+    }
+    const key = JSON.stringify(next)
+    if (key === this.snapshotKey) return
+    this.snapshotKey = key
+    this.snapshot = next
+    for (const listener of this.listeners) {
+      try {
+        listener(next)
+      } catch (error) {
+        console.warn("OfflineActivity: listener failed:", error)
+      }
+    }
+  }
+
+  reset(): void {
+    this.transcription = null
+    this.llmRuns = []
+    this.translationSource = null
+    this.refresh()
+  }
+
+  private translation(): OfflineTranslationActivity | null {
+    if (!this.transcription || !this.translationSource) return null
+    const pairs = this.translationSource()
+    if (pairs.length === 0) return null
+    return {
+      reason: pairs.some((p) => p.forceLocal) ? "force_local" : this.transcription.reason,
+      pairs: pairs.map(({source, target}) => ({source, target})),
+    }
+  }
+
+  private llm(): OfflineLlmActivity | null {
+    const latest = this.llmRuns[this.llmRuns.length - 1]
+    if (!latest) return null
+    return {reason: latest.reason, model: latest.model, requests: this.llmRuns.length}
+  }
+}
+
+export {OfflineActivityTracker}
+const offlineActivity = new OfflineActivityTracker()
+export default offlineActivity

package/src/services/PhoneCalendarService.ts

@@ -49,9 +49,16 @@ export async function listPhoneCalendarEvents(request: CalendarListRequest): Pro
   if (calendars.length === 0) return {events: [], truncated: false}
 
   const rawEvents = await Calendar.listEvents(calendars, startsAt, endsAt)
+  const seen = new Set<string>()
   const events = rawEvents
     .map(normalizeCalendarEvent)
     .filter((event) => calendarEventOverlapsWindow(event, startsAt, endsAt))
+    .filter((event) => {
+      const key = `${event.title}\n${event.startsAt}\n${event.endsAt}\n${event.allDay}`
+      if (seen.has(key)) return false
+      seen.add(key)
+      return true
+    })
     .sort((a, b) => Date.parse(a.startsAt) - Date.parse(b.startsAt) || Date.parse(a.endsAt) - Date.parse(b.endsAt))
 
   return {

package/src/services/PhoneNotificationsSync.ts

@@ -91,6 +91,11 @@ export function nativeNotificationsSupported(): boolean {
   return getModelCapabilities(model).hasNativeNotifications === true
 }
 
+function notificationRelaySupported(): boolean {
+  const model = useGlassesStore.getState().deviceModel as DeviceTypes
+  return Platform.OS === "ios" && getModelCapabilities(model).hasNotificationRelay === true
+}
+
 /** Popup durations the firmware accepts, or an empty list when it takes any. */
 export function nativeNotificationPopupSeconds(): number[] {
   const model = useGlassesStore.getState().deviceModel as DeviceTypes
@@ -141,10 +146,10 @@ export function currentPresentationOwner(hostActive: boolean): PresentationOwner
  */
 export function captureAuthorization(): "granted" | "denied" | "unknown" | "not_needed" {
   if (Platform.OS !== "ios") return "not_needed"
-  if (!nativeNotificationsSupported()) return "not_needed"
+  if (!nativeNotificationsSupported() && !notificationRelaySupported()) return "not_needed"
   const glasses = useGlassesStore.getState()
   if (!isGlassesConnected(glasses.connection)) return "unknown"
-  return glasses.ancsAuthorized ? "granted" : "denied"
+  return glasses.ancsAuthorized ? "granted" : notificationRelaySupported() ? "unknown" : "denied"
 }
 
 /**
@@ -178,7 +183,7 @@ function pushListenerConfig(): void {
 }
 
 function pushGlassesConfig(): void {
-  if (!nativeNotificationsSupported()) return
+  if (!nativeNotificationsSupported() && !notificationRelaySupported()) return
   if (!isGlassesConnected(useGlassesStore.getState().connection)) return
   void Promise.resolve(BluetoothSdk.setGlassesNotificationConfig(desiredGlassesNotificationConfig())).catch(
     (err: unknown) =>

package/src/services/STTModelManager.ts

@@ -228,6 +228,12 @@ class STTModelManager {
     return this.currentLanguage
   }
 
+  currentModelLabel(): string {
+    const language = this.config(this.currentLanguage)
+    if (!language) return this.currentLanguage
+    return language.type === "apple" ? `Apple · ${language.displayName}` : language.displayName
+  }
+
   setCurrentLanguage(code: string): void {
     if (this.config(code)) {
       this.currentLanguage = code

package/src/services/SceneRenderer.ts

@@ -250,7 +250,7 @@ class SceneRenderer {
       return {kind: "legacy", layout, degraded, dropped}
     }
 
-    const processed = processScene(elements, caps, displayProcessor.getProfile())
+    const processed = processScene(elements, caps, displayProcessor.getSceneProfile())
     // A stale baseline means the glasses were cleared since the last commit —
     // diff from empty so everything repaints (the retained frame stays valid
     // as the replay source only).

package/src/services/appStateBackupFile.ts

@@ -0,0 +1,171 @@
+/**
+ * App state backup files: the share-sheet export and file-picker restore
+ * behind Settings > Profile > Backup. What goes in the file is decided in
+ * AppStateBackup.ts; this side reads and writes the live stores.
+ */
+
+import type {MemoryImportResult} from "@glassly/miniapp"
+import {File, Paths} from "expo-file-system"
+import {Platform} from "react-native"
+import Share from "react-native-share"
+
+import {SETTINGS, useSettingsStore} from "../stores/settings"
+import {useAppStatusStore} from "../stores/apps"
+import {storage} from "../utils/storage/storage"
+import appRegistry, {saveAlwaysOnOverride, saveWidgetExpandChoice} from "./AppRegistry"
+import {
+  AppStateBackupError,
+  collectAppStateBackup,
+  miniappPrefs,
+  miniappsWithStorage,
+  parseAppStateBackup,
+  restorableSettings,
+  restoreMiniappStorage,
+  type AppStateBackupBackend,
+} from "./AppStateBackup"
+import {cloudClientService} from "./CloudClientService"
+import {memoryStore} from "./memoryStoreInstance"
+import {respawnMiniapp, runningMiniappPackages, stopMiniapp} from "./MiniappEngine"
+
+export interface AppStateExportResult {
+  success: boolean
+  cancelled?: boolean
+}
+
+export interface AppStateRestoreResult {
+  /** Settings written. */
+  settings: number
+  /** Miniapps whose storage was restored. */
+  miniapps: number
+  memory: MemoryImportResult | null
+  /** Installed when the backup was made but not on this phone now. */
+  missing: string[]
+}
+
+export interface AppStateRestoreOptions {
+  /**
+   * Install what the backup had installed and this phone lacks. Runs before
+   * the restored miniapps start again, so the dashboard comes back with every
+   * widget provider its saved layout names: it drops unknown widgets from the
+   * layout the next time it saves it.
+   */
+  reinstall?: (packageNames: string[]) => Promise<void>
+}
+
+const PICK_MIME_TYPES =
+  Platform.OS === "android" ? ["application/json", "application/octet-stream"] : ["application/json"]
+
+const backend: AppStateBackupBackend = {
+  get(key) {
+    const result = storage.load<unknown>(key)
+    return result.is_ok() ? result.value : null
+  },
+  set(key, value) {
+    const result = storage.save(key, value)
+    if (result.is_error()) throw result.error
+  },
+  keys: () => storage.getAllKeys(),
+}
+
+export async function exportAppStateFile(): Promise<AppStateExportResult> {
+  const userId = await cloudClientService.resolveUserId()
+  const installed: Array<{packageName: string; version: string; source?: string}> = []
+  for (const app of await appRegistry.getInstalledMiniapps()) {
+    const version = await appRegistry.getActiveVersion(app.packageName)
+    if (!version) continue
+    installed.push({
+      packageName: app.packageName,
+      version,
+      source: appRegistry.getReleaseIdentity(app.packageName, version)?.source,
+    })
+  }
+  const backup = collectAppStateBackup({
+    backend,
+    userId,
+    settings: Object.values(SETTINGS),
+    installed,
+    memory: await memoryStore.exportBackup(),
+    now: Date.now(),
+  })
+
+  const filename = `glassly-backup-${localDate(backup.exportedAt)}.json`
+  const file = new File(Paths.cache, filename)
+  file.writeSync(JSON.stringify(backup))
+  try {
+    await Share.open({url: file.uri, type: "application/json", filename, title: "Glassly backup"})
+    return {success: true}
+  } catch (error: any) {
+    // react-native-share rejects when the user dismisses the sheet.
+    if (error?.message?.includes("User did not share")) return {success: false, cancelled: true}
+    throw error
+  }
+}
+
+/** Resolves null when the user cancels the picker. */
+export async function importAppStateFile(opts: AppStateRestoreOptions = {}): Promise<AppStateRestoreResult | null> {
+  const picked = await File.pickFileAsync({mimeTypes: PICK_MIME_TYPES})
+  if (picked.canceled) return null
+  let data: unknown
+  try {
+    data = JSON.parse(await picked.result.text())
+  } catch {
+    throw new AppStateBackupError("Not a Glassly app state backup")
+  }
+  const backup = parseAppStateBackup(data)
+  const userId = await cloudClientService.resolveUserId()
+
+  // First, so a memory section this build rejects fails the restore before anything is written.
+  const memory = backup.memory ? await memoryStore.importBackup(backup.memory) : null
+
+  const {plain, indexed} = restorableSettings(backup, Object.values(SETTINGS))
+  const written = await useSettingsStore.getState().setManyLocally(plain)
+  if (written.is_error()) throw written.error
+  // setManyLocally only takes registry keys; `key:index` values go to storage and the store directly.
+  for (const [key, value] of Object.entries(indexed)) backend.set(key, value)
+  if (Object.keys(indexed).length > 0) {
+    useSettingsStore.setState((state) => ({settings: {...state.settings, ...indexed}}))
+  }
+
+  // A running miniapp holds its old values in memory and could write them back over the
+  // restore, so the ones getting storage stop now and start again at the end.
+  const running = new Set(runningMiniappPackages())
+  const restarting = miniappsWithStorage(backup).filter((packageName) => running.has(packageName))
+  for (const packageName of restarting) await stopMiniapp(packageName)
+
+  try {
+    const restored = restoreMiniappStorage(backend, userId, backup)
+
+    const apps = useAppStatusStore.getState()
+    for (const [packageName, record] of Object.entries(backup.miniapps)) {
+      const prefs = miniappPrefs(record)
+      if (prefs.hidden !== undefined) apps.setHiddenStatus(packageName, prefs.hidden)
+      if (prefs.alwaysOn !== undefined) saveAlwaysOnOverride(packageName, prefs.alwaysOn)
+      for (const [widgetId, expand] of Object.entries(prefs.widgetExpand)) {
+        saveWidgetExpandChoice(packageName, widgetId, expand)
+      }
+    }
+    appRegistry.markRefreshNeeded()
+    await apps.refresh()
+
+    const installedNow = new Set((await appRegistry.getInstalledMiniapps()).map((app) => app.packageName))
+    const missing = Object.entries(backup.miniapps)
+      .filter(([packageName, record]) => record.installed && !installedNow.has(packageName))
+      .map(([packageName]) => packageName)
+    if (missing.length > 0) await opts.reinstall?.(missing)
+
+    return {
+      settings: Object.keys(plain).length + Object.keys(indexed).length,
+      miniapps: restored.packages.length,
+      memory,
+      missing,
+    }
+  } finally {
+    for (const packageName of restarting) await respawnMiniapp(packageName)
+  }
+}
+
+function localDate(ms: number): string {
+  const d = new Date(ms)
+  const pad = (n: number) => String(n).padStart(2, "0")
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
+}

package/src/services/controllers.ts

@@ -26,8 +26,8 @@ const NEURAL_BAND_SURFACE: InputSurface = {
   ],
 }
 
-/** The Apple Watch trackpad's taps and four-way swipes, and the Digital Crown as the dial. */
-const APPLE_WATCH_SURFACE: InputSurface = {
+/** A watch trackpad's taps and four-way swipes, and the crown (Apple) or rotary bezel (Wear OS) as the dial. */
+const WATCH_SURFACE: InputSurface = {
   type: "swipe2d",
   events: [
     "TAP",
@@ -42,10 +42,21 @@ const APPLE_WATCH_SURFACE: InputSurface = {
   ],
 }
 
+/** The Gamebrick's D-pad is four absolute swipes; A is the press lifecycle (tap and hold) and B a double tap. */
+const GAMEBRICK_SURFACE: InputSurface = {
+  type: "swipe2d",
+  events: ["TAP", "DOUBLE_TAP", "PRESS_HOLD", "SWIPE_UP", "SWIPE_DOWN", "SWIPE_LEFT", "SWIPE_RIGHT"],
+}
+
 // The R1 swipes up/down like the temples it stands in for, so it adds nothing.
 const INPUT_SURFACES: Readonly<Record<string, readonly InputSurface[]>> = {
   [ControllerTypes.NEURAL_BAND]: [NEURAL_BAND_SURFACE],
-  [ControllerTypes.APPLE_WATCH]: [APPLE_WATCH_SURFACE],
+  [ControllerTypes.APPLE_WATCH]: [WATCH_SURFACE],
+  [ControllerTypes.WEAR_OS]: [WATCH_SURFACE],
+  [ControllerTypes.GAMEBRICK]: [GAMEBRICK_SURFACE],
+  [ControllerTypes.IINE_ANANKE]: [GAMEBRICK_SURFACE],
+  [ControllerTypes.ZERO2]: [GAMEBRICK_SURFACE],
+  [ControllerTypes.MICRO]: [GAMEBRICK_SURFACE],
   [ControllerTypes.R1]: [],
 }
 

package/src/services/effectiveCapabilities.ts

@@ -61,6 +61,8 @@ function glassesCapabilities(model: DeviceTypes): Capabilities {
   // Glassly CFW supports the complete vector contract, including SVG and rotation.
   // Upstream g2flash publishes a raster canvas with sceneVector=false.
   const vector = useGlassesStore.getState().sceneVector === true
+  // Depth is a disparity between the lenses; one panel (MemoMind One) draws every element flat.
+  const stereo = (base.display.count ?? 1) >= 2
   return {
     ...(volumeGate ? withVolumeGate(base) : base),
     hasNativeNavigation: resolveNativeNavigation(base.hasNativeNavigation, true, forceNativeNavigationOnCfw()),
@@ -68,6 +70,9 @@ function glassesCapabilities(model: DeviceTypes): Capabilities {
       ...base.display,
       width: canvas.width,
       height: canvas.height,
+      // A Glassly CFW that publishes a canvas takes positioned elements, whatever
+      // the stock profile says (the G1's stock firmware degrades scenes to text walls).
+      canPosition: true,
       maxTextElements: Math.max(
         base.display.maxTextElements ?? 0,
         vector ? CFW_VECTOR_MAX_ELEMENTS : CFW_MAX_TEXT_ELEMENTS,
@@ -78,7 +83,7 @@ function glassesCapabilities(model: DeviceTypes): Capabilities {
         vector ? CFW_VECTOR_MAX_ELEMENTS : CFW_MAX_IMAGE_ELEMENTS,
       ),
       ...(vector
-        ? {shapes: [...ALL_DISPLAY_SHAPES, "svg" as const], animation: true, rotation: true, depth: true}
+        ? {shapes: [...ALL_DISPLAY_SHAPES, "svg" as const], animation: true, rotation: true, depth: stereo}
         : {}),
     },
   }

package/src/services/neuralBand/NeuralBandInput.ts

@@ -6,7 +6,12 @@
  * latest claim is also kept on its own, since the pairing screen runs before
  * the band's id reaches JS.
  */
-import type {NeuralBandClaimEvent, NeuralBandHandwritingEvent, NeuralBandPointerEvent} from "@glassly/bluetooth-sdk"
+import type {
+  NeuralBandClaimEvent,
+  NeuralBandFirmwareEvent,
+  NeuralBandHandwritingEvent,
+  NeuralBandPointerEvent,
+} from "@glassly/bluetooth-sdk"
 import {MiniappStreamType} from "@glassly/miniapp"
 
 import type {KeyboardEventPayload} from "../GlassesKeyboardInput"
@@ -34,6 +39,8 @@ export interface NeuralBandHandwritingUpdate {
   status: NeuralBandHandwritingStatus
 }
 
+export type NeuralBandFirmwareStatus = Omit<NeuralBandFirmwareEvent, "type" | "controllerId"> & {known: boolean}
+
 export interface NeuralBandInputOptions {
   forward?: (stream: string, payload: unknown) => void
   now?: () => number
@@ -67,13 +74,25 @@ function codeFor(char: string): string {
 
 const IDLE_CLAIM: NeuralBandClaimStatus = {stage: "idle", sessionExpired: false}
 const IDLE_HANDWRITING: NeuralBandHandwritingStatus = {phase: "idle", message: "", text: ""}
+const IDLE_FIRMWARE: NeuralBandFirmwareStatus = {
+  known: false,
+  connected: false,
+  hasMetaSession: false,
+  checked: false,
+  updateAvailable: false,
+  phase: "idle",
+  progress: 0,
+  message: "",
+}
 
 export class NeuralBandInput {
   private latestClaim: NeuralBandClaimStatus = IDLE_CLAIM
   private claims = new Map<string, NeuralBandClaimStatus>()
   private handwriting = new Map<string, NeuralBandHandwritingStatus>()
+  private firmware = new Map<string, NeuralBandFirmwareStatus>()
   private claimListeners = new Set<(status: NeuralBandClaimStatus) => void>()
   private handwritingListeners = new Set<(update: NeuralBandHandwritingUpdate) => void>()
+  private firmwareListeners = new Set<(update: {id: string; status: NeuralBandFirmwareStatus}) => void>()
   private readonly forward: (stream: string, payload: unknown) => void
   private readonly now: () => number
 
@@ -102,6 +121,15 @@ export class NeuralBandInput {
     return () => this.handwritingListeners.delete(cb)
   }
 
+  firmwareStatus(controllerId: string): NeuralBandFirmwareStatus {
+    return this.firmware.get(controllerId) ?? IDLE_FIRMWARE
+  }
+
+  onFirmwareStatus(cb: (update: {id: string; status: NeuralBandFirmwareStatus}) => void): () => void {
+    this.firmwareListeners.add(cb)
+    return () => this.firmwareListeners.delete(cb)
+  }
+
   /** A new pairing attempt starts from a clean slate. */
   resetClaim(): void {
     this.latestClaim = IDLE_CLAIM
@@ -112,6 +140,14 @@ export class NeuralBandInput {
   forget(controllerId: string): void {
     this.claims.delete(controllerId)
     this.handwriting.delete(controllerId)
+    this.firmware.delete(controllerId)
+  }
+
+  handleFirmware(event: NeuralBandFirmwareEvent): void {
+    const {type: _type, controllerId, ...rest} = event
+    const status: NeuralBandFirmwareStatus = {...rest, known: true}
+    this.firmware.set(controllerId, status)
+    for (const cb of this.firmwareListeners) cb({id: controllerId, status})
   }
 
   handleClaim(event: NeuralBandClaimEvent): void {

package/src/services/neuralBand/NeuralBandSettingsSync.ts

@@ -32,6 +32,13 @@ function pushHand(id: string): void {
   )
 }
 
+function pushVibration(id: string): void {
+  const enabled = useSettingsStore.getState().getSetting(SETTINGS.neural_band_vibration.key) !== false
+  void BluetoothSdk.neuralBandSetGestureHaptics(id, enabled).catch((err) =>
+    console.warn("NeuralBandSettingsSync: vibration push failed:", err),
+  )
+}
+
 export function startNeuralBandSettingsSync(): void {
   if (unsubscribers.length > 0) return
   let connected = new Set(connectedBandIds())
@@ -44,6 +51,7 @@ export function startNeuralBandSettingsSync(): void {
           if (connected.has(id)) continue
           pushAirMouse(id)
           pushHand(id)
+          pushVibration(id)
         }
         connected = next
       },
@@ -56,6 +64,10 @@ export function startNeuralBandSettingsSync(): void {
       (s) => s.getSetting(SETTINGS.neural_band_hand.key),
       () => connectedBandIds().forEach(pushHand),
     ),
+    useSettingsStore.subscribe(
+      (s) => s.getSetting(SETTINGS.neural_band_vibration.key),
+      () => connectedBandIds().forEach(pushVibration),
+    ),
   ]
 }
 

package/src/services/pages/pageEligibility.ts

@@ -13,7 +13,10 @@ import {isGlassesConnected} from "../GlassesReadiness"
 
 /** The SGC appends this marker after the firmware advertises Glassly CFW capabilities (G2, RayNeo iO). */
 export function isCfwFirmwareVersion(firmwareVersion: string | null | undefined): boolean {
-  return firmwareVersion?.toLowerCase().includes("glassly cfw") === true
+  return (
+    firmwareVersion?.toLowerCase().includes("glassly cfw") === true ||
+    /^GLASSLYCFW\/[0-9]+$/.test(firmwareVersion ?? "")
+  )
 }
 
 /**
@@ -23,6 +26,11 @@ export function isCfwFirmwareVersion(firmwareVersion: string | null | undefined)
  */
 export function isCustomDashboardEligible(info: {model?: string | null; firmwareVersion?: string | null}): boolean {
   if (!info.model) return false
+  if (info.model === DeviceTypes.MEMOMIND_ONE) {
+    const match = /^GLASSLYCFW\/([0-9]+)$/.exec(info.firmwareVersion ?? "")
+    const revision = match ? Number(match[1]) : 0
+    return Number.isSafeInteger(revision) && revision >= 10
+  }
   return (
     getModelCapabilities(info.model as DeviceTypes).hasCustomFirmware === true &&
     isCfwFirmwareVersion(info.firmwareVersion)

package/src/services/settingsBridge.ts

@@ -38,6 +38,7 @@ export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>
   notifications_enabled: "write",
   notifications_popups: "write",
   notifications_popup_seconds: "write",
+  notifications_batch_seconds: "write",
   notifications_hold_during_apps: "write",
   notifications_ignore_while_active: "write",
   notifications_blocklist: "write",