@mentra/crust 3.2.1-dev.314 → 3.3.0-beta.1000

package/ios/PermissionStatusReceipt.swift

@@ -0,0 +1,105 @@
+import AVFoundation
+import CoreBluetooth
+import CoreLocation
+import Foundation
+
+/// Passive app-owned observations. None of these getters requests consent,
+/// starts capture, creates a Bluetooth central, or joins a network.
+enum PermissionStatusReceipt {
+    static let relativePath = "MentraDiagnostics/permission-status.json"
+
+    static func state(_ rawStatus: String, _ status: String) -> [String: String] {
+        ["rawStatus": rawStatus, "status": status]
+    }
+
+    static func location(_ value: CLAuthorizationStatus) -> [String: String] {
+        switch value {
+        case .notDetermined: return state("notDetermined", "denied")
+        case .denied: return state("denied", "blocked")
+        case .restricted: return state("restricted", "unavailable")
+        case .authorizedAlways: return state("authorizedAlways", "granted")
+        case .authorizedWhenInUse: return state("authorizedWhenInUse", "granted")
+        @unknown default: return state("unknown", "unknown")
+        }
+    }
+
+    static func capture(_ value: AVAuthorizationStatus) -> [String: String] {
+        switch value {
+        case .notDetermined: return state("notDetermined", "denied")
+        case .denied: return state("denied", "blocked")
+        case .restricted: return state("restricted", "unavailable")
+        case .authorized: return state("authorized", "granted")
+        @unknown default: return state("unknown", "unknown")
+        }
+    }
+
+    static func bluetooth(_ value: CBManagerAuthorization) -> [String: String] {
+        switch value {
+        case .notDetermined: return state("notDetermined", "denied")
+        case .denied: return state("denied", "blocked")
+        case .restricted: return state("restricted", "unavailable")
+        case .allowedAlways: return state("allowedAlways", "granted")
+        @unknown default: return state("unknown", "unknown")
+        }
+    }
+
+    static func current() async -> [String: Any] {
+        // The global service getter may block; only the manager's authorization
+        // observation belongs to the main actor, which owns Core Location objects.
+        let servicesEnabled = CLLocationManager.locationServicesEnabled()
+        return await MainActor.run {
+            let bundle = Bundle.main
+            let formatter = ISO8601DateFormatter()
+            formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+            return [
+                "schemaVersion": 1,
+                "observedAt": formatter.string(from: Date()),
+                "identity": [
+                    "pid": ProcessInfo.processInfo.processIdentifier,
+                    "uid": getuid(),
+                    "bundleId": bundle.bundleIdentifier ?? "",
+                    "bundlePath": bundle.bundleURL.path,
+                    "executablePath": bundle.executableURL?.path ?? "",
+                    "version": bundle.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? "",
+                    "build": bundle.object(forInfoDictionaryKey: "CFBundleVersion") as? String ?? "",
+                ] as [String: Any],
+                "locationServicesEnabled": servicesEnabled,
+                "permissions": [
+                    "location": location(CLLocationManager().authorizationStatus),
+                    "camera": capture(AVCaptureDevice.authorizationStatus(for: .video)),
+                    "microphone": capture(AVCaptureDevice.authorizationStatus(for: .audio)),
+                    "bluetooth": bluetooth(CBManager.authorization),
+                    // iOS has no public passive Local Network authorization getter.
+                    "localNetwork": ["rawStatus": NSNull(), "status": "unknown"],
+                ] as [String: Any],
+            ]
+        }
+    }
+
+    static func correlate(_ observation: [String: Any], requestId: String) throws -> [String: Any] {
+        guard requestId.range(of: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}\\z", options: .regularExpression) != nil else {
+            throw NSError(domain: "MentraPermissionStatus", code: 1,
+                          userInfo: [NSLocalizedDescriptionKey: "One bounded permission request ID is required"])
+        }
+        return observation.merging(["requestId": requestId]) { _, fresh in fresh }
+    }
+
+    static func write(_ receipt: [String: Any], to path: URL) throws {
+        let files = FileManager.default
+        try files.createDirectory(at: path.deletingLastPathComponent(), withIntermediateDirectories: true,
+                                  attributes: [.posixPermissions: 0o700])
+        try JSONSerialization.data(withJSONObject: receipt, options: [.sortedKeys]).write(to: path, options: .atomic)
+        try files.setAttributes([.posixPermissions: 0o600], ofItemAtPath: path.path)
+    }
+
+    static func publish(requestId: String) async throws -> [String: Any] {
+        // Validate before observing; the request never controls a filesystem path.
+        _ = try correlate([:], requestId: requestId)
+        let observation = await current()
+        let receipt = try correlate(observation, requestId: requestId)
+        let cache = try FileManager.default.url(for: .cachesDirectory, in: .userDomainMask,
+                                                appropriateFor: nil, create: true)
+        try write(receipt, to: cache.appendingPathComponent(relativePath))
+        return receipt
+    }
+}

package/ios/Resources/startup.js

@@ -436,6 +436,140 @@
     }
     ;
     g.crypto = cryptoNs;
+    const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    const BASE64_VALUES = new Uint8Array(128).fill(255);
+    for (let i = 0; i < BASE64_ALPHABET.length; i++) BASE64_VALUES[BASE64_ALPHABET.charCodeAt(i)] = i;
+    const CHARS_PER_CHUNK = 8192;
+    function bytesOf(data) {
+      return data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    function bytesToBase64(bytes) {
+      const parts = [];
+      const chars = [];
+      for (let i = 0; i < bytes.length; i += 3) {
+        const b1 = bytes[i];
+        const b2 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+        const b3 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+        chars.push(
+          BASE64_ALPHABET.charCodeAt(b1 >> 2),
+          BASE64_ALPHABET.charCodeAt((b1 & 3) << 4 | b2 >> 4),
+          i + 1 < bytes.length ? BASE64_ALPHABET.charCodeAt((b2 & 15) << 2 | b3 >> 6) : 61,
+          i + 2 < bytes.length ? BASE64_ALPHABET.charCodeAt(b3 & 63) : 61
+        );
+        if (chars.length >= CHARS_PER_CHUNK) {
+          parts.push(String.fromCharCode.apply(null, chars));
+          chars.length = 0;
+        }
+      }
+      parts.push(String.fromCharCode.apply(null, chars));
+      return parts.join("");
+    }
+    function base64ToBytes(base64) {
+      const length = base64.length;
+      if (length % 4 !== 0) throw new TypeError("Invalid base64 from the native bridge");
+      const padding = length === 0 || base64.charCodeAt(length - 1) !== 61 ? 0 : base64.charCodeAt(length - 2) === 61 ? 2 : 1;
+      const out = new Uint8Array(length / 4 * 3 - padding);
+      const unpadded = padding === 0 ? length : length - 4;
+      let codes = 0;
+      let values = 0;
+      let o = 0;
+      for (let i = 0; i < unpadded; i += 4) {
+        const c1 = base64.charCodeAt(i);
+        const c2 = base64.charCodeAt(i + 1);
+        const c3 = base64.charCodeAt(i + 2);
+        const c4 = base64.charCodeAt(i + 3);
+        const v1 = BASE64_VALUES[c1 & 127];
+        const v2 = BASE64_VALUES[c2 & 127];
+        const v3 = BASE64_VALUES[c3 & 127];
+        const v4 = BASE64_VALUES[c4 & 127];
+        codes |= c1 | c2 | c3 | c4;
+        values |= v1 | v2 | v3 | v4;
+        out[o++] = v1 << 2 | v2 >> 4;
+        out[o++] = (v2 & 15) << 4 | v3 >> 2;
+        out[o++] = (v3 & 3) << 6 | v4;
+      }
+      if (padding > 0) {
+        const c1 = base64.charCodeAt(unpadded);
+        const c2 = base64.charCodeAt(unpadded + 1);
+        const c3 = padding === 1 ? base64.charCodeAt(unpadded + 2) : 65;
+        const v1 = BASE64_VALUES[c1 & 127];
+        const v2 = BASE64_VALUES[c2 & 127];
+        const v3 = BASE64_VALUES[c3 & 127];
+        codes |= c1 | c2 | c3;
+        values |= v1 | v2 | v3;
+        out[o++] = v1 << 2 | v2 >> 4;
+        if (padding === 1) out[o++] = (v2 & 15) << 4 | v3 >> 2;
+      }
+      if (codes > 127 || values > 63) throw new TypeError("Invalid base64 from the native bridge");
+      return out;
+    }
+    function decodeUtf8(bytes, fatal, ignoreBOM) {
+      const length = bytes.length;
+      const parts = [];
+      const units = [];
+      let i = !ignoreBOM && length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191 ? 3 : 0;
+      while (i < length) {
+        const asciiStart = i;
+        while (i < length && bytes[i] < 128) i++;
+        if (i > asciiStart) {
+          if (units.length > 0) {
+            parts.push(String.fromCharCode.apply(null, units));
+            units.length = 0;
+          }
+          for (let start = asciiStart; start < i; start += CHARS_PER_CHUNK) {
+            const chunk = bytes.subarray(start, Math.min(i, start + CHARS_PER_CHUNK));
+            parts.push(String.fromCharCode.apply(null, chunk));
+          }
+          if (i >= length) break;
+        }
+        const lead = bytes[i++];
+        let codePoint;
+        let needed;
+        let lower = 128;
+        let upper = 191;
+        if (lead >= 194 && lead <= 223) {
+          needed = 1;
+          codePoint = lead & 31;
+        } else if (lead >= 224 && lead <= 239) {
+          if (lead === 224) lower = 160;
+          if (lead === 237) upper = 159;
+          needed = 2;
+          codePoint = lead & 15;
+        } else if (lead >= 240 && lead <= 244) {
+          if (lead === 240) lower = 144;
+          if (lead === 244) upper = 143;
+          needed = 3;
+          codePoint = lead & 7;
+        } else {
+          needed = -1;
+          codePoint = 0;
+        }
+        while (needed > 0) {
+          const next = i < length ? bytes[i] : -1;
+          if (next < lower || next > upper) break;
+          codePoint = codePoint << 6 | next & 63;
+          lower = 128;
+          upper = 191;
+          needed--;
+          i++;
+        }
+        if (needed !== 0) {
+          if (fatal) throw new TypeError("The encoded data was not valid utf-8");
+          units.push(65533);
+        } else if (codePoint > 65535) {
+          codePoint -= 65536;
+          units.push(55296 + (codePoint >> 10), 56320 + (codePoint & 1023));
+        } else {
+          units.push(codePoint);
+        }
+        if (units.length >= CHARS_PER_CHUNK) {
+          parts.push(String.fromCharCode.apply(null, units));
+          units.length = 0;
+        }
+      }
+      if (units.length > 0) parts.push(String.fromCharCode.apply(null, units));
+      return parts.join("");
+    }
     if (typeof g.TextEncoder !== "function") {
       class TextEncoderPolyfill {
         constructor() {
@@ -476,36 +610,14 @@
     }
     if (typeof g.TextDecoder !== "function") {
       class TextDecoderPolyfill {
-        constructor(encoding = "utf-8") {
+        constructor(encoding = "utf-8", options) {
           this.encoding = encoding;
+          this.fatal = options?.fatal === true;
+          this.ignoreBOM = options?.ignoreBOM === true;
         }
         decode(buffer) {
           if (!buffer) return "";
-          const bytes = buffer instanceof Uint8Array ? buffer : buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-          let out = "";
-          let i = 0;
-          while (i < bytes.length) {
-            const b1 = bytes[i++];
-            let code;
-            if (b1 < 128) {
-              code = b1;
-            } else if (b1 < 192) {
-              code = 65533;
-            } else if (b1 < 224) {
-              code = (b1 & 31) << 6 | bytes[i++] & 63;
-            } else if (b1 < 240) {
-              code = (b1 & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
-            } else {
-              code = (b1 & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
-            }
-            if (code > 65535) {
-              code -= 65536;
-              out += String.fromCharCode(55296 + (code >> 10), 56320 + (code & 1023));
-            } else {
-              out += String.fromCharCode(code);
-            }
-          }
-          return out;
+          return decodeUtf8(bytesOf(buffer), this.fatal, this.ignoreBOM);
         }
       }
       ;
@@ -552,9 +664,12 @@
         const url = typeof input === "string" ? input : input.toString();
         const method = (init?.method ?? "GET").toUpperCase();
         let bodyString = null;
+        let bodyBase64;
         const reqBody = init?.body;
         if (typeof reqBody === "string") {
           bodyString = reqBody;
+        } else if (reqBody instanceof ArrayBuffer || ArrayBuffer.isView(reqBody)) {
+          bodyBase64 = bytesToBase64(bytesOf(reqBody));
         } else if (reqBody && typeof reqBody.toString === "function") {
           bodyString = reqBody.toString();
         }
@@ -578,9 +693,10 @@
         }
         const sendRequest = g.__mentraSendRequest;
         const result = await sendRequest("fetch", "request", [
-          { url, method, headers, body: bodyString }
+          bodyBase64 === void 0 ? { url, method, headers, body: bodyString } : { url, method, headers, bodyBase64 }
         ]);
-        const bodyText = typeof result.body === "string" ? result.body : "";
+        const responseText = typeof result.body === "string" ? result.body : null;
+        const responseBase64 = typeof result.bodyBase64 === "string" ? result.bodyBase64 : "";
         const responseHeaders = new Map(Object.entries(result.headers ?? {}));
         class ResponseLike {
           constructor() {
@@ -597,11 +713,13 @@
             };
           }
           async text() {
-            return bodyText;
+            if (responseText === null) return decodeUtf8(base64ToBytes(responseBase64), false, false);
+            return responseText.charCodeAt(0) === 65279 ? responseText.slice(1) : responseText;
           }
           async json() {
+            const text = await this.text();
             try {
-              return JSON.parse(bodyText);
+              return JSON.parse(text);
             } catch (e) {
               const err = new Error(
                 `Failed to parse JSON response from ${url}: ${e instanceof Error ? e.message : String(e)}`
@@ -611,52 +729,21 @@
             }
           }
           async arrayBuffer() {
+            if (responseText === null) return base64ToBytes(responseBase64).buffer;
             const enc = new g.TextEncoder();
-            return enc.encode(bodyText).buffer;
+            return enc.encode(responseText).buffer;
           }
         }
         return new ResponseLike();
       };
     }
     if (typeof g.WebSocket !== "function") {
-      let bytesToBase642 = function(bytes) {
-        const b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-        let out = "";
-        let i = 0;
-        while (i < bytes.length) {
-          const c1 = bytes[i++];
-          const c2 = i < bytes.length ? bytes[i++] : NaN;
-          const c3 = i < bytes.length ? bytes[i++] : NaN;
-          const e1 = c1 >> 2;
-          const e2 = (c1 & 3) << 4 | (Number.isNaN(c2) ? 0 : c2 >> 4);
-          const e3 = Number.isNaN(c2) ? 64 : (c2 & 15) << 2 | (Number.isNaN(c3) ? 0 : c3 >> 6);
-          const e4 = Number.isNaN(c3) ? 64 : c3 & 63;
-          out += b64[e1] + b64[e2] + (e3 === 64 ? "=" : b64[e3]) + (e4 === 64 ? "=" : b64[e4]);
-        }
-        return out;
-      }, base64ToBytes2 = function(s) {
-        const b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-        const clean = s.replace(/=+$/, "");
-        const out = [];
-        let buf = 0;
-        let bits = 0;
-        for (let i = 0; i < clean.length; i++) {
-          const idx = b64.indexOf(clean[i]);
-          if (idx < 0) continue;
-          buf = buf << 6 | idx;
-          bits += 6;
-          if (bits >= 8) {
-            bits -= 8;
-            out.push(buf >> bits & 255);
-          }
-        }
-        return new Uint8Array(out);
-      }, queueMicrotaskSafe2 = function(fn) {
+      let queueMicrotaskSafe2 = function(fn) {
         const q = g.queueMicrotask;
         if (typeof q === "function") q(fn);
         else g.Promise.resolve().then(fn);
       };
-      var bytesToBase64 = bytesToBase642, base64ToBytes = base64ToBytes2, queueMicrotaskSafe = queueMicrotaskSafe2;
+      var queueMicrotaskSafe = queueMicrotaskSafe2;
       const sockets = /* @__PURE__ */ new Map();
       g.__mentraDeliverWebSocketEvent = (sid, type, payload) => {
         const sock = sockets.get(sid);
@@ -718,8 +805,7 @@
             payload = data;
           } else {
             kind = "binary";
-            const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-            payload = bytesToBase642(bytes);
+            payload = bytesToBase64(bytesOf(data));
           }
           try {
             __dispatch("ws", "send", JSON.stringify([{ sid: this.sid, kind, payload }]));
@@ -752,7 +838,7 @@
           }
           const synth = { type, target: this, ...ev };
           if (type === "message" && ev.kind === "binary" && typeof ev.data === "string") {
-            synth.data = base64ToBytes2(ev.data).buffer;
+            synth.data = base64ToBytes(ev.data).buffer;
           } else if (type === "message" && ev.kind === "text") {
             synth.data = ev.data;
           }

package/ios/Source/JSCPolyfillBridge.swift

@@ -100,14 +100,25 @@ public enum JSCPolyfillBridge {
             }
 
             var urlRequest = URLRequest(url: url)
-            urlRequest.httpMethod = (req["method"] as? String) ?? "GET"
+            let method = (req["method"] as? String) ?? "GET"
+            urlRequest.httpMethod = method
             if let headers = req["headers"] as? [String: Any] {
                 for (k, v) in headers {
                     urlRequest.setValue(String(describing: v), forHTTPHeaderField: k)
                 }
             }
-            if let body = req["body"] as? String, !body.isEmpty {
-                urlRequest.httpBody = body.data(using: .utf8)
+            // ArrayBuffer and typed-array bodies arrive as base64 of their bytes.
+            // As on Android, an empty body is still sent, and POST, PUT and PATCH
+            // always carry one, so the server sees Content-Length: 0.
+            if let encoded = req["bodyBase64"] as? String {
+                guard let data = Data(base64Encoded: encoded) else {
+                    return .error(code: "INVALID_ARGS", message: "fetch.request: bodyBase64 is not base64")
+                }
+                urlRequest.httpBody = data
+            } else if let body = req["body"] as? String {
+                urlRequest.httpBody = Data(body.utf8)
+            } else if ["POST", "PUT", "PATCH"].contains(method.uppercased()) {
+                urlRequest.httpBody = Data()
             }
 
             // Reasonable defaults — caller can override later by passing
@@ -141,21 +152,27 @@ public enum JSCPolyfillBridge {
                     }
                     return out
                 }()
-                let bodyStr: String = {
-                    guard let data else { return "" }
-                    return String(data: data, encoding: .utf8) ?? ""
-                }()
+                var result: [String: Any] = [
+                    "status": status,
+                    "statusText": HTTPURLResponse.localizedString(forStatusCode: status),
+                    "headers": headersDict,
+                    "ok": (200..<300).contains(status),
+                ]
+                // The string `body` only when the bytes are exactly its UTF-8
+                // encoding; otherwise every byte as base64. The decode fails
+                // on invalid UTF-8, and the round trip also catches a dropped
+                // byte order mark.
+                let body = data ?? Data()
+                if let text = String(data: body, encoding: .utf8), Data(text.utf8) == body {
+                    result["body"] = text
+                } else {
+                    result["bodyBase64"] = body.base64EncodedString()
+                }
                 let payload: [String: Any] = [
                     "kind": "response",
                     "reqId": reqId,
                     "ok": true,
-                    "result": [
-                        "status": status,
-                        "statusText": HTTPURLResponse.localizedString(forStatusCode: status),
-                        "headers": headersDict,
-                        "body": bodyStr,
-                        "ok": (200..<300).contains(status),
-                    ] as [String: Any],
+                    "result": result,
                 ]
                 JSCRuntime.shared.dispatchToJs(packageName: packageName, envelope: payload)
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/crust",
-  "version": "3.2.1-dev.314",
+  "version": "3.3.0-beta.1000",
   "description": "Mentra Native Module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -35,7 +35,7 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/Mentra-Community/MentraOS/tree/dev/mobile/modules/crust#readme",
   "dependencies": {
-    "@mentra/jspolyfill": "3.2.1-dev.314"
+    "@mentra/jspolyfill": "3.3.0-beta.1000"
   },
   "devDependencies": {
     "@expo/config-plugins": ">=8.0.0",

package/plugin/build/index.d.ts

@@ -14,6 +14,8 @@ import { type ConfigPlugin } from "expo/config-plugins";
  *   both fails the release build with duplicate classes)
  * - core-library desugaring (crust's AAR metadata requires it of embedding
  *   apps — the Nav SDK uses newer core libs)
+ * - Kotlin 2.3.0 or newer, with the root Kotlin Gradle plugin pinned to it
+ *   (crust's QuickJS library, quickjs-kt 1.0.15, is compiled with Kotlin 2.4)
  * - a generated MainApplication process guard so the notification-listener
  *   process never initializes React Native
  * - iOS Mapbox Swift Package products and the Crust build-order dependency

package/plugin/build/index.js

@@ -21,6 +21,8 @@ const withMapboxNavIos_1 = __importDefault(require("./withMapboxNavIos"));
  *   both fails the release build with duplicate classes)
  * - core-library desugaring (crust's AAR metadata requires it of embedding
  *   apps — the Nav SDK uses newer core libs)
+ * - Kotlin 2.3.0 or newer, with the root Kotlin Gradle plugin pinned to it
+ *   (crust's QuickJS library, quickjs-kt 1.0.15, is compiled with Kotlin 2.4)
  * - a generated MainApplication process guard so the notification-listener
  *   process never initializes React Native
  * - iOS Mapbox Swift Package products and the Crust build-order dependency

package/plugin/build/withAndroid.js

@@ -20,12 +20,50 @@ const MAPBOX_REPO = [
     "      }",
     "    }",
 ].join("\n");
+// quickjs-kt 1.0.15 is compiled with Kotlin 2.4, and a Kotlin compiler reads
+// metadata one version ahead. 2.3.0 is the newest 2.3 release Expo SDK 55's
+// root plugin maps to a KSP version.
+const MIN_KOTLIN_VERSION = "2.3.0";
+// The template's unversioned classpath entry resolves to the Kotlin Gradle
+// plugin React Native's Gradle plugin depends on (2.1.20 on RN 0.83), whatever
+// `android.kotlinVersion` says; Expo fixes that only in SDK 58
+// (expo/expo#49668). SDK 56 also never copies the property into Expo's catalog,
+// so pin both the compiler and the root `kotlinVersion` to the property itself.
+const UNVERSIONED_KOTLIN_PLUGIN = "classpath('org.jetbrains.kotlin:kotlin-gradle-plugin')";
+const PINNED_KOTLIN_PLUGIN = `classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:\${findProperty('android.kotlinVersion')}")`;
+const KOTLIN_VERSION_MARKER = "kotlinVersion from android.kotlinVersion (injected by @mentra/crust)";
+const EXPO_ROOT_PROJECT = 'apply plugin: "expo-root-project"';
+function isOlderVersion(version, minimum) {
+    const actual = version.split(".").map(Number);
+    const required = minimum.split(".").map(Number);
+    for (let i = 0; i < required.length; i++) {
+        if ((actual[i] ?? 0) !== required[i])
+            return (actual[i] ?? 0) < required[i];
+    }
+    return false;
+}
+function withCrustKotlinVersion(config) {
+    return (0, config_plugins_1.withGradleProperties)(config, (cfg) => {
+        const property = cfg.modResults.find((item) => item.type === "property" && item.key === "android.kotlinVersion");
+        if (property?.type !== "property") {
+            cfg.modResults.push({ type: "property", key: "android.kotlinVersion", value: MIN_KOTLIN_VERSION });
+        }
+        else if (isOlderVersion(property.value, MIN_KOTLIN_VERSION)) {
+            property.value = MIN_KOTLIN_VERSION;
+        }
+        return cfg;
+    });
+}
 const PROTOBUF_EXCLUDE = "exclude group: 'com.google.protobuf', module: 'protobuf-javalite'";
 const NOTIFICATION_PROCESS_GUARD = "crust: skip React Native in notification process";
 const NOTIFICATION_CONFIG_GUARD = "crust: skip Expo lifecycle in notification process";
 function withCrustProjectGradle(config) {
     return (0, config_plugins_1.withProjectBuildGradle)(config, (cfg) => {
         let gradle = cfg.modResults.contents;
+        gradle = gradle.replace(UNVERSIONED_KOTLIN_PLUGIN, PINNED_KOTLIN_PLUGIN);
+        if (!gradle.includes(KOTLIN_VERSION_MARKER)) {
+            gradle = gradle.replace(EXPO_ROOT_PROJECT, `// ${KOTLIN_VERSION_MARKER}\next.kotlinVersion = findProperty('android.kotlinVersion')\n${EXPO_ROOT_PROJECT}`);
+        }
         // Mapbox Downloads repo, inserted at the top of allprojects.repositories.
         if (!gradle.includes(MAPBOX_REPO_MARKER)) {
             const reposMatch = gradle.match(/allprojects\s*\{[\s\S]*?repositories\s*\{/);
@@ -129,6 +167,7 @@ function withNotificationProcessGuard(config) {
     });
 }
 const withCrustAndroidBuildContract = (config) => {
+    config = withCrustKotlinVersion(config);
     config = withCrustProjectGradle(config);
     config = withCrustAppGradle(config);
     return withNotificationProcessGuard(config);

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,17 +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
 
   /**