Revert visionOS changes and provide Copilot instruction improvements

.github/workflows/check-visionos.yml

@@ -0,0 +1,134 @@
+name: Check visionOS
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test-visionos:
+    name: Test Ferric with visionOS Triplets
+    runs-on: macos-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/jod
+      # Install nightly Rust for -Zbuild-std support (required for tier 3 visionOS targets)
+      - name: Install Rust nightly with visionOS source
+        run: |
+          rustup toolchain install nightly --component rust-src
+          rustup default nightly
+      # Set up Xcode and visionOS SDK (required for visionOS compilation)  
+      - name: Setup Xcode and verify visionOS SDK
+        run: |
+          sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer
+          # Verify visionOS SDK is available
+          if xcrun --sdk xros --show-sdk-path; then
+            echo "visionOS SDK found at: $(xcrun --sdk xros --show-sdk-path)"
+          else
+            echo "⚠️  visionOS SDK not found - may need Xcode 15+ with visionOS support"
+          fi
+      # Install required iOS target for the bootstrap process
+      - run: rustup target add aarch64-apple-ios-sim
+      - run: npm ci
+      - run: npm run build
+      # Bootstrap host package to get weak-node-api and ferric-example with visionOS support
+      - run: npm run bootstrap --workspace react-native-node-api
+        env:
+          CMAKE_RN_TRIPLETS: arm64-apple-visionos,arm64-apple-visionos-sim
+      - name: Configure Cargo for visionOS tier 3 targets with build-std
+        run: |
+          # Create cargo config for build-std support (tier 3 visionOS targets)
+          # Per official docs: build-std requires nightly Cargo + rustc + rust-src component
+          mkdir -p packages/ferric-example/.cargo
+          cat > packages/ferric-example/.cargo/config.toml << 'EOF'
+          [unstable]
+          build-std = ["std", "panic_abort"]
+
+          [build]
+          target = ["aarch64-apple-visionos", "aarch64-apple-visionos-sim"]
+
+          [target.aarch64-apple-visionos]
+          linker = "clang"
+
+          [target.aarch64-apple-visionos-sim]
+          linker = "clang"
+          EOF
+
+          # Verify cargo config is properly set
+          echo "Cargo config created:"
+          cat packages/ferric-example/.cargo/config.toml
+      # Test visionOS target availability and setup for build-std
+      - name: Test visionOS Rust targets installation
+        run: |
+          echo "Testing visionOS target availability on macOS..."
+
+          # First, try the standard installation (might work on macOS with proper Xcode)
+          if rustup target add aarch64-apple-visionos aarch64-apple-visionos-sim; then
+            echo "✅ visionOS targets successfully installed via rustup"
+          else
+            echo "⚠️ visionOS targets not available via rustup - this may be expected for tier 3 targets"
+            echo "The build will rely on -Zbuild-std to compile from source"
+
+            # Let's see if we can force the issue by testing direct compilation
+            echo "Testing if rustc can compile for visionOS targets with build-std..."
+
+            # Create a minimal test to see if the targets work with build-std
+            echo 'fn main() { println!("Hello visionOS!"); }' > /tmp/visionos_test.rs
+
+            if rustc -Z build-std=std,panic_abort --target aarch64-apple-visionos /tmp/visionos_test.rs -o /tmp/visionos_test 2>/dev/null; then
+              echo "✅ Direct compilation with build-std works for aarch64-apple-visionos"
+            else
+              echo "❌ Direct compilation failed - may need proper SDK setup"
+            fi
+          fi
+      - name: Verify build-std setup and bootstrap ferric-example
+        run: |
+          # Verify nightly toolchain and components
+          echo "=== Rust Toolchain Info ==="
+          rustc --version
+          cargo --version
+          rustup component list --installed --toolchain nightly
+
+          echo "=== Installed Rust Targets ==="
+          rustup target list --installed --toolchain nightly
+
+          echo "=== Testing visionOS SDK availability ==="
+          xcrun --sdk xros --show-sdk-path || echo "visionOS SDK not available - continuing anyway"
+
+          echo "=== Bootstrapping ferric-example with visionOS targets ==="
+          cd packages/ferric-example
+          ls -la .cargo/ || echo "No .cargo dir found"
+          cat .cargo/config.toml || echo "No config found" 
+          cd ../..
+
+          # Try to bootstrap ferric-example with visionOS targets
+          # If Ferric's target validation fails, we'll try to bypass it or test manually
+          echo "Attempting to bootstrap ferric-example with visionOS targets..."
+          if ! npm run bootstrap --workspace @react-native-node-api/ferric-example; then
+            echo "❌ Bootstrap failed - likely due to Ferric's target validation"
+            echo "This confirms the hypothesis that Ferric's ensureInstalledTargets() prevents build-std usage"
+            echo "Analyzing the specific error to understand if the build would actually work..."
+
+            # Test if we can compile directly with cargo and build-std
+            cd packages/ferric-example
+            echo "Testing direct cargo compilation with build-std..."
+            cargo build --target aarch64-apple-visionos || echo "Direct cargo build also failed"
+            cd ../..
+          else
+            echo "✅ Bootstrap succeeded!"
+          fi
+        env:
+          CMAKE_RN_TRIPLETS: arm64-apple-visionos,arm64-apple-visionos-sim
+          FERRIC_TARGETS: aarch64-apple-visionos,aarch64-apple-visionos-sim
+          # visionOS SDK configuration
+          XROS_DEPLOYMENT_TARGET: "1.0"

packages/ferric/src/cargo.ts

@@ -28,8 +28,8 @@ const APPLE_XCFRAMEWORK_CHILDS_PER_TARGET: Record<AppleTargetName, string> = {
   // "x86_64-apple-ios-macabi": "ios-x86_64-simulator",
   // "aarch64-apple-tvos": "tvos-arm64",
   // "aarch64-apple-tvos-sim": "tvos-arm64-simulator",
-  // "aarch64-apple-visionos": "xros-arm64",
-  // "aarch64-apple-visionos-sim": "xros-arm64-simulator",
+  "aarch64-apple-visionos": "xros-arm64",
+  "aarch64-apple-visionos-sim": "xros-arm64-simulator",
 };
 
 const ANDROID_ARCH_PR_TARGET: Record<AndroidTargetName, string> = {

packages/ferric/src/targets.ts

@@ -26,9 +26,9 @@ export const APPLE_TARGETS = [
   /*
   "aarch64-apple-tvos",
   "aarch64-apple-tvos-sim",
+  */
   "aarch64-apple-visionos",
   "aarch64-apple-visionos-sim",
-  */
 
   // "aarch64-apple-watchos",
   // "aarch64-apple-watchos-sim",
@@ -49,25 +49,68 @@ export type AppleTargetName = (typeof APPLE_TARGETS)[number];
 export const ALL_TARGETS = [...ANDROID_TARGETS, ...APPLE_TARGETS] as const;
 export type TargetName = (typeof ALL_TARGETS)[number];
 
+/**
+ * Tier 3 Rust targets that are not available via `rustup target add` 
+ * and require building the standard library from source using `-Zbuild-std`.
+ * 
+ * @see https://doc.rust-lang.org/rustc/platform-support.html
+ * @see https://doc.rust-lang.org/cargo/reference/unstable.html#build-std
+ */
+export const TIER_3_TARGETS: readonly TargetName[] = [
+  "aarch64-apple-visionos",
+  "aarch64-apple-visionos-sim",
+] as const;
+
+/**
+ * Check if a target is a tier 3 target that requires build-std
+ */
+export function isTier3Target(target: TargetName): boolean {
+  return TIER_3_TARGETS.includes(target);
+}
+
 /**
  * Ensure the targets are installed into the Rust toolchain
  * We do this up-front because the error message and fix is very unclear from the failure when missing.
  */
 export function ensureInstalledTargets(expectedTargets: Set<TargetName>) {
   const installedTargets = getInstalledTargets();
-  const missingTargets = new Set([
-    ...[...expectedTargets].filter((target) => !installedTargets.has(target)),
+  const missingStandardTargets = new Set([
+    ...[...expectedTargets].filter(
+      (target) => !installedTargets.has(target) && !isTier3Target(target),
+    ),
   ]);
-  if (missingTargets.size > 0) {
-    // TODO: Ask the user if they want to run this
+  const tier3Targets = new Set([
+    ...[...expectedTargets].filter((target) => isTier3Target(target)),
+  ]);
+
+  // Handle standard targets that can be installed via rustup
+  if (missingStandardTargets.size > 0) {
     throw new UsageError(
       `You're missing ${
-        missingTargets.size
+        missingStandardTargets.size
       } targets - to fix this, run:\n\n${chalk.italic(
-        `rustup target add ${[...missingTargets].join(" ")}`,
+        `rustup target add ${[...missingStandardTargets].join(" ")}`,
       )}`,
     );
   }
+
+  // Handle tier 3 targets that require build-std setup
+  if (tier3Targets.size > 0) {
+    throw new UsageError(
+      `You're using tier 3 targets (${[...tier3Targets].join(", ")}) that require building the standard library from source.\n\n` +
+        `To set up support for these targets:\n\n` +
+        `1. Install nightly Rust with the rust-src component:\n` +
+        `   ${chalk.italic("rustup toolchain install nightly --component rust-src")}\n\n` +
+        `2. Configure Cargo to use build-std by creating a .cargo/config.toml file:\n` +
+        `   ${chalk.italic("[unstable]")}\n` +
+        `   ${chalk.italic('build-std = ["std", "panic_abort"]')}\n\n` +
+        `3. Set your default toolchain to nightly:\n` +
+        `   ${chalk.italic("rustup default nightly")}\n\n` +
+        `For more information, see:\n` +
+        `- Rust Platform Support: ${chalk.italic("https://doc.rust-lang.org/rustc/platform-support.html")}\n` +
+        `- Cargo build-std: ${chalk.italic("https://doc.rust-lang.org/cargo/reference/unstable.html#build-std")}`,
+    );
+  }
 }
 
 export function isAndroidTarget(