@mentra/crust 3.2.0-dev.137 → 3.2.0-dev.154

package/ios/Crust.podspec

@@ -24,7 +24,7 @@ Pod::Spec.new do |s|
   # CocoaPods dependency — Mapbox Nav v3 dropped reliable CocoaPods support, so
   # `pod install` cannot resolve 'MapboxNavigationCore' ("Unable to find a
   # specification"). The SPM package is wired into the Xcode project by
-  # mobile/plugins/mapbox-nav-ios.ts at prebuild, and its MapboxMaps dependency
+  # @mentra/crust/plugin/src/withMapboxNavIos.ts at prebuild, and its MapboxMaps dependency
   # + Downloads-token auth come from the @rnmapbox/maps config plugin. So there
   # is intentionally NO `s.dependency 'MapboxNavigationCore'` here.
 
@@ -34,7 +34,7 @@ Pod::Spec.new do |s|
   # Swift/Objective-C compatibility + Mapbox SPM module visibility.
   #
   # MapboxNavigationCore / MapboxMaps / MapboxDirections are linked into the
-  # Crust target as Swift Package products (see plugins/mapbox-nav-crust-link.ts).
+  # Crust target as Swift Package products (see plugin/src/withMapboxNavCrustLink.ts).
   # MapboxDirections builds as a STATIC LIBRARY, so SPM emits it as a bare
   # `MapboxDirections.swiftmodule` in the build-products dir rather than a
   # `.framework`. For `import MapboxDirections` to resolve from this CocoaPods

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/crust",
-  "version": "3.2.0-dev.137",
+  "version": "3.2.0-dev.154",
   "description": "Mentra Native Module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -35,10 +35,11 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/Mentra-Community/MentraOS/tree/dev/mobile/modules/crust#readme",
   "dependencies": {
-    "@mentra/jspolyfill": "3.2.0-dev.137"
+    "@mentra/jspolyfill": "3.2.0-dev.154"
   },
   "devDependencies": {
     "@expo/config-plugins": ">=8.0.0",
+    "@types/node": "^25.9.3",
     "expo-module-scripts": "^55.0.2",
     "typescript": "~5.9.2"
   },

package/plugin/build/index.d.ts

@@ -1,6 +1,6 @@
 import { type ConfigPlugin } from "expo/config-plugins";
 /**
- * @mentra/crust config plugin — the module's own Android build contract, so
+ * @mentra/crust config plugin — the module's native build contract, so
  * every host that embeds crust (the Mentra app, the example OEM app, real OEM
  * hosts) inherits it by listing "@mentra/crust" in `app.json` plugins instead
  * of hand-mirroring gradle edits:
@@ -16,6 +16,7 @@ import { type ConfigPlugin } from "expo/config-plugins";
  *   apps — the Nav SDK uses newer core libs)
  * - 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
  */
 declare const withCrust: ConfigPlugin;
 export default withCrust;

package/plugin/build/index.js

@@ -1,8 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const withAndroid_1 = require("./withAndroid");
+const withMapboxNavCrustLink_1 = __importDefault(require("./withMapboxNavCrustLink"));
+const withMapboxNavIos_1 = __importDefault(require("./withMapboxNavIos"));
 /**
- * @mentra/crust config plugin — the module's own Android build contract, so
+ * @mentra/crust config plugin — the module's native build contract, so
  * every host that embeds crust (the Mentra app, the example OEM app, real OEM
  * hosts) inherits it by listing "@mentra/crust" in `app.json` plugins instead
  * of hand-mirroring gradle edits:
@@ -18,8 +23,9 @@ const withAndroid_1 = require("./withAndroid");
  *   apps — the Nav SDK uses newer core libs)
  * - 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
  */
 const withCrust = (config) => {
-    return (0, withAndroid_1.withCrustAndroidBuildContract)(config);
+    return (0, withMapboxNavCrustLink_1.default)((0, withMapboxNavIos_1.default)((0, withAndroid_1.withCrustAndroidBuildContract)(config)));
 };
 exports.default = withCrust;

package/plugin/build/withMapboxNavCrustLink.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from "expo/config-plugins";
+declare const withMapboxNavCrustLink: ConfigPlugin;
+export default withMapboxNavCrustLink;

package/plugin/build/withMapboxNavCrustLink.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_plugins_1 = require("expo/config-plugins");
+/**
+ * Expo Config Plugin — make the Mapbox Navigation SPM modules importable from
+ * the `Crust` CocoaPods target WITHOUT statically linking them into libCrust.a,
+ * AND guarantee they are built BEFORE Crust compiles.
+ *
+ * The problem: `Crust` is a CocoaPods static-library target (in Pods.xcodeproj),
+ * and the Mapbox SPM products (MapboxNavigationCore / MapboxDirections /
+ * MapboxMaps) are added to the APP target in the app project (withMapboxNavIos.ts).
+ * Crust's Swift needs to `import MapboxNavigationCore` etc.
+ *
+ * IMPORTANT — why we do NOT add package_product_dependencies to Crust:
+ * adding an XCSwiftPackageProductDependency to a *static library* target makes
+ * Xcode bake that product's object code straight into `libCrust.a`. The app
+ * target then links `libCrust.a` (Mapbox baked in) AND the same SPM products
+ * again → "duplicate symbol" link errors for every Mapbox symbol. (Confirmed:
+ * MapboxNavigationCore / MapboxDirections / MapboxMaps all build as STATIC
+ * swiftmodules + .o, not dynamic frameworks, so the collision is real.) A static
+ * library does not need its external symbols resolved at archive time; it only
+ * needs the modules to be VISIBLE at compile time so `import` typechecks. That
+ * visibility is provided entirely by the search paths in Crust.podspec
+ * (SWIFT_INCLUDE_PATHS / FRAMEWORK_SEARCH_PATHS / OTHER_SWIFT_FLAGS -I pointing
+ * at ${PODS_CONFIGURATION_BUILD_DIR}, where SPM drops the .swiftmodule /
+ * .framework). The actual Mapbox object code is linked exactly once, by the app
+ * target.
+ *
+ * THE BUILD-ORDER RACE (why a previous version of this plugin was insufficient):
+ * a clean `xcodebuild archive` builds targets in parallel against a fresh
+ * ArchiveIntermediates dir. Crust only sees the Mapbox swiftmodules via search
+ * paths into the shared build-products dir — but NOTHING forced those modules to
+ * exist there before Crust compiled. The app target's own SPM product deps make
+ * Xcode emit them, but that emission is NOT ordered relative to Crust (a target
+ * in a *different* project). In practice MapboxNavigationCore.swiftmodule lands
+ * in the products dir AFTER Crust compiles → `error: no such module
+ * 'MapboxNavigationCore'` → ARCHIVE FAILED (exit 65), DETERMINISTICALLY on a
+ * clean build. The release-ios.mjs archive-retry can't recover it: every fresh
+ * clean archive re-races identically and the failed partial build never copies
+ * NavigationCore's swiftmodule into the products dir for the next attempt.
+ *
+ * THE FIX — a build-order-only target dependency:
+ *   1. Create a tiny throwaway static-library "host" target (MapboxNavOrder) in
+ *      Pods.xcodeproj that carries the Mapbox SPM product dependencies. Building
+ *      it forces SPM to emit MapboxNavigationCore/Directions/Maps.swiftmodule
+ *      into the shared build-products dir. Its own libMapboxNavOrder.a is never
+ *      linked by anyone, so the Mapbox objects baked into it are harmless (no
+ *      duplicate symbols — the app still links Mapbox exactly once via its own
+ *      SPM deps).
+ *   2. Add a PBXTargetDependency from Crust → MapboxNavOrder. This is a pure
+ *      BUILD-ORDER edge (not a link dep), so Xcode schedules the host (and thus
+ *      the Mapbox swiftmodules) before Crust compiles. Verified: a clean archive
+ *      now logs "Explicit dependency on target 'MapboxNavOrder'" and succeeds on
+ *      the first try with no missing-module error.
+ *   3. SCRUB any stale Mapbox package_product_dependencies that an older version
+ *      of this plugin (or a manual edit) may have added directly to Crust, which
+ *      would re-introduce the duplicate-symbol error.
+ *
+ * Runs as a Podfile post_install hook (not a file patch) so it executes AFTER
+ * `pod install` has generated Pods.xcodeproj with the Crust target.
+ */
+const MARKER_BEGIN = "# @generated begin mapbox-nav-crust-link";
+const MARKER_END = "# @generated end mapbox-nav-crust-link";
+const PRODUCTS = ["MapboxNavigationCore", "MapboxDirections", "MapboxMaps"];
+const CRUST_TARGET = "Crust";
+const HOST_TARGET = "MapboxNavOrder";
+// Must match the repo + version pinned in plugin/src/withMapboxNavIos.ts so the host
+// target resolves the SAME package the app target uses (one Mapbox provider).
+const NAV_REPO = "https://github.com/mapbox/mapbox-navigation-ios.git";
+const NAV_MIN_VERSION = "3.0.0";
+function crustLinkRuby() {
+    const rubyList = PRODUCTS.map((p) => `'${p}'`).join(", ");
+    return [
+        `    ${MARKER_BEGIN} (DO NOT MODIFY — plugin/src/withMapboxNavCrustLink.ts)`,
+        `    # Guarantee the Mapbox SPM swiftmodules are built BEFORE Crust compiles,`,
+        `    # without linking them into libCrust.a (which would duplicate-symbol against`,
+        `    # the app target's own copy). See plugin/src/withMapboxNavCrustLink.ts header.`,
+        `    __mb_products  = [${rubyList}]`,
+        `    __mb_host_name = '${HOST_TARGET}'`,
+        `    __mb_repo      = '${NAV_REPO}'`,
+        `    __mb_min_ver   = '${NAV_MIN_VERSION}'`,
+        `    __mb_proj      = installer.pods_project`,
+        `    __mb_crust     = __mb_proj.targets.find { |t| t.name == '${CRUST_TARGET}' }`,
+        `    if __mb_crust.nil?`,
+        `      Pod::UI.warn "[mapbox-nav-crust-link] ${CRUST_TARGET} target not found — skipping"`,
+        `    else`,
+        `      # CocoaPods stabilizes target UUIDs before post_install, resetting its`,
+        `      # sequential allocator bookkeeping. Adding this host can then reuse`,
+        `      # existing IDs, including rootObject. Use Xcodeproj's collision-checked`,
+        `      # allocator for any new objects in this project after that reset.`,
+        `      def __mb_proj.generate_available_uuid_list(count = 100)`,
+        `        Xcodeproj::Project.instance_method(:generate_available_uuid_list).bind(self).call(count)`,
+        `      end`,
+        ``,
+        `      # 1) SCRUB any stale Mapbox link-deps from Crust (duplicate-symbol guard).`,
+        `      __removed = __mb_crust.package_product_dependencies.select { |d| __mb_products.include?(d.product_name) }`,
+        `      unless __removed.empty?`,
+        `        __mb_crust.package_product_dependencies.reject! { |d| __mb_products.include?(d.product_name) }`,
+        `        Pod::UI.puts "[mapbox-nav-crust-link] removed stale Mapbox link-deps from ${CRUST_TARGET}: #{__removed.map(&:product_name).join(', ')}"`,
+        `      end`,
+        ``,
+        `      # 2) Ensure a remote SPM package reference for the Nav repo exists in the`,
+        `      #    Pods project (the host target's product deps point at it).`,
+        `      __mb_pkg = __mb_proj.root_object.package_references.find { |r| (r.repositoryURL rescue nil) == __mb_repo }`,
+        `      unless __mb_pkg`,
+        `        __mb_pkg = __mb_proj.new(Xcodeproj::Project::Object::XCRemoteSwiftPackageReference)`,
+        `        __mb_pkg.repositoryURL = __mb_repo`,
+        `        __mb_pkg.requirement = { 'kind' => 'upToNextMajorVersion', 'minimumVersion' => __mb_min_ver }`,
+        `        __mb_proj.root_object.package_references << __mb_pkg`,
+        `      end`,
+        ``,
+        `      # 3) (Re)create the throwaway host static-lib target carrying the Mapbox`,
+        `      #    SPM product deps. Building it emits the swiftmodules into the shared`,
+        `      #    products dir; its .a is never linked, so no duplicate symbols.`,
+        `      __mb_crust.dependencies.reject! { |d| d.target&.name == __mb_host_name }`,
+        `      __mb_proj.targets.reject! { |t| t.name == __mb_host_name }`,
+        `      __mb_host = __mb_proj.new_target(:static_library, __mb_host_name, :ios, '15.1')`,
+        `      __mb_products.each do |p|`,
+        `        __mb_dep = __mb_proj.new(Xcodeproj::Project::Object::XCSwiftPackageProductDependency)`,
+        `        __mb_dep.package = __mb_pkg`,
+        `        __mb_dep.product_name = p`,
+        `        __mb_host.package_product_dependencies << __mb_dep`,
+        `      end`,
+        ``,
+        `      # 4) Build-order edge: Crust depends on the host (NOT a link dep).`,
+        `      __mb_crust.add_dependency(__mb_host)`,
+        `      __mb_proj.save`,
+        `      Pod::UI.puts "[mapbox-nav-crust-link] ${CRUST_TARGET} now build-order-depends on #{__mb_host_name} (#{__mb_products.join(', ')})"`,
+        `    end`,
+        `    ${MARKER_END}`,
+    ].join("\n");
+}
+const withMapboxNavCrustLink = (config) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        "ios",
+        async (cfg) => {
+            const podfilePath = path_1.default.join(cfg.modRequest.platformProjectRoot, "Podfile");
+            if (!fs_1.default.existsSync(podfilePath)) {
+                throw new Error(`[mapbox-nav-crust-link] Podfile not found at ${podfilePath}`);
+            }
+            let contents = fs_1.default.readFileSync(podfilePath, "utf8");
+            if (contents.includes(MARKER_BEGIN)) {
+                const re = new RegExp(`\\n? *${MARKER_BEGIN}[\\s\\S]*?${MARKER_END}\\n?`, "g");
+                contents = contents.replace(re, "\n");
+            }
+            const anchor = /post_install do \|installer\|\n/;
+            if (!anchor.test(contents)) {
+                throw new Error(`[mapbox-nav-crust-link] no 'post_install do |installer|' in Podfile`);
+            }
+            contents = contents.replace(anchor, (m) => `${m}${crustLinkRuby()}\n`);
+            fs_1.default.writeFileSync(podfilePath, contents, "utf8");
+            // eslint-disable-next-line no-console
+            console.log("[mapbox-nav-crust-link] injected post_install hook (build-order host target + link-dep scrub)");
+            return cfg;
+        },
+    ]);
+};
+exports.default = withMapboxNavCrustLink;

package/plugin/build/withMapboxNavIos.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from "expo/config-plugins";
+declare const withMapboxNavIos: ConfigPlugin;
+export default withMapboxNavIos;

package/plugin/build/withMapboxNavIos.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_plugins_1 = require("expo/config-plugins");
+/**
+ * Expo Config Plugin — add the Mapbox Navigation SDK for iOS (v3) as a Swift
+ * Package to the generated Xcode project so the `crust` native module can
+ * `import MapboxNavigationCore`.
+ *
+ * Why a Swift Package and not CocoaPods: Mapbox Navigation v3 dropped reliable
+ * CocoaPods support — `pod install` cannot resolve `MapboxNavigationCore`
+ * (that's the "Unable to find a specification" error). v3 is SPM-first, so we
+ * add it via SPM here, including its MapboxMaps dependency, and link the
+ * products to the app target. The host supplies Downloads-token authentication.
+ *
+ * Implementation: a dangerous mod that drives the `xcodeproj` Ruby gem (always
+ * present on a Mac with CocoaPods) to add the remote SPM package + product.
+ * The legacy JS `xcode` pbxproj lib predates SPM and can't express package
+ * references, so Ruby is the reliable path.
+ *
+ * Requirements at build time:
+ *   • ~/.netrc with `machine api.mapbox.com / login mapbox / password sk.…`
+ *     (the secret Downloads:Read token) so SPM can fetch the binaries.
+ *   • Use SPM as the single Mapbox provider; do not also install MapboxMaps
+ *     through CocoaPods.
+ */
+// Mapbox Navigation v3 resolves the matching MapboxMaps dependency through SPM.
+const NAV_REPO = "https://github.com/mapbox/mapbox-navigation-ios.git";
+const NAV_MIN_VERSION = "3.0.0";
+// Products to link into the app target:
+//   • MapboxNavigationCore — the headless engine the crust module imports.
+//   • MapboxDirections      — Waypoint / RouteStep / ManeuverType / etc.
+//                             (NavigationManager.swift + NavPayloads.swift use these).
+//   • MapboxMaps            — peer Maps SDK / runtime-token consumer.
+// Linking all three from the SAME package makes SPM the single Mapbox provider
+// for the whole app.
+const NAV_PRODUCTS = ["MapboxNavigationCore", "MapboxDirections", "MapboxMaps"];
+/**
+ * Find CocoaPods' private GEM_HOME (which contains the `xcodeproj` gem) by
+ * reading it out of the `pod` launcher wrapper. Homebrew's `pod` is a bash
+ * shim that does `GEM_HOME="…/libexec" exec "…/bin/pod"`. We grep that path so
+ * our Ruby invocation can `require 'xcodeproj'` using the same gems CocoaPods
+ * uses. Returns {} when it can't be determined (caller falls back to bare ruby).
+ */
+function cocoapodsGemEnv() {
+    try {
+        const podPath = (0, child_process_1.execSync)("command -v pod", { encoding: "utf8" }).trim();
+        if (!podPath || !fs_1.default.existsSync(podPath))
+            return {};
+        const contents = fs_1.default.readFileSync(podPath, "utf8");
+        const m = contents.match(/GEM_HOME=["']?([^"'\s]+)["']?/);
+        if (m?.[1])
+            return { GEM_HOME: m[1] };
+    }
+    catch {
+        /* ignore — fall back to bare ruby */
+    }
+    return {};
+}
+const withMapboxNavIos = (config) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        "ios",
+        async (cfg) => {
+            const iosRoot = cfg.modRequest.platformProjectRoot; // .../ios
+            const projName = cfg.modRequest.projectName; // e.g. "Mentra"
+            const pbxproj = path_1.default.join(iosRoot, `${projName}.xcodeproj`, "project.pbxproj");
+            if (!fs_1.default.existsSync(pbxproj)) {
+                throw new Error(`[mapbox-nav-ios] project.pbxproj not found at ${pbxproj}`);
+            }
+            // Ruby script: idempotently add the SPM remote package + product, and
+            // link the product to the FIRST application target (the app, not the
+            // test/extension targets).
+            //
+            // Written to a TEMP FILE and run as `ruby <file>` rather than inlined via
+            // `ruby -e "..."` — inlining a multi-line script through the shell mangles
+            // the newlines into literal backslash-n and Ruby errors with
+            // "unexpected backslash". Config values are injected as JSON literals so
+            // there's no string-escaping ambiguity.
+            const ruby = [
+                `require 'xcodeproj'`,
+                `proj = Xcodeproj::Project.open(${JSON.stringify(`${projName}.xcodeproj`)})`,
+                `target = proj.targets.find { |t| t.product_type == 'com.apple.product-type.application' }`,
+                `abort('[mapbox-nav-ios] no application target found') unless target`,
+                ``,
+                `repo = ${JSON.stringify(NAV_REPO)}`,
+                `products = ${JSON.stringify(NAV_PRODUCTS)}`,
+                `min_version = ${JSON.stringify(NAV_MIN_VERSION)}`,
+                ``,
+                `# Reuse an existing package reference for this repo if present (idempotent).`,
+                `pkg = proj.root_object.package_references.find { |r| r.respond_to?(:repositoryURL) && r.repositoryURL == repo }`,
+                `unless pkg`,
+                `  pkg = proj.new(Xcodeproj::Project::Object::XCRemoteSwiftPackageReference)`,
+                `  pkg.repositoryURL = repo`,
+                `  pkg.requirement = { 'kind' => 'upToNextMajorVersion', 'minimumVersion' => min_version }`,
+                `  proj.root_object.package_references << pkg`,
+                `end`,
+                ``,
+                `# Link each product to the target if not already linked.`,
+                `products.each do |product|`,
+                `  already = target.package_product_dependencies.any? { |d| d.product_name == product }`,
+                `  next if already`,
+                `  dep = proj.new(Xcodeproj::Project::Object::XCSwiftPackageProductDependency)`,
+                `  dep.package = pkg`,
+                `  dep.product_name = product`,
+                `  target.package_product_dependencies << dep`,
+                `end`,
+                ``,
+                `proj.save`,
+                `puts "[mapbox-nav-ios] ensured #{products.join(', ')} (>= #{min_version}) from #{repo}"`,
+            ].join("\n");
+            const scriptPath = path_1.default.join(iosRoot, ".mapbox-nav-ios-spm.rb");
+            try {
+                fs_1.default.writeFileSync(scriptPath, ruby, "utf8");
+                // The `xcodeproj` gem isn't in the system Ruby — it ships INSIDE
+                // CocoaPods' private GEM_HOME. Reuse CocoaPods' own environment so the
+                // require works regardless of which Ruby the user has on PATH. We read
+                // GEM_HOME out of the `pod` launcher wrapper (it sets it before exec),
+                // falling back to a bare `ruby` (which works if the user happens to
+                // have xcodeproj installed globally).
+                const env = { ...process.env, ...cocoapodsGemEnv() };
+                (0, child_process_1.execSync)(`ruby ${JSON.stringify(scriptPath)}`, {
+                    cwd: iosRoot,
+                    stdio: "inherit",
+                    env,
+                });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                throw new Error(`[mapbox-nav-ios] failed to add the Mapbox Navigation SPM package. ` +
+                    `Ensure the 'xcodeproj' Ruby gem is available (it ships with CocoaPods). ` +
+                    `Underlying error: ${msg}`);
+            }
+            finally {
+                // Clean up the temp script so it doesn't linger in the generated ios/.
+                try {
+                    fs_1.default.unlinkSync(scriptPath);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            return cfg;
+        },
+    ]);
+};
+exports.default = withMapboxNavIos;