@mentra/crust 3.2.1 → 3.3.0-beta.942

package/src/Crust.types.ts

@@ -16,7 +16,6 @@ export type CrustModuleEvents = {
   onHeading: (params: HeadingPayload) => void
   phone_notification: (event: PhoneNotificationEvent) => void
   phone_notification_dismissed: (event: PhoneNotificationDismissedEvent) => void
-  captions_tester_incident: (event: CaptionsTesterIncidentEvent) => void
 }
 
 export type NavOffRoutePayload = {
@@ -114,6 +113,8 @@ export type NavManeuverPayload = {
 
 export type NavErrorPayload = {
   message: string
+  /** True only when native navigation has ended; absent for recoverable reroute errors. */
+  terminal?: boolean
 }
 
 export type InstalledApp = {
@@ -144,19 +145,32 @@ export type PhoneNotificationDismissedEvent = {
   notificationId: string
 }
 
-export type CaptionsTesterIncidentEvent = {
-  action?: string
-  timestamp?: number
-  failure_code?: string
-  failure_message?: string
-  test_run_id?: string
-  scenario_name?: string
-  source?: string
-  [key: string]: unknown
-}
-
 export type CrustViewProps = {
   url: string
   onLoad: (event: {nativeEvent: OnLoadEventPayload}) => void
   style?: StyleProp<ViewStyle>
 }
+
+/** Passive OS observations for the currently executing Mentra App. */
+export type AppPermissionStatus = {
+  rawStatus: string | null
+  status: "granted" | "denied" | "blocked" | "unavailable" | "unknown"
+}
+
+export type AppPermissionSnapshot = {
+  schemaVersion: 1
+  observedAt: string
+  identity: {
+    pid: number
+    uid: number
+    bundleId: string
+    bundlePath: string
+    executablePath: string
+    version: string
+    build: string
+  }
+  locationServicesEnabled: boolean
+  permissions: Record<"location" | "camera" | "microphone" | "bluetooth" | "localNetwork", AppPermissionStatus>
+}
+
+export type AppPermissionReceipt = AppPermissionSnapshot & {requestId: string}

package/src/CrustModule.ts

@@ -1,19 +1,27 @@
 import {NativeModule, requireNativeModule} from "expo"
 
-import {CrustModuleEvents, InstalledApp} from "./Crust.types"
+import {AppPermissionReceipt, AppPermissionSnapshot, CrustModuleEvents, InstalledApp} from "./Crust.types"
 
 declare class CrustModule extends NativeModule<CrustModuleEvents> {
   /** True for the native iOS app running on an Apple Silicon Mac. */
   readonly isIOSAppOnMac?: boolean
+  /** iOS: passive actual-app authorization status; never requests consent. */
+  getPermissionStatus(requestId: null): Promise<AppPermissionSnapshot>
+  /** iOS: a nonce publishes fresh status at the fixed managed-cache path. */
+  getPermissionStatus(requestId: string): Promise<AppPermissionReceipt>
   PI: number
   hello(): string
   setValueAsync(value: string): Promise<void>
+  /** Android: copy the displayed view's window pixels to a temporary JPEG URI. */
+  captureMiniappPreview(viewTag: number): Promise<string>
   nativeHttpRequest(
+    requestId: string,
     method: string,
     url: string,
     headers: Record<string, string>,
     body?: string | null,
   ): Promise<{status: number; statusText: string; headers: Record<string, string>; body: string}>
+  cancelNativeHttpRequest(requestId: string): Promise<void>
   showAVRoutePicker(tintColor?: string | null): void
 
   /**

package/src/CrustModule.web.ts

@@ -4,18 +4,29 @@ import {CrustModuleEvents} from "./Crust.types"
 
 class CrustModule extends NativeModule<CrustModuleEvents> {
   PI = Math.PI
+  private readonly httpRequests = new Map<string, AbortController>()
   async setValueAsync(value: string): Promise<void> {
     this.emit("onChange", {value})
   }
-  async nativeHttpRequest(method: string, url: string, headers: Record<string, string>, body?: string | null) {
-    const response = await fetch(url, {method, headers, body})
-    return {
-      status: response.status,
-      statusText: response.statusText,
-      headers: Object.fromEntries(response.headers.entries()),
-      body: await response.text(),
+  async nativeHttpRequest(requestId: string, method: string, url: string, headers: Record<string, string>, body?: string | null) {
+    const controller = new AbortController()
+    this.httpRequests.set(requestId, controller)
+    try {
+      const response = await fetch(url, {method, headers, body, signal: controller.signal})
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: await response.text(),
+      }
+    } finally {
+      this.httpRequests.delete(requestId)
     }
   }
+  async cancelNativeHttpRequest(requestId: string): Promise<void> {
+    this.httpRequests.get(requestId)?.abort()
+    this.httpRequests.delete(requestId)
+  }
   hello() {
     return "Hello world! 👋"
   }

package/src/index.ts

@@ -3,3 +3,4 @@
 export {default} from "./CrustModule"
 export {default as CrustView} from "./CrustView"
 export * from "./Crust.types"
+export {nativeHttpRequest} from "./nativeHttpRequest"

package/src/nativeHttpRequest.test.ts

@@ -0,0 +1,94 @@
+import {nativeHttpRequest, type NativeHttpResult, type NativeHttpTransport} from "./nativeHttpRequest"
+
+const response: NativeHttpResult = {status: 200, statusText: "OK", headers: {}, body: "{}"}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  let reject!: (error: unknown) => void
+  const promise = new Promise<T>((yes, no) => {
+    resolve = yes
+    reject = no
+  })
+  return {promise, resolve, reject}
+}
+
+function transport(request = deferred<NativeHttpResult>()) {
+  const native: NativeHttpTransport = {
+    nativeHttpRequest: jest.fn(() => request.promise),
+    cancelNativeHttpRequest: jest.fn(async () => {}),
+  }
+  return {native, request}
+}
+
+describe("nativeHttpRequest", () => {
+  test("pre-aborted requests do not start or cancel native work", async () => {
+    const {native} = transport()
+    const controller = new AbortController()
+    const reason = new Error("deadline")
+    controller.abort(reason)
+    await expect(nativeHttpRequest(native, "GET", "https://example.com", {}, null, controller.signal)).rejects.toBe(reason)
+    expect(native.nativeHttpRequest).not.toHaveBeenCalled()
+    expect(native.cancelNativeHttpRequest).not.toHaveBeenCalled()
+  })
+
+  test("abort cancels only this request and waits for native cancellation acceptance", async () => {
+    const {native, request} = transport()
+    const cancellation = deferred<void>()
+    native.cancelNativeHttpRequest = jest.fn(() => cancellation.promise)
+    const controller = new AbortController()
+    const remove = jest.spyOn(controller.signal, "removeEventListener")
+    const promise = nativeHttpRequest(native, "POST", "https://example.com", {test: "header"}, "body", controller.signal)
+    const rejected = expect(promise).rejects.toMatchObject({name: "AbortError"})
+    controller.abort()
+    const id = (native.nativeHttpRequest as jest.Mock).mock.calls[0][0]
+    expect(native.cancelNativeHttpRequest).toHaveBeenCalledWith(id)
+    expect(remove).not.toHaveBeenCalled()
+    request.reject(new Error("cancelled socket"))
+    cancellation.resolve()
+    await rejected
+    expect(native.cancelNativeHttpRequest).toHaveBeenCalledTimes(1)
+    expect(remove).toHaveBeenCalledWith("abort", expect.any(Function))
+  })
+
+  test("an abort during native start is cancelled after start and removes its listener", async () => {
+    const {native} = transport()
+    const controller = new AbortController()
+    const order: string[] = []
+    native.nativeHttpRequest = jest.fn(() => {
+      order.push("start")
+      controller.abort()
+      return new Promise<NativeHttpResult>(() => {})
+    })
+    native.cancelNativeHttpRequest = jest.fn(async () => {order.push("cancel")})
+    await expect(nativeHttpRequest(native, "GET", "https://example.com", {}, null, controller.signal)).rejects.toMatchObject({name: "AbortError"})
+    expect(order).toEqual(["start", "cancel"])
+  })
+
+  test.each(["success", "failure"])("%s removes its abort listener and a later abort does not cancel", async (outcome) => {
+    const {native, request} = transport()
+    const controller = new AbortController()
+    const remove = jest.spyOn(controller.signal, "removeEventListener")
+    const promise = nativeHttpRequest(native, "GET", "https://example.com", {}, null, controller.signal)
+    if (outcome === "success") {
+      request.resolve(response)
+      await expect(promise).resolves.toBe(response)
+    } else {
+      request.reject(new Error("offline"))
+      await expect(promise).rejects.toThrow("offline")
+    }
+    controller.abort()
+    expect(remove).toHaveBeenCalledTimes(1)
+    expect(native.cancelNativeHttpRequest).not.toHaveBeenCalled()
+  })
+
+  test("independent calls have separate IDs and unsignalled calls keep the native path", async () => {
+    const {native, request} = transport()
+    const first = nativeHttpRequest(native, "GET", "https://example.com/first", {}, null)
+    const second = nativeHttpRequest(native, "GET", "https://example.com/second", {}, null)
+    const calls = (native.nativeHttpRequest as jest.Mock).mock.calls
+    expect(calls[0][0]).not.toBe(calls[1][0])
+    request.resolve(response)
+    await Promise.all([first, second])
+    expect(native.cancelNativeHttpRequest).not.toHaveBeenCalled()
+  })
+})

package/src/nativeHttpRequest.ts

@@ -0,0 +1,74 @@
+export interface NativeHttpResult {
+  status: number
+  statusText: string
+  headers: Record<string, string>
+  body: string
+}
+
+export interface NativeHttpTransport {
+  nativeHttpRequest(
+    requestId: string,
+    method: string,
+    url: string,
+    headers: Record<string, string>,
+    body: string | null,
+  ): Promise<NativeHttpResult>
+  cancelNativeHttpRequest(requestId: string): Promise<void>
+}
+
+let requestSequence = 0
+
+function abortReason(signal: AbortSignal): unknown {
+  if (signal.reason !== undefined) return signal.reason
+  const error = new Error("Native HTTP request aborted")
+  error.name = "AbortError"
+  return error
+}
+
+/** Keep Android's background-safe HTTP path while cancelling its actual native request. */
+export function nativeHttpRequest(
+  native: NativeHttpTransport,
+  method: string,
+  url: string,
+  headers: Record<string, string>,
+  body: string | null,
+  signal?: AbortSignal,
+): Promise<NativeHttpResult> {
+  if (signal?.aborted) return Promise.reject(abortReason(signal))
+  const requestId = `http-${Date.now().toString(36)}-${++requestSequence}`
+  // Start first, then subscribe: Expo delivers start and cancel on the same serial queue.
+  const request = native.nativeHttpRequest(requestId, method, url, headers, body)
+  if (!signal) return request
+
+  return new Promise((resolve, reject) => {
+    let settled = false
+    let cancelling = false
+    const finish = (action: () => void) => {
+      if (settled) return
+      settled = true
+      signal.removeEventListener("abort", onAbort)
+      action()
+    }
+    const onAbort = () => {
+      if (settled || cancelling) return
+      cancelling = true
+      void native.cancelNativeHttpRequest(requestId).then(
+        () => finish(() => reject(abortReason(signal))),
+        (error: unknown) => finish(() => reject(error)),
+      )
+    }
+    request.then(
+      (result) => {
+        if (signal.aborted) onAbort()
+        else finish(() => resolve(result))
+      },
+      (error: unknown) => {
+        if (signal.aborted) onAbort()
+        else finish(() => reject(error))
+      },
+    )
+    signal.addEventListener("abort", onAbort, {once: true})
+    // Handles an abort fired synchronously during native registration.
+    if (signal.aborted) onAbort()
+  })
+}

package/android/src/internal/AndroidManifest.xml

@@ -1,9 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-  <application>
-    <receiver android:name="com.mentra.crust.receivers.CaptionsTesterIncidentReceiver" android:exported="true">
-      <intent-filter>
-        <action android:name="com.mentra.CAPTIONS_TESTER_INCIDENT"/>
-      </intent-filter>
-    </receiver>
-  </application>
-</manifest>

package/android/src/internal/java/com/mentra/crust/receivers/CaptionsTesterIncidentReceiver.kt

@@ -1,46 +0,0 @@
-package com.mentra.crust.receivers
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.util.Log
-import com.mentra.crust.CrustModule
-
-/**
- * Receives broadcasts from the external captions tester and forwards them into React Native so
- * the app can file a normal incident through the existing mobile incident pipeline.
- */
-class CaptionsTesterIncidentReceiver : BroadcastReceiver() {
-  @Suppress("DEPRECATION")
-  override fun onReceive(context: Context?, intent: Intent?) {
-    if (intent == null) {
-      Log.w("CaptionsTesterIncident", "Received null intent")
-      return
-    }
-
-    val body =
-      hashMapOf<String, Any>(
-        "action" to (intent.action ?: "unknown"),
-        "timestamp" to System.currentTimeMillis(),
-      )
-
-    intent.getStringExtra("failure_code")?.let { body["failure_code"] = it }
-    intent.getStringExtra("failure_message")?.let { body["failure_message"] = it }
-    intent.getStringExtra("test_run_id")?.let { body["test_run_id"] = it }
-    intent.getStringExtra("scenario_name")?.let { body["scenario_name"] = it }
-    intent.getStringExtra("source")?.let { body["source"] = it }
-
-    intent.extras?.keySet()?.forEach { key ->
-      if (body.containsKey(key)) {
-        return@forEach
-      }
-      val value = intent.extras?.get(key) ?: return@forEach
-      when (value) {
-        is String, is Int, is Long, is Boolean, is Double, is Float -> body[key] = value
-        else -> body[key] = value.toString()
-      }
-    }
-
-    CrustModule.emitCaptionsTesterIncident(body)
-  }
-}