react-three-game 0.0.108 → 0.0.109

package/README.md

@@ -29,7 +29,7 @@ npm install react-three-game @react-three/drei @react-three/fiber three
 Here is a minimal example that renders a prefab inside a normal R3F app:
 
 ```tsx
-import { GameCanvas, PrefabRoot, ground } from "react-three-game";
+import { GameCanvas, PrefabRoot, ground } from "react-three-game/viewer";
 
 const prefab = {
   id: "starter-scene",
@@ -80,7 +80,7 @@ This example renders a simple authored prefab with a ground plane and mesh conte
 In addition to the runtime renderer, there is a visual editor for authoring prefabs.
 
 ```tsx
-import { PrefabEditor } from "react-three-game";
+import { PrefabEditor } from "react-three-game/editor";
 
 export default function App() {
   return <PrefabEditor initialPrefab={prefab} onChange={console.log} />;
@@ -164,7 +164,7 @@ Use the editor or root ref for scene-native object access, and the `Scene` mutat
 
 ```tsx
 import { useEffect, useRef } from "react";
-import { PrefabEditor, type PrefabEditorRef } from "react-three-game";
+import { PrefabEditor, type PrefabEditorRef } from "react-three-game/editor";
 
 function RaiseBall() {
   const editorRef = useRef<PrefabEditorRef>(null);
@@ -199,7 +199,7 @@ ball?.rotateY(0.5);
 For runtime integrations that need to react to authored scene changes, subscribe through the prefab store:
 
 ```tsx
-import { usePrefabStoreApi } from "react-three-game";
+import { usePrefabStoreApi } from "react-three-game/editor";
 
 const store = usePrefabStoreApi();
 const stop = store.subscribe(
@@ -214,7 +214,7 @@ For runtime-owned imperative state, register node-local handles instead of reach
 
 ```tsx
 import { useEffect } from "react";
-import { useAssetRuntime, useNode, useNodeHandle } from "react-three-game";
+import { useAssetRuntime, useNode, useNodeHandle } from "react-three-game/viewer";
 
 function SpinnerView({ children }: { children?: React.ReactNode }) {
   const { nodeId } = useNode();

package/dist/editor.d.ts

@@ -0,0 +1,22 @@
+import { registerBuiltinComponents } from "./tools/prefabeditor/components";
+import "./viewer";
+export { registerBuiltinComponents };
+export * from "./viewer";
+export { default as PrefabEditor } from "./tools/prefabeditor/PrefabEditor";
+export type { PrefabEditorProps, PrefabEditorRef } from "./tools/prefabeditor/PrefabEditor";
+export { useEditorContext, useEditorRef } from "./tools/prefabeditor/EditorContext";
+export type { EditorContextType } from "./tools/prefabeditor/EditorContext";
+export { usePrefabStore, usePrefabStoreApi } from "./tools/prefabeditor/prefabStore";
+export type { PrefabStoreApi, PrefabStoreState } from "./tools/prefabeditor/prefabStore";
+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, } from "./tools/prefabeditor/utils";
+export type { ExportGLBOptions } from "./tools/prefabeditor/utils";
+export { decomposeModelToPrefabNodes } from "./tools/prefabeditor/modelPrefab";
+export type { DecomposeModelOptions } from "./tools/prefabeditor/modelPrefab";
+export type { FieldDefinition, FieldType } from "./tools/prefabeditor/components/Input";
+export { MaterialOverridesProvider, useMaterialOverrides } from "./tools/prefabeditor/components/MaterialComponent";
+export type { MaterialOverrides } from "./tools/prefabeditor/components/MaterialComponent";
+export { float, positionLocal, sin, time, uniform, vec3, } from "three/tsl";
+export { loadFiles } from "./tools/dragdrop/DragDropLoader";
+export type { AssetLoadOptions } from "./tools/dragdrop/DragDropLoader";
+export { ModelListViewer, SoundListViewer, ModelPicker, SoundPicker, TextureListViewer, TexturePicker, SingleModelViewer, SingleSoundViewer, SingleTextureViewer, SharedCanvas, } from "./tools/assetviewer/page";

package/dist/editor.js

@@ -0,0 +1,15 @@
+import { registerBuiltinComponents } from "./tools/prefabeditor/components";
+import "./viewer";
+registerBuiltinComponents();
+export { registerBuiltinComponents };
+export * from "./viewer";
+export { default as PrefabEditor } from "./tools/prefabeditor/PrefabEditor";
+export { useEditorContext, useEditorRef } from "./tools/prefabeditor/EditorContext";
+export { usePrefabStore, usePrefabStoreApi } from "./tools/prefabeditor/prefabStore";
+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, } from "./tools/prefabeditor/utils";
+export { decomposeModelToPrefabNodes } from "./tools/prefabeditor/modelPrefab";
+export { MaterialOverridesProvider, useMaterialOverrides } from "./tools/prefabeditor/components/MaterialComponent";
+export { float, positionLocal, sin, time, uniform, vec3, } from "three/tsl";
+export { loadFiles } from "./tools/dragdrop/DragDropLoader";
+export { ModelListViewer, SoundListViewer, ModelPicker, SoundPicker, TextureListViewer, TexturePicker, SingleModelViewer, SingleSoundViewer, SingleTextureViewer, SharedCanvas, } from "./tools/assetviewer/page";

package/dist/plugins/crashcat/CrashcatPhysicsComponent.js

@@ -5,7 +5,7 @@ import { useEffect, useMemo, useRef } from "react";
 import { BooleanField, FieldRenderer, StringField, Vector3Field, } from "../../tools/prefabeditor/components/Input";
 import { useAssetRuntime, useNode } from "../../tools/prefabeditor/assetRuntime";
 import { usePrefabStoreApi } from "../../tools/prefabeditor/prefabStore";
-import { PrefabEditorMode, useScene } from "../../tools/prefabeditor/PrefabRoot";
+import { PrefabEditorMode, useScene } from "../../tools/prefabeditor/SceneContext";
 import { box, capsule, convexHull, MotionQuality, MotionType, rigidBody, sphere, triangleMesh, } from "crashcat";
 import { Matrix4, Quaternion, Vector3 } from "three";
 import { useCrashcat } from "./CrashcatRuntime";

package/dist/plugins/crashcat/CrashcatRuntime.js

@@ -5,7 +5,7 @@ import { addBroadphaseLayer, addObjectLayer, createWorld, createWorldSettings, e
 import { debugRenderer } from "crashcat/three";
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { gameEvents } from "../../tools/prefabeditor/GameEvents";
-import { PrefabEditorMode, useScene } from "../../tools/prefabeditor/PrefabRoot";
+import { PrefabEditorMode, useScene } from "../../tools/prefabeditor/SceneContext";
 const SLEEP_TIME_BEFORE_REST = 0.1;
 const SLEEP_POINT_VELOCITY_THRESHOLD = 0.06;
 const MAX_PHYSICS_STEP_DELTA = 1 / 60;

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

@@ -0,0 +1,36 @@
+import type { PrefabEditorMode, Scene } from "./SceneContext";
+import type { Prefab } from "./types";
+import type { ExportGLBOptions } from "./utils";
+export interface PrefabEditorRef extends Scene {
+    save: () => Prefab;
+    load: (prefab: Prefab, options?: {
+        resetHistory?: boolean;
+        notifyChange?: boolean;
+    }) => void;
+    undo: () => void;
+    redo: () => void;
+    screenshot: () => void;
+    exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;
+    exportGLBData: () => Promise<ArrayBuffer | undefined>;
+    clearSelection: () => Promise<void>;
+}
+export interface EditorContextType {
+    mode: PrefabEditorMode;
+    basePath: string;
+    setMode: (mode: PrefabEditorMode) => void;
+    transformMode: "translate" | "rotate" | "scale";
+    setTransformMode: (mode: "translate" | "rotate" | "scale") => void;
+    scaleSnap: number;
+    setScaleSnap: (resolution: number) => void;
+    positionSnap: number;
+    setPositionSnap: (resolution: number) => void;
+    rotationSnap: number;
+    setRotationSnap: (resolution: number) => void;
+    onFocusNode?: (nodeId: string) => void;
+    onScreenshot?: () => void;
+    onExportGLB?: () => void;
+}
+export declare const EditorContext: import("react").Context<EditorContextType | null>;
+export declare const EditorRefContext: import("react").Context<PrefabEditorRef | null>;
+export declare function useEditorContext(): EditorContextType;
+export declare function useEditorRef(): PrefabEditorRef;

package/dist/tools/prefabeditor/EditorContext.js

@@ -0,0 +1,17 @@
+import { createContext, useContext } from "react";
+export const EditorContext = createContext(null);
+export const EditorRefContext = createContext(null);
+export function useEditorContext() {
+    const context = useContext(EditorContext);
+    if (!context) {
+        throw new Error("useEditorContext must be used within EditorContext.Provider");
+    }
+    return context;
+}
+export function useEditorRef() {
+    const editorRef = useContext(EditorRefContext);
+    if (!editorRef) {
+        throw new Error("useEditorRef must be used within PrefabEditor");
+    }
+    return editorRef;
+}

package/dist/tools/prefabeditor/EditorTree.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { memo, useCallback, useState } from 'react';
 import { base, colors, tree } from './styles';
-import { useEditorContext, useEditorRef } from './PrefabEditor';
+import { useEditorContext, useEditorRef } from './EditorContext';
 import { Dropdown } from './Dropdown';
 import { FileMenu, TreeContextMenu, TreeNodeMenu } from './EditorTreeMenus';
 import { createEmptyNode, createPackedPrefabNode } from './prefab';

package/dist/tools/prefabeditor/EditorTreeMenus.js

@@ -12,7 +12,7 @@ import { useEffect, useRef, useState } from 'react';
 import { createPortal } from 'react-dom';
 import { createEmptyPrefab } from './prefab';
 import { menu } from './styles';
-import { useEditorContext } from './PrefabEditor';
+import { useEditorContext } from './EditorContext';
 import { loadJson, loadJsonFile, saveJson, withBasePath } from './utils';
 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,7 +14,7 @@ import { useState } from 'react';
 import EditorTree from './EditorTree';
 import { canAddComponentToNode, getAllComponentDefs, getNextComponentKey } from './components/ComponentRegistry';
 import { createComponentData } from './prefab';
-import { useEditorRef } from './PrefabEditor';
+import { useEditorRef } from './EditorContext';
 import { base, colors, inspector, componentCard } from './styles';
 import { usePrefabStore } from './prefabStore';
 function EditorUI({ selectedId, setSelectedId, getPrefab, onReplacePrefab, onImportPrefab, basePath, onUndo, onRedo, canUndo, canRedo }) {

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

@@ -1,44 +1,11 @@
-import GameCanvas from "../../shared/GameCanvas";
 import type { Prefab } from "./types";
-import { PrefabEditorMode, type Scene } from "./PrefabRoot";
-import type { ExportGLBOptions } from "./utils";
+import { GameCanvas, PrefabEditorMode } from "../../viewer";
+import { type PrefabEditorRef } from "./EditorContext";
 export { isExternalPath as isAbsoluteAssetPath } from "./utils";
 export declare function resolvePrefabAssetPath(basePath: string, file: string): string;
 export declare function getPrefabAssetRef(assetRef: string, folder: "models" | "textures" | "sound"): string;
-export interface PrefabEditorRef extends Scene {
-    save: () => Prefab;
-    load: (prefab: Prefab, options?: {
-        resetHistory?: boolean;
-        notifyChange?: boolean;
-    }) => void;
-    undo: () => void;
-    redo: () => void;
-    screenshot: () => void;
-    exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;
-    exportGLBData: () => Promise<ArrayBuffer | undefined>;
-    clearSelection: () => Promise<void>;
-}
-export type { PrefabNode } from "./PrefabRoot";
-export interface EditorContextType {
-    mode: PrefabEditorMode;
-    basePath: string;
-    setMode: (mode: PrefabEditorMode) => void;
-    transformMode: "translate" | "rotate" | "scale";
-    setTransformMode: (mode: "translate" | "rotate" | "scale") => void;
-    scaleSnap: number;
-    setScaleSnap: (resolution: number) => void;
-    positionSnap: number;
-    setPositionSnap: (resolution: number) => void;
-    rotationSnap: number;
-    setRotationSnap: (resolution: number) => void;
-    onFocusNode?: (nodeId: string) => void;
-    onScreenshot?: () => void;
-    onExportGLB?: () => void;
-}
-export declare const EditorContext: import("react").Context<EditorContextType | null>;
-export declare const EditorRefContext: import("react").Context<PrefabEditorRef | null>;
-export declare function useEditorContext(): EditorContextType;
-export declare function useEditorRef(): PrefabEditorRef;
+export type { EditorContextType, PrefabEditorRef } from "./EditorContext";
+export { EditorContext, EditorRefContext, useEditorContext, useEditorRef } from "./EditorContext";
 export interface PrefabEditorProps {
     basePath?: string;
     initialPrefab?: Prefab;

package/dist/tools/prefabeditor/PrefabEditor.js

@@ -9,18 +9,18 @@ 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, useMemo, useRef, useState, forwardRef, useImperativeHandle, createContext, useContext } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState, forwardRef, useImperativeHandle } from "react";
 import { BoxHelper } from "three";
 import { findComponentEntry } from "./types";
-import { PrefabEditorMode, PrefabRoot } from "./PrefabRoot";
+import { GameCanvas, PrefabRoot, PrefabEditorMode, SceneContext, createImageNode, createModelNode, denormalizePrefab } from "../../viewer";
 import EditorUI from "./EditorUI";
 import { base, toolbar } from "./styles";
 import { computeParentWorldMatrix, decompose, exportGLB as exportGLBFile, exportGLBData, focusCameraOnObject, isExternalPath, regenerateIds, withBasePath } from "./utils";
 import { loadDroppedAssets } from "../dragdrop";
-import { denormalizePrefab, createImageNode, createModelNode, createNode } from './prefab';
+import { createNode } from './prefab';
 import { createPrefabStore, PrefabStoreProvider } from "./prefabStore";
 import { decomposeModelToPrefabNodes, hasCollisionMeshConventions } from "./modelPrefab";
+import { EditorContext, EditorRefContext } from "./EditorContext";
 function isObjectAttachedToRoot(root, object) {
     if (!root || !object)
         return false;
@@ -48,22 +48,7 @@ function SelectionHelper({ object }) {
     useHelper(helperTarget, BoxHelper, "cyan");
     return null;
 }
-export const EditorContext = createContext(null);
-export const EditorRefContext = createContext(null);
-export function useEditorContext() {
-    const context = useContext(EditorContext);
-    if (!context) {
-        throw new Error("useEditorContext must be used within EditorContext.Provider");
-    }
-    return context;
-}
-export function useEditorRef() {
-    const editorRef = useContext(EditorRefContext);
-    if (!editorRef) {
-        throw new Error("useEditorRef must be used within PrefabEditor");
-    }
-    return editorRef;
-}
+export { EditorContext, EditorRefContext, useEditorContext, useEditorRef } from "./EditorContext";
 const MAX_HISTORY_LENGTH = 50;
 const HISTORY_DEBOUNCE_MS = 500;
 const DEFAULT_PREFAB = {
@@ -404,7 +389,7 @@ const PrefabEditor = forwardRef(({ basePath = "", initialPrefab, mode: initialMo
         canvasRef.current = state.gl.domElement;
         (_a = canvasProps === null || canvasProps === void 0 ? void 0 : canvasProps.onCreated) === null || _a === void 0 ? void 0 : _a.call(canvasProps, state);
     }, [canvasProps]);
-    return _jsx(PrefabStoreProvider, { store: prefabStore, children: _jsx(EditorRefContext.Provider, { value: editorRefValue, children: _jsxs(EditorContext.Provider, { value: {
+    return _jsx(PrefabStoreProvider, { store: prefabStore, children: _jsx(EditorRefContext.Provider, { value: editorRefValue, children: _jsx(EditorContext.Provider, { value: {
                     mode,
                     basePath,
                     setMode: updateMode,
@@ -419,16 +404,16 @@ const PrefabEditor = forwardRef(({ basePath = "", initialPrefab, mode: initialMo
                     onFocusNode: isEditMode ? handleFocusNode : undefined,
                     onScreenshot: handleScreenshot,
                     onExportGLB: handleExportGLB
-                }, children: [_jsxs(GameCanvas, Object.assign({ camera: { position: [0, 5, 15] } }, canvasProps, { onCreated: handleCanvasCreated, onPointerMissed: isEditMode
-                            ? (event) => {
-                                var _a, _b, _c, _d;
-                                const button = (_c = (_a = event.button) !== null && _a !== void 0 ? _a : (_b = event.sourceEvent) === null || _b === void 0 ? void 0 : _b.button) !== null && _c !== void 0 ? _c : 0;
-                                if (button === 0 && selectedId) {
-                                    setSelection(null);
+                }, children: _jsxs(SceneContext.Provider, { value: sceneValue, children: [_jsxs(GameCanvas, Object.assign({ camera: { position: [0, 5, 15] } }, canvasProps, { onCreated: handleCanvasCreated, onPointerMissed: isEditMode
+                                ? (event) => {
+                                    var _a, _b, _c, _d;
+                                    const button = (_c = (_a = event.button) !== null && _a !== void 0 ? _a : (_b = event.sourceEvent) === null || _b === void 0 ? void 0 : _b.button) !== null && _c !== void 0 ? _c : 0;
+                                    if (button === 0 && selectedId) {
+                                        setSelection(null);
+                                    }
+                                    (_d = canvasProps === null || canvasProps === void 0 ? void 0 : canvasProps.onPointerMissed) === null || _d === void 0 ? void 0 : _d.call(canvasProps, event);
                                 }
-                                (_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: [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: transformMode === "translate" ? "world" : "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", { type: "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: transformMode === "translate" ? "world" : "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", { type: "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;

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

@@ -1,35 +1,11 @@
 import { Matrix4 } from "three";
-import type { Object3D, Texture } from "three";
+import type { Object3D } from "three";
 import { type ThreeEvent } from "@react-three/fiber";
 import type { GameObject as GameObjectType, Prefab } from "./types";
 import type { LoadedModels } from "../dragdrop";
 import type { PrefabStoreApi } from "./prefabStore";
-export declare enum PrefabEditorMode {
-    Edit = "edit",
-    Play = "play"
-}
-export type PrefabNode = Omit<GameObjectType, "children">;
-export interface Scene {
-    root: Object3D | null;
-    mode: PrefabEditorMode;
-    basePath: string;
-    get(id: string): GameObjectType | null;
-    getObject(id: string): Object3D | null;
-    getHandle<T = unknown>(id: string, kind: string): T | null;
-    getModel(path: string): Object3D | null;
-    add(node: GameObjectType, parentId?: string): GameObjectType;
-    update(id: string, fn: (node: PrefabNode) => PrefabNode): void;
-    replaceNode(id: string, node: GameObjectType): void;
-    remove(id: string): void;
-    duplicate(id: string): string | null;
-    move(draggedId: string, targetId: string, position: "before" | "inside"): void;
-    replace(prefab: Prefab): void;
-    addModel(path: string, model: Object3D): void;
-    addTexture(path: string, texture: Texture): void;
-    addSound(path: string, sound: AudioBuffer): void;
-}
-export declare const SceneContext: import("react").Context<Scene | null>;
-export declare function useScene(): Scene;
+import { type Scene } from "./SceneContext";
+export type { Scene };
 export interface PrefabRootProps {
     editMode?: boolean;
     data?: Prefab;

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -19,26 +19,22 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 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 { forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
 import { Euler, Matrix4 } from "three";
 import { useThree } from "@react-three/fiber";
 import { useStore } from "zustand";
 import { useClickValid } from "./useClickValid";
 import { findComponent, getNodeUserData } from "./types";
-import { getComponentDef, registerComponent } from "./components/ComponentRegistry";
-import { builtinComponents } from "./components";
+import { getComponentDef } from "./components/ComponentRegistry";
 import { loadModel, loadSound, loadTexture } from "../dragdrop";
 import { GameInstance, GameInstanceProvider, getRepeatAxesFromModelProperties } from "./InstanceProvider";
-import { composeTransform, decompose, withBasePath } from "./utils";
+import { composeTransform, decompose, withBasePath } from "./runtimeUtils";
 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);
+import { PrefabEditorMode, SceneContext } from "./SceneContext";
 const IDENTITY = new Matrix4();
-const EMPTY_MODELS = {};
-const EMPTY_TEXTURES = {};
-const EMPTY_SOUNDS = {};
 const EMPTY_NODE_COMPONENTS = {
     geometry: undefined,
     materials: [],
@@ -76,28 +72,14 @@ function getNodeMetadataProps(node) {
         userData: Object.assign(Object.assign({ prefabNodeId: node.id }, (nodeName ? { prefabNodeName: nodeName } : {})), getNodeUserData(node)),
     };
 }
-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 parentScene = useContext(SceneContext);
+    const parentAssetRuntime = useContext(AssetRuntimeContext);
     const renderer = useThree(state => state.gl);
     const camera = useThree(state => state.camera);
     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());
@@ -119,19 +101,18 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
     const usesOwnedStore = resolvedStore === ownedStore;
     const rootId = useStore(resolvedStore, state => state.rootId);
     const assetRefCounts = useStore(resolvedStore, state => state.assetRefCounts);
-    const availableModels = useMemo(() => (Object.assign(Object.assign({}, models), injectedModels)), [models, injectedModels]);
-    const getModel = useCallback((path) => { var _a; return (_a = availableModels[path]) !== null && _a !== void 0 ? _a : null; }, [availableModels]);
-    const getTexture = useCallback((path) => { var _a, _b; return (_b = (_a = injectedTextures[path]) !== null && _a !== void 0 ? _a : textures[path]) !== null && _b !== void 0 ? _b : null; }, [injectedTextures, textures]);
-    const getSound = useCallback((path) => { var _a, _b; return (_b = (_a = injectedSounds[path]) !== null && _a !== void 0 ? _a : sounds[path]) !== null && _b !== void 0 ? _b : null; }, [injectedSounds, sounds]);
-    const assetRevision = useMemo(() => `${Object.keys(textures).concat(Object.keys(injectedTextures)).sort().join('|')}::${Object.keys(availableModels).sort().join('|')}`, [availableModels, injectedTextures, textures]);
+    const getModel = useCallback((path) => { var _a, _b; return (_b = (_a = models[path]) !== null && _a !== void 0 ? _a : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getModel(path)) !== null && _b !== void 0 ? _b : null; }, [models, parentAssetRuntime]);
+    const getTexture = useCallback((path) => { var _a, _b; return (_b = (_a = textures[path]) !== null && _a !== void 0 ? _a : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getTexture(path)) !== null && _b !== void 0 ? _b : null; }, [parentAssetRuntime, textures]);
+    const getSound = useCallback((path) => { var _a, _b; return (_b = (_a = sounds[path]) !== null && _a !== void 0 ? _a : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getSound(path)) !== null && _b !== void 0 ? _b : null; }, [parentAssetRuntime, sounds]);
+    const assetRevision = useMemo(() => { var _a; return `${(_a = parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getAssetRevision()) !== null && _a !== void 0 ? _a : ""}::${Object.keys(textures).sort().join('|')}::${Object.keys(models).sort().join('|')}`; }, [models, parentAssetRuntime, textures]);
     const getObject = useCallback((id) => {
-        var _a;
-        return (_a = objectRefs.current[id]) !== null && _a !== void 0 ? _a : null;
-    }, []);
-    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;
-    }, []);
+        return (_b = (_a = objectRefs.current[id]) !== null && _a !== void 0 ? _a : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getObject(id)) !== null && _b !== void 0 ? _b : null;
+    }, [parentAssetRuntime]);
+    const getHandle = useCallback((id, kind) => {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = nodeHandles.current.get(id)) === null || _a === void 0 ? void 0 : _a.get(kind)) !== null && _b !== void 0 ? _b : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getHandle(id, kind)) !== null && _c !== void 0 ? _c : null;
+    }, [parentAssetRuntime]);
     const getNode = useCallback((nodeId) => {
         var _a;
         return (_a = resolvedStore.getState().nodesById[nodeId]) !== null && _a !== void 0 ? _a : null;
@@ -139,6 +120,7 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
     const registerHandle = useCallback((id, kind, handle) => {
         const current = nodeHandles.current.get(id);
         if (handle == null) {
+            parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerHandle(id, kind, null);
             if (!current)
                 return;
             current.delete(kind);
@@ -149,10 +131,34 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
         }
         if (current) {
             current.set(kind, handle);
+            parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerHandle(id, kind, handle);
             return;
         }
         nodeHandles.current.set(id, new Map([[kind, handle]]));
-    }, []);
+        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerHandle(id, kind, handle);
+    }, [parentAssetRuntime]);
+    const registerObject = useCallback((id, obj) => {
+        if (obj) {
+            objectRefs.current[id] = obj;
+        }
+        else {
+            delete objectRefs.current[id];
+        }
+        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerObject(id, obj);
+    }, [parentAssetRuntime]);
+    const registerModel = useCallback((path, model) => {
+        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerModel(path, model);
+        setModels(prev => prev[path] === model ? prev : Object.assign(Object.assign({}, prev), { [path]: model }));
+    }, [parentAssetRuntime]);
+    const registerTexture = useCallback((path, texture) => {
+        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerTexture(path, texture);
+        setTextures(prev => prev[path] === texture ? prev : Object.assign(Object.assign({}, prev), { [path]: texture }));
+    }, [parentAssetRuntime]);
+    const registerSound = useCallback((path, sound) => {
+        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerSound(path, sound);
+        soundManager.setBuffer(path, sound);
+        setSounds(prev => prev[path] === sound ? prev : Object.assign(Object.assign({}, prev), { [path]: sound }));
+    }, [parentAssetRuntime]);
     const sceneValue = useMemo(() => ({
         get root() {
             var _a;
@@ -182,27 +188,21 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
             void precompileModel(model, renderer, camera).then(() => {
                 if (injectedModelVersions.current[path] !== version)
                     return;
-                setInjectedModels(prev => (Object.assign(Object.assign({}, prev), { [path]: model })));
+                registerModel(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 })));
-        },
-    }), [basePath, camera, editMode, getHandle, getModel, getNode, getObject, renderer, resolvedStore, rootId]);
+        addTexture: registerTexture,
+        addSound: registerSound,
+    }), [basePath, camera, editMode, getHandle, getModel, getNode, getObject, registerModel, registerSound, registerTexture, renderer, resolvedStore, rootId]);
     useImperativeHandle(ref, () => sceneValue, [sceneValue]);
-    const registerRef = useCallback((id, obj) => {
-        objectRefs.current[id] = obj;
-    }, []);
     useEffect(() => {
         if (usesOwnedStore && data) {
             resolvedStore.getState().replacePrefab(data);
         }
     }, [data, resolvedStore, usesOwnedStore]);
     useEffect(() => {
-        const loadAsset = (file, loaded, injected, failed, loader) => {
-            if (loaded[file] || injected[file] || loading.current.has(file) || failed.has(file))
+        const loadAsset = (file, loaded, failed, loader) => {
+            if (loaded[file] || loading.current.has(file) || failed.has(file))
                 return;
             loading.current.add(file);
             void loader(withBasePath(basePath, file)).then(result => {
@@ -218,45 +218,63 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
             const type = entry.slice(0, separator);
             const file = entry.slice(separator + 1);
             if (type === 'model') {
-                loadAsset(file, models, injectedModels, failedModels.current, path => loadModel(path).then((result) => __awaiter(void 0, void 0, void 0, function* () {
+                const inheritedModel = models[file] ? null : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getModel(file);
+                if (inheritedModel) {
+                    registerModel(file, inheritedModel);
+                    return;
+                }
+                loadAsset(file, models, failedModels.current, path => loadModel(path).then((result) => __awaiter(void 0, void 0, void 0, function* () {
                     const loadedModel = result.model;
                     if (result.success && loadedModel) {
                         yield precompileModel(loadedModel, renderer, camera);
-                        setModels(currentModels => (Object.assign(Object.assign({}, currentModels), { [file]: loadedModel })));
+                        registerModel(file, loadedModel);
                     }
                     return result;
                 })));
             }
             else if (type === 'texture') {
-                loadAsset(file, textures, injectedTextures, failedTextures.current, path => loadTexture(path).then(result => {
+                const inheritedTexture = textures[file] ? null : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getTexture(file);
+                if (inheritedTexture) {
+                    registerTexture(file, inheritedTexture);
+                    return;
+                }
+                loadAsset(file, textures, failedTextures.current, path => loadTexture(path).then(result => {
                     const loadedTexture = result.texture;
                     if (result.success && loadedTexture) {
-                        setTextures(currentTextures => (Object.assign(Object.assign({}, currentTextures), { [file]: loadedTexture })));
+                        registerTexture(file, loadedTexture);
                     }
                     return result;
                 }));
             }
             else if (type === 'sound') {
-                loadAsset(file, sounds, injectedSounds, failedSounds.current, path => loadSound(path).then(result => {
+                const inheritedSound = sounds[file] ? null : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getSound(file);
+                if (inheritedSound) {
+                    registerSound(file, inheritedSound);
+                    return;
+                }
+                loadAsset(file, sounds, failedSounds.current, path => loadSound(path).then(result => {
                     const loadedSound = result.sound;
                     if (result.success && loadedSound) {
-                        soundManager.setBuffer(file, loadedSound);
-                        setSounds(currentSounds => (Object.assign(Object.assign({}, currentSounds), { [file]: loadedSound })));
+                        registerSound(file, loadedSound);
                     }
                     return result;
                 }));
             }
         });
-    }, [assetRefCounts, basePath, camera, injectedModels, injectedSounds, injectedTextures, models, renderer, sounds, textures]);
+    }, [assetRefCounts, basePath, camera, models, parentAssetRuntime, registerModel, registerSound, registerTexture, renderer, sounds, textures]);
     const assetRuntime = useMemo(() => ({
+        registerObject,
         registerHandle,
+        registerModel,
+        registerTexture,
+        registerSound,
         getHandle,
         getObject,
         getModel,
         getTexture,
         getSound,
         getAssetRevision: () => assetRevision,
-    }), [registerHandle, getHandle, getObject, getModel, getTexture, getSound, assetRevision]);
+    }), [registerObject, registerHandle, registerModel, registerTexture, registerSound, getHandle, getObject, getModel, getTexture, getSound, assetRevision]);
     const handleNodeClick = useCallback((event, nodeId, fallbackObject) => {
         const node = resolvedStore.getState().nodesById[nodeId];
         if (!node)
@@ -265,9 +283,10 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
         emitNodePointerEvent(clickEventName, event, nodeId, node, fallbackObject);
         onClick === null || onClick === void 0 ? void 0 : onClick(event, node);
     }, [onClick, resolvedStore]);
-    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, basePath: basePath }), children] }));
-    const runtimeContent = (_jsx(SceneContext.Provider, { value: sceneValue, children: _jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content }) }));
-    return _jsx(PrefabStoreProvider, { store: resolvedStore, children: runtimeContent });
+    const content = (_jsxs(GameInstanceProvider, { models: models, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, registerRef: registerObject, children: [_jsx(StoreRootNode, { selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, onEditNodeClick: editMode ? onEditNodeClick : undefined, registerRef: registerObject, loadedModels: models, editMode: editMode, parentMatrix: IDENTITY, basePath: basePath }), children] }));
+    const runtimeContent = parentAssetRuntime ? content : (_jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content }));
+    const sceneContent = parentScene ? runtimeContent : (_jsx(SceneContext.Provider, { value: sceneValue, children: runtimeContent }));
+    return _jsx(PrefabStoreProvider, { store: resolvedStore, children: sceneContent });
 });
 function StoreRootNode(props) {
     const rootId = usePrefabRootId();