@mentra/engine 0.1.0-beta.0

package/src/services/PhoneCalendarHelpers.ts

@@ -0,0 +1,212 @@
+import {MiniappErrorCode, type CalendarEvent} from "@mentra/miniapp"
+
+const DEFAULT_LIMIT = 50
+const MAX_LIMIT = 100
+const MAX_RANGE_MS = 31 * 24 * 60 * 60 * 1000
+
+export interface CalendarListRequest {
+  startsAt?: unknown
+  endsAt?: unknown
+  limit?: unknown
+}
+
+export class PhoneCalendarError extends Error {
+  constructor(
+    public readonly code: MiniappErrorCode,
+    message: string,
+  ) {
+    super(message)
+    this.name = "PhoneCalendarError"
+  }
+}
+
+export interface ValidatedCalendarListRequest {
+  startsAt: Date
+  endsAt: Date
+  limit: number
+}
+
+export interface RawCalendarEvent {
+  id?: string
+  calendarId?: string
+  title?: string | null
+  startDate: string | Date
+  endDate: string | Date
+  timeZone?: string | null
+  allDay?: boolean
+  location?: string | null
+  notes?: string | null
+  url?: string | null
+}
+
+export function validateCalendarListRequest(request: CalendarListRequest): ValidatedCalendarListRequest {
+  const startsAt = parseDate(request.startsAt, "startsAt")
+  const endsAt = parseDate(request.endsAt, "endsAt")
+  if (endsAt.getTime() <= startsAt.getTime()) {
+    throw new PhoneCalendarError(MiniappErrorCode.INVALID_ARGUMENT, "endsAt must be after startsAt")
+  }
+  if (endsAt.getTime() - startsAt.getTime() > MAX_RANGE_MS) {
+    throw new PhoneCalendarError(MiniappErrorCode.INVALID_ARGUMENT, "Calendar query range may not exceed 31 days")
+  }
+
+  const limit = request.limit === undefined ? DEFAULT_LIMIT : request.limit
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) {
+    throw new PhoneCalendarError(
+      MiniappErrorCode.INVALID_ARGUMENT,
+      `limit must be an integer between 1 and ${MAX_LIMIT}`,
+    )
+  }
+  return {startsAt, endsAt, limit}
+}
+
+function parseDate(value: unknown, field: string): Date {
+  if (typeof value !== "string") {
+    throw new PhoneCalendarError(MiniappErrorCode.INVALID_ARGUMENT, `${field} must be an ISO 8601 string`)
+  }
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) {
+    throw new PhoneCalendarError(MiniappErrorCode.INVALID_ARGUMENT, `${field} must be a valid ISO 8601 string`)
+  }
+  return date
+}
+
+export function extractHttpsLinks(...values: Array<string | null | undefined>): string[] {
+  const links = new Set<string>()
+  for (const value of values) {
+    for (const match of value?.match(/https:\/\/[^\s<>"']+/gi) ?? []) {
+      let link = match
+      while (".,;:!?)]}".includes(link[link.length - 1] ?? "")) link = link.slice(0, -1)
+      if (link) links.add(link)
+    }
+  }
+  return [...links]
+}
+
+interface CalendarDateParts {
+  year: number
+  month: number
+  day: number
+  hour: number
+  minute: number
+  second: number
+}
+
+function localDateParts(date: Date): CalendarDateParts {
+  return {
+    year: date.getFullYear(),
+    month: date.getMonth() + 1,
+    day: date.getDate(),
+    hour: date.getHours(),
+    minute: date.getMinutes(),
+    second: date.getSeconds(),
+  }
+}
+
+function datePartsInTimeZone(date: Date, timeZone: string): CalendarDateParts | undefined {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23",
+    }).formatToParts(date)
+    const value = (type: Intl.DateTimeFormatPartTypes) => Number(parts.find((part) => part.type === type)?.value)
+    return {
+      year: value("year"),
+      month: value("month"),
+      day: value("day"),
+      hour: value("hour"),
+      minute: value("minute"),
+      second: value("second"),
+    }
+  } catch {
+    return undefined
+  }
+}
+
+function timeZoneOffsetMinutes(date: Date, timeZone: string): number | undefined {
+  const parts = datePartsInTimeZone(date, timeZone)
+  if (!parts) return undefined
+  const representedAsUtc = Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hour,
+    parts.minute,
+    parts.second,
+    date.getUTCMilliseconds(),
+  )
+  return Math.round((representedAsUtc - date.getTime()) / 60_000)
+}
+
+function pad(value: number, length = 2): string {
+  return String(value).padStart(length, "0")
+}
+
+function formatOffset(offsetMinutes: number): string {
+  if (offsetMinutes === 0) return "Z"
+  const sign = offsetMinutes < 0 ? "-" : "+"
+  const absolute = Math.abs(offsetMinutes)
+  return `${sign}${pad(Math.floor(absolute / 60))}:${pad(absolute % 60)}`
+}
+
+function formatAllDayDate(value: string | Date, timeZone?: string | null): string {
+  const dateOnly = typeof value === "string" ? /^(\d{4})-(\d{2})-(\d{2})$/.exec(value) : null
+  if (dateOnly) {
+    const [, year, month, day] = dateOnly
+    const localMidnight = new Date(Number(year), Number(month) - 1, Number(day))
+    let offsetMinutes = -localMidnight.getTimezoneOffset()
+    if (timeZone) {
+      // Resolve the offset at midnight in the event timezone. Repeating once
+      // accounts for the initial UTC guess landing across a DST boundary.
+      const wallTime = Date.UTC(Number(year), Number(month) - 1, Number(day))
+      let instant = new Date(wallTime)
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        const offset = timeZoneOffsetMinutes(instant, timeZone)
+        if (offset === undefined) break
+        offsetMinutes = offset
+        instant = new Date(wallTime - offset * 60_000)
+      }
+    }
+    return `${year}-${month}-${day}T00:00:00.000${formatOffset(offsetMinutes)}`
+  }
+
+  const date = new Date(value)
+  const zonedParts = timeZone ? datePartsInTimeZone(date, timeZone) : undefined
+  const parts = zonedParts ?? localDateParts(date)
+  const offsetMinutes =
+    timeZone && zonedParts
+      ? (timeZoneOffsetMinutes(date, timeZone) ?? -date.getTimezoneOffset())
+      : -date.getTimezoneOffset()
+  return `${pad(parts.year, 4)}-${pad(parts.month)}-${pad(parts.day)}T${pad(parts.hour)}:${pad(parts.minute)}:${pad(parts.second)}.${pad(date.getUTCMilliseconds(), 3)}${formatOffset(offsetMinutes)}`
+}
+
+export function normalizeCalendarEvent(event: RawCalendarEvent): CalendarEvent {
+  const startsAt = event.allDay
+    ? formatAllDayDate(event.startDate, event.timeZone)
+    : new Date(event.startDate).toISOString()
+  const endsAt = event.allDay ? formatAllDayDate(event.endDate, event.timeZone) : new Date(event.endDate).toISOString()
+  const calendarId = event.calendarId ?? ""
+  const eventId = event.id ?? ""
+  return {
+    id: `${calendarId}:${eventId}:${startsAt}`,
+    calendarId,
+    title: event.title ?? "",
+    startsAt,
+    endsAt,
+    ...(event.timeZone ? {timezone: event.timeZone} : {}),
+    allDay: !!event.allDay,
+    ...(event.location ? {location: event.location} : {}),
+    ...(event.notes ? {notes: event.notes} : {}),
+    ...(event.url ? {url: event.url} : {}),
+    links: extractHttpsLinks(event.url, event.location, event.notes),
+  }
+}
+
+export function calendarEventOverlapsWindow(event: CalendarEvent, startsAt: Date, endsAt: Date): boolean {
+  return Date.parse(event.endsAt) > startsAt.getTime() && Date.parse(event.startsAt) < endsAt.getTime()
+}

package/src/services/PhoneCalendarService.ts

@@ -0,0 +1,42 @@
+import * as Calendar from "expo-calendar"
+
+import {MiniappErrorCode, type CalendarListResult} from "@mentra/miniapp"
+
+import {
+  calendarEventOverlapsWindow,
+  type CalendarListRequest,
+  normalizeCalendarEvent,
+  PhoneCalendarError,
+  validateCalendarListRequest,
+} from "./PhoneCalendarHelpers"
+
+export {PhoneCalendarError} from "./PhoneCalendarHelpers"
+
+export async function listPhoneCalendarEvents(request: CalendarListRequest): Promise<CalendarListResult> {
+  const {startsAt, endsAt, limit} = validateCalendarListRequest(request)
+  const permission = await Calendar.getCalendarPermissionsAsync()
+  if (permission.status !== "granted") {
+    throw new PhoneCalendarError(
+      MiniappErrorCode.PERMISSION_DENIED,
+      "Calendar permission is not granted. Reopen the miniapp and grant calendar access.",
+    )
+  }
+
+  const calendars = await Calendar.getCalendarsAsync(Calendar.EntityTypes.EVENT)
+  if (calendars.length === 0) return {events: [], truncated: false}
+
+  const rawEvents = await Calendar.getEventsAsync(
+    calendars.map((calendar) => calendar.id),
+    startsAt,
+    endsAt,
+  )
+  const events = rawEvents
+    .map(normalizeCalendarEvent)
+    .filter((event) => calendarEventOverlapsWindow(event, startsAt, endsAt))
+    .sort((a, b) => Date.parse(a.startsAt) - Date.parse(b.startsAt) || Date.parse(a.endsAt) - Date.parse(b.endsAt))
+
+  return {
+    events: events.slice(0, limit),
+    truncated: events.length > limit,
+  }
+}

package/src/services/PhoneCameraFovCoordinator.ts

@@ -0,0 +1,195 @@
+import BluetoothSdk, {type CameraFovRequest, type CameraFovResult} from "@mentra/bluetooth-sdk/internal"
+
+export const CAMERA_FOV_OVERRIDE_TTL_MS = 300_000
+export const CAMERA_FOV_OVERRIDE_REFRESH_MS = 120_000
+// Legacy ASG clients restart the camera HAL for an FOV update but cannot acknowledge
+// when it is usable again. The ASG cooldown is 5s; retain a small settling margin so
+// miniapps cannot submit a photo against the stale camera service.
+const LEGACY_CAMERA_RESTART_SETTLE_MS = 7_000
+
+interface OverrideEntry {
+  leaseId: string
+  fov: number
+  roiPosition: "center" | "bottom" | "top"
+  order: number
+}
+
+let leaseCounter = 0
+
+function mintLeaseId(): string {
+  leaseCounter = (leaseCounter + 1) & 0xffff
+  return `fov-${leaseCounter.toString(16).padStart(4, "0")}`
+}
+
+function isLegacyFovCompatibilityError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error)
+  return /timed out waiting for glasses response|not available|unknown method/i.test(message)
+}
+
+/**
+ * Serializes miniapp-owned FOV/ROI overrides. The last live owner wins; releasing it applies the
+ * previous owner or asks ASG to restore its persistent base. ASG refreshes are no-restart TTL
+ * extensions for crash safety.
+ */
+export class PhoneCameraFovCoordinator {
+  private readonly overrides = new Map<string, OverrideEntry>()
+  private effectiveLeaseId: string | undefined
+  private sequence = 0
+  private queue: Promise<unknown> = Promise.resolve()
+  private refreshTimer: ReturnType<typeof setTimeout> | undefined
+  private legacyMode = false
+
+  constructor(private readonly legacyRestartSettleMs = LEGACY_CAMERA_RESTART_SETTLE_MS) {}
+
+  setOverride(packageName: string, request: CameraFovRequest): Promise<CameraFovResult> {
+    return this.enqueue(async () => {
+      const previous = this.overrides.get(packageName)
+      const leaseId = previous?.leaseId ?? mintLeaseId()
+      const order = ++this.sequence
+      try {
+        if (this.legacyMode) return this.setLegacyOverride(packageName, request, leaseId, order)
+        const result = await BluetoothSdk.setCameraFovOverride({
+          ...request,
+          leaseId,
+          ttlMs: CAMERA_FOV_OVERRIDE_TTL_MS,
+        })
+        this.overrides.set(packageName, {
+          leaseId,
+          fov: result.fov,
+          roiPosition: result.roiPosition,
+          order,
+        })
+        this.effectiveLeaseId = leaseId
+        this.scheduleRefresh()
+        return result
+      } catch (error) {
+        if (!isLegacyFovCompatibilityError(error)) throw error
+        console.warn("[PhoneCameraFovCoordinator] override unavailable; using legacy FOV command", error)
+        const result = await this.setLegacyOverride(packageName, request, leaseId, order)
+        // Only cache compatibility mode after the fallback itself succeeds. A
+        // disconnect or missing native bridge must not permanently downgrade
+        // future requests on a healthy/newer glasses connection.
+        this.legacyMode = true
+        return result
+      }
+    })
+  }
+
+  releaseForApp(packageName: string): Promise<void> {
+    return this.enqueue(async () => {
+      const removed = this.overrides.get(packageName)
+      if (!removed) return
+      if (removed.leaseId !== this.effectiveLeaseId) {
+        this.overrides.delete(packageName)
+        return
+      }
+
+      const next = [...this.overrides.entries()]
+        .filter(([candidatePackage]) => candidatePackage !== packageName)
+        .map(([, entry]) => entry)
+        .sort((a, b) => b.order - a.order)[0]
+      if (this.legacyMode) {
+        if (next) {
+          await this.applyLegacyFov({fov: next.fov, roiPosition: next.roiPosition})
+          this.overrides.delete(packageName)
+          this.effectiveLeaseId = next.leaseId
+        } else {
+          // Legacy commands are one-way and have no lease-release protocol.
+          // Ask native to replay its unchanged persistent base setting, then
+          // probe the modern override path again for the next ownership cycle.
+          await BluetoothSdk.restoreLegacyCameraFov()
+          await this.waitForLegacyCameraRestart()
+          this.overrides.delete(packageName)
+          this.clearRefresh()
+          this.effectiveLeaseId = undefined
+          this.legacyMode = false
+        }
+        return
+      }
+      if (next) {
+        await BluetoothSdk.setCameraFovOverride({
+          leaseId: next.leaseId,
+          fov: next.fov,
+          roiPosition: next.roiPosition,
+          ttlMs: CAMERA_FOV_OVERRIDE_TTL_MS,
+        })
+        // Commit phone-side ownership only after ASG accepted the replacement. On failure the
+        // closing app remains effective here, allowing unregister/reconnect cleanup to retry.
+        this.overrides.delete(packageName)
+        this.effectiveLeaseId = next.leaseId
+        this.scheduleRefresh()
+      } else {
+        await BluetoothSdk.releaseCameraFovOverride(removed.leaseId)
+        this.overrides.delete(packageName)
+        this.clearRefresh()
+        this.effectiveLeaseId = undefined
+      }
+    })
+  }
+
+  private scheduleRefresh(): void {
+    if (this.legacyMode) return
+    this.clearRefresh()
+    const leaseId = this.effectiveLeaseId
+    if (!leaseId) return
+    this.refreshTimer = setTimeout(() => {
+      void this.enqueue(async () => {
+        if (this.effectiveLeaseId !== leaseId) return
+        const entry = [...this.overrides.values()].find((candidate) => candidate.leaseId === leaseId)
+        if (!entry) return
+        await BluetoothSdk.setCameraFovOverride({
+          leaseId,
+          fov: entry.fov,
+          roiPosition: entry.roiPosition,
+          ttlMs: CAMERA_FOV_OVERRIDE_TTL_MS,
+        })
+        this.scheduleRefresh()
+      }).catch((error) => console.warn("[PhoneCameraFovCoordinator] failed to refresh override", error))
+    }, CAMERA_FOV_OVERRIDE_REFRESH_MS)
+  }
+
+  private clearRefresh(): void {
+    if (this.refreshTimer) clearTimeout(this.refreshTimer)
+    this.refreshTimer = undefined
+  }
+
+  private async setLegacyOverride(
+    packageName: string,
+    request: CameraFovRequest,
+    leaseId: string,
+    order: number,
+  ): Promise<CameraFovResult> {
+    const result = await this.applyLegacyFov(request)
+    this.overrides.set(packageName, {
+      leaseId,
+      fov: result.fov,
+      roiPosition: result.roiPosition,
+      order,
+    })
+    this.effectiveLeaseId = leaseId
+    this.clearRefresh()
+    return result
+  }
+
+  private async applyLegacyFov(request: CameraFovRequest): Promise<CameraFovResult> {
+    const result = await BluetoothSdk.setLegacyCameraFov(request)
+    await this.waitForLegacyCameraRestart()
+    return result
+  }
+
+  private waitForLegacyCameraRestart(): Promise<void> {
+    if (this.legacyRestartSettleMs <= 0) return Promise.resolve()
+    return new Promise<void>((resolve) => setTimeout(resolve, this.legacyRestartSettleMs))
+  }
+
+  private enqueue<T>(operation: () => Promise<T>): Promise<T> {
+    const result = this.queue.then(operation, operation)
+    this.queue = result.then(
+      () => undefined,
+      () => undefined,
+    )
+    return result
+  }
+}
+
+export const phoneCameraFovCoordinator = new PhoneCameraFovCoordinator()

package/src/services/PhoneLocationService.ts

@@ -0,0 +1,122 @@
+/**
+ * Phone location service — engine-owned. Owns the background phone-GPS task: the
+ * accuracy-tier control (`setLocationTier`), the accuracy mapping, and the
+ * `expo-task-manager` background task that fans each fix to the v2 cloud
+ * local miniapps (`location_update`). Cloud upload was V1 (removed).
+ *
+ * This used to be the host-injected `locationTier` runtime hook + a MantleManager
+ * `TaskManager.defineTask`. It's device/OS plumbing (no UI), so it moved into engine:
+ * the runtime drives `setLocationTier` directly off miniapp demand, and any host —
+ * including a bare OEM — gets phone location without wiring a hook. The host keeps the
+ * permission *UI* (it gates `setLocationTier` on the OS permission before calling).
+ *
+ * The task is registered at module load (the export from `index.ts` evaluates this
+ * file as soon as `@mentra/engine` is imported), matching the old MantleManager
+ * top-level `defineTask` timing — including on a headless background relaunch.
+ */
+import * as Location from "expo-location"
+import * as TaskManager from "expo-task-manager"
+
+import localMiniappRuntime from "./LocalMiniappRuntime"
+
+export const LOCATION_TASK_NAME = "handleLocationUpdates"
+
+// Background location task — sends each fix to the v2 cloud (RestComms) + local
+// miniapps. (The v1 SocketComms leg was already removed/commented before the move.)
+TaskManager.defineTask<{locations?: Location.LocationObject[]}>(LOCATION_TASK_NAME, async ({data, error}) => {
+  if (error) {
+    // OS-level failure (permission revoked, GPS unavailable, …) — log it so
+    // background location dropouts are diagnosable.
+    console.warn("ISLAND: LOCATION: background task error:", error)
+    return
+  }
+  const locs = data?.locations ?? []
+  if (locs.length === 0) {
+    console.log("ISLAND: LOCATION: No locations received")
+    return
+  }
+  const first = locs[0]!
+  // Cloud path (relayMessageToApps) never reaches __phone__, so local miniapps rely
+  // on this direct push.
+  // Local miniapps get the update directly (the cloud relay never reaches
+  // __phone__). The Cloud V1 upload that used to run here was removed with the
+  // V1 ripout (issue #3392); a V2 location channel is separate product work.
+  localMiniappRuntime.forwardEvent("location_update", {
+    lat: first.coords.latitude,
+    lng: first.coords.longitude,
+    accuracy: first.coords.accuracy ?? undefined,
+    timestamp: first.timestamp,
+  })
+})
+
+/** Map a MentraOS location tier/accuracy string to an expo-location accuracy. */
+export function getLocationAccuracy(accuracy: string | undefined): Location.LocationAccuracy {
+  switch (accuracy) {
+    // Aggregate miniapp tiers (LocalMiniappRuntime.recomputeLocation → "passive" |
+    // "low" | "high" | "realtime"). Previously only "realtime" mapped; "passive"/"low"/
+    // "high" fell through to Lowest, so a miniapp asking for high-rate GPS got the
+    // coarsest accuracy.
+    case "realtime":
+      return Location.LocationAccuracy.BestForNavigation
+    case "high":
+      return Location.LocationAccuracy.High
+    case "low":
+      return Location.LocationAccuracy.Low
+    case "passive":
+      return Location.LocationAccuracy.Lowest
+    // Accuracy-string vocabulary (persisted location_tier setting / boot path).
+    case "tenMeters":
+      return Location.LocationAccuracy.High
+    case "hundredMeters":
+      return Location.LocationAccuracy.Balanced
+    case "kilometer":
+      return Location.LocationAccuracy.Low
+    case "threeKilometers":
+      return Location.LocationAccuracy.Lowest
+    case "reduced":
+      return Location.LocationAccuracy.Lowest
+    default:
+      return Location.LocationAccuracy.Lowest
+  }
+}
+
+/**
+ * Apply a location tier (the aggregate of what miniapps request). "off" means no app
+ * is asking — stop the task so the OS can power GPS down; anything else (re)starts the
+ * background task at the matching accuracy. Callers gate this on the OS location
+ * permission (host UI concern).
+ */
+export async function setLocationTier(
+  tier: "off" | "passive" | "low" | "high" | "realtime" | string,
+): Promise<void> {
+  console.log("ISLAND: setLocationTier()", tier)
+  try {
+    const isRegistered = await Location.hasStartedLocationUpdatesAsync(LOCATION_TASK_NAME).catch(() => false)
+    if (isRegistered) {
+      await Location.stopLocationUpdatesAsync(LOCATION_TASK_NAME)
+    }
+    if (tier === "off") {
+      console.log("ISLAND: setLocationTier() stopped — no active subscribers")
+      return
+    }
+    await Location.startLocationUpdatesAsync(LOCATION_TASK_NAME, {
+      accuracy: getLocationAccuracy(tier),
+      pausesUpdatesAutomatically: false,
+    })
+    console.log("ISLAND: setLocationTier() success —", tier)
+  } catch (error) {
+    console.log("ISLAND: Error setting location tier", error)
+  }
+}
+
+/** Stop the background location task (host cleanup). */
+export function stopPhoneLocation(): void {
+  Location.stopLocationUpdatesAsync(LOCATION_TASK_NAME).catch(() => {})
+}
+
+export const phoneLocationService = {
+  LOCATION_TASK_NAME,
+  getLocationAccuracy,
+  setLocationTier,
+  stopPhoneLocation,
+}

package/src/services/PhoneNotificationsSync.ts

@@ -0,0 +1,44 @@
+/**
+ * Phone-notifications sync — engine-owned. Pushes the notification-forwarding
+ * config (`notifications_enabled` + `notifications_blocklist`) to the native
+ * NotificationListener via `CrustModule.setNotificationConfig`, so
+ * `engine.phoneNotifications.setEnabled()/setBlocklist()` actually reach the
+ * listener for ANY host — not just the Mentra app, where this used to live in
+ * MantleManager. Android-only; a no-op elsewhere. Started by `engine.start()`.
+ */
+import {shallow} from "zustand/shallow"
+import CrustModule from "@mentra/crust"
+
+import {useSettingsStore, SETTINGS} from "../stores/settings"
+
+let unsubscribe: (() => void) | null = null
+
+function pushConfig(): void {
+  const s = useSettingsStore.getState()
+  const enabled = Boolean(s.getSetting(SETTINGS.notifications_enabled.key))
+  const blocklist = s.getSetting(SETTINGS.notifications_blocklist.key)
+  // Unconditional (matches the prior MantleManager sync) — the listener is
+  // Android-only, but CrustModule.setNotificationConfig is a safe no-op elsewhere;
+  // the Android-only gating lives on the facade's setEnabled/setBlocklist.
+  CrustModule.setNotificationConfig(enabled, Array.isArray(blocklist) ? blocklist : []).catch((err: unknown) =>
+    console.warn(`PhoneNotificationsSync: setNotificationConfig failed: ${(err as Error)?.message ?? err}`),
+  )
+}
+
+export function startPhoneNotificationsSync(): void {
+  if (unsubscribe) return
+  pushConfig() // initial sync so the listener has the current config
+  unsubscribe = useSettingsStore.subscribe(
+    (state) => ({
+      enabled: state.getSetting(SETTINGS.notifications_enabled.key),
+      blocklist: state.getSetting(SETTINGS.notifications_blocklist.key),
+    }),
+    () => pushConfig(),
+    {equalityFn: shallow},
+  )
+}
+
+export function stopPhoneNotificationsSync(): void {
+  unsubscribe?.()
+  unsubscribe = null
+}