@glassly/crust 0.1.0-dev.1

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@glassly/crust",
+  "version": "0.1.0-dev.1",
+  "description": "Glassly Native Module",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "app.plugin": "app.plugin.js",
+  "scripts": {
+    "build": "expo-module build && expo-module build plugin",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "EXPO_NONINTERACTIVE=1 expo-module build && EXPO_NONINTERACTIVE=1 expo-module build plugin",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android",
+    "build:plugin": "expo-module build plugin"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "crust",
+    "Crust"
+  ],
+  "repository": "https://github.com/fossephate/crust",
+  "bugs": {
+    "url": "https://github.com/fossephate/crust/issues"
+  },
+  "author": "fossephate <6175367+fossephate@users.noreply.github.com> (https://github.com/fossephate)",
+  "license": "MIT",
+  "homepage": "https://github.com/fossephate/crust#readme",
+  "dependencies": {
+    "@glassly/jspolyfill": "^0.1.0-dev.0"
+  },
+  "devDependencies": {
+    "@expo/config-plugins": ">=8.0.0",
+    "expo-module-scripts": "^56.0.3",
+    "typescript": "~5.9.2"
+  },
+  "peerDependencies": {
+    "@types/react": "*",
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "android",
+    "!android/.gradle",
+    "!android/.gradle/**",
+    "!android/build",
+    "!android/build/**",
+    "ios",
+    "!ios/build",
+    "!ios/build/**",
+    "!ios/Pods",
+    "!ios/Pods/**",
+    "app.plugin.js",
+    "build",
+    "plugin/build",
+    "expo-module.config.json",
+    "src",
+    "!src/__tests__",
+    "README.md"
+  ]
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,21 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+/**
+ * @glassly/crust config plugin — the module's own Android build contract, so
+ * every host that embeds crust (the Glassly app, the example OEM app, real OEM
+ * hosts) inherits it by listing "@glassly/crust" in `app.json` plugins instead
+ * of hand-mirroring gradle edits:
+ *
+ * - the authenticated Mapbox Downloads Maven repo (crust bundles the Mapbox
+ *   Navigation SDK, whose artifacts exist only in Mapbox's private registry;
+ *   the MAPBOX_DOWNLOADS_TOKEN env / gradle property authenticates it at
+ *   dependency-resolution time — build-time only, never in the APK)
+ * - a global protobuf-javalite exclusion (the bluetooth-sdk/crust native stack
+ *   needs protobuf-java; Mapbox drags protobuf-javalite transitively; shipping
+ *   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)
+ * - a generated MainApplication process guard so the notification-listener
+ *   process never initializes React Native
+ */
+declare const withCrust: ConfigPlugin;
+export default withCrust;

package/plugin/build/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const withAndroid_1 = require("./withAndroid");
+/**
+ * @glassly/crust config plugin — the module's own Android build contract, so
+ * every host that embeds crust (the Glassly app, the example OEM app, real OEM
+ * hosts) inherits it by listing "@glassly/crust" in `app.json` plugins instead
+ * of hand-mirroring gradle edits:
+ *
+ * - the authenticated Mapbox Downloads Maven repo (crust bundles the Mapbox
+ *   Navigation SDK, whose artifacts exist only in Mapbox's private registry;
+ *   the MAPBOX_DOWNLOADS_TOKEN env / gradle property authenticates it at
+ *   dependency-resolution time — build-time only, never in the APK)
+ * - a global protobuf-javalite exclusion (the bluetooth-sdk/crust native stack
+ *   needs protobuf-java; Mapbox drags protobuf-javalite transitively; shipping
+ *   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)
+ * - a generated MainApplication process guard so the notification-listener
+ *   process never initializes React Native
+ */
+const withCrust = (config) => {
+    return (0, withAndroid_1.withCrustAndroidBuildContract)(config);
+};
+exports.default = withCrust;

package/plugin/build/withAndroid.d.ts

@@ -0,0 +1,2 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+export declare const withCrustAndroidBuildContract: ConfigPlugin;

package/plugin/build/withAndroid.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withCrustAndroidBuildContract = void 0;
+const config_plugins_1 = require("expo/config-plugins");
+// Marker comments double as idempotency checks: each injection looks for its
+// OWN unique marker (never a shared substring — a marker one block contains
+// can silently mask another block's check).
+const MAPBOX_REPO_MARKER = "mapbox: navigation sdk downloads repo (injected by @glassly/crust)";
+const MAPBOX_REPO = [
+    "    maven {",
+    `      // ${MAPBOX_REPO_MARKER}`,
+    "      url 'https://api.mapbox.com/downloads/v2/releases/maven'",
+    "      authentication { basic(BasicAuthentication) }",
+    "      credentials {",
+    "        username = 'mapbox'",
+    "        password = System.getenv('MAPBOX_DOWNLOADS_TOKEN') ?: (findProperty('MAPBOX_DOWNLOADS_TOKEN') ?: '')",
+    "      }",
+    "    }",
+].join("\n");
+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;
+        // 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*\{/);
+            if (reposMatch) {
+                const idx = (reposMatch.index ?? 0) + reposMatch[0].length;
+                gradle = gradle.slice(0, idx) + "\n" + MAPBOX_REPO + gradle.slice(idx);
+            }
+            else {
+                gradle += `\nallprojects {\n  repositories {\n${MAPBOX_REPO}\n  }\n}\n`;
+            }
+        }
+        // protobuf-javalite exclusion, appended as its own allprojects block so
+        // placement never depends on the shape of existing gradle content (other
+        // plugins add maven{} entries that break brace-counting regexes).
+        if (!gradle.includes(PROTOBUF_EXCLUDE)) {
+            gradle += `
+// Exclude protobuf-javalite in every project to avoid duplicate classes with
+// protobuf-java (injected by @glassly/crust).
+allprojects {
+  configurations.all {
+    ${PROTOBUF_EXCLUDE}
+  }
+}
+`;
+        }
+        cfg.modResults.contents = gradle;
+        return cfg;
+    });
+}
+function withCrustAppGradle(config) {
+    return (0, config_plugins_1.withAppBuildGradle)(config, (cfg) => {
+        let gradle = cfg.modResults.contents;
+        if (!gradle.includes("coreLibraryDesugaringEnabled")) {
+            gradle = gradle.replace(/(namespace\s+['"][^'"]+['"])/, `$1
+    compileOptions {
+        coreLibraryDesugaringEnabled true
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }`);
+        }
+        if (!gradle.includes("coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs")) {
+            gradle = gradle.replace(/(implementation\("com\.facebook\.react:react-android"\))/, `$1
+
+    // Required by :glassly-crust (Mapbox Navigation SDK uses newer core libs).
+    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.1.4'`);
+        }
+        cfg.modResults.contents = gradle;
+        return cfg;
+    });
+}
+function withNotificationProcessGuard(config) {
+    return (0, config_plugins_1.withMainApplication)(config, (cfg) => {
+        let source = cfg.modResults.contents;
+        const isJava = cfg.modResults.language === "java";
+        if (!source.includes(NOTIFICATION_PROCESS_GUARD)) {
+            const pattern = isJava
+                ? /public void onCreate\(\)\s*\{\s*super\.onCreate\(\);/
+                : /override fun onCreate\(\)\s*\{\s*super\.onCreate\(\)/;
+            const replacement = isJava
+                ? `public void onCreate() {
+    super.onCreate();
+    // ${NOTIFICATION_PROCESS_GUARD}
+    if (com.glassly.crust.services.NotificationProcess.isCurrent(this)) {
+      return;
+    }`
+                : `override fun onCreate() {
+    super.onCreate()
+    // ${NOTIFICATION_PROCESS_GUARD}
+    if (com.glassly.crust.services.NotificationProcess.isCurrent(this)) {
+      return
+    }`;
+            if (!pattern.test(source)) {
+                throw new Error("@glassly/crust could not add the notification-process guard to MainApplication");
+            }
+            source = source.replace(pattern, replacement);
+        }
+        if (!source.includes(NOTIFICATION_CONFIG_GUARD)) {
+            const pattern = isJava
+                ? /public void onConfigurationChanged\(Configuration newConfig\)\s*\{\s*super\.onConfigurationChanged\(newConfig\);/
+                : /override fun onConfigurationChanged\(newConfig: Configuration\)\s*\{\s*super\.onConfigurationChanged\(newConfig\)/;
+            const replacement = isJava
+                ? `public void onConfigurationChanged(Configuration newConfig) {
+    super.onConfigurationChanged(newConfig);
+    // ${NOTIFICATION_CONFIG_GUARD}
+    if (com.glassly.crust.services.NotificationProcess.isCurrent(this)) {
+      return;
+    }`
+                : `override fun onConfigurationChanged(newConfig: Configuration) {
+    super.onConfigurationChanged(newConfig)
+    // ${NOTIFICATION_CONFIG_GUARD}
+    if (com.glassly.crust.services.NotificationProcess.isCurrent(this)) {
+      return
+    }`;
+            // Some custom hosts do not override onConfigurationChanged. In that case
+            // there is no Expo lifecycle callback to guard.
+            if (pattern.test(source))
+                source = source.replace(pattern, replacement);
+        }
+        cfg.modResults.contents = source;
+        return cfg;
+    });
+}
+const withCrustAndroidBuildContract = (config) => {
+    config = withCrustProjectGradle(config);
+    config = withCrustAppGradle(config);
+    return withNotificationProcessGuard(config);
+};
+exports.withCrustAndroidBuildContract = withCrustAndroidBuildContract;

package/src/Crust.types.ts

@@ -0,0 +1,162 @@
+import type {StyleProp, ViewStyle} from "react-native"
+
+export type OnLoadEventPayload = {
+  url: string
+}
+
+export type CrustModuleEvents = {
+  onChange: (params: ChangeEventPayload) => void
+  onNavManeuver: (params: NavManeuverPayload) => void
+  onNavRerouting: (params: Record<string, never>) => void
+  onNavArrived: (params: Record<string, never>) => void
+  onNavError: (params: NavErrorPayload) => void
+  onNavLocation: (params: NavLocationPayload) => void
+  onNavRoute: (params: NavRoutePayload) => void
+  onNavOffRoute: (params: NavOffRoutePayload) => void
+  onHeading: (params: HeadingPayload) => void
+}
+
+export type NavOffRoutePayload = {
+  /** Approximate perpendicular distance in meters from the route. */
+  offRouteDistanceMeters: number
+}
+
+export type HeadingPayload = {
+  /** Compass heading in degrees, 0 = north, 90 = east. */
+  degrees: number
+}
+
+export type NavRoutePayload = {
+  points: Array<{lat: number; lng: number}>
+  /**
+   * Ordered step list along the route, when supplied by the host. Each
+   * step is one navigable segment — typically one straight stretch of
+   * road ending in a maneuver. Optional for back-compat with older
+   * hosts that only ship the polyline. The SDK's pivot module consumes
+   * this to enrich pivots with `fromRoad` / `toRoad` metadata.
+   */
+  steps?: NavRouteStepPayload[]
+}
+
+export type NavRouteStepPayload = {
+  /** Coordinate where this step begins (== end of the previous step). */
+  lat: number
+  lng: number
+  /**
+   * Index into `NavRoutePayload.points[]` where this step starts.
+   * Lets consumers correlate step boundaries with polyline geometry.
+   */
+  routeIndex: number
+  /** Name of the road traversed during this step. Null when the engine has no name. */
+  road?: string | null
+  /**
+   * Categorical maneuver performed at the END of this step (i.e. how
+   * the user exits this step). Same vocabulary as `NavManeuverPayload.maneuverType`.
+   */
+  maneuver: string
+  /** Length of this step in meters. */
+  distanceMeters: number
+}
+
+export type NavLocationPayload = {
+  lat: number
+  lng: number
+  /** Horizontal accuracy in meters, if reported by the platform. */
+  accuracy: number | null
+  /** Unix ms timestamp of the fix. */
+  timestamp: number
+  phone_notification: (event: PhoneNotificationEvent) => void
+  phone_notification_dismissed: (event: PhoneNotificationDismissedEvent) => void
+  captions_tester_incident: (event: CaptionsTesterIncidentEvent) => void
+}
+
+export type ChangeEventPayload = {
+  value: string
+}
+
+export type NavManeuverPayload = {
+  /**
+   * Categorical type of the upcoming maneuver. One of: STRAIGHT,
+   * SLIGHT_LEFT, SLIGHT_RIGHT, TURN_LEFT, TURN_RIGHT, SHARP_LEFT,
+   * SHARP_RIGHT, U_TURN, ARRIVE.
+   */
+  maneuverType: string
+  /** Distance in meters from the user's current position to that maneuver. -1 if unknown. */
+  distanceMeters: number
+  /** Road the user is currently on, per the Nav SDK. Null if unavailable. */
+  fromRoad?: string | null
+  /**
+   * Legacy "next road" field — historically populated from the same
+   * source as `fromRoad` (the current step's road, NOT the road
+   * after the upcoming turn). Kept for back-compat. New consumers
+   * should read `nextStepRoad` instead.
+   */
+  toRoad?: string | null
+  /**
+   * Road the user will be on AFTER the upcoming maneuver, sourced
+   * from the Nav SDK's `remainingSteps[0]`. This is the value to
+   * show as the "next street" headline on the maneuver card. Null
+   * when the SDK hasn't surfaced a remaining step yet (final leg,
+   * pre-first-NavInfo, etc.).
+   */
+  nextStepRoad?: string | null
+  /** Total remaining distance to final destination, meters. -1 if unknown. */
+  distanceToDestinationMeters?: number
+  /** Total remaining travel time, seconds. -1 if unknown. */
+  timeToDestinationSeconds?: number
+  /** Current speed in m/s. Null if unavailable. */
+  currentSpeedMps?: number | null
+  /** Speed limit on the current road segment in m/s. Null if unknown / not regulated. */
+  speedLimitMps?: number | null
+  /** Bearing along the route at the user's current position, 0–360. Null if unknown. */
+  routeHeadingDeg?: number | null
+}
+
+export type NavErrorPayload = {
+  message: string
+}
+
+export type InstalledApp = {
+  packageName: string
+  appName: string
+  isBlocked: boolean
+  icon: string | null
+}
+
+export type PhoneNotificationEvent = {
+  notificationId: string
+  app: string
+  title: string
+  content: string
+  /**
+   * Android notification priority: PRIORITY_MIN (-2) through PRIORITY_MAX (2).
+   * Derived from the channel importance when the ranking is available, since
+   * Notification.priority reads 0 for channel-based notifications.
+   */
+  priority: number
+  timestamp: number
+  packageName: string
+}
+
+export type PhoneNotificationDismissedEvent = {
+  notificationKey: string
+  packageName: string
+  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>
+}

package/src/CrustModule.ts

@@ -0,0 +1,194 @@
+import {NativeModule, requireNativeModule} from "expo"
+
+import type {CrustModuleEvents, InstalledApp} from "./Crust.types"
+
+declare class CrustModule extends NativeModule<CrustModuleEvents> {
+  PI: number
+  hello(): string
+  setValueAsync(value: string): Promise<void>
+  nativeHttpRequest(
+    method: string,
+    url: string,
+    headers: Record<string, string>,
+    body?: string | null,
+  ): Promise<{status: number; statusText: string; headers: Record<string, string>; body: string}>
+  showAVRoutePicker(tintColor?: string | null): void
+
+  /**
+   * iOS: configure `preferredScreenEdgesDeferringSystemGestures`. When an
+   * edge is deferred, the first swipe across that edge is consumed by the
+   * app and the system gesture (Control Center, Notification Center, Home
+   * indicator) only fires on a second swipe — i.e. a two-swipe-to-exit UX.
+   *
+   * Pass `[]` to restore default behavior. Android: no-op (Android has no
+   * per-app equivalent; system gestures are configured at the OS level).
+   */
+  setDeferredSystemGestures(edges: Array<"top" | "bottom" | "left" | "right" | "all">): Promise<void>
+
+  // Glassly Notification Commands
+  setNotificationConfig(listenerEnabled: boolean, blocklist: string[]): Promise<void>
+  getInstalledApps(): Promise<InstalledApp[]>
+  getInstalledAppsForNotifications(): Promise<InstalledApp[]>
+  hasNotificationListenerPermission(): Promise<boolean>
+  refreshNotificationListener(): Promise<boolean>
+  openNotificationListenerSettings(): Promise<boolean>
+  isBetaBuild(): Promise<boolean>
+  // location services commands
+  showLocationServicesDialog(): Promise<boolean>
+  isLocationServicesEnabled(): Promise<boolean>
+  openLocationSettings(): Promise<boolean>
+  openAppSettings(): Promise<boolean>
+  openBluetoothSettings(): Promise<boolean>
+
+  // Image Processing Commands
+  processGalleryImage(
+    inputPath: string,
+    outputPath: string,
+    options: {
+      lensCorrection?: boolean
+      colorCorrection?: boolean
+    },
+  ): Promise<{
+    success: boolean
+    outputPath?: string
+    processingTimeMs?: number
+    error?: string
+  }>
+
+  mergeHdrBrackets(
+    underPath: string,
+    normalPath: string,
+    overPath: string,
+    outputPath: string,
+  ): Promise<{
+    success: boolean
+    outputPath?: string
+    processingTimeMs?: number
+    error?: string
+  }>
+
+  stabilizeVideo(
+    inputPath: string,
+    imuPath: string,
+    outputPath: string,
+  ): Promise<{
+    success: boolean
+    outputPath?: string
+    processingTimeMs?: number
+    error?: string
+  }>
+
+  // Media Library Commands
+  saveToGalleryWithDate(
+    filePath: string,
+    captureTimeMillis?: number,
+    displayName?: string,
+  ): Promise<{
+    success: boolean
+    uri?: string
+    identifier?: string
+    existing?: boolean
+    error?: string
+  }>
+
+  // Navigation (both platforms via Mapbox; the dev toggles below are Android-only)
+  /**
+   * Override the Mapbox access token the native Navigation SDK
+   * authenticates with. A non-empty token wins over the one baked at build
+   * time (AndroidManifest `com.mapbox.token` / Info.plist `MBXAccessToken`);
+   * "" clears the override and restores the baked token. Call before
+   * `startNavigation` — the engine pushes the user's Settings > Keys token
+   * here per trip start.
+   */
+  setMapboxAccessToken(token: string): Promise<{ok: boolean; error?: string}>
+  startNavigation(
+    lat: number,
+    lng: number,
+    options?: {
+      simulate?: boolean
+      speedMultiplier?: number
+      /** Optional multi-stop list. When present takes precedence over lat/lng. Last entry is the final destination. */
+      stops?: Array<{lat: number; lng: number}>
+      /** "walking" | "driving" | "cycling" | "two_wheeler". Defaults driving. */
+      mode?: string
+      avoid?: {highways?: boolean; tolls?: boolean; ferries?: boolean}
+      /** Force a reroute when the user is more than N meters past a pivot they didn't take. */
+      missedTurnRerouteMeters?: number
+    },
+  ): Promise<{ok: boolean; error?: string}>
+  stopNavigation(): Promise<{ok: boolean; error?: string}>
+
+  /**
+   * Kept for API parity with the Google-era contract. Mapbox has no
+   * Terms & Conditions dialog, so no dialog is shown; resolves with
+   * `{accepted: true}` once permission handling completes. Idempotent —
+   * still safe (and intended) to call eagerly.
+   */
+  requestNavigationPermission(): Promise<{ok: boolean; accepted: boolean; error?: string}>
+
+  /**
+   * Dev-only: push the simulated user position off-route so the Nav SDK
+   * reroutes. Only meaningful in simulate mode. Both platforms;
+   * `offsetMeters` tunes the jump on Android and is ignored on iOS.
+   */
+  simulateDeviation(offsetMeters?: number): Promise<{ok: boolean; error?: string}>
+
+  /**
+   * Dev toggle. When enabled, the native NavigationManager shifts every
+   * reported location ~8m perpendicular to the route bearing, simulating
+   * a pedestrian walking on the wrong sidewalk. Only meaningful in
+   * simulate mode; lets us verify the SDK's along-path pivot trigger
+   * fires even when the user never crosses the 7m pivot point radius.
+   * Android-only today; iOS is a no-op stub.
+   */
+  setWrongSidewalkOffset(enabled: boolean): Promise<{ok: boolean; error?: string}>
+
+  /**
+   * Dev toggle. When enabled, the native NavigationManager takes over
+   * from the Mapbox simulator and walks the user along a modified
+   * polyline that omits crossing micro-steps — reproducing the
+   * wrong-sidewalk-then-missed-the-turn scenario. Android-only today;
+   * iOS is a no-op stub.
+   */
+  setSkipCrossings(enabled: boolean): Promise<{ok: boolean; error?: string}>
+
+  // Heading / compass (both platforms)
+  startHeading(): Promise<{ok: boolean; error?: string}>
+  stopHeading(): Promise<{ok: boolean; error?: string}>
+
+  // GlasslyJS Runtime — per-miniapp JSContext lifecycle.
+  /**
+   * Spawn a per-miniapp JS context. Re-spawn is allowed: a live context
+   * with the same packageName is killed first. Returns true if the
+   * polyfill bundle + miniapp source evaluated without throwing.
+   *
+   * The polyfill bundle is `mobile/modules/glasslyjs-runtime/dist/startup.js`
+   * (shipped inside the host binary). It installs window-style globals
+   * (console, timers, fetch, localStorage, crypto) atop the JSC runtime.
+   */
+  jsSpawn(packageName: string, polyfillBundle: string, miniappJs: string): Promise<boolean>
+  jsEvaluate(packageName: string, source: string): Promise<unknown>
+  jsKill(packageName: string): Promise<void>
+  /**
+   * Push a `{kind: "event"|"response", …}` envelope into the named
+   * context's globalThis.__deliver. Returns when the underlying
+   * evaluateScript completes (the JS handler runs synchronously on the
+   * context's queue).
+   */
+  jsDispatchToJs(packageName: string, envelope: Record<string, unknown>): Promise<void>
+  jsSetManifest(packageName: string, permissions: string[]): Promise<void>
+  /** Diagnostic — returns the packageNames of every live JSContext. */
+  jsAlivePackages(): string[]
+  /** Diagnostic — force a GC cycle on the named context. */
+  jsDebugForceGC(packageName: string): Promise<boolean>
+  /**
+   * Read the bundled GlasslyJS polyfill (startup.js) shipped inside the
+   * host binary. Synchronous — host RN code calls this once on app boot
+   * and caches the string, then passes it to every jsSpawn so
+   * every JSContext starts with the same polyfill ABI.
+   */
+  jsLoadPolyfillBundle(): string
+}
+
+// This call loads the native module object from the JSI.
+export default requireNativeModule<CrustModule>("Crust")

package/src/CrustModule.web.ts

@@ -0,0 +1,72 @@
+import {registerWebModule, NativeModule} from "expo"
+
+import type {CrustModuleEvents} from "./Crust.types"
+
+class CrustModule extends NativeModule<CrustModuleEvents> {
+  PI = Math.PI
+  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(),
+    }
+  }
+  hello() {
+    return "Hello world! 👋"
+  }
+  showAVRoutePicker(_tintColor?: string | null) {}
+  async setDeferredSystemGestures(_edges: string[]): Promise<void> {}
+  async setNotificationConfig(_listenerEnabled: boolean, _blocklist: string[]): Promise<void> {}
+  async getInstalledApps() {
+    return []
+  }
+  async getInstalledAppsForNotifications() {
+    return []
+  }
+  async hasNotificationListenerPermission() {
+    return false
+  }
+  async refreshNotificationListener() {
+    return false
+  }
+  async openNotificationListenerSettings() {
+    return false
+  }
+  async isBetaBuild() {
+    return false
+  }
+  async setMapboxAccessToken(_token: string) {
+    return {ok: false, error: "Not supported on web"}
+  }
+  async jsSpawn(_pkg: string, _polyfill: string, _miniappJs: string) {
+    return false
+  }
+  async jsEvaluate(_pkg: string, _src: string) {
+    return null
+  }
+  async jsKill(_pkg: string) {
+    return
+  }
+  async jsDispatchToJs(_pkg: string, _env: Record<string, unknown>) {
+    return
+  }
+  async jsSetManifest(_pkg: string, _perms: string[]) {
+    return
+  }
+  jsAlivePackages() {
+    return []
+  }
+  async jsDebugForceGC(_pkg: string) {
+    return false
+  }
+  jsLoadPolyfillBundle() {
+    return ""
+  }
+}
+
+export default registerWebModule(CrustModule, "CrustModule")