react-three-game 0.0.92 → 0.0.93

package/dist/tools/prefabeditor/InstanceProvider.js

@@ -1,20 +1,9 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React, { createContext, useContext, useMemo, useRef, useState, useEffect, useCallback } from "react";
+import React, { createContext, useContext, useMemo, useRef, useState, useEffect } from "react";
 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 { Mesh, Matrix4, BoxHelper } from "three";
+import { useStore } from "zustand";
+import { createStore } from "zustand/vanilla";
 import { usePointerEvents } from "./usePointerEvents";
 export const DEFAULT_REPEAT_AXES = [{ axis: 'x', count: 1, offset: 1 }];
 export function normalizeRepeatAxes(value) {
@@ -81,66 +70,67 @@ function arrayEquals(a, b) {
     }
     return true;
 }
-function stableSerialize(value) {
-    if (Array.isArray(value)) {
-        return `[${value.map(stableSerialize).join(',')}]`;
-    }
-    if (value && typeof value === 'object') {
-        const entries = Object.entries(value)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([key, entry]) => `${key}:${stableSerialize(entry)}`);
-        return `{${entries.join(',')}}`;
-    }
-    return JSON.stringify(value);
-}
-function getPhysicsSignature(physics) {
-    return physics ? stableSerialize(physics) : 'none';
-}
-function hasPhysics(instance) {
-    return Boolean(instance.physics);
-}
-function getColliderType(physics) {
-    return physics.colliders || (physics.type === 'fixed' ? 'trimesh' : 'hull');
-}
 function instanceEquals(a, b) {
     return a.id === b.id &&
         a.sourceId === b.sourceId &&
         a.locked === b.locked &&
+        a.visible === b.visible &&
         a.meshPath === b.meshPath &&
         arrayEquals(a.position, b.position) &&
         arrayEquals(a.rotation, b.rotation) &&
-        arrayEquals(a.scale, b.scale) &&
-        getPhysicsSignature(a.physics) === getPhysicsSignature(b.physics);
+        arrayEquals(a.scale, b.scale);
 }
-const GameInstanceContext = createContext(null);
-export function GameInstanceProvider({ children, models, onSelect, registerRef, selectedId, editMode }) {
-    const [instances, setInstances] = useState([]);
-    const addInstance = useCallback((instance) => {
-        setInstances(prev => {
-            const idx = prev.findIndex(i => i.id === instance.id);
-            if (idx !== -1) {
-                // Update existing if changed
-                if (instanceEquals(prev[idx], instance)) {
-                    return prev;
-                }
-                const copy = [...prev];
-                copy[idx] = instance;
-                return copy;
+function createInstanceRegistryStore() {
+    return createStore()((set, get) => ({
+        instancesById: {},
+        sourceInstanceIdsById: {},
+        addInstance: (instance) => {
+            const previous = get().instancesById[instance.id];
+            if (previous && instanceEquals(previous, instance)) {
+                return;
             }
-            // Add new
-            return [...prev, instance];
-        });
-    }, []);
-    const removeInstance = useCallback((id) => {
-        setInstances(prev => {
-            if (!prev.find(i => i.id === id))
-                return prev;
-            return prev.filter(i => i.id !== id);
-        });
-    }, []);
-    const hasInstance = useCallback((id) => {
-        return instances.some(i => i.id === id || i.sourceId === id);
-    }, [instances]);
+            set(state => {
+                var _a, _b;
+                const instancesById = Object.assign(Object.assign({}, state.instancesById), { [instance.id]: instance });
+                const sourceInstanceIdsById = Object.assign({}, state.sourceInstanceIdsById);
+                if (previous && previous.sourceId !== previous.id) {
+                    const previousSourceInstances = Object.assign({}, ((_a = sourceInstanceIdsById[previous.sourceId]) !== null && _a !== void 0 ? _a : {}));
+                    delete previousSourceInstances[previous.id];
+                    sourceInstanceIdsById[previous.sourceId] = Object.keys(previousSourceInstances).length > 0
+                        ? previousSourceInstances
+                        : undefined;
+                }
+                if (instance.sourceId !== instance.id) {
+                    sourceInstanceIdsById[instance.sourceId] = Object.assign(Object.assign({}, ((_b = sourceInstanceIdsById[instance.sourceId]) !== null && _b !== void 0 ? _b : {})), { [instance.id]: true });
+                }
+                return { instancesById, sourceInstanceIdsById };
+            });
+        },
+        removeInstance: (id) => {
+            const previous = get().instancesById[id];
+            if (!previous)
+                return;
+            set(state => {
+                var _a;
+                const instancesById = Object.assign({}, state.instancesById);
+                const sourceInstanceIdsById = Object.assign({}, state.sourceInstanceIdsById);
+                delete instancesById[id];
+                if (previous.sourceId !== previous.id) {
+                    const sourceInstances = Object.assign({}, ((_a = sourceInstanceIdsById[previous.sourceId]) !== null && _a !== void 0 ? _a : {}));
+                    delete sourceInstances[id];
+                    sourceInstanceIdsById[previous.sourceId] = Object.keys(sourceInstances).length > 0
+                        ? sourceInstances
+                        : undefined;
+                }
+                return { instancesById, sourceInstanceIdsById };
+            });
+        },
+    }));
+}
+const GameInstanceContext = createContext(null);
+export function GameInstanceProvider({ children, models, onSelect, onClick, registerRef, selectedId, editMode }) {
+    const [instanceStore] = useState(createInstanceRegistryStore);
+    const instancesById = useStore(instanceStore, state => state.instancesById);
     // Flatten all model meshes once (models → flat mesh parts)
     // Note: Geometry is cloned with baked transforms for instancing
     const { flatMeshes, modelParts } = useMemo(() => {
@@ -170,13 +160,14 @@ export function GameInstanceProvider({ children, models, onSelect, registerRef,
             Object.values(flatMeshes).forEach(mesh => mesh.geometry.dispose());
         };
     }, [flatMeshes]);
-    // Group instances by meshPath and physics presence for batch rendering.
+    const instances = useMemo(() => Object.values(instancesById), [instancesById]);
+    // Group instances by meshPath for batched rendering.
     const grouped = useMemo(() => {
         const groups = {};
         for (const inst of instances) {
-            const key = `${inst.meshPath}__${inst.physics ? 'physics' : 'visual'}`;
+            const key = inst.meshPath;
             if (!groups[key])
-                groups[key] = { hasPhysics: Boolean(inst.physics), instances: [] };
+                groups[key] = { instances: [] };
             groups[key].instances.push(inst);
         }
         Object.values(groups).forEach(group => {
@@ -184,146 +175,45 @@ export function GameInstanceProvider({ children, models, onSelect, registerRef,
         });
         return groups;
     }, [instances]);
-    return (_jsxs(GameInstanceContext.Provider, { value: {
-            addInstance,
-            removeInstance,
-            instances,
-            meshes: flatMeshes,
-            modelParts,
-            hasInstance
-        }, children: [children, Object.entries(grouped).map(([key, group]) => {
-                if (!group.hasPhysics)
-                    return null;
+    const contextValue = useMemo(() => ({
+        store: instanceStore,
+        meshes: flatMeshes,
+        modelParts,
+    }), [instanceStore, flatMeshes, modelParts]);
+    return (_jsxs(GameInstanceContext.Provider, { value: contextValue, children: [children, Object.entries(grouped).map(([key, group]) => {
                 const modelKey = group.instances[0].meshPath;
                 const partCount = modelParts[modelKey] || 0;
                 if (partCount === 0)
                     return null;
-                return (_jsx(InstancedRigidGroup, { group: group, modelKey: modelKey, partCount: partCount, flatMeshes: flatMeshes, onSelect: onSelect, editMode: editMode }, key));
-            }), Object.entries(grouped).map(([key, group]) => {
-                if (group.hasPhysics)
-                    return null;
-                const modelKey = group.instances[0].meshPath;
-                const partCount = modelParts[modelKey] || 0;
-                if (partCount === 0)
-                    return null;
-                // Create mesh subset for this specific model
                 const meshesForModel = {};
                 for (let i = 0; i < partCount; i++) {
                     const partKey = `${modelKey}__${i}`;
                     meshesForModel[partKey] = flatMeshes[partKey];
                 }
-                return (_jsx(Merged, { meshes: meshesForModel, castShadow: true, receiveShadow: true, children: (instancesMap) => (_jsx(NonPhysicsInstancedGroup, { modelKey: modelKey, group: group, partCount: partCount, instancesMap: instancesMap, onSelect: onSelect, registerRef: registerRef, selectedId: selectedId, editMode: editMode })) }, key));
+                return (_jsx(Merged, { meshes: meshesForModel, castShadow: true, receiveShadow: true, children: (instancesMap) => (_jsx(InstancedGroup, { modelKey: modelKey, group: group, partCount: partCount, instancesMap: instancesMap, onSelect: onSelect, onClick: onClick, registerRef: registerRef, selectedId: selectedId, editMode: editMode })) }, key));
             })] }));
 }
-// Render physics-enabled instances using InstancedRigidBodies
-function InstancedRigidGroup({ group, modelKey, partCount, flatMeshes, onSelect, editMode }) {
-    const meshRefs = useRef([]);
-    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 }) });
-    }), [group.instances]);
-    // Apply scale to visual meshes (InstancedRigidBodies only scales colliders, not visuals)
-    useEffect(() => {
-        const matrix = new Matrix4();
-        const pos = new Vector3();
-        const quat = new Quaternion();
-        const euler = new Euler();
-        const scl = new Vector3();
-        meshRefs.current.forEach(mesh => {
-            if (!mesh)
-                return;
-            group.instances.forEach((inst, i) => {
-                pos.set(...inst.position);
-                euler.set(...inst.rotation);
-                quat.setFromEuler(euler);
-                scl.set(...inst.scale);
-                matrix.compose(pos, quat, scl);
-                mesh.setMatrixAt(i, matrix);
-            });
-            mesh.instanceMatrix.needsUpdate = true;
-        });
-        // Update rigid body positions when instances change
-        if (rigidBodiesRef.current) {
-            try {
-                group.instances.forEach((inst, i) => {
-                    var _a;
-                    const body = (_a = rigidBodiesRef.current) === null || _a === void 0 ? void 0 : _a[i];
-                    if (body && body.setTranslation && body.setRotation) {
-                        pos.set(...inst.position);
-                        euler.set(...inst.rotation);
-                        quat.setFromEuler(euler);
-                        body.setTranslation(pos, false);
-                        body.setRotation(quat, false);
-                    }
-                });
-            }
-            catch (error) {
-                // Ignore errors when switching between instanced/non-instanced states
-                console.warn('Failed to update rigidbody positions:', error);
-            }
-        }
-    }, [group.instances]);
-    useEffect(() => {
-        group.instances.forEach((inst, i) => {
-            var _a, _b;
-            if (!inst.physics || inst.physics.activeCollisionTypes !== 'all')
-                return;
-            const body = (_a = rigidBodiesRef.current) === null || _a === void 0 ? void 0 : _a[i];
-            if (!body || !body.numColliders || !body.collider)
-                return;
-            for (let colliderIndex = 0; colliderIndex < body.numColliders(); colliderIndex++) {
-                const collider = body.collider(colliderIndex);
-                (_b = collider.setActiveCollisionTypes) === null || _b === void 0 ? void 0 : _b.call(collider, ActiveCollisionTypes.DEFAULT |
-                    ActiveCollisionTypes.KINEMATIC_FIXED |
-                    ActiveCollisionTypes.KINEMATIC_KINEMATIC);
-            }
-        });
-    }, [group.instances]);
-    // Handle click on instanced mesh in edit mode
-    const handleClick = (e) => {
-        const instanceId = e.instanceId;
-        const instance = instanceId !== undefined ? group.instances[instanceId] : undefined;
-        if (!instance)
-            return;
-        if (editMode) {
-            if (!onSelect || instance.locked)
-                return;
-            e.stopPropagation();
-            onSelect(instance.sourceId);
-            return;
-        }
-    };
-    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) => {
-            const mesh = flatMeshes[`${modelKey}__${i}`];
-            if (!mesh)
-                return null;
-            return (_jsx("instancedMesh", { ref: el => { meshRefs.current[i] = el; }, args: [mesh.geometry, mesh.material, group.instances.length], castShadow: true, receiveShadow: true, frustumCulled: false, onClick: shouldHandleClick ? handleClick : undefined }, i));
-        }) }, rigidBodyKey));
-}
-// Render non-physics instances using Merged (instancing without rigid bodies)
-function NonPhysicsInstancedGroup({ modelKey, group, partCount, instancesMap, onSelect, registerRef, selectedId, editMode }) {
-    // Pre-compute which Instance components exist for this model
+function InstancedGroup({ modelKey, group, partCount, instancesMap, onSelect, onClick, registerRef, selectedId, editMode }) {
     const InstanceComponents = useMemo(() => Array.from({ length: partCount }, (_, i) => instancesMap[`${modelKey}__${i}`]).filter(Boolean), [instancesMap, modelKey, partCount]);
-    return (_jsx(_Fragment, { children: group.instances.map(inst => (_jsx(InstanceGroupItem, { instance: inst, InstanceComponents: InstanceComponents, onSelect: onSelect, registerRef: registerRef, selectedId: selectedId, editMode: editMode }, inst.id))) }));
+    const visibleInstances = useMemo(() => group.instances.filter(instance => instance.visible !== false), [group.instances]);
+    return (_jsx(_Fragment, { children: visibleInstances.map(inst => (_jsx(InstanceGroupItem, { instance: inst, InstanceComponents: InstanceComponents, onSelect: onSelect, onClick: onClick, registerRef: registerRef, selectedId: selectedId, editMode: editMode }, inst.id))) }));
 }
 // Individual instance item with its own click state
-function InstanceGroupItem({ instance, InstanceComponents, onSelect, registerRef, selectedId, editMode }) {
+function InstanceGroupItem({ instance, InstanceComponents, onSelect, onClick, registerRef, selectedId, editMode }) {
     const groupRef = useRef(null);
     const isLocked = Boolean(instance.locked);
     const isSelected = selectedId === instance.id || selectedId === instance.sourceId;
     const canSelect = editMode && !isLocked;
-    const canClick = false;
+    const canClick = !editMode && Boolean(onClick);
     const pointerHandlers = usePointerEvents({
         enabled: canSelect || canClick,
-        entity: instance,
-        onClick: () => {
+        node: instance,
+        onClick: (event) => {
             if (editMode) {
                 onSelect === null || onSelect === void 0 ? void 0 : onSelect(instance.sourceId);
+                return;
             }
+            onClick === null || onClick === void 0 ? void 0 : onClick(event, instance.sourceId, groupRef.current);
         },
     });
     // Use BoxHelper when object is selected in edit mode
@@ -336,34 +226,29 @@ function InstanceGroupItem({ instance, InstanceComponents, onSelect, registerRef
     }, [editMode, instance.id, registerRef]);
     return (_jsx("group", Object.assign({ ref: groupRef, position: instance.position, rotation: instance.rotation, scale: instance.scale }, pointerHandlers, { children: InstanceComponents.map((Instance, i) => _jsx(Instance, {}, i)) })));
 }
-// Hook to check if an instance exists
 export function useInstanceCheck(id) {
-    var _a;
     const ctx = useContext(GameInstanceContext);
-    return (_a = ctx === null || ctx === void 0 ? void 0 : ctx.hasInstance(id)) !== null && _a !== void 0 ? _a : false;
+    return ctx ? useStore(ctx.store, state => Boolean(state.instancesById[id] || state.sourceInstanceIdsById[id])) : false;
 }
-// GameInstance component: registers an instance for batch rendering (renders nothing itself)
-export const GameInstance = React.forwardRef(({ id, sourceId, modelUrl, locked = false, position, rotation, scale, physics = undefined, }, ref) => {
+export const GameInstance = React.forwardRef(({ id, sourceId, modelUrl, locked = false, position, rotation, scale, visible = true, onClick: _onClick, }, 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;
     const [positionX, positionY, positionZ] = position;
     const [rotationX, rotationY, rotationZ] = rotation;
     const [scaleX, scaleY, scaleZ] = scale;
-    const physicsSignature = getPhysicsSignature(physics);
     const instance = useMemo(() => ({
         id,
         sourceId: sourceId !== null && sourceId !== void 0 ? sourceId : id,
         locked,
+        visible,
         meshPath: modelUrl,
         position,
         rotation,
         scale,
-        physics,
     }), [
         id,
         sourceId,
         locked,
+        visible,
         modelUrl,
         positionX,
         positionY,
@@ -374,16 +259,16 @@ export const GameInstance = React.forwardRef(({ id, sourceId, modelUrl, locked =
         scaleX,
         scaleY,
         scaleZ,
-        physicsSignature,
     ]);
     useEffect(() => {
-        if (!addInstance || !removeInstance)
+        if (!ctx)
             return;
+        const store = ctx.store;
+        const { addInstance, removeInstance } = store.getState();
         addInstance(instance);
         return () => {
             removeInstance(instance.id);
         };
-    }, [addInstance, removeInstance, instance]);
-    // No visual rendering - provider handles all instanced visuals
+    }, [ctx === null || ctx === void 0 ? void 0 : ctx.store, instance]);
     return null;
 });

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

@@ -2,13 +2,12 @@ import GameCanvas from "../../shared/GameCanvas";
 import { Object3D, Texture } from "three";
 import { GameObject, Prefab } from "./types";
 import type { ExportGLBOptions } from "./utils";
-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;
+    getNode: (nodeId: string) => PrefabNode | null;
+    getNodeObject: (nodeId: string) => Object3D | null;
+    getNodeHandle: <T = unknown>(nodeId: string, kind: string) => T | null;
+    onSceneChange: (listener: (revision: number) => void) => () => void;
     screenshot: () => void;
     exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;
     exportGLBData: () => Promise<ArrayBuffer | undefined>;
@@ -18,10 +17,24 @@ export interface PrefabEditorRef {
         resetHistory?: boolean;
         notifyChange?: boolean;
     }) => void;
+    updateNode: (nodeId: string, update: (node: PrefabNode) => PrefabNode) => void;
+    updateNodes: (updates: Array<{
+        id: string;
+        update: (node: PrefabNode) => PrefabNode;
+    }>) => void;
+    deleteNode: (nodeId: string) => void;
+    duplicateNode: (nodeId: string) => string | null;
+    moveNode: (draggedId: string, targetId: string, position: "before" | "inside") => void;
     addNode: (node: GameObject, options?: SpawnOptions) => GameObject;
     addModel: (path: string, model: Object3D, options?: SpawnOptions) => GameObject;
     addTexture: (path: string, texture: Texture, options?: SpawnOptions) => GameObject;
 }
+export interface SpawnOptions {
+    name?: string;
+    parentId?: string;
+    select?: boolean;
+}
+export type PrefabNode = Omit<GameObject, "children">;
 export declare enum PrefabEditorMode {
     Edit = "edit",
     Play = "play"
@@ -46,7 +59,6 @@ export declare function useEditorContext(): EditorContextType;
 export interface PrefabEditorProps {
     basePath?: string;
     initialPrefab?: Prefab;
-    physics?: boolean;
     mode?: PrefabEditorMode;
     onChange?: (prefab: Prefab) => void;
     showUI?: boolean;

package/dist/tools/prefabeditor/PrefabEditor.js

@@ -10,11 +10,10 @@ 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, useHelper } from "@react-three/drei";
 import GameCanvas from "../../shared/GameCanvas";
-import { useCallback, useEffect, useLayoutEffect, useRef, useState, forwardRef, useImperativeHandle, createContext, useContext } from "react";
+import { useCallback, useEffect, useRef, useState, forwardRef, useImperativeHandle, createContext, useContext } from "react";
 import { BoxHelper } from "three";
 import { findComponentEntry } from "./types";
-import PrefabRoot from "./PrefabRoot";
-import { Physics } from "@react-three/rapier";
+import { PrefabRootInternal } from "./PrefabRoot";
 import EditorUI from "./EditorUI";
 import { base, toolbar } from "./styles";
 import { computeParentWorldMatrix, decompose, exportGLB as exportGLBFile, exportGLBData, focusCameraOnObject, regenerateIds } from "./utils";
@@ -58,8 +57,7 @@ const DEFAULT_PREFAB = {
     name: "New 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 PrefabEditor = forwardRef(({ basePath, initialPrefab, mode: initialMode = PrefabEditorMode.Edit, onChange, showUI = true, enableWindowDrop = true, canvasProps, uiPlugins, children }, ref) => {
     const [mode, setMode] = useState(initialMode);
     const [selectedId, setSelectedId] = useState(null);
     const [transformMode, setTransformMode] = useState("translate");
@@ -76,13 +74,29 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
     const canvasRef = useRef(null);
     const controlsRef = useRef(null);
     const transformControlsRef = useRef(null);
-    const transformProxyRef = useRef(null);
     const onChangeRef = useRef(onChange);
+    const sceneChangeListenersRef = useRef(new Set());
     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 getNode = useCallback((nodeId) => { var _a; return (_a = prefabStore.getState().nodesById[nodeId]) !== null && _a !== void 0 ? _a : null; }, [prefabStore]);
+    const getSceneRootObject = useCallback(() => { var _a, _b; return (_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.root) !== null && _b !== void 0 ? _b : null; }, []);
+    const getNodeObject = useCallback((nodeId) => { var _a, _b; return (_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.getNodeObject(nodeId)) !== null && _b !== void 0 ? _b : null; }, []);
+    const getNodeHandle = useCallback((nodeId, kind) => { var _a, _b; return (_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.getNodeHandle(nodeId, kind)) !== null && _b !== void 0 ? _b : null; }, []);
+    const updateNode = useCallback((nodeId, update) => {
+        prefabStore.getState().updateNode(nodeId, update);
+    }, [prefabStore]);
+    const updateNodes = useCallback((updates) => {
+        prefabStore.getState().updateNodes(updates);
+    }, [prefabStore]);
+    const deleteNode = useCallback((nodeId) => {
+        prefabStore.getState().deleteNode(nodeId);
+    }, [prefabStore]);
+    const duplicateNode = useCallback((nodeId) => {
+        return prefabStore.getState().duplicateNode(nodeId);
+    }, [prefabStore]);
+    const moveNode = useCallback((draggedId, targetId, position) => {
+        prefabStore.getState().moveNode(draggedId, targetId, position);
+    }, [prefabStore]);
     onChangeRef.current = onChange;
     const setSelection = useCallback((nodeId) => {
         const nextNode = nodeId ? prefabStore.getState().nodesById[nodeId] : null;
@@ -135,6 +149,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
                 return;
             }
             lastRevision = state.revision;
+            sceneChangeListenersRef.current.forEach(listener => listener(state.revision));
             const nextPrefab = denormalizePrefab(state);
             const changeOrigin = changeOriginRef.current;
             if (changeOrigin !== "replace-silent") {
@@ -177,23 +192,11 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         });
         return () => unsubscribe();
     }, [prefabStore, selectedId]);
-    const selectedNode = selectedId ? (_a = prefabStore.getState().nodesById[selectedId]) !== null && _a !== void 0 ? _a : null : null;
-    const selectedObject = selectedId ? getObject(selectedId) : null;
-    const selectedHasPhysics = Object.values((_b = selectedNode === null || selectedNode === void 0 ? void 0 : selectedNode.components) !== null && _b !== void 0 ? _b : {}).some(component => (component === null || component === void 0 ? void 0 : component.type) === "Physics");
-    const transformObject = isEditMode && (selectedHasPhysics ? transformProxyRef.current : selectedObject)
-        && isObjectAttachedToRoot(getRootObject(), selectedObject)
-        ? (selectedHasPhysics ? transformProxyRef.current : selectedObject)
+    const selectedObject = selectedId ? getNodeObject(selectedId) : null;
+    const transformObject = isEditMode && selectedObject
+        && isObjectAttachedToRoot(getSceneRootObject(), selectedObject)
+        ? selectedObject
         : null;
-    useLayoutEffect(() => {
-        if (!isEditMode || !selectedHasPhysics || !selectedObject || !transformProxyRef.current) {
-            return;
-        }
-        selectedObject.updateMatrixWorld(true);
-        transformProxyRef.current.matrixAutoUpdate = true;
-        selectedObject.matrixWorld.decompose(transformProxyRef.current.position, transformProxyRef.current.quaternion, transformProxyRef.current.scale);
-        transformProxyRef.current.updateMatrix();
-        transformProxyRef.current.updateMatrixWorld(true);
-    }, [isEditMode, selectedHasPhysics, selectedId, selectedObject]);
     const addNode = useCallback((node, options) => {
         var _a;
         const { addChild, rootId } = prefabStore.getState();
@@ -272,30 +275,30 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
     }), [setSelection]);
     const handleExportGLB = useCallback((...args_1) => __awaiter(void 0, [...args_1], void 0, function* (options = {}) {
         yield clearSelection();
-        const rootObject = getRootObject();
+        const rootObject = getSceneRootObject();
         if (!rootObject)
             return;
         return exportGLBFile(rootObject, Object.assign({ filename: `${prefabStore.getState().prefabName || 'prefab'}.glb` }, options));
-    }), [clearSelection, getRootObject, prefabStore]);
+    }), [clearSelection, getSceneRootObject, prefabStore]);
     const handleExportGLBData = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
         yield clearSelection();
-        const rootObject = getRootObject();
+        const rootObject = getSceneRootObject();
         if (!rootObject)
             return;
         return exportGLBData(rootObject);
-    }), [clearSelection, getRootObject]);
+    }), [clearSelection, getSceneRootObject]);
     const handleFocusNode = useCallback((nodeId) => {
-        const object = getObject(nodeId);
+        const object = getNodeObject(nodeId);
         const controls = controlsRef.current;
         const camera = controls === null || controls === void 0 ? void 0 : controls.object;
         if (!object || !controls || !camera)
             return;
         focusCameraOnObject(object, camera, controls.target, () => { var _a; return (_a = controls.update) === null || _a === void 0 ? void 0 : _a.call(controls); });
-    }, [getObject]);
+    }, [getNodeObject]);
     const handleTransformChange = () => {
         if (!selectedId)
             return;
-        const object = selectedHasPhysics ? transformProxyRef.current : getObject(selectedId);
+        const object = getNodeObject(selectedId);
         if (!object)
             return;
         const parentWorld = computeParentWorldMatrix(prefabStore.getState(), selectedId);
@@ -348,21 +351,34 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         };
     }, [addModel, addTexture, isEditMode, enableWindowDrop]);
     useImperativeHandle(ref, () => ({
-        root: getRootObject(),
-        store: prefabStore,
-        getObject,
-        getRigidBody,
+        get root() {
+            return getSceneRootObject();
+        },
+        getNode,
+        getNodeObject,
+        getNodeHandle,
+        onSceneChange: (listener) => {
+            sceneChangeListenersRef.current.add(listener);
+            return () => {
+                sceneChangeListenersRef.current.delete(listener);
+            };
+        },
         screenshot: handleScreenshot,
         exportGLB: handleExportGLB,
         exportGLBData: handleExportGLBData,
         clearSelection,
         save: getPrefab,
         load: loadPrefab,
+        updateNode,
+        updateNodes,
+        deleteNode,
+        duplicateNode,
+        moveNode,
         addNode,
         addModel,
         addTexture
-    }), [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, basePath: basePath }), children] }));
+    }), [addModel, addNode, addTexture, clearSelection, deleteNode, duplicateNode, getNode, getNodeHandle, getNodeObject, getPrefab, getSceneRootObject, handleExportGLB, handleExportGLBData, handleScreenshot, loadPrefab, moveNode, updateNode, updateNodes]);
+    const content = (_jsxs(_Fragment, { children: [isEditMode ? _jsx("gridHelper", { args: [10, 10], position: [0, -1, 0] }) : null, _jsx(PrefabRootInternal, { ref: prefabRootRef, store: prefabStore, editMode: isEditMode, selectedId: selectedId, onSelect: setSelection, basePath: basePath }), children] }));
     const handleCanvasCreated = useCallback((state) => {
         var _a;
         canvasRef.current = state.gl.domElement;
@@ -391,7 +407,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
                             }
                             (_d = canvasProps === null || canvasProps === void 0 ? void 0 : canvasProps.onPointerMissed) === null || _d === void 0 ? void 0 : _d.call(canvasProps, event);
                         }
-                        : canvasProps === null || canvasProps === void 0 ? void 0 : canvasProps.onPointerMissed, children: [physics ? (_jsx(Physics, { colliders: false, debug: isEditMode, paused: isEditMode, children: content })) : content, _jsx("group", { ref: transformProxyRef, visible: false }), isEditMode ? _jsx(SelectionHelper, { object: transformObject }) : null, isEditMode && (_jsxs(_Fragment, { children: [_jsx(MapControls, { ref: controlsRef, enableDamping: false, makeDefault: true }), transformObject && (_jsx(TransformControls, { ref: transformControlsRef, object: transformObject, mode: transformMode, space: "local", onObjectChange: handleTransformChange, translationSnap: positionSnap > 0 ? positionSnap : undefined, rotationSnap: rotationSnap > 0 ? rotationSnap : undefined, scaleSnap: scaleSnap > 0 ? scaleSnap : undefined }, `transform-${selectedId}-${transformMode}-${positionSnap}-${rotationSnap}-${scaleSnap}`))] }))] })), showUI && (_jsxs(_Fragment, { children: [_jsxs("div", { style: toolbar.panel, children: [_jsx("button", { style: base.btn, onClick: toggleMode, children: isEditMode ? "▶" : "⏸" }), uiPlugins] }), isEditMode && (_jsx(EditorUI, { selectedId: selectedId, setSelectedId: setSelection, getPrefab: getPrefab, onReplacePrefab: (prefab) => loadPrefab(prefab, { resetHistory: true }), onImportPrefab: importPrefab, basePath: basePath, onUndo: undo, onRedo: redo, canUndo: historyIndex > 0, canRedo: historyIndex < history.length - 1 }))] }))] }) });
+                        : canvasProps === null || canvasProps === void 0 ? void 0 : canvasProps.onPointerMissed, children: [content, isEditMode ? _jsx(SelectionHelper, { object: transformObject }) : null, isEditMode && (_jsxs(_Fragment, { children: [_jsx(MapControls, { ref: controlsRef, enableDamping: false, makeDefault: true }), transformObject && (_jsx(TransformControls, { ref: transformControlsRef, object: transformObject, mode: transformMode, space: "local", onObjectChange: handleTransformChange, translationSnap: positionSnap > 0 ? positionSnap : undefined, rotationSnap: rotationSnap > 0 ? rotationSnap : undefined, scaleSnap: scaleSnap > 0 ? scaleSnap : undefined }, `transform-${selectedId}-${transformMode}-${positionSnap}-${rotationSnap}-${scaleSnap}`))] }))] })), showUI && (_jsxs(_Fragment, { children: [_jsxs("div", { style: toolbar.panel, children: [_jsx("button", { style: base.btn, onClick: toggleMode, children: isEditMode ? "▶" : "⏸" }), uiPlugins] }), isEditMode && (_jsx(EditorUI, { selectedId: selectedId, setSelectedId: setSelection, getPrefab: getPrefab, onReplacePrefab: (prefab) => loadPrefab(prefab, { resetHistory: true }), onImportPrefab: importPrefab, basePath: basePath, onUndo: undo, onRedo: redo, canUndo: historyIndex > 0, canRedo: historyIndex < history.length - 1 }))] }))] }) });
 });
 PrefabEditor.displayName = "PrefabEditor";
 export default PrefabEditor;