react-three-game 0.0.106 → 0.0.108

package/dist/tools/prefabeditor/components/ComponentRegistry.d.ts

@@ -1,4 +1,5 @@
 import type { FC } from "react";
+import type { ThreeEvent } from "@react-three/fiber";
 import type { ComponentData, GameObject } from "../types";
 export type AssetRef = {
     type: "model" | "texture" | "sound";
@@ -12,13 +13,27 @@ export interface ComponentViewProps<P = Record<string, unknown>> {
     properties: P;
     /** Children to render for components that wrap the current subtree. */
     children?: React.ReactNode;
+    /** Whether this node is currently rendered in editor mode. */
+    editMode?: boolean;
+    /** Node-level pointer/click handlers for custom components that render their own pickable objects. */
+    nodeInteractionHandlers?: NodeInteractionHandlers;
     /** Current node local position for wrapper components. */
     position?: [number, number, number];
     /** Current node local rotation in radians for wrapper components. */
     rotation?: [number, number, number];
     /** Current node local scale for wrapper components. */
     scale?: [number, number, number];
+    /** Current node world position. Components that create world-space resources should prefer this. */
+    worldPosition?: [number, number, number];
+    /** Public asset URL prefix, such as a Next.js basePath. */
+    basePath?: string;
 }
+export type NodeInteractionHandlers = {
+    onClick?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerDown?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerMove?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerUp?: (event: ThreeEvent<PointerEvent>) => void;
+};
 export interface Component {
     name: string;
     /** Set when this component occupies a single slot on a node. Use a string to share a slot across component types. */

package/dist/tools/prefabeditor/components/PrefabRefComponent.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from './ComponentRegistry';
+declare const PrefabRefComponent: Component;
+export default PrefabRefComponent;

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

@@ -0,0 +1,72 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import PrefabRoot from '../PrefabRoot';
+import { useEditorRef } from '../PrefabEditor';
+import { withBasePath } from '../utils';
+import { base, colors } from '../styles';
+import { FieldGroup, Label } from './Input';
+function PrefabRefView({ properties, children, basePath = '' }) {
+    var _a;
+    const [loadedPrefab, setLoadedPrefab] = useState(null);
+    const url = (_a = properties.url) !== null && _a !== void 0 ? _a : '';
+    const resolvedUrl = url ? withBasePath(basePath, url) : '';
+    useEffect(() => {
+        if (!resolvedUrl)
+            return;
+        let cancelled = false;
+        fetch(resolvedUrl)
+            .then(r => r.json())
+            .then(data => { if (!cancelled)
+            setLoadedPrefab(data); })
+            .catch(err => console.warn('[PrefabRef] Failed to load:', resolvedUrl, err));
+        return () => { cancelled = true; };
+    }, [resolvedUrl]);
+    return (_jsxs(_Fragment, { children: [loadedPrefab && _jsx(PrefabRoot, { data: loadedPrefab, editMode: false, basePath: basePath }), children] }));
+}
+function PrefabRefEditor({ node, component, onUpdate, basePath = '', }) {
+    var _a, _b;
+    const url = (_b = (_a = component.properties) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : '';
+    const [manifest, setManifest] = useState([]);
+    const [unpacking, setUnpacking] = useState(false);
+    const editor = useEditorRef();
+    useEffect(() => {
+        fetch(withBasePath(basePath, '/prefabs/manifest.json'))
+            .then(r => r.json())
+            .then(data => setManifest(data))
+            .catch(() => setManifest([]));
+    }, []);
+    const handleUnpack = () => __awaiter(this, void 0, void 0, function* () {
+        if (!node || !url)
+            return;
+        setUnpacking(true);
+        try {
+            const prefab = yield fetch(withBasePath(basePath, url)).then(r => r.json());
+            editor.replaceNode(node.id, prefab.root);
+        }
+        catch (err) {
+            console.error('[PrefabRef] Unpack failed:', err);
+        }
+        finally {
+            setUnpacking(false);
+        }
+    });
+    return (_jsxs(FieldGroup, { children: [_jsxs("div", { children: [_jsx(Label, { children: "Prefab URL" }), _jsx("input", { type: "text", style: Object.assign(Object.assign({}, base.input), { width: '100%', boxSizing: 'border-box', fontFamily: 'monospace' }), value: url, onChange: e => onUpdate({ url: e.target.value }), placeholder: "/prefabs/my-prefab.json" }), manifest.length > 0 && (_jsxs("select", { style: Object.assign(Object.assign({}, base.input), { width: '100%', marginTop: 4, background: colors.bgInput, boxSizing: 'border-box' }), value: url, onChange: e => onUpdate({ url: e.target.value }), children: [_jsx("option", { value: "", children: "\u2014 pick from manifest \u2014" }), manifest.map(entry => (_jsx("option", { value: entry, children: entry.replace(/^.*\//, '') }, entry)))] }))] }), _jsx("button", { type: "button", style: Object.assign(Object.assign({}, base.btn), { width: '100%', opacity: unpacking || !url ? 0.5 : 1 }), disabled: unpacking || !url, onClick: handleUnpack, children: unpacking ? 'Unpacking…' : 'Unpack' })] }));
+}
+const PrefabRefComponent = {
+    name: 'PrefabRef',
+    Editor: PrefabRefEditor,
+    View: PrefabRefView,
+    defaultProperties: {
+        url: '',
+    },
+};
+export default PrefabRefComponent;

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

@@ -1,9 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ColorField, FieldGroup, NumberField, SelectField, StringField } from "./Input";
 import { Text } from 'three-text/three/react';
-import { useRef, useState, useCallback } from 'react';
-// Initialize HarfBuzz path for font shaping
-Text.setHarfBuzzPath('/fonts/hb.wasm');
+import { useRef, useState, useCallback, useEffect } from 'react';
+import { withBasePath } from "../utils";
 function TextComponentEditor({ component, onUpdate, }) {
     return (_jsxs(FieldGroup, { children: [_jsx(StringField, { name: "text", label: "Text", values: component.properties, onChange: onUpdate, placeholder: "Enter text..." }), _jsx(ColorField, { name: "color", label: "Color", values: component.properties, onChange: onUpdate }), _jsx(StringField, { name: "font", label: "Font", values: component.properties, onChange: onUpdate, placeholder: "/fonts/NotoSans-Regular.ttf" }), _jsx(NumberField, { name: "size", label: "Size", values: component.properties, onChange: onUpdate, min: 0.01, step: 0.1 }), _jsx(NumberField, { name: "depth", label: "Depth", values: component.properties, onChange: onUpdate, min: 0, step: 0.1 }), _jsx(NumberField, { name: "width", label: "Width", values: component.properties, onChange: onUpdate, min: 0, step: 0.5 }), _jsx(SelectField, { name: "align", label: "Align", values: component.properties, onChange: onUpdate, options: [
                     { value: 'left', label: 'Left' },
@@ -11,11 +10,15 @@ function TextComponentEditor({ component, onUpdate, }) {
                     { value: 'right', label: 'Right' },
                 ] })] }));
 }
-function TextComponentView({ properties, children }) {
+function TextComponentView({ properties, children, basePath = "" }) {
     const { text = '', font, size, depth, width, align, color } = properties;
     const textContent = String(text || '');
+    const resolvedFont = font ? withBasePath(basePath, font) : font;
     const meshRef = useRef(null);
     const [offset, setOffset] = useState([0, 0, 0]);
+    useEffect(() => {
+        Text.setHarfBuzzPath(withBasePath(basePath, '/fonts/hb.wasm'));
+    }, [basePath]);
     const handleLoad = useCallback((_geometry, info) => {
         if (info === null || info === void 0 ? void 0 : info.planeBounds) {
             const bounds = info.planeBounds;
@@ -37,7 +40,7 @@ function TextComponentView({ properties, children }) {
     }, [align]);
     if (!textContent)
         return null;
-    return (_jsxs("group", { position: offset, children: [_jsx(Text, { ref: meshRef, font: font, size: size, depth: depth, layout: { align, width }, color: color, onLoad: handleLoad, children: textContent }), children] }));
+    return (_jsxs("group", { position: offset, children: [_jsx(Text, { ref: meshRef, font: resolvedFont, size: size, depth: depth, layout: { align, width }, color: color, onLoad: handleLoad, children: textContent }), children] }));
 }
 const TextComponent = {
     name: 'Text',

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

@@ -1,5 +1,6 @@
 // biome-ignore assist/source/organizeImports: <in order of display in the editor>
 import TransformComponent from "./TransformComponent";
+import PrefabRefComponent from "./PrefabRefComponent";
 import GeometryComponent from "./GeometryComponent";
 import BufferGeometryComponent from "./BufferGeometryComponent";
 import ModelComponent from "./ModelComponent";
@@ -35,4 +36,5 @@ export const builtinComponents = [
     CameraComponent,
     SoundComponent,
     DataComponent,
+    PrefabRefComponent,
 ];

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

@@ -6,9 +6,12 @@ export interface DecomposeModelOptions {
     idPrefix?: string;
     /** Include invisible Three objects in the generated prefab tree. */
     includeInvisible?: boolean;
+    /** Create CrashcatPhysics components from Blender-style mesh name suffixes. */
+    inferCollisionMeshes?: boolean;
     /** Return a serializable texture ref for embedded or externally loaded textures. */
     getTexturePath?: (texture: Texture, usage: 'map' | 'normalMap') => string | null | undefined;
 }
+export declare function hasCollisionMeshConventions(object: Object3D, enabled?: boolean): boolean;
 /**
  * Converts a live Three object hierarchy into prefab JSON nodes made from
  * Transform, BufferGeometry, and Material components.

package/dist/tools/prefabeditor/modelPrefab.js

@@ -52,6 +52,27 @@ function serializeGeometry(geometry) {
         computeVertexNormals: normals.length === 0,
     };
 }
+function getCollisionMeshConvention(name, enabled) {
+    if (!enabled)
+        return null;
+    const match = name.match(/^(.*)_(colonly|col)(?:\.\d+)?$/i);
+    if (!match)
+        return null;
+    const [, baseName, suffix] = match;
+    return {
+        displayName: baseName || name,
+        renderMesh: suffix.toLowerCase() === 'col',
+    };
+}
+export function hasCollisionMeshConventions(object, enabled = true) {
+    let hasConvention = false;
+    object.traverse(child => {
+        if (hasConvention)
+            return;
+        hasConvention = child instanceof Mesh && getCollisionMeshConvention(child.name, enabled) != null;
+    });
+    return hasConvention;
+}
 function getSideName(side) {
     if (side === BackSide)
         return 'BackSide';
@@ -138,17 +159,19 @@ function createTransformComponent(object) {
         },
     };
 }
-function createNode(object, idPrefix, children = [], components = {}) {
+function createNode(object, idPrefix, children = [], components = {}, options = {}) {
+    var _a, _b;
     return {
         id: createId(idPrefix),
-        name: object.name || object.type,
-        hidden: object.visible === false ? true : undefined,
+        name: ((_a = options.name) !== null && _a !== void 0 ? _a : object.name) || object.type,
+        hidden: (_b = options.hidden) !== null && _b !== void 0 ? _b : (object.visible === false ? true : undefined),
         components: Object.assign({ transform: createTransformComponent(object) }, components),
         children,
     };
 }
 function decomposeObject(object, options) {
-    if (!options.includeInvisible && !object.visible)
+    const collisionMesh = getCollisionMeshConvention(object.name, options.inferCollisionMeshes);
+    if (!options.includeInvisible && !object.visible && !collisionMesh)
         return null;
     const childNodes = object.children
         .map(child => decomposeObject(child, options))
@@ -161,20 +184,30 @@ function decomposeObject(object, options) {
         result[part.key] = serializeMaterial(part.material, part.attach, options);
         return result;
     }, {});
-    return createNode(object, options.idPrefix, childNodes, Object.assign({ geometry: {
+    return createNode(object, options.idPrefix, childNodes, Object.assign(Object.assign({ geometry: {
             type: 'BufferGeometry',
-            properties: Object.assign(Object.assign({}, serializeGeometry(object.geometry)), { visible: object.visible, castShadow: object.castShadow, receiveShadow: object.receiveShadow }),
-        } }, materialComponents));
+            properties: Object.assign(Object.assign({}, serializeGeometry(object.geometry)), { visible: collisionMesh ? collisionMesh.renderMesh : object.visible, castShadow: object.castShadow, receiveShadow: object.receiveShadow }),
+        } }, materialComponents), (collisionMesh ? {
+        crashcatPhysics: {
+            type: 'CrashcatPhysics',
+            properties: {
+                type: 'fixed',
+                colliders: 'trimesh',
+                sensor: false,
+            },
+        },
+    } : null)), collisionMesh ? { name: collisionMesh.displayName, hidden: false } : undefined);
 }
 /**
  * Converts a live Three object hierarchy into prefab JSON nodes made from
  * Transform, BufferGeometry, and Material components.
  */
 export function decomposeModelToPrefabNodes(object, options = {}) {
-    var _a, _b, _c, _d, _e;
-    return (_d = decomposeObject(object, {
+    var _a, _b, _c, _d, _e, _f;
+    return (_e = decomposeObject(object, {
         idPrefix: (_a = options.idPrefix) !== null && _a !== void 0 ? _a : 'model',
         includeInvisible: (_b = options.includeInvisible) !== null && _b !== void 0 ? _b : false,
-        getTexturePath: (_c = options.getTexturePath) !== null && _c !== void 0 ? _c : (() => undefined),
-    })) !== null && _d !== void 0 ? _d : createNode(object, (_e = options.idPrefix) !== null && _e !== void 0 ? _e : 'model');
+        inferCollisionMeshes: (_c = options.inferCollisionMeshes) !== null && _c !== void 0 ? _c : true,
+        getTexturePath: (_d = options.getTexturePath) !== null && _d !== void 0 ? _d : (() => undefined),
+    })) !== null && _e !== void 0 ? _e : createNode(object, (_f = options.idPrefix) !== null && _f !== void 0 ? _f : 'model');
 }

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

@@ -1,5 +1,5 @@
-import type { ComponentData, GameObject, Prefab } from './types';
-export type PrefabNodeRecord = Omit<GameObject, 'children'>;
+import type { ComponentData, GameObject, Prefab } from "./types";
+export type PrefabNodeRecord = Omit<GameObject, "children">;
 export type PrefabAssetRefCounts = Record<string, number>;
 export interface PrefabState {
     prefabId?: string;
@@ -24,12 +24,13 @@ 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 createPackedPrefabNode(url: string): GameObject;
 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 denormalizePrefab(state: Pick<PrefabState, "prefabId" | "prefabName" | "rootId" | "nodesById" | "childIdsById">): Prefab;
 export declare function collectSubtreeIds(id: string, childIdsById: Record<string, string[]>): string[];
 export declare function insertSubtree(node: GameObject, parentId: string | null, nodesById: Record<string, PrefabNodeRecord>, childIdsById: Record<string, string[]>, parentIdById: Record<string, string | null>): void;
-export declare function cloneSubtree(id: string, parentId: string | null, source: Pick<PrefabState, 'nodesById' | 'childIdsById'>, nodesById: Record<string, PrefabNodeRecord>, childIdsById: Record<string, string[]>, parentIdById: Record<string, string | null>): string | null;
+export declare function cloneSubtree(id: string, parentId: string | null, source: Pick<PrefabState, "nodesById" | "childIdsById">, nodesById: Record<string, PrefabNodeRecord>, childIdsById: Record<string, string[]>, parentIdById: Record<string, string | null>): string | null;
 export declare function isDescendant(id: string, potentialAncestorId: string, parentIdById: Record<string, string | null>): boolean;
 export declare function updateAssetRefsForNodeChange(assetRefCounts: PrefabAssetRefCounts, currentNode: PrefabNodeRecord, nextNode: PrefabNodeRecord): PrefabAssetRefCounts;
 export declare function collectSubtreeAssetRefs(node: GameObject): string[];

package/dist/tools/prefabeditor/prefab.js

@@ -9,12 +9,12 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { getComponentAssetRefs, getComponentDef } from './components/ComponentRegistry';
+import { getComponentAssetRefs, getComponentDef, } from "./components/ComponentRegistry";
 function clonePrefabValue(value) {
     if (Array.isArray(value)) {
-        return value.map(item => clonePrefabValue(item));
+        return value.map((item) => clonePrefabValue(item));
     }
-    if (value && typeof value === 'object') {
+    if (value && typeof value === "object") {
         const clone = {};
         Object.entries(value).forEach(([key, entry]) => {
             clone[key] = clonePrefabValue(entry);
@@ -25,7 +25,7 @@ function clonePrefabValue(value) {
 }
 function createComponentMap(components) {
     const componentMap = {
-        transform: createComponentData('Transform'),
+        transform: createComponentData("Transform"),
     };
     Object.entries(components).forEach(([key, component]) => {
         componentMap[key] = createComponentData(component.type, component.properties);
@@ -33,10 +33,10 @@ function createComponentMap(components) {
     return componentMap;
 }
 function getNodeNameFromPath(path, name) {
-    return name !== null && name !== void 0 ? name : path.replace(/^.*[\/]/, '').replace(/\.[^.]+$/, '');
+    return name !== null && name !== void 0 ? name : path.replace(/^.*[\/]/, "").replace(/\.[^.]+$/, "");
 }
 function getAssetManifestKey(assetRefCounts) {
-    return Object.keys(assetRefCounts).sort().join('|');
+    return Object.keys(assetRefCounts).sort().join("|");
 }
 function sameStringArrays(left, right) {
     if (left.length !== right.length)
@@ -46,7 +46,7 @@ function sameStringArrays(left, right) {
 function getAssetRefs(node) {
     var _a;
     const refs = [];
-    Object.values((_a = node === null || node === void 0 ? void 0 : node.components) !== null && _a !== void 0 ? _a : {}).forEach(component => {
+    Object.values((_a = node === null || node === void 0 ? void 0 : node.components) !== null && _a !== void 0 ? _a : {}).forEach((component) => {
         var _a;
         if (!(component === null || component === void 0 ? void 0 : component.type))
             return;
@@ -57,13 +57,13 @@ function getAssetRefs(node) {
     return refs.sort();
 }
 function addAssetRefs(assetRefCounts, refs) {
-    refs.forEach(ref => {
+    refs.forEach((ref) => {
         var _a;
         assetRefCounts[ref] = ((_a = assetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) + 1;
     });
 }
 function removeAssetRefs(assetRefCounts, refs) {
-    refs.forEach(ref => {
+    refs.forEach((ref) => {
         var _a;
         const nextCount = ((_a = assetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) - 1;
         if (nextCount > 0) {
@@ -75,13 +75,15 @@ function removeAssetRefs(assetRefCounts, refs) {
 }
 function createAssetRefCounts(nodesById) {
     const assetRefCounts = {};
-    Object.values(nodesById).forEach(node => addAssetRefs(assetRefCounts, getAssetRefs(node)));
+    Object.values(nodesById).forEach((node) => {
+        addAssetRefs(assetRefCounts, getAssetRefs(node));
+    });
     return assetRefCounts;
 }
 function denormalizeNode(id, nodesById, childIdsById) {
     var _a;
     const node = nodesById[id];
-    return Object.assign(Object.assign({}, node), { children: ((_a = childIdsById[id]) !== null && _a !== void 0 ? _a : []).map(childId => denormalizeNode(childId, nodesById, childIdsById)) });
+    return Object.assign(Object.assign({}, node), { children: ((_a = childIdsById[id]) !== null && _a !== void 0 ? _a : []).map((childId) => denormalizeNode(childId, nodesById, childIdsById)) });
 }
 export function createDefaultComponentProperties(type) {
     var _a, _b;
@@ -90,32 +92,34 @@ export function createDefaultComponentProperties(type) {
 export function createComponentData(type, properties) {
     return {
         type,
-        properties: properties ? clonePrefabValue(properties) : createDefaultComponentProperties(type),
+        properties: properties
+            ? clonePrefabValue(properties)
+            : createDefaultComponentProperties(type),
     };
 }
 export function createNode(name, components = {}, options) {
     var _a;
     return Object.assign({ id: (_a = options === null || options === void 0 ? void 0 : options.id) !== null && _a !== void 0 ? _a : crypto.randomUUID(), name, components: createComponentMap(components) }, ((options === null || options === void 0 ? void 0 : options.children) ? { children: options.children } : null));
 }
-export function createEmptyNode(name = 'New Node') {
+export function createEmptyNode(name = "New Node") {
     return createNode(name);
 }
 export function createEmptyPrefab() {
     return {
         id: crypto.randomUUID(),
-        name: 'New Prefab',
-        root: createNode('Root', {}, { id: crypto.randomUUID(), children: [] }),
+        name: "New Prefab",
+        root: createNode("Root", {}, { id: crypto.randomUUID(), children: [] }),
     };
 }
 export function createModelNode(filename, name) {
     return createNode(getNodeNameFromPath(filename, name), {
         model: {
-            type: 'Model',
+            type: "Model",
             properties: {
                 filename,
                 instanced: false,
                 repeat: false,
-                repeatAxes: [{ axis: 'x', count: 1, offset: 1 }],
+                repeatAxes: [{ axis: "x", count: 1, offset: 1 }],
             },
         },
     });
@@ -123,12 +127,20 @@ export function createModelNode(filename, name) {
 export function createImageNode(texturePath, name) {
     return createNode(getNodeNameFromPath(texturePath, name), {
         geometry: {
-            type: 'Geometry',
-            properties: { geometryType: 'plane', args: [1, 1] },
+            type: "Geometry",
+            properties: { geometryType: "plane", args: [1, 1] },
         },
         material: {
-            type: 'Material',
-            properties: { color: '#ffffff', texture: texturePath },
+            type: "Material",
+            properties: { color: "#ffffff", texture: texturePath },
+        },
+    });
+}
+export function createPackedPrefabNode(url) {
+    return createNode("Packed Prefab", {
+        prefabref: {
+            type: "PrefabRef",
+            properties: { url },
         },
     });
 }
@@ -151,10 +163,12 @@ export function normalizePrefab(prefab) {
 }
 export function createPrefabPatch(state, patch, nextAssetRefCounts = state.assetRefCounts) {
     const assetRefsChanged = nextAssetRefCounts !== state.assetRefCounts;
-    return Object.assign(Object.assign({}, patch), (assetRefsChanged ? {
-        assetRefCounts: nextAssetRefCounts,
-        assetManifestKey: getAssetManifestKey(nextAssetRefCounts),
-    } : null));
+    return Object.assign(Object.assign({}, patch), (assetRefsChanged
+        ? {
+            assetRefCounts: nextAssetRefCounts,
+            assetManifestKey: getAssetManifestKey(nextAssetRefCounts),
+        }
+        : null));
 }
 export function denormalizePrefab(state) {
     return {
@@ -175,9 +189,11 @@ export function insertSubtree(node, parentId, nodesById, childIdsById, parentIdB
     var _a;
     const { children } = node, nodeRecord = __rest(node, ["children"]);
     nodesById[node.id] = nodeRecord;
-    childIdsById[node.id] = (_a = children === null || children === void 0 ? void 0 : children.map(child => child.id)) !== null && _a !== void 0 ? _a : [];
+    childIdsById[node.id] = (_a = children === null || children === void 0 ? void 0 : children.map((child) => child.id)) !== null && _a !== void 0 ? _a : [];
     parentIdById[node.id] = parentId;
-    children === null || children === void 0 ? void 0 : children.forEach(child => insertSubtree(child, node.id, nodesById, childIdsById, parentIdById));
+    children === null || children === void 0 ? void 0 : children.forEach((child) => {
+        insertSubtree(child, node.id, nodesById, childIdsById, parentIdById);
+    });
 }
 export function cloneSubtree(id, parentId, source, nodesById, childIdsById, parentIdById) {
     var _a, _b;
@@ -189,7 +205,7 @@ export function cloneSubtree(id, parentId, source, nodesById, childIdsById, pare
     nodesById[clonedId] = clonedNode;
     parentIdById[clonedId] = parentId;
     const clonedChildIds = ((_b = source.childIdsById[id]) !== null && _b !== void 0 ? _b : [])
-        .map(childId => cloneSubtree(childId, clonedId, source, nodesById, childIdsById, parentIdById))
+        .map((childId) => cloneSubtree(childId, clonedId, source, nodesById, childIdsById, parentIdById))
         .filter((childId) => Boolean(childId));
     childIdsById[clonedId] = clonedChildIds;
     return clonedId;
@@ -217,7 +233,9 @@ export function updateAssetRefsForNodeChange(assetRefCounts, currentNode, nextNo
 export function collectSubtreeAssetRefs(node) {
     var _a;
     const refs = getAssetRefs(node);
-    (_a = node.children) === null || _a === void 0 ? void 0 : _a.forEach(child => refs.push(...collectSubtreeAssetRefs(child)));
+    (_a = node.children) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
+        refs.push(...collectSubtreeAssetRefs(child));
+    });
     return refs;
 }
 export function collectAssetRefsForIds(ids, nodesById) {

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

@@ -1,5 +1,7 @@
 import { GameObject, Prefab } from "./types";
-import { Matrix4, Object3D, Vector3 } from 'three';
+import { Matrix4, Object3D, Vector3 } from "three";
+export declare function isExternalPath(path: string): boolean;
+export declare function withBasePath(basePath: string | undefined, path: string): string;
 export interface ExportGLBOptions {
     filename?: string;
 }
@@ -7,6 +9,11 @@ export interface ExportGLBOptions {
 export declare function saveJson(data: Prefab, filename: string): Promise<void>;
 /** Load scene JSON from a file */
 export declare function loadJson(): Promise<Prefab | undefined>;
+/** Load scene JSON from a file, also returning the original filename */
+export declare function loadJsonFile(): Promise<{
+    prefab: Prefab;
+    filename: string;
+} | undefined>;
 /**
  * Export a Three.js scene or object to GLB binary data
  */