@fps-games/editor 0.2.1-beta.1 → 0.2.1-beta.3

package/dist/local-editor-harness.js

@@ -3,6 +3,8 @@ import { createEditorToolManager, createEditorToolRegistry, resolveEditingContex
 import { createEditorDiagnosticStore, normalizeEditorDiagnostic, normalizeEditorDiagnosticDetails, } from '@fps-games/editor-core/diagnostics';
 import {} from '@fps-games/editor-protocol';
 import { createLocalEditorBrowserUi, resolveLocalEditorBrowserAssetKind, resolveLocalEditorStatusDiagnosticLocator, toTransformOperationPolicyStatusLabel, } from '@fps-games/editor-browser';
+import { mountLocalEditorProjectModelPreview, resolveLocalEditorProjectModelThumbnail, } from './internal/project-model-preview.js';
+import { mountLocalEditorMaterialPreview } from './internal/material-preview.js';
 import { bindFpsEditorTools, } from '@fps-games/editor-core/plugin-host';
 import { createLocalEditorHarnessPluginInspectorOptions } from './local-editor-plugin-inspector.js';
 import { registerLocalEditorHarnessLifecycleOperations, } from './internal/local-editor-lifecycle-operations.js';
@@ -305,6 +307,8 @@ function createLocalEditorHarnessImplementation(options, construction) {
         handleSessionObserverError: () => { },
         source: null,
         assets: [],
+        projectFiles: null,
+        projectFilesWarning: null,
         assetFilter: '',
         updatedAssetProjection: { pending: false },
         selectedAssetId: null,
@@ -340,6 +344,9 @@ function createLocalEditorHarnessImplementation(options, construction) {
         sceneViewMeasurement: null,
         sceneViewSpatialOverlay: null,
         selectionController: null,
+        selectionInspectorRefreshGeneration: 0,
+        selectionInspectorRefreshFrame: null,
+        selectionInspectorRefreshTimeout: null,
         sceneRenderScheduler: null,
         viewportRenderCoordinator: null,
         sceneFrameStats: null,
@@ -449,11 +456,12 @@ function createLocalEditorHarnessImplementation(options, construction) {
     state.createSessionChangeObserver = createSessionChangeObserver;
     state.handleSessionObserverError = handleEditorSessionObserverError;
     let harness;
+    let renderSelectionChange = () => harness.render();
     const busyOperationExecutors = new WeakMap();
     let agentLifecycleController;
     const pluginInspector = createLocalEditorHarnessPluginInspectorOptions(options.pluginHost, options.inspector);
-    const builtInSceneHierarchyProvider = createLocalEditorHarnessHierarchyScopeProvider(state, options, () => harness.render(), createLocalEditorSceneHierarchyScopeAdapter(state, options), busyOperationExecutors);
-    const builtInPrefabStageHierarchyProvider = createLocalEditorHarnessHierarchyScopeProvider(state, options, () => harness.render(), createLocalEditorPrefabHierarchyScopeAdapter(state, options), busyOperationExecutors);
+    const builtInSceneHierarchyProvider = createLocalEditorHarnessHierarchyScopeProvider(state, options, () => harness.render(), createLocalEditorSceneHierarchyScopeAdapter(state, options), busyOperationExecutors, () => renderSelectionChange());
+    const builtInPrefabStageHierarchyProvider = createLocalEditorHarnessHierarchyScopeProvider(state, options, () => harness.render(), createLocalEditorPrefabHierarchyScopeAdapter(state, options), busyOperationExecutors, () => renderSelectionChange());
     const hierarchySurface = options.pluginHost
         ? resolveHierarchySurfaceContribution(options.pluginHost.contributions)
         : options.hierarchy?.surface;
@@ -473,7 +481,10 @@ function createLocalEditorHarnessImplementation(options, construction) {
     const unregisterStandardTools = createLocalEditorStandardToolRegistrations({
         activate(tool) {
             const previous = state.transformTool;
-            commitEditorStateChange(state, options, () => harness.render(), 'transform-tool-change', () => {
+            // Tool Manager publishes immediately after the runtime activates, and that
+            // publication owns the UI refresh. Rendering here as well rebuilt the full
+            // workbench twice before Babylon could present the first Gizmo frame.
+            commitEditorStateChange(state, options, () => { }, 'transform-tool-change', () => {
                 state.transformTool = tool;
                 state.transformConstraint = normalizeTransformConstraint(tool, state.transformConstraint);
             }, {
@@ -489,6 +500,11 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 });
             }
         },
+        reconcile(tool) {
+            if (state.transformTool !== tool)
+                return;
+            syncTransformGizmoToSceneArtifacts(state, 'transform-tool-reconcile');
+        },
         cancelActiveOperation() {
             cancelActiveOperation(state);
         },
@@ -720,6 +736,21 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 if (patchMarkerRelation(state, options, input))
                     harness.render();
             },
+            onAssetBrowserRefresh: () => runExclusive(state, harness.render, async () => {
+                await harness.reloadAssets();
+            }, busyOperationExecutors),
+            onProjectFileRead: options.persistenceAdapter.loadProjectFile
+                ? path => Promise.resolve(options.persistenceAdapter.loadProjectFile(path))
+                : undefined,
+            onProjectEntrySendToAgent: options.agentContext
+                ? input => Promise.resolve(options.agentContext.sendProjectEntry(input)).then(() => undefined)
+                : undefined,
+            onProjectMediaResolve: options.persistenceAdapter.resolveProjectMedia
+                ? path => Promise.resolve(options.persistenceAdapter.resolveProjectMedia(path))
+                : undefined,
+            onProjectModelPreviewMount: mountLocalEditorProjectModelPreview,
+            onProjectModelThumbnailResolve: resolveLocalEditorProjectModelThumbnail,
+            onMaterialPreviewMount: mountLocalEditorMaterialPreview,
             onAssetFilterChange: (value) => {
                 state.assetFilter = value;
                 harness.render();
@@ -897,6 +928,13 @@ function createLocalEditorHarnessImplementation(options, construction) {
             },
         },
     });
+    renderSelectionChange = () => {
+        if (!state.world || !ui.updatePreview) {
+            harness.render();
+            return;
+        }
+        publishLocalEditorSelectionPresentation(state, options, previewState => ui.updatePreview?.(previewState), 'hierarchy-selection-presentation');
+    };
     const discardPrefabStageChanges = () => {
         const stage = state.prefabStage;
         if (!stage || !stage.transaction.snapshot().stageDirty)
@@ -958,9 +996,26 @@ function createLocalEditorHarnessImplementation(options, construction) {
         }
         return exitPrefabStage(state, options, 'reject');
     };
-    const unsubscribeToolManager = toolManager.subscribe(() => {
-        if (state.toolManagerRenderSuppression === 0)
+    const unsubscribeToolManager = toolManager.subscribe(snapshot => {
+        if (state.toolManagerRenderSuppression !== 0)
+            return;
+        const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        const previewState = createUiToolPresentationPreviewState(state, snapshot);
+        if (ui.updatePreview)
+            ui.updatePreview(previewState);
+        else
             harness.render();
+        if (typeof globalThis.location?.search === 'string'
+            && /(?:^|[?&])debugGizmo=(?:1|true)(?:&|$)/.test(globalThis.location.search)) {
+            console.info('[fps-editor:gizmo]', 'tool-manager.presentation-published', {
+                timestamp: typeof performance !== 'undefined' ? Number(performance.now().toFixed(2)) : Date.now(),
+                durationMs: Number(((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt).toFixed(2)),
+                revision: snapshot.revision,
+                activationGeneration: snapshot.activationGeneration,
+                activeToolId: snapshot.activeToolId,
+                updateMode: ui.updatePreview ? 'preview' : 'full-fallback',
+            });
+        }
     });
     construction.setCleanup(() => {
         harnessDisposed = true;
@@ -1045,16 +1100,45 @@ function createLocalEditorHarnessImplementation(options, construction) {
         }, executor);
         return runResult.accepted ? runResult.value : false;
     };
+    const loadOptionalProjectFiles = async () => {
+        if (!options.persistenceAdapter.loadProjectFiles) {
+            return { projectFiles: state.projectFiles, warning: null };
+        }
+        try {
+            return {
+                projectFiles: await options.persistenceAdapter.loadProjectFiles(),
+                warning: null,
+            };
+        }
+        catch (error) {
+            return {
+                projectFiles: state.projectFiles,
+                warning: `Project file browser unavailable: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    };
+    const applyProjectFilesWarningToStatus = () => {
+        if (!state.projectFilesWarning)
+            return;
+        state.statusTone = 'warning';
+        state.statusToneStatus = state.status;
+        state.statusDetails = [state.statusDetails, state.projectFilesWarning].filter(Boolean).join(' · ');
+    };
     const loadEditorDocument = async () => {
-        const loadedSource = options.persistenceAdapter.loadAuthoringSource
-            ? await options.persistenceAdapter.loadAuthoringSource()
-            : null;
+        const [loadedSource, projectFilesResult] = await Promise.all([
+            options.persistenceAdapter.loadAuthoringSource
+                ? options.persistenceAdapter.loadAuthoringSource()
+                : null,
+            loadOptionalProjectFiles(),
+        ]);
         const [document, assets] = loadedSource
             ? [loadedSource.document, loadedSource.assets ?? await options.persistenceAdapter.loadAssets()]
             : [await loadDocumentFallback(options), await options.persistenceAdapter.loadAssets()];
         const source = loadedSource?.source ?? null;
         const preparedDocument = options.documentAdapter.prepareDocument?.(document, assets) ?? document;
         state.assets = assets;
+        state.projectFiles = projectFilesResult.projectFiles;
+        state.projectFilesWarning = projectFilesResult.warning;
         state.source = source;
         state.markerGraphVisibility = createDefaultMarkerGraphVisibilityState();
         state.markerGraphVisibilityRevision += 1;
@@ -1121,6 +1205,10 @@ function createLocalEditorHarnessImplementation(options, construction) {
             throw error;
         }
         state.status = `GameWorld disposed; EditorWorld active; assets=${state.assets.length}`;
+        state.statusTone = 'default';
+        state.statusToneStatus = state.status;
+        state.statusDetails = '';
+        applyProjectFilesWarningToStatus();
         harness.render();
         harness.notifyViewportRevealed('editor-enter');
     };
@@ -1344,7 +1432,10 @@ function createLocalEditorHarnessImplementation(options, construction) {
         async reloadAssets() {
             try {
                 const previousAssets = state.assets;
-                const assets = await options.persistenceAdapter.loadAssets();
+                const [assets, projectFilesResult] = await Promise.all([
+                    options.persistenceAdapter.loadAssets(),
+                    loadOptionalProjectFiles(),
+                ]);
                 const refreshedAssetIds = options.documentAdapter.listAssetSnapshots
                     ? findLocalEditorUpdatedAssetIds(options.documentAdapter.listAssetSnapshots(previousAssets), options.documentAdapter.listAssetSnapshots(assets))
                     : [];
@@ -1379,6 +1470,9 @@ function createLocalEditorHarnessImplementation(options, construction) {
                     state.statusDetails = '';
                 }
                 state.assets = assets;
+                state.projectFiles = projectFilesResult.projectFiles;
+                state.projectFilesWarning = projectFilesResult.warning;
+                applyProjectFilesWarningToStatus();
                 clearArmedPlacement(state);
                 harness.render();
                 return {
@@ -1416,7 +1510,10 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 if (!options.documentAdapter.resolveUpdatedAssetSnapshot) {
                     throw new Error('asset_update_snapshot_verification_unavailable');
                 }
-                const assets = await options.persistenceAdapter.loadAssets();
+                const [assets, projectFilesResult] = await Promise.all([
+                    options.persistenceAdapter.loadAssets(),
+                    loadOptionalProjectFiles(),
+                ]);
                 assertLocalEditorUpdatedAssetSnapshotFreshness(options.documentAdapter.resolveUpdatedAssetSnapshot(assets, { assetId: input.assetId }), input);
                 const result = applyLocalEditorUpdatedAssetRefresh(state.session, {
                     assetId: input.assetId,
@@ -1430,6 +1527,8 @@ function createLocalEditorHarnessImplementation(options, construction) {
                         : {}),
                 });
                 state.assets = assets;
+                state.projectFiles = projectFilesResult.projectFiles;
+                state.projectFilesWarning = projectFilesResult.warning;
                 clearArmedPlacement(state);
                 syncLocalEditorUpdatedAssetProjection(state.updatedAssetProjection, result.changed, () => {
                     rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
@@ -1443,6 +1542,7 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 state.statusTone = warnings.length > 0 ? 'warning' : 'success';
                 state.statusToneStatus = state.status;
                 state.statusDetails = warnings.map(warning => warning.code).join(', ');
+                applyProjectFilesWarningToStatus();
                 replaceAssetUpdateDiagnosticSnapshot(state, {
                     assetIds: [input.assetId],
                     warnings,
@@ -2657,6 +2757,7 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
         },
     });
     state.gizmo = gizmo;
+    await gizmo.prepare?.();
     gizmo.setOperationSettings(getScopedTransformOperationSettings(state));
     gizmo.setConstraint(state.transformConstraint);
     const selectionController = createBabylonProjectionSelectionController({
@@ -2669,8 +2770,18 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
         isLocked: nodeId => getLocalEditorEditingContext(state).isLocked(nodeId),
         isOperationBlocked: () => state.gizmo?.getState().dragPhase === 'dragging',
         onSelectionCommand(command) {
-            if (getLocalEditorEditingContext(state).dispatchSelection(command))
-                render();
+            const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+            if (getLocalEditorEditingContext(state).dispatchSelection(command)) {
+                publishLocalEditorSelectionPresentation(state, options, renderPreviewUi, 'viewport-selection-presentation');
+                if (isLocalEditorSelectionDebugEnabled()) {
+                    console.info('[fps-editor:selection]', 'selection.presentation-published', {
+                        timestamp: readLocalEditorPerformanceTimestamp(),
+                        durationMs: Number(((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt).toFixed(2)),
+                        activeId: getCurrentPreviewSelection(state, options).activeId,
+                        selectedCount: getCurrentPreviewSelection(state, options).selectedIds.length,
+                    });
+                }
+            }
         },
         onFocusIntent(nodeId) {
             if (getLocalEditorEditingContext(state).focus(nodeId))
@@ -2852,9 +2963,9 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
     });
     state.postProcess = postProcess;
     postProcess.setProfile(initialRendering.postProcess ?? null);
-    const environmentTexture = createBabylonEnvironmentTextureController(world.scene, null);
+    const environmentTexture = createBabylonEnvironmentTextureController(world.scene);
     state.environmentTexture = environmentTexture;
-    environmentTexture.setProfile(initialRendering.environment ?? null);
+    await environmentTexture.applyProfile(initialRendering.environment ?? null);
     world.refreshSkyBackdrop();
     const resize = () => {
         engine.resize?.();
@@ -2890,6 +3001,7 @@ function disposeEditorWorld(state) {
         clear();
     });
     run(() => clearPrefabStageForEditorTeardown(state));
+    run(() => cancelScheduledSelectionInspectorRefresh(state));
     state.activeTransformPreview = null;
     disposeField(() => state.sceneViewInteraction, () => { state.sceneViewInteraction = null; });
     if (state.resizeHandler) {
@@ -4380,16 +4492,58 @@ function createMarkerRelationVisibilityOptions(state) {
     };
 }
 function syncTransformGizmoToSceneArtifacts(state, reason, revision = state.editorStateRevision, beginSync = true) {
-    if (beginSync && !beginSceneArtifactSync(state, reason, revision))
+    const debugGizmo = typeof globalThis.location?.search === 'string'
+        && /(?:^|[?&])debugGizmo=(?:1|true)(?:&|$)/.test(globalThis.location.search);
+    if (beginSync && !beginSceneArtifactSync(state, reason, revision)) {
+        if (debugGizmo) {
+            console.info('[fps-editor:gizmo]', 'harness.sync.skipped', {
+                timestamp: typeof performance !== 'undefined' ? Number(performance.now().toFixed(2)) : Date.now(),
+                reason,
+                revision,
+                sceneArtifactRevision: state.sceneArtifactRevision,
+            });
+        }
         return;
+    }
     const gizmo = state.gizmo;
+    if (debugGizmo) {
+        console.info('[fps-editor:gizmo]', 'harness.sync.started', {
+            timestamp: typeof performance !== 'undefined' ? Number(performance.now().toFixed(2)) : Date.now(),
+            reason,
+            revision,
+            transformTool: state.transformTool,
+            transformSpace: state.transformSpace,
+            transformConstraint: state.transformConstraint,
+            gizmoState: gizmo?.getState() ?? null,
+        });
+    }
     if (gizmo) {
-        gizmo.setTool(state.transformTool);
-        gizmo.setSpace(state.transformSpace);
-        gizmo.setConstraint(state.transformConstraint);
-        gizmo.refreshSelection();
+        const current = gizmo.getState();
+        let attachmentReconciled = false;
+        if (current.tool !== state.transformTool) {
+            gizmo.setTool(state.transformTool);
+            attachmentReconciled = true;
+        }
+        if (current.space !== state.transformSpace) {
+            gizmo.setSpace(state.transformSpace);
+            attachmentReconciled = true;
+        }
+        if (current.constraint !== state.transformConstraint) {
+            gizmo.setConstraint(state.transformConstraint);
+            attachmentReconciled = true;
+        }
+        if (!attachmentReconciled)
+            gizmo.refreshSelection();
     }
     requestEditorArtifactRevealFrame(state, reason);
+    if (debugGizmo) {
+        console.info('[fps-editor:gizmo]', 'harness.sync.completed', {
+            timestamp: typeof performance !== 'undefined' ? Number(performance.now().toFixed(2)) : Date.now(),
+            reason,
+            gizmoState: gizmo?.getState() ?? null,
+            revealFrameRequested: !!state.viewportRenderCoordinator,
+        });
+    }
 }
 function syncTransformOperationSettingsToSceneArtifacts(state, reason, revision = state.editorStateRevision) {
     if (!beginSceneArtifactSync(state, reason, revision))
@@ -4460,12 +4614,21 @@ function syncEditorWorldRenderingFromDocument(state, options, document, reason,
         state.world?.refreshSkyBackdrop();
         return;
     }
-    state.worldRenderingKey = key;
     state.shadowPreview?.setOptions(rendering.shadowPreview, refreshOptions);
-    state.environmentTexture?.setProfile(rendering.environment);
-    state.world?.refreshSkyBackdrop();
-    state.postProcess?.setProfile(rendering.postProcess);
-    requestEditorSceneFrame(state, reason);
+    const environmentUpdate = state.environmentTexture?.applyProfile(rendering.environment ?? null);
+    if (!environmentUpdate)
+        return;
+    void environmentUpdate.then(() => {
+        state.worldRenderingKey = key;
+        state.world?.refreshSkyBackdrop();
+        state.postProcess?.setProfile(rendering.postProcess);
+        requestEditorSceneFrame(state, reason);
+    }).catch((error) => {
+        if (error?.name === 'AbortError')
+            return;
+        reportLocalEditorWorldRenderingResolutionError(state, error, true);
+        requestEditorSceneFrame(state, `${reason}-failed`);
+    });
 }
 function reportLocalEditorWorldRenderingResolutionError(state, error, keptPrevious) {
     state.status = keptPrevious
@@ -8375,7 +8538,7 @@ function resolveHierarchyReparentInvocation(snapshot, invocation, resolveTarget)
         ...(resolveAnchor(invocation.input?.afterId) !== undefined ? { afterId: resolveAnchor(invocation.input?.afterId) } : {}),
     });
 }
-export function createLocalEditorHarnessHierarchyScopeProvider(state, options, render, adapter, executorStates = new WeakMap()) {
+export function createLocalEditorHarnessHierarchyScopeProvider(state, options, render, adapter, executorStates = new WeakMap(), renderSelection = render) {
     assertUniqueHierarchyOperationContributionIds(options.hierarchy?.operations ?? []);
     let treeCache = null;
     let cachedSession = null;
@@ -8414,7 +8577,7 @@ export function createLocalEditorHarnessHierarchyScopeProvider(state, options, r
             return validated;
         const changed = adapter.applySelection(input, validated);
         if (changed)
-            render();
+            renderSelection();
         const current = getSnapshot();
         const selection = adapter.getSelection();
         const selectionMatches = sameHierarchySelection(selection.selectedIds, input.selectedIds)
@@ -9032,6 +9195,7 @@ function createUiState(state, options, hierarchySnapshot, toolManager) {
         summary: state.summary,
         assetFilter: state.assetFilter,
         assets,
+        projectFiles: state.projectFiles ?? undefined,
         selectedAssetId: state.selectedAssetId,
         assetCountLabel: `${assets.length} assets`,
         selectedIds,
@@ -9042,6 +9206,7 @@ function createUiState(state, options, hierarchySnapshot, toolManager) {
         },
         inspectorObject: previewInspectorObject,
         inspectorMultiObject: previewInspectorMultiObject,
+        inspectorPending: false,
         renderingPanel: document
             ? options.documentAdapter.getRenderingPanelState?.(document, {
                 scene: state.world?.scene ?? null,
@@ -9145,7 +9310,7 @@ function createLocalEditorContextActions(state) {
         }),
     ]);
 }
-function createBrowserPrefabStageState(state, options, document) {
+function createBrowserPrefabStageState(state, options, document, includeInspector = true) {
     const stage = state.prefabStage;
     if (!stage || !document)
         return null;
@@ -9153,7 +9318,9 @@ function createBrowserPrefabStageState(state, options, document) {
     const cachedStructure = getCachedLocalEditorPrefabStageStructure(state, options, document, descriptor);
     const context = cachedStructure.context;
     const structureItems = cachedStructure.items;
-    const inspectorObject = options.documentAdapter.getPrefabStageInspectorObject?.(document, descriptor, stage.selectedItemId, context) ?? null;
+    const inspectorObject = includeInspector
+        ? options.documentAdapter.getPrefabStageInspectorObject?.(document, descriptor, stage.selectedItemId, context) ?? null
+        : null;
     const transactionSnapshot = stage.transaction.snapshot();
     return {
         assetId: descriptor.assetId,
@@ -9618,6 +9785,135 @@ function getScopedPreviewSelectionForUiState(state, _options, _fallbackSelection
 function getCurrentPreviewSelection(state, options) {
     return getScopedPreviewSelectionForUiState(state, options, state.session?.getState({ cloneDocuments: false }).selection ?? EMPTY_EDITOR_SELECTION);
 }
+function createUiToolPresentationPreviewState(state, snapshot) {
+    return {
+        tools: snapshot.tools,
+        activeToolId: snapshot.activeToolId,
+        transformTool: {
+            activeTool: state.transformTool,
+            activeSpace: state.transformSpace,
+            activeConstraint: state.transformConstraint,
+            dragPhase: state.gizmo?.getState().dragPhase ?? 'idle',
+            draggingNodeId: state.gizmo?.getState().draggingNodeId ?? null,
+        },
+    };
+}
+function publishLocalEditorSelectionPresentation(state, options, renderPreviewUi, reason) {
+    syncViewportSpatialOverlay(state, options);
+    renderPreviewUi(createUiSelectionPresentationPreviewState(state, options));
+    requestEditorSceneFrame(state, reason);
+    scheduleSelectionInspectorRefresh(state, options, renderPreviewUi);
+}
+function createUiSelectionPresentationPreviewState(state, options) {
+    const selection = getCurrentPreviewSelection(state, options);
+    const selectedIds = [...selection.selectedIds];
+    const activeId = selection.activeId;
+    const transformSelectionIsLarge = isLargeSelection(selectedIds);
+    const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;
+    return {
+        selectedIds,
+        activeId,
+        selectionSummary: {
+            count: selectedIds.length,
+            activeId,
+        },
+        inspectorPending: true,
+        transformOperations: {
+            settings: cloneTransformOperationSettings(getScopedTransformOperationSettings(state)),
+            selectedCount: selectedIds.length,
+            activeId,
+            canAlign: !transformSelectionIsLarge && selectedIds.length >= 2 && activeId != null
+                && isLocalEditorEditingCapabilityEnabled(state, LOCAL_EDITOR_EDITING_CAPABILITIES.transformActions),
+            canDistribute: !transformSelectionIsLarge && selectedIds.length >= 3
+                && isLocalEditorEditingCapabilityEnabled(state, LOCAL_EDITOR_EDITING_CAPABILITIES.transformActions),
+        },
+        viewportSpatialOverlay: cloneEditorViewportSpatialOverlayState(state.viewportSpatialOverlay),
+        ...(state.prefabStage
+            ? { prefabStage: createBrowserPrefabStageState(state, options, document, false) }
+            : {}),
+    };
+}
+function createUiSelectionInspectorPreviewState(state, options) {
+    const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;
+    if (!document) {
+        return {
+            inspectorObject: null,
+            inspectorMultiObject: null,
+            inspectorPending: false,
+            ...(state.prefabStage ? { prefabStage: null } : {}),
+        };
+    }
+    if (state.prefabStage) {
+        const prefabStage = createBrowserPrefabStageState(state, options, document);
+        return {
+            prefabStage,
+            inspectorObject: prefabStage?.inspectorObject ?? null,
+            inspectorMultiObject: null,
+            inspectorPending: false,
+        };
+    }
+    const editingContext = getLocalEditorEditingContext(state);
+    return {
+        inspectorObject: editingContext.getInspectorObject(document),
+        inspectorMultiObject: editingContext.getInspectorMultiObject(document),
+        inspectorPending: false,
+    };
+}
+function cancelScheduledSelectionInspectorRefresh(state) {
+    state.selectionInspectorRefreshGeneration += 1;
+    if (state.selectionInspectorRefreshFrame !== null) {
+        globalThis.cancelAnimationFrame?.(state.selectionInspectorRefreshFrame);
+        state.selectionInspectorRefreshFrame = null;
+    }
+    if (state.selectionInspectorRefreshTimeout !== null) {
+        globalThis.clearTimeout(state.selectionInspectorRefreshTimeout);
+        state.selectionInspectorRefreshTimeout = null;
+    }
+}
+function scheduleSelectionInspectorRefresh(state, options, renderPreviewUi) {
+    cancelScheduledSelectionInspectorRefresh(state);
+    const generation = state.selectionInspectorRefreshGeneration;
+    const publish = () => {
+        state.selectionInspectorRefreshTimeout = null;
+        if (generation !== state.selectionInspectorRefreshGeneration || !state.world)
+            return;
+        const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        const preview = createUiSelectionInspectorPreviewState(state, options);
+        const stateReadyAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        renderPreviewUi(preview);
+        if (isLocalEditorSelectionDebugEnabled()) {
+            const completedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+            console.info('[fps-editor:selection]', 'selection.inspector-published', {
+                timestamp: readLocalEditorPerformanceTimestamp(),
+                stateBuildMs: Number((stateReadyAt - startedAt).toFixed(2)),
+                renderMs: Number((completedAt - stateReadyAt).toFixed(2)),
+                durationMs: Number((completedAt - startedAt).toFixed(2)),
+                generation,
+            });
+        }
+    };
+    const deferUntilAfterFrame = () => {
+        state.selectionInspectorRefreshFrame = null;
+        if (generation !== state.selectionInspectorRefreshGeneration || !state.world)
+            return;
+        state.selectionInspectorRefreshTimeout = globalThis.setTimeout(publish, 0);
+    };
+    if (typeof globalThis.requestAnimationFrame === 'function') {
+        state.selectionInspectorRefreshFrame = globalThis.requestAnimationFrame(deferUntilAfterFrame);
+    }
+    else {
+        state.selectionInspectorRefreshTimeout = globalThis.setTimeout(publish, 0);
+    }
+}
+function isLocalEditorSelectionDebugEnabled() {
+    return typeof globalThis.location?.search === 'string'
+        && /(?:^|[?&])debug(?:Gizmo|Selection)=(?:1|true)(?:&|$)/.test(globalThis.location.search);
+}
+function readLocalEditorPerformanceTimestamp() {
+    return typeof performance !== 'undefined'
+        ? Number(performance.now().toFixed(2))
+        : Date.now();
+}
 function createUiPreviewState(state, options) {
     const sessionState = state.session?.getState({ cloneDocuments: false });
     const selection = sessionState?.selection;
@@ -10385,12 +10681,14 @@ function toBrowserAssetItem(options, asset) {
         ?? {
             id: asset.assetId ?? asset.id,
             label: asset.displayName ?? asset.label,
+            relativePath: asset.relativePath,
             guid: asset.guid,
             assetId: asset.assetId,
             kind: asset.kind,
             external: asset.external,
             origin: asset.origin,
             dedupeKey: asset.dedupeKey,
+            contentHash: asset.contentHash,
             placeable: asset.placeable,
             preview: asset.preview,
             material: asset.material,