@fps-games/editor 0.1.4-beta.4 → 0.1.5-beta.1

package/dist/local-editor-harness.js

@@ -1,12 +1,18 @@
 import { createEditorSession, createInspectorRegistry, DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS, DEFAULT_EDITOR_VIEWPORT_TOOL_STATE, createEmptyEditorViewportSpatialOverlayState, cloneEditorViewportToolState, cloneEditorViewportSpatialOverlayState, aggregateInspectorObjectsToMultiObject, createInspectorEditPayload, compareInspectorSections, computeEditorTransformActionTargets, mergeInspectorSections, normalizeEditorTransformConstraint, resolveEditorSelectionCommand, serializedMultiObjectToInspectorObject, serializedObjectToInspectorObject, validateSceneGraphDelete, validateSceneGraphDrop, validateSceneGraphGroupSelection, validateSceneGraphMove, validateSceneGraphRename, } from '@fps-games/editor-core';
 import { createLocalEditorBrowserUi, toTransformOperationPolicyStatusLabel, } from '@fps-games/editor-browser';
 import { createBabylonEnvironmentTextureController, createBabylonDefaultPostProcessPipelineController, } from '@fps-games/babylon-renderer';
-import { createBabylonEditorProjection, createBabylonEditorWorld, createBabylonProjectionSelectionController, createBabylonSceneCameraPreviewController, createBabylonSceneViewCameraController, createBabylonSceneViewInputController, createBabylonSceneViewMeasurementController, createBabylonSceneViewSpatialOverlayController, createBabylonEditorShadowPreviewController, createBabylonTransformGizmoController, focusEditorViewportSelection, } from '@fps-games/editor-babylon';
+import { createBabylonEditorProjection, createBabylonEditorWorld, createBabylonProjectionSelectionController, createBabylonSceneCameraPreviewController, createBabylonSceneViewCameraController, createBabylonSceneViewInputController, createBabylonSceneViewMeasurementController, createBabylonSceneViewSpatialOverlayController, createBabylonEditorShadowPreviewController, createBabylonTransformGizmoController, createBabylonEditorPerformanceMonitor, focusEditorViewportSelection, } from '@fps-games/editor-babylon';
 import { createLocalEditorSceneRenderScheduler, } from './local-editor-scene-render-scheduler.js';
 import { createPlayableBabylonOutlineInspectorSection, createPlayableBabylonOutlineInspectorSeedPatchValue, isPlayableBabylonOutlineInspectorPatchPath, } from './playable-babylon-outline-inspector.js';
 import { createLocalEditorViewportRenderCoordinator, } from './local-editor-viewport-render-coordinator.js';
 import { createLocalEditorSceneViewInteractionRuntime, } from './local-editor-scene-view-interaction-runtime.js';
+import { cloneLocalEditorPerformanceStats, countLocalEditorAuthoredObjects, createLocalEditorPerformanceStats, LOCAL_EDITOR_PERFORMANCE_MONITOR_REASON, } from './local-editor-performance-stats.js';
 const BATCH_EDIT_REQUIRES_MULTI_PATCH_REASON = 'Batch edit requires multi-property patch support.';
+const LARGE_SELECTION_THRESHOLD = 200;
+const LARGE_SHADOW_MODE_BATCH_THRESHOLD = 200;
+const EDITOR_PROJECTION_IDLE_BEFORE_RUN_GAME_TIMEOUT_MS = 1500;
+const EDITOR_WORLD_DISPOSE_BOUNDARY_DELAY_MS = 500;
+const RENDERING_ACTION_PROGRESS_MIN_VISIBLE_MS = 1000;
 export function createLocalEditorHarness(options) {
     const root = options.root ?? document.body;
     const state = {
@@ -29,6 +35,7 @@ export function createLocalEditorHarness(options) {
         environmentTexture: null,
         postProcess: null,
         projectionShadowPreviewRebuildFrame: null,
+        projectionShadowPreviewRefreshFrame: null,
         gizmo: null,
         sceneCameraPreview: null,
         sceneCameraPreviewEnabled: false,
@@ -41,6 +48,10 @@ export function createLocalEditorHarness(options) {
         sceneRenderScheduler: null,
         viewportRenderCoordinator: null,
         sceneFrameStats: null,
+        performanceMonitor: null,
+        performanceMonitorOpen: false,
+        performanceObjectCount: null,
+        performanceStats: null,
         worldAppearanceKey: '',
         worldRenderingKey: '',
         boxSelection: null,
@@ -59,6 +70,7 @@ export function createLocalEditorHarness(options) {
         statusTone: 'default',
         statusToneStatus: 'Game running',
         statusDetails: '',
+        renderingAction: null,
         summary: '',
     };
     let harness;
@@ -178,10 +190,11 @@ export function createLocalEditorHarness(options) {
                 : undefined,
             onRenderingAction: options.documentAdapter.onRenderingAction
                 ? (input) => {
-                    void applyRenderingAction(state, options, input)
+                    return applyRenderingAction(state, options, input, harness.render)
                         .then((changed) => {
                         if (changed)
                             harness.render();
+                        return changed;
                     });
                 }
                 : undefined,
@@ -282,6 +295,10 @@ export function createLocalEditorHarness(options) {
                 if (setGridVisible(state, visible))
                     harness.render();
             },
+            onPerformanceMonitorOpenChange: (open) => {
+                setLocalEditorPerformanceMonitorOpen(state, open);
+                updateLocalEditorPerformanceStats(state, stats => ui.updatePerformanceStats?.(stats));
+            },
             onFocusSelection: () => {
                 if (focusSelectedProjection(state))
                     harness.render();
@@ -298,7 +315,9 @@ export function createLocalEditorHarness(options) {
     });
     const runGameFromEditor = async (reason) => {
         cancelActiveOperation(state);
+        await waitForEditorProjectionIdleBeforeRunGame(state);
         disposeEditorWorld(state);
+        await waitForEditorWorldDisposeBoundary();
         state.mode = 'game';
         state.session = null;
         state.source = null;
@@ -404,7 +423,7 @@ export function createLocalEditorHarness(options) {
                     ui.updatePreview(previewState);
                 else
                     ui.update(createUiState(state, options));
-            }, stats => ui.updateSceneFrameStats?.(stats));
+            }, stats => ui.updateSceneFrameStats?.(stats), stats => ui.updatePerformanceStats?.(stats));
             state.mode = 'editor';
             state.summary = loadedSource?.summary ?? summarizeDocument(options, preparedDocument, source);
             state.status = `GameWorld disposed; EditorWorld active; assets=${assets.length}`;
@@ -784,7 +803,7 @@ function validateTransformActionSelection(state, action) {
         ? { ok: true }
         : { ok: false, message: 'Distribute needs at least 3 selected objects' };
 }
-async function createEditorWorld(state, options, renderUi, renderPreviewUi, updateSceneFrameStats) {
+async function createEditorWorld(state, options, renderUi, renderPreviewUi, updateSceneFrameStats, updatePerformanceStats) {
     disposeEditorWorld(state);
     const render = (reason = 'editor-world-update') => {
         renderUi();
@@ -814,6 +833,7 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
         useRightHandedSystem: options.world?.useRightHandedSystem,
         enableDefaultCameraControls: false,
     });
+    const performanceMonitor = createBabylonEditorPerformanceMonitor(world.scene);
     const sceneRenderScheduler = createLocalEditorSceneRenderScheduler((frame) => {
         state.sceneViewInteraction?.updateFrame(frame);
         world.render();
@@ -821,6 +841,7 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
         onStatsChange(stats) {
             state.sceneFrameStats = stats;
             updateSceneFrameStats(stats);
+            updateLocalEditorPerformanceStats(state, updatePerformanceStats);
         },
     });
     const viewportRenderCoordinator = createLocalEditorViewportRenderCoordinator({
@@ -845,6 +866,7 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
         scene: world.scene,
         importModel: options.worldAdapter.importProjectionModel,
         resolveTextureUrl: options.worldAdapter.resolveMaterialTextureUrl,
+        selectionEdgesPrewarm: options.world?.selectionEdgesPrewarm,
         logger: console,
         onProjectionReady(event) {
             syncCurrentSelectionToSceneArtifacts(state, `projection-${event.nodeId}-ready-selection`);
@@ -1075,6 +1097,9 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
         scene: world.scene,
         projection,
         options: initialRendering.shadowPreview,
+        onStaticProjectedShadowTextureReady(event) {
+            viewportRenderCoordinator.invalidateScene(`static-shadow-texture-ready-${event.chunkId}`);
+        },
     });
     const environmentTexture = createBabylonEnvironmentTextureController(world.scene, initialRendering.environment ?? null);
     const postProcess = createBabylonDefaultPostProcessPipelineController(world.scene, [world.camera], initialRendering.postProcess ?? null, { name: 'editorDefaultPostProcessPipeline' });
@@ -1101,11 +1126,14 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
     state.sceneRenderScheduler = sceneRenderScheduler;
     state.viewportRenderCoordinator = viewportRenderCoordinator;
     state.sceneFrameStats = sceneRenderScheduler.getStats();
+    state.performanceMonitor = performanceMonitor;
+    updateLocalEditorPerformanceStats(state, updatePerformanceStats);
     state.worldAppearanceKey = initialAppearanceKey;
     state.worldRenderingKey = initialRenderingKey;
     state.resizeHandler = resize;
     if (document) {
         projection.projectNodes(options.documentAdapter.getProjectionNodes(document));
+        scheduleProjectionShadowPreviewRebuild(state, 'editor-world-initial-projection-shadow');
     }
     syncCurrentSelectionToSceneArtifacts(state, 'editor-world-initial-selection');
     viewportRenderCoordinator.requestFrame('editor-world-created');
@@ -1131,6 +1159,14 @@ function disposeEditorWorld(state) {
     state.sceneViewInput = null;
     state.selectionController?.dispose();
     state.selectionController = null;
+    if (state.performanceMonitorOpen) {
+        state.viewportRenderCoordinator?.endContinuous(LOCAL_EDITOR_PERFORMANCE_MONITOR_REASON);
+    }
+    state.performanceMonitorOpen = false;
+    state.performanceMonitor?.dispose();
+    state.performanceMonitor = null;
+    state.performanceStats = null;
+    state.performanceObjectCount = null;
     state.viewportRenderCoordinator?.dispose();
     state.viewportRenderCoordinator = null;
     state.sceneRenderScheduler?.dispose();
@@ -1149,6 +1185,10 @@ function disposeEditorWorld(state) {
         window.cancelAnimationFrame(state.projectionShadowPreviewRebuildFrame);
         state.projectionShadowPreviewRebuildFrame = null;
     }
+    if (state.projectionShadowPreviewRefreshFrame !== null) {
+        window.cancelAnimationFrame(state.projectionShadowPreviewRefreshFrame);
+        state.projectionShadowPreviewRefreshFrame = null;
+    }
     state.shadowPreview?.dispose();
     state.shadowPreview = null;
     state.environmentTexture?.dispose();
@@ -1166,6 +1206,63 @@ function disposeEditorWorld(state) {
     state.world = null;
     state.engine = null;
 }
+async function waitForEditorProjectionIdleBeforeRunGame(state) {
+    const projection = state.projection;
+    if (!projection)
+        return;
+    const timeout = createTimeoutPromise(EDITOR_PROJECTION_IDLE_BEFORE_RUN_GAME_TIMEOUT_MS);
+    try {
+        await Promise.race([
+            projection.waitForIdle().catch(() => null),
+            timeout.promise,
+        ]);
+    }
+    finally {
+        timeout.cancel();
+    }
+}
+async function waitForEditorWorldDisposeBoundary() {
+    await waitForEditorAnimationFrame();
+    await waitForEditorAnimationFrame();
+    await waitForEditorTimeout(EDITOR_WORLD_DISPOSE_BOUNDARY_DELAY_MS);
+}
+function waitForEditorAnimationFrame() {
+    if (typeof window === 'undefined' || typeof window.requestAnimationFrame !== 'function') {
+        return Promise.resolve();
+    }
+    return new Promise(resolve => {
+        window.requestAnimationFrame(() => resolve());
+    });
+}
+function waitForEditorTimeout(milliseconds) {
+    if (typeof window === 'undefined' || typeof window.setTimeout !== 'function') {
+        return Promise.resolve();
+    }
+    return new Promise(resolve => {
+        window.setTimeout(() => resolve(), milliseconds);
+    });
+}
+function createTimeoutPromise(milliseconds) {
+    if (typeof window === 'undefined' || typeof window.setTimeout !== 'function') {
+        return { promise: new Promise(() => undefined), cancel: () => undefined };
+    }
+    let timeoutId = null;
+    const promise = new Promise(resolve => {
+        timeoutId = window.setTimeout(() => {
+            timeoutId = null;
+            resolve();
+        }, milliseconds);
+    });
+    return {
+        promise,
+        cancel() {
+            if (timeoutId === null)
+                return;
+            window.clearTimeout(timeoutId);
+            timeoutId = null;
+        },
+    };
+}
 function requestEditorSceneFrame(state, reason) {
     state.viewportRenderCoordinator?.requestFrame(reason);
 }
@@ -1203,6 +1300,21 @@ function scheduleProjectionShadowPreviewRebuild(state, reason) {
         state.viewportRenderCoordinator?.invalidateScene(reason);
     });
 }
+function scheduleProjectionShadowPreviewRefresh(state, reason) {
+    if (typeof window === 'undefined' || typeof window.requestAnimationFrame !== 'function') {
+        state.shadowPreview?.refresh();
+        state.viewportRenderCoordinator?.invalidateScene(reason);
+        return;
+    }
+    if (state.projectionShadowPreviewRefreshFrame !== null) {
+        window.cancelAnimationFrame(state.projectionShadowPreviewRefreshFrame);
+    }
+    state.projectionShadowPreviewRefreshFrame = window.requestAnimationFrame(() => {
+        state.projectionShadowPreviewRefreshFrame = null;
+        state.shadowPreview?.refresh();
+        state.viewportRenderCoordinator?.invalidateScene(reason);
+    });
+}
 async function runExclusive(state, render, action) {
     if (state.busy)
         return;
@@ -1228,7 +1340,7 @@ function selectItem(state, options, input, renderUi) {
         return false;
     if (!isDocumentNodeSelectable(state, options, input.id))
         return false;
-    const selection = state.session?.getState().selection ?? { selectedIds: [], activeId: null };
+    const selection = state.session?.getState({ cloneDocuments: false }).selection ?? { selectedIds: [], activeId: null };
     const command = resolveEditorSelectionCommand({
         selection,
         targetIds: [input.id],
@@ -1328,7 +1440,7 @@ function handleContextAction(state, options, action) {
         return runHierarchyCustomContextAction(state, options, action);
     if (action.action === 'focus') {
         const activeId = action.activeId ?? action.targetIds[action.targetIds.length - 1] ?? null;
-        const selectionChanged = activeId && !state.session?.getState().selection.selectedIds.includes(activeId)
+        const selectionChanged = activeId && !state.session?.getState({ cloneDocuments: false }).selection.selectedIds.includes(activeId)
             ? dispatchSelectionCommand(state, options, {
                 type: 'selection.replace',
                 selectedIds: [activeId],
@@ -1571,15 +1683,13 @@ function duplicateSceneGraphNodes(state, options, intent) {
         state.status = 'Duplicate rejected';
         return true;
     }
+    const projectionImpact = resolveProjectionImpact(patch, createDuplicateProjectionImpact(patch));
     const result = state.session.dispatch({
         type: 'document.patch',
         label: patch.label ?? `Duplicate ${targetIds.length} object(s)`,
         patch: patch.patch,
         targetId: patch.activeId ?? patch.createdIds[patch.createdIds.length - 1] ?? undefined,
-        ...withProjectionImpact(resolveProjectionImpact(patch, createCreatedReprojectProjectionImpact({
-            createdNodeIds: patch.createdIds,
-            reprojectIds: patch.reprojectIds,
-        }))),
+        ...withProjectionImpact(projectionImpact),
     });
     if (!result.documentChanged) {
         state.status = 'Duplicate unchanged';
@@ -1597,11 +1707,14 @@ function duplicateSceneGraphNodes(state, options, intent) {
             label: 'Select Duplicated Nodes',
         }).selection
         : sanitizeSelection(state, options, result.workingDocument, result.selection) ?? result.selection;
-    rebuildProjectionFromDocument(state, options, result.workingDocument, selection);
-    if (patch.reprojectIds?.length)
-        reprojectProjectionForChangedIds(state, options, result.workingDocument, patch.reprojectIds);
-    else
-        syncProjectionForChangedIds(state, options, result.workingDocument, patch.changedIds ?? createdIds);
+    if (!applyProjectionImpactToDocument(state, options, {
+        document: result.workingDocument,
+        selection,
+        impact: projectionImpact,
+        reason: 'duplicate-impact',
+    })) {
+        rebuildProjectionFromDocument(state, options, result.workingDocument, selection);
+    }
     state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
     state.status = patch.label ?? `Duplicated ${createdIds.length} object(s)`;
     return true;
@@ -1765,7 +1878,7 @@ function commitEditorStateChange(state, renderUi, reason, mutate, options = {})
     renderUi();
     if (options.syncSelectionArtifacts) {
         const selection = typeof options.syncSelectionArtifacts === 'boolean'
-            ? state.session?.getState().selection ?? { selectedIds: [], activeId: null }
+            ? state.session?.getState({ cloneDocuments: false }).selection ?? { selectedIds: [], activeId: null }
             : options.syncSelectionArtifacts;
         syncSelectionToProjection(state, selection, reason, revision);
     }
@@ -1785,7 +1898,7 @@ function syncSelectionToProjection(state, selection, reason = 'projection-select
     syncTransformGizmoToSceneArtifacts(state, reason, revision, false);
 }
 function syncCurrentSelectionToSceneArtifacts(state, reason = 'projection-selection-current', revision = state.editorStateRevision) {
-    syncSelectionToProjection(state, state.session?.getState().selection ?? { selectedIds: [], activeId: null }, reason, revision);
+    syncSelectionToProjection(state, state.session?.getState({ cloneDocuments: false }).selection ?? { selectedIds: [], activeId: null }, reason, revision);
 }
 function syncTransformGizmoToSceneArtifacts(state, reason, revision = state.editorStateRevision, beginSync = true) {
     if (beginSync && !beginSceneArtifactSync(state, reason, revision))
@@ -2237,7 +2350,8 @@ function patchSerializedProperty(state, options, input) {
     cancelActiveOperation(state);
     if (!state.session)
         return false;
-    const document = state.session.getState().workingDocument;
+    const sessionState = state.session.getState({ cloneDocuments: false });
+    const document = sessionState.workingDocument;
     const targetIds = input.targetIds && input.targetIds.length > 0 ? input.targetIds : [input.targetId];
     const transaction = createInspectorEditTransaction(state, options, document, input, targetIds);
     if (!transaction.ok) {
@@ -2250,7 +2364,7 @@ function patchSerializedProperty(state, options, input) {
         const patch = options.documentAdapter.createSerializedMultiPropertyPatch?.({
             document,
             targetIds,
-            activeId: state.session.getState().selection.activeId,
+            activeId: sessionState.selection.activeId,
             path: payload.path,
             value: payload.value,
             control: payload.control,
@@ -2262,11 +2376,15 @@ function patchSerializedProperty(state, options, input) {
         if (!patch)
             return false;
         const changedIds = patch.changedIds ?? targetIds;
+        const projectionMetadataPatch = isSerializedProjectionMetadataPath(payload.path);
+        const largeProjectionMetadataPatch = projectionMetadataPatch
+            && changedIds.length >= LARGE_SHADOW_MODE_BATCH_THRESHOLD;
+        const invalidateStaticShadowArtifact = projectionMetadataPatch && payload.path === 'shadowMode';
         const result = state.session.dispatch({
             type: 'document.patch',
             label: patch.label ?? `Patch ${payload.path} on ${targetIds.length} objects`,
             patch: patch.patch,
-            targetId: state.session.getState().selection.activeId ?? undefined,
+            targetId: sessionState.selection.activeId ?? undefined,
             ...withProjectionImpact(resolveProjectionImpact(patch, patch.reprojectIds?.length
                 ? createReprojectProjectionImpact(patch.reprojectIds)
                 : shouldReprojectInspectorEdit
@@ -2274,7 +2392,14 @@ function patchSerializedProperty(state, options, input) {
                     : isSerializedTransformPath(payload.path)
                         ? createTransformProjectionImpact(targetIds)
                         : undefined)),
-        });
+        }, largeProjectionMetadataPatch
+            ? {
+                assumeDocumentChanged: true,
+                assumeDirty: true,
+                clonePatchInput: false,
+                cloneResultDocument: false,
+            }
+            : undefined);
         if (!result.documentChanged)
             return false;
         const projectionSyncIds = isSerializedTransformPath(payload.path) ? targetIds : changedIds;
@@ -2283,6 +2408,12 @@ function patchSerializedProperty(state, options, input) {
             reprojectProjectionForChangedIds(state, options, workingDocument, patch.reprojectIds);
         else if (shouldReprojectInspectorEdit)
             reprojectProjectionForChangedIds(state, options, workingDocument, changedIds);
+        else if (isSerializedProjectionMetadataPath(payload.path)) {
+            syncProjectionMetadataForChangedIds(state, options, workingDocument, projectionSyncIds, {
+                deferShadowPreviewRefresh: largeProjectionMetadataPatch,
+                invalidateStaticShadowArtifact,
+            });
+        }
         else
             syncProjectionForChangedIds(state, options, workingDocument, projectionSyncIds);
         state.summary = summarizeDocument(options, workingDocument, state.session.getSource());
@@ -2320,6 +2451,11 @@ function patchSerializedProperty(state, options, input) {
     else if (shouldReprojectInspectorEdit) {
         reprojectProjectionForChangedIds(state, options, result.workingDocument, patch.changedIds ?? [patch.changedId ?? payload.targetId]);
     }
+    else if (isSerializedProjectionMetadataPath(payload.path)) {
+        syncProjectionMetadataForChangedIds(state, options, result.workingDocument, [patch.changedId ?? payload.targetId], {
+            invalidateStaticShadowArtifact: payload.path === 'shadowMode',
+        });
+    }
     else if (isSerializedTransformPath(payload.path))
         syncProjectionForChangedIds(state, options, result.workingDocument, [patch.changedId ?? payload.targetId]);
     else if (patch.changedIds)
@@ -2361,13 +2497,26 @@ async function applyRenderingPropertyChange(state, options, input) {
             source: input.source,
         });
         const resultObject = typeof result === 'object' && result != null ? result : null;
-        const changed = result === true || resultObject?.changed === true || resultObject?.refreshWorldRendering === true;
+        const documentPatchResult = resultObject?.documentPatch
+            ? applyRenderingDocumentPatch(state, options, document, resultObject.documentPatch, `Rendering document update: ${input.path}`)
+            : null;
+        const syncDocument = documentPatchResult?.workingDocument ?? document;
+        const changed = result === true
+            || resultObject?.changed === true
+            || resultObject?.refreshWorldRendering === true
+            || documentPatchResult?.changed === true;
         if (resultObject?.status) {
             state.status = resultObject.status;
             state.statusTone = resultObject.statusTone ?? 'default';
             state.statusToneStatus = state.status;
             state.statusDetails = resultObject.statusDetails ?? '';
         }
+        else if (documentPatchResult?.changed) {
+            state.status = documentPatchResult.label;
+            state.statusTone = 'success';
+            state.statusToneStatus = state.status;
+            state.statusDetails = '';
+        }
         else if (changed) {
             state.status = `Updated rendering: ${input.path}`;
             state.statusTone = 'success';
@@ -2375,7 +2524,7 @@ async function applyRenderingPropertyChange(state, options, input) {
             state.statusDetails = '';
         }
         if (changed) {
-            syncEditorWorldRenderingFromDocument(state, options, document, 'rendering-panel-change', true);
+            syncEditorWorldRenderingFromDocument(state, options, syncDocument, 'rendering-panel-change', true);
             requestEditorSceneFrame(state, 'rendering-panel-change');
         }
         return changed || !!resultObject?.status;
@@ -2389,25 +2538,78 @@ async function applyRenderingPropertyChange(state, options, input) {
         return true;
     }
 }
-async function applyRenderingAction(state, options, input) {
+async function applyRenderingAction(state, options, input, render) {
     if (state.mode !== 'editor')
         return false;
     if (!state.session || !options.documentAdapter.onRenderingAction)
         return false;
+    if (state.renderingAction) {
+        state.status = state.renderingAction.status ?? `Rendering action already running: ${state.renderingAction.actionId}`;
+        state.statusTone = state.renderingAction.statusTone ?? 'default';
+        state.statusToneStatus = state.status;
+        state.statusDetails = state.renderingAction.statusDetails ?? '';
+        render();
+        return true;
+    }
     const document = state.session.getState().workingDocument;
+    const progressStartedAt = Date.now();
+    state.renderingAction = {
+        actionId: input.actionId,
+        label: input.actionId === 'bake-static-shadows' ? 'Baking static shadows' : input.actionId,
+        status: input.actionId === 'bake-static-shadows' ? 'Baking static shadows...' : `Rendering action: ${input.actionId}`,
+        statusTone: 'default',
+        indeterminate: true,
+    };
+    state.status = state.renderingAction.status ?? state.status;
+    state.statusTone = state.renderingAction.statusTone ?? 'default';
+    state.statusToneStatus = state.status;
+    state.statusDetails = '';
+    render();
     try {
+        await state.projection?.waitForIdle?.();
         const result = await options.documentAdapter.onRenderingAction({
+            ...input,
             document,
             actionId: input.actionId,
+            scene: state.world?.scene ?? null,
+            projection: state.projection,
+            reportProgress: async (progress) => {
+                state.renderingAction = {
+                    ...state.renderingAction,
+                    ...progress,
+                    actionId: progress.actionId ?? state.renderingAction?.actionId ?? input.actionId,
+                };
+                if (progress.status) {
+                    state.status = progress.status;
+                    state.statusTone = progress.statusTone ?? 'default';
+                    state.statusToneStatus = state.status;
+                    state.statusDetails = progress.statusDetails ?? '';
+                }
+                render();
+                await waitForRenderingProgressFrame();
+            },
         });
         const resultObject = typeof result === 'object' && result != null ? result : null;
-        const changed = result === true || resultObject?.changed === true || resultObject?.refreshWorldRendering === true;
+        const documentPatchResult = resultObject?.documentPatch
+            ? applyRenderingDocumentPatch(state, options, document, resultObject.documentPatch, `Rendering action document update: ${input.actionId}`)
+            : null;
+        const syncDocument = documentPatchResult?.workingDocument ?? document;
+        const changed = result === true
+            || resultObject?.changed === true
+            || resultObject?.refreshWorldRendering === true
+            || documentPatchResult?.changed === true;
         if (resultObject?.status) {
             state.status = resultObject.status;
             state.statusTone = resultObject.statusTone ?? 'default';
             state.statusToneStatus = state.status;
             state.statusDetails = resultObject.statusDetails ?? '';
         }
+        else if (documentPatchResult?.changed) {
+            state.status = documentPatchResult.label;
+            state.statusTone = 'success';
+            state.statusToneStatus = state.status;
+            state.statusDetails = '';
+        }
         else if (changed) {
             state.status = `Rendering action: ${input.actionId}`;
             state.statusTone = 'success';
@@ -2415,12 +2617,14 @@ async function applyRenderingAction(state, options, input) {
             state.statusDetails = '';
         }
         if (changed) {
-            syncEditorWorldRenderingFromDocument(state, options, document, 'rendering-panel-action', true);
-            requestEditorSceneFrame(state, 'rendering-panel-action');
+            syncEditorWorldRenderingFromDocument(state, options, syncDocument, 'rendering-panel-action', true);
+            invalidateEditorScene(state, 'rendering-panel-action', options);
         }
+        clearRenderingActionAfterMinimumDuration(state, progressStartedAt, input.actionId, render);
         return changed || !!resultObject?.status;
     }
     catch (error) {
+        state.renderingAction = null;
         state.status = error instanceof Error ? error.message : String(error);
         state.statusTone = 'error';
         state.statusToneStatus = state.status;
@@ -2429,6 +2633,70 @@ async function applyRenderingAction(state, options, input) {
         return true;
     }
 }
+function clearRenderingActionAfterMinimumDuration(state, startedAt, actionId, render) {
+    void waitForRenderingProgressMinimumDuration(startedAt).then(() => {
+        if (state.renderingAction?.actionId !== actionId)
+            return;
+        state.renderingAction = null;
+        render();
+    });
+}
+function waitForRenderingProgressFrame() {
+    return new Promise(resolve => {
+        if (typeof requestAnimationFrame === 'function') {
+            requestAnimationFrame(() => resolve());
+        }
+        else {
+            setTimeout(resolve, 0);
+        }
+    });
+}
+function waitForRenderingProgressMinimumDuration(startedAt) {
+    const elapsed = Date.now() - startedAt;
+    const remaining = RENDERING_ACTION_PROGRESS_MIN_VISIBLE_MS - elapsed;
+    if (remaining <= 0)
+        return Promise.resolve();
+    return new Promise(resolve => setTimeout(resolve, remaining));
+}
+function applyRenderingDocumentPatch(state, options, document, patch, fallbackLabel) {
+    if (state.mode !== 'editor' || !state.session) {
+        return { changed: false, workingDocument: document, label: patch.label ?? fallbackLabel };
+    }
+    const label = patch.label ?? fallbackLabel;
+    const defaultImpact = patch.reprojectIds?.length
+        ? createReprojectProjectionImpact(patch.reprojectIds)
+        : patch.changedIds?.length
+            ? createReprojectProjectionImpact(patch.changedIds)
+            : patch.changedId
+                ? createReprojectProjectionImpact([patch.changedId])
+                : undefined;
+    const projectionImpact = resolveProjectionImpact(patch, defaultImpact);
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label,
+        patch: patch.patch,
+        targetId: patch.changedId,
+        ...withProjectionImpact(projectionImpact),
+    });
+    if (!result.documentChanged) {
+        return { changed: false, workingDocument: result.workingDocument, label };
+    }
+    if (projectionImpact) {
+        const applied = applyProjectionImpactToDocument(state, options, {
+            document: result.workingDocument,
+            selection: result.selection,
+            impact: projectionImpact,
+            reason: 'rendering-document-patch-impact',
+        });
+        if (!applied)
+            rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
+    }
+    else {
+        syncProjectionForDispatchResult(state, options, result, patch.changedId);
+    }
+    state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
+    return { changed: true, workingDocument: result.workingDocument, label };
+}
 function createInspectorEditTransaction(state, options, document, input, targetIds) {
     const property = findInspectorPropertyForEdit(state, options, document, input, targetIds);
     if (!property) {
@@ -2516,6 +2784,9 @@ function isSerializedTransformPath(path) {
         || path.startsWith('transform.rotation.')
         || path.startsWith('transform.scale.');
 }
+function isSerializedProjectionMetadataPath(path) {
+    return path === 'shadowMode';
+}
 function beginDuplicateDrag(state, options, input) {
     if (state.mode !== 'editor' || !state.session)
         return null;
@@ -2533,15 +2804,13 @@ function beginDuplicateDrag(state, options, input) {
         return null;
     }
     const originalSelection = state.session.getSelection();
+    const projectionImpact = resolveProjectionImpact(patch, createDuplicateProjectionImpact(patch));
     const result = state.session.dispatch({
         type: 'document.patch',
         label: patch.label ?? `Duplicate ${input.targetIds.length} object(s)`,
         patch: patch.patch,
         targetId: patch.activeId ?? patch.createdIds[patch.createdIds.length - 1] ?? undefined,
-        ...withProjectionImpact(resolveProjectionImpact(patch, createCreatedReprojectProjectionImpact({
-            createdNodeIds: patch.createdIds,
-            reprojectIds: patch.reprojectIds,
-        }))),
+        ...withProjectionImpact(projectionImpact),
     });
     if (!result.documentChanged) {
         state.status = 'Duplicate drag unchanged';
@@ -2569,11 +2838,14 @@ function beginDuplicateDrag(state, options, input) {
         createdIds,
         activeId,
     };
-    rebuildProjectionFromDocument(state, options, result.workingDocument, selectionResult.selection);
-    if (patch.reprojectIds?.length)
-        reprojectProjectionForChangedIds(state, options, result.workingDocument, patch.reprojectIds);
-    else
-        syncProjectionForChangedIds(state, options, result.workingDocument, patch.changedIds ?? createdIds);
+    if (!applyProjectionImpactToDocument(state, options, {
+        document: result.workingDocument,
+        selection: selectionResult.selection,
+        impact: projectionImpact,
+        reason: 'duplicate-drag-impact',
+    })) {
+        rebuildProjectionFromDocument(state, options, result.workingDocument, selectionResult.selection);
+    }
     state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
     state.status = patch.label ?? `Duplicated ${createdIds.length} object(s)`;
     return {
@@ -2800,6 +3072,19 @@ function createKnownCreatedReprojectProjectionImpact(input) {
         reprojectIds: input.reprojectIds,
     });
 }
+function createDuplicateProjectionImpact(patch) {
+    const createdNodeIds = uniqueProjectionIds(patch.createdIds);
+    const reprojectIds = uniqueProjectionIds(patch.reprojectIds);
+    const createdNodeIdSet = new Set(createdNodeIds);
+    const reprojectIdSet = new Set(reprojectIds);
+    const syncTransformIds = uniqueProjectionIds(patch.changedIds)
+        .filter(id => !createdNodeIdSet.has(id) && !reprojectIdSet.has(id));
+    return createIncrementalProjectionImpact({
+        createdNodeIds,
+        reprojectIds,
+        syncTransformIds,
+    });
+}
 function createIncrementalProjectionImpact(input) {
     const syncTransformIds = uniqueProjectionIds(input.syncTransformIds);
     const reprojectIds = uniqueProjectionIds(input.reprojectIds);
@@ -2903,56 +3188,85 @@ function applyHistoryProjectionImpact(state, options, result, operation) {
     if (!applied)
         rebuildProjection(state, options, result);
 }
+function applyProjectionImpactToDocument(state, options, input) {
+    if (!input.impact || input.impact.type === 'rebuild')
+        return false;
+    return applyIncrementalProjectionImpactToDocument(state, options, {
+        document: input.document,
+        selection: input.selection,
+        syncTransformIds: input.impact.syncTransformIds,
+        reprojectIds: input.impact.reprojectIds,
+        projectNodeIds: input.impact.createdNodeIds,
+        removeNodeIds: input.impact.deletedNodeIds,
+        reason: input.reason,
+    });
+}
 function rebuildProjection(state, options, result) {
     rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
 }
 function applyIncrementalHistoryProjectionImpact(state, options, result, operation, impact) {
-    if (!state.projection)
-        return false;
-    const syncTransformIds = uniqueProjectionIds(impact.syncTransformIds);
-    const reprojectIds = uniqueProjectionIds(impact.reprojectIds);
     const projectNodeIds = operation === 'redo'
         ? uniqueProjectionIds(impact.createdNodeIds)
         : uniqueProjectionIds(impact.deletedNodeIds);
     const removeNodeIds = operation === 'redo'
         ? uniqueProjectionIds(impact.deletedNodeIds)
         : uniqueProjectionIds(impact.createdNodeIds);
+    return applyIncrementalProjectionImpactToDocument(state, options, {
+        document: result.workingDocument,
+        selection: result.selection,
+        syncTransformIds: impact.syncTransformIds,
+        reprojectIds: impact.reprojectIds,
+        projectNodeIds,
+        removeNodeIds,
+        reason: 'history-impact',
+    });
+}
+function applyIncrementalProjectionImpactToDocument(state, options, input) {
+    if (!state.projection)
+        return false;
+    const syncTransformIds = uniqueProjectionIds(input.syncTransformIds);
+    const reprojectIds = uniqueProjectionIds(input.reprojectIds);
+    const projectNodeIds = uniqueProjectionIds(input.projectNodeIds);
+    const removeNodeIds = uniqueProjectionIds(input.removeNodeIds);
     const touched = syncTransformIds.length > 0
         || reprojectIds.length > 0
         || projectNodeIds.length > 0
         || removeNodeIds.length > 0;
     if (!touched)
         return false;
+    const projectNodes = resolveProjectionNodes(options, input.document, projectNodeIds);
+    const reprojectNodes = resolveProjectionNodes(options, input.document, reprojectIds);
+    const syncTransformNodes = resolveProjectionNodes(options, input.document, syncTransformIds);
+    if (!projectNodes || !reprojectNodes || !syncTransformNodes)
+        return false;
     for (const nodeId of removeNodeIds) {
         state.projection.removeNode(nodeId);
     }
-    for (const nodeId of projectNodeIds) {
-        const projectedNode = options.documentAdapter.getProjectionNode(result.workingDocument, nodeId);
-        if (!projectedNode)
-            return false;
+    for (const projectedNode of projectNodes) {
         state.projection.projectNode(projectedNode);
     }
-    for (const nodeId of reprojectIds) {
-        const projectedNode = options.documentAdapter.getProjectionNode(result.workingDocument, nodeId);
-        if (!projectedNode)
-            return false;
+    for (const projectedNode of reprojectNodes) {
         state.projection.projectNode(projectedNode);
     }
-    for (const nodeId of syncTransformIds) {
-        const projectedNode = options.documentAdapter.getProjectionNode(result.workingDocument, nodeId);
-        if (!projectedNode)
-            return false;
+    for (const projectedNode of syncTransformNodes) {
         state.projection.syncNodeTransform(projectedNode);
     }
-    syncProjectionAfterHistoryIncrementalImpact(state, options, result.workingDocument, result.selection);
+    const sanitized = sanitizeSelection(state, options, input.document, input.selection);
+    syncSelectionToProjection(state, sanitized ?? input.selection);
+    syncEditorWorldAppearanceFromDocument(state, options, input.document, `world-appearance-${input.reason}`);
+    syncEditorWorldRenderingFromDocument(state, options, input.document, `world-rendering-${input.reason}`, true);
+    invalidateEditorScene(state, `projection-${input.reason}`, options);
     return true;
 }
-function syncProjectionAfterHistoryIncrementalImpact(state, options, document, selection) {
-    const sanitized = sanitizeSelection(state, options, document, selection);
-    syncSelectionToProjection(state, sanitized ?? selection);
-    syncEditorWorldAppearanceFromDocument(state, options, document, 'world-appearance-history-impact');
-    syncEditorWorldRenderingFromDocument(state, options, document, 'world-rendering-history-impact', true);
-    invalidateEditorScene(state, 'projection-history-impact', options);
+function resolveProjectionNodes(options, document, ids) {
+    const projectedNodes = [];
+    for (const id of ids) {
+        const projectedNode = options.documentAdapter.getProjectionNode(document, id);
+        if (!projectedNode)
+            return null;
+        projectedNodes.push(projectedNode);
+    }
+    return projectedNodes;
 }
 function rebuildProjectionFromDocument(state, options, document, selection) {
     state.projection?.rebuild(options.documentAdapter.getProjectionNodes(document));
@@ -2972,7 +3286,7 @@ function syncProjectionForDispatchResult(state, options, result, changedId) {
         syncSelectionToProjection(state, result.selection ?? { selectedIds: [], activeId: null });
     }
     else if (result.documentChanged) {
-        const selection = state.session?.getState().selection ?? { selectedIds: [], activeId: null };
+        const selection = state.session?.getState({ cloneDocuments: false }).selection ?? { selectedIds: [], activeId: null };
         const sanitized = result.workingDocument ? sanitizeSelection(state, options, result.workingDocument, selection) : null;
         syncSelectionToProjection(state, sanitized ?? selection);
     }
@@ -2990,12 +3304,36 @@ function syncProjectionForChangedIds(state, options, document, changedIds) {
         if (projectedNode)
             state.projection?.syncNodeTransform(projectedNode);
     }
-    const selection = state.session?.getState().selection ?? { selectedIds: [], activeId: null };
+    const selection = state.session?.getState({ cloneDocuments: false }).selection ?? { selectedIds: [], activeId: null };
     syncSelectionToProjection(state, selection);
     syncEditorWorldAppearanceFromDocument(state, options, document, 'world-appearance-sync-changed-ids');
     syncEditorWorldRenderingFromDocument(state, options, document, 'world-rendering-sync-changed-ids', true);
     invalidateEditorScene(state, 'projection-sync-changed-ids');
 }
+function syncProjectionMetadataForChangedIds(state, options, document, changedIds, syncOptions = {}) {
+    for (const changedId of changedIds) {
+        const projectedNode = options.documentAdapter.getProjectionNode(document, changedId);
+        if (projectedNode) {
+            state.projection?.syncNodeMetadata?.(projectedNode);
+        }
+    }
+    const selection = state.session?.getState({ cloneDocuments: false }).selection ?? { selectedIds: [], activeId: null };
+    syncSelectionToProjection(state, selection);
+    syncEditorWorldAppearanceFromDocument(state, options, document, 'world-appearance-sync-metadata-ids');
+    if (syncOptions.invalidateStaticShadowArtifact) {
+        state.shadowPreview?.invalidateStaticProjectedArtifact?.();
+    }
+    else {
+        syncEditorWorldRenderingFromDocument(state, options, document, 'world-rendering-sync-metadata-ids', true);
+    }
+    if (syncOptions.deferShadowPreviewRefresh) {
+        scheduleProjectionShadowPreviewRefresh(state, 'projection-sync-metadata-ids-shadow-preview');
+    }
+    else {
+        state.shadowPreview?.refresh();
+    }
+    invalidateEditorScene(state, 'projection-sync-metadata-ids');
+}
 function reprojectProjectionForChangedIds(state, options, document, changedIds) {
     for (const changedId of changedIds) {
         const projectedNode = options.documentAdapter.getProjectionNode(document, changedId);
@@ -3172,21 +3510,24 @@ function radiansToInspectorDegrees(value) {
     return (value * 180) / Math.PI;
 }
 function createUiState(state, options) {
-    const sessionState = state.session?.getState();
+    const sessionState = state.session?.getState({ cloneDocuments: false });
     const document = sessionState?.workingDocument ?? null;
     const selectedIds = sessionState?.selection.selectedIds ?? [];
     const activeId = sessionState?.selection.activeId ?? null;
+    const largeSelection = isLargeSelection(selectedIds);
     const serializedObject = document && activeId && selectedIds.length === 1
         ? options.documentAdapter.getSerializedObject(document, activeId)
         : null;
-    const serializedMultiObject = document && selectedIds.length > 1
+    const serializedMultiObject = document && selectedIds.length > 1 && !largeSelection
         ? options.documentAdapter.getSerializedMultiObject?.(document, selectedIds, activeId) ?? null
         : null;
     const inspectorObjectBase = document && activeId && selectedIds.length === 1
         ? options.documentAdapter.getInspectorObject?.(document, activeId) ?? (serializedObject ? serializedObjectToInspectorObject(serializedObject, document) : null)
         : null;
     const inspectorMultiObjectBase = document && selectedIds.length > 1
-        ? createInspectorMultiObjectBase(state, options, document, selectedIds, activeId, serializedMultiObject)
+        ? createInspectorMultiObjectBase(state, options, document, selectedIds, activeId, serializedMultiObject, {
+            largeSelection,
+        })
         : null;
     const inspectorObject = document && inspectorObjectBase
         ? withRuntimeInspectorSections(state, options, document, inspectorObjectBase)
@@ -3199,6 +3540,13 @@ function createUiState(state, options) {
     const documentAssetItems = document
         ? options.documentAdapter.getBrowserAssetItems?.(document) ?? []
         : [];
+    const hierarchy = document ? options.documentAdapter.getHierarchyItems(document) : [];
+    state.performanceObjectCount = document ? countLocalEditorAuthoredObjects(hierarchy) : null;
+    state.performanceStats = createLocalEditorPerformanceStats({
+        frameStats: state.sceneFrameStats,
+        runtimeStats: state.performanceMonitor?.readSnapshot() ?? null,
+        objectCount: state.performanceObjectCount,
+    });
     const assets = dedupeLocalEditorBrowserAssetItems([
         ...state.assets.map(asset => toBrowserAssetItem(options, asset)),
         ...documentAssetItems,
@@ -3214,7 +3562,7 @@ function createUiState(state, options) {
         assets,
         selectedAssetId: state.selectedAssetId,
         assetCountLabel: `${assets.length} assets`,
-        hierarchy: document ? options.documentAdapter.getHierarchyItems(document) : [],
+        hierarchy,
         selectedIds,
         activeId,
         selectionSummary: {
@@ -3225,7 +3573,13 @@ function createUiState(state, options) {
         serializedMultiObject,
         inspectorObject: previewInspectorObject,
         inspectorMultiObject: previewInspectorMultiObject,
-        renderingPanel: document ? options.documentAdapter.getRenderingPanelState?.(document) ?? null : null,
+        renderingPanel: document
+            ? options.documentAdapter.getRenderingPanelState?.(document, {
+                scene: state.world?.scene ?? null,
+                projection: state.projection,
+                renderingAction: state.renderingAction,
+            }) ?? null
+            : null,
         boxSelection: state.boxSelection,
         coordinateAxes: options.world?.coordinateAxes === false
             ? null
@@ -3241,8 +3595,8 @@ function createUiState(state, options) {
             settings: cloneTransformOperationSettings(state.transformOperationSettings),
             selectedCount: selectedIds.length,
             activeId,
-            canAlign: selectedIds.length >= 2 && activeId != null,
-            canDistribute: selectedIds.length >= 3,
+            canAlign: !largeSelection && selectedIds.length >= 2 && activeId != null,
+            canDistribute: !largeSelection && selectedIds.length >= 3,
         },
         viewportTools: cloneEditorViewportToolState(state.viewportTools),
         viewportMeasurement: cloneViewportMeasurement(state.viewportMeasurement),
@@ -3250,6 +3604,7 @@ function createUiState(state, options) {
         sceneFrameStats: state.sceneFrameStats
             ? { ...state.sceneFrameStats, activeReasons: [...state.sceneFrameStats.activeReasons] }
             : null,
+        performanceStats: cloneLocalEditorPerformanceStats(state.performanceStats),
         sceneCameraPreview: {
             enabled: state.sceneCameraPreviewEnabled,
             available: hasSceneCameraPreviewRig(state, options),
@@ -3270,10 +3625,12 @@ function createUiState(state, options) {
     };
 }
 function createUiPreviewState(state, options) {
-    const selection = state.session?.getState().selection;
-    const document = state.session?.getState().workingDocument ?? null;
+    const sessionState = state.session?.getState({ cloneDocuments: false });
+    const selection = sessionState?.selection;
+    const document = sessionState?.workingDocument ?? null;
     const selectedIds = selection?.selectedIds ?? [];
     const activeId = selection?.activeId ?? null;
+    const largeSelection = isLargeSelection(selectedIds);
     const shouldPreviewInspector = !!state.activeTransformPreview && document && activeId && selectedIds.length === 1;
     const inspectorObjectBase = shouldPreviewInspector
         ? options.documentAdapter.getInspectorObject?.(document, activeId)
@@ -3305,8 +3662,8 @@ function createUiPreviewState(state, options) {
             settings: cloneTransformOperationSettings(state.transformOperationSettings),
             selectedCount: selectedIds.length,
             activeId,
-            canAlign: selectedIds.length >= 2 && activeId != null,
-            canDistribute: selectedIds.length >= 3,
+            canAlign: !largeSelection && selectedIds.length >= 2 && activeId != null,
+            canDistribute: !largeSelection && selectedIds.length >= 3,
         },
         viewportTools: cloneEditorViewportToolState(state.viewportTools),
         viewportMeasurement: cloneViewportMeasurement(state.viewportMeasurement),
@@ -3314,8 +3671,28 @@ function createUiPreviewState(state, options) {
         sceneFrameStats: state.sceneFrameStats
             ? { ...state.sceneFrameStats, activeReasons: [...state.sceneFrameStats.activeReasons] }
             : null,
+        performanceStats: cloneLocalEditorPerformanceStats(state.performanceStats),
     };
 }
+function setLocalEditorPerformanceMonitorOpen(state, open) {
+    if (state.performanceMonitorOpen === open)
+        return;
+    state.performanceMonitorOpen = open;
+    if (open) {
+        state.viewportRenderCoordinator?.beginContinuous(LOCAL_EDITOR_PERFORMANCE_MONITOR_REASON);
+    }
+    else {
+        state.viewportRenderCoordinator?.endContinuous(LOCAL_EDITOR_PERFORMANCE_MONITOR_REASON);
+    }
+}
+function updateLocalEditorPerformanceStats(state, updatePerformanceStats) {
+    state.performanceStats = createLocalEditorPerformanceStats({
+        frameStats: state.sceneFrameStats,
+        runtimeStats: state.performanceMonitor?.readSnapshot() ?? null,
+        objectCount: state.performanceObjectCount,
+    });
+    updatePerformanceStats(cloneLocalEditorPerformanceStats(state.performanceStats));
+}
 function createSceneViewCoordinateAxesState(state) {
     if (state.mode !== 'editor')
         return null;
@@ -3409,36 +3786,84 @@ function clampNumber(value, min, max) {
         return min;
     return Math.min(max, Math.max(min, value));
 }
-function createInspectorMultiObjectBase(state, options, document, selectedIds, activeId, serializedMultiObject) {
+function isLargeSelection(selectedIds) {
+    return selectedIds.length > LARGE_SELECTION_THRESHOLD;
+}
+function createInspectorMultiObjectBase(state, options, document, selectedIds, activeId, serializedMultiObject, multiOptions = {}) {
     const targetIds = [...selectedIds];
     if (targetIds.length <= 1)
         return null;
     const adapterMultiObject = options.documentAdapter.getInspectorMultiObject?.(document, targetIds, activeId) ?? null;
+    if (multiOptions.largeSelection) {
+        return applyMultiInspectorBatchCapabilityGate(options, document, adapterMultiObject ?? createLargeSelectionInspectorObject(document, targetIds, activeId));
+    }
     const serializedMulti = serializedMultiObject !== undefined
         ? serializedMultiObject
         : options.documentAdapter.getSerializedMultiObject?.(document, targetIds, activeId) ?? null;
     const serializedInspector = serializedMulti ? serializedMultiObjectToInspectorObject(serializedMulti, document) : null;
     const baseInspector = adapterMultiObject ?? serializedInspector;
     const aggregatedInspector = createAggregatedInspectorMultiObjectBase(state, options, document, targetIds, activeId);
-    if (!baseInspector)
-        return aggregatedInspector;
-    if (!aggregatedInspector)
-        return baseInspector;
+    let inspectorObject = baseInspector ?? aggregatedInspector;
+    if (baseInspector && aggregatedInspector) {
+        inspectorObject = {
+            ...baseInspector,
+            targetIds,
+            activeId,
+            label: baseInspector.label ?? aggregatedInspector.label,
+            document,
+            selection: {
+                ...baseInspector.selection,
+                targetIds,
+                activeId,
+                document,
+            },
+            sections: mergeInspectorSections(baseInspector.sections, aggregatedInspector.sections, {
+                propertyConflict: 'ignore',
+            }),
+        };
+    }
+    return applyMultiInspectorBatchCapabilityGate(options, document, inspectorObject);
+}
+function createLargeSelectionInspectorObject(document, targetIds, activeId) {
     return {
-        ...baseInspector,
-        targetIds,
+        targetIds: [...targetIds],
         activeId,
-        label: baseInspector.label ?? aggregatedInspector.label,
+        label: `${targetIds.length} objects`,
         document,
         selection: {
-            ...baseInspector.selection,
-            targetIds,
+            targetIds: [...targetIds],
             activeId,
             document,
         },
-        sections: mergeInspectorSections(baseInspector.sections, aggregatedInspector.sections, {
-            propertyConflict: 'ignore',
-        }),
+        sections: [{
+                id: 'large-selection',
+                title: 'Large Selection',
+                order: 10,
+                placement: 'body',
+                persistence: 'readonly',
+                properties: [
+                    {
+                        path: 'selection.count',
+                        label: 'Selected',
+                        valueType: 'number',
+                        control: 'readonly',
+                        value: targetIds.length,
+                        readOnly: true,
+                        persistence: 'readonly',
+                        commitMode: 'immediate',
+                    },
+                    {
+                        path: 'selection.activeId',
+                        label: 'Active ID',
+                        valueType: 'string',
+                        control: 'readonly',
+                        value: activeId ?? 'None',
+                        readOnly: true,
+                        persistence: 'readonly',
+                        commitMode: 'immediate',
+                    },
+                ],
+            }],
     };
 }
 function createAggregatedInspectorMultiObjectBase(_state, options, document, selectedIds, activeId) {
@@ -3452,9 +3877,7 @@ function createAggregatedInspectorMultiObjectBase(_state, options, document, sel
         label: `${selectedIds.length} objects`,
         document,
     });
-    return options.documentAdapter.createSerializedMultiPropertyPatch
-        ? applyAggregatedBatchInspectorCapabilityGate(options, document, aggregatedInspector)
-        : disableAggregatedBatchInspectorObject(aggregatedInspector);
+    return aggregatedInspector;
 }
 function createSingleInspectorObjectBase(options, document, targetId) {
     const inspectorObject = options.documentAdapter.getInspectorObject?.(document, targetId) ?? null;
@@ -3463,6 +3886,11 @@ function createSingleInspectorObjectBase(options, document, targetId) {
     const serializedObject = options.documentAdapter.getSerializedObject(document, targetId);
     return serializedObject ? serializedObjectToInspectorObject(serializedObject, document) : null;
 }
+function applyMultiInspectorBatchCapabilityGate(options, document, inspectorObject) {
+    return options.documentAdapter.createSerializedMultiPropertyPatch
+        ? applyAggregatedBatchInspectorCapabilityGate(options, document, inspectorObject)
+        : disableAggregatedBatchInspectorObject(inspectorObject);
+}
 function disableAggregatedBatchInspectorObject(inspectorObject) {
     if (!inspectorObject)
         return null;
@@ -3774,13 +4202,13 @@ async function saveDocumentFallback(options, document) {
     return options.persistenceAdapter.saveDocument(document);
 }
 function isDocumentNodeSelectable(state, options, id) {
-    const document = state.session?.getState().workingDocument;
+    const document = state.session?.getState({ cloneDocuments: false }).workingDocument;
     if (!document)
         return false;
     return isNodeSelectableInDocument(options, document, id);
 }
 function isDocumentNodeLocked(state, options, id) {
-    const document = state.session?.getState().workingDocument;
+    const document = state.session?.getState({ cloneDocuments: false }).workingDocument;
     if (!document)
         return false;
     return options.documentAdapter.isLocked?.(document, id) ?? false;