@reactvision/react-viro 2.53.1 → 2.55.0

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchCollisionBindingActions = dispatchCollisionBindingActions;
+exports.createPlacementCollisionHandler = createPlacementCollisionHandler;
+const collisionPairKey_1 = require("./collisionPairKey");
+const sceneNavigationHandler_1 = require("./sceneNavigationHandler");
+const DEFAULT_COOLDOWN_MS = 750;
+function pairCooldownKey(pairKey, functionId) {
+    return `${pairKey}::${functionId}`;
+}
+/**
+ * Dispatches scene functions for collision bindings matching the canonical pair.
+ * Cooldown prevents per-frame spam while physics contacts overlap.
+ */
+function dispatchCollisionBindingActions(params) {
+    const { selfPlacementId, otherTag, bindingsByPairKey, sceneNavigator, animations, onSceneChange, onAnimationTrigger, cooldownMs = DEFAULT_COOLDOWN_MS, lastFiredRef, } = params;
+    if (!otherTag)
+        return;
+    const { asset_x_id, asset_y_id } = (0, collisionPairKey_1.canonicalizeCollisionAssetIds)(selfPlacementId, otherTag);
+    const pKey = (0, collisionPairKey_1.collisionPairKey)(asset_x_id, asset_y_id);
+    const rows = bindingsByPairKey.get(pKey);
+    if (!rows?.length)
+        return;
+    const now = Date.now();
+    const map = lastFiredRef.current;
+    for (const row of rows) {
+        const fn = row.scene_function;
+        if (!fn)
+            continue;
+        const ck = pairCooldownKey(pKey, row.function_id);
+        const last = map.get(ck) ?? 0;
+        if (now - last < cooldownMs)
+            continue;
+        map.set(ck, now);
+        (0, sceneNavigationHandler_1.executeFunctionWithRelations)(fn, sceneNavigator, animations, onAnimationTrigger, 0, onSceneChange);
+    }
+}
+/**
+ * Returns an onCollision handler for a given placement asset ID.
+ */
+function createPlacementCollisionHandler(placementId, bindingsByPairKey, sceneNavigator, animations, lastFiredRef, onAnimationTrigger, onSceneChange) {
+    return (viroTag) => {
+        dispatchCollisionBindingActions({
+            selfPlacementId: placementId,
+            otherTag: viroTag,
+            bindingsByPairKey,
+            sceneNavigator,
+            animations,
+            onSceneChange,
+            onAnimationTrigger,
+            lastFiredRef,
+        });
+    };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Canonical collision pair — matches DB constraint where asset_x_id < asset_y_id lexicographically.
+ */
+export declare function canonicalizeCollisionAssetIds(a: string, b: string): {
+    asset_x_id: string;
+    asset_y_id: string;
+};
+export declare function collisionPairKey(assetX: string, assetY: string): string;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalizeCollisionAssetIds = canonicalizeCollisionAssetIds;
+exports.collisionPairKey = collisionPairKey;
+/**
+ * Canonical collision pair — matches DB constraint where asset_x_id < asset_y_id lexicographically.
+ */
+function canonicalizeCollisionAssetIds(a, b) {
+    return a < b
+        ? { asset_x_id: a, asset_y_id: b }
+        : { asset_x_id: b, asset_y_id: a };
+}
+function collisionPairKey(assetX, assetY) {
+    return `${assetX}|${assetY}`;
+}

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

@@ -0,0 +1,20 @@
+import { StudioAsset, StudioSceneMeta } from "../types";
+export type DragType = "FixedToWorld" | "FixedToPlane" | undefined;
+export type DragPlane = {
+    planePoint: [number, number, number];
+    planeNormal: [number, number, number];
+    maxDistance: number;
+};
+export declare class DragConfiguration {
+    /**
+     * Chooses FixedToPlane when the scene uses plane detection, FixedToWorld otherwise.
+     * Returns undefined if the asset is not draggable.
+     */
+    static getDragType(asset: StudioAsset, scene: StudioSceneMeta | null): DragType;
+    /**
+     * Returns a drag plane that passes through the object's current position,
+     * preventing objects from jumping on drag start. maxDistance caps how far
+     * objects can travel from the camera.
+     */
+    static getDragPlane(planeAlignment: string, objectPosition: [number, number, number]): DragPlane;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragConfiguration = void 0;
+class DragConfiguration {
+    /**
+     * Chooses FixedToPlane when the scene uses plane detection, FixedToWorld otherwise.
+     * Returns undefined if the asset is not draggable.
+     */
+    static getDragType(asset, scene) {
+        if (!asset.is_draggable)
+            return undefined;
+        const planeDetection = (scene?.plane_detection ?? "NONE").toUpperCase();
+        if (planeDetection === "AUTOMATIC" || planeDetection === "MANUAL") {
+            return "FixedToPlane";
+        }
+        return "FixedToWorld";
+    }
+    /**
+     * Returns a drag plane that passes through the object's current position,
+     * preventing objects from jumping on drag start. maxDistance caps how far
+     * objects can travel from the camera.
+     */
+    static getDragPlane(planeAlignment, objectPosition) {
+        switch (planeAlignment.toLowerCase()) {
+            case "horizontal":
+            case "horizontalupward":
+                return { planePoint: objectPosition, planeNormal: [0, 1, 0], maxDistance: 1.5 };
+            case "horizontaldownward":
+                return { planePoint: objectPosition, planeNormal: [0, -1, 0], maxDistance: 1.5 };
+            case "vertical":
+                return { planePoint: objectPosition, planeNormal: [0, 0, 1], maxDistance: 1.5 };
+            default:
+                return { planePoint: objectPosition, planeNormal: [0, 1, 0], maxDistance: 1.5 };
+        }
+    }
+}
+exports.DragConfiguration = DragConfiguration;

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

@@ -0,0 +1,56 @@
+/**
+ * Studio material_config parsing and Viro material definition building.
+ * Ported from studio-go/domain/materialConfig.ts — no zod dependency.
+ */
+type ShaderModifierStage = {
+    uniforms?: string;
+    body?: string;
+    varyings?: unknown;
+    requiresSceneDepth?: boolean;
+    requiresCameraTexture?: boolean;
+    priority?: unknown;
+};
+export type MaterialConfig = {
+    presetName?: string;
+    lightingModel: "Constant" | "Lambert" | "Blinn" | "Phong" | "PBR";
+    diffuseColor?: string;
+    roughness?: number;
+    metalness?: number;
+    shininess?: number;
+    alpha?: number;
+    blendMode?: string;
+    bloomThreshold?: number | null;
+    wrapS?: "Clamp" | "Repeat" | "Mirror";
+    wrapT?: "Clamp" | "Repeat" | "Mirror";
+    diffuseTexture?: string | null;
+    normalTexture?: string | null;
+    roughnessTexture?: string | null;
+    metalnessTexture?: string | null;
+    ambientOcclusionTexture?: string | null;
+    specularTexture?: string | null;
+    shaderModifiers?: Record<string, ShaderModifierStage | string>;
+    materialUniforms?: Array<{
+        name: string;
+        type: string;
+        value: unknown;
+    }>;
+    transparencyMode?: string;
+    cullMode?: string;
+};
+export type ViroMaterialDefinition = Record<string, unknown>;
+export declare function materialConfigNeedsTimeUniform(config: MaterialConfig): boolean;
+/**
+ * True if the shader uses _rf_vpw/_rf_vph viewport uniforms.
+ * These must be pushed via ViroMaterials.updateShaderUniform on mount and orientation change.
+ */
+export declare function materialConfigNeedsViewportUniforms(config: MaterialConfig): boolean;
+export declare function studioMaterialName(assetId: string): string;
+/**
+ * Parses `scene_assets.material_config` JSON. Returns null if missing or invalid.
+ */
+export declare function parseMaterialConfig(raw: unknown): MaterialConfig | null;
+/**
+ * Maps a validated Studio material_config to Viro's `createMaterials` definition shape.
+ */
+export declare function buildViroMaterialDefinition(config: MaterialConfig): ViroMaterialDefinition;
+export {};

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

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * Studio material_config parsing and Viro material definition building.
+ * Ported from studio-go/domain/materialConfig.ts — no zod dependency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materialConfigNeedsTimeUniform = materialConfigNeedsTimeUniform;
+exports.materialConfigNeedsViewportUniforms = materialConfigNeedsViewportUniforms;
+exports.studioMaterialName = studioMaterialName;
+exports.parseMaterialConfig = parseMaterialConfig;
+exports.buildViroMaterialDefinition = buildViroMaterialDefinition;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const TEXTURE_KEYS = [
+    "diffuseTexture",
+    "normalTexture",
+    "roughnessTexture",
+    "metalnessTexture",
+    "ambientOcclusionTexture",
+    "specularTexture",
+];
+function textureToViro(uri) {
+    if (uri == null || uri === "")
+        return undefined;
+    return { uri };
+}
+function collectShaderModifierStrings(config) {
+    const mods = config.shaderModifiers;
+    if (!mods)
+        return [];
+    const strings = [];
+    for (const stage of Object.values(mods)) {
+        if (typeof stage === "string") {
+            strings.push(stage);
+        }
+        else if (stage && typeof stage === "object") {
+            const s = stage;
+            if (typeof s.uniforms === "string")
+                strings.push(s.uniforms);
+            if (typeof s.body === "string")
+                strings.push(s.body);
+        }
+    }
+    return strings;
+}
+const TIME_WORD_RE = /\btime\b/i;
+const CAMERA_TEXTURE_RE = /\bcamera_texture\b/;
+const RF_VIEWPORT_RE = /\b_rf_vpw\b|\b_rf_vph\b/;
+function materialConfigNeedsTimeUniform(config) {
+    if (config.materialUniforms?.some((u) => u.name === "time"))
+        return true;
+    return collectShaderModifierStrings(config).some((s) => TIME_WORD_RE.test(s));
+}
+/**
+ * True if the shader uses _rf_vpw/_rf_vph viewport uniforms.
+ * These must be pushed via ViroMaterials.updateShaderUniform on mount and orientation change.
+ */
+function materialConfigNeedsViewportUniforms(config) {
+    return collectShaderModifierStrings(config).some((s) => RF_VIEWPORT_RE.test(s));
+}
+/**
+ * Prepends GLSL uniform declarations that the body references but the uniforms block omits.
+ * Required when shaders are authored for remote delivery without explicit sampler declarations.
+ */
+function injectMissingGlslDeclarations(uniforms, body) {
+    let result = uniforms;
+    if (CAMERA_TEXTURE_RE.test(body) && !CAMERA_TEXTURE_RE.test(result)) {
+        result =
+            "uniform sampler2D camera_texture;\nuniform highp mat4 camera_image_transform;\n" +
+                result;
+    }
+    if (RF_VIEWPORT_RE.test(body) && !/\b_rf_vpw\b/.test(result)) {
+        result = "uniform highp float _rf_vpw;\nuniform highp float _rf_vph;\n" + result;
+    }
+    return result;
+}
+/**
+ * iOS only applies `ViroMaterials.updateShaderUniform` to uniforms registered
+ * via `materialUniforms`. If a shader references `time` or viewport uniforms in
+ * GLSL only, we add the runtime binding here.
+ */
+function mergeMaterialUniformsForViro(config) {
+    const list = config.materialUniforms
+        ? config.materialUniforms.map((u) => ({ name: u.name, type: u.type, value: u.value }))
+        : [];
+    if (materialConfigNeedsTimeUniform(config) && !list.some((u) => u.name === "time")) {
+        list.push({ name: "time", type: "float", value: 0 });
+    }
+    if (materialConfigNeedsViewportUniforms(config)) {
+        if (!list.some((u) => u.name === "_rf_vpw"))
+            list.push({ name: "_rf_vpw", type: "float", value: 0 });
+        if (!list.some((u) => u.name === "_rf_vph"))
+            list.push({ name: "_rf_vph", type: "float", value: 0 });
+    }
+    return list.length > 0 ? list : undefined;
+}
+/**
+ * Studio stores modifiers as `{ uniforms, body }`; Viro works best with a single
+ * GLSL string per stage. Stages with advanced fields are kept as structured objects.
+ * Camera texture usage is detected from GLSL and auto-flagged so the Viro native
+ * layer binds the camera feed even when the DB JSON omits `requiresCameraTexture`.
+ */
+function normalizeShaderModifiersForViro(mods) {
+    const out = {};
+    for (const [key, stage] of Object.entries(mods)) {
+        if (typeof stage === "string") {
+            out[key] = stage;
+            continue;
+        }
+        if (stage && typeof stage === "object") {
+            const s = stage;
+            const uniforms = typeof s.uniforms === "string" ? s.uniforms : "";
+            const body = typeof s.body === "string" ? s.body : "";
+            // Detect camera texture usage in GLSL even when the flag is absent from DB JSON.
+            const usesCameraTexture = CAMERA_TEXTURE_RE.test(body) || CAMERA_TEXTURE_RE.test(uniforms);
+            const hasAdvanced = s.varyings != null ||
+                s.requiresSceneDepth === true ||
+                s.requiresCameraTexture === true ||
+                usesCameraTexture ||
+                s.priority != null;
+            if (hasAdvanced) {
+                if (usesCameraTexture && s.requiresCameraTexture !== true) {
+                    // Auto-fix: flag the stage and inject any missing GLSL declarations so the
+                    // native Viro layer binds camera_texture and the shader compiles cleanly.
+                    out[key] = {
+                        ...s,
+                        requiresCameraTexture: true,
+                        uniforms: injectMissingGlslDeclarations(uniforms, body),
+                    };
+                }
+                else {
+                    out[key] = stage;
+                }
+                continue;
+            }
+            const merged = [uniforms.trim(), body.trim()].filter(Boolean).join("\n");
+            out[key] = merged.length > 0 ? merged : stage;
+        }
+    }
+    return out;
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+function studioMaterialName(assetId) {
+    return `studio_${assetId}`;
+}
+/**
+ * Parses `scene_assets.material_config` JSON. Returns null if missing or invalid.
+ */
+function parseMaterialConfig(raw) {
+    if (raw == null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    try {
+        const config = {
+            lightingModel: (["Constant", "Lambert", "Blinn", "Phong", "PBR"].includes(r.lightingModel)
+                ? r.lightingModel
+                : "PBR"),
+        };
+        if (typeof r.presetName === "string")
+            config.presetName = r.presetName;
+        if (typeof r.diffuseColor === "string")
+            config.diffuseColor = r.diffuseColor;
+        if (typeof r.roughness === "number")
+            config.roughness = r.roughness;
+        if (typeof r.metalness === "number")
+            config.metalness = r.metalness;
+        if (typeof r.shininess === "number")
+            config.shininess = r.shininess;
+        if (typeof r.alpha === "number")
+            config.alpha = r.alpha;
+        if (typeof r.blendMode === "string")
+            config.blendMode = r.blendMode;
+        if (r.bloomThreshold != null && typeof r.bloomThreshold === "number")
+            config.bloomThreshold = r.bloomThreshold;
+        if (["Clamp", "Repeat", "Mirror"].includes(r.wrapS))
+            config.wrapS = r.wrapS;
+        if (["Clamp", "Repeat", "Mirror"].includes(r.wrapT))
+            config.wrapT = r.wrapT;
+        if (typeof r.transparencyMode === "string")
+            config.transparencyMode = r.transparencyMode;
+        if (typeof r.cullMode === "string")
+            config.cullMode = r.cullMode;
+        for (const key of TEXTURE_KEYS) {
+            const v = r[key];
+            if (typeof v === "string" || v === null)
+                config[key] = v;
+        }
+        if (r.shaderModifiers && typeof r.shaderModifiers === "object" && !Array.isArray(r.shaderModifiers)) {
+            config.shaderModifiers = r.shaderModifiers;
+        }
+        if (Array.isArray(r.materialUniforms)) {
+            config.materialUniforms = r.materialUniforms.filter((u) => u && typeof u.name === "string" && typeof u.type === "string");
+        }
+        return config;
+    }
+    catch (e) {
+        console.warn("[material_config] Failed to parse material_config", e);
+        return null;
+    }
+}
+/**
+ * Maps a validated Studio material_config to Viro's `createMaterials` definition shape.
+ */
+function buildViroMaterialDefinition(config) {
+    const out = { lightingModel: config.lightingModel };
+    if (config.diffuseColor !== undefined)
+        out.diffuseColor = config.diffuseColor;
+    if (config.roughness !== undefined)
+        out.roughness = config.roughness;
+    if (config.metalness !== undefined)
+        out.metalness = config.metalness;
+    if (config.shininess !== undefined)
+        out.shininess = config.shininess;
+    if (config.alpha !== undefined)
+        out.alpha = config.alpha;
+    if (config.blendMode !== undefined)
+        out.blendMode = config.blendMode;
+    if (config.bloomThreshold != undefined)
+        out.bloomThreshold = config.bloomThreshold;
+    if (config.wrapS !== undefined)
+        out.wrapS = config.wrapS;
+    if (config.wrapT !== undefined)
+        out.wrapT = config.wrapT;
+    if (config.transparencyMode !== undefined)
+        out.transparencyMode = config.transparencyMode;
+    if (config.cullMode !== undefined)
+        out.cullMode = config.cullMode;
+    for (const key of TEXTURE_KEYS) {
+        const mapped = textureToViro(config[key]);
+        if (mapped !== undefined)
+            out[key] = mapped;
+    }
+    if (config.shaderModifiers !== undefined) {
+        out.shaderModifiers = normalizeShaderModifiersForViro(config.shaderModifiers);
+    }
+    const mergedUniforms = mergeMaterialUniformsForViro(config);
+    if (mergedUniforms !== undefined)
+        out.materialUniforms = mergedUniforms;
+    return out;
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Studio physics_config and physics_world_config parsing and Viro prop building.
+ * Ported from studio-go/domain/physicsConfig.ts — no zod dependency.
+ */
+type Vec3 = [number, number, number];
+type ForceEntry = {
+    value: Vec3;
+    position?: Vec3;
+};
+type PhysicsShape = {
+    type: "Box";
+    params: [number, number, number];
+} | {
+    type: "Sphere";
+    params: [number];
+} | {
+    type: "Compound";
+    children: Array<{
+        type: "Box" | "Sphere";
+        params: number[];
+        position: Vec3;
+        rotation?: Vec3;
+    }>;
+};
+export type PhysicsBodyConfig = {
+    enabled: boolean;
+    type: "Dynamic" | "Kinematic" | "Static";
+    mass: number;
+    shape?: PhysicsShape;
+    restitution?: number;
+    friction?: number;
+    useGravity?: boolean;
+    viroTag?: string;
+    force?: ForceEntry | ForceEntry[];
+    torque?: Vec3 | Vec3[];
+    velocity?: Vec3;
+};
+export type PhysicsWorldConfig = {
+    enabled: boolean;
+    gravity: Vec3;
+    drawBounds: boolean;
+};
+export type BuildViroPhysicsBodyOptions = {
+    /** Forces Dynamic body to Kinematic with mass 0 while dragging. */
+    kinematicDragOverride?: boolean;
+};
+/**
+ * Parses `scene.physics_world_config` JSON. Returns null if missing or invalid.
+ */
+export declare function parsePhysicsWorldConfig(raw: unknown): PhysicsWorldConfig | null;
+/**
+ * Parses `asset.physics_config` JSON. Returns null if missing or invalid.
+ */
+export declare function parsePhysicsBodyConfig(raw: unknown): PhysicsBodyConfig | null;
+/** Viro `ViroARScene` physicsWorld prop. */
+export declare function buildViroPhysicsWorld(config: PhysicsWorldConfig): {
+    gravity: Vec3;
+    drawBounds?: boolean;
+};
+/** Maps validated Studio physics_config to Viro `physicsBody` prop. */
+export declare function buildViroPhysicsBody(config: PhysicsBodyConfig, options?: BuildViroPhysicsBodyOptions): Record<string, unknown>;
+/**
+ * Draggable Dynamic bodies need kinematic override during drag so the simulation
+ * doesn't fight the gesture.
+ */
+export declare function shouldUseKinematicPhysicsDrag(asset: {
+    is_draggable: boolean;
+}, config: PhysicsBodyConfig | null): boolean;
+export {};

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

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Studio physics_config and physics_world_config parsing and Viro prop building.
+ * Ported from studio-go/domain/physicsConfig.ts — no zod dependency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePhysicsWorldConfig = parsePhysicsWorldConfig;
+exports.parsePhysicsBodyConfig = parsePhysicsBodyConfig;
+exports.buildViroPhysicsWorld = buildViroPhysicsWorld;
+exports.buildViroPhysicsBody = buildViroPhysicsBody;
+exports.shouldUseKinematicPhysicsDrag = shouldUseKinematicPhysicsDrag;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function isVec3(v) {
+    return Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === "number");
+}
+function parseShape(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const r = raw;
+    if (r.type === "Box" && Array.isArray(r.params) && r.params.length === 3) {
+        return { type: "Box", params: r.params };
+    }
+    if (r.type === "Sphere" && Array.isArray(r.params) && r.params.length >= 1) {
+        return { type: "Sphere", params: [r.params[0]] };
+    }
+    if (r.type === "Compound" && Array.isArray(r.children)) {
+        const children = r.children.filter((c) => {
+            if (!c || typeof c !== "object")
+                return false;
+            const ch = c;
+            return (ch.type === "Box" || ch.type === "Sphere") && Array.isArray(ch.params) && isVec3(ch.position);
+        });
+        if (children.length > 0)
+            return { type: "Compound", children };
+    }
+    return undefined;
+}
+function mapShapeToViro(shape) {
+    if (shape.type === "Box")
+        return { type: "Box", params: [...shape.params] };
+    if (shape.type === "Sphere")
+        return { type: "Sphere", params: [...shape.params] };
+    return {
+        type: "Compound",
+        params: [],
+        children: shape.children.map((c) => {
+            const base = { type: c.type, params: [...c.params], position: [...c.position] };
+            if (c.rotation)
+                base.rotation = [...c.rotation];
+            return base;
+        }),
+    };
+}
+function normalizeTorque(torque) {
+    if (Array.isArray(torque[0])) {
+        return torque.reduce((acc, t) => [acc[0] + t[0], acc[1] + t[1], acc[2] + t[2]], [0, 0, 0]);
+    }
+    return [...torque];
+}
+function normalizeForce(force) {
+    const arr = Array.isArray(force) ? force : [force];
+    return arr.map((f) => ({
+        value: [...f.value],
+        position: f.position != null ? [...f.position] : undefined,
+    }));
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Parses `scene.physics_world_config` JSON. Returns null if missing or invalid.
+ */
+function parsePhysicsWorldConfig(raw) {
+    if (raw == null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    try {
+        return {
+            enabled: typeof r.enabled === "boolean" ? r.enabled : false,
+            gravity: isVec3(r.gravity) ? r.gravity : [0, -9.8, 0],
+            drawBounds: typeof r.drawBounds === "boolean" ? r.drawBounds : false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parses `asset.physics_config` JSON. Returns null if missing or invalid.
+ */
+function parsePhysicsBodyConfig(raw) {
+    if (raw == null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    try {
+        const type = (["Dynamic", "Kinematic", "Static"].includes(r.type)
+            ? r.type
+            : undefined);
+        if (!type)
+            return null;
+        const mass = typeof r.mass === "number" ? r.mass : 0;
+        const config = {
+            enabled: typeof r.enabled === "boolean" ? r.enabled : true,
+            type,
+            mass,
+        };
+        const shape = parseShape(r.shape);
+        if (shape)
+            config.shape = shape;
+        if (typeof r.restitution === "number")
+            config.restitution = r.restitution;
+        if (typeof r.friction === "number")
+            config.friction = r.friction;
+        if (typeof r.useGravity === "boolean")
+            config.useGravity = r.useGravity;
+        if (typeof r.viroTag === "string")
+            config.viroTag = r.viroTag;
+        if (isVec3(r.velocity))
+            config.velocity = r.velocity;
+        if (r.torque != null)
+            config.torque = r.torque;
+        if (r.force != null)
+            config.force = r.force;
+        return config;
+    }
+    catch {
+        return null;
+    }
+}
+/** Viro `ViroARScene` physicsWorld prop. */
+function buildViroPhysicsWorld(config) {
+    return {
+        gravity: [...config.gravity],
+        ...(config.drawBounds ? { drawBounds: true } : {}),
+    };
+}
+/** Maps validated Studio physics_config to Viro `physicsBody` prop. */
+function buildViroPhysicsBody(config, options) {
+    const kinematicDrag = options?.kinematicDragOverride === true && config.type === "Dynamic" && config.enabled;
+    const type = kinematicDrag ? "Kinematic" : config.type;
+    const mass = kinematicDrag ? 0 : config.mass;
+    const shape = mapShapeToViro(config.shape ?? { type: "Box", params: [1, 1, 1] });
+    const body = { type, mass, shape, enabled: config.enabled };
+    if (config.restitution !== undefined)
+        body.restitution = config.restitution;
+    if (config.friction !== undefined)
+        body.friction = config.friction;
+    if (config.useGravity !== undefined)
+        body.useGravity = kinematicDrag ? false : config.useGravity;
+    if (config.velocity !== undefined)
+        body.velocity = [...config.velocity];
+    if (config.torque !== undefined)
+        body.torque = normalizeTorque(config.torque);
+    if (config.force !== undefined)
+        body.force = normalizeForce(config.force);
+    return body;
+}
+/**
+ * Draggable Dynamic bodies need kinematic override during drag so the simulation
+ * doesn't fight the gesture.
+ */
+function shouldUseKinematicPhysicsDrag(asset, config) {
+    return (asset.is_draggable === true &&
+        config != null &&
+        config.enabled === true &&
+        config.type === "Dynamic");
+}

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

@@ -0,0 +1,12 @@
+import { StudioAnimation, StudioSceneFunction } from "../types";
+type SceneNavigator = any;
+/**
+ * Single dispatcher for all scene function types.
+ * Used by onClick, onCollision, and on_load_function triggers.
+ */
+export declare function executeFunctionWithRelations(fn: StudioSceneFunction, sceneNavigator: SceneNavigator | undefined, animations: StudioAnimation[], onAnimationTrigger?: (targetAssetId: string, animationKey: string) => void, depth?: number, onSceneChange?: (sceneId: string, sceneName: string) => void): void;
+/**
+ * Executes the scene's on_load_function if set.
+ */
+export declare function executeOnLoadFunction(functionId: string, functions: StudioSceneFunction[], sceneNavigator: SceneNavigator | undefined, animations: StudioAnimation[], onAnimationTrigger?: (targetAssetId: string, animationKey: string) => void, onSceneChange?: (sceneId: string, sceneName: string) => void): void;
+export {};