@reactvision/react-viro 2.53.1 → 2.55.0

package/dist/components/Studio/StudioARScene.js

@@ -0,0 +1,299 @@
+"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.StudioARScene = void 0;
+const React = __importStar(require("react"));
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const ViroAmbientLight_1 = require("../ViroAmbientLight");
+const ViroARImageMarker_1 = require("../AR/ViroARImageMarker");
+const ViroARPlane_1 = require("../AR/ViroARPlane");
+const ViroARPlaneSelector_1 = require("../AR/ViroARPlaneSelector");
+const ViroARScene_1 = require("../AR/ViroARScene");
+const ViroScene_1 = require("../ViroScene");
+const ViroText_1 = require("../ViroText");
+const ViroController_1 = require("../ViroController");
+const ViroPlatform_1 = require("../Utilities/ViroPlatform");
+const animationRegistry_1 = require("./domain/animationRegistry");
+const collisionBindingsRuntime_1 = require("./domain/collisionBindingsRuntime");
+const collisionPairKey_1 = require("./domain/collisionPairKey");
+const triggerImageRegistry_1 = require("./domain/triggerImageRegistry");
+const viroNodeFactory_1 = require("./domain/viroNodeFactory");
+const sceneNavigationHandler_1 = require("./domain/sceneNavigationHandler");
+const studioMaterials_1 = require("./domain/studioMaterials");
+const useStudioShaderTimeUniforms_1 = require("./domain/useStudioShaderTimeUniforms");
+const useStudioShaderViewportUniforms_1 = require("./domain/useStudioShaderViewportUniforms");
+const physicsConfig_1 = require("./domain/physicsConfig");
+const ANDROID_MAX_3D_MODELS = 3;
+const IOS_MAX_3D_MODELS = 10;
+/**
+ * Outer gate: keeps the hooks-bearing inner component out of the tree until
+ * sceneData is available, avoiding a Rules of Hooks violation.
+ */
+const StudioARScene = (props) => {
+    if (!props.sceneData) {
+        return ViroPlatform_1.isQuest ? <ViroScene_1.ViroScene /> : <ViroARScene_1.ViroARScene />;
+    }
+    return <StudioARSceneInner {...props} sceneData={props.sceneData}/>;
+};
+exports.StudioARScene = StudioARScene;
+const StudioARSceneInner = (props) => {
+    const { sceneNavigator, sceneData, onReady, onSceneChange } = props;
+    const { scene, assets, animations, collision_bindings, functions } = sceneData;
+    // ─── Material registration ────────────────────────────────────────────────
+    const materialsRegisteredRef = (0, react_1.useRef)(false);
+    if (!materialsRegisteredRef.current) {
+        (0, studioMaterials_1.registerStudioMaterialsForAssets)(assets);
+        materialsRegisteredRef.current = true;
+    }
+    (0, useStudioShaderTimeUniforms_1.useStudioShaderTimeUniforms)(assets);
+    (0, useStudioShaderViewportUniforms_1.useStudioShaderViewportUniforms)(assets);
+    // ─── Animation registration ───────────────────────────────────────────────
+    const registeredKeyRef = (0, react_1.useRef)(null);
+    const animationsKey = animations.map((a) => a.animation_key).join(",");
+    if (animations.length > 0 && registeredKeyRef.current !== animationsKey) {
+        registeredKeyRef.current = animationsKey;
+        (0, animationRegistry_1.registerSceneAnimations)(animations);
+    }
+    // ─── Animation runtime state ──────────────────────────────────────────────
+    const [animOverrides, setAnimOverrides] = (0, react_1.useState)({});
+    const [loadedAssetIds, setLoadedAssetIds] = (0, react_1.useState)({});
+    const handleAssetLoaded = (0, react_1.useCallback)((assetId) => {
+        setLoadedAssetIds((prev) => prev[assetId] ? prev : { ...prev, [assetId]: true });
+    }, []);
+    const triggerHandlesRef = (0, react_1.useRef)(new Set());
+    (0, react_1.useEffect)(() => {
+        return () => {
+            triggerHandlesRef.current.forEach((id) => cancelAnimationFrame(id));
+            triggerHandlesRef.current.clear();
+        };
+    }, []);
+    const triggerAnimation = (0, react_1.useCallback)((targetAssetId, animationKey) => {
+        // Viro's animation prop is edge-triggered on false→true. Force false first,
+        // then flip to true on the next frame so a re-trigger of the same key fires.
+        setAnimOverrides((prev) => ({ ...prev, [targetAssetId]: { key: animationKey, run: false } }));
+        const handle = requestAnimationFrame(() => {
+            triggerHandlesRef.current.delete(handle);
+            setAnimOverrides((prev) => {
+                const current = prev[targetAssetId];
+                if (!current || current.key !== animationKey || current.run)
+                    return prev;
+                return { ...prev, [targetAssetId]: { key: animationKey, run: true } };
+            });
+        });
+        triggerHandlesRef.current.add(handle);
+    }, []);
+    const triggerAnimationRef = (0, react_1.useRef)(triggerAnimation);
+    triggerAnimationRef.current = triggerAnimation;
+    // ─── Computed animation props per asset ──────────────────────────────────
+    const animationStates = (0, react_1.useMemo)(() => {
+        const states = {};
+        const animsByAsset = new Map();
+        for (const anim of animations) {
+            const list = animsByAsset.get(anim.target_asset_id) ?? [];
+            list.push(anim);
+            animsByAsset.set(anim.target_asset_id, list);
+        }
+        for (const [assetId, anims] of animsByAsset) {
+            const override = animOverrides[assetId];
+            let activeAnim;
+            let run;
+            if (override) {
+                const triggered = anims.find((a) => a.animation_key === override.key);
+                if (!triggered)
+                    continue;
+                activeAnim = triggered;
+                run = override.run && !!loadedAssetIds[assetId];
+            }
+            else {
+                activeAnim = anims[0];
+                run = false;
+            }
+            states[assetId] = {
+                name: activeAnim.animation_key,
+                run,
+                loop: activeAnim.loop,
+                interruptible: activeAnim.interruptible,
+                delay: activeAnim.delay_ms ?? 0,
+                onStart: activeAnim.on_start_function
+                    ? () => (0, sceneNavigationHandler_1.executeOnLoadFunction)(activeAnim.on_start_function, functions, sceneNavigator, animations, (id, key) => triggerAnimationRef.current(id, key))
+                    : undefined,
+                onFinish: activeAnim.on_finish_function
+                    ? () => (0, sceneNavigationHandler_1.executeOnLoadFunction)(activeAnim.on_finish_function, functions, sceneNavigator, animations, (id, key) => triggerAnimationRef.current(id, key))
+                    : undefined,
+            };
+        }
+        return states;
+    }, [animations, animOverrides, loadedAssetIds, functions, sceneNavigator]);
+    // ─── on_load_function ─────────────────────────────────────────────────────
+    const onLoadExecutedRef = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        if (scene.on_load_function && !onLoadExecutedRef.current) {
+            onLoadExecutedRef.current = true;
+            (0, sceneNavigationHandler_1.executeOnLoadFunction)(scene.on_load_function, functions, sceneNavigator, animations, (id, key) => triggerAnimationRef.current(id, key), onSceneChange);
+        }
+    }, [scene.id]);
+    // ─── Collision bindings ───────────────────────────────────────────────────
+    const bindingsByPairKey = (0, react_1.useMemo)(() => {
+        const m = new Map();
+        for (const b of collision_bindings) {
+            const key = (0, collisionPairKey_1.collisionPairKey)(b.asset_x_id, b.asset_y_id);
+            const list = m.get(key) ?? [];
+            list.push(b);
+            m.set(key, list);
+        }
+        return m;
+    }, [collision_bindings]);
+    const collisionAssetIds = (0, react_1.useMemo)(() => {
+        const s = new Set();
+        for (const b of collision_bindings) {
+            s.add(b.asset_x_id);
+            s.add(b.asset_y_id);
+        }
+        return s;
+    }, [collision_bindings]);
+    const collisionCooldownRef = (0, react_1.useRef)(new Map());
+    const getCollisionHandler = (0, react_1.useCallback)((placementId) => {
+        if (!collisionAssetIds.has(placementId))
+            return undefined;
+        return (0, collisionBindingsRuntime_1.createPlacementCollisionHandler)(placementId, bindingsByPairKey, sceneNavigator, animations, collisionCooldownRef, (id, key) => triggerAnimationRef.current(id, key), onSceneChange);
+    }, [bindingsByPairKey, collisionAssetIds, sceneNavigator, animations]);
+    // ─── Trigger image targets ────────────────────────────────────────────────
+    const { planeAssets, imageTriggeredAssets } = (0, react_1.useMemo)(() => {
+        const plane = assets.filter((a) => !a.trigger_image_url);
+        const imgTriggered = assets.filter((a) => !!a.trigger_image_url);
+        return { planeAssets: plane, imageTriggeredAssets: imgTriggered };
+    }, [assets]);
+    const [urlToTargetName, setUrlToTargetName] = (0, react_1.useState)(() => new Map());
+    const prevTargetNamesRef = (0, react_1.useRef)([]);
+    (0, react_1.useEffect)(() => {
+        if (ViroPlatform_1.isQuest) {
+            if (imageTriggeredAssets.length > 0) {
+                console.warn("[Studio] Image-triggered assets are not supported on Quest — skipping.");
+            }
+            return;
+        }
+        if (imageTriggeredAssets.length === 0) {
+            (0, triggerImageRegistry_1.cleanupTriggerImageTargets)(prevTargetNamesRef.current);
+            prevTargetNamesRef.current = [];
+            setUrlToTargetName(new Map());
+            return;
+        }
+        const map = (0, triggerImageRegistry_1.registerTriggerImageTargets)(imageTriggeredAssets);
+        const targetNames = [...map.values()];
+        prevTargetNamesRef.current = targetNames;
+        setUrlToTargetName(map);
+        return () => {
+            (0, triggerImageRegistry_1.cleanupTriggerImageTargets)(targetNames);
+            prevTargetNamesRef.current = [];
+        };
+    }, [imageTriggeredAssets]);
+    // ─── Ready callback ───────────────────────────────────────────────────────
+    (0, react_1.useEffect)(() => { onReady?.(); }, []);
+    // ─── Render helpers ───────────────────────────────────────────────────────
+    const maxModels = react_native_1.Platform.OS === "android" ? ANDROID_MAX_3D_MODELS : IOS_MAX_3D_MODELS;
+    const renderedPlaneAssets = (0, react_1.useMemo)(() => {
+        let modelCount = 0;
+        return planeAssets
+            .map((asset) => {
+            if (asset.asset_type_name === "3D-MODEL") {
+                modelCount++;
+                if (modelCount > maxModels) {
+                    console.warn(`[Studio] Skipping 3D model "${asset.name}" — ${react_native_1.Platform.OS} limit (${maxModels}) reached`);
+                    return null;
+                }
+            }
+            return (0, viroNodeFactory_1.createNode)(asset, sceneNavigator, animations, scene, (id, key) => triggerAnimationRef.current(id, key), animationStates, handleAssetLoaded, getCollisionHandler(asset.id), onSceneChange);
+        })
+            .filter(Boolean);
+    }, [planeAssets, sceneNavigator, animations, animationStates, handleAssetLoaded, getCollisionHandler, maxModels, onSceneChange]);
+    const renderedImageTriggeredAssets = (0, react_1.useMemo)(() => {
+        if (ViroPlatform_1.isQuest)
+            return [];
+        return imageTriggeredAssets
+            .map((asset) => {
+            const targetName = urlToTargetName.get(asset.trigger_image_url);
+            if (!targetName)
+                return null;
+            const node = (0, viroNodeFactory_1.createNode)(asset, sceneNavigator, animations, scene, (id, key) => triggerAnimationRef.current(id, key), animationStates, handleAssetLoaded, getCollisionHandler(asset.id), onSceneChange);
+            if (!node)
+                return null;
+            return (<ViroARImageMarker_1.ViroARImageMarker key={asset.id} target={targetName}>
+            {node}
+          </ViroARImageMarker_1.ViroARImageMarker>);
+        })
+            .filter(Boolean);
+    }, [urlToTargetName, imageTriggeredAssets, sceneNavigator, animations, animationStates, handleAssetLoaded, getCollisionHandler, onSceneChange]);
+    // ─── Plane detection (AR only) ────────────────────────────────────────────
+    const planeDetectionMode = (scene.plane_detection ?? "NONE").toUpperCase();
+    const planeAlignment = (scene.plane_direction ?? "Horizontal");
+    const renderAssets = () => {
+        if (ViroPlatform_1.isQuest) {
+            if (planeDetectionMode !== "NONE") {
+                console.warn(`[Studio] Plane detection (${planeDetectionMode}) is not supported on Quest — rendering assets without plane anchor.`);
+            }
+            return <>{renderedPlaneAssets}</>;
+        }
+        if (planeDetectionMode === "AUTOMATIC") {
+            return (<ViroARPlane_1.ViroARPlane minHeight={0.1} minWidth={0.1} alignment={planeAlignment}>
+          {renderedPlaneAssets}
+        </ViroARPlane_1.ViroARPlane>);
+        }
+        if (planeDetectionMode === "MANUAL") {
+            return (<ViroARPlaneSelector_1.ViroARPlaneSelector minHeight={0.1} minWidth={0.1} alignment={planeAlignment}>
+          {renderedPlaneAssets}
+        </ViroARPlaneSelector_1.ViroARPlaneSelector>);
+        }
+        return <>{renderedPlaneAssets}</>;
+    };
+    // ─── Physics world ────────────────────────────────────────────────────────
+    const physicsWorldConfig = (0, physicsConfig_1.parsePhysicsWorldConfig)(scene.physics_world_config);
+    const physicsWorld = physicsWorldConfig?.enabled
+        ? (0, physicsConfig_1.buildViroPhysicsWorld)(physicsWorldConfig)
+        : undefined;
+    const physicsProps = physicsWorld ? { physicsWorld: physicsWorld } : {};
+    // ─── Render ───────────────────────────────────────────────────────────────
+    const children = (<>
+      {ViroPlatform_1.isQuest && <ViroController_1.ViroController controllerVisibility reticleVisibility/>}
+      <ViroAmbientLight_1.ViroAmbientLight color="#ffffff" intensity={1000}/>
+      {renderAssets()}
+      {renderedImageTriggeredAssets}
+      {assets.length === 0 && (<ViroText_1.ViroText text="No assets to display" position={[0, 0, -2]} style={{ fontFamily: "Arial", fontSize: 16, color: "#CCCCCC", textAlign: "center" }}/>)}
+    </>);
+    if (ViroPlatform_1.isQuest) {
+        return <ViroScene_1.ViroScene {...physicsProps}>{children}</ViroScene_1.ViroScene>;
+    }
+    return <ViroARScene_1.ViroARScene {...physicsProps}>{children}</ViroARScene_1.ViroARScene>;
+};

package/dist/components/Studio/StudioSceneNavigator.d.ts

@@ -0,0 +1,31 @@
+import * as React from "react";
+import { ViewStyle } from "react-native";
+interface StudioSceneNavigatorProps {
+    /**
+     * UUID of a specific scene to load. If omitted, the navigator fetches the
+     * project configured in the app manifest and uses its opening scene.
+     */
+    sceneId?: string;
+    worldAlignment?: "Gravity" | "GravityAndHeading" | "Camera";
+    autofocus?: boolean;
+    style?: ViewStyle;
+    onSceneReady?: () => void;
+    onError?: (err: Error) => void;
+    onSceneChange?: (sceneId: string, sceneName: string) => void;
+    onExitViro?: () => void;
+}
+/**
+ * Cross-reality Studio scene navigator. Renders a Studio-authored scene on
+ * both AR devices (iOS / non-Quest Android) and Meta Quest (VR).
+ *
+ * Opening-scene resolution order:
+ *   1. `sceneId` prop → use it directly
+ *   2. Native project (RVProjectId from manifest) → use `opening_scene.id`
+ *   3. Fallback → first scene in the project's scene list
+ *
+ * On Quest, ViroXRSceneNavigator is not rendered until the scene data is
+ * ready. This means VRActivity always launches with the actual content scene
+ * as its initial scene, avoiding the LoadingVRScene → replace timing race.
+ */
+export declare function StudioSceneNavigator({ sceneId, worldAlignment, autofocus, style, onSceneReady, onError, onSceneChange, onExitViro, }: StudioSceneNavigatorProps): React.JSX.Element;
+export {};

package/dist/components/Studio/StudioSceneNavigator.js

@@ -0,0 +1,174 @@
+"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.StudioSceneNavigator = StudioSceneNavigator;
+const React = __importStar(require("react"));
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const ViroARScene_1 = require("../AR/ViroARScene");
+const ViroScene_1 = require("../ViroScene");
+const ViroXRSceneNavigator_1 = require("../ViroXRSceneNavigator");
+const ViroPlatform_1 = require("../Utilities/ViroPlatform");
+const animationRegistry_1 = require("./domain/animationRegistry");
+const studioMaterials_1 = require("./domain/studioMaterials");
+const StudioARScene_1 = require("./StudioARScene");
+const VRTStudioModule_1 = require("./VRTStudioModule");
+function LoadingARScene() { return <ViroARScene_1.ViroARScene />; }
+function LoadingVRScene() { return <ViroScene_1.ViroScene />; }
+const styles = react_native_1.StyleSheet.create({
+    loader: {
+        position: "absolute",
+        top: 0, left: 0, right: 0, bottom: 0,
+        justifyContent: "center",
+        alignItems: "center",
+        backgroundColor: "#000000",
+    },
+});
+/**
+ * Cross-reality Studio scene navigator. Renders a Studio-authored scene on
+ * both AR devices (iOS / non-Quest Android) and Meta Quest (VR).
+ *
+ * Opening-scene resolution order:
+ *   1. `sceneId` prop → use it directly
+ *   2. Native project (RVProjectId from manifest) → use `opening_scene.id`
+ *   3. Fallback → first scene in the project's scene list
+ *
+ * On Quest, ViroXRSceneNavigator is not rendered until the scene data is
+ * ready. This means VRActivity always launches with the actual content scene
+ * as its initial scene, avoiding the LoadingVRScene → replace timing race.
+ */
+function StudioSceneNavigator({ sceneId, worldAlignment = "Gravity", autofocus = true, style, onSceneReady, onError, onSceneChange, onExitViro, }) {
+    const navigatorRef = (0, react_1.useRef)(null);
+    const loadedSceneIdRef = (0, react_1.useRef)(null);
+    const onSceneReadyRef = (0, react_1.useRef)(onSceneReady);
+    const onErrorRef = (0, react_1.useRef)(onError);
+    const onSceneChangeRef = (0, react_1.useRef)(onSceneChange);
+    onSceneReadyRef.current = onSceneReady;
+    onErrorRef.current = onError;
+    onSceneChangeRef.current = onSceneChange;
+    // On Quest: holds the resolved scene entry. ViroXRSceneNavigator is not
+    // rendered until this is non-null, so VRActivity always launches into content.
+    const [vrSceneEntry, setVrSceneEntry] = (0, react_1.useState)(null);
+    const resolveSceneId = (0, react_1.useCallback)(async () => {
+        if (sceneId)
+            return sceneId;
+        const projectResult = await VRTStudioModule_1.VRTStudioModule.rvGetProject();
+        if (!projectResult.success) {
+            throw new Error(projectResult.error ?? "rvGetProject failed");
+        }
+        if (typeof projectResult.data !== "string") {
+            throw new Error("rvGetProject returned no data");
+        }
+        const { project } = JSON.parse(projectResult.data);
+        if (project.opening_scene?.id) {
+            return project.opening_scene.id;
+        }
+        if (project.scenes.length > 0) {
+            return project.scenes[0].id;
+        }
+        throw new Error(`Project ${project.id} has no scenes`);
+    }, [sceneId]);
+    const loadScene = (0, react_1.useCallback)(async (isCancelled) => {
+        await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+        if (isCancelled())
+            return;
+        const resolvedSceneId = await resolveSceneId();
+        if (isCancelled())
+            return;
+        if (loadedSceneIdRef.current === resolvedSceneId)
+            return;
+        const result = await VRTStudioModule_1.VRTStudioModule.rvGetScene(resolvedSceneId);
+        if (isCancelled())
+            return;
+        if (!result.success) {
+            throw new Error(result.error ?? "rvGetScene failed");
+        }
+        if (typeof result.data !== "string") {
+            throw new Error("rvGetScene returned no data");
+        }
+        const sceneData = JSON.parse(result.data);
+        if (isCancelled())
+            return;
+        loadedSceneIdRef.current = resolvedSceneId;
+        // On Quest: pre-register animations and materials before VRActivity launches.
+        // This mirrors the module-level registration pattern used by XRSceneContent —
+        // native registrations complete before any Viro components mount, eliminating
+        // the race between registerAnimations/createMaterials native calls and the
+        // Fabric commit that creates those components.
+        if (ViroPlatform_1.isQuest) {
+            (0, animationRegistry_1.registerSceneAnimations)(sceneData.animations);
+            (0, studioMaterials_1.registerStudioMaterialsForAssets)(sceneData.assets);
+        }
+        const entry = {
+            scene: StudioARScene_1.StudioARScene,
+            passProps: {
+                sceneData,
+                onReady: onSceneReadyRef.current,
+                onSceneChange: onSceneChangeRef.current,
+            },
+        };
+        if (ViroPlatform_1.isQuest) {
+            // On Quest: setting vrSceneEntry triggers ViroXRSceneNavigator to mount
+            // with StudioARScene as vrInitialScene — VRActivity gets content immediately.
+            setVrSceneEntry(entry);
+        }
+        else {
+            navigatorRef.current?.arSceneNavigator?.push(entry);
+        }
+    }, [resolveSceneId]);
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        const isCancelled = () => cancelled;
+        loadScene(isCancelled).catch((e) => {
+            if (cancelled)
+                return;
+            const err = e instanceof Error ? e : new Error(String(e));
+            const handler = onErrorRef.current;
+            if (handler)
+                handler(err);
+            else
+                console.error("[Studio] Failed to load scene:", err);
+        });
+        return () => { cancelled = true; };
+    }, [sceneId, loadScene]);
+    // On Quest: show a spinner until scene data is ready, then mount
+    // ViroXRSceneNavigator (which launches VRActivity with content immediately).
+    if (ViroPlatform_1.isQuest && !vrSceneEntry) {
+        return (<react_native_1.View style={styles.loader}>
+        <react_native_1.ActivityIndicator size="large" color="#ffffff"/>
+      </react_native_1.View>);
+    }
+    return (<ViroXRSceneNavigator_1.ViroXRSceneNavigator ref={navigatorRef} arInitialScene={{ scene: LoadingARScene }} vrInitialScene={vrSceneEntry ?? { scene: LoadingVRScene }} worldAlignment={worldAlignment} autofocus={autofocus} onExitViro={onExitViro} style={style ?? react_native_1.StyleSheet.absoluteFill}/>);
+}

package/dist/components/Studio/VRTStudioModule.d.ts

@@ -0,0 +1,15 @@
+export interface StudioModuleResult {
+    success: boolean;
+    data?: string;
+    error?: string;
+}
+export declare const VRTStudioModule: {
+    rvGetScene: (sceneId: string) => Promise<StudioModuleResult>;
+    /**
+     * Fetches the project configured in the app manifest (Android: `com.reactvision.RVProjectId`,
+     * iOS: `RVProjectId`). The project ID is baked in by the Expo plugin at build time.
+     */
+    rvGetProject: () => Promise<StudioModuleResult>;
+    /** Returns the configured project ID, or null if not set. */
+    rvGetProjectId: () => Promise<string | null>;
+};

package/dist/components/Studio/VRTStudioModule.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VRTStudioModule = void 0;
+const react_native_1 = require("react-native");
+const native = react_native_1.NativeModules.VRTStudio;
+const NOT_AVAILABLE = {
+    success: false,
+    error: "VRTStudio native module not available",
+};
+exports.VRTStudioModule = {
+    rvGetScene: (sceneId) => {
+        if (!native)
+            return Promise.resolve(NOT_AVAILABLE);
+        return native.rvGetScene(sceneId);
+    },
+    /**
+     * Fetches the project configured in the app manifest (Android: `com.reactvision.RVProjectId`,
+     * iOS: `RVProjectId`). The project ID is baked in by the Expo plugin at build time.
+     */
+    rvGetProject: () => {
+        if (!native)
+            return Promise.resolve(NOT_AVAILABLE);
+        return native.rvGetProject();
+    },
+    /** Returns the configured project ID, or null if not set. */
+    rvGetProjectId: () => {
+        if (!native)
+            return Promise.resolve(null);
+        return native.rvGetProjectId();
+    },
+};

package/dist/components/Studio/domain/animationRegistry.d.ts

@@ -0,0 +1,11 @@
+import { StudioAnimation } from "../types";
+/**
+ * Builds the Viro animation registry object from StudioAnimation rows.
+ * The properties field is already in Viro's native keyframe format.
+ */
+export declare function buildViroAnimationRegistry(animations: StudioAnimation[]): Record<string, unknown>;
+/**
+ * Registers all scene animations with ViroReact.
+ * Must be called before any animated Viro components mount.
+ */
+export declare function registerSceneAnimations(animations: StudioAnimation[]): void;

package/dist/components/Studio/domain/animationRegistry.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildViroAnimationRegistry = buildViroAnimationRegistry;
+exports.registerSceneAnimations = registerSceneAnimations;
+const ViroAnimations_1 = require("../../Animation/ViroAnimations");
+const MAX_CONCURRENT_ANIMATIONS = 10;
+const MAX_DURATION_MS = 30_000;
+const MAX_POSITION_ABS = 1_000;
+const MAX_SCALE = 100;
+const MIN_SCALE = 0.01;
+/**
+ * Builds the Viro animation registry object from StudioAnimation rows.
+ * The properties field is already in Viro's native keyframe format.
+ */
+function buildViroAnimationRegistry(animations) {
+    const registry = {};
+    for (const anim of animations) {
+        warnAnimationPerformance(anim);
+        registry[anim.animation_key] = {
+            properties: anim.properties,
+            duration: anim.duration_ms ?? 1000,
+            delay: anim.delay_ms ?? 0,
+            ...(anim.easing ? { easing: anim.easing } : {}),
+        };
+    }
+    return registry;
+}
+/**
+ * Registers all scene animations with ViroReact.
+ * Must be called before any animated Viro components mount.
+ */
+function registerSceneAnimations(animations) {
+    if (animations.length === 0)
+        return;
+    if (animations.length > MAX_CONCURRENT_ANIMATIONS) {
+        console.warn(`[Studio/Animation] Scene has ${animations.length} animations. ` +
+            `Recommended max is ${MAX_CONCURRENT_ANIMATIONS} for smooth performance.`);
+    }
+    const registry = buildViroAnimationRegistry(animations);
+    ViroAnimations_1.ViroAnimations.registerAnimations(registry);
+    console.log(`[Studio/Animation] Registered ${Object.keys(registry).length} animation(s): ${Object.keys(registry).join(", ")}`);
+}
+function warnAnimationPerformance(anim) {
+    if ((anim.duration_ms ?? 0) > MAX_DURATION_MS) {
+        console.warn(`[Studio/Animation] "${anim.animation_key}" duration ${anim.duration_ms}ms exceeds ` +
+            `recommended max of ${MAX_DURATION_MS}ms.`);
+    }
+    const props = anim.properties;
+    if (!props || typeof props !== "object")
+        return;
+    for (const key of Object.keys(props)) {
+        const val = props[key];
+        if (typeof val !== "number")
+            continue;
+        if (key === "scaleX" || key === "scaleY" || key === "scaleZ") {
+            if (val > MAX_SCALE || val < MIN_SCALE) {
+                console.warn(`[Studio/Animation] "${anim.animation_key}" ${key}=${val} is outside ` +
+                    `recommended range [${MIN_SCALE}, ${MAX_SCALE}].`);
+            }
+        }
+        if (key === "positionX" || key === "positionY" || key === "positionZ") {
+            if (Math.abs(val) > MAX_POSITION_ABS) {
+                console.warn(`[Studio/Animation] "${anim.animation_key}" ${key}=${val} is far from origin.`);
+            }
+        }
+    }
+}

package/dist/components/Studio/domain/collisionBindingsRuntime.d.ts

@@ -0,0 +1,21 @@
+import { MutableRefObject } from "react";
+import { StudioAnimation, StudioCollisionBinding } from "../types";
+/**
+ * Dispatches scene functions for collision bindings matching the canonical pair.
+ * Cooldown prevents per-frame spam while physics contacts overlap.
+ */
+export declare function dispatchCollisionBindingActions(params: {
+    selfPlacementId: string;
+    otherTag: string;
+    bindingsByPairKey: Map<string, StudioCollisionBinding[]>;
+    sceneNavigator?: unknown;
+    animations: StudioAnimation[];
+    onSceneChange?: (sceneId: string, sceneName: string) => void;
+    onAnimationTrigger?: (targetAssetId: string, animationKey: string) => void;
+    cooldownMs?: number;
+    lastFiredRef: MutableRefObject<Map<string, number>>;
+}): void;
+/**
+ * Returns an onCollision handler for a given placement asset ID.
+ */
+export declare function createPlacementCollisionHandler(placementId: string, bindingsByPairKey: Map<string, StudioCollisionBinding[]>, sceneNavigator: unknown, animations: StudioAnimation[], lastFiredRef: MutableRefObject<Map<string, number>>, onAnimationTrigger?: (targetAssetId: string, animationKey: string) => void, onSceneChange?: (sceneId: string, sceneName: string) => void): (viroTag: string, collidedPoint: [number, number, number], collidedNormal: [number, number, number]) => void;