react-three-game 0.0.70 → 0.0.71

package/dist/index.d.ts

@@ -10,20 +10,25 @@ 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/sceneApi';
+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';
-export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, createModelNode, createImageNode, } from './tools/prefabeditor/utils';
+export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
 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/sceneApi';
-export type { PrefabRootProps, PrefabRootRef } from './tools/prefabeditor/PrefabRoot';
-export type { Component } from './tools/prefabeditor/components/ComponentRegistry';
+export type { SpawnOptions, Scene, Entity, EntityComponent, EntityData, EntityUpdate, PropertyPath, SceneUpdates, } from './tools/prefabeditor/scene';
+export type { PrefabRootProps, PrefabRootRef, SceneRuntime } from './tools/prefabeditor/PrefabRoot';
+export { useSceneRuntime } from './tools/prefabeditor/PrefabRoot';
+export type { Component, ComponentViewProps } from './tools/prefabeditor/components/ComponentRegistry';
 export type { FieldDefinition, FieldType } from './tools/prefabeditor/components/Input';
 export type { Prefab, GameObject, ComponentData } from './tools/prefabeditor/types';
 export { findComponent, findComponentEntry, hasComponent } from './tools/prefabeditor/types';
 export { gameEvents, useGameEvent, getEntityIdFromRigidBody } from './tools/prefabeditor/GameEvents';
 export type { GameEventType, GameEventMap, GameEventPayload, PhysicsEventType, InteractionEventType, PhysicsEventPayload, ClickEventPayload } from './tools/prefabeditor/GameEvents';
+export { createRefBridge } from './tools/prefabeditor/RefBridge';
+export type { RefBridge } from './tools/prefabeditor/RefBridge';
 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,16 +10,21 @@ 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/sceneApi';
+export { createScene } from './tools/prefabeditor/scene';
+export { denormalizePrefab } from './tools/prefabeditor/prefab';
 // Prefab Editor - Component Registry
 export { registerComponent } from './tools/prefabeditor/components/ComponentRegistry';
 // Prefab Editor - Input Components
 export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Field, NumberField, ColorInput, ColorField, StringInput, StringField, BooleanInput, BooleanField, SelectInput, SelectField, } from './tools/prefabeditor/components/Input';
 // Prefab Editor - Utils
-export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, createModelNode, createImageNode, } from './tools/prefabeditor/utils';
+export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
+export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
+export { useSceneRuntime } from './tools/prefabeditor/PrefabRoot';
 export { findComponent, findComponentEntry, hasComponent } from './tools/prefabeditor/types';
 // Game Events (physics + custom events)
 export { gameEvents, useGameEvent, getEntityIdFromRigidBody } from './tools/prefabeditor/GameEvents';
+// RefBridge & Systems
+export { createRefBridge } from './tools/prefabeditor/RefBridge';
 // Asset Loading
 export { loadFiles } from './tools/dragdrop/DragDropLoader';
 export { loadModel, loadSound, loadTexture } from './tools/dragdrop/modelLoader';

package/dist/tools/prefabeditor/EditorTree.js

@@ -1,10 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { memo, useCallback, useState } from 'react';
-import { getComponentDef } from './components/ComponentRegistry';
 import { base, colors, tree } from './styles';
 import { useEditorContext } from './PrefabEditor';
 import { Dropdown } from './Dropdown';
 import { FileMenu, TreeContextMenu, TreeNodeMenu } from './EditorTreeMenus';
+import { createEmptyNode } from './prefab';
 import { usePrefabChildIds, usePrefabNode, usePrefabRootId, usePrefabStore, usePrefabStoreApi } from './prefabStore';
 export default function EditorTree({ selectedId, setSelectedId, getPrefab, onReplacePrefab, onImportPrefab, onUndo, onRedo, canUndo, canRedo }) {
     const { onFocusNode } = useEditorContext();
@@ -30,17 +30,7 @@ export default function EditorTree({ selectedId, setSelectedId, getPrefab, onRep
         });
     };
     const handleAddChild = (parentId) => {
-        var _a;
-        const newNode = {
-            id: crypto.randomUUID(),
-            name: "New Node",
-            components: {
-                transform: {
-                    type: "Transform",
-                    properties: Object.assign({}, (_a = getComponentDef('Transform')) === null || _a === void 0 ? void 0 : _a.defaultProperties)
-                }
-            }
-        };
+        const newNode = createEmptyNode();
         addChild(parentId, newNode);
         setSelectedId(newNode.id);
     };

package/dist/tools/prefabeditor/EditorTreeMenus.js

@@ -10,28 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
 import { createPortal } from 'react-dom';
+import { createEmptyPrefab } from './prefab';
 import { menu } from './styles';
 import { useEditorContext } from './PrefabEditor';
-import { getComponentDef } from './components/ComponentRegistry';
 import { loadJson, saveJson } from './utils';
-function createEmptyPrefab() {
-    var _a;
-    return {
-        id: crypto.randomUUID(),
-        name: 'New Prefab',
-        root: {
-            id: crypto.randomUUID(),
-            name: 'Root',
-            components: {
-                transform: {
-                    type: 'Transform',
-                    properties: Object.assign({}, (_a = getComponentDef('Transform')) === null || _a === void 0 ? void 0 : _a.defaultProperties)
-                }
-            },
-            children: []
-        }
-    };
-}
 function MenuPanel({ children, style, }) {
     return (_jsx("div", { style: Object.assign(Object.assign(Object.assign({}, menu.container), { position: 'static' }), style), onClick: (e) => e.stopPropagation(), children: children }));
 }

package/dist/tools/prefabeditor/EditorUI.js

@@ -14,6 +14,7 @@ import { useState } from 'react';
 import { hasComponent } from "./types";
 import EditorTree from './EditorTree';
 import { getAllComponentDefs } from './components/ComponentRegistry';
+import { createComponentData } from './prefab';
 import { base, colors, inspector, componentCard } from './styles';
 import { usePrefabStore } from './prefabStore';
 function EditorUI({ selectedId, setSelectedId, getPrefab, onReplacePrefab, onImportPrefab, basePath, onUndo, onRedo, canUndo, canRedo }) {
@@ -58,7 +59,7 @@ function NodeInspector({ node, updateNode, deleteNode, basePath }) {
                                     return;
                                 const def = ALL_COMPONENTS[addType];
                                 if (def) {
-                                    updateNode(n => (Object.assign(Object.assign({}, n), { components: Object.assign(Object.assign({}, n.components), { [addType.toLowerCase()]: { type: def.name, properties: def.defaultProperties } }) })));
+                                    updateNode(n => (Object.assign(Object.assign({}, n), { components: Object.assign(Object.assign({}, n.components), { [addType.toLowerCase()]: createComponentData(def.name) }) })));
                                 }
                             }, title: "Add Component", children: "+" })] }) }))] });
 }

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

@@ -3,7 +3,7 @@ import { Object3D, Texture } from "three";
 import { GameObject, Prefab } from "./types";
 import { PrefabRootRef } from "./PrefabRoot";
 import type { ExportGLBOptions } from "./utils";
-import { type Scene, type SpawnOptions } from "./sceneApi";
+import { type Scene, type SpawnOptions } from "./scene";
 export interface PrefabEditorRef {
     screenshot: () => void;
     exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;

package/dist/tools/prefabeditor/PrefabEditor.js

@@ -16,10 +16,11 @@ import PrefabRoot from "./PrefabRoot";
 import { Physics } from "@react-three/rapier";
 import EditorUI from "./EditorUI";
 import { base, toolbar } from "./styles";
-import { createImageNode, createModelNode, computeParentWorldMatrix, decompose, exportGLB as exportGLBFile, exportGLBData, focusCameraOnObject, regenerateIds } from "./utils";
+import { computeParentWorldMatrix, decompose, exportGLB as exportGLBFile, exportGLBData, focusCameraOnObject, regenerateIds } from "./utils";
 import { loadFiles } from "../dragdrop";
-import { createPrefabStore, PrefabStoreProvider, prefabStoreToPrefab } from "./prefabStore";
-import { createScene } from "./sceneApi";
+import { denormalizePrefab, createImageNode, createModelNode, createNode } from './prefab';
+import { createPrefabStore, PrefabStoreProvider } from "./prefabStore";
+import { createScene } from "./scene";
 export var PrefabEditorMode;
 (function (PrefabEditorMode) {
     PrefabEditorMode["Edit"] = "edit";
@@ -38,15 +39,7 @@ const HISTORY_DEBOUNCE_MS = 500;
 const DEFAULT_PREFAB = {
     id: "prefab-default",
     name: "New Prefab",
-    root: {
-        id: "root",
-        components: {
-            transform: {
-                type: "Transform",
-                properties: { position: [0, 0, 0], rotation: [0, 0, 0], scale: [1, 1, 1] }
-            }
-        }
-    }
+    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) => {
     const [mode, setMode] = useState(initialMode);
@@ -66,10 +59,8 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
     const canvasRef = useRef(null);
     const controlsRef = useRef(null);
     const onChangeRef = useRef(onChange);
-    const [injectedModels, setInjectedModels] = useState({});
-    const [injectedTextures, setInjectedTextures] = useState({});
     const isEditMode = mode === PrefabEditorMode.Edit;
-    const getPrefab = useCallback(() => prefabStoreToPrefab(prefabStore.getState()), [prefabStore]);
+    const getPrefab = useCallback(() => denormalizePrefab(prefabStore.getState()), [prefabStore]);
     onChangeRef.current = onChange;
     const setSelection = useCallback((nodeId) => {
         const nextNode = nodeId ? prefabStore.getState().nodesById[nodeId] : null;
@@ -101,8 +92,6 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         setSelectedObject(null);
         if (options === null || options === void 0 ? void 0 : options.resetHistory) {
             setSelectedId(null);
-            setInjectedModels({});
-            setInjectedTextures({});
             setHistory([prefab]);
             historyIndexRef.current = 0;
             setHistoryIndex(0);
@@ -124,7 +113,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
                 return;
             }
             lastRevision = state.revision;
-            const nextPrefab = prefabStoreToPrefab(state);
+            const nextPrefab = denormalizePrefab(state);
             const changeOrigin = changeOriginRef.current;
             if (changeOrigin !== "replace-silent") {
                 (_a = onChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onChangeRef, nextPrefab);
@@ -188,15 +177,17 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         addNode(regenerateIds(prefab.root), { select: false });
     }, [addNode]);
     const addModel = useCallback((path, model, options) => {
+        var _a;
         const node = createModelNode(path, options === null || options === void 0 ? void 0 : options.name);
         addNode(node, options);
-        setInjectedModels(prev => (Object.assign(Object.assign({}, prev), { [path]: model })));
+        (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.addModel(path, model);
         return node;
     }, [addNode]);
     const addTexture = useCallback((path, texture, options) => {
+        var _a;
         const node = createImageNode(path, options === null || options === void 0 ? void 0 : options.name);
         addNode(node, options);
-        setInjectedTextures(prev => (Object.assign(Object.assign({}, prev), { [path]: texture })));
+        (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.addTexture(path, texture);
         return node;
     }, [addNode]);
     const applyHistory = (index) => {
@@ -361,7 +352,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         addTexture,
         viewRef: prefabRootRef
     }), [addModel, addTexture, clearSelection, getPrefab, handleExportGLB, handleExportGLBData, handleScreenshot, loadPrefab, scene]);
-    const content = (_jsxs(_Fragment, { children: [_jsx("ambientLight", { intensity: 1.5 }), _jsx("gridHelper", { args: [10, 10], position: [0, -1, 0] }), _jsx(PrefabRoot, { ref: prefabRootRef, store: prefabStore, editMode: isEditMode, selectedId: selectedId, onSelect: setSelection, onSelectedObjectChange: isEditMode ? setSelectedObject : undefined, onFocusNode: isEditMode ? handleFocusNode : undefined, basePath: basePath, injectedModels: injectedModels, injectedTextures: injectedTextures }), children] }));
+    const content = (_jsxs(_Fragment, { children: [_jsx("gridHelper", { args: [10, 10], position: [0, -1, 0] }), _jsx(PrefabRoot, { ref: prefabRootRef, store: prefabStore, editMode: isEditMode, selectedId: selectedId, onSelect: setSelection, basePath: basePath }), children] }));
     return _jsx(PrefabStoreProvider, { store: prefabStore, children: _jsxs(EditorContext.Provider, { value: {
                 mode,
                 setMode: updateMode,

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

@@ -1,14 +1,36 @@
-import { Group, Matrix4, Object3D } from "three";
+import { Group, Matrix4, Object3D, Texture } from "three";
 import { ThreeEvent } from "@react-three/fiber";
 import { GameObject as GameObjectType, Prefab } from "./types";
-import { LoadedModels, LoadedSounds, LoadedTextures } from "../dragdrop";
+import { LoadedModels } from "../dragdrop";
 import { PrefabStoreApi } from "./prefabStore";
+import { type RefBridge } from "./RefBridge";
+/** Runtime context available to all component Views inside a PrefabRoot. */
+export interface SceneRuntime {
+    refBridge: RefBridge;
+    getRigidBody: (id: string) => any;
+    /** @internal Used by PhysicsComponent. */
+    registerRigidBodyRef: (id: string, rb: any) => void;
+    editMode?: boolean;
+    /** Get a loaded model by asset path. */
+    getModel: (path: string) => Object3D | null;
+    /** Get a loaded texture by asset path. */
+    getTexture: (path: string) => Texture | null;
+    /** Get a loaded sound buffer by asset path. */
+    getSound: (path: string) => AudioBuffer | null;
+    /** Get a revision string that changes when loaded assets change (for cache-busting keys). */
+    getAssetRevision: () => string;
+}
+/** Access the scene runtime (refBridge, getRigidBody, editMode) from within a component View. */
+export declare function useSceneRuntime(): SceneRuntime;
 export interface PrefabRootRef {
     root: Group | null;
+    refBridge: RefBridge;
     rigidBodyRefs: Map<string, any>;
     getObject: (nodeId: string) => Object3D | null;
     getRigidBody: (nodeId: string) => any;
-    focusNode: (nodeId: string) => void;
+    addModel: (path: string, model: Object3D) => void;
+    addTexture: (path: string, texture: Texture) => void;
+    addSound: (path: string, sound: AudioBuffer) => void;
 }
 export interface PrefabRootProps {
     editMode?: boolean;
@@ -17,12 +39,7 @@ export interface PrefabRootProps {
     selectedId?: string | null;
     onSelect?: (id: string | null) => void;
     onClick?: (event: ThreeEvent<PointerEvent>, entity: GameObjectType) => void;
-    onSelectedObjectChange?: (object: Object3D | null) => void;
-    onFocusNode?: (nodeId: string) => void;
     basePath?: string;
-    injectedModels?: LoadedModels;
-    injectedTextures?: LoadedTextures;
-    injectedSounds?: LoadedSounds;
 }
 export declare const PrefabRoot: import("react").ForwardRefExoticComponent<PrefabRootProps & import("react").RefAttributes<PrefabRootRef>>;
 export declare function GameObjectRenderer(props: RendererProps): import("react/jsx-runtime").JSX.Element | null;
@@ -32,11 +49,7 @@ interface RendererProps {
     onSelect?: (id: string) => void;
     onClick?: (event: ThreeEvent<PointerEvent>, entity: GameObjectType) => void;
     registerRef: (id: string, obj: Object3D | null) => void;
-    registerRigidBodyRef: (id: string, rb: any) => void;
-    getRigidBody: (id: string) => any;
     loadedModels: LoadedModels;
-    loadedSounds: LoadedSounds;
-    loadedTextures: LoadedTextures;
     editMode?: boolean;
     parentMatrix?: Matrix4;
 }

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -11,7 +11,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useHelper } from "@react-three/drei";
-import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { forwardRef, createContext, useCallback, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
 import { BoxHelper, Euler, Matrix4, } from "three";
 import { useStore } from "zustand";
 import { useClickValid } from "./useClickValid";
@@ -22,13 +22,23 @@ import { loadModel, loadSound, loadTexture } from "../dragdrop";
 import { GameInstance, GameInstanceProvider, getRepeatAxesFromModelProperties, useInstanceCheck } from "./InstanceProvider";
 import { composeTransform, decompose } from "./utils";
 import { isPhysicsProps } from "./components/PhysicsComponent";
-import { createPrefabStore, PrefabStoreProvider, prefabStoreToPrefab, useOptionalPrefabStoreApi, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
+import { denormalizePrefab } from "./prefab";
+import { createPrefabStore, PrefabStoreProvider, useOptionalPrefabStoreApi, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
+import { createRefBridge } from "./RefBridge";
 import { sound as soundManager } from "../../helpers/SoundManager";
 components.forEach(registerComponent);
 const IDENTITY = new Matrix4();
 const EMPTY_MODELS = {};
 const EMPTY_TEXTURES = {};
 const EMPTY_SOUNDS = {};
+const SceneRuntimeContext = createContext(null);
+/** Access the scene runtime (refBridge, getRigidBody, editMode) from within a component View. */
+export function useSceneRuntime() {
+    const ctx = useContext(SceneRuntimeContext);
+    if (!ctx)
+        throw new Error("useSceneRuntime must be used inside <PrefabRoot>");
+    return ctx;
+}
 /** Resolve a relative or absolute asset file path against a base path. */
 function resolveAssetPath(basePath, file) {
     if (file.startsWith("http://") || file.startsWith("https://"))
@@ -43,11 +53,14 @@ function isNodeReady(node, loadedModels) {
         return true;
     return Boolean(loadedModels[model.properties.filename]);
 }
-export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSelect, onClick, onSelectedObjectChange, onFocusNode, basePath = "", injectedModels = EMPTY_MODELS, injectedTextures = EMPTY_TEXTURES, injectedSounds = EMPTY_SOUNDS }, ref) => {
+export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSelect, onClick, basePath = "" }, ref) => {
     var _a;
     const [models, setModels] = useState({});
     const [textures, setTextures] = useState({});
     const [sounds, setSounds] = useState({});
+    const [injectedModels, setInjectedModels] = useState(EMPTY_MODELS);
+    const [injectedTextures, setInjectedTextures] = useState(EMPTY_TEXTURES);
+    const [injectedSounds, setInjectedSounds] = useState(EMPTY_SOUNDS);
     const loading = useRef(new Set());
     const failedModels = useRef(new Set());
     const failedTextures = useRef(new Set());
@@ -55,8 +68,9 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
     const objectRefs = useRef({});
     const rigidBodyRefs = useRef(new Map());
     const rootRef = useRef(null);
+    const [refBridge] = useState(() => createRefBridge());
     const parentStore = useOptionalPrefabStoreApi();
-    const [ownedStore] = useState(() => { var _a, _b; return createPrefabStore(data !== null && data !== void 0 ? data : prefabStoreToPrefab((_b = (_a = store === null || store === void 0 ? void 0 : store.getState()) !== null && _a !== void 0 ? _a : parentStore === null || parentStore === void 0 ? void 0 : parentStore.getState()) !== null && _b !== void 0 ? _b : missingStoreState())); });
+    const [ownedStore] = useState(() => { var _a, _b; return createPrefabStore(data !== null && data !== void 0 ? data : denormalizePrefab((_b = (_a = store === null || store === void 0 ? void 0 : store.getState()) !== null && _a !== void 0 ? _a : parentStore === null || parentStore === void 0 ? void 0 : parentStore.getState()) !== null && _b !== void 0 ? _b : missingStoreState())); });
     const resolvedStore = (_a = store !== null && store !== void 0 ? store : parentStore) !== null && _a !== void 0 ? _a : ownedStore;
     const usesOwnedStore = resolvedStore === ownedStore;
     const shouldProvideStoreContext = !parentStore || parentStore !== resolvedStore;
@@ -66,17 +80,21 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
     const availableSounds = useMemo(() => (Object.assign(Object.assign({}, sounds), injectedSounds)), [sounds, injectedSounds]);
     useImperativeHandle(ref, () => ({
         root: rootRef.current,
+        refBridge,
         rigidBodyRefs: rigidBodyRefs.current,
         getObject: (nodeId) => { var _a; return (_a = objectRefs.current[nodeId]) !== null && _a !== void 0 ? _a : null; },
         getRigidBody: (nodeId) => { var _a; return (_a = rigidBodyRefs.current.get(nodeId)) !== null && _a !== void 0 ? _a : null; },
-        focusNode: (nodeId) => onFocusNode === null || onFocusNode === void 0 ? void 0 : onFocusNode(nodeId),
-    }), [onFocusNode]);
+        addModel: (path, model) => setInjectedModels(prev => (Object.assign(Object.assign({}, prev), { [path]: model }))),
+        addTexture: (path, texture) => setInjectedTextures(prev => (Object.assign(Object.assign({}, prev), { [path]: texture }))),
+        addSound: (path, sound) => {
+            soundManager.setBuffer(path, sound);
+            setInjectedSounds(prev => (Object.assign(Object.assign({}, prev), { [path]: sound })));
+        },
+    }), [refBridge]);
     const registerRef = useCallback((id, obj) => {
         objectRefs.current[id] = obj;
-        if (id === selectedId) {
-            onSelectedObjectChange === null || onSelectedObjectChange === void 0 ? void 0 : onSelectedObjectChange(obj);
-        }
-    }, [onSelectedObjectChange, selectedId]);
+        refBridge.register(id, obj);
+    }, [refBridge]);
     const registerRigidBodyRef = useCallback((id, rb) => {
         rigidBodyRefs.current.set(id, rb);
     }, []);
@@ -155,11 +173,32 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
         };
         syncAssets();
     }, [resolvedStore, assetManifestKey, basePath, injectedModels, injectedSounds, injectedTextures, models, sounds, textures]);
-    const content = (_jsx("group", { ref: rootRef, children: _jsx(GameInstanceProvider, { models: availableModels, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, registerRef: registerRef, children: _jsx(StoreRootNode, { selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: onClick, registerRef: registerRef, registerRigidBodyRef: registerRigidBodyRef, getRigidBody: getRigidBody, loadedModels: availableModels, loadedSounds: availableSounds, loadedTextures: availableTextures, editMode: editMode, parentMatrix: IDENTITY }) }) }));
+    // Keep refs current so context getters are always fresh without changing context identity
+    const availableModelsRef = useRef(availableModels);
+    availableModelsRef.current = availableModels;
+    const availableTexturesRef = useRef(availableTextures);
+    availableTexturesRef.current = availableTextures;
+    const availableSoundsRef = useRef(availableSounds);
+    availableSoundsRef.current = availableSounds;
+    const sceneRuntime = useMemo(() => ({
+        refBridge,
+        getRigidBody,
+        registerRigidBodyRef,
+        editMode,
+        getModel: (path) => { var _a; return (_a = availableModelsRef.current[path]) !== null && _a !== void 0 ? _a : null; },
+        getTexture: (path) => { var _a; return (_a = availableTexturesRef.current[path]) !== null && _a !== void 0 ? _a : null; },
+        getSound: (path) => { var _a; return (_a = availableSoundsRef.current[path]) !== null && _a !== void 0 ? _a : null; },
+        getAssetRevision: () => {
+            const modelKeys = Object.keys(availableModelsRef.current).sort().join('|');
+            const textureKeys = Object.keys(availableTexturesRef.current).sort().join('|');
+            return `${textureKeys}::${modelKeys}`;
+        },
+    }), [refBridge, getRigidBody, registerRigidBodyRef, editMode]);
+    const content = (_jsx("group", { ref: rootRef, children: _jsx(GameInstanceProvider, { models: availableModels, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, registerRef: registerRef, children: _jsx(StoreRootNode, { selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: onClick, registerRef: registerRef, loadedModels: availableModels, editMode: editMode, parentMatrix: IDENTITY }) }) }));
     if (!shouldProvideStoreContext) {
-        return content;
+        return _jsx(SceneRuntimeContext.Provider, { value: sceneRuntime, children: content });
     }
-    return _jsx(PrefabStoreProvider, { store: resolvedStore, children: content });
+    return _jsx(PrefabStoreProvider, { store: resolvedStore, children: _jsx(SceneRuntimeContext.Provider, { value: sceneRuntime, children: content }) });
 });
 function StoreRootNode(props) {
     const rootId = usePrefabRootId();
@@ -218,7 +257,7 @@ function InstancedNode({ nodeId, parentMatrix = IDENTITY, editMode, registerRef,
     }
     return (_jsx(_Fragment, { children: instances.map(instance => (_jsx(GameInstance, { id: instance.id, sourceId: gameObject.id, clickable: clickable, clickEventName: clickEventName, modelUrl: instance.modelUrl, position: instance.position, rotation: instance.rotation, scale: instance.scale, locked: isLocked, physics: instance.physics }, instance.id))) }));
 }
-function StandardNode({ nodeId, selectedId, onSelect, onClick, registerRef, registerRigidBodyRef, getRigidBody, loadedModels, loadedSounds, loadedTextures, editMode, parentMatrix = IDENTITY, }) {
+function StandardNode({ nodeId, selectedId, onSelect, onClick, registerRef, loadedModels, editMode, parentMatrix = IDENTITY, }) {
     var _a, _b;
     const gameObject = usePrefabNode(nodeId);
     const childIds = usePrefabChildIds(nodeId);
@@ -246,16 +285,16 @@ function StandardNode({ nodeId, selectedId, onSelect, onClick, registerRef, regi
     const physicsDef = hasPhysics ? getComponentDef(physics.type) : null;
     const isInstanced = (_b = (_a = findComponent(gameObject, "Model")) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.instanced;
     const physicsKey = `physics_${nodeId}_${isInstanced ? 'instanced' : 'standard'}`;
-    const renderCtx = { loadedModels, loadedSounds, loadedTextures, editMode, registerRef, getRigidBody };
+    const renderCtx = { loadedModels, editMode, registerRef };
     const childNodes = getChildHostComponents(gameObject).length > 0
         ? _jsx(CompositionChildren, { childIds: childIds, selectedId: selectedId, ctx: renderCtx, parentMatrix: world })
-        : _jsx(ChildNodes, { childIds: childIds, parentMatrix: world, selectedId: selectedId, onSelect: onSelect, onClick: onClick, registerRef: registerRef, registerRigidBodyRef: registerRigidBodyRef, getRigidBody: getRigidBody, loadedModels: loadedModels, loadedSounds: loadedSounds, loadedTextures: loadedTextures, editMode: editMode });
+        : _jsx(ChildNodes, { childIds: childIds, parentMatrix: world, selectedId: selectedId, onSelect: onSelect, onClick: onClick, registerRef: registerRef, loadedModels: loadedModels, editMode: editMode });
     const inner = (_jsx("group", Object.assign({}, clickHandlers, { children: renderCompositionNode(gameObject, renderCtx, isSelected, parentMatrix, childNodes) })));
     if (editMode) {
-        return (_jsxs(_Fragment, { children: [_jsx("group", { ref: groupRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: _jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) }) }), _jsx("group", { ref: helperRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: inner }), hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View) ? (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, editMode: editMode, nodeId: nodeId, registerRigidBodyRef: registerRigidBodyRef, children: inner }, physicsKey)) : null] }));
+        return (_jsxs(_Fragment, { children: [_jsx("group", { ref: groupRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: _jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) }) }), _jsx("group", { ref: helperRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: inner }), hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View) ? (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, editMode: editMode, nodeId: nodeId, children: inner }, physicsKey)) : null] }));
     }
     if (hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View)) {
-        return (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, editMode: editMode, nodeId: nodeId, registerRigidBodyRef: registerRigidBodyRef, children: inner }, physicsKey));
+        return (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, editMode: editMode, nodeId: nodeId, children: inner }, physicsKey));
     }
     return (_jsx("group", { ref: groupRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: inner }));
 }
@@ -363,17 +402,11 @@ function renderCompositionNode(gameObject, ctx, isSelected, parentMatrix, childN
     const ownContent = renderNodeOwnContent(gameObject, ctx, isSelected, parentMatrix);
     return wrapWithChildHosts(gameObject, ctx, isSelected, parentMatrix, _jsxs(_Fragment, { children: [ownContent, childNodes] }));
 }
-function buildContextProps(gameObject, ctx, isSelected, parentMatrix) {
+function buildContextProps(gameObject, _ctx, isSelected) {
     return {
-        loadedModels: ctx.loadedModels,
-        loadedSounds: ctx.loadedSounds,
-        loadedTextures: ctx.loadedTextures,
-        editMode: ctx.editMode,
+        editMode: _ctx.editMode,
         isSelected,
         nodeId: gameObject.id,
-        parentMatrix,
-        registerRef: ctx.registerRef,
-        getRigidBody: ctx.getRigidBody,
     };
 }
 function renderNodeOwnContent(gameObject, ctx, isSelected, parentMatrix) {
@@ -383,11 +416,11 @@ function renderNodeOwnContent(gameObject, ctx, isSelected, parentMatrix) {
     const materialDef = material && getComponentDef(material.type);
     if (!geometry || !(geometryDef === null || geometryDef === void 0 ? void 0 : geometryDef.View))
         return null;
-    const contextProps = buildContextProps(gameObject, ctx, isSelected, parentMatrix);
+    const contextProps = buildContextProps(gameObject, ctx, isSelected);
     return (_jsxs("mesh", { castShadow: true, receiveShadow: true, children: [_jsx(geometryDef.View, Object.assign({ properties: geometry.properties }, contextProps)), material && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View) && (_jsx(materialDef.View, Object.assign({ properties: material.properties }, contextProps), "material"))] }));
 }
 function wrapWithChildHosts(gameObject, ctx, isSelected, parentMatrix, subtree) {
-    const contextProps = buildContextProps(gameObject, ctx, isSelected, parentMatrix);
+    const contextProps = buildContextProps(gameObject, ctx, isSelected);
     const childHosts = getChildHostComponents(gameObject);
     return childHosts.reduce((acc, { key, View, properties }) => (_jsx(View, Object.assign({ properties: properties }, contextProps, { children: acc }), key)), subtree);
 }

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

@@ -0,0 +1,24 @@
+import { Object3D } from "three";
+/**
+ * RefBridge — O(1) lookup from entity ID to live Three.js Object3D.
+ *
+ * In play mode the Scene API writes directly to these refs, bypassing
+ * React reconciliation.  In edit mode the store path is used instead.
+ *
+ * Component Views register/unregister refs on mount/unmount via
+ * `bridge.register(id, obj)` / `bridge.unregister(id)`.
+ */
+export interface RefBridge {
+    register: (id: string, obj: Object3D | null) => void;
+    unregister: (id: string) => void;
+    get: (id: string) => Object3D | null;
+    /** Apply a transform component's properties directly to the Object3D. */
+    setTransform: (id: string, position?: number[], rotation?: number[], scale?: number[]) => void;
+    /** Read current transform from the Object3D back into a properties bag. */
+    readTransform: (id: string) => {
+        position: [number, number, number];
+        rotation: [number, number, number];
+        scale: [number, number, number];
+    } | null;
+}
+export declare function createRefBridge(): RefBridge;

package/dist/tools/prefabeditor/RefBridge.js

@@ -0,0 +1,44 @@
+export function createRefBridge() {
+    const refs = new Map();
+    return {
+        register(id, obj) {
+            if (obj) {
+                refs.set(id, obj);
+            }
+            else {
+                refs.delete(id);
+            }
+        },
+        unregister(id) {
+            refs.delete(id);
+        },
+        get(id) {
+            var _a;
+            return (_a = refs.get(id)) !== null && _a !== void 0 ? _a : null;
+        },
+        setTransform(id, position, rotation, scale) {
+            const obj = refs.get(id);
+            if (!obj)
+                return;
+            if (position) {
+                obj.position.set(position[0], position[1], position[2]);
+            }
+            if (rotation) {
+                obj.rotation.set(rotation[0], rotation[1], rotation[2]);
+            }
+            if (scale) {
+                obj.scale.set(scale[0], scale[1], scale[2]);
+            }
+        },
+        readTransform(id) {
+            const obj = refs.get(id);
+            if (!obj)
+                return null;
+            return {
+                position: [obj.position.x, obj.position.y, obj.position.z],
+                rotation: [obj.rotation.x, obj.rotation.y, obj.rotation.z],
+                scale: [obj.scale.x, obj.scale.y, obj.scale.z],
+            };
+        },
+    };
+}

package/dist/tools/prefabeditor/components/AmbientLightComponent.js

@@ -1,19 +1,22 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { ColorField, FieldGroup, NumberField } from "./Input";
+import { ColorField, NumberField } from "./Input";
+import { LightSection, mergeWithDefaults } from "./lightUtils";
+const ambientLightDefaults = {
+    color: '#ffffff',
+    intensity: 1,
+};
 function AmbientLightComponentEditor({ component, onUpdate, }) {
-    return (_jsxs(FieldGroup, { children: [_jsx(ColorField, { name: "color", label: "Color", values: component.properties, onChange: onUpdate }), _jsx(NumberField, { name: "intensity", label: "Intensity", values: component.properties, onChange: onUpdate, min: 0, step: 0.1, fallback: 1 })] }));
+    const values = mergeWithDefaults(ambientLightDefaults, component.properties);
+    return (_jsxs(LightSection, { title: "Light", children: [_jsx(ColorField, { name: "color", label: "Color", values: values, onChange: onUpdate }), _jsx(NumberField, { name: "intensity", label: "Intensity", values: values, onChange: onUpdate, min: 0, step: 0.1, fallback: 1 })] }));
 }
 function AmbientLightComponentView({ properties, children }) {
-    const { color = '#ffffff', intensity = 1 } = properties;
+    const { color, intensity } = mergeWithDefaults(ambientLightDefaults, properties);
     return (_jsxs(_Fragment, { children: [_jsx("ambientLight", { color: color, intensity: intensity }), children] }));
 }
 const AmbientLightComponent = {
     name: 'AmbientLight',
     Editor: AmbientLightComponentEditor,
     View: AmbientLightComponentView,
-    defaultProperties: {
-        color: '#ffffff',
-        intensity: 1,
-    },
+    defaultProperties: {},
 };
 export default AmbientLightComponent;