react-three-game 0.0.108 → 0.0.110

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} />;
@@ -153,6 +153,7 @@ interface GameObject {
   name?: string;
   disabled?: boolean;
   locked?: boolean;
+  hidden?: boolean;
   components?: Record<string, { type: string; properties: any }>;
   children?: GameObject[];
 }
@@ -164,7 +165,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 +200,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 +215,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();
@@ -280,17 +281,9 @@ Custom component `View`s use normal React and R3F behavior — `useFrame`, refs,
 
 ## Useful Exports
 
-* `GameCanvas`, `PrefabRoot`, `PrefabEditor`, `PrefabEditorMode`
-* `Prefab`, `GameObject`, `ComponentData`, `PrefabNode`, `PrefabEditorRef`, `Scene`
-* `registerComponent`, `Component`, `ComponentViewProps`, `FieldDefinition`
-* `useScene`, `useEditorRef`, `useEditorContext`
-* `useNode`, `useNodeObject`, `useNodeHandle`, `useAssetRuntime`
-* `usePrefabStore`, `usePrefabStoreApi`
-* `gameEvents`, `useGameEvent`, `useClickEvent`
-* `loadJson`, `saveJson`, `loadFiles`, `loadModel`, `loadTexture`, `loadSound`
-* `exportGLB`, `exportGLBData`, `regenerateIds`, `computeParentWorldMatrix`
-* `ground`, `soundManager`
-* `FieldRenderer`, `Vector3Field`, `NumberField`, `StringField`, `BooleanField`, `SelectField`, `ColorField`
+* `react-three-game/viewer`: `GameCanvas`, `PrefabRoot`, `PrefabEditorMode`, `registerComponent`, scene hooks, event hooks, asset/runtime hooks, prefab types, loaders, `ground`, and `soundManager`
+* `react-three-game/editor`: everything from `/viewer`, plus `PrefabEditor`, editor refs/context, prefab store hooks, inspector field components, JSON import/export helpers, GLB export helpers, material overrides, model decomposition, asset viewer components, and `three/tsl` helpers
+* `react-three-game/plugins/crashcat`: `CrashcatRuntime`, `CrashcatPhysicsComponent`, `CrashcatRagdollComponent`, ragdoll helpers, static body helpers, and `useCrashcat`
 
 ## Development
 

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

@@ -1,11 +1,12 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useFrame } from "@react-three/fiber";
-import { useEffect, useMemo, useRef } from "react";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useStore } from "zustand";
 import { BooleanField, FieldRenderer, StringField, Vector3Field, } from "../../tools/prefabeditor/components/Input";
-import { useAssetRuntime, useNode } from "../../tools/prefabeditor/assetRuntime";
+import { useModelAsset, 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";
@@ -51,7 +52,26 @@ const scratchBoundsSize = new Vector3();
 const worldQuaternion = new Quaternion();
 const parentWorldQuaternion = new Quaternion();
 const localQuaternion = new Quaternion();
+// Extracted collider geometry is keyed by the sequence of geometry UUIDs in the
+// object's subtree. Clones of the same model share geometry instances and have
+// identical model-internal transforms, and the extraction is expressed in
+// object-local space (the object's own world transform is divided out), so the
+// result is identical across every instance/body of that model. Extracting once
+// avoids re-walking thousands of vertices per rigid body.
+const geometryDataCache = new Map();
 function collectGeometryData(object) {
+    let cacheKey = "";
+    object.traverse((child) => {
+        var _a;
+        const geometry = child.geometry;
+        if (((_a = geometry === null || geometry === void 0 ? void 0 : geometry.attributes) === null || _a === void 0 ? void 0 : _a.position) && geometry.uuid)
+            cacheKey += `${geometry.uuid};`;
+    });
+    if (cacheKey) {
+        const cached = geometryDataCache.get(cacheKey);
+        if (cached)
+            return cached;
+    }
     const positions = [];
     const indices = [];
     let vertexOffset = 0;
@@ -83,7 +103,10 @@ function collectGeometryData(object) {
     });
     if (positions.length === 0 || indices.length < 3)
         return null;
-    return { positions, indices };
+    const result = { positions, indices };
+    if (cacheKey)
+        geometryDataCache.set(cacheKey, result);
+    return result;
 }
 function createShapeForObject(object, physics) {
     var _a, _b;
@@ -246,8 +269,23 @@ function CrashcatPhysicsView({ properties, children }) {
     const scene = useScene();
     const store = usePrefabStoreApi();
     const api = useCrashcat();
-    const { getAssetRevision } = useAssetRuntime();
-    const revision = getAssetRevision();
+    // Subscribe only to this node's Model filename (not its full node, which would
+    // re-render on every transform edit), then to that one model's loaded asset.
+    // Colliders rebuild when *this* node's mesh loads, not when any asset loads.
+    const modelPath = useStore(store, useCallback((s) => {
+        var _a, _b;
+        const node = s.nodesById[nodeId];
+        if (!node)
+            return null;
+        for (const key in node.components) {
+            const component = node.components[key];
+            if ((component === null || component === void 0 ? void 0 : component.type) === "Model") {
+                return (_b = (_a = component.properties) === null || _a === void 0 ? void 0 : _a.filename) !== null && _b !== void 0 ? _b : null;
+            }
+        }
+        return null;
+    }, [nodeId]));
+    const loadedModel = useModelAsset(modelPath);
     const bodyRef = useRef(null);
     const motionTypeRef = useRef(MotionType.STATIC);
     const needsRegistrationRef = useRef(false);
@@ -307,8 +345,8 @@ function CrashcatPhysicsView({ properties, children }) {
         lastQuaternionRef.current = null;
     };
     useEffect(() => {
-        // Rebuild mesh-derived colliders when referenced assets finish loading.
-        void revision;
+        // Rebuild mesh-derived colliders when this node's referenced model finishes loading.
+        void loadedModel;
         needsRegistrationRef.current = true;
         if (api) {
             api.unregister(nodeId);
@@ -325,7 +363,7 @@ function CrashcatPhysicsView({ properties, children }) {
         getObject,
         nodeId,
         physics,
-        revision,
+        loadedModel,
     ]);
     useFrame(() => {
         if (needsRegistrationRef.current) {

package/dist/plugins/crashcat/CrashcatRagdoll.d.ts

@@ -52,7 +52,7 @@ export type CrashcatRagdollProps = {
     nodeInteractionHandlers?: NodeInteractionHandlers;
 };
 export declare function createRagdollSettings(scale?: number, angleA?: number, angleB?: number, twistAngle?: number): RagdollSettings;
-export declare function CrashcatRagdoll({ position, scale, swingAngle, shoulderAngle, twistAngle, stabilize, initialLinearVelocity, initialAngularVelocity, color, clickImpulse, nodeInteractionHandlers, }: CrashcatRagdollProps): import("react/jsx-runtime").JSX.Element;
+export declare function CrashcatRagdoll({ position, scale, swingAngle, shoulderAngle, twistAngle, stabilize, initialLinearVelocity, initialAngularVelocity, color, clickImpulse, nodeInteractionHandlers, }: CrashcatRagdollProps): import("react").JSX.Element;
 declare const CrashcatRagdollComponent: Component;
 export default CrashcatRagdollComponent;
 export declare function createStaticBoxBody(world: World, objectLayer: number, halfExtents: Vec3, position: Vec3): rigidBody.RigidBody;

package/dist/plugins/crashcat/CrashcatRuntime.d.ts

@@ -24,4 +24,4 @@ export declare function useCrashcat(): CrashcatApi | null;
 export declare function CrashcatRuntime({ debug, children }: {
     debug?: boolean;
     children?: React.ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

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/shared/ContactShadow.d.ts

@@ -4,5 +4,5 @@ interface ContactShadowProps {
     scale?: number;
     yOffset?: number;
 }
-declare const ContactShadow: ({ opacity, blur, scale, yOffset, }: ContactShadowProps) => import("react/jsx-runtime").JSX.Element;
+declare const ContactShadow: ({ opacity, blur, scale, yOffset, }: ContactShadowProps) => import("react").JSX.Element;
 export default ContactShadow;

package/dist/shared/GameCanvas.d.ts

@@ -5,4 +5,4 @@ export interface GameCanvasProps extends Omit<CanvasProps, 'children'> {
     children: React.ReactNode;
     glConfig?: WebGPURendererParameters;
 }
-export default function GameCanvas({ loader, children, glConfig, onCreated, style, ...props }: GameCanvasProps): import("react/jsx-runtime").JSX.Element;
+export default function GameCanvas({ loader, children, glConfig, onCreated, style, ...props }: GameCanvasProps): import("react").JSX.Element;

package/dist/tools/assetviewer/page.d.ts

@@ -4,48 +4,48 @@ interface TextureListViewerProps {
     onSelect: (file: string) => void;
     basePath?: string;
 }
-export declare function TextureListViewer({ files, selected, onSelect, basePath }: TextureListViewerProps): import("react/jsx-runtime").JSX.Element;
+export declare function TextureListViewer({ files, selected, onSelect, basePath }: TextureListViewerProps): import("react").JSX.Element;
 interface ModelListViewerProps {
     files: string[];
     selected?: string;
     onSelect: (file: string) => void;
     basePath?: string;
 }
-export declare function ModelListViewer({ files, selected, onSelect, basePath }: ModelListViewerProps): import("react/jsx-runtime").JSX.Element;
+export declare function ModelListViewer({ files, selected, onSelect, basePath }: ModelListViewerProps): import("react").JSX.Element;
 interface SoundListViewerProps {
     files: string[];
     selected?: string;
     onSelect: (file: string) => void;
     basePath?: string;
 }
-export declare function SoundListViewer({ files, selected, onSelect, basePath }: SoundListViewerProps): import("react/jsx-runtime").JSX.Element;
+export declare function SoundListViewer({ files, selected, onSelect, basePath }: SoundListViewerProps): import("react").JSX.Element;
 export declare function TexturePicker({ value, onChange, basePath }: {
     value: string | undefined;
     onChange: (value: string | undefined) => void;
     basePath?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function ModelPicker({ value, onChange, basePath, pickerKey }: {
     value: string | undefined;
     onChange: (value: string | undefined) => void;
     basePath?: string;
     pickerKey?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function SoundPicker({ value, onChange, basePath }: {
     value: string | undefined;
     onChange: (value: string | undefined) => void;
     basePath?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function SingleTextureViewer({ file, basePath }: {
     file?: string;
     basePath?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function SingleModelViewer({ file, basePath }: {
     file?: string;
     basePath?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function SingleSoundViewer({ file, basePath }: {
     file?: string;
     basePath?: string;
-}): import("react/jsx-runtime").JSX.Element | null;
-export declare function SharedCanvas(): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element | null;
+export declare function SharedCanvas(): import("react").JSX.Element;
 export {};

package/dist/tools/dragdrop/DragDropLoader.d.ts

@@ -21,6 +21,6 @@ export declare function loadDroppedAssets(dataTransfer: DataTransfer | null, opt
 export declare function loadUrls(urls: string[], options: AssetLoadOptions): Promise<void>;
 export declare function loadUrl(url: string, options: AssetLoadOptions): Promise<void>;
 export declare function loadFiles(files: File[], { onModelLoaded, onTextureLoaded, onSoundLoaded, onUnhandledFile, onFilesLoaded, onLoadError }: AssetLoadOptions): Promise<void>;
-export declare function DragDropLoader({ children, ...divProps }: DragDropLoaderProps): import("react/jsx-runtime").JSX.Element;
-export declare function FilePicker({ accept, children, multiple, ...divProps }: FilePickerProps): import("react/jsx-runtime").JSX.Element;
+export declare function DragDropLoader({ children, ...divProps }: DragDropLoaderProps): import("react").JSX.Element;
+export declare function FilePicker({ accept, children, multiple, ...divProps }: FilePickerProps): import("react").JSX.Element;
 export {};

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

@@ -11,5 +11,5 @@ export declare function Dropdown({ trigger, children, placement, offset, zIndex,
     placement?: Placement;
     offset?: number;
     zIndex?: number;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export {};

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.d.ts

@@ -9,4 +9,4 @@ export default function EditorTree({ selectedId, setSelectedId, getPrefab, onRep
     onRedo?: () => void;
     canUndo?: boolean;
     canRedo?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

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.d.ts

@@ -14,7 +14,7 @@ export declare function TreeNodeMenu({ isRoot, nodeId, locked, onAddChild, onFoc
     onDuplicate?: (nodeId: string) => void;
     onDelete?: (nodeId: string) => void;
     onClose: () => void;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function TreeContextMenu({ contextMenu, onClose, children, }: {
     contextMenu: TreeContextMenuState;
     onClose: () => void;
@@ -26,4 +26,4 @@ export declare function FileMenu({ getPrefab, onReplacePrefab, onImportPrefab, o
     onImportPrefab: (prefab: Prefab) => void;
     onImportPackedPrefab: (url: string) => void;
     onClose: () => void;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

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.d.ts

@@ -10,5 +10,5 @@ declare function EditorUI({ selectedId, setSelectedId, getPrefab, onReplacePrefa
     onRedo?: () => void;
     canUndo?: boolean;
     canRedo?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export default EditorUI;

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/InstanceProvider.d.ts

@@ -29,7 +29,7 @@ export declare function GameInstanceProvider({ children, models, onSelect, onCli
     registerRef?: (id: string, obj: Object3D | null) => void;
     selectedId?: string | null;
     editMode?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function useInstanceCheck(id: string): boolean;
 export declare function GameInstance({ id, sourceId, modelUrl, locked, position, rotation, scale, visible, onClick: _onClick, }: {
     id: string;

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;