react-three-game 0.0.93 → 0.0.94

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -9,8 +9,8 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { createContext, forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
 import { Euler, Matrix4, } from "three";
 import { useStore } from "zustand";
 import { useClickValid } from "./useClickValid";
@@ -20,8 +20,8 @@ import { builtinComponents } from "./components";
 import { loadModel, loadSound, loadTexture } from "../dragdrop";
 import { GameInstance, GameInstanceProvider, getRepeatAxesFromModelProperties, useInstanceCheck } from "./InstanceProvider";
 import { composeTransform, decompose } from "./utils";
-import { createPrefabStore, PrefabStoreProvider, useOptionalPrefabStoreApi, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
-import { AssetRuntimeContext, CurrentNodeScope } from "./assetRuntime";
+import { createPrefabStore, PrefabStoreProvider, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
+import { AssetRuntimeContext, NodeScope } from "./assetRuntime";
 import { gameEvents } from "./GameEvents";
 import { sound as soundManager } from "../../helpers/SoundManager";
 builtinComponents.forEach(registerComponent);
@@ -50,8 +50,20 @@ function getNodeMetadataProps(node) {
         userData: Object.assign(Object.assign({ prefabNodeId: node.id }, (nodeName ? { prefabNodeName: nodeName } : {})), getNodeUserData(node)),
     };
 }
-export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedId, onSelect, onClick, onEditNodeClick, basePath = "" }, ref) => {
-    var _a;
+export var PrefabEditorMode;
+(function (PrefabEditorMode) {
+    PrefabEditorMode["Edit"] = "edit";
+    PrefabEditorMode["Play"] = "play";
+})(PrefabEditorMode || (PrefabEditorMode = {}));
+export const SceneContext = createContext(null);
+export function useScene() {
+    const scene = useContext(SceneContext);
+    if (!scene) {
+        throw new Error("useScene must be used within a PrefabRoot or PrefabEditor scene provider");
+    }
+    return scene;
+}
+export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSelect, onClick, onEditNodeClick, basePath = "", children }, ref) => {
     const [models, setModels] = useState({});
     const [textures, setTextures] = useState({});
     const [sounds, setSounds] = useState({});
@@ -64,31 +76,33 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
     const failedSounds = useRef(new Set());
     const objectRefs = useRef({});
     const nodeHandles = useRef(new Map());
-    const parentStore = useOptionalPrefabStoreApi();
     const [ownedStore] = useState(() => {
+        if (store)
+            return null;
         if (data)
             return createPrefabStore(data);
-        if (store || parentStore)
-            return null;
         throw new Error("PrefabRoot requires either a `data` or `store` prop");
     });
-    const resolvedStore = (_a = store !== null && store !== void 0 ? store : parentStore) !== null && _a !== void 0 ? _a : ownedStore;
+    const resolvedStore = store !== null && store !== void 0 ? store : ownedStore;
     const usesOwnedStore = resolvedStore === ownedStore;
-    const shouldProvideStoreContext = !parentStore || parentStore !== resolvedStore;
     const rootId = useStore(resolvedStore, state => state.rootId);
     const assetManifestKey = useStore(resolvedStore, state => state.assetManifestKey);
     const availableModels = useMemo(() => (Object.assign(Object.assign({}, models), injectedModels)), [models, injectedModels]);
     const availableTextures = useMemo(() => (Object.assign(Object.assign({}, textures), injectedTextures)), [textures, injectedTextures]);
     const availableSounds = useMemo(() => (Object.assign(Object.assign({}, sounds), injectedSounds)), [sounds, injectedSounds]);
-    const getNodeObject = useCallback((id) => {
+    const getObject = useCallback((id) => {
         var _a;
         return (_a = objectRefs.current[id]) !== null && _a !== void 0 ? _a : null;
     }, []);
-    const getNodeHandle = useCallback((id, kind) => {
+    const getHandle = useCallback((id, kind) => {
         var _a, _b;
         return (_b = (_a = nodeHandles.current.get(id)) === null || _a === void 0 ? void 0 : _a.get(kind)) !== null && _b !== void 0 ? _b : null;
     }, []);
-    const registerNodeHandle = useCallback((id, kind, handle) => {
+    const getNode = useCallback((nodeId) => {
+        var _a;
+        return (_a = resolvedStore.getState().nodesById[nodeId]) !== null && _a !== void 0 ? _a : null;
+    }, [resolvedStore]);
+    const registerHandle = useCallback((id, kind, handle) => {
         const current = nodeHandles.current.get(id);
         if (handle == null) {
             if (!current)
@@ -105,20 +119,33 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
         }
         nodeHandles.current.set(id, new Map([[kind, handle]]));
     }, []);
-    useImperativeHandle(ref, () => ({
+    const sceneValue = useMemo(() => ({
         get root() {
             var _a;
             return (_a = objectRefs.current[rootId]) !== null && _a !== void 0 ? _a : null;
         },
-        getNodeObject,
-        getNodeHandle,
+        mode: editMode ? PrefabEditorMode.Edit : PrefabEditorMode.Play,
+        get: getNode,
+        getObject,
+        getHandle,
+        add: (node, parentId) => {
+            const state = resolvedStore.getState();
+            state.addChild(parentId !== null && parentId !== void 0 ? parentId : state.rootId, node);
+            return node;
+        },
+        update: (id, fn) => resolvedStore.getState().updateNode(id, fn),
+        remove: (id) => resolvedStore.getState().deleteNode(id),
+        duplicate: (id) => resolvedStore.getState().duplicateNode(id),
+        move: (draggedId, targetId, position) => resolvedStore.getState().moveNode(draggedId, targetId, position),
+        replace: (prefab) => resolvedStore.getState().replacePrefab(prefab),
         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 })));
         },
-    }), [getNodeHandle, getNodeObject, rootId]);
+    }), [editMode, getHandle, getNode, getObject, resolvedStore, rootId]);
+    useImperativeHandle(ref, () => sceneValue, [sceneValue]);
     const registerRef = useCallback((id, obj) => {
         objectRefs.current[id] = obj;
     }, []);
@@ -153,31 +180,27 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
                     return;
                 loading.current.add(file);
                 void loader(resolveAssetPath(basePath, file)).then(result => {
+                    loading.current.delete(file);
                     if (!result.success) {
                         console.warn(`Failed to load asset: ${file}`, result.error);
-                        loading.current.delete(file);
                         failed.add(file);
                     }
                 });
             };
-            modelsToLoad.forEach(file => loadAsset(file, models, injectedModels, failedModels.current, (path) => loadModel(path).then(result => {
-                const model = result.model;
-                if (result.success && model) {
-                    setModels(m => (Object.assign(Object.assign({}, m), { [file]: model })));
-                }
+            modelsToLoad.forEach(file => loadAsset(file, models, injectedModels, failedModels.current, path => loadModel(path).then(result => {
+                if (result.success && result.model)
+                    setModels(m => (Object.assign(Object.assign({}, m), { [file]: result.model })));
                 return result;
             })));
-            texturesToLoad.forEach(file => loadAsset(file, textures, injectedTextures, failedTextures.current, (path) => loadTexture(path).then(result => {
-                if (result.success && result.texture) {
+            texturesToLoad.forEach(file => loadAsset(file, textures, injectedTextures, failedTextures.current, path => loadTexture(path).then(result => {
+                if (result.success && result.texture)
                     setTextures(t => (Object.assign(Object.assign({}, t), { [file]: result.texture })));
-                }
                 return result;
             })));
-            soundsToLoad.forEach(file => loadAsset(file, sounds, injectedSounds, failedSounds.current, (path) => loadSound(path).then(result => {
+            soundsToLoad.forEach(file => loadAsset(file, sounds, injectedSounds, failedSounds.current, path => loadSound(path).then(result => {
                 if (result.success && result.sound) {
                     soundManager.setBuffer(file, result.sound);
-                    setSounds(current => (Object.assign(Object.assign({}, current), { [file]: result.sound })));
-                    loading.current.delete(file);
+                    setSounds(s => (Object.assign(Object.assign({}, s), { [file]: result.sound })));
                 }
                 return result;
             })));
@@ -185,14 +208,14 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
         syncAssets();
     }, [resolvedStore, assetManifestKey, basePath, injectedModels, injectedSounds, injectedTextures, models, sounds, textures]);
     const assetRuntime = useMemo(() => ({
-        registerNodeHandle,
-        getNodeHandle,
-        getNodeObject,
+        registerHandle,
+        getHandle,
+        getObject,
         getModel: (path) => { var _a; return (_a = availableModels[path]) !== null && _a !== void 0 ? _a : null; },
         getTexture: (path) => { var _a; return (_a = availableTextures[path]) !== null && _a !== void 0 ? _a : null; },
         getSound: (path) => { var _a; return (_a = availableSounds[path]) !== null && _a !== void 0 ? _a : null; },
         getAssetRevision: () => `${Object.keys(availableTextures).sort().join('|')}::${Object.keys(availableModels).sort().join('|')}`,
-    }), [registerNodeHandle, getNodeHandle, getNodeObject, availableModels, availableTextures, availableSounds]);
+    }), [registerHandle, getHandle, getObject, availableModels, availableTextures, availableSounds]);
     const handleNodeClick = useCallback((event, nodeId, fallbackObject) => {
         const node = resolvedStore.getState().nodesById[nodeId];
         if (!node)
@@ -201,14 +224,10 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
         emitNodePointerEvent(clickEventName, event, nodeId, node, fallbackObject);
         onClick === null || onClick === void 0 ? void 0 : onClick(event, node);
     }, [onClick, resolvedStore]);
-    const content = (_jsx(GameInstanceProvider, { models: availableModels, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, registerRef: registerRef, children: _jsx(StoreRootNode, { selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, onEditNodeClick: editMode ? onEditNodeClick : undefined, registerRef: registerRef, loadedModels: availableModels, editMode: editMode, parentMatrix: IDENTITY }) }));
-    const runtimeContent = _jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content });
-    if (!shouldProvideStoreContext) {
-        return runtimeContent;
-    }
+    const content = (_jsxs(GameInstanceProvider, { models: availableModels, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, registerRef: registerRef, children: [_jsx(StoreRootNode, { selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, onEditNodeClick: editMode ? onEditNodeClick : undefined, registerRef: registerRef, loadedModels: availableModels, editMode: editMode, parentMatrix: IDENTITY }), children] }));
+    const runtimeContent = (_jsx(SceneContext.Provider, { value: sceneValue, children: _jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content }) }));
     return _jsx(PrefabStoreProvider, { store: resolvedStore, children: runtimeContent });
 });
-export const PrefabRoot = PrefabRootInternal;
 function StoreRootNode(props) {
     const rootId = usePrefabRootId();
     return _jsx(GameObjectRenderer, Object.assign({}, props, { nodeId: rootId }));
@@ -379,7 +398,7 @@ function StandardNode({ nodeId, selectedId, onSelect, onClick, onEditNodeClick,
     const inner = renderNodeContent(analyzedComponents, loadedModels, primaryClickHandlers, childNodes);
     const editAnchor = editMode ? (_jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) })) : null;
     const standardNode = (_jsxs("group", Object.assign({ ref: handleGroupRef }, groupProps, { visible: nodeVisible }, (editMode ? editClickHandlers : undefined), { children: [editAnchor, inner] })));
-    return (_jsx(CurrentNodeScope, { nodeId: nodeId, editMode: editMode, isSelected: isSelected, children: standardNode }));
+    return (_jsx(NodeScope, { nodeId: nodeId, editMode: editMode, isSelected: isSelected, children: standardNode }));
 }
 function ChildNodes(_a) {
     var { childIds, parentMatrix } = _a, props = __rest(_a, ["childIds", "parentMatrix"]);

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

@@ -1,36 +1,30 @@
 import { type ReactNode } from "react";
 import type { Object3D, Texture } from "three";
 export interface AssetRuntime {
-    registerNodeHandle: (id: string, kind: string, handle: unknown) => void;
-    getNodeHandle: <T = unknown>(id: string, kind: string) => T | null;
+    registerHandle: (id: string, kind: string, handle: unknown) => void;
+    getHandle: <T = unknown>(id: string, kind: string) => T | null;
     getModel: (path: string) => Object3D | null;
     getTexture: (path: string) => Texture | null;
     getSound: (path: string) => AudioBuffer | null;
     getAssetRevision: () => string;
-    getNodeObject: (id: string) => Object3D | null;
+    getObject: (id: string) => Object3D | null;
 }
-export interface AssetRuntimeContextValue extends AssetRuntime {
-}
-export interface CurrentNodeRuntime {
+export interface NodeApi {
     nodeId: string;
     editMode?: boolean;
     isSelected?: boolean;
-    getCurrentNodeObject: <T extends Object3D = Object3D>() => T | null;
-    getCurrentNodeHandle: <T = unknown>(kind: string) => T | null;
+    getObject: <T extends Object3D = Object3D>() => T | null;
+    getHandle: <T = unknown>(kind: string) => T | null;
 }
 export interface LiveRef<T> {
     readonly current: T | null;
 }
-export type LiveObjectRef<T extends Object3D = Object3D> = LiveRef<T>;
-export type LiveHandleRef<T = unknown> = LiveRef<T>;
-export type CurrentNodeObjectRef<T extends Object3D = Object3D> = LiveObjectRef<T>;
-export type CurrentNodeHandleRef<T = unknown> = LiveHandleRef<T>;
-export declare const AssetRuntimeContext: import("react").Context<AssetRuntimeContextValue | null>;
+export declare const AssetRuntimeContext: import("react").Context<AssetRuntime | null>;
 export declare function useAssetRuntime(): AssetRuntime;
-export declare function useCurrentNode(): CurrentNodeRuntime;
-export declare function useCurrentNodeObject<T extends Object3D = Object3D>(): LiveRef<T>;
-export declare function useCurrentNodeHandle<T = unknown>(kind: string): LiveRef<T>;
-export declare function CurrentNodeScope({ nodeId, editMode, isSelected, children, }: {
+export declare function useNode(): NodeApi;
+export declare function useNodeObject<T extends Object3D = Object3D>(): LiveRef<T>;
+export declare function useNodeHandle<T = unknown>(kind: string): LiveRef<T>;
+export declare function NodeScope({ nodeId, editMode, isSelected, children, }: {
     nodeId: string;
     editMode?: boolean;
     isSelected?: boolean;

package/dist/tools/prefabeditor/assetRuntime.js

@@ -1,37 +1,37 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useMemo } from "react";
 export const AssetRuntimeContext = createContext(null);
-const CurrentNodeRuntimeContext = createContext(null);
+const NodeContext = createContext(null);
 export function useAssetRuntime() {
     const ctx = useContext(AssetRuntimeContext);
     if (!ctx)
         throw new Error("useAssetRuntime must be used inside <PrefabRoot>");
     return ctx;
 }
-export function useCurrentNode() {
-    const ctx = useContext(CurrentNodeRuntimeContext);
+export function useNode() {
+    const ctx = useContext(NodeContext);
     if (!ctx)
-        throw new Error("useCurrentNode must be used inside a component View rendered by <PrefabRoot>");
+        throw new Error("useNode must be used inside a component View rendered by <PrefabRoot>");
     return ctx;
 }
-export function useCurrentNodeObject() {
-    const { getCurrentNodeObject } = useCurrentNode();
-    return useMemo(() => ({ get current() { return getCurrentNodeObject(); } }), [getCurrentNodeObject]);
+export function useNodeObject() {
+    const { getObject } = useNode();
+    return useMemo(() => ({ get current() { return getObject(); } }), [getObject]);
 }
-export function useCurrentNodeHandle(kind) {
-    const { getCurrentNodeHandle } = useCurrentNode();
-    return useMemo(() => ({ get current() { return getCurrentNodeHandle(kind); } }), [getCurrentNodeHandle, kind]);
+export function useNodeHandle(kind) {
+    const { getHandle } = useNode();
+    return useMemo(() => ({ get current() { return getHandle(kind); } }), [getHandle, kind]);
 }
-export function CurrentNodeScope({ nodeId, editMode, isSelected, children, }) {
+export function NodeScope({ nodeId, editMode, isSelected, children, }) {
     const asset = useContext(AssetRuntimeContext);
     if (!asset)
-        throw new Error("CurrentNodeScope must be used inside <PrefabRoot>");
+        throw new Error("NodeScope must be used inside <PrefabRoot>");
     const value = useMemo(() => ({
         nodeId,
         editMode,
         isSelected,
-        getCurrentNodeObject: () => asset.getNodeObject(nodeId),
-        getCurrentNodeHandle: (kind) => asset.getNodeHandle(nodeId, kind),
+        getObject: () => asset.getObject(nodeId),
+        getHandle: (kind) => asset.getHandle(nodeId, kind),
     }), [asset, editMode, isSelected, nodeId]);
-    return _jsx(CurrentNodeRuntimeContext.Provider, { value: value, children: children });
+    return _jsx(NodeContext.Provider, { value: value, children: children });
 }

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

@@ -3,7 +3,7 @@ import { OrthographicCamera, PerspectiveCamera, useHelper } from '@react-three/d
 import { useRef } from 'react';
 import { CameraHelper } from 'three';
 import { useFrame, useThree } from '@react-three/fiber';
-import { useCurrentNode } from '../assetRuntime';
+import { useNode } from '../assetRuntime';
 import { FieldGroup, NumberField, SelectField } from './Input';
 const CAMERA_PROJECTION_OPTIONS = [
     { value: 'perspective', label: 'Perspective' },
@@ -25,7 +25,7 @@ function CameraComponentEditor({ component, onUpdate }) {
 }
 function CameraComponentView({ properties, children }) {
     var _a;
-    const { editMode, isSelected } = useCurrentNode();
+    const { editMode, isSelected } = useNode();
     const { size } = useThree();
     const merged = Object.assign(Object.assign({}, cameraDefaults), properties);
     const projection = (_a = merged.projection) !== null && _a !== void 0 ? _a : cameraDefaults.projection;

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

@@ -3,7 +3,7 @@ import { useHelper } from "@react-three/drei";
 import { useRef, useEffect, useState } from "react";
 import { useFrame } from "@react-three/fiber";
 import { CameraHelper } from "three";
-import { useCurrentNode } from "../assetRuntime";
+import { useNode } from "../assetRuntime";
 import { BooleanField, ColorField, NumberField, NumberInput, Vector3Input } from "./Input";
 import { LightSection, ShadowBiasField, mergeWithDefaults } from "./lightUtils";
 import { colors } from "../styles";
@@ -102,7 +102,7 @@ function DirectionalLightComponentEditor({ component, onUpdate }) {
     return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 8 }, children: [_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 }), _jsx(Vector3Input, { label: "Target Offset", value: values.targetOffset, onChange: targetOffset => onUpdate({ targetOffset }), snap: 0.5 })] }), _jsxs(LightSection, { title: "Shadow", children: [_jsx(BooleanField, { name: "castShadow", label: "Cast Shadow", values: values, onChange: onUpdate, fallback: false }), values.castShadow ? (_jsxs(_Fragment, { children: [_jsx(BooleanField, { name: "shadowAutoUpdate", label: "Auto Update", values: values, onChange: onUpdate, fallback: true }), _jsx(NumberField, { name: "shadowMapSize", label: "Map Size", values: values, onChange: onUpdate, min: 128, step: 128, fallback: 512 }), _jsx(ShadowBiasField, { name: "shadowBias", label: "Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(ShadowBiasField, { name: "shadowNormalBias", label: "Normal Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(NumberField, { name: "shadowCameraNear", label: "Near", values: values, onChange: onUpdate, min: 0.001, step: 0.1, fallback: 0.5 }), _jsx(NumberField, { name: "shadowCameraFar", label: "Far", values: values, onChange: onUpdate, min: 0.1, step: 1, fallback: 500 }), _jsx(ShadowFrustumField, { values: values, onChange: onUpdate })] })) : null] })] }));
 }
 function DirectionalLightView({ properties, children }) {
-    const { editMode, isSelected } = useCurrentNode();
+    const { editMode, isSelected } = useNode();
     const merged = mergeWithDefaults(directionalLightDefaults, properties);
     const color = merged.color;
     const intensity = merged.intensity;

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

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { colors, ui } from '../styles';
-import { useOptionalPrefabStoreApi } from '../prefabStore';
+import { usePrefabStoreApi } from '../prefabStore';
 // ============================================================================
 // Shared Styles (derived from shared color tokens)
 // ============================================================================
@@ -278,14 +278,10 @@ export function ColorInput({ label, value, onChange }) {
 export function StringInput({ label, value, onChange, placeholder }) {
     return (_jsxs("div", { children: [label && _jsx(Label, { children: label }), _jsx("input", { type: "text", style: styles.input, value: value, onChange: e => onChange(e.target.value), placeholder: placeholder })] }));
 }
-function useOptionalPrefabSnapshot() {
-    const store = useOptionalPrefabStoreApi();
-    const [state, setState] = useState(() => { var _a; return (_a = store === null || store === void 0 ? void 0 : store.getState()) !== null && _a !== void 0 ? _a : null; });
+function usePrefabSnapshot() {
+    const store = usePrefabStoreApi();
+    const [state, setState] = useState(() => store.getState());
     useEffect(() => {
-        if (!store) {
-            setState(null);
-            return;
-        }
         setState(store.getState());
         return store.subscribe(nextState => setState(nextState));
     }, [store]);
@@ -323,7 +319,7 @@ function SearchSuggestionList({ query, options, onSelect, emptyMessage, }) {
                     }, children: [_jsx("span", { style: { fontSize: 11, fontWeight: 500 }, children: option.label }), option.description ? (_jsx("span", { style: { fontSize: 10, color: colors.textMuted, fontFamily: 'monospace' }, children: option.description })) : null] }, option.value))) })] }));
 }
 export function NodeInput({ label, value, onChange, placeholder, includeRoot = true, }) {
-    const prefabState = useOptionalPrefabSnapshot();
+    const prefabState = usePrefabSnapshot();
     const [query, setQuery] = useState('');
     const options = useMemo(() => {
         var _a;

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

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { ModelPicker } from '../../assetviewer/page';
-import { useContext, useMemo } from 'react';
+import { useMemo } from 'react';
 import { BooleanField, FieldGroup, Label, ListEditor, NumberInput, SelectInput, StringField } from './Input';
 import { useAssetRuntime } from '../assetRuntime';
-import { EditorContext } from '../PrefabEditor';
+import { useEditorContext } from '../PrefabEditor';
 import { getRepeatAxesFromModelProperties, normalizeRepeatAxes } from '../InstanceProvider';
 import { colors, ui } from '../styles';
 const AXIS_OPTIONS = [
@@ -39,9 +39,7 @@ function RepeatAxisEditor({ axes, onChange, positionSnap, }) {
         } }));
 }
 function ModelComponentEditor({ component, node, onUpdate, basePath = "" }) {
-    var _a;
-    const editorContext = useContext(EditorContext);
-    const positionSnap = (_a = editorContext === null || editorContext === void 0 ? void 0 : editorContext.positionSnap) !== null && _a !== void 0 ? _a : 0.5;
+    const { positionSnap } = useEditorContext();
     const repeatAxes = getRepeatAxesFromModelProperties(component.properties);
     return (_jsxs(FieldGroup, { children: [_jsx(ModelPicker, { value: component.properties.filename, onChange: (filename) => onUpdate({ filename }), basePath: basePath, pickerKey: node === null || node === void 0 ? void 0 : node.id }), _jsx(BooleanField, { name: "instanced", label: "Instanced", values: component.properties, onChange: onUpdate, fallback: false }), !component.properties.instanced ? (_jsxs(_Fragment, { children: [_jsx(BooleanField, { name: "emitClickEvent", label: "Emit Click Event", values: component.properties, onChange: onUpdate, fallback: false }), component.properties.emitClickEvent ? (_jsx(StringField, { name: "clickEventName", label: "Click Event Name", values: component.properties, onChange: onUpdate, placeholder: "node:click" })) : null] })) : null, component.properties.instanced && (_jsxs(_Fragment, { children: [_jsx(BooleanField, { name: "repeat", label: "Repeat", values: component.properties, onChange: onUpdate, fallback: false }), component.properties.repeat && (_jsx(RepeatAxisEditor, { axes: repeatAxes, onChange: (nextAxes) => onUpdate({ repeatAxes: nextAxes }), positionSnap: positionSnap }))] }))] }));
 }

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

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { useEffect, useRef } from 'react';
 import { useHelper } from '@react-three/drei';
 import { PointLightHelper } from 'three';
-import { useCurrentNode } from '../assetRuntime';
+import { useNode } from '../assetRuntime';
 import { BooleanField, ColorField, NumberField } from './Input';
 import { LightSection, ShadowBiasField, mergeWithDefaults } from './lightUtils';
 const pointLightDefaults = {
@@ -23,7 +23,7 @@ function PointLightComponentEditor({ component, onUpdate }) {
     return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 8 }, children: [_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 }), _jsx(NumberField, { name: "distance", label: "Distance", values: values, onChange: onUpdate, min: 0, step: 1, fallback: 0 }), _jsx(NumberField, { name: "decay", label: "Decay", values: values, onChange: onUpdate, min: 0, step: 0.1, fallback: 2 })] }), _jsxs(LightSection, { title: "Shadow", children: [_jsx(BooleanField, { name: "castShadow", label: "Cast Shadow", values: values, onChange: onUpdate, fallback: false }), values.castShadow ? (_jsxs(_Fragment, { children: [_jsx(BooleanField, { name: "shadowAutoUpdate", label: "Auto Update", values: values, onChange: onUpdate, fallback: true }), _jsx(NumberField, { name: "shadowMapSize", label: "Map Size", values: values, onChange: onUpdate, min: 128, step: 128, fallback: 512 }), _jsx(ShadowBiasField, { name: "shadowBias", label: "Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(ShadowBiasField, { name: "shadowNormalBias", label: "Normal Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(NumberField, { name: "shadowCameraNear", label: "Near", values: values, onChange: onUpdate, min: 0.001, step: 0.1, fallback: 0.5 }), _jsx(NumberField, { name: "shadowCameraFar", label: "Far", values: values, onChange: onUpdate, min: 0.1, step: 1, fallback: 500 })] })) : null] })] }));
 }
 function PointLightView({ properties, children }) {
-    const { editMode, isSelected } = useCurrentNode();
+    const { editMode, isSelected } = useNode();
     const merged = mergeWithDefaults(pointLightDefaults, properties);
     const color = merged.color;
     const intensity = merged.intensity;

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

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { useEffect, useRef } from 'react';
 import { useThree } from '@react-three/fiber';
 import { SoundPicker } from '../../assetviewer/page';
-import { useAssetRuntime, useCurrentNode } from '../assetRuntime';
+import { useAssetRuntime, useNode } from '../assetRuntime';
 import { gameEvents } from '../GameEvents';
 import { BooleanField, FieldGroup, FieldRenderer, ListEditor, NumberField, SelectField, StringField } from './Input';
 import { colors, ui } from '../styles';
@@ -124,7 +124,7 @@ function SoundComponentEditor({ component, onUpdate, basePath = '' }) {
 }
 function SoundComponentView({ properties, children }) {
     const { getSound } = useAssetRuntime();
-    const { editMode, nodeId } = useCurrentNode();
+    const { editMode, nodeId } = useNode();
     const { camera } = useThree();
     const { eventName, autoplay = false, positional = false, refDistance = 1, maxDistance = 24, rolloffFactor = 1, distanceModel = 'inverse' } = properties;
     const sequenceIndexRef = useRef(0);

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

@@ -3,7 +3,7 @@ import { useHelper } from "@react-three/drei";
 import { useRef, useEffect } from "react";
 import { BooleanField, ColorField, Label, NumberField, Vector3Input } from "./Input";
 import { SpotLightHelper } from "three";
-import { useAssetRuntime, useCurrentNode } from "../assetRuntime";
+import { useAssetRuntime, useNode } from "../assetRuntime";
 import { useFrame } from "@react-three/fiber";
 import { TexturePicker } from "../../assetviewer/page";
 import { LightSection, ShadowBiasField, mergeWithDefaults } from "./lightUtils";
@@ -31,7 +31,7 @@ function SpotLightComponentEditor({ component, onUpdate, basePath = "" }) {
 function SpotLightView({ properties, children }) {
     var _a;
     const { getTexture } = useAssetRuntime();
-    const { editMode, isSelected } = useCurrentNode();
+    const { editMode, isSelected } = useNode();
     const merged = mergeWithDefaults(spotLightDefaults, properties);
     const color = merged.color;
     const intensity = merged.intensity;

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

@@ -8,7 +8,6 @@ export interface PrefabState {
     nodesById: Record<string, PrefabNodeRecord>;
     childIdsById: Record<string, string[]>;
     parentIdById: Record<string, string | null>;
-    revision: number;
     assetManifestKey: string;
     assetRefCounts: PrefabAssetRefCounts;
 }
@@ -25,7 +24,7 @@ export declare function createEmptyNode(name?: string): GameObject;
 export declare function createEmptyPrefab(): Prefab;
 export declare function createModelNode(filename: string, name?: string): GameObject;
 export declare function createImageNode(texturePath: string, name?: string): GameObject;
-export declare function normalizePrefab(prefab: Prefab, revision?: number): PrefabState;
+export declare function normalizePrefab(prefab: Prefab): PrefabState;
 export declare function createPrefabPatch(state: PrefabState, patch: Partial<PrefabState>, nextAssetRefCounts?: PrefabAssetRefCounts): Partial<PrefabState>;
 export declare function denormalizePrefab(state: Pick<PrefabState, 'prefabId' | 'prefabName' | 'rootId' | 'nodesById' | 'childIdsById'>): Prefab;
 export declare function collectSubtreeIds(id: string, childIdsById: Record<string, string[]>): string[];

package/dist/tools/prefabeditor/prefab.js

@@ -132,7 +132,7 @@ export function createImageNode(texturePath, name) {
         },
     });
 }
-export function normalizePrefab(prefab, revision = 0) {
+export function normalizePrefab(prefab) {
     const nodesById = {};
     const childIdsById = {};
     const parentIdById = {};
@@ -145,14 +145,13 @@ export function normalizePrefab(prefab, revision = 0) {
         nodesById,
         childIdsById,
         parentIdById,
-        revision,
         assetManifestKey: getAssetManifestKey(assetRefCounts),
         assetRefCounts,
     };
 }
 export function createPrefabPatch(state, patch, nextAssetRefCounts = state.assetRefCounts) {
     const assetRefsChanged = nextAssetRefCounts !== state.assetRefCounts;
-    return Object.assign(Object.assign(Object.assign({}, patch), { revision: state.revision + 1 }), (assetRefsChanged ? {
+    return Object.assign(Object.assign({}, patch), (assetRefsChanged ? {
         assetRefCounts: nextAssetRefCounts,
         assetManifestKey: getAssetManifestKey(nextAssetRefCounts),
     } : null));

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

@@ -5,14 +5,9 @@ import { denormalizePrefab, PrefabState, PrefabNodeRecord } from "./prefab";
 export interface PrefabStoreState extends PrefabState {
     replacePrefab: (prefab: Prefab) => void;
     updateNode: (id: string, update: (node: PrefabNodeRecord) => PrefabNodeRecord) => void;
-    updateNodes: (updates: Array<{
-        id: string;
-        update: (node: PrefabNodeRecord) => PrefabNodeRecord;
-    }>) => void;
     addChild: (parentId: string, node: GameObject) => void;
     deleteNode: (id: string) => void;
     duplicateNode: (id: string) => string | null;
-    toggleNodeFlag: (id: string, key: "disabled" | "locked") => void;
     moveNode: (draggedId: string, targetId: string, position: "before" | "inside") => void;
 }
 export type PrefabStoreApi = StoreApi<PrefabStoreState>;
@@ -21,7 +16,6 @@ export declare function PrefabStoreProvider({ store, children, }: {
     children: ReactNode;
 }): import("react").FunctionComponentElement<import("react").ProviderProps<PrefabStoreApi | null>>;
 export declare function usePrefabStoreApi(): PrefabStoreApi;
-export declare function useOptionalPrefabStoreApi(): PrefabStoreApi | null;
 export declare function usePrefabStore<T>(selector: (state: PrefabStoreState) => T): T;
 export declare function usePrefabRootId(): string;
 export declare function usePrefabNode(nodeId: string | null | undefined): PrefabNodeRecord | null;

package/dist/tools/prefabeditor/prefabStore.js

@@ -15,9 +15,6 @@ export function usePrefabStoreApi() {
     }
     return store;
 }
-export function useOptionalPrefabStoreApi() {
-    return useContext(PrefabStoreContext);
-}
 export function usePrefabStore(selector) {
     return useStore(usePrefabStoreApi(), selector);
 }
@@ -32,7 +29,7 @@ export function usePrefabChildIds(nodeId) {
 }
 export function createPrefabStore(prefab) {
     return createStore()(subscribeWithSelector((set, get) => (Object.assign(Object.assign({}, normalizePrefab(prefab)), { replacePrefab: (nextPrefab) => {
-            set(normalizePrefab(nextPrefab, get().revision + 1));
+            set(normalizePrefab(nextPrefab));
         }, updateNode: (id, update) => {
             const state = get();
             const node = state.nodesById[id];
@@ -45,26 +42,6 @@ export function createPrefabStore(prefab) {
             set(createPrefabPatch(state, {
                 nodesById: Object.assign(Object.assign({}, state.nodesById), { [id]: nextNode }),
             }, nextAssetRefCounts));
-        }, updateNodes: (updates) => {
-            if (updates.length === 0)
-                return;
-            const state = get();
-            let nextNodesById = null;
-            let nextAssetRefCounts = state.assetRefCounts;
-            for (const { id, update } of updates) {
-                const currentNode = (nextNodesById !== null && nextNodesById !== void 0 ? nextNodesById : state.nodesById)[id];
-                if (!currentNode)
-                    continue;
-                const nextNode = update(currentNode);
-                if (nextNode === currentNode)
-                    continue;
-                nextNodesById !== null && nextNodesById !== void 0 ? nextNodesById : (nextNodesById = Object.assign({}, state.nodesById));
-                nextNodesById[id] = nextNode;
-                nextAssetRefCounts = updateAssetRefsForNodeChange(nextAssetRefCounts, currentNode, nextNode);
-            }
-            if (!nextNodesById)
-                return;
-            set(createPrefabPatch(state, { nodesById: nextNodesById }, nextAssetRefCounts));
         }, addChild: (parentId, node) => {
             var _a;
             const state = get();
@@ -152,15 +129,6 @@ export function createPrefabStore(prefab) {
                 parentIdById: nextParentIdById,
             }, nextAssetRefCounts));
             return duplicatedRootId;
-        }, toggleNodeFlag: (id, key) => {
-            const state = get();
-            const node = state.nodesById[id];
-            if (!node)
-                return;
-            const nextNode = Object.assign(Object.assign({}, node), { [key]: !node[key] });
-            set(createPrefabPatch(state, {
-                nodesById: Object.assign(Object.assign({}, state.nodesById), { [id]: nextNode }),
-            }));
         }, moveNode: (draggedId, targetId, position) => {
             var _a, _b, _c;
             const state = get();