react-three-game 0.0.84 → 0.0.86

package/README.md

@@ -2,7 +2,7 @@
 
 ![Scene Editor](assets/editor.gif)
 
-JSON-first 3D game engine for React Three Fiber.
+JSON-first scene mounting and authoring for React Three Fiber.
 
 Built on top of [three.js](https://github.com/mrdoob/three.js), [@react-three/fiber](https://github.com/pmndrs/react-three-fiber), and [@react-three/rapier](https://github.com/pmndrs/react-three-rapier).
 
@@ -10,7 +10,7 @@ Built on top of [three.js](https://github.com/mrdoob/three.js), [@react-three/fi
 * **🎬 Scene Editor** - Edit prefabs visually with hierarchy, inspector, transform gizmos, and play mode.
 * **⚛️ Physics** - Author rigid bodies directly in prefab data and run them through Rapier.
 * **🧩 Components** - Build scenes from reusable `GameObject` + component composition.
-* **🔧 Runtime Scene API** - Mutate the live world through `Scene`, `Entity`, and `EntityComponent` handles.
+* **🔧 Direct Runtime Access** - Get native `Object3D`, Rapier rigid body, and prefab store access without a parallel engine API.
 * **⚡ R3F Native** - Use normal React Three Fiber components whenever runtime behavior is clearer in code.
 
 ## Documentation
@@ -98,12 +98,10 @@ Open the hosted editor here:
 
 * https://prnth.com/react-three-game/editor
 
-## Prefabs And Scenes
+## Prefabs And Mounted Scenes
 
 `Prefab` is the serializable pure data format.
 
-`Scene` is the live runtime/editor world handle.
-
 That means a saved scene is just a prefab, and the same prefab can be:
 
 * edited directly in `PrefabEditor`
@@ -113,13 +111,35 @@ That means a saved scene is just a prefab, and the same prefab can be:
 `PrefabRoot` keeps the rendering model narrow and compositional:
 
 * `Transform` is the renderer-owned outer transform
-* `Geometry` + `Material` become the primary mesh content
+* `Geometry` or `BufferGeometry` + `Material` become the primary mesh content
 * non-instanced `Model` becomes the node's primary content
 * `Physics` is a renderer-owned outer wrapper
 * every other component `View` wraps the current subtree
 
 Custom component `View`s use normal React Three Fiber composition with `children`.
 
+For agent-authored custom meshes, use `BufferGeometry` with flat numeric arrays:
+
+```json
+{
+  "id": "triangle",
+  "components": {
+    "bufferGeometry": {
+      "type": "BufferGeometry",
+      "properties": {
+        "positions": [0, 0, 0, 1, 0, 0, 0, 1, 0],
+        "indices": [0, 1, 2],
+        "computeVertexNormals": true
+      }
+    },
+    "material": {
+      "type": "Material",
+      "properties": { "color": "#ff8844" }
+    }
+  }
+}
+```
+
 ## Prefab Format
 
 ```ts
@@ -141,7 +161,7 @@ interface GameObject {
 
 ## Runtime Mutation
 
-Use the `Scene` API from `PrefabEditorRef` for authored state changes that should stay in prefab data.
+Use native object access for Three.js behavior and the prefab store for authored data changes.
 
 ```tsx
 import { useEffect, useRef } from "react";
@@ -151,48 +171,105 @@ function RaiseBall() {
   const editorRef = useRef<PrefabEditorRef>(null);
 
   useEffect(() => {
-    const transform = editorRef.current
-      ?.scene
-      .find("ball")
-      ?.getComponent<{ position: [number, number, number] }>("Transform");
-
-    transform?.set("position", [0, 8, 0]);
+    editorRef.current?.store.getState().updateNode("ball", (node) => ({
+      ...node,
+      components: {
+        ...node.components,
+        transform: {
+          type: "Transform",
+          properties: {
+            ...node.components?.transform?.properties,
+            position: [0, 8, 0],
+          },
+        },
+      },
+    }));
   }, []);
 
   return <PrefabEditor ref={editorRef} initialPrefab={prefab} />;
 }
 ```
 
-Batch related entity changes so they flush as one store revision:
+For live Three.js access, use mounted objects directly:
 
 ```tsx
-scene.batch(() => {
-  scene.find("orb1")?.getComponent("Transform")?.set("position", [1, 0, 0]);
-  scene.find("orb2")?.getComponent("Transform")?.set("position", [-1, 0, 0]);
-});
+const ball = editorRef.current?.getObject("ball");
+ball?.rotateY(0.5);
 ```
 
-Define a component runtime factory with `create(ctx)` for hot runtime behavior that mutates the live Three.js object directly:
+Mounted node metadata is mirrored onto the canonical Three.js wrapper object:
+
+* `GameObject.id` -> `object.userData.prefabNodeId`
+* `GameObject.name` -> `object.name` and `object.userData.prefabNodeName`
+* `Data.properties.data` -> merged into `object.userData`
+
+That gives you a stable authored id for traversal-based integrations, while still making Three.js name lookup convenient:
 
 ```tsx
-import type { Component } from "react-three-game";
-
-const Rotator: Component = {
-  name: "Rotator",
-  Editor: () => null,
-  defaultProperties: { speed: 1 },
-  create(ctx) {
-    return {
-      update(dt) {
-        const speed = ctx.component.get<number>("speed") ?? 1;
-        ctx.object.rotation.y += dt * speed;
+const playerByName = editorRef.current?.root?.getObjectByName("Player");
+const playerById = editorRef.current?.root?.getObjectByProperty("userData.prefabNodeId", "player");
+```
+
+Treat names as a convenience surface, not the primary lookup key:
+
+* names are not guaranteed unique
+* `getObject(id)` is still the stable authored-node lookup
+* traversal metadata is applied to the prefab node transform object, not necessarily the inner mesh or model child
+
+You can author extra `userData` from the editor with a `Data` component:
+
+```json
+{
+  "data": {
+    "faction": "enemy",
+    "health": 100,
+    "loot": { "table": "crate" }
+  }
+}
+```
+
+For batched authored updates, write through the store once:
+
+```tsx
+editorRef.current?.store.getState().updateNodes([
+  {
+    id: "orb1",
+    update: (node) => ({
+      ...node,
+      components: {
+        ...node.components,
+        transform: {
+          ...node.components?.transform,
+          type: "Transform",
+          properties: {
+            ...node.components?.transform?.properties,
+            position: [1, 0, 0],
+          },
+        },
       },
-    };
+    }),
   },
-};
+  {
+    id: "orb2",
+    update: (node) => ({
+      ...node,
+      components: {
+        ...node.components,
+        transform: {
+          ...node.components?.transform,
+          type: "Transform",
+          properties: {
+            ...node.components?.transform?.properties,
+            position: [-1, 0, 0],
+          },
+        },
+      },
+    }),
+  },
+]);
 ```
 
-`View` handles composition and rendering. `create(ctx)` handles imperative runtime behavior.
+Custom component `View`s should use normal React and R3F behavior, such as `useFrame`, refs, and native Three.js APIs.
 
 ## Useful Exports
 
@@ -202,9 +279,6 @@ const Rotator: Component = {
 * `PrefabEditorMode`
 * `Prefab`
 * `GameObject`
-* `Scene`
-* `Entity`
-* `EntityComponent`
 * `registerComponent`
 * `createPrefabStore`
 * `usePrefabStoreApi`

package/dist/index.d.ts

@@ -10,7 +10,6 @@ export { useEditorContext } from './tools/prefabeditor/PrefabEditor';
 export type { EditorContextType } from './tools/prefabeditor/PrefabEditor';
 export { createPrefabStore, prefabStoreToPrefab, usePrefabStoreApi } from './tools/prefabeditor/prefabStore';
 export type { PrefabStoreApi, PrefabStoreState } from './tools/prefabeditor/prefabStore';
-export { createScene } from './tools/prefabeditor/scene';
 export { denormalizePrefab } from './tools/prefabeditor/prefab';
 export { registerComponent } from './tools/prefabeditor/components/ComponentRegistry';
 export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Field, NumberField, ColorInput, ColorField, StringInput, StringField, BooleanInput, BooleanField, SelectInput, SelectField, } from './tools/prefabeditor/components/Input';
@@ -18,11 +17,10 @@ export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computePar
 export type { ExportGLBOptions } from './tools/prefabeditor/utils';
 export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
 export type { PrefabEditorProps, PrefabEditorRef, } from './tools/prefabeditor/PrefabEditor';
-export type { SpawnOptions, Scene, Entity, EntityComponent, EntityData, EntityUpdate, PropertyPath, SceneUpdates, } from './tools/prefabeditor/scene';
+export type { SpawnOptions, } from './tools/prefabeditor/scene';
 export type { PrefabRootProps } from './tools/prefabeditor/PrefabRoot';
-export type { AssetRuntime, EntityRuntime, LiveObjectRef, LiveRigidBodyRef } from './tools/prefabeditor/runtime';
-export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/runtime';
-export type { ComponentInstance, ComponentRuntimeContext } from './tools/prefabeditor/runtime';
+export type { AssetRuntime, EntityRuntime, LiveObjectRef, LiveRigidBodyRef } from './tools/prefabeditor/assetRuntime';
+export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/assetRuntime';
 export type { Component, ComponentViewProps } from './tools/prefabeditor/components/ComponentRegistry';
 export type { FieldDefinition, FieldType } from './tools/prefabeditor/components/Input';
 export { MaterialOverridesProvider, useMaterialOverrides } from './tools/prefabeditor/components/MaterialComponent';
@@ -30,8 +28,6 @@ export type { MaterialOverrides } from './tools/prefabeditor/components/Material
 export type { Prefab, GameObject, ComponentData } from './tools/prefabeditor/types';
 export { findComponent, findComponentEntry, hasComponent } from './tools/prefabeditor/types';
 export { float, positionLocal, sin, time, uniform, vec3, } from 'three/tsl';
-export { gameEvents, useGameEvent, usePhysicsEvent, useClickEvent, getEntityIdFromRigidBody } from './tools/prefabeditor/GameEvents';
-export type { GameEventType, GameEventMap, GameEventPayload, PhysicsEventType, InteractionEventType, PhysicsEventPayload, ClickEventPayload } from './tools/prefabeditor/GameEvents';
 export { loadFiles } from './tools/dragdrop/DragDropLoader';
 export type { AssetLoadOptions } from './tools/dragdrop/DragDropLoader';
 export { loadModel, loadSound, loadTexture } from './tools/dragdrop/modelLoader';

package/dist/index.js

@@ -10,7 +10,6 @@ export { default as PrefabRoot } from './tools/prefabeditor/PrefabRoot';
 export { useEditorContext } from './tools/prefabeditor/PrefabEditor';
 // Prefab Editor - Store & Scene API
 export { createPrefabStore, prefabStoreToPrefab, usePrefabStoreApi } from './tools/prefabeditor/prefabStore';
-export { createScene } from './tools/prefabeditor/scene';
 export { denormalizePrefab } from './tools/prefabeditor/prefab';
 // Prefab Editor - Component Registry
 export { registerComponent } from './tools/prefabeditor/components/ComponentRegistry';
@@ -19,12 +18,10 @@ export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Fiel
 // Prefab Editor - Utils
 export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
 export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
-export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/runtime';
+export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/assetRuntime';
 export { MaterialOverridesProvider, useMaterialOverrides } from './tools/prefabeditor/components/MaterialComponent';
 export { findComponent, findComponentEntry, hasComponent } from './tools/prefabeditor/types';
 export { float, positionLocal, sin, time, uniform, vec3, } from 'three/tsl';
-// Game Events (physics + custom events)
-export { gameEvents, useGameEvent, usePhysicsEvent, useClickEvent, getEntityIdFromRigidBody } from './tools/prefabeditor/GameEvents';
 // Asset Loading
 export { loadFiles } from './tools/dragdrop/DragDropLoader';
 export { loadModel, loadSound, loadTexture } from './tools/dragdrop/modelLoader';

package/dist/tools/prefabeditor/InstanceProvider.d.ts

@@ -12,8 +12,6 @@ export declare function getRepeatAxesFromModelProperties(properties: Record<stri
 export type InstanceData = {
     id: string;
     sourceId: string;
-    clickable?: boolean;
-    clickEventName?: string;
     locked?: boolean;
     position: [number, number, number];
     rotation: [number, number, number];
@@ -35,8 +33,6 @@ export declare function useInstanceCheck(id: string): boolean;
 export declare const GameInstance: React.ForwardRefExoticComponent<{
     id: string;
     sourceId?: string;
-    clickable?: boolean;
-    clickEventName?: string;
     modelUrl: string;
     locked?: boolean;
     position: [number, number, number];

package/dist/tools/prefabeditor/InstanceProvider.js

@@ -15,8 +15,7 @@ import { Merged, useHelper } from '@react-three/drei';
 import { InstancedRigidBodies } from "@react-three/rapier";
 import { ActiveCollisionTypes } from "@dimforge/rapier3d-compat";
 import { Mesh, Matrix4, Vector3, Quaternion, Euler, BoxHelper } from "three";
-import { gameEvents, getEntityIdFromRigidBody } from "./GameEvents";
-import { useClickValid } from "./useClickValid";
+import { usePointerEvents } from "./usePointerEvents";
 export const DEFAULT_REPEAT_AXES = [{ axis: 'x', count: 1, offset: 1 }];
 export function normalizeRepeatAxes(value) {
     if (!Array.isArray(value)) {
@@ -103,32 +102,9 @@ function hasPhysics(instance) {
 function getColliderType(physics) {
     return physics.colliders || (physics.type === 'fixed' ? 'trimesh' : 'hull');
 }
-function emitPhysicsEvent(sourceId, eventName, payload) {
-    if (!eventName)
-        return;
-    gameEvents.emit(eventName, {
-        sourceEntityId: sourceId,
-        targetEntityId: getEntityIdFromRigidBody(payload.other.rigidBody),
-        targetRigidBody: payload.other.rigidBody,
-    });
-}
-function emitClick(sourceId, instanceId, eventName, event) {
-    gameEvents.emit(eventName, {
-        sourceEntityId: sourceId,
-        instanceEntityId: instanceId && instanceId !== sourceId ? instanceId : undefined,
-        point: [event.point.x, event.point.y, event.point.z],
-        button: event.button,
-        altKey: event.nativeEvent.altKey,
-        ctrlKey: event.nativeEvent.ctrlKey,
-        metaKey: event.nativeEvent.metaKey,
-        shiftKey: event.nativeEvent.shiftKey,
-    });
-}
 function instanceEquals(a, b) {
     return a.id === b.id &&
         a.sourceId === b.sourceId &&
-        a.clickable === b.clickable &&
-        a.clickEventName === b.clickEventName &&
         a.locked === b.locked &&
         a.meshPath === b.meshPath &&
         arrayEquals(a.position, b.position) &&
@@ -245,7 +221,7 @@ function InstancedRigidGroup({ group, modelKey, partCount, flatMeshes, onSelect,
     const rigidBodiesRef = useRef(null);
     const instances = useMemo(() => group.instances.filter(hasPhysics).map(inst => {
         const _a = inst.physics, { activeCollisionTypes: _activeCollisionTypes, colliders: _colliders, userData } = _a, rigidBodyProps = __rest(_a, ["activeCollisionTypes", "colliders", "userData"]);
-        return Object.assign(Object.assign({ key: inst.id, position: inst.position, rotation: inst.rotation, scale: inst.scale }, rigidBodyProps), { colliders: getColliderType(inst.physics), userData: Object.assign(Object.assign({}, userData), { entityId: inst.sourceId }), onIntersectionEnter: (payload) => emitPhysicsEvent(inst.sourceId, inst.physics.sensorEnterEventName, payload), onIntersectionExit: (payload) => emitPhysicsEvent(inst.sourceId, inst.physics.sensorExitEventName, payload), onCollisionEnter: (payload) => emitPhysicsEvent(inst.sourceId, inst.physics.collisionEnterEventName, payload), onCollisionExit: (payload) => emitPhysicsEvent(inst.sourceId, inst.physics.collisionExitEventName, payload) });
+        return Object.assign(Object.assign({ key: inst.id, position: inst.position, rotation: inst.rotation, scale: inst.scale }, rigidBodyProps), { colliders: getColliderType(inst.physics), userData: Object.assign(Object.assign({}, userData), { entityId: inst.sourceId }) });
     }), [group.instances]);
     // Apply scale to visual meshes (InstancedRigidBodies only scales colliders, not visuals)
     useEffect(() => {
@@ -317,12 +293,8 @@ function InstancedRigidGroup({ group, modelKey, partCount, flatMeshes, onSelect,
             onSelect(instance.sourceId);
             return;
         }
-        if (!instance.clickable)
-            return;
-        e.stopPropagation();
-        emitClick(instance.sourceId, instance.id, instance.clickEventName || 'click', e);
     };
-    const shouldHandleClick = editMode || group.instances.some(inst => inst.clickable);
+    const shouldHandleClick = editMode;
     // Add key to force remount when instance count changes significantly (helps with cleanup)
     const rigidBodyKey = `rb_${modelKey}_${group.instances.map(inst => `${inst.id}:${getPhysicsSignature(inst.physics)}`).join('|')}`;
     return (_jsx(InstancedRigidBodies, { ref: rigidBodiesRef, instances: instances, children: Array.from({ length: partCount }).map((_, i) => {
@@ -344,14 +316,15 @@ function InstanceGroupItem({ instance, InstanceComponents, onSelect, registerRef
     const isLocked = Boolean(instance.locked);
     const isSelected = selectedId === instance.id || selectedId === instance.sourceId;
     const canSelect = editMode && !isLocked;
-    const canClick = !editMode && Boolean(instance.clickable);
-    const pointerHandlers = useClickValid(canSelect || canClick, (e) => {
-        if (editMode) {
-            onSelect === null || onSelect === void 0 ? void 0 : onSelect(instance.sourceId);
-        }
-        else if (instance.clickable) {
-            emitClick(instance.sourceId, instance.id, instance.clickEventName || 'click', e);
-        }
+    const canClick = false;
+    const pointerHandlers = usePointerEvents({
+        enabled: canSelect || canClick,
+        entity: instance,
+        onClick: () => {
+            if (editMode) {
+                onSelect === null || onSelect === void 0 ? void 0 : onSelect(instance.sourceId);
+            }
+        },
     });
     // Use BoxHelper when object is selected in edit mode
     useHelper(editMode && isSelected ? groupRef : null, BoxHelper, 'cyan');
@@ -370,7 +343,7 @@ export function useInstanceCheck(id) {
     return (_a = ctx === null || ctx === void 0 ? void 0 : ctx.hasInstance(id)) !== null && _a !== void 0 ? _a : false;
 }
 // GameInstance component: registers an instance for batch rendering (renders nothing itself)
-export const GameInstance = React.forwardRef(({ id, sourceId, clickable = false, clickEventName, modelUrl, locked = false, position, rotation, scale, physics = undefined, }, ref) => {
+export const GameInstance = React.forwardRef(({ id, sourceId, modelUrl, locked = false, position, rotation, scale, physics = undefined, }, ref) => {
     const ctx = useContext(GameInstanceContext);
     const addInstance = ctx === null || ctx === void 0 ? void 0 : ctx.addInstance;
     const removeInstance = ctx === null || ctx === void 0 ? void 0 : ctx.removeInstance;
@@ -381,8 +354,6 @@ export const GameInstance = React.forwardRef(({ id, sourceId, clickable = false,
     const instance = useMemo(() => ({
         id,
         sourceId: sourceId !== null && sourceId !== void 0 ? sourceId : id,
-        clickable,
-        clickEventName,
         locked,
         meshPath: modelUrl,
         position,
@@ -392,8 +363,6 @@ export const GameInstance = React.forwardRef(({ id, sourceId, clickable = false,
     }), [
         id,
         sourceId,
-        clickable,
-        clickEventName,
         locked,
         modelUrl,
         positionX,

package/dist/tools/prefabeditor/PrefabEditor.d.ts

@@ -2,18 +2,23 @@ import GameCanvas from "../../shared/GameCanvas";
 import { Object3D, Texture } from "three";
 import { GameObject, Prefab } from "./types";
 import type { ExportGLBOptions } from "./utils";
-import { type Scene, type SpawnOptions } from "./scene";
+import { type PrefabStoreApi } from "./prefabStore";
+import type { SpawnOptions } from "./scene";
 export interface PrefabEditorRef {
+    root: Object3D | null;
+    store: PrefabStoreApi;
+    getObject: (nodeId: string) => Object3D | null;
+    getRigidBody: (nodeId: string) => any;
     screenshot: () => void;
     exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;
     exportGLBData: () => Promise<ArrayBuffer | undefined>;
     clearSelection: () => Promise<void>;
     save: () => Prefab;
-    scene: Scene;
     load: (prefab: Prefab, options?: {
         resetHistory?: boolean;
         notifyChange?: boolean;
     }) => void;
+    addNode: (node: GameObject, options?: SpawnOptions) => GameObject;
     addModel: (path: string, model: Object3D, options?: SpawnOptions) => GameObject;
     addTexture: (path: string, texture: Texture, options?: SpawnOptions) => GameObject;
 }

package/dist/tools/prefabeditor/PrefabEditor.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { MapControls, TransformControls } from "@react-three/drei";
 import GameCanvas from "../../shared/GameCanvas";
-import { useCallback, useEffect, useMemo, useReducer, useRef, useState, forwardRef, useImperativeHandle, createContext, useContext } from "react";
+import { useCallback, useEffect, useReducer, useRef, useState, forwardRef, useImperativeHandle, createContext, useContext } from "react";
 import { findComponentEntry } from "./types";
 import PrefabRoot from "./PrefabRoot";
 import { Physics } from "@react-three/rapier";
@@ -20,7 +20,6 @@ import { computeParentWorldMatrix, decompose, exportGLB as exportGLBFile, export
 import { loadFiles } from "../dragdrop";
 import { denormalizePrefab, createImageNode, createModelNode, createNode } from './prefab';
 import { createPrefabStore, PrefabStoreProvider } from "./prefabStore";
-import { createScene } from "./scene";
 function isObjectAttachedToRoot(root, object) {
     if (!root || !object)
         return false;
@@ -53,7 +52,6 @@ const DEFAULT_PREFAB = {
     root: createNode('Root', {}, { id: 'root' })
 };
 const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode: initialMode = PrefabEditorMode.Edit, onChange, showUI = true, enableWindowDrop = true, canvasProps, uiPlugins, children }, ref) => {
-    var _a, _b;
     const [mode, setMode] = useState(initialMode);
     const [selectedId, setSelectedId] = useState(null);
     const [transformMode, setTransformMode] = useState("translate");
@@ -73,6 +71,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
     const onChangeRef = useRef(onChange);
     const isEditMode = mode === PrefabEditorMode.Edit;
     const getPrefab = useCallback(() => denormalizePrefab(prefabStore.getState()), [prefabStore]);
+    const getRootObject = useCallback(() => { var _a, _b; return (_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.root) !== null && _b !== void 0 ? _b : null; }, []);
     const getObject = useCallback((nodeId) => { var _a, _b; return (_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.getObject(nodeId)) !== null && _b !== void 0 ? _b : null; }, []);
     const getRigidBody = useCallback((nodeId) => { var _a, _b; return (_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.getRigidBody(nodeId)) !== null && _b !== void 0 ? _b : null; }, []);
     const handleObjectRefChange = useCallback((nodeId) => {
@@ -173,7 +172,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         return () => unsubscribe();
     }, [prefabStore, selectedId]);
     const selectedObject = selectedId ? getObject(selectedId) : null;
-    const transformObject = isObjectAttachedToRoot((_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.root) !== null && _b !== void 0 ? _b : null, selectedObject)
+    const transformObject = isObjectAttachedToRoot(getRootObject(), selectedObject)
         ? selectedObject
         : null;
     const addNode = useCallback((node, options) => {
@@ -251,21 +250,19 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         });
     }), [setSelection]);
     const handleExportGLB = useCallback((...args_1) => __awaiter(void 0, [...args_1], void 0, function* (options = {}) {
-        var _a;
         yield clearSelection();
-        const rootObject = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.root;
+        const rootObject = getRootObject();
         if (!rootObject)
             return;
         return exportGLBFile(rootObject, Object.assign({ filename: `${prefabStore.getState().prefabName || 'prefab'}.glb` }, options));
-    }), [clearSelection, prefabStore]);
+    }), [clearSelection, getRootObject, prefabStore]);
     const handleExportGLBData = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
         yield clearSelection();
-        const rootObject = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.root;
+        const rootObject = getRootObject();
         if (!rootObject)
             return;
         return exportGLBData(rootObject);
-    }), [clearSelection]);
+    }), [clearSelection, getRootObject]);
     const handleFocusNode = useCallback((nodeId) => {
         const object = getObject(nodeId);
         const controls = controlsRef.current;
@@ -274,18 +271,6 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
             return;
         focusCameraOnObject(object, camera, controls.target, () => { var _a; return (_a = controls.update) === null || _a === void 0 ? void 0 : _a.call(controls); });
     }, [getObject]);
-    const scene = useMemo(() => createScene({
-        getRootId: () => prefabStore.getState().rootId,
-        getNode: (id) => { var _a; return (_a = prefabStore.getState().nodesById[id]) !== null && _a !== void 0 ? _a : null; },
-        getChildIds: (id) => { var _a; return (_a = prefabStore.getState().childIdsById[id]) !== null && _a !== void 0 ? _a : []; },
-        getParentId: (id) => { var _a; return (_a = prefabStore.getState().parentIdById[id]) !== null && _a !== void 0 ? _a : null; },
-        updateNode: (id, update) => prefabStore.getState().updateNode(id, update),
-        updateNodes: (updates) => prefabStore.getState().updateNodes(Object.entries(updates).map(([id, update]) => ({ id, update }))),
-        addNode: (node, options) => addNode(node, options).id,
-        removeNode: (id) => prefabStore.getState().deleteNode(id),
-        getObject,
-        getRigidBody,
-    }), [addNode, getObject, getRigidBody, prefabStore]);
     const handleTransformChange = () => {
         if (!selectedId)
             return;
@@ -342,16 +327,20 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         };
     }, [addModel, addTexture, isEditMode, enableWindowDrop]);
     useImperativeHandle(ref, () => ({
+        root: getRootObject(),
+        store: prefabStore,
+        getObject,
+        getRigidBody,
         screenshot: handleScreenshot,
         exportGLB: handleExportGLB,
         exportGLBData: handleExportGLBData,
         clearSelection,
         save: getPrefab,
-        scene,
         load: loadPrefab,
+        addNode,
         addModel,
         addTexture
-    }), [addModel, addTexture, clearSelection, getPrefab, handleExportGLB, handleExportGLBData, handleScreenshot, loadPrefab, scene]);
+    }), [addModel, addNode, addTexture, clearSelection, getObject, getPrefab, getRigidBody, getRootObject, handleExportGLB, handleExportGLBData, handleScreenshot, loadPrefab, prefabStore]);
     const content = (_jsxs(_Fragment, { children: [isEditMode ? _jsx("gridHelper", { args: [10, 10], position: [0, -1, 0] }) : null, _jsx(PrefabRoot, { ref: prefabRootRef, store: prefabStore, editMode: isEditMode, selectedId: selectedId, onSelect: setSelection, onObjectRefChange: handleObjectRefChange, basePath: basePath }), children] }));
     const handleCanvasCreated = useCallback((state) => {
         var _a;