@reactvision/react-viro 2.54.0 → 2.55.0

package/dist/components/ViroVRSceneNavigator.d.ts

@@ -11,7 +11,7 @@
  */
 import * as React from "react";
 import { NativeSyntheticEvent, ViewProps } from "react-native";
-import { ViroExitViroEvent } from "./Types/ViroEvents";
+import { ViroExitViroEvent, ViroHandUpdateEvent } from "./Types/ViroEvents";
 import { Viro3DPoint, ViroNativeRef, ViroScene, ViroSceneDictionary } from "./Types/ViroUtils";
 type State = {
     sceneDictionary: ViroSceneDictionary;
@@ -54,9 +54,23 @@ type Props = ViewProps & {
     bloomEnabled?: boolean;
     shadowsEnabled?: boolean;
     multisamplingEnabled?: boolean;
+    /** Enable XR_FB_passthrough mixed-reality camera feed (Quest 3 / Quest Pro). */
+    passthroughEnabled?: boolean;
+    /**
+     * Enable skeletal hand tracking (Quest — requires com.oculus.permission.HAND_TRACKING in manifest).
+     * Pinch and grab gestures fire the same onClick/onDrag events as controller buttons.
+     */
+    handTrackingEnabled?: boolean;
+    /**
+     * Per-frame skeletal hand joint data. Fires at display refresh rate (72/90 Hz).
+     * null for a hand means it is not currently tracked.
+     */
+    onHandUpdate?: (event: NativeSyntheticEvent<ViroHandUpdateEvent>) => void;
 };
 /**
  * ViroVRSceneNavigator is used to transition between multiple scenes.
+ * Intended for OVR / Google Cardboard VR mode on non-Quest Android devices.
+ * On Meta Quest use ViroXRSceneNavigator instead.
  */
 export declare class ViroVRSceneNavigator extends React.Component<Props, State> {
     _component: ViroNativeRef;
@@ -64,7 +78,7 @@ export declare class ViroVRSceneNavigator extends React.Component<Props, State>
      * Called from native when either the user physically decides to exit vr (hits
      * the "X" buton).
      */
-    _onExitViro(_event: NativeSyntheticEvent<ViroExitViroEvent>): void;
+    _onExitViro: (_event: NativeSyntheticEvent<ViroExitViroEvent>) => void;
     constructor(props: Props);
     getRandomTag(): string;
     /**
@@ -81,7 +95,7 @@ export declare class ViroVRSceneNavigator extends React.Component<Props, State>
      *
      * @todo: use Typescript function overloading rather than this inaccurate solution
      */
-    push(param1?: ViroScene | string, param2?: ViroScene): void;
+    push: (param1?: ViroScene | string, param2?: ViroScene) => void;
     /**
      * Replace the top scene in the stack with the given scene. The remainder of the back
      * history is kept in the same order as before.
@@ -93,7 +107,7 @@ export declare class ViroVRSceneNavigator extends React.Component<Props, State>
      *
      * @todo: use Typescript function overloading rather than this inaccurate solution
      */
-    replace(param1?: ViroScene | string, param2?: ViroScene): void;
+    replace: (param1?: ViroScene | string, param2?: ViroScene) => void;
     /**
      * Jumps to a given scene that had been previously pushed. If the scene was not pushed, we
      * then push and jump to it. The back history is re-ordered such that jumped to scenes are
@@ -106,9 +120,9 @@ export declare class ViroVRSceneNavigator extends React.Component<Props, State>
      *
      * @todo: use Typescript function overloading rather than this inaccurate solution
      */
-    jump(param1?: ViroScene | string, param2?: ViroScene): void;
-    pop(): void;
-    popN(n: number): void;
+    jump: (param1?: ViroScene | string, param2?: ViroScene) => void;
+    pop: () => void;
+    popN: (n: number) => void;
     /**
      * Increments the reference count for a scene within sceneDictionary that is
      * mapped to the given sceneKey. If no scenes are found / mapped, we create
@@ -136,9 +150,9 @@ export declare class ViroVRSceneNavigator extends React.Component<Props, State>
     reorderHistory(sceneKey: string): void;
     popHistoryByN(n: number): void;
     getSceneIndex(sceneTag: string): number;
-    _recenterTracking(): void;
-    _project(point: Viro3DPoint): Promise<any>;
-    _unproject(point: Viro3DPoint): Promise<any>;
+    _recenterTracking: () => void;
+    _project: (point: Viro3DPoint) => Promise<any>;
+    _unproject: (point: Viro3DPoint) => Promise<any>;
     _renderSceneStackItems(): React.JSX.Element[];
     sceneNavigator: {
         push: (param1?: ViroScene | string, param2?: ViroScene) => void;

package/dist/components/ViroVRSceneNavigator.js

@@ -48,9 +48,12 @@ exports.ViroVRSceneNavigator = void 0;
 const React = __importStar(require("react"));
 const react_native_1 = require("react-native");
 const ViroSceneNavigatorModule = react_native_1.NativeModules.VRTSceneNavigatorModule;
+const VRModuleOpenXR = react_native_1.NativeModules.VRModuleOpenXR;
 var mathRandomOffset = 0;
 /**
  * ViroVRSceneNavigator is used to transition between multiple scenes.
+ * Intended for OVR / Google Cardboard VR mode on non-Quest Android devices.
+ * On Meta Quest use ViroXRSceneNavigator instead.
  */
 class ViroVRSceneNavigator extends React.Component {
     _component = null;
@@ -58,9 +61,9 @@ class ViroVRSceneNavigator extends React.Component {
      * Called from native when either the user physically decides to exit vr (hits
      * the "X" buton).
      */
-    _onExitViro(_event) {
+    _onExitViro = (_event) => {
         this.props.onExitViro && this.props.onExitViro();
-    }
+    };
     constructor(props) {
         super(props);
         let initialSceneTag = props.initialSceneKey;
@@ -99,7 +102,7 @@ class ViroVRSceneNavigator extends React.Component {
      *
      * @todo: use Typescript function overloading rather than this inaccurate solution
      */
-    push(param1, param2) {
+    push = (param1, param2) => {
         var sceneKey = undefined;
         var scene = undefined;
         if (typeof param1 == "string") {
@@ -125,7 +128,7 @@ class ViroVRSceneNavigator extends React.Component {
         }
         this.incrementSceneReference(scene, sceneKey, false);
         this.addToHistory(sceneKey);
-    }
+    };
     /**
      * Replace the top scene in the stack with the given scene. The remainder of the back
      * history is kept in the same order as before.
@@ -137,7 +140,7 @@ class ViroVRSceneNavigator extends React.Component {
      *
      * @todo: use Typescript function overloading rather than this inaccurate solution
      */
-    replace(param1, param2) {
+    replace = (param1, param2) => {
         var sceneKey = undefined;
         var scene = undefined;
         if (typeof param1 == "string") {
@@ -167,7 +170,7 @@ class ViroVRSceneNavigator extends React.Component {
         this.popHistoryByN(1);
         this.incrementSceneReference(scene, sceneKey, false);
         this.addToHistory(sceneKey);
-    }
+    };
     /**
      * Jumps to a given scene that had been previously pushed. If the scene was not pushed, we
      * then push and jump to it. The back history is re-ordered such that jumped to scenes are
@@ -180,7 +183,7 @@ class ViroVRSceneNavigator extends React.Component {
      *
      * @todo: use Typescript function overloading rather than this inaccurate solution
      */
-    jump(param1, param2) {
+    jump = (param1, param2) => {
         var sceneKey = undefined;
         var scene = undefined;
         if (typeof param1 == "string") {
@@ -206,11 +209,11 @@ class ViroVRSceneNavigator extends React.Component {
         }
         this.incrementSceneReference(scene, sceneKey, true);
         this.reorderHistory(sceneKey);
-    }
-    pop() {
+    };
+    pop = () => {
         this.popN(1);
-    }
-    popN(n) {
+    };
+    popN = (n) => {
         if (n === 0) {
             return;
         }
@@ -220,7 +223,7 @@ class ViroVRSceneNavigator extends React.Component {
         }
         this.decrementReferenceForLastNScenes(n);
         this.popHistoryByN(n);
-    }
+    };
     /**
      * Increments the reference count for a scene within sceneDictionary that is
      * mapped to the given sceneKey. If no scenes are found / mapped, we create
@@ -335,15 +338,15 @@ class ViroVRSceneNavigator extends React.Component {
         // Unable to find the given sceneTag, return -1
         return -1;
     }
-    _recenterTracking() {
+    _recenterTracking = () => {
         ViroSceneNavigatorModule.recenterTracking((0, react_native_1.findNodeHandle)(this));
-    }
-    async _project(point) {
+    };
+    _project = async (point) => {
         return await ViroSceneNavigatorModule.project((0, react_native_1.findNodeHandle)(this), point);
-    }
-    async _unproject(point) {
+    };
+    _unproject = async (point) => {
         return await ViroSceneNavigatorModule.unproject((0, react_native_1.findNodeHandle)(this), point);
-    }
+    };
     _renderSceneStackItems() {
         let views = [];
         var i = 0;

package/dist/components/ViroXRSceneNavigator.d.ts

@@ -0,0 +1,54 @@
+import * as React from "react";
+import { ViewProps } from "react-native";
+type SceneFactory = {
+    scene: () => React.JSX.Element;
+};
+/**
+ * Cross-reality scene navigator. Picks the right underlying navigator at runtime:
+ *
+ *  - **iOS / non-Quest Android** → `ViroARSceneNavigator` (rendered inline)
+ *  - **Meta Quest** → launches VRActivity via `VRLauncher.launchVRScene()` and
+ *    forwards all navigator operations (push/pop/etc.) to the
+ *    `ViroVRSceneNavigator` running there via `VRQuestNavigatorBridge`.
+ *    Render output is null — VRActivity owns the display.
+ *
+ * Pass `arInitialScene` / `vrInitialScene` when the AR and VR scenes differ.
+ * When only `initialScene` is provided it is used for both modes.
+ *
+ * Renderer flags (`hdrEnabled`, `pbrEnabled`, `bloomEnabled`, `shadowsEnabled`,
+ * `passthroughEnabled`, etc.) are forwarded to ViroVRSceneNavigator on Quest
+ * via the intent bridge.
+ */
+export declare const ViroXRSceneNavigator: React.ForwardRefExoticComponent<ViewProps & {
+    /**
+     * Scene used on both AR and VR platforms when no platform-specific scene is provided.
+     * Most apps want a different scene per platform — pass `arInitialScene` and
+     * `vrInitialScene` instead in that case.
+     */
+    initialScene?: SceneFactory;
+    /** Scene mounted on iOS / non-Quest Android (rendered via ViroARSceneNavigator). */
+    arInitialScene?: SceneFactory;
+    /**
+     * Scene mounted on Meta Quest (rendered via ViroVRSceneNavigator in VRActivity).
+     * On Quest, this scene is forwarded to VRActivity via VRQuestNavigatorBridge
+     * rather than rendered inline, because OpenXR exclusive display requires the
+     * VR intent category on the host Activity.
+     */
+    vrInitialScene?: SceneFactory;
+    worldAlignment?: "Gravity" | "GravityAndHeading" | "Camera";
+    autofocus?: boolean;
+    videoQuality?: "High" | "Low";
+    numberOfTrackedImages?: number;
+    vrModeEnabled?: boolean;
+    passthroughEnabled?: boolean;
+    handTrackingEnabled?: boolean;
+    onExitViro?: () => void;
+    viroAppProps?: any;
+    hdrEnabled?: boolean;
+    pbrEnabled?: boolean;
+    bloomEnabled?: boolean;
+    shadowsEnabled?: boolean;
+    multisamplingEnabled?: boolean;
+    debug?: boolean;
+} & React.RefAttributes<unknown>>;
+export {};

package/dist/components/ViroXRSceneNavigator.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViroXRSceneNavigator = void 0;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const ViroARSceneNavigator_1 = require("./AR/ViroARSceneNavigator");
+const ViroPlatform_1 = require("./Utilities/ViroPlatform");
+const VRQuestNavigatorBridge_1 = require("./Utilities/VRQuestNavigatorBridge");
+const VRLauncher = react_native_1.NativeModules.VRLauncher;
+// Quest VR requires a lifecycle-correct VRActivity that drives
+// ReactHostImpl.onHostResume(VRActivity) on entry. The skipActivityIdentity
+// AssertionOnHostPause feature flag (used to suppress the racy MainActivity.
+// onPause assertion when currentActivity has been promoted to VR) is only
+// honored on RN >= 0.83. Without it, MainActivity.onPause hard-crashes via
+// Assertions.assertCondition, so the entire VR path requires RN 0.83+.
+// AR continues to work on RN >= 0.81 (Expo 54+) — only the Quest VR launch
+// is gated.
+const MIN_RN_FOR_VR = { major: 0, minor: 83 };
+function checkRNVersionForVR() {
+    let version = "unknown";
+    try {
+        version = require("react-native/package.json").version;
+        const [maj, min] = version.split(".").map((n) => parseInt(n, 10));
+        if (Number.isFinite(maj) &&
+            Number.isFinite(min) &&
+            (maj > MIN_RN_FOR_VR.major ||
+                (maj === MIN_RN_FOR_VR.major && min >= MIN_RN_FOR_VR.minor))) {
+            return;
+        }
+    }
+    catch {
+        // fall through to throw with version="unknown"
+    }
+    throw new Error(`[Viro] Meta Quest VR requires React Native >= ${MIN_RN_FOR_VR.major}.${MIN_RN_FOR_VR.minor} ` +
+        `(Expo SDK >= 55). Detected: ${version}. ` +
+        `AR features still work on this version — only ViroXRSceneNavigator's VR path on Quest is gated.`);
+}
+/**
+ * Cross-reality scene navigator. Picks the right underlying navigator at runtime:
+ *
+ *  - **iOS / non-Quest Android** → `ViroARSceneNavigator` (rendered inline)
+ *  - **Meta Quest** → launches VRActivity via `VRLauncher.launchVRScene()` and
+ *    forwards all navigator operations (push/pop/etc.) to the
+ *    `ViroVRSceneNavigator` running there via `VRQuestNavigatorBridge`.
+ *    Render output is null — VRActivity owns the display.
+ *
+ * Pass `arInitialScene` / `vrInitialScene` when the AR and VR scenes differ.
+ * When only `initialScene` is provided it is used for both modes.
+ *
+ * Renderer flags (`hdrEnabled`, `pbrEnabled`, `bloomEnabled`, `shadowsEnabled`,
+ * `passthroughEnabled`, etc.) are forwarded to ViroVRSceneNavigator on Quest
+ * via the intent bridge.
+ */
+exports.ViroXRSceneNavigator = React.forwardRef(function ViroXRSceneNavigator(props, ref) {
+    const { initialScene, arInitialScene, vrInitialScene, 
+    // VR-only renderer config — forwarded via bridge on Quest
+    hdrEnabled, pbrEnabled, bloomEnabled, shadowsEnabled, multisamplingEnabled, vrModeEnabled, passthroughEnabled, handTrackingEnabled, onExitViro, debug, ...rest } = props;
+    // Inner ref used on the AR path to capture the ViroARSceneNavigator instance.
+    const arRef = React.useRef(null);
+    // Expose navigator interface on the ref.
+    // Quest: proxy push/pop/etc. through VRQuestNavigatorBridge to VRActivity.
+    // AR:    expose the underlying ViroARSceneNavigator instance directly.
+    React.useImperativeHandle(ref, () => {
+        if (ViroPlatform_1.isQuest) {
+            const bridgeNav = {
+                push: (scene) => VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.dispatchOp({ type: "push", scene }),
+                replace: (scene) => VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.dispatchOp({ type: "replace", scene }),
+                jump: (scene) => VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.dispatchOp({ type: "jump", scene }),
+                pop: () => VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.dispatchOp({ type: "pop" }),
+                popN: (n) => VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.dispatchOp({ type: "popN", n }),
+            };
+            return { sceneNavigator: bridgeNav, arSceneNavigator: bridgeNav };
+        }
+        return arRef.current;
+    }, []);
+    // Track AppState so we can detect background → active transitions.
+    const appStateRef = React.useRef(react_native_1.AppState.currentState);
+    // Timestamp at which AppState last left "active". Lets us distinguish a
+    // genuine Quest-menu return (background lasts seconds) from racy
+    // background→active bounces caused by the dual-Activity ReactHost
+    // transitioning state (background lasts <500ms). Only the former should
+    // re-launch VR; the latter would trigger a no-op startActivity that can
+    // contribute to the lifecycle storm in some configurations.
+    const leftActiveAtRef = React.useRef(0);
+    // On Quest: register the intent (scene + renderer config) then launch VRActivity.
+    // Also re-launch when the app returns from background (e.g. Quest system menu),
+    // because VRActivity auto-finishes when MainActivity resumes.
+    React.useEffect(() => {
+        if (!ViroPlatform_1.isQuest)
+            return;
+        checkRNVersionForVR();
+        const scene = vrInitialScene ?? initialScene;
+        if (scene) {
+            VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.setIntent(scene, {
+                hdrEnabled,
+                pbrEnabled,
+                bloomEnabled,
+                shadowsEnabled,
+                multisamplingEnabled,
+                vrModeEnabled,
+                passthroughEnabled,
+                handTrackingEnabled,
+                onExitViro,
+                debug,
+            });
+        }
+        VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.setVRActive(true);
+        VRLauncher?.launchVRScene?.();
+        const sub = react_native_1.AppState.addEventListener("change", (nextState) => {
+            const prev = appStateRef.current;
+            appStateRef.current = nextState;
+            if (prev === "active" && nextState !== "active") {
+                leftActiveAtRef.current = Date.now();
+            }
+            // Re-launch VR when the app returns from being backgrounded by the system
+            // (Quest menu, home, recents). Explicit exitVRScene() clears isVRActive()
+            // before finishing VRActivity, so Activity-transition-driven background→active
+            // cycles are ignored here.
+            if (prev !== "active" && nextState === "active" && VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.isVRActive()) {
+                // Skip if we were only briefly out of "active" — that's a racy
+                // dual-Activity ReactHost bounce, not a genuine menu return.
+                const backgroundedFor = Date.now() - leftActiveAtRef.current;
+                if (leftActiveAtRef.current > 0 && backgroundedFor < 1500)
+                    return;
+                VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.setVRActive(true);
+                VRLauncher?.launchVRScene?.();
+            }
+        });
+        return () => sub.remove();
+    }, []);
+    // Quest renders nothing here — VRActivity owns the display.
+    if (ViroPlatform_1.isQuest)
+        return null;
+    const scene = arInitialScene ?? initialScene;
+    if (!scene) {
+        console.warn("[Viro] ViroXRSceneNavigator requires `arInitialScene` or `initialScene`.");
+        return null;
+    }
+    return (<ViroARSceneNavigator_1.ViroARSceneNavigator ref={arRef} initialScene={scene} {...rest}/>);
+});

package/dist/components/VisionOS/ViroVisionOSModule.d.ts

@@ -0,0 +1,65 @@
+/**
+ * ViroVisionOSModule
+ *
+ * JavaScript API for controlling the visionOS ImmersiveSpace.
+ * On iOS / Android the calls are no-ops (module returns false / resolves silently).
+ *
+ * ── Host-app setup required ──────────────────────────────────────────────────
+ *
+ * 1. Add the ImmersiveSpace to your SwiftUI App struct (visionOS only):
+ *
+ *    #if os(visionOS)
+ *    import ViroReact
+ *    #endif
+ *
+ *    @main struct MyApp: App {
+ *      var body: some Scene {
+ *        WindowGroup {
+ *          ContentView()
+ *            #if os(visionOS)
+ *            .viroImmersiveSpaceController()
+ *            #endif
+ *        }
+ *        #if os(visionOS)
+ *        ImmersiveSpace(id: "ViroImmersive") {
+ *          ViroImmersiveSpaceView()
+ *        }
+ *        .immersionStyle(selection: .constant(.mixed), in: .mixed, .full, .progressive)
+ *        #endif
+ *      }
+ *    }
+ *
+ * 2. Call from JavaScript:
+ *
+ *    import { ViroVisionOSModule } from '@reactvision/react-viro';
+ *
+ *    await ViroVisionOSModule.enterImmersiveSpace('mixed');
+ *    // ... render Viro scene inside ImmersiveSpace ...
+ *    await ViroVisionOSModule.exitImmersiveSpace();
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+export type ImmersiveSpaceStyle = "mixed" | "full" | "progressive";
+/**
+ * Returns true if the app is running on Apple Vision Pro (visionOS).
+ * Uses the native module constant; falls back to Platform.isVision when
+ * available (React Native 0.83+).
+ */
+export declare function isVisionOS(): boolean;
+/**
+ * Opens the Viro ImmersiveSpace on visionOS.
+ *
+ * @param style  "mixed" (default) — virtual content blended over passthrough
+ *               "full"  — fully virtual, passthrough hidden
+ *               "progressive" — graduated immersion with crown dial
+ */
+export declare function enterImmersiveSpace(style?: ImmersiveSpaceStyle): Promise<boolean>;
+/**
+ * Dismisses the Viro ImmersiveSpace and returns to the window layer.
+ */
+export declare function exitImmersiveSpace(): Promise<boolean>;
+/** Convenience object matching the typical NativeModules pattern. */
+export declare const ViroVisionOSModule: {
+    readonly isVisionOS: typeof isVisionOS;
+    readonly enterImmersiveSpace: typeof enterImmersiveSpace;
+    readonly exitImmersiveSpace: typeof exitImmersiveSpace;
+};

package/dist/components/VisionOS/ViroVisionOSModule.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * ViroVisionOSModule
+ *
+ * JavaScript API for controlling the visionOS ImmersiveSpace.
+ * On iOS / Android the calls are no-ops (module returns false / resolves silently).
+ *
+ * ── Host-app setup required ──────────────────────────────────────────────────
+ *
+ * 1. Add the ImmersiveSpace to your SwiftUI App struct (visionOS only):
+ *
+ *    #if os(visionOS)
+ *    import ViroReact
+ *    #endif
+ *
+ *    @main struct MyApp: App {
+ *      var body: some Scene {
+ *        WindowGroup {
+ *          ContentView()
+ *            #if os(visionOS)
+ *            .viroImmersiveSpaceController()
+ *            #endif
+ *        }
+ *        #if os(visionOS)
+ *        ImmersiveSpace(id: "ViroImmersive") {
+ *          ViroImmersiveSpaceView()
+ *        }
+ *        .immersionStyle(selection: .constant(.mixed), in: .mixed, .full, .progressive)
+ *        #endif
+ *      }
+ *    }
+ *
+ * 2. Call from JavaScript:
+ *
+ *    import { ViroVisionOSModule } from '@reactvision/react-viro';
+ *
+ *    await ViroVisionOSModule.enterImmersiveSpace('mixed');
+ *    // ... render Viro scene inside ImmersiveSpace ...
+ *    await ViroVisionOSModule.exitImmersiveSpace();
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViroVisionOSModule = void 0;
+exports.isVisionOS = isVisionOS;
+exports.enterImmersiveSpace = enterImmersiveSpace;
+exports.exitImmersiveSpace = exitImmersiveSpace;
+const react_native_1 = require("react-native");
+/** @internal — raw NativeModule reference */
+const { VRTVisionOSModule } = react_native_1.NativeModules;
+/**
+ * Returns true if the app is running on Apple Vision Pro (visionOS).
+ * Uses the native module constant; falls back to Platform.isVision when
+ * available (React Native 0.83+).
+ */
+function isVisionOS() {
+    // React Native 0.83+ exposes Platform.isVision on visionOS builds.
+    if (react_native_1.Platform.isVision === true)
+        return true;
+    // Fallback: check the native module constant.
+    return VRTVisionOSModule?.isVisionOS === true;
+}
+/**
+ * Opens the Viro ImmersiveSpace on visionOS.
+ *
+ * @param style  "mixed" (default) — virtual content blended over passthrough
+ *               "full"  — fully virtual, passthrough hidden
+ *               "progressive" — graduated immersion with crown dial
+ */
+async function enterImmersiveSpace(style = "mixed") {
+    if (!VRTVisionOSModule) {
+        if (__DEV__) {
+            console.warn("[Viro] VRTVisionOSModule not available on this platform");
+        }
+        return false;
+    }
+    return VRTVisionOSModule.enterImmersiveSpace(style);
+}
+/**
+ * Dismisses the Viro ImmersiveSpace and returns to the window layer.
+ */
+async function exitImmersiveSpace() {
+    if (!VRTVisionOSModule)
+        return false;
+    return VRTVisionOSModule.exitImmersiveSpace();
+}
+/** Convenience object matching the typical NativeModules pattern. */
+exports.ViroVisionOSModule = {
+    isVisionOS,
+    enterImmersiveSpace,
+    exitImmersiveSpace,
+};

package/dist/index.d.ts

@@ -4,6 +4,8 @@
  *
  */
 import { ViroAnimations } from "./components/Animation/ViroAnimations";
+import { StudioSceneNavigator, StudioARScene } from "./components/Studio";
+import { ViroVisionOSModule, isVisionOS, enterImmersiveSpace, exitImmersiveSpace } from "./components/VisionOS/ViroVisionOSModule";
 import { Viro3DObject } from "./components/Viro3DObject";
 import { Viro360Image } from "./components/Viro360Image";
 import { Viro360Video } from "./components/Viro360Video";
@@ -49,13 +51,24 @@ import { ViroSpotLight } from "./components/ViroSpotLight";
 import { ViroText } from "./components/ViroText";
 import { ViroVideo } from "./components/ViroVideo";
 import { ViroVRSceneNavigator } from "./components/ViroVRSceneNavigator";
+import { ViroXRSceneNavigator } from "./components/ViroXRSceneNavigator";
 import { Viro3DSceneNavigator } from "./components/Viro3DSceneNavigator";
+import { hasOpenXRSupport, isQuest } from "./components/Utilities/ViroPlatform";
+import { useAnySourceHover } from "./components/Utilities/useAnySourceHover";
+import { useAnySourcePressed } from "./components/Utilities/useAnySourcePressed";
 import { ViroTextStyle } from "./components/Styles/ViroTextStyle";
 import { ViroStyle } from "./components/Styles/ViroStyle";
 import { polarToCartesian, polarToCartesianActual, isARSupportedOnDevice, requestRequiredPermissions, checkPermissions, ViroARSupportResponse, ViroPermissionsResult, ViroPermission, latLngToMercator, gpsToArWorld } from "./components/Utilities/ViroUtils";
 import { ViroARCamera } from "./components/AR/ViroARCamera";
-import { ViroHoverEvent, ViroClickEvent, ViroClickStateEvent, ViroTouchEvent, ViroScrollEvent, ViroSwipeEvent, ViroFuseEvent, ViroPinchEvent, ViroRotateEvent, ViroDragEvent, ViroPlatformEvent, ViroCollisionEvent, ViroPlatformInfo, ViroCameraTransformEvent, ViroPlatformUpdateEvent, ViroCameraTransform, ViroExitViroEvent, ViroErrorEvent, ViroAnimationStartEvent, ViroAnimationFinishEvent, ViroLoadStartEvent, ViroLoadEndEvent, ViroLoadErrorEvent, ViroVideoBufferStartEvent, ViroVideoBufferEndEvent, ViroVideoUpdateTimeEvent, ViroVideoErrorEvent, ViroVideoFinishEvent, ViroAnimatedComponentStartEvent, ViroAnimatedComponentFinishEvent, ViroARAnchorRemovedEvent, ViroARAnchorUpdatedEvent, ViroARAnchorFoundEvent, ViroAnchor, ViroAnchorFoundMap, ViroAnchorUpdatedMap, ViroPlaneUpdatedMap, ViroPlaneUpdatedEvent, ViroARPlaneSizes, ViroCameraARHitTestEvent, ViroCameraARHitTest, ViroARHitTestResult, ViroARPointCloudUpdateEvent, ViroARPointCloud, ViroTrackingUpdatedEvent, ViroTrackingState, ViroTrackingReason, ViroAmbientLightUpdateEvent, ViroAmbientLightInfo, ViroWorldOrigin, ViroNativeTransformUpdateEvent, ViroControllerStatusEvent, ViroControllerStatus, ViroPortalEnterEvent, ViroPortalExitEvent, ViroSoundFinishEvent, ViroPinchStateTypes, ViroClickStateTypes, ViroRotateStateTypes, ViroProvider, ViroCloudAnchorState, ViroCloudAnchorProvider, ViroCloudAnchor, ViroHostCloudAnchorResult, ViroResolveCloudAnchorResult, ViroCloudAnchorStateChangeEvent, ViroGeospatialAnchorProvider, ViroEarthTrackingState, ViroVPSAvailability, ViroGeospatialAnchorType, ViroQuaternion, ViroGeospatialPose, ViroGeospatialAnchor, ViroGeospatialSupportResult, ViroEarthTrackingStateResult, ViroGeospatialPoseResult, ViroVPSAvailabilityResult, ViroCreateGeospatialAnchorResult, ViroMonocularDepthSupportResult, ViroMonocularDepthModelAvailableResult, ViroMonocularDepthPreferenceResult } from "./components/Types/ViroEvents";
+import { ViroHoverEvent, ViroClickEvent, ViroClickStateEvent, ViroTouchEvent, ViroScrollEvent, ViroSwipeEvent, ViroFuseEvent, ViroPinchEvent, ViroRotateEvent, ViroDragEvent, ViroPlatformEvent, ViroCollisionEvent, ViroPlatformInfo, ViroCameraTransformEvent, ViroPlatformUpdateEvent, ViroCameraTransform, ViroExitViroEvent, ViroErrorEvent, ViroAnimationStartEvent, ViroAnimationFinishEvent, ViroLoadStartEvent, ViroLoadEndEvent, ViroLoadErrorEvent, ViroVideoBufferStartEvent, ViroVideoBufferEndEvent, ViroVideoUpdateTimeEvent, ViroVideoErrorEvent, ViroVideoFinishEvent, ViroAnimatedComponentStartEvent, ViroAnimatedComponentFinishEvent, ViroARAnchorRemovedEvent, ViroARAnchorUpdatedEvent, ViroARAnchorFoundEvent, ViroAnchor, ViroAnchorFoundMap, ViroAnchorUpdatedMap, ViroPlaneUpdatedMap, ViroPlaneUpdatedEvent, ViroARPlaneSizes, ViroCameraARHitTestEvent, ViroCameraARHitTest, ViroARHitTestResult, ViroARPointCloudUpdateEvent, ViroARPointCloud, ViroTrackingUpdatedEvent, ViroTrackingState, ViroTrackingReason, ViroAmbientLightUpdateEvent, ViroAmbientLightInfo, ViroWorldOrigin, ViroNativeTransformUpdateEvent, ViroControllerStatusEvent, ViroControllerStatus, ViroPortalEnterEvent, ViroPortalExitEvent, ViroSoundFinishEvent, ViroPinchStateTypes, ViroClickStateTypes, ViroRotateStateTypes, ViroProvider, ViroCloudAnchorState, ViroCloudAnchorProvider, ViroCloudAnchor, ViroHostCloudAnchorResult, ViroResolveCloudAnchorResult, ViroCloudAnchorStateChangeEvent, ViroGeospatialAnchorProvider, ViroEarthTrackingState, ViroVPSAvailability, ViroGeospatialAnchorType, ViroQuaternion, ViroGeospatialPose, ViroGeospatialAnchor, ViroGeospatialSupportResult, ViroEarthTrackingStateResult, ViroGeospatialPoseResult, ViroVPSAvailabilityResult, ViroCreateGeospatialAnchorResult, ViroMonocularDepthSupportResult, ViroMonocularDepthModelAvailableResult, ViroMonocularDepthPreferenceResult, ViroJoint, ViroHandJoints, ViroHandPinchEvent, ViroHandUpdateEvent } from "./components/Types/ViroEvents";
 import { ViroSurface } from "./components/ViroSurface";
 import { ViroSceneNavigator } from "./components/ViroSceneNavigator";
 import { VIRO_VERSION } from "./components/Utilities/ViroVersion";
-export { ViroARImageMarker, ViroARObjectMarker, ViroARTrackingTargets, ViroARPlane, ViroARPlaneSelector, ViroARScene, ViroARSceneNavigator, ViroBox, ViroButton, ViroCamera, ViroController, ViroDirectionalLight, ViroFlexView, ViroGeometry, ViroLightingEnvironment, ViroImage, ViroMaterials, ViroARCamera, ViroMaterialVideo, ViroNode, ViroOmniLight, ViroOrbitCamera, ViroParticleEmitter, ViroPolygon, ViroPolyline, ViroPortal, ViroPortalScene, ViroQuad, ViroScene, ViroSurface, ViroSceneNavigator, ViroSkyBox, ViroAnimations, Viro3DObject, Viro360Image, Viro360Video, ViroAnimatedImage, ViroAmbientLight, ViroAnimatedComponent, ViroSound, ViroSoundField, ViroSpatialSound, ViroSphere, ViroSpinner, ViroSpotLight, ViroText, ViroVideo, ViroVRSceneNavigator, Viro3DSceneNavigator, ViroARTrackingReasonConstants, ViroRecordingErrorConstants, ViroTrackingStateConstants, polarToCartesian, polarToCartesianActual, isARSupportedOnDevice, requestRequiredPermissions, checkPermissions, latLngToMercator, gpsToArWorld, ViroARSupportResponse, ViroPermissionsResult, ViroPermission, ViroHoverEvent, ViroClickEvent, ViroClickStateEvent, ViroClickStateTypes, ViroTouchEvent, ViroScrollEvent, ViroSwipeEvent, ViroFuseEvent, ViroPinchEvent, ViroPinchStateTypes, ViroRotateEvent, ViroRotateStateTypes, ViroDragEvent, ViroPlatformEvent, ViroCollisionEvent, ViroPlatformInfo, ViroCameraTransformEvent, ViroPlatformUpdateEvent, ViroCameraTransform, ViroExitViroEvent, ViroErrorEvent, ViroAnimationStartEvent, ViroAnimationFinishEvent, ViroLoadStartEvent, ViroLoadEndEvent, ViroLoadErrorEvent, ViroVideoBufferStartEvent, ViroVideoBufferEndEvent, ViroVideoUpdateTimeEvent, ViroVideoErrorEvent, ViroVideoFinishEvent, ViroAnimatedComponentStartEvent, ViroAnimatedComponentFinishEvent, ViroARAnchorRemovedEvent, ViroARAnchorUpdatedEvent, ViroARAnchorFoundEvent, ViroAnchor, ViroAnchorFoundMap, ViroAnchorUpdatedMap, ViroPlaneUpdatedMap, ViroPlaneUpdatedEvent, ViroARPlaneSizes, ViroCameraARHitTestEvent, ViroCameraARHitTest, ViroARHitTestResult, ViroARPointCloudUpdateEvent, ViroARPointCloud, ViroTrackingUpdatedEvent, ViroTrackingState, ViroTrackingReason, ViroAmbientLightUpdateEvent, ViroAmbientLightInfo, ViroWorldOrigin, ViroNativeTransformUpdateEvent, ViroControllerStatusEvent, ViroControllerStatus, ViroPortalEnterEvent, ViroPortalExitEvent, ViroSoundFinishEvent, ViroTextStyle, ViroStyle, ViroMaterial, ViroShaderModifiers, ViroShaderUniform, ViroShaderModifier, VIRO_VERSION, ViroProvider, ViroCloudAnchorState, ViroCloudAnchorProvider, ViroCloudAnchor, ViroHostCloudAnchorResult, ViroResolveCloudAnchorResult, ViroCloudAnchorStateChangeEvent, ViroGeospatialAnchorProvider, ViroEarthTrackingState, ViroVPSAvailability, ViroGeospatialAnchorType, ViroQuaternion, ViroGeospatialPose, ViroGeospatialAnchor, ViroGeospatialSupportResult, ViroEarthTrackingStateResult, ViroGeospatialPoseResult, ViroVPSAvailabilityResult, ViroCreateGeospatialAnchorResult, ViroMonocularDepthSupportResult, ViroMonocularDepthModelAvailableResult, ViroMonocularDepthPreferenceResult, };
+import { ViroQuestEntryPoint } from "./components/ViroQuestEntryPoint";
+import { VRQuestNavigatorBridge } from "./components/Utilities/VRQuestNavigatorBridge";
+import { VRModuleOpenXR, useVRViewTag, exitVRScene } from "./components/Utilities/VRModuleOpenXR";
+import type { VRModuleOpenXRType } from "./components/Utilities/VRModuleOpenXR";
+export { ViroARImageMarker, ViroARObjectMarker, ViroARTrackingTargets, ViroARPlane, ViroARPlaneSelector, ViroARScene, ViroARSceneNavigator, ViroBox, ViroButton, ViroCamera, ViroController, ViroDirectionalLight, ViroFlexView, ViroGeometry, ViroLightingEnvironment, ViroImage, ViroMaterials, ViroARCamera, ViroMaterialVideo, ViroNode, ViroOmniLight, ViroOrbitCamera, ViroParticleEmitter, ViroPolygon, ViroPolyline, ViroPortal, ViroPortalScene, ViroQuad, ViroScene, ViroSurface, ViroSceneNavigator, ViroSkyBox, ViroAnimations, Viro3DObject, Viro360Image, Viro360Video, ViroAnimatedImage, ViroAmbientLight, ViroAnimatedComponent, ViroSound, ViroSoundField, ViroSpatialSound, ViroSphere, ViroSpinner, ViroSpotLight, ViroText, ViroVideo, ViroVRSceneNavigator, ViroXRSceneNavigator, ViroQuestEntryPoint, VRQuestNavigatorBridge, VRModuleOpenXR, useVRViewTag, exitVRScene, Viro3DSceneNavigator, hasOpenXRSupport, isQuest, useAnySourceHover, useAnySourcePressed, ViroARTrackingReasonConstants, ViroRecordingErrorConstants, ViroTrackingStateConstants, polarToCartesian, polarToCartesianActual, isARSupportedOnDevice, requestRequiredPermissions, checkPermissions, latLngToMercator, gpsToArWorld, ViroARSupportResponse, ViroPermissionsResult, ViroPermission, ViroHoverEvent, ViroClickEvent, ViroClickStateEvent, ViroClickStateTypes, ViroTouchEvent, ViroScrollEvent, ViroSwipeEvent, ViroFuseEvent, ViroPinchEvent, ViroPinchStateTypes, ViroRotateEvent, ViroRotateStateTypes, ViroDragEvent, ViroPlatformEvent, ViroCollisionEvent, ViroPlatformInfo, ViroCameraTransformEvent, ViroPlatformUpdateEvent, ViroCameraTransform, ViroExitViroEvent, ViroErrorEvent, ViroAnimationStartEvent, ViroAnimationFinishEvent, ViroLoadStartEvent, ViroLoadEndEvent, ViroLoadErrorEvent, ViroVideoBufferStartEvent, ViroVideoBufferEndEvent, ViroVideoUpdateTimeEvent, ViroVideoErrorEvent, ViroVideoFinishEvent, ViroAnimatedComponentStartEvent, ViroAnimatedComponentFinishEvent, ViroARAnchorRemovedEvent, ViroARAnchorUpdatedEvent, ViroARAnchorFoundEvent, ViroAnchor, ViroAnchorFoundMap, ViroAnchorUpdatedMap, ViroPlaneUpdatedMap, ViroPlaneUpdatedEvent, ViroARPlaneSizes, ViroCameraARHitTestEvent, ViroCameraARHitTest, ViroARHitTestResult, ViroARPointCloudUpdateEvent, ViroARPointCloud, ViroTrackingUpdatedEvent, ViroTrackingState, ViroTrackingReason, ViroAmbientLightUpdateEvent, ViroAmbientLightInfo, ViroWorldOrigin, ViroNativeTransformUpdateEvent, ViroControllerStatusEvent, ViroControllerStatus, ViroPortalEnterEvent, ViroPortalExitEvent, ViroSoundFinishEvent, ViroTextStyle, ViroStyle, ViroMaterial, ViroShaderModifiers, ViroShaderUniform, ViroShaderModifier, VIRO_VERSION, ViroProvider, ViroCloudAnchorState, ViroCloudAnchorProvider, ViroCloudAnchor, ViroHostCloudAnchorResult, ViroResolveCloudAnchorResult, ViroCloudAnchorStateChangeEvent, ViroGeospatialAnchorProvider, ViroEarthTrackingState, ViroVPSAvailability, ViroGeospatialAnchorType, ViroQuaternion, ViroGeospatialPose, ViroGeospatialAnchor, ViroGeospatialSupportResult, ViroEarthTrackingStateResult, ViroGeospatialPoseResult, ViroVPSAvailabilityResult, ViroCreateGeospatialAnchorResult, ViroMonocularDepthSupportResult, ViroMonocularDepthModelAvailableResult, ViroMonocularDepthPreferenceResult, ViroJoint, ViroHandJoints, ViroHandPinchEvent, ViroHandUpdateEvent, StudioSceneNavigator, StudioARScene, ViroVisionOSModule, isVisionOS, enterImmersiveSpace, exitImmersiveSpace, };
+export type { VRModuleOpenXRType };
+export type { ImmersiveSpaceStyle } from "./components/VisionOS/ViroVisionOSModule";
+export type { StudioSceneResponse, StudioAsset, StudioAnimation, StudioCollisionBinding, StudioSceneFunction, StudioSceneMeta, StudioProjectMeta, } from "./components/Studio";