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

package/dist/local-editor-harness.js

@@ -1,8 +1,9 @@
-import { createEditorSession, FPS_EDITOR_ACTIVE_TOOL_CHANGED, FPS_EDITOR_DOCUMENT_CHANGED, FPS_EDITOR_HISTORY_CHANGED, FPS_EDITOR_SELECTION_CHANGED, createEditorAgentBridge, createInspectorRegistry, DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS, DEFAULT_EDITOR_VIEWPORT_TOOL_STATE, createEmptyEditorViewportSpatialOverlayState, cloneEditorTransformSnapshot as cloneCoreEditorTransformSnapshot, composeEditorTransformMatrix, editorTransformMatricesAlmostEqual, cloneEditorViewportToolState, cloneEditorViewportSpatialOverlayState, aggregateInspectorObjectsToMultiObject, createInspectorEditPayload, compareInspectorSections, computeEditorTransformActionTargets, mergeInspectorSections, isEditorTransformTrsSnapshot, normalizeEditorTransformConstraint, readEditorTransformPosition, resolveEditorSelectionCommand, validateSceneGraphDelete, validateSceneGraphDrop, validateSceneGraphGroupSelection, validateSceneGraphMove, validateSceneGraphRename, } from '@fps-games/editor-core';
+import { createEditorAuthoringHost, createEditorSession, FPS_EDITOR_ACTIVE_TOOL_CHANGED, FPS_EDITOR_DOCUMENT_CHANGED, FPS_EDITOR_HISTORY_CHANGED, FPS_EDITOR_SELECTION_CHANGED, createEditorCommandCapabilityAdapter, createEditorCommandSystem, createInspectorRegistry, DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS, DEFAULT_EDITOR_VIEWPORT_TOOL_STATE, createEmptyEditorViewportSpatialOverlayState, callWithEditorAuthoringSerializedAccess, createEditorAuthoringSerializedSessionView, cloneEditorTransformSnapshot as cloneCoreEditorTransformSnapshot, composeEditorTransformMatrix, editorTransformMatricesAlmostEqual, cloneEditorViewportToolState, cloneEditorViewportSpatialOverlayState, aggregateInspectorObjectsToMultiObject, createInspectorEditPayload, compareInspectorSections, computeEditorTransformActionTargets, mergeInspectorSections, isEditorTransformTrsSnapshot, normalizeEditorTransformConstraint, readEditorTransformPosition, resolveEditorSelectionCommand, validateSceneGraphDelete, validateSceneGraphDrop, validateSceneGraphGroupSelection, validateSceneGraphMove, validateSceneGraphRename, } from '@fps-games/editor-core';
 import { createEditorToolManager, createEditorToolRegistry, resolveEditingContextProvider, } from '@fps-games/editor-core/tools';
 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 { EDITOR_COMMAND_ID, } from '@fps-games/editor-protocol';
+import { createLocalEditorBrowserUi, createLocalEditorCommandServiceClient, resolveLocalEditorBrowserAssetKind, resolveLocalEditorStatusDiagnosticLocator, toTransformOperationPolicyStatusLabel, } from '@fps-games/editor-browser';
+import { classifyProjectServiceSnapshot, createProjectServiceProjectionSessionAuthority, shouldReplacePendingProjectServiceSnapshot, waitForProjectServiceOperation, } from './project-service-projection.js';
 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';
@@ -17,14 +18,12 @@ import { createPlayableBabylonOutlineInspectorSection, createPlayableBabylonOutl
 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';
-import { registerLocalEditorAgentBridgeCapabilities } from './local-editor-agent-bridge.js';
-import { registerEditorPluginAgentCapabilities } from './editor-plugin-agent-capabilities.js';
+import { registerLocalEditorCommandCapabilities } from './local-editor-commands.js';
+import { registerEditorPluginCommands } from './editor-plugin-commands.js';
 import { createLocalEditorStandardToolRegistrations, LOCAL_EDITOR_SELECTION_CAPABILITY_ID, LOCAL_EDITOR_STANDARD_TOOL_IDS, LOCAL_EDITOR_TRANSFORM_CAPABILITY_ID, resolveLocalEditorTransformTool, } from './local-editor-tools.js';
 import { createHierarchyScopeSnapshot, createHierarchyTreeSnapshot, resolveHierarchyScopeProviders, resolveHierarchySurfaceContribution, } from '@fps-games/plugin-hierarchy';
-import { createLocalEditorAgentBridgeCapabilitySources, } from './agent-bridge/capability-sources.js';
-import { createDisabledLocalEditorAgentBridgeTransportStatus, createLocalEditorAgentBridgeWebSocketTransportFromQuery, } from './local-editor-agent-bridge-transport.js';
+import { createLocalEditorCommandCapabilitySources, } from './editor-commands/command-sources.js';
 import { PLAYABLE_LOCAL_EDITOR_APPLICATION_SCOPE_ID, PLAYABLE_LOCAL_EDITOR_MAIN_DOCUMENT_SCOPE_ID, PLAYABLE_LOCAL_EDITOR_MAIN_PREVIEW_SCOPE_ID, PLAYABLE_LOCAL_EDITOR_MAIN_SESSION_SCOPE_ID, PLAYABLE_LOCAL_EDITOR_PROJECT_SCOPE_ID, } from '@fps-games/editor-playable-sdk/internal/local-harness';
-import { FPS_EDITOR_LIFECYCLE_TRANSITION_TYPES } from '@fps-games/editor-core/lifecycle';
 import { createMarkerGraphHierarchyItems, createMarkerGraphInspectorObject, createMarkerGraphRootInspectorObject, createMarkerPanelState, createMarkerRelationCommand, createMarkerRelationCreateManyCommand, createMarkerRelationDeleteConnectedCommand, createMarkerRelationReverseCommand, createMarkerGraphPatchFromInspectorEdit, findSpatialMarkerById, getSpatialMarkerDirectRelations, isMarkerGraphHierarchyId, isMarkerGraphHierarchyRootId, isMarkerGraphHierarchyRootRowId, isSpatialMarkerBackedByHierarchyRow, isSpatialMarkerHierarchyVisible, readMarkerGraphHierarchyMarkerIdForGraph, readSpatialMarkerIdFromHierarchySelection, } from './local-editor-marker-graph.js';
 const BATCH_EDIT_REQUIRES_MULTI_PATCH_REASON = 'Batch edit requires multi-property patch support.';
 const LARGE_SELECTION_THRESHOLD = 200;
@@ -32,6 +31,7 @@ const LARGE_SHADOW_METADATA_BATCH_THRESHOLD = 200;
 const EDITOR_PROJECTION_VALIDATION_TIMEOUT_MS = 10000;
 const EDITOR_WORLD_DISPOSE_BOUNDARY_DELAY_MS = 500;
 const RENDERING_ACTION_PROGRESS_MIN_VISIBLE_MS = 1000;
+const SERIALIZED_HIERARCHY_INVOCATION = Symbol('fps.editor.serialized-hierarchy-invocation');
 const PREFAB_STAGE_CONTEXT_ACTION_IDS = Object.freeze({
     save: 'fps.editor.context.prefab.save',
     discard: 'fps.editor.context.prefab.discard',
@@ -264,22 +264,36 @@ export function createLocalEditorHarness(options) {
 }
 function createLocalEditorHarnessImplementation(options, construction) {
     const root = options.root ?? document.body;
+    const projectCommandService = createLocalEditorCommandServiceClient();
+    const browserCommandAttachmentId = `browser-command-host-${createLocalEditorAuthoringServiceInstanceId()}`;
+    let disposeBrowserCommandAttachment = null;
+    let projectedServiceInstanceId = null;
+    let projectedServiceRevision = null;
+    let projectedBrowserDocumentFingerprint = null;
+    let pendingProjectServiceSnapshot = null;
+    let stopProjectServiceWatch = null;
     let lifecycleController = null;
     let releaseApplicationAuthorityScopeResource = null;
     let releaseLifecycleRenderScopeResource = null;
     let unsubscribeLifecycleRender = null;
-    let unregisterAgentBridgeLifecycleParticipant = null;
-    const agentBridgeLifecycleTransports = new Map();
+    let suppressedDocumentMarkDirtyTransitionId = null;
+    let lifecyclePresentationOnlyRenderDepth = 0;
     let releaseMainSessionScopeResource = null;
     let releaseMainPreviewScopeResource = null;
     let pendingScheduledLifecycleExit = null;
     let harnessDisposed = false;
+    const commandServiceCommandSystem = createEditorCommandSystem();
+    const projectionSessionAuthority = createProjectServiceProjectionSessionAuthority();
+    const replaceProjectionSessionAuthority = (session) => projectionSessionAuthority.replace(session);
+    const runProjectionSessionMutation = (session, mutation) => projectionSessionAuthority.run(session, mutation);
     const state = {
         get mode() {
+            if (state.session)
+                return 'editor';
             const lifecycleMode = lifecycleController?.lifecycle.getSnapshot().mode;
             if (lifecycleMode)
                 return lifecycleMode === 'edit' ? 'editor' : 'game';
-            return state.world ? 'editor' : 'game';
+            return 'game';
         },
         get lifecycle() {
             return lifecycleController?.lifecycle ?? null;
@@ -294,6 +308,7 @@ function createLocalEditorHarnessImplementation(options, construction) {
         hierarchyItemsCacheSession: null,
         hierarchyItemsCacheRevision: -1,
         hierarchyItemsCache: Object.freeze([]),
+        hierarchyPresentationFallbackRevision: 0,
         diagnosticStore: createEditorDiagnosticStore(),
         diagnosticPhase: 'edit',
         reuseDiagnosticSnapshotOnNextRender: false,
@@ -303,6 +318,17 @@ function createLocalEditorHarnessImplementation(options, construction) {
         busy: false,
         documentOperationActive: false,
         session: null,
+        authoringHost: null,
+        projectAuthoringSnapshot: null,
+        replaceProjectionSessionAuthority,
+        runBrowserAuthoringMutation: async () => {
+            throw new Error('Browser authoring authority is unavailable.');
+        },
+        tryRunBrowserAuthoringMutationImmediately: () => ({
+            ok: false,
+            reason: 'Browser authoring authority is unavailable.',
+        }),
+        reconcilePendingProjectServiceSnapshot: async () => { },
         createSessionChangeObserver: () => () => { },
         handleSessionObserverError: () => { },
         source: null,
@@ -345,8 +371,13 @@ function createLocalEditorHarnessImplementation(options, construction) {
         sceneViewSpatialOverlay: null,
         selectionController: null,
         selectionInspectorRefreshGeneration: 0,
-        selectionInspectorRefreshFrame: null,
         selectionInspectorRefreshTimeout: null,
+        suppressDocumentMarkDirtyInspectorRefresh: false,
+        suppressedProjectionInspectorRefreshBatchIds: new Set(),
+        suppressedProjectionInspectorRefreshNodeBatches: new Map(),
+        inspectorPresentationGeneration: 0,
+        inspectorPresentationFrame: null,
+        inspectorPresentationPatches: null,
         sceneRenderScheduler: null,
         viewportRenderCoordinator: null,
         sceneFrameStats: null,
@@ -383,10 +414,387 @@ function createLocalEditorHarnessImplementation(options, construction) {
         statusDetails: '',
         renderingAction: null,
         summary: '',
-        agentBridge: createEditorAgentBridge(),
-        unregisterAgentBridgeCapabilities: null,
-        agentBridgeTransport: null,
-        agentBridgeStatus: createDisabledLocalEditorAgentBridgeTransportStatus(),
+        commandService: createEditorCommandCapabilityAdapter({
+            commandSystem: commandServiceCommandSystem,
+            resolveAuthoringRevision: () => projectCommandService
+                ? projectedServiceRevision
+                : state.authoringHost?.getSnapshot().documentRevision ?? null,
+        }),
+        unregisterCommandCapabilities: null,
+    };
+    let browserAuthoringMutationSequence = 0;
+    let projectServiceSyncTail = Promise.resolve();
+    let projectServiceSyncPending = 0;
+    const acquireProjectServiceSync = async () => {
+        projectServiceSyncPending += 1;
+        const previous = projectServiceSyncTail;
+        let releaseCurrent;
+        projectServiceSyncTail = new Promise(resolve => { releaseCurrent = resolve; });
+        await previous;
+        let active = true;
+        return () => {
+            if (!active)
+                return;
+            active = false;
+            projectServiceSyncPending -= 1;
+            releaseCurrent();
+        };
+    };
+    const tryAcquireProjectServiceSync = () => {
+        if (projectServiceSyncPending > 0)
+            return null;
+        projectServiceSyncPending = 1;
+        let releaseCurrent;
+        projectServiceSyncTail = new Promise(resolve => { releaseCurrent = resolve; });
+        let active = true;
+        return () => {
+            if (!active)
+                return;
+            active = false;
+            projectServiceSyncPending = 0;
+            releaseCurrent();
+        };
+    };
+    const readProjectServiceSnapshot = async () => {
+        if (!projectCommandService)
+            return null;
+        const response = await projectCommandService.request({ kind: 'authoring.snapshot' });
+        if (!response.ok || response.kind !== 'authoring.snapshot'
+            || response.result.kind !== 'snapshot-required')
+            return null;
+        return response.result.snapshot;
+    };
+    const commitProjectAuthoringProjection = (snapshot, documentFingerprint = createLocalEditorDocumentFingerprint(snapshot.document)) => {
+        state.projectAuthoringSnapshot = {
+            serviceInstanceId: snapshot.serviceInstanceId,
+            documentRevision: snapshot.documentRevision,
+            dirty: snapshot.dirty,
+            canUndo: snapshot.canUndo,
+            canRedo: snapshot.canRedo,
+            history: snapshot.history
+                ? { entries: snapshot.history.entries.map(entry => ({ ...entry })) }
+                : { entries: [] },
+        };
+        projectedServiceRevision = snapshot.documentRevision;
+        projectedServiceInstanceId = snapshot.serviceInstanceId;
+        projectedBrowserDocumentFingerprint = documentFingerprint;
+        if (pendingProjectServiceSnapshot?.serviceInstanceId === snapshot.serviceInstanceId
+            && pendingProjectServiceSnapshot.documentRevision === snapshot.documentRevision) {
+            pendingProjectServiceSnapshot = null;
+        }
+    };
+    const invokeProjectServiceCommand = async (commandId, input = {}, expectedDocumentRevision) => {
+        if (!projectCommandService)
+            throw new Error('Project Editor Service is unavailable.');
+        if (projectedServiceRevision === null || projectedServiceInstanceId === null) {
+            const snapshot = await readProjectServiceSnapshot();
+            if (snapshot)
+                await applyProjectServiceSnapshot(snapshot, true);
+        }
+        const invocationExpectedRevision = expectedDocumentRevision ?? projectedServiceRevision;
+        if (invocationExpectedRevision === null || projectedServiceInstanceId === null) {
+            throw new Error('Project Editor Service revision is not ready.');
+        }
+        const requestId = `browser-project-${++browserAuthoringMutationSequence}`;
+        const response = await projectCommandService.request({
+            kind: 'command.invoke',
+            invocation: {
+                commandId,
+                input: input,
+                requestId,
+                idempotencyKey: requestId,
+                expectedRevision: {
+                    serviceInstanceId: projectedServiceInstanceId,
+                    document: invocationExpectedRevision,
+                },
+                principal: { type: 'human' },
+                source: 'browser-ui',
+                clientId: browserCommandAttachmentId,
+            },
+            timeoutMs: 10000,
+        });
+        const operation = await waitForProjectServiceOperation(projectCommandService.request, response);
+        if (operation?.status !== 'completed') {
+            throw new Error(operation?.diagnostics?.map(diagnostic => diagnostic.message).join('; ')
+                || `Project Editor Service rejected ${commandId}.`);
+        }
+        return operation.output && typeof operation.output === 'object' && !Array.isArray(operation.output)
+            ? operation.output
+            : {};
+    };
+    const prepareProjectServiceDocumentExport = async () => {
+        if (!projectCommandService)
+            return null;
+        const prepared = await invokeProjectServiceCommand('document.export');
+        const transactionId = typeof prepared.transactionId === 'string'
+            ? prepared.transactionId
+            : null;
+        if (!transactionId) {
+            throw new Error('Project Editor Service did not return an export transaction.');
+        }
+        const response = await projectCommandService.request({
+            kind: 'document.export.get',
+            transactionId,
+        });
+        if (!response.ok || response.kind !== 'document.export' || !response.artifact) {
+            throw new Error('Project Editor Service did not return the prepared export artifact.');
+        }
+        return response.artifact;
+    };
+    const applyProjectServiceSnapshot = async (snapshot, syncLeaseHeld = false) => {
+        if (projectCommandService && !syncLeaseHeld) {
+            const release = await acquireProjectServiceSync();
+            try {
+                return await applyProjectServiceSnapshot(snapshot, true);
+            }
+            finally {
+                release();
+            }
+        }
+        const classification = classifyProjectServiceSnapshot(projectedServiceInstanceId, projectedServiceRevision, snapshot);
+        if (classification === 'stale')
+            return;
+        const serviceChanged = classification === 'service-changed';
+        if (shouldReplacePendingProjectServiceSnapshot(pendingProjectServiceSnapshot, snapshot)) {
+            pendingProjectServiceSnapshot = snapshot;
+        }
+        const session = state.session;
+        if (!session || state.prefabStage)
+            return;
+        const stateSnapshot = session.getState({ cloneDocuments: false });
+        const localDocumentFingerprint = createLocalEditorDocumentFingerprint(stateSnapshot.workingDocument);
+        const snapshotDocumentFingerprint = createLocalEditorDocumentFingerprint(snapshot.document);
+        if (!serviceChanged
+            && projectedServiceRevision !== null
+            && projectedBrowserDocumentFingerprint !== null
+            && localDocumentFingerprint !== projectedBrowserDocumentFingerprint) {
+            throw new Error('The project snapshot cannot replace Browser working state because a newer local authoring transaction is not projected.');
+        }
+        if (localDocumentFingerprint === snapshotDocumentFingerprint
+            && createLocalEditorDocumentFingerprint(stateSnapshot.persistedDocument)
+                === createLocalEditorDocumentFingerprint(snapshot.savedDocument)) {
+            commitProjectAuthoringProjection(snapshot, snapshotDocumentFingerprint);
+            return;
+        }
+        const rebaseProjection = (activeSession) => {
+            if (state.session !== session || state.prefabStage) {
+                throw new Error('Browser authoring scope changed before applying the project snapshot.');
+            }
+            runProjectionSessionMutation(activeSession, () => {
+                activeSession.rebaseExternalDocuments({
+                    persistedDocument: snapshot.savedDocument,
+                    workingDocument: snapshot.document,
+                });
+            });
+        };
+        const host = state.authoringHost;
+        if (host) {
+            const sequence = ++browserAuthoringMutationSequence;
+            await host.runExternalCommandMutation({
+                commandId: 'authoring.snapshot.project',
+                requestId: `project-snapshot-${sequence}`,
+                idempotencyKey: `project-snapshot-${sequence}`,
+                expectedDocumentRevision: stateSnapshot.documentRevision,
+                fingerprint: JSON.stringify({ serviceInstanceId: snapshot.serviceInstanceId, documentRevision: snapshot.documentRevision }),
+            }, rebaseProjection);
+        }
+        else {
+            rebaseProjection(session);
+        }
+        commitProjectAuthoringProjection(snapshot, snapshotDocumentFingerprint);
+        harness.render();
+    };
+    const pushBrowserDocumentToProjectService = async (document, commandId, inputFingerprint, expectedServiceInstanceId, expectedServiceRevision, baseDocumentFingerprint, rollbackSession) => {
+        if (!projectCommandService)
+            return;
+        if (!disposeBrowserCommandAttachment || await disposeBrowserCommandAttachment === null) {
+            throw new Error('Browser command attachment is unavailable.');
+        }
+        const requestId = `browser-project-${++browserAuthoringMutationSequence}`;
+        const response = await projectCommandService.request({
+            kind: 'command.invoke',
+            invocation: {
+                commandId: 'authoring.proposal.commit',
+                intentCommandId: commandId,
+                input: { commandId, inputFingerprint, document },
+                requestId,
+                idempotencyKey: requestId,
+                expectedRevision: {
+                    serviceInstanceId: expectedServiceInstanceId,
+                    document: expectedServiceRevision,
+                },
+                principal: { type: 'human' },
+                source: 'browser-ui',
+                clientId: browserCommandAttachmentId,
+            },
+            timeoutMs: 10000,
+        });
+        const operation = await waitForProjectServiceOperation(projectCommandService.request, response);
+        if (operation?.status === 'completed') {
+            return;
+        }
+        const snapshot = await readProjectServiceSnapshot();
+        if (snapshot) {
+            if (shouldReplacePendingProjectServiceSnapshot(pendingProjectServiceSnapshot, snapshot)) {
+                pendingProjectServiceSnapshot = snapshot;
+            }
+        }
+        if (snapshot && rollbackSession) {
+            runProjectionSessionMutation(rollbackSession, () => {
+                rollbackSession.rebaseExternalDocuments({
+                    persistedDocument: snapshot.savedDocument,
+                    workingDocument: snapshot.document,
+                });
+            });
+            commitProjectAuthoringProjection(snapshot);
+        }
+        const remoteFingerprint = snapshot
+            ? createLocalEditorDocumentFingerprint(snapshot.document)
+            : null;
+        throw new Error(remoteFingerprint !== baseDocumentFingerprint
+            ? 'Browser authoring was rejected because the project document changed in another client.'
+            : operation?.diagnostics?.map(diagnostic => diagnostic.message).join('; ')
+                || 'Project Editor Service rejected the Browser authoring transaction.');
+    };
+    state.reconcilePendingProjectServiceSnapshot = async () => {
+        if (pendingProjectServiceSnapshot) {
+            await applyProjectServiceSnapshot(pendingProjectServiceSnapshot);
+        }
+    };
+    state.runBrowserAuthoringMutation = async (commandId, fingerprint, handler) => {
+        const releaseProjectSync = projectCommandService ? await acquireProjectServiceSync() : () => { };
+        try {
+            const session = state.session;
+            if (!session)
+                throw new Error('Browser authoring projection is unavailable.');
+            if (projectCommandService) {
+                if (projectedServiceRevision === null) {
+                    const remote = await readProjectServiceSnapshot();
+                    if (remote)
+                        await applyProjectServiceSnapshot(remote, true);
+                }
+                const expectedServiceInstanceId = projectedServiceInstanceId;
+                const expectedServiceRevision = projectedServiceRevision;
+                if (expectedServiceInstanceId === null || expectedServiceRevision === null) {
+                    throw new Error('Project Editor Service revision is not ready.');
+                }
+                const baseDocumentFingerprint = createLocalEditorDocumentFingerprint(session.getWorkingDocument());
+                const transaction = session.beginTransaction();
+                try {
+                    const authoringState = new Proxy(state, {
+                        get(target, property, receiver) {
+                            if (property === 'session')
+                                return transaction.session;
+                            return Reflect.get(target, property, receiver);
+                        },
+                        set(target, property, value, receiver) {
+                            if (property === 'session') {
+                                throw new Error('Browser authoring proposal handlers cannot replace the projection Session.');
+                            }
+                            return Reflect.set(target, property, value, receiver);
+                        },
+                    });
+                    const value = await handler(authoringState);
+                    if (state.session !== session) {
+                        throw new Error(`Browser authoring scope changed before ${commandId}.`);
+                    }
+                    const proposedDocument = transaction.session.getWorkingDocument();
+                    await pushBrowserDocumentToProjectService(proposedDocument, commandId, fingerprint, expectedServiceInstanceId, expectedServiceRevision, baseDocumentFingerprint, session);
+                    const committedSnapshot = await readProjectServiceSnapshot();
+                    if (!committedSnapshot) {
+                        throw new Error('Project Editor Service did not return the committed authoring snapshot.');
+                    }
+                    if (state.prefabStage && state.session === session) {
+                        const projectionState = session.getState({ cloneDocuments: false });
+                        runProjectionSessionMutation(session, () => {
+                            session.rebaseExternalDocuments({
+                                persistedDocument: projectionState.persistedDocument,
+                                workingDocument: committedSnapshot.document,
+                            });
+                        });
+                        commitProjectAuthoringProjection(committedSnapshot);
+                        harness.render();
+                    }
+                    else {
+                        await applyProjectServiceSnapshot(committedSnapshot, true);
+                    }
+                    return value;
+                }
+                finally {
+                    transaction.discard();
+                }
+            }
+            const host = state.authoringHost;
+            if (!host)
+                throw new Error('Browser authoring authority is unavailable.');
+            const expectedDocumentRevision = session.getState({ cloneDocuments: false }).documentRevision;
+            const sequence = ++browserAuthoringMutationSequence;
+            const requestId = `browser-${sequence}`;
+            return await host.runExternalCommandMutation({
+                commandId,
+                requestId,
+                idempotencyKey: requestId,
+                expectedDocumentRevision,
+                fingerprint,
+            }, activeSession => {
+                if (state.session !== session) {
+                    throw new Error(`Browser authoring scope changed before ${commandId}.`);
+                }
+                const authoringState = new Proxy(state, {
+                    get(target, property, receiver) {
+                        if (property === 'session')
+                            return activeSession;
+                        return Reflect.get(target, property, receiver);
+                    },
+                    set(target, property, value, receiver) {
+                        if (property === 'session') {
+                            throw new Error('Browser authoring handlers cannot replace the active Session.');
+                        }
+                        return Reflect.set(target, property, value, receiver);
+                    },
+                });
+                return handler(authoringState);
+            });
+        }
+        finally {
+            releaseProjectSync();
+        }
+    };
+    state.tryRunBrowserAuthoringMutationImmediately = (commandId, fingerprint, handler) => {
+        if (projectCommandService) {
+            return { ok: false, reason: 'Project Editor Service authoring is asynchronous.' };
+        }
+        const host = state.authoringHost;
+        const session = state.session;
+        if (!host || !session)
+            return { ok: false, reason: 'Browser authoring authority is unavailable.' };
+        const releaseProjectSync = tryAcquireProjectServiceSync();
+        if (!releaseProjectSync)
+            return { ok: false, reason: 'An authoring transaction is still pending.' };
+        const expectedDocumentRevision = session.getState({ cloneDocuments: false }).documentRevision;
+        const sequence = ++browserAuthoringMutationSequence;
+        const requestId = `browser-${sequence}`;
+        try {
+            const result = host.tryRunExternalCommandMutationImmediately({
+                commandId,
+                requestId,
+                idempotencyKey: requestId,
+                expectedDocumentRevision,
+                fingerprint,
+            }, activeSession => {
+                if (state.session !== session) {
+                    throw new Error(`Browser authoring scope changed before ${commandId}.`);
+                }
+                return handler(activeSession);
+            });
+            return result.ok ? { ok: true, value: result.value } : {
+                ok: false,
+                reason: 'Another authoring transaction is running.',
+            };
+        }
+        finally {
+            releaseProjectSync();
+        }
     };
     const getDocumentDirty = () => {
         const stageSnapshot = state.prefabStage?.transaction.snapshot();
@@ -398,6 +806,8 @@ function createLocalEditorHarnessImplementation(options, construction) {
         if (change.documentChanged)
             state.diagnosticPhase = 'edit';
         void lifecycleController?.synchronizeDocumentState(getDocumentDirty()).catch(error => {
+            state.suppressDocumentMarkDirtyInspectorRefresh = false;
+            suppressedDocumentMarkDirtyTransitionId = null;
             console.error('[LocalEditorHarness] lifecycle document synchronization failed', error);
         });
         const eventPublisher = options.pluginHost?.eventPublisher;
@@ -456,11 +866,93 @@ function createLocalEditorHarnessImplementation(options, construction) {
     state.createSessionChangeObserver = createSessionChangeObserver;
     state.handleSessionObserverError = handleEditorSessionObserverError;
     let harness;
+    const runProjectServiceHistoryOperation = async (operation, historyOptions = {}) => {
+        const origin = historyOptions.origin ?? 'user';
+        const waitForProjection = historyOptions.waitForProjection ?? 'none';
+        const releaseProjectSync = await acquireProjectServiceSync();
+        try {
+            cancelActiveOperation(state);
+            const before = await readProjectServiceSnapshot();
+            if (!before)
+                throw new Error('Project Editor Service history is unavailable.');
+            await applyProjectServiceSnapshot(before, true);
+            const available = operation === 'undo' ? before.canUndo : before.canRedo;
+            if (!available) {
+                return {
+                    ok: false,
+                    operation,
+                    origin,
+                    waitForProjection,
+                    documentChanged: false,
+                    transactionLabel: null,
+                    workingDocument: before.document,
+                    dirty: before.dirty,
+                    history: { canUndo: before.canUndo, canRedo: before.canRedo },
+                    status: operation === 'undo' ? 'Undo unavailable' : 'Redo unavailable',
+                    projection: createHistoryProjectionResult(waitForProjection, null, state),
+                };
+            }
+            await invokeProjectServiceCommand(`history.${operation}`);
+            const after = await readProjectServiceSnapshot();
+            if (!after)
+                throw new Error('Project Editor Service did not return the updated history snapshot.');
+            await applyProjectServiceSnapshot(after, true);
+            state.summary = summarizeDocument(options, after.document, state.session?.getSource());
+            state.status = operation === 'undo' ? 'Undo' : 'Redo';
+            state.statusTone = 'default';
+            state.statusToneStatus = state.status;
+            state.statusDetails = '';
+            harness.render();
+            const idleState = waitForProjection === 'settled'
+                ? await state.projection?.waitForIdle() ?? null
+                : null;
+            return {
+                ok: true,
+                operation,
+                origin,
+                waitForProjection,
+                documentChanged: after.documentRevision !== before.documentRevision,
+                transactionLabel: null,
+                workingDocument: after.document,
+                dirty: after.dirty,
+                history: { canUndo: after.canUndo, canRedo: after.canRedo },
+                status: state.status,
+                projection: createHistoryProjectionResult(waitForProjection, idleState, state),
+            };
+        }
+        catch (error) {
+            reportBrowserAuthoringFailure(state, () => harness.render(), error);
+            const snapshot = state.projectAuthoringSnapshot;
+            return {
+                ok: false,
+                operation,
+                origin,
+                waitForProjection,
+                documentChanged: false,
+                transactionLabel: null,
+                workingDocument: state.session?.getWorkingDocument() ?? null,
+                dirty: snapshot?.dirty ?? state.session?.isDirty() ?? false,
+                history: {
+                    canUndo: snapshot?.canUndo ?? false,
+                    canRedo: snapshot?.canRedo ?? false,
+                },
+                status: state.status,
+                projection: createHistoryProjectionResult(waitForProjection, null, state),
+            };
+        }
+        finally {
+            releaseProjectSync();
+        }
+    };
     let renderSelectionChange = () => harness.render();
+    let applySceneRenamePresentation = (_input) => false;
+    let applyHistoryPresentation = (_impact) => false;
+    let applyInspectorPresentation = (_input) => false;
+    let applyRenderingPresentation = () => false;
     const busyOperationExecutors = new WeakMap();
     let agentLifecycleController;
     const pluginInspector = createLocalEditorHarnessPluginInspectorOptions(options.pluginHost, options.inspector);
-    const builtInSceneHierarchyProvider = createLocalEditorHarnessHierarchyScopeProvider(state, options, () => harness.render(), createLocalEditorSceneHierarchyScopeAdapter(state, options), busyOperationExecutors, () => renderSelectionChange());
+    const builtInSceneHierarchyProvider = createLocalEditorHarnessHierarchyScopeProvider(state, options, () => harness.render(), createLocalEditorSceneHierarchyScopeAdapter(state, options, input => applySceneRenamePresentation(input)), busyOperationExecutors, () => renderSelectionChange());
     const builtInPrefabStageHierarchyProvider = createLocalEditorHarnessHierarchyScopeProvider(state, options, () => harness.render(), createLocalEditorPrefabHierarchyScopeAdapter(state, options), busyOperationExecutors, () => renderSelectionChange());
     const hierarchySurface = options.pluginHost
         ? resolveHierarchySurfaceContribution(options.pluginHost.contributions)
@@ -551,6 +1043,8 @@ function createLocalEditorHarnessImplementation(options, construction) {
         theme: options.theme,
         localTestActions: options.localTestActions,
         gameModeEntryVisible: options.gameModeEntryVisible,
+        commandService: projectCommandService,
+        commandClientId: browserCommandAttachmentId,
         input: {
             isShortcutReserved: (event) => state.sceneViewInput?.ownsKeyboardEvent(event) ?? false,
         },
@@ -686,8 +1180,10 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 })();
             },
             onCreateFromAsset: (assetId) => {
-                if (createAssetFromBrowserIntent(state, options, assetId))
-                    harness.render();
+                void state.runBrowserAuthoringMutation('object.createFromAsset', JSON.stringify({ assetId }), authoringState => createAssetFromBrowserIntent(authoringState, options, assetId)).then(changed => {
+                    if (changed)
+                        harness.render();
+                }).catch(error => reportBrowserAuthoringFailure(state, harness.render, error));
             },
             onSelectAsset: (assetId) => {
                 if (selectBrowserAsset(state, assetId))
@@ -715,7 +1211,7 @@ function createLocalEditorHarnessImplementation(options, construction) {
                                 return;
                         }
                         else if (choice === 'discard') {
-                            discardPrefabStageChanges();
+                            await discardPrefabStageChanges();
                         }
                         else {
                             return;
@@ -729,12 +1225,18 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 void runExclusive(state, harness.render, executor => (runPrefabContextAction(actionId, executor)), busyOperationExecutors);
             },
             onMarkerTypeAction: (input) => {
-                if (patchMarkerTypeCatalog(state, options, input))
-                    harness.render();
+                void state.runBrowserAuthoringMutation('marker.type.apply', JSON.stringify(input), authoringState => patchMarkerTypeCatalog(authoringState, options, input)).then(changed => {
+                    if (changed)
+                        harness.render();
+                }).catch(error => reportBrowserAuthoringFailure(state, harness.render, error));
             },
             onMarkerRelationAction: (input) => {
-                if (patchMarkerRelation(state, options, input))
-                    harness.render();
+                void state.runBrowserAuthoringMutation('marker.relation.apply', JSON.stringify(input), authoringState => {
+                    const changed = patchMarkerRelation(authoringState, options, input);
+                    if (changed)
+                        harness.render();
+                    return changed;
+                }).catch(error => reportBrowserAuthoringFailure(state, harness.render, error));
             },
             onAssetBrowserRefresh: () => runExclusive(state, harness.render, async () => {
                 await harness.reloadAssets();
@@ -742,9 +1244,6 @@ function createLocalEditorHarnessImplementation(options, construction) {
             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,
@@ -756,10 +1255,46 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 harness.render();
             },
             onPropertyInput: (input) => {
-                const previousStatus = state.status;
-                const patched = patchSerializedProperty(state, options, input);
-                if (patched || state.status !== previousStatus)
-                    harness.render();
+                const refreshInspector = input.refreshInspector
+                    ?? !(input.source === 'custom' && input.commitMode === 'live');
+                const normalizedInput = refreshInspector === input.refreshInspector
+                    ? input
+                    : { ...input, refreshInspector };
+                const lifecycleSnapshot = lifecycleController?.lifecycle.getSnapshot();
+                state.suppressDocumentMarkDirtyInspectorRefresh = !refreshInspector
+                    && normalizedInput.persistence === 'document'
+                    && lifecycleSnapshot?.mode === 'edit'
+                    && lifecycleSnapshot.document !== 'dirty';
+                void state.runBrowserAuthoringMutation('inspector.property.set', JSON.stringify(normalizedInput), authoringState => {
+                    const previousStatus = authoringState.status;
+                    const patched = patchSerializedProperty(authoringState, options, normalizedInput);
+                    return {
+                        patched,
+                        statusChanged: authoringState.status !== previousStatus,
+                    };
+                })
+                    .then(({ patched, statusChanged }) => {
+                    const presentationApplied = patched
+                        ? applyInspectorPresentation(normalizedInput)
+                        : false;
+                    if (!refreshInspector) {
+                        if (!presentationApplied && (patched || statusChanged)) {
+                            ui.updatePreview?.({
+                                status: state.status,
+                                statusTone: state.statusToneStatus === state.status ? state.statusTone : 'default',
+                                statusDetails: state.statusToneStatus === state.status ? state.statusDetails : '',
+                                session: createUiSessionState(state),
+                            });
+                        }
+                        return;
+                    }
+                    if ((patched || statusChanged) && !presentationApplied)
+                        harness.render();
+                })
+                    .catch(error => reportBrowserAuthoringFailure(state, harness.render, error))
+                    .finally(() => {
+                    state.suppressDocumentMarkDirtyInspectorRefresh = false;
+                });
             },
             onInspectorAction: (input) => {
                 void runExclusive(state, harness.render, async () => {
@@ -769,20 +1304,31 @@ function createLocalEditorHarnessImplementation(options, construction) {
             },
             onRenderingPropertyChange: options.documentAdapter.onRenderingPropertyChange
                 ? (input) => {
-                    void applyRenderingPropertyChange(state, options, input)
+                    void state.runBrowserAuthoringMutation('rendering.property.set', JSON.stringify(input), authoringState => applyRenderingPropertyChange(authoringState, options, input))
                         .then((changed) => {
-                        if (changed)
+                        if (changed && !applyRenderingPresentation())
                             harness.render();
-                    });
+                    })
+                        .catch(error => reportBrowserAuthoringFailure(state, harness.render, error));
                 }
                 : undefined,
             onRenderingAction: options.documentAdapter.onRenderingAction
                 ? (input) => {
-                    return applyRenderingAction(state, options, input, harness.render)
-                        .then((changed) => {
-                        if (changed)
+                    return state.runBrowserAuthoringMutation(`rendering.${input.actionId ?? 'action'}`, JSON.stringify(input), authoringState => applyRenderingAction(authoringState, options, input, harness.render))
+                        .then((result) => {
+                        if (result.rendered && !applyRenderingPresentation())
                             harness.render();
-                        return changed;
+                        return result;
+                    })
+                        .catch(error => {
+                        reportBrowserAuthoringFailure(state, harness.render, error);
+                        return {
+                            ok: false,
+                            changed: false,
+                            rendered: false,
+                            status: error instanceof Error ? error.message : String(error),
+                            statusTone: 'error',
+                        };
                     });
                 }
                 : undefined,
@@ -870,8 +1416,10 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 });
             },
             onTransformAction: (action) => {
-                if (executeTransformAction(state, options, action))
-                    harness.render();
+                void state.runBrowserAuthoringMutation(`transform.${action}`, JSON.stringify({ action }), authoringState => executeTransformAction(authoringState, options, action)).then(changed => {
+                    if (changed)
+                        harness.render();
+                }).catch(error => reportBrowserAuthoringFailure(state, harness.render, error));
             },
             onViewportViewPresetChange: (preset) => {
                 if (setViewportViewPreset(state, options, preset))
@@ -935,28 +1483,38 @@ function createLocalEditorHarnessImplementation(options, construction) {
         }
         publishLocalEditorSelectionPresentation(state, options, previewState => ui.updatePreview?.(previewState), 'hierarchy-selection-presentation');
     };
-    const discardPrefabStageChanges = () => {
+    const discardPrefabStageChanges = async (serializedAccess) => {
         const stage = state.prefabStage;
         if (!stage || !stage.transaction.snapshot().stageDirty)
             return false;
         cancelActiveOperation(state);
-        stage.transaction.discard();
+        stage.transaction.assertParentUnchanged();
         const draftState = stage.transaction.draftSession.getState({ cloneDocuments: false });
-        rebuildProjectionFromDocument(state, options, draftState.workingDocument, EMPTY_EDITOR_SELECTION);
+        if (state.authoringHost) {
+            await state.authoringHost.reset(draftState.persistedDocument, draftState.source, {
+                expectedDocumentRevision: draftState.documentRevision,
+                ...(serializedAccess ? { serializedAccess } : {}),
+            });
+        }
+        else {
+            await state.runBrowserAuthoringMutation('prefab.stage.discard', JSON.stringify({ documentRevision: draftState.documentRevision }), authoringState => authoringState.session?.reset(draftState.persistedDocument, draftState.source));
+        }
+        const resetState = stage.transaction.draftSession.getState({ cloneDocuments: false });
+        rebuildProjectionFromDocument(state, options, resetState.workingDocument, EMPTY_EDITOR_SELECTION);
         state.status = `Discarded changes to Prefab ${stage.descriptor.label}`;
         state.statusTone = 'default';
         state.statusToneStatus = state.status;
         state.statusDetails = '';
         return true;
     };
-    runPrefabContextAction = async (actionId, executor) => {
+    runPrefabContextAction = async (actionId, executor, serializedAccess) => {
         const stage = state.prefabStage;
         if (!stage)
             return false;
         if (actionId === PREFAB_STAGE_CONTEXT_ACTION_IDS.save) {
             if (!stage.transaction.snapshot().documentDirty)
                 return false;
-            return harness.saveScene(executor);
+            return harness.saveScene(executor, undefined, serializedAccess);
         }
         if (actionId === PREFAB_STAGE_CONTEXT_ACTION_IDS.discard) {
             if (!stage.transaction.snapshot().stageDirty)
@@ -968,7 +1526,7 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 confirmLabel: '废弃更改',
                 cancelLabel: '继续编辑',
             });
-            return confirmed ? discardPrefabStageChanges() : false;
+            return confirmed ? discardPrefabStageChanges(serializedAccess) : false;
         }
         if (actionId !== PREFAB_STAGE_CONTEXT_ACTION_IDS.exit)
             return false;
@@ -984,17 +1542,155 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 cancelLabel: '取消',
             });
             if (choice === 'save') {
-                if (!await harness.saveScene(executor))
+                if (!await harness.saveScene(executor, undefined, serializedAccess))
                     return false;
             }
             else if (choice === 'discard') {
-                discardPrefabStageChanges();
+                await discardPrefabStageChanges(serializedAccess);
             }
             else {
                 return false;
             }
         }
-        return exitPrefabStage(state, options, 'reject');
+        return exitPrefabStage(state, options, 'reject', serializedAccess);
+    };
+    applySceneRenamePresentation = ({ id, name }) => {
+        const sessionState = state.session?.getState({ cloneDocuments: false });
+        const document = sessionState?.workingDocument ?? null;
+        const authoritativeName = document
+            ? resolveAuthoritativeHierarchyLabels(state, options, document, [id])[id] ?? name
+            : name;
+        let applied = false;
+        try {
+            applied = ui.updatePresentationDelta?.({
+                hierarchyLabelIds: [id],
+                hierarchyLabels: { [id]: authoritativeName },
+                materialUsageOwnerNames: { [id]: authoritativeName },
+                inspector: ['summary'],
+                session: createUiSessionState(state),
+                status: state.status,
+                statusTone: state.statusTone,
+                statusDetails: state.statusDetails,
+            }) === true;
+        }
+        catch {
+            applied = false;
+        }
+        if (!applied)
+            state.hierarchyPresentationFallbackRevision += 1;
+        return applied;
+    };
+    applyHistoryPresentation = impact => {
+        if (!impact || impact.hierarchy === 'full')
+            return false;
+        const inspectorNeedsAssembly = impact.inspector === 'full'
+            || (Array.isArray(impact.inspector) && impact.inspector.includes('material'));
+        if (inspectorNeedsAssembly)
+            cancelInspectorPresentationPreview(state);
+        const sessionState = state.session?.getState({ cloneDocuments: false });
+        const document = sessionState?.workingDocument ?? null;
+        const labelIds = impact.hierarchy?.labelIds ?? [];
+        const labels = document
+            ? resolveAuthoritativeHierarchyLabels(state, options, document, labelIds)
+            : {};
+        const inspectorState = inspectorNeedsAssembly && document
+            ? createUiSelectionInspectorPreviewState(state, options)
+            : null;
+        const inspectorValuePatches = Array.isArray(impact.inspector)
+            && impact.inspector.includes('transform')
+            && document
+            ? createHistoryTransformInspectorPresentationPatches(state, document, sessionState?.selection)
+            : [];
+        const renderingPanel = impact.rendering && document
+            ? options.documentAdapter.getRenderingPanelState?.(document, {
+                scene: state.world?.scene ?? null,
+                projection: state.projection,
+                renderingAction: state.renderingAction,
+            }) ?? null
+            : undefined;
+        let applied = false;
+        try {
+            applied = ui.updatePresentationDelta?.({
+                hierarchyLabelIds: labelIds,
+                hierarchyLabels: labels,
+                materialUsageOwnerNames: labels,
+                inspector: impact.inspector,
+                ...(inspectorValuePatches.length > 0 ? { inspectorValuePatches } : {}),
+                ...(inspectorState ? {
+                    inspectorObject: inspectorState.inspectorObject,
+                    inspectorMultiObject: inspectorState.inspectorMultiObject,
+                    inspectorPresentationGeneration: state.inspectorPresentationGeneration,
+                } : {}),
+                rendering: impact.rendering,
+                ...(renderingPanel !== undefined ? { renderingPanel } : {}),
+                session: createUiSessionState(state),
+                status: state.status, statusTone: state.statusTone, statusDetails: state.statusDetails,
+            }) === true;
+        }
+        catch {
+            applied = false;
+        }
+        if (!applied && labelIds.length > 0)
+            state.hierarchyPresentationFallbackRevision += 1;
+        return applied;
+    };
+    applyInspectorPresentation = input => {
+        if (isSerializedNamePath(input.path) && typeof input.value === 'string') {
+            return applySceneRenamePresentation({ id: input.targetId, name: input.value });
+        }
+        const impact = resolveSerializedPresentationImpact(input.path);
+        if (!impact)
+            return false;
+        if (impact.inspector?.includes('material'))
+            cancelInspectorPresentationPreview(state);
+        const sessionState = state.session?.getState({ cloneDocuments: false });
+        const inspectorState = impact.inspector?.includes('material')
+            ? createUiSelectionInspectorPreviewState(state, options)
+            : null;
+        try {
+            return ui.updatePresentationDelta?.({
+                inspector: impact.inspector,
+                ...(impact.inspector?.includes('transform') ? {
+                    inspectorValuePatches: [{
+                            targetId: input.targetId,
+                            propertyPath: input.path,
+                            value: input.value,
+                            generation: state.inspectorPresentationGeneration,
+                        }],
+                } : {}),
+                ...(inspectorState ? {
+                    inspectorObject: inspectorState.inspectorObject,
+                    inspectorMultiObject: inspectorState.inspectorMultiObject,
+                    inspectorPresentationGeneration: state.inspectorPresentationGeneration,
+                } : {}),
+                session: createUiSessionState(state),
+                status: state.status, statusTone: state.statusTone, statusDetails: state.statusDetails,
+            }) === true;
+        }
+        catch {
+            return false;
+        }
+    };
+    applyRenderingPresentation = () => {
+        const sessionState = state.session?.getState({ cloneDocuments: false });
+        const document = sessionState?.workingDocument ?? null;
+        if (!document)
+            return false;
+        try {
+            return ui.updatePresentationDelta?.({
+                rendering: true,
+                renderingPanel: options.documentAdapter.getRenderingPanelState?.(document, {
+                    scene: state.world?.scene ?? null,
+                    projection: state.projection,
+                    renderingAction: state.renderingAction,
+                }) ?? null,
+                session: createUiSessionState(state),
+                status: state.status, statusTone: state.statusTone, statusDetails: state.statusDetails,
+            }) === true;
+        }
+        catch {
+            return false;
+        }
     };
     const unsubscribeToolManager = toolManager.subscribe(snapshot => {
         if (state.toolManagerRenderSuppression !== 0)
@@ -1019,11 +1715,12 @@ function createLocalEditorHarnessImplementation(options, construction) {
     });
     construction.setCleanup(() => {
         harnessDisposed = true;
+        stopProjectServiceWatch?.();
+        stopProjectServiceWatch = null;
+        void disposeBrowserCommandAttachment?.then(dispose => dispose?.());
+        disposeBrowserCommandAttachment = null;
         pendingScheduledLifecycleExit?.cancel();
         pendingScheduledLifecycleExit = null;
-        unregisterAgentBridgeLifecycleParticipant?.();
-        unregisterAgentBridgeLifecycleParticipant = null;
-        agentBridgeLifecycleTransports.clear();
         releaseApplicationAuthorityScopeResource?.();
         releaseApplicationAuthorityScopeResource = null;
         releaseMainSessionScopeResource?.();
@@ -1038,6 +1735,9 @@ function createLocalEditorHarnessImplementation(options, construction) {
         unbindPluginTools?.();
         for (const unregister of [...unregisterStandardTools].reverse())
             unregister();
+        state.authoringHost?.dispose();
+        state.authoringHost = null;
+        state.replaceProjectionSessionAuthority(null);
         disposeLocalEditorHarnessResources(state, ui, hierarchyKernel);
     });
     const startGameRuntime = async (reason) => {
@@ -1053,6 +1753,10 @@ function createLocalEditorHarnessImplementation(options, construction) {
             return;
         // The lifecycle-owned Session Scope clears these before runGame. Keep the
         // assignment idempotent for direct harness consumers without a coordinator.
+        state.authoringHost?.dispose();
+        await state.authoringHost?.drain();
+        state.authoringHost = null;
+        state.replaceProjectionSessionAuthority(null);
         state.session = null;
         state.source = null;
         state.status = reason === 'save' ? 'Saved scene; starting game' : 'Discarded editor changes; starting game';
@@ -1100,6 +1804,25 @@ function createLocalEditorHarnessImplementation(options, construction) {
         }, executor);
         return runResult.accepted ? runResult.value : false;
     };
+    const replaceAuthoringHost = async (session) => {
+        state.unregisterCommandCapabilities?.();
+        state.unregisterCommandCapabilities = null;
+        const previousHost = state.authoringHost;
+        previousHost?.dispose();
+        await previousHost?.drain();
+        if (projectCommandService) {
+            state.authoringHost = null;
+            state.replaceProjectionSessionAuthority(session);
+            return;
+        }
+        state.replaceProjectionSessionAuthority(null);
+        state.authoringHost = createEditorAuthoringHost({
+            serviceInstanceId: createLocalEditorAuthoringServiceInstanceId(),
+            session,
+            commandSystem: commandServiceCommandSystem,
+            disposeCommandSystem: false,
+        });
+    };
     const loadOptionalProjectFiles = async () => {
         if (!options.persistenceAdapter.loadProjectFiles) {
             return { projectFiles: state.projectFiles, warning: null };
@@ -1153,7 +1876,7 @@ function createLocalEditorHarnessImplementation(options, construction) {
             cloneDocument: options.documentAdapter.cloneDocument,
             compareDocuments: options.documentAdapter.compareDocuments,
             reduceDocument: options.documentAdapter.reduceDocument,
-            isDocumentStructureChange: options.documentAdapter.isHierarchyStructureChange,
+            isDocumentStructureChange: command => resolveLocalEditorDocumentStructureChange(options.documentAdapter.isHierarchyStructureChange, command),
             onChange: createSessionChangeObserver(() => mainSession, {
                 document: PLAYABLE_LOCAL_EDITOR_MAIN_DOCUMENT_SCOPE_ID,
                 session: PLAYABLE_LOCAL_EDITOR_MAIN_SESSION_SCOPE_ID,
@@ -1162,14 +1885,22 @@ function createLocalEditorHarnessImplementation(options, construction) {
         });
         state.session = mainSession;
         try {
+            await replaceAuthoringHost(mainSession);
             attachLifecycleOwnedSessionAuthority();
+            activateCommandAuthority();
         }
         catch (error) {
+            state.authoringHost?.dispose();
+            state.authoringHost = null;
+            state.replaceProjectionSessionAuthority(null);
             state.session = null;
             state.source = null;
             throw error;
         }
         state.summary = loadedSource?.summary ?? summarizeDocument(options, preparedDocument, source);
+        if (pendingProjectServiceSnapshot) {
+            await applyProjectServiceSnapshot(pendingProjectServiceSnapshot);
+        }
     };
     const enterEditorWorld = async () => {
         if (!state.session)
@@ -1220,13 +1951,33 @@ function createLocalEditorHarnessImplementation(options, construction) {
         if (prefabTransaction) {
             prefabTransaction.assertParentUnchanged();
             const parentState = prefabTransaction.parentSession.getState({ cloneDocuments: false });
-            prefabTransaction.parentSession.reset(parentState.persistedDocument, parentState.source);
-            prefabTransaction.draftSession.reset(parentState.persistedDocument, parentState.source);
+            if (state.authoringHost) {
+                await state.authoringHost.resetWithRelatedSession(parentState.persistedDocument, parentState.source, {
+                    expectedDocumentRevision: sessionState.documentRevision,
+                    relatedSession: prefabTransaction.parentSession,
+                    expectedRelatedDocumentRevision: parentState.documentRevision,
+                    mutateRelatedSession(parentDraftSession) {
+                        parentDraftSession.reset(parentState.persistedDocument, parentState.source);
+                    },
+                });
+            }
+            else {
+                await state.runBrowserAuthoringMutation('document.discard', JSON.stringify({ documentRevision: sessionState.documentRevision }), authoringState => authoringState.session?.reset(parentState.persistedDocument, parentState.source));
+                prefabTransaction.parentSession.reset(parentState.persistedDocument, parentState.source);
+            }
+            prefabTransaction.acceptParentRevision();
             state.source = parentState.source ?? null;
             state.summary = summarizeDocument(options, parentState.persistedDocument, state.source);
         }
         else {
-            state.session.reset(sessionState.persistedDocument, sessionState.source);
+            if (state.authoringHost) {
+                await state.authoringHost.reset(sessionState.persistedDocument, sessionState.source, {
+                    expectedDocumentRevision: sessionState.documentRevision,
+                });
+            }
+            else {
+                await state.runBrowserAuthoringMutation('document.discard', JSON.stringify({ documentRevision: sessionState.documentRevision }), authoringState => authoringState.session?.reset(sessionState.persistedDocument, sessionState.source));
+            }
             state.source = sessionState.source ?? null;
             state.summary = summarizeDocument(options, sessionState.persistedDocument, state.source);
         }
@@ -1235,21 +1986,76 @@ function createLocalEditorHarnessImplementation(options, construction) {
         state.statusToneStatus = state.status;
         state.statusDetails = '';
     };
-    const markDocumentCommitted = async (expectedDocumentFingerprint) => {
+    const markDocumentCommitted = async (expectedDocumentFingerprint, expectedDocumentRevision, preparedAuthoringSource) => {
         const sessionState = state.session?.getState({ cloneDocuments: false });
         if (!state.session || !sessionState)
             throw new Error('Cannot commit an unloaded editor document.');
-        if (createLocalEditorDocumentFingerprint(sessionState.workingDocument) !== expectedDocumentFingerprint) {
+        const hasProjectServiceTransaction = Boolean(projectCommandService
+            && typeof preparedAuthoringSource?.serviceTransactionId === 'string'
+            && preparedAuthoringSource.serviceTransactionId.length > 0);
+        if (!hasProjectServiceTransaction
+            && createLocalEditorDocumentFingerprint(sessionState.workingDocument) !== expectedDocumentFingerprint) {
             throw new Error('Editor document changed after export; refusing to commit a stale snapshot.');
         }
+        const committedDocument = (preparedAuthoringSource?.document
+            ?? sessionState.workingDocument);
+        const committedSource = preparedAuthoringSource?.source ?? sessionState.source;
         const prefabTransaction = state.prefabStage?.transaction ?? null;
+        if (projectCommandService) {
+            const transactionId = typeof preparedAuthoringSource?.serviceTransactionId === 'string'
+                ? preparedAuthoringSource.serviceTransactionId
+                : null;
+            if (!transactionId) {
+                throw new Error('Platform save confirmation is missing the Project Editor Service transaction.');
+            }
+            const serviceDocumentRevision = preparedAuthoringSource?.serviceDocumentRevision;
+            if (!Number.isSafeInteger(serviceDocumentRevision) || (serviceDocumentRevision ?? -1) < 0) {
+                throw new Error('Platform save confirmation is missing the Project Editor Service document revision.');
+            }
+            await invokeProjectServiceCommand('document.commit', { transactionId }, serviceDocumentRevision);
+            const snapshot = await readProjectServiceSnapshot();
+            if (!snapshot)
+                throw new Error('Project Editor Service did not return the committed checkpoint.');
+            await applyProjectServiceSnapshot(snapshot, true);
+            state.source = sessionState.source ?? null;
+            state.status = 'Platform save committed';
+            state.statusTone = 'success';
+            state.statusToneStatus = state.status;
+            state.statusDetails = '';
+            return;
+        }
         if (prefabTransaction) {
-            prefabTransaction.commitSavedDocument(sessionState.workingDocument, sessionState.source, `Apply Prefab ${state.prefabStage?.descriptor.label ?? 'changes'}`);
+            if (!state.authoringHost)
+                throw new Error('Cannot commit Prefab without an Editor Authoring Host.');
+            if (expectedDocumentRevision === null) {
+                throw new Error('Platform save confirmation is missing the exported document revision.');
+            }
+            await state.authoringHost.markSavedWithRelatedSession(committedDocument, {
+                expectedDocumentRevision,
+                source: committedSource,
+                resetHistory: true,
+                relatedSession: prefabTransaction.parentSession,
+                expectedRelatedDocumentRevision: prefabTransaction.parentSession
+                    .getState({ cloneDocuments: false }).documentRevision,
+                mutateRelatedSession(parentDraftSession) {
+                    prefabTransaction.stageParentSavedDocument(parentDraftSession, committedDocument, committedSource, `Apply Prefab ${state.prefabStage?.descriptor.label ?? 'changes'}`);
+                },
+            });
+            prefabTransaction.acceptParentRevision();
         }
         else {
-            state.session.markSaved(sessionState.workingDocument, sessionState.source);
+            if (!state.authoringHost)
+                throw new Error('Cannot commit without an Editor Authoring Host.');
+            if (expectedDocumentRevision === null) {
+                throw new Error('Platform save confirmation is missing the exported document revision.');
+            }
+            await state.authoringHost.markSaved(committedDocument, {
+                expectedDocumentRevision,
+                source: committedSource,
+            });
         }
-        state.source = sessionState.source ?? null;
+        state.source = committedSource ?? null;
+        state.summary = summarizeDocument(options, committedDocument, committedSource);
         state.status = 'Platform save committed';
         state.statusTone = 'success';
         state.statusToneStatus = state.status;
@@ -1330,10 +2136,36 @@ function createLocalEditorHarnessImplementation(options, construction) {
             throw error;
         }
     };
+    const renderSuppressedDocumentMarkDirtyPreview = () => {
+        const lifecycleSnapshot = lifecycleController?.lifecycle.getSnapshot();
+        const activeTransition = lifecycleSnapshot?.activeTransition;
+        if (state.suppressDocumentMarkDirtyInspectorRefresh
+            && activeTransition?.type === 'document.markDirty') {
+            suppressedDocumentMarkDirtyTransitionId = activeTransition.id;
+            if (!ui.updatePreview)
+                return false;
+            ui.updatePreview({ session: createUiSessionState(state) });
+            return true;
+        }
+        if (suppressedDocumentMarkDirtyTransitionId && lifecycleSnapshot && !lifecycleSnapshot.transitioning) {
+            suppressedDocumentMarkDirtyTransitionId = null;
+            state.suppressDocumentMarkDirtyInspectorRefresh = false;
+            if (!ui.updatePreview)
+                return false;
+            ui.updatePreview({ session: createUiSessionState(state) });
+            return true;
+        }
+        return false;
+    };
     harness = {
         render() {
             if (harnessDisposed)
                 return;
+            if (renderSuppressedDocumentMarkDirtyPreview())
+                return;
+            if (lifecyclePresentationOnlyRenderDepth > 0)
+                return;
+            cancelInspectorPresentationPreview(state);
             syncViewportCameraState(state);
             syncViewportMeasurementState(state);
             syncViewportSpatialOverlay(state, options);
@@ -1352,12 +2184,13 @@ function createLocalEditorHarnessImplementation(options, construction) {
         getHostServices() {
             return options.hostServices ?? null;
         },
-        getAgentBridge() {
-            return state.agentBridge;
+        getCommandService() {
+            return state.commandService;
         },
         getWorkingDocument() {
             return state.session?.getState().workingDocument ?? null;
         },
+        prepareProjectServiceDocumentExport,
         projectAssetDropPoint(point) {
             return projectBabylonViewportPointToGround({
                 babylon: state.babylon,
@@ -1429,7 +2262,7 @@ function createLocalEditorHarnessImplementation(options, construction) {
             }
             return runExclusiveResult(state, harness.render, transactionExecutor => executeLocalEditorDocumentOperation(busyOperationExecutors, transactionExecutor, operation), busyOperationExecutors);
         },
-        async reloadAssets() {
+        async reloadAssets(serializedAccess) {
             try {
                 const previousAssets = state.assets;
                 const [assets, projectFilesResult] = await Promise.all([
@@ -1440,7 +2273,8 @@ function createLocalEditorHarnessImplementation(options, construction) {
                     ? findLocalEditorUpdatedAssetIds(options.documentAdapter.listAssetSnapshots(previousAssets), options.documentAdapter.listAssetSnapshots(assets))
                     : [];
                 if (state.session && options.documentAdapter.hydrateDocumentAssets) {
-                    const result = applyLocalEditorUpdatedAssetsRefresh(state.session, {
+                    const expectedDocumentRevision = state.session.getState({ cloneDocuments: false }).documentRevision;
+                    const applyRefresh = (session = state.session) => applyLocalEditorUpdatedAssetsRefresh(session, {
                         assetIds: refreshedAssetIds,
                         assets,
                         hydrateDocumentAssets: options.documentAdapter.hydrateDocumentAssets,
@@ -1451,6 +2285,9 @@ function createLocalEditorHarnessImplementation(options, construction) {
                             ? { compareDocuments: options.documentAdapter.compareDocuments }
                             : {}),
                     });
+                    const result = serializedAccess
+                        ? state.authoringHost?.runSerializedExternalMutation(serializedAccess, expectedDocumentRevision, session => applyRefresh(session)) ?? (() => { throw new Error('Asset refresh authoring authority is unavailable.'); })()
+                        : await state.runBrowserAuthoringMutation('asset.library.refresh', JSON.stringify({ refreshedAssetIds }), authoringState => applyRefresh(authoringState.session));
                     syncLocalEditorUpdatedAssetProjection(state.updatedAssetProjection, result.changed, () => {
                         rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
                     });
@@ -1515,7 +2352,7 @@ function createLocalEditorHarnessImplementation(options, construction) {
                     loadOptionalProjectFiles(),
                 ]);
                 assertLocalEditorUpdatedAssetSnapshotFreshness(options.documentAdapter.resolveUpdatedAssetSnapshot(assets, { assetId: input.assetId }), input);
-                const result = applyLocalEditorUpdatedAssetRefresh(state.session, {
+                const applyRefresh = (authoringState) => applyLocalEditorUpdatedAssetRefresh(authoringState.session, {
                     assetId: input.assetId,
                     assets,
                     hydrateDocumentAssets: options.documentAdapter.hydrateDocumentAssets,
@@ -1526,6 +2363,7 @@ function createLocalEditorHarnessImplementation(options, construction) {
                         ? { compareDocuments: options.documentAdapter.compareDocuments }
                         : {}),
                 });
+                const result = await state.runBrowserAuthoringMutation('asset.library.refreshUpdated', JSON.stringify(input), applyRefresh);
                 state.assets = assets;
                 state.projectFiles = projectFilesResult.projectFiles;
                 state.projectFilesWarning = projectFilesResult.warning;
@@ -1579,19 +2417,33 @@ function createLocalEditorHarnessImplementation(options, construction) {
             }
         },
         createAssetFromAssetId(assetId, createOptions) {
-            const result = addAssetToDocument(state, options, assetId, createOptions);
+            const execute = (session = state.session ?? undefined) => addAssetToDocument(state, options, assetId, createOptions, session);
+            const immediate = state.tryRunBrowserAuthoringMutationImmediately('object.createFromAsset', JSON.stringify({ assetId, createOptions }), session => execute(session));
+            const result = immediate.ok ? immediate.value : {
+                ok: false,
+                assetId,
+                changed: false,
+                status: `Asset creation unavailable: ${immediate.reason}`,
+                error: 'authoring_busy',
+            };
             harness.render();
             return result;
         },
         async undo(historyOptions) {
-            const result = applyHistoryOperation(state, options, 'undo', historyOptions);
-            if (result.ok)
+            if (projectCommandService) {
+                return runProjectServiceHistoryOperation('undo', historyOptions);
+            }
+            const result = await state.runBrowserAuthoringMutation('history.undo', JSON.stringify(historyOptions ?? {}), authoringState => applyHistoryOperation(authoringState, options, 'undo', historyOptions));
+            if (result.ok && !applyHistoryPresentation(result.presentationImpact))
                 harness.render();
             return waitForHistoryOperationProjection(state, result);
         },
         async redo(historyOptions) {
-            const result = applyHistoryOperation(state, options, 'redo', historyOptions);
-            if (result.ok)
+            if (projectCommandService) {
+                return runProjectServiceHistoryOperation('redo', historyOptions);
+            }
+            const result = await state.runBrowserAuthoringMutation('history.redo', JSON.stringify(historyOptions ?? {}), authoringState => applyHistoryOperation(authoringState, options, 'redo', historyOptions));
+            if (result.ok && !applyHistoryPresentation(result.presentationImpact))
                 harness.render();
             return waitForHistoryOperationProjection(state, result);
         },
@@ -1599,13 +2451,13 @@ function createLocalEditorHarnessImplementation(options, construction) {
             await loadEditorDocument();
             await enterEditorWorld();
         },
-        async saveScene(executor, saveOptions) {
+        async saveScene(executor, saveOptions, serializedAccess) {
             cancelActiveOperation(state);
             const validationPhases = [...new Set([
                     ...(saveOptions?.validationPhases ?? []),
                     'save',
                 ])];
-            const refreshResult = await runValidatedExclusiveDocumentOperation('save', () => harness.reloadAssets(), executor, validationPhases);
+            const refreshResult = await runValidatedExclusiveDocumentOperation('save', () => harness.reloadAssets(serializedAccess), executor, validationPhases);
             if (!refreshResult.accepted)
                 return false;
             const assetRefresh = refreshResult.value;
@@ -1620,6 +2472,19 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 const prefabTransaction = state.prefabStage?.transaction ?? null;
                 try {
                     prefabTransaction?.assertParentUnchanged();
+                    if (projectCommandService) {
+                        await invokeProjectServiceCommand('document.save');
+                        const snapshot = await readProjectServiceSnapshot();
+                        if (!snapshot)
+                            throw new Error('Project Editor Service did not return the saved checkpoint.');
+                        await applyProjectServiceSnapshot(snapshot, true);
+                        state.summary = summarizeDocument(options, snapshot.document, state.source);
+                        state.status = prefabTransaction ? 'Prefab saved' : 'Scene saved';
+                        state.statusTone = 'success';
+                        state.statusToneStatus = state.status;
+                        state.statusDetails = '';
+                        return true;
+                    }
                     let savedSource = source;
                     let result;
                     if (source && options.authoringHost) {
@@ -1663,10 +2528,34 @@ function createLocalEditorHarnessImplementation(options, construction) {
                     state.source = savedSource ?? null;
                     if (state.session) {
                         if (prefabTransaction && state.prefabStage?.transaction === prefabTransaction) {
-                            prefabTransaction.commitSavedDocument(preparedDocument, savedSource ?? undefined, `Apply Prefab ${state.prefabStage.descriptor.label}`);
+                            if (!state.authoringHost)
+                                throw new Error('Cannot save Prefab without an Editor Authoring Host.');
+                            if (expectedAuthoredVersion === null)
+                                throw new Error('Cannot save without an expected document revision.');
+                            await state.authoringHost.markSavedWithRelatedSession(preparedDocument, {
+                                expectedDocumentRevision: expectedAuthoredVersion,
+                                source: savedSource ?? undefined,
+                                resetHistory: true,
+                                relatedSession: prefabTransaction.parentSession,
+                                expectedRelatedDocumentRevision: prefabTransaction.parentSession
+                                    .getState({ cloneDocuments: false }).documentRevision,
+                                mutateRelatedSession(parentDraftSession) {
+                                    prefabTransaction.stageParentSavedDocument(parentDraftSession, preparedDocument, savedSource ?? undefined, `Apply Prefab ${state.prefabStage?.descriptor.label ?? 'changes'}`);
+                                },
+                                ...(serializedAccess ? { serializedAccess } : {}),
+                            });
+                            prefabTransaction.acceptParentRevision();
                         }
                         else {
-                            state.session.markSaved(preparedDocument, savedSource ?? undefined);
+                            if (!state.authoringHost)
+                                throw new Error('Cannot save without an Editor Authoring Host.');
+                            if (expectedAuthoredVersion === null)
+                                throw new Error('Cannot save without an expected document revision.');
+                            await state.authoringHost.markSaved(preparedDocument, {
+                                expectedDocumentRevision: expectedAuthoredVersion,
+                                source: savedSource ?? undefined,
+                                ...(serializedAccess ? { serializedAccess } : {}),
+                            });
                         }
                     }
                     else {
@@ -1678,7 +2567,7 @@ function createLocalEditorHarnessImplementation(options, construction) {
                             cloneDocument: options.documentAdapter.cloneDocument,
                             compareDocuments: options.documentAdapter.compareDocuments,
                             reduceDocument: options.documentAdapter.reduceDocument,
-                            isDocumentStructureChange: options.documentAdapter.isHierarchyStructureChange,
+                            isDocumentStructureChange: command => resolveLocalEditorDocumentStructureChange(options.documentAdapter.isHierarchyStructureChange, command),
                             onChange: createSessionChangeObserver(() => mainSession, {
                                 document: PLAYABLE_LOCAL_EDITOR_MAIN_DOCUMENT_SCOPE_ID,
                                 session: PLAYABLE_LOCAL_EDITOR_MAIN_SESSION_SCOPE_ID,
@@ -1687,9 +2576,14 @@ function createLocalEditorHarnessImplementation(options, construction) {
                         });
                         state.session = mainSession;
                         try {
+                            await replaceAuthoringHost(mainSession);
                             attachLifecycleOwnedSessionAuthority();
+                            activateCommandAuthority();
                         }
                         catch (error) {
+                            state.authoringHost?.dispose();
+                            state.authoringHost = null;
+                            state.replaceProjectionSessionAuthority(null);
                             state.session = null;
                             state.source = null;
                             throw error;
@@ -1736,20 +2630,22 @@ function createLocalEditorHarnessImplementation(options, construction) {
     };
     agentLifecycleController = {
         enterEditor: () => harness.enterEditor(),
-        saveScene: (_operation, _context, executor) => harness.saveScene(executor),
+        saveScene: (_operation, context, executor) => harness.saveScene(executor, undefined, context
+            ?.serializedAuthoringAccess),
         saveAndRunGame: (_context, executor) => harness.saveAndRunGame(executor),
         async discardAndRunGame(_context, executor) {
             await harness.discardAndRunGame(executor);
             return true;
         },
-        async prepareSaveAndRunGame(_context, executor) {
+        async prepareSaveAndRunGame(context, executor) {
             return harness.runExclusiveDocumentOperation(async (transactionExecutor) => {
                 const initialValidation = await runValidatedExclusiveDocumentOperation('run', async () => true, transactionExecutor);
                 if (!initialValidation.accepted)
                     return { accepted: false };
                 const saved = await harness.saveScene(transactionExecutor, {
                     validationPhases: ['run', 'save'],
-                });
+                }, context
+                    ?.serializedAuthoringAccess);
                 if (!saved)
                     return { accepted: false };
                 const finalValidation = await runValidatedExclusiveDocumentOperation('run', async (documentRevision) => documentRevision, transactionExecutor);
@@ -1797,21 +2693,26 @@ function createLocalEditorHarnessImplementation(options, construction) {
             }, executor);
         },
     };
-    const agentBridgeCapabilitySourceOperations = {
-        createAssetFromAssetId: (assetId, createOptions) => harness.createAssetFromAssetId(assetId, createOptions),
-        getPrefabStage: () => summarizeAgentBridgePrefabStage(state, options),
-        getPrefabStageDetails: () => summarizeAgentBridgePrefabStageDetails(state, options),
-        openPrefabStage: input => runExclusiveResult(state, harness.render, async (executor) => {
-            const previousStage = summarizeAgentBridgePrefabStage(state, options);
+    const commandServiceCapabilitySourceOperations = {
+        createAssetFromAssetId: (assetId, createOptions) => {
+            const result = addAssetToDocument(state, options, assetId, createOptions);
+            harness.render();
+            return result;
+        },
+        getPrefabStage: () => summarizeEditorCommandPrefabStage(state, options),
+        getPrefabStageDetails: () => summarizeEditorCommandPrefabStageDetails(state, options),
+        openPrefabStage: (input, access) => runExclusiveResult(state, harness.render, async (executor) => {
+            const serializedAccess = access;
+            const previousStage = summarizeEditorCommandPrefabStage(state, options);
             if (previousStage
                 && previousStage.assetId !== input.assetId
                 && state.prefabStage?.transaction.snapshot().stageDirty) {
                 if (input.dirtyAction === 'save') {
-                    if (!await harness.saveScene(executor))
+                    if (!await harness.saveScene(executor, undefined, serializedAccess))
                         return null;
                 }
                 else if (input.dirtyAction === 'discard') {
-                    discardPrefabStageChanges();
+                    await discardPrefabStageChanges(serializedAccess);
                 }
                 else {
                     state.status = 'Prefab has unsaved changes';
@@ -1826,32 +2727,33 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 assetId: input.assetId,
                 browserAssetId: input.browserAssetId,
                 assetKind: 'prefab',
-            });
-            const stage = summarizeAgentBridgePrefabStage(state, options);
+            }, serializedAccess);
+            const stage = summarizeEditorCommandPrefabStage(state, options);
             if (!opened || !stage)
                 return null;
-            const alreadyOpen = isSameAgentBridgePrefabStage(previousStage, stage);
+            const alreadyOpen = isSameEditorCommandPrefabStage(previousStage, stage);
             return {
                 opened: !alreadyOpen,
                 alreadyOpen,
-                prefab: createAgentBridgePrefabSummaryFromStage(stage),
+                prefab: createEditorCommandPrefabSummaryFromStage(stage),
                 stage,
                 status: state.status,
             };
         }, busyOperationExecutors),
-        exitPrefabStage: (input = {}) => runExclusiveResult(state, harness.render, async (executor) => {
-            const previousStage = summarizeAgentBridgePrefabStage(state, options);
+        exitPrefabStage: (input = {}, access) => runExclusiveResult(state, harness.render, async (executor) => {
+            const serializedAccess = access;
+            const previousStage = summarizeEditorCommandPrefabStage(state, options);
             if (state.prefabStage?.transaction.snapshot().stageDirty) {
                 if (input.dirtyAction === 'save') {
-                    if (!await harness.saveScene(executor)) {
+                    if (!await harness.saveScene(executor, undefined, serializedAccess)) {
                         return { exited: false, wasOpen: true, previousStage, status: state.status };
                     }
                 }
                 else if (input.dirtyAction === 'discard') {
-                    discardPrefabStageChanges();
+                    await discardPrefabStageChanges(serializedAccess);
                 }
             }
-            const exited = await exitPrefabStage(state, options, 'reject');
+            const exited = await exitPrefabStage(state, options, 'reject', serializedAccess);
             return {
                 exited,
                 wasOpen: !!previousStage,
@@ -1859,8 +2761,8 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 status: exited ? state.status : previousStage ? state.status : 'No Prefab stage is open.',
             };
         }, busyOperationExecutors),
-        savePrefabStage: () => runExclusiveResult(state, harness.render, executor => (runPrefabContextAction(PREFAB_STAGE_CONTEXT_ACTION_IDS.save, executor)), busyOperationExecutors),
-        discardPrefabStage: () => discardPrefabStageChanges(),
+        savePrefabStage: access => runExclusiveResult(state, harness.render, executor => (runPrefabContextAction(PREFAB_STAGE_CONTEXT_ACTION_IDS.save, executor, access)), busyOperationExecutors),
+        discardPrefabStage: access => discardPrefabStageChanges(access),
         selectPrefabStageItem: itemId => selectPrefabStageItemWithPreviewSync(state, options, itemId),
         runPrefabStageAssetAction: input => patchBrowserAssetAction(state, options, input),
         getHierarchyReadModel,
@@ -1933,10 +2835,10 @@ function createLocalEditorHarnessImplementation(options, construction) {
                 })),
             };
         },
-        executeHierarchyOperation: async (input) => {
+        executeHierarchyOperation: async (input, serializedAccess) => {
             const model = getRequiredHierarchyViewModel();
             const { snapshot } = model;
-            const result = await hierarchyKernel.dispatch({
+            const invocation = {
                 type: 'operation.execute',
                 operationId: input.operationId,
                 expectedAuthorityToken: model.authorityToken,
@@ -1948,9 +2850,13 @@ function createLocalEditorHarnessImplementation(options, construction) {
                     contextNodeId: 'contextNodeId' in input ? input.contextNodeId ?? null : snapshot.activeId,
                     targetIds: input.targetIds ?? [...snapshot.selectedIds],
                     activeId: 'activeId' in input ? input.activeId ?? null : snapshot.activeId,
+                    ...(serializedAccess !== undefined
+                        ? { [SERIALIZED_HIERARCHY_INVOCATION]: serializedAccess }
+                        : {}),
                 },
                 ...(input.input ? { input: input.input } : {}),
-            });
+            };
+            const result = await hierarchyKernel.dispatch(invocation);
             return {
                 ok: result.ok,
                 changed: result.changed,
@@ -2012,10 +2918,10 @@ function createLocalEditorHarnessImplementation(options, construction) {
         },
         runRenderingAction: actionId => applyRenderingAction(state, options, { actionId }, () => harness.render()),
     };
-    const registerAgentBridgeCapabilities = () => {
-        if (state.unregisterAgentBridgeCapabilities)
+    const registerCommandCapabilities = () => {
+        if (state.unregisterCommandCapabilities)
             return;
-        const unregisterStandardAgentCapabilities = registerLocalEditorAgentBridgeCapabilities(state.agentBridge, createLocalEditorAgentBridgeCapabilitySources(state, options, () => harness.render(), context => runExclusive(state, harness.render, () => agentLifecycleController.enterEditor(context), busyOperationExecutors), async (context) => {
+        const unregisterStandardAgentCapabilities = registerLocalEditorCommandCapabilities(state.commandService, createLocalEditorCommandCapabilitySources(state, options, () => harness.render(), context => runExclusive(state, harness.render, () => agentLifecycleController.enterEditor(context), busyOperationExecutors), async (context) => {
             const prepared = await runExclusiveResult(state, harness.render, executor => agentLifecycleController.prepareSaveAndRunGame(context, executor), busyOperationExecutors);
             if (prepared.accepted)
                 scheduleEditorLifecycleExit(executor => prepared.run(executor));
@@ -2025,10 +2931,12 @@ function createLocalEditorHarnessImplementation(options, construction) {
             if (prepared.accepted)
                 scheduleEditorLifecycleExit(executor => prepared.run(executor));
             return prepared.accepted;
-        }, agentBridgeCapabilitySourceOperations));
+        }, commandServiceCapabilitySourceOperations), state.authoringHost ?? undefined);
         try {
-            const unregisterPluginAgentCapabilities = registerEditorPluginAgentCapabilities(state.agentBridge, options.pluginHost);
-            state.unregisterAgentBridgeCapabilities = () => {
+            const unregisterPluginAgentCapabilities = state.authoringHost
+                ? registerEditorPluginCommands(state.commandService, options.pluginHost, state.authoringHost)
+                : () => undefined;
+            state.unregisterCommandCapabilities = () => {
                 const errors = [];
                 try {
                     unregisterPluginAgentCapabilities();
@@ -2043,44 +2951,50 @@ function createLocalEditorHarnessImplementation(options, construction) {
                     errors.push(error);
                 }
                 if (errors.length > 0) {
-                    const error = new Error('Local Editor Agent capability cleanup failed.');
+                    const error = new Error('Local Editor command cleanup failed.');
                     error.errors = errors;
                     throw error;
                 }
             };
+            if (projectCommandService && !disposeBrowserCommandAttachment) {
+                const handlers = Object.fromEntries(state.commandService.commandSystem.listManifests()
+                    .map(manifest => [manifest.id, async (input, request) => {
+                        if (harnessDisposed)
+                            throw new Error('Local editor harness has been disposed.');
+                        const result = await state.commandService.callCapability(manifest.id, input, {
+                            ...(request.invocation.traceId ? { traceId: request.invocation.traceId } : {}),
+                            ...(request.invocation.traceStepId ? { traceStepId: request.invocation.traceStepId } : {}),
+                        });
+                        if (!result.ok)
+                            throw new Error(result.diagnostics.map(diagnostic => diagnostic.message).join('; '));
+                        return result.output;
+                    }]));
+                disposeBrowserCommandAttachment = projectCommandService.attach({
+                    attachmentId: browserCommandAttachmentId,
+                    label: 'Local Editor Command Host',
+                    handlers,
+                }).catch(() => null);
+            }
         }
         catch (error) {
             try {
                 unregisterStandardAgentCapabilities();
             }
             catch (cleanupError) {
-                const combined = new Error('Plugin Agent capability registration failed and standard capability rollback reported errors.');
+                const combined = new Error('Plugin command registration failed and standard command rollback reported errors.');
                 combined.errors = [error, cleanupError];
                 throw combined;
             }
             throw error;
         }
     };
-    const activateAgentBridgeAuthority = () => {
-        registerAgentBridgeCapabilities();
-        if (state.agentBridgeTransport)
-            return;
-        state.agentBridgeTransport = createLocalEditorAgentBridgeWebSocketTransportFromQuery(state.agentBridge, {
-            metadata: options.agentBridge?.sessionMetadata,
-            onStatusChange: agentBridgeStatus => {
-                state.agentBridgeStatus = agentBridgeStatus;
-                harness.render();
-            },
-        });
+    const activateCommandAuthority = () => {
+        registerCommandCapabilities();
     };
-    const disposeAgentBridgeAuthority = () => {
-        if (state.agentBridgeTransport) {
-            state.agentBridgeTransport.dispose();
-            state.agentBridgeTransport = null;
-        }
-        if (state.unregisterAgentBridgeCapabilities) {
-            state.unregisterAgentBridgeCapabilities();
-            state.unregisterAgentBridgeCapabilities = null;
+    const disposeCommandAuthority = () => {
+        if (state.unregisterCommandCapabilities) {
+            state.unregisterCommandCapabilities();
+            state.unregisterCommandCapabilities = null;
         }
     };
     const attachLifecycleOwnedApplicationAuthority = () => {
@@ -2088,46 +3002,14 @@ function createLocalEditorHarnessImplementation(options, construction) {
             return;
         if (!unsubscribeLifecycleRender)
             attachLifecycleRenderSubscription();
-        activateAgentBridgeAuthority();
-        attachAgentBridgeLifecycleParticipant();
+        activateCommandAuthority();
         if (!releaseApplicationAuthorityScopeResource) {
             releaseApplicationAuthorityScopeResource = lifecycleController.addScopeResource(PLAYABLE_LOCAL_EDITOR_APPLICATION_SCOPE_ID, () => {
-                disposeAgentBridgeAuthority();
+                disposeCommandAuthority();
                 releaseApplicationAuthorityScopeResource = null;
             });
         }
     };
-    const reportAgentBridgeLifecycleTransition = (event) => {
-        const transitionId = event.transition.id;
-        const transport = agentBridgeLifecycleTransports.get(transitionId)
-            ?? state.agentBridgeTransport;
-        transport?.reportLifecycleTransition(event);
-        if (event.status !== 'started')
-            agentBridgeLifecycleTransports.delete(transitionId);
-    };
-    const attachAgentBridgeLifecycleParticipant = () => {
-        unregisterAgentBridgeLifecycleParticipant?.();
-        unregisterAgentBridgeLifecycleParticipant = null;
-        if (!lifecycleController)
-            return;
-        unregisterAgentBridgeLifecycleParticipant = lifecycleController.registerParticipant({
-            id: 'fps.editor.agent-bridge.lifecycle-trace',
-            transitions: FPS_EDITOR_LIFECYCLE_TRANSITION_TYPES,
-            prepare(context) {
-                const transport = state.agentBridgeTransport;
-                if (transport)
-                    agentBridgeLifecycleTransports.set(context.transition.id, transport);
-                reportAgentBridgeLifecycleTransition({
-                    status: 'started',
-                    transition: context.transition,
-                    previous: context.before,
-                    current: context.getSnapshot(),
-                });
-            },
-            settled: reportAgentBridgeLifecycleTransition,
-            failed: reportAgentBridgeLifecycleTransition,
-        });
-    };
     const attachLifecycleRenderSubscription = () => {
         releaseLifecycleRenderScopeResource?.();
         releaseLifecycleRenderScopeResource = null;
@@ -2136,7 +3018,26 @@ function createLocalEditorHarnessImplementation(options, construction) {
         if (!lifecycleController)
             return;
         const lifecycle = lifecycleController.lifecycle;
-        const unsubscribe = lifecycle.subscribe(() => harness.render());
+        const unsubscribe = lifecycle.subscribe(() => {
+            let presentationApplied = false;
+            try {
+                presentationApplied = ui.updatePresentationDelta?.({
+                    pluginPanel: createLocalEditorPluginPanelState(options.pluginHost, state.lifecycle),
+                }) === true;
+            }
+            catch {
+                // The authoritative full render below preserves lifecycle presentation on adapter failure.
+            }
+            if (presentationApplied)
+                lifecyclePresentationOnlyRenderDepth += 1;
+            try {
+                harness.render();
+            }
+            finally {
+                if (presentationApplied)
+                    lifecyclePresentationOnlyRenderDepth -= 1;
+            }
+        });
         unsubscribeLifecycleRender = unsubscribe;
         releaseLifecycleRenderScopeResource = lifecycleController.addScopeResource(PLAYABLE_LOCAL_EDITOR_APPLICATION_SCOPE_ID, () => {
             unsubscribe();
@@ -2149,14 +3050,18 @@ function createLocalEditorHarnessImplementation(options, construction) {
         if (!lifecycleController || !state.session)
             return;
         if (!releaseMainSessionScopeResource) {
-            releaseMainSessionScopeResource = lifecycleController.addScopeResource(PLAYABLE_LOCAL_EDITOR_MAIN_SESSION_SCOPE_ID, () => {
+            releaseMainSessionScopeResource = lifecycleController.addScopeResource(PLAYABLE_LOCAL_EDITOR_MAIN_SESSION_SCOPE_ID, async () => {
+                state.authoringHost?.dispose();
+                await state.authoringHost?.drain();
+                state.authoringHost = null;
+                state.replaceProjectionSessionAuthority(null);
                 state.session = null;
                 state.source = null;
                 releaseMainSessionScopeResource = null;
             });
         }
     };
-    activateAgentBridgeAuthority();
+    activateCommandAuthority();
     registerLocalEditorHarnessLifecycleOperations(harness, {
         runGame: startGameRuntime,
         validateRun: async () => {
@@ -2197,9 +3102,45 @@ function createLocalEditorHarnessImplementation(options, construction) {
         state.statusDetails = stringifyLocalEditorError(error) ?? 'Unknown Tool activation error';
         harness.render();
     });
+    if (projectCommandService) {
+        void projectCommandService.watchAuthoring({
+            onSnapshot: snapshot => applyProjectServiceSnapshot(snapshot),
+            async onEvents(events) {
+                if (events.length === 0)
+                    return;
+                const snapshot = await readProjectServiceSnapshot();
+                if (snapshot)
+                    await applyProjectServiceSnapshot(snapshot);
+            },
+            onIdle: () => state.reconcilePendingProjectServiceSnapshot(),
+            onError(error) {
+                if (harnessDisposed)
+                    return;
+                reportBrowserAuthoringFailure(state, () => harness.render(), error);
+            },
+        }).then((stop) => {
+            if (harnessDisposed)
+                stop();
+            else
+                stopProjectServiceWatch = stop;
+        }).catch((error) => {
+            if (harnessDisposed)
+                return;
+            state.status = 'Project Editor Service connection failed';
+            state.statusTone = 'error';
+            state.statusToneStatus = state.status;
+            state.statusDetails = stringifyLocalEditorError(error) ?? 'Unknown Editor Service error';
+            harness.render();
+        });
+    }
     harness.render();
     return harness;
 }
+let localEditorAuthoringServiceSequence = 0;
+function createLocalEditorAuthoringServiceInstanceId() {
+    localEditorAuthoringServiceSequence += 1;
+    return `local-editor-${Date.now().toString(36)}-${localEditorAuthoringServiceSequence.toString(36)}`;
+}
 function createLocalEditorDocumentFingerprint(document) {
     if (document == null)
         return null;
@@ -2221,11 +3162,13 @@ function disposeLocalEditorHarnessResources(state, ui, hierarchyKernel) {
             errors.push(error);
         }
     };
-    dispose(() => state.agentBridgeTransport?.dispose(), () => { state.agentBridgeTransport = null; });
-    dispose(() => state.unregisterAgentBridgeCapabilities?.(), () => {
-        state.unregisterAgentBridgeCapabilities = null;
+    dispose(() => state.unregisterCommandCapabilities?.(), () => {
+        state.unregisterCommandCapabilities = null;
+    });
+    dispose(() => disposeEditorWorld(state), () => {
+        state.replaceProjectionSessionAuthority(null);
+        state.session = null;
     });
-    dispose(() => disposeEditorWorld(state), () => { state.session = null; });
     dispose(() => ui.dispose());
     dispose(() => hierarchyKernel.setProviders([]));
     if (errors.length > 0) {
@@ -2274,7 +3217,7 @@ export function mergeLocalEditorHarnessInspectorComponentSections(input) {
         }),
     };
 }
-function isAgentBridgeObjectSelectable(options, document, objectId, hierarchyItems) {
+function isEditorCommandObjectSelectable(options, document, objectId, hierarchyItems) {
     const inHierarchy = hierarchyItems.some(item => item.id === objectId);
     const hasProjectionNode = !!options.documentAdapter.getProjectionNode(document, objectId);
     if (!inHierarchy && !hasProjectionNode)
@@ -2678,10 +3621,31 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
         },
         onProjectionReady(event) {
             getLocalEditorEditingContext(state).handleProjectionReady(event.nodeId);
+            if (isProjectionInspectorRefreshSuppressed(state, event.nodeId, event.batchId)) {
+                renderPreviewUi({
+                    status: state.status,
+                    statusTone: state.statusToneStatus === state.status ? state.statusTone : 'default',
+                    statusDetails: state.statusToneStatus === state.status ? state.statusDetails : '',
+                    session: createUiSessionState(state),
+                });
+                return;
+            }
             renderUi();
         },
         onProjectionBatchSettled(event) {
             getLocalEditorEditingContext(state).handleProjectionBatchSettled(event.batchId);
+            const suppressInspectorRefresh = state.suppressedProjectionInspectorRefreshBatchIds.has(event.batchId)
+                || (event.nodeIds ?? []).some(nodeId => state.suppressedProjectionInspectorRefreshNodeBatches.has(nodeId));
+            releaseProjectionInspectorRefreshSuppression(state, event.batchId);
+            if (suppressInspectorRefresh) {
+                renderPreviewUi({
+                    status: state.status,
+                    statusTone: state.statusToneStatus === state.status ? state.statusTone : 'default',
+                    statusDetails: state.statusToneStatus === state.status ? state.statusDetails : '',
+                    session: createUiSessionState(state),
+                });
+                return;
+            }
             renderUi();
         },
     });
@@ -2710,27 +3674,41 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
             state.statusTone = policyStatus ? 'warning' : 'default';
             state.statusToneStatus = state.status;
             state.statusDetails = '';
-            render();
+            renderPreviewUi({
+                status: state.status,
+                statusTone: state.statusTone,
+                statusDetails: state.statusDetails,
+                transformTool: {
+                    activeTool: event.tool,
+                    activeSpace: event.space,
+                    activeConstraint: event.constraint,
+                    dragPhase: 'dragging',
+                    draggingNodeId: event.nodeId ?? event.activeId ?? null,
+                },
+            });
+            requestEditorSceneFrame(state, 'gizmo-drag-start');
         },
         onDragUpdate(event) {
             updateActiveTransformPreview(state, event);
-            syncMarkerOverlayToSceneArtifacts(state, options, state.session?.getState().selection ?? { selectedIds: [], activeId: null });
+            syncMarkerOverlayToSceneArtifacts(state, options, state.session?.getSelection() ?? { selectedIds: [], activeId: null });
             state.gizmo?.refreshSelection();
-            preview('gizmo-drag-update');
+            scheduleInspectorPresentationPreview(state, options, renderPreviewUi, 'gizmo-drag-update');
+            requestEditorSceneFrame(state, 'gizmo-drag-update');
         },
         onDragEnd(event) {
             sceneViewInteraction.endGizmoDrag();
             clearActiveTransformPreview(state);
-            const changed = getLocalEditorEditingContext(state).commitTransform(event);
-            if (!changed)
-                requestEditorSceneFrame(state, 'gizmo-drag-end');
-            renderUi();
+            void state.runBrowserAuthoringMutation('transform.gizmo.commit', JSON.stringify(event), authoringState => getLocalEditorEditingContext(authoringState).commitTransform(event)).then(changed => {
+                if (!changed)
+                    requestEditorSceneFrame(state, 'gizmo-drag-end');
+                renderUi();
+            }).catch(error => reportBrowserAuthoringFailure(state, renderUi, error));
         },
         onDragCancel(event) {
             sceneViewInteraction.endGizmoDrag();
             clearActiveTransformPreview(state);
-            if (event.duplicate && cancelDuplicateDrag(state, options)) {
-                render();
+            if (event.duplicate) {
+                void state.runBrowserAuthoringMutation('transform.duplicate.cancel', JSON.stringify(event), authoringState => cancelDuplicateDrag(authoringState, options)).then(() => render()).catch(error => reportBrowserAuthoringFailure(state, render, error));
                 return;
             }
             state.status = event.targetIds.length > 1
@@ -2741,8 +3719,9 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
         onDragBlocked(event) {
             sceneViewInteraction.endGizmoDrag();
             clearActiveTransformPreview(state);
-            if (event.duplicate)
-                cancelDuplicateDrag(state, options);
+            if (event.duplicate) {
+                void state.runBrowserAuthoringMutation('transform.duplicate.cancel', JSON.stringify(event), authoringState => cancelDuplicateDrag(authoringState, options)).catch(error => reportBrowserAuthoringFailure(state, renderUi, error));
+            }
             requestEditorSceneFrame(state, 'gizmo-drag-blocked');
             state.status = formatBlockedGizmoTransformStatus(event);
             state.statusTone = 'warning';
@@ -2750,10 +3729,17 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
             renderUi();
         },
         onDuplicateDragStart(input) {
-            const result = getLocalEditorEditingContext(state).beginDuplicateDrag(input);
-            if (!result)
+            const result = state.tryRunBrowserAuthoringMutationImmediately('transform.duplicate.begin', JSON.stringify(input), session => getLocalEditorEditingContext(state).beginDuplicateDrag(input, session));
+            if (!result.ok) {
+                state.status = `Duplicate drag unavailable: ${result.reason}`;
+                state.statusTone = 'warning';
+                state.statusToneStatus = state.status;
                 renderUi();
-            return result;
+                return null;
+            }
+            if (!result.value)
+                renderUi();
+            return result.value;
         },
     });
     state.gizmo = gizmo;
@@ -2865,8 +3851,10 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
                 return;
             }
             if (event.state.intent === 'placement') {
-                if (commitArmedPlacement(state, options, event.originalEvent))
-                    render();
+                void state.runBrowserAuthoringMutation('asset.place', JSON.stringify({ x: event.originalEvent.clientX, y: event.originalEvent.clientY }), authoringState => commitArmedPlacement(authoringState, options, event.originalEvent)).then(changed => {
+                    if (changed)
+                        render();
+                }).catch(error => reportBrowserAuthoringFailure(state, render, error));
                 return;
             }
             if (event.state.intent === 'view-plane-move') {
@@ -3002,7 +3990,7 @@ function disposeEditorWorld(state) {
     });
     run(() => clearPrefabStageForEditorTeardown(state));
     run(() => cancelScheduledSelectionInspectorRefresh(state));
-    state.activeTransformPreview = null;
+    clearActiveTransformPreview(state);
     disposeField(() => state.sceneViewInteraction, () => { state.sceneViewInteraction = null; });
     if (state.resizeHandler) {
         run(() => {
@@ -3202,7 +4190,7 @@ function requestEditorPreviewFrame(state, options, renderPreviewUi, reason) {
 function updateActiveTransformPreview(state, event) {
     const activeId = event.activeId ?? event.nodeId ?? event.targetIds[0] ?? null;
     if (!activeId) {
-        state.activeTransformPreview = null;
+        clearActiveTransformPreview(state);
         return;
     }
     state.activeTransformPreview = {
@@ -3215,6 +4203,74 @@ function updateActiveTransformPreview(state, event) {
 }
 function clearActiveTransformPreview(state) {
     state.activeTransformPreview = null;
+    cancelInspectorPresentationPreview(state);
+}
+function cancelInspectorPresentationPreview(state) {
+    state.inspectorPresentationGeneration += 1;
+    state.inspectorPresentationPatches = null;
+    if (state.inspectorPresentationFrame !== null) {
+        globalThis.cancelAnimationFrame?.(state.inspectorPresentationFrame);
+        state.inspectorPresentationFrame = null;
+    }
+}
+function scheduleInspectorPresentationPreview(state, options, renderPreviewUi, _reason) {
+    const preview = state.activeTransformPreview;
+    const transform = preview?.activeId ? preview.transforms[preview.activeId] : null;
+    if (!preview?.activeId || !transform || !isEditorTransformTrsSnapshot(transform))
+        return;
+    const generation = state.inspectorPresentationGeneration;
+    const targetId = preview.activeId;
+    state.inspectorPresentationPatches = createTransformInspectorPresentationPatches(targetId, transform, generation);
+    if (state.inspectorPresentationFrame !== null)
+        return;
+    const publish = () => {
+        if (generation !== state.inspectorPresentationGeneration)
+            return;
+        state.inspectorPresentationFrame = null;
+        const patches = state.inspectorPresentationPatches;
+        state.inspectorPresentationPatches = null;
+        if (!patches?.length || !state.world)
+            return;
+        renderPreviewUi({ inspectorPresentationPatches: patches });
+    };
+    if (typeof globalThis.requestAnimationFrame === 'function') {
+        state.inspectorPresentationFrame = globalThis.requestAnimationFrame(publish);
+    }
+    else {
+        publish();
+    }
+}
+function createTransformInspectorPresentationPatches(targetId, transform, generation) {
+    const patches = [];
+    for (const group of ['position', 'rotation', 'scale']) {
+        for (const axis of ['x', 'y', 'z']) {
+            const rawValue = transform[group][axis];
+            patches.push({
+                targetId,
+                propertyPath: `transform.${group}.${axis}`,
+                value: group === 'rotation' ? radiansToInspectorDegrees(rawValue) : rawValue,
+                generation,
+            });
+        }
+    }
+    return patches;
+}
+function createHistoryTransformInspectorPresentationPatches(state, document, selection) {
+    const activeId = selection?.activeId ?? null;
+    if (!activeId || !selection?.selectedIds.includes(activeId))
+        return [];
+    const transform = state.projection?.readNodeTransform(activeId) ?? null;
+    if (!transform)
+        return [];
+    const preview = {
+        targetIds: [...selection.selectedIds],
+        activeId,
+        transforms: { [activeId]: cloneEditorTransformSnapshot(transform) },
+    };
+    const resolved = getLocalEditorEditingContext(state).resolveInspectorPreviewTransform(document, activeId, transform, preview);
+    return resolved && isEditorTransformTrsSnapshot(resolved)
+        ? createTransformInspectorPresentationPatches(activeId, resolved, state.inspectorPresentationGeneration)
+        : [];
 }
 function scheduleProjectionShadowPreviewRebuild(state, reason) {
     if (state.projectionShadowPreviewRebuildFrame !== null) {
@@ -3283,8 +4339,9 @@ async function runExclusiveLocalEditorDocumentOperation(state, render, operation
         render();
     }
 }
-async function runExclusiveResult(state, render, action, executorStates) {
-    const lease = acquireLocalEditorBusyOperationLease(state, render, executorStates);
+async function runExclusiveResult(state, render, action, executorStates, options = {}) {
+    const renderBoundary = options.renderBoundary !== false;
+    const lease = acquireLocalEditorBusyOperationLease(state, render, executorStates, { renderBoundary });
     let failed = false;
     try {
         return await action(lease.executor);
@@ -3296,22 +4353,25 @@ async function runExclusiveResult(state, render, action, executorStates) {
     finally {
         lease.release();
         state.busy = false;
-        try {
-            render();
-        }
-        catch (error) {
-            if (!failed)
-                throw error;
+        if (renderBoundary || failed) {
+            try {
+                render();
+            }
+            catch (error) {
+                if (!failed)
+                    throw error;
+            }
         }
     }
 }
-function acquireLocalEditorBusyOperationLease(state, render, executorStates) {
+function acquireLocalEditorBusyOperationLease(state, render, executorStates, options = {}) {
     if (state.busy)
         throw new Error('Local editor host is busy. Retry this operation.');
     state.busy = true;
     const lease = createLocalEditorBusyOperationLease(state, render, executorStates);
     try {
-        render();
+        if (options.renderBoundary !== false)
+            render();
         return lease;
     }
     catch (error) {
@@ -3544,7 +4604,7 @@ function consumeMarkerRelationPickSelectionCommand(state, options, command, rend
             renderUi();
         return true;
     }
-    const handled = patchMarkerRelation(state, options, {
+    const relationInput = {
         action: 'create',
         type: pick.type ?? '',
         fromKind: pick.from.kind,
@@ -3552,16 +4612,18 @@ function consumeMarkerRelationPickSelectionCommand(state, options, command, rend
         toKind: endpoint.kind,
         toId: endpoint.id,
         directed: pick.directed,
-    });
-    if (handled && state.markerRelationPick) {
-        state.markerRelationPick = {
-            ...state.markerRelationPick,
-            status: state.status,
-            statusTone: state.statusTone,
-        };
-    }
-    if (renderUi)
-        renderUi();
+    };
+    void state.runBrowserAuthoringMutation('marker.relation.pick.create', JSON.stringify(relationInput), authoringState => patchMarkerRelation(authoringState, options, relationInput)).then(handled => {
+        if (handled && state.markerRelationPick) {
+            state.markerRelationPick = {
+                ...state.markerRelationPick,
+                status: state.status,
+                statusTone: state.statusTone,
+            };
+        }
+        if (renderUi)
+            renderUi();
+    }).catch(error => reportBrowserAuthoringFailure(state, renderUi ?? (() => undefined), error));
     return true;
 }
 function readMarkerRelationPickTargetId(command) {
@@ -3617,13 +4679,14 @@ function renameSceneGraphNode(state, options, intent) {
         label: patch.label ?? `Rename ${intent.id}`,
         patch: patch.patch,
         targetId: intent.id,
-        ...withProjectionImpact(patch.projectionImpact),
+        ...withProjectionImpact(createMetadataProjectionImpact([intent.id])),
+        ...withPresentationImpact({ hierarchy: { labelIds: [intent.id] }, inspector: ['summary'] }),
     });
     if (!result.documentChanged) {
         state.status = `Rename unchanged: ${intent.id}`;
         return 'rejected';
     }
-    rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
+    applyRenameProjectionImpact(state, options, result.workingDocument, result.selection, [intent.id], 'scene-rename');
     state.summary = summarizeDocument(options, result.workingDocument, session.getSource());
     state.status = patch.label ?? `Renamed ${intent.id}`;
     return 'changed';
@@ -4139,7 +5202,7 @@ function sanitizeSelection(state, options, document, selection) {
     const hierarchy = graph
         ? createMarkerGraphHierarchyItems(documentHierarchy, graph, createMarkerGraphHierarchyVisibility(state))
         : documentHierarchy;
-    const selectedIds = selection.selectedIds.filter(id => isAgentBridgeObjectSelectable(options, document, id, hierarchy));
+    const selectedIds = selection.selectedIds.filter(id => isEditorCommandObjectSelectable(options, document, id, hierarchy));
     const activeId = selection.activeId && selectedIds.includes(selection.activeId)
         ? selection.activeId
         : selectedIds[selectedIds.length - 1] ?? null;
@@ -4792,7 +5855,9 @@ async function handleBrowserAssetAction(state, options, input) {
         return enterPrefabStage(state, options, input);
     }
     if (input.actionId === 'asset.add-to-scene') {
-        return input.assetId ? addAssetToDocument(state, options, input.assetId).ok : false;
+        return input.assetId
+            ? state.runBrowserAuthoringMutation('object.createFromAsset', JSON.stringify({ assetId: input.assetId, source: 'asset-browser-action' }), authoringState => addAssetToDocument(authoringState, options, input.assetId).ok)
+            : false;
     }
     if (input.actionId === 'asset.place') {
         if (!input.assetId)
@@ -4805,7 +5870,7 @@ async function handleBrowserAssetAction(state, options, input) {
         }
         return armAssetPlacement(state, options, input.assetId);
     }
-    const patched = patchBrowserAssetAction(state, options, input);
+    const patched = await state.runBrowserAuthoringMutation(input.actionId, JSON.stringify(input), authoringState => patchBrowserAssetAction(authoringState, options, input));
     if (patched)
         return true;
     state.status = `Asset action unavailable: ${input.actionId}`;
@@ -4817,11 +5882,11 @@ async function handleInspectorAction(state, options, input) {
     if (!input.actionId.startsWith('prefab.')) {
         const activeId = input.targetId ?? state.session?.getState().selection.activeId ?? null;
         const selectedIds = input.targetIds ?? (activeId ? [activeId] : []);
-        return patchBrowserAssetAction(state, options, {
+        return state.runBrowserAuthoringMutation(input.actionId, JSON.stringify([input, activeId, selectedIds]), authoringState => patchBrowserAssetAction(authoringState, options, {
             actionId: input.actionId,
             fieldPath: input.path,
             value: input.params,
-        }, { activeId, selectedIds });
+        }, { activeId, selectedIds }));
     }
     const assetId = readInspectorActionParamString(input, 'assetId');
     const browserAssetId = readInspectorActionParamString(input, 'browserAssetId')
@@ -4872,7 +5937,7 @@ function readInspectorActionParamString(input, key) {
     const value = input.params?.[key];
     return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
 }
-async function enterPrefabStage(state, options, input) {
+async function enterPrefabStage(state, options, input, serializedAccess) {
     if (state.mode !== 'editor')
         return false;
     const sessionState = state.session?.getState({ cloneDocuments: false });
@@ -4897,13 +5962,14 @@ async function enterPrefabStage(state, options, input) {
         return true;
     }
     if (previousPrefabStage) {
-        const exited = await exitPrefabStage(state, options, 'reject');
+        const exited = await exitPrefabStage(state, options, 'reject', serializedAccess);
         if (!exited)
             return true;
     }
     const parentSession = state.session;
     if (!parentSession)
         throw new Error('Prefab Stage requires an active parent Session.');
+    const expectedParentRevision = parentSession.getState({ cloneDocuments: false }).documentRevision;
     const prefabScopeRevision = ++state.nextPrefabScopeRevision;
     const documentScopeId = state.scopeOperations
         ? `editor:document:prefab:${prefabScopeRevision}`
@@ -4958,12 +6024,32 @@ async function enterPrefabStage(state, options, input) {
         selectedItemIds: ['prefab-root'],
         restoreSceneCameraPreviewEnabled: previousPrefabStage?.restoreSceneCameraPreviewEnabled ?? state.sceneCameraPreviewEnabled,
     };
-    const previousSceneContext = getLocalEditorEditingContextById(state, 'fps.editor.context.scene').getSnapshot();
+    const previousSceneContext = state.toolManager?.snapshot().context
+        ?? getLocalEditorEditingContextById(state, 'fps.editor.context.scene').getSnapshot();
+    let projectionAuthoritySwitched = false;
     try {
         await rebindLocalEditorToolContext(state, createLocalEditorPrefabEditingContextSnapshot(state, nextPrefabStage));
+        if (state.authoringHost) {
+            await state.authoringHost.switchSession(transaction.draftSession, {
+                expectedDocumentRevision: expectedParentRevision,
+                ...(serializedAccess ? { serializedAccess } : {}),
+            });
+        }
+        else {
+            state.replaceProjectionSessionAuthority(transaction.draftSession);
+            projectionAuthoritySwitched = true;
+        }
     }
     catch (error) {
         const rollbackErrors = [error];
+        if (projectionAuthoritySwitched) {
+            try {
+                state.replaceProjectionSessionAuthority(parentSession);
+            }
+            catch (authorityRollbackError) {
+                rollbackErrors.push(authorityRollbackError);
+            }
+        }
         try {
             await rebindLocalEditorToolContext(state, previousSceneContext);
         }
@@ -4997,7 +6083,7 @@ async function enterPrefabStage(state, options, input) {
     syncTransformOperationSettingsToSceneArtifacts(state, 'prefab-stage-enter-operation-settings');
     return true;
 }
-async function exitPrefabStage(state, options, dirtyAction = 'reject') {
+async function exitPrefabStage(state, options, dirtyAction = 'reject', serializedAccess) {
     if (!state.prefabStage)
         return false;
     const transactionSnapshot = state.prefabStage.transaction.snapshot();
@@ -5009,13 +6095,25 @@ async function exitPrefabStage(state, options, dirtyAction = 'reject') {
             state.statusDetails = 'Save or discard the Prefab changes before returning to the Scene.';
             return false;
         }
-        state.prefabStage.transaction.discard();
+        state.prefabStage.transaction.assertParentUnchanged();
+        const checkpoint = state.prefabStage.transaction.draftSession.getState({ cloneDocuments: false });
+        if (state.authoringHost) {
+            await state.authoringHost.reset(checkpoint.persistedDocument, checkpoint.source, {
+                expectedDocumentRevision: checkpoint.documentRevision,
+                ...(serializedAccess ? { serializedAccess } : {}),
+            });
+        }
+        else {
+            await state.runBrowserAuthoringMutation('prefab.stage.discard', JSON.stringify({ documentRevision: checkpoint.documentRevision }), authoringState => authoringState.session?.reset(checkpoint.persistedDocument, checkpoint.source));
+        }
     }
     const sessionState = state.session?.getState({ cloneDocuments: false });
     const label = sessionState?.workingDocument
         ? resolvePrefabStageDescriptorForDocument(state, options, sessionState.workingDocument)?.label ?? state.prefabStage.descriptor.label
         : state.prefabStage.descriptor.label;
     const prefabStage = state.prefabStage;
+    const expectedDraftRevision = prefabStage.transaction.draftSession
+        .getState({ cloneDocuments: false }).documentRevision;
     const restoreSceneCameraPreviewEnabled = prefabStage.restoreSceneCameraPreviewEnabled;
     const currentSceneContext = getLocalEditorEditingContextById(state, 'fps.editor.context.scene').getSnapshot();
     const parentDocumentRevision = prefabStage.transaction.parentSession
@@ -5024,17 +6122,48 @@ async function exitPrefabStage(state, options, dirtyAction = 'reject') {
         ...currentSceneContext,
         revision: parentDocumentRevision + state.editorStateRevision + 1,
     };
+    const prefabContext = state.toolManager?.snapshot().context
+        ?? createLocalEditorPrefabEditingContextSnapshot(state, prefabStage);
+    let projectionAuthoritySwitched = false;
     await closePrefabStageLifecycleScopes(state, prefabStage);
     try {
         await rebindLocalEditorToolContext(state, sceneContext);
+        if (state.authoringHost) {
+            await state.authoringHost.switchSession(prefabStage.transaction.parentSession, {
+                expectedDocumentRevision: expectedDraftRevision,
+                ...(serializedAccess ? { serializedAccess } : {}),
+            });
+        }
+        else {
+            state.replaceProjectionSessionAuthority(prefabStage.transaction.parentSession);
+            projectionAuthoritySwitched = true;
+        }
     }
     catch (error) {
+        const rollbackErrors = [error];
+        if (projectionAuthoritySwitched) {
+            try {
+                state.replaceProjectionSessionAuthority(prefabStage.transaction.draftSession);
+            }
+            catch (authorityRollbackError) {
+                rollbackErrors.push(authorityRollbackError);
+            }
+        }
         try {
             await openPrefabStageLifecycleScopes(state, prefabStage);
         }
         catch (rollbackError) {
+            rollbackErrors.push(rollbackError);
+        }
+        try {
+            await rebindLocalEditorToolContext(state, prefabContext);
+        }
+        catch (rollbackError) {
+            rollbackErrors.push(rollbackError);
+        }
+        if (rollbackErrors.length > 1) {
             const combined = new Error('Prefab Tool context exit and lifecycle scope rollback failed.');
-            combined.errors = [error, rollbackError];
+            combined.errors = rollbackErrors;
             throw combined;
         }
         throw error;
@@ -5042,6 +6171,13 @@ async function exitPrefabStage(state, options, dirtyAction = 'reject') {
     state.session = prefabStage.transaction.parentSession;
     state.prefabStage = null;
     state.editorStateRevision += 1;
+    let reconciliationError;
+    try {
+        await state.reconcilePendingProjectServiceSnapshot();
+    }
+    catch (error) {
+        reconciliationError = error;
+    }
     activateLocalEditorSceneViewContext(state, getLocalEditorEditingContext(state).getViewStateKey(), false);
     const parentSessionState = state.session.getState({ cloneDocuments: false });
     if (parentSessionState.workingDocument) {
@@ -5053,10 +6189,12 @@ async function exitPrefabStage(state, options, dirtyAction = 'reject') {
         syncSceneCameraPreview(state, options);
     else
         state.sceneCameraPreview?.setActive(false);
-    state.status = `Exited Prefab ${label}`;
-    state.statusTone = 'default';
+    state.status = reconciliationError ? 'Project Editor Service reconciliation failed' : `Exited Prefab ${label}`;
+    state.statusTone = reconciliationError ? 'error' : 'default';
     state.statusToneStatus = state.status;
-    state.statusDetails = '';
+    state.statusDetails = reconciliationError
+        ? stringifyLocalEditorError(reconciliationError) ?? 'Unknown project snapshot reconciliation error'
+        : '';
     return true;
 }
 async function rebindLocalEditorToolContext(state, nextContext = getLocalEditorEditingContext(state).getSnapshot()) {
@@ -5097,7 +6235,7 @@ async function openPrefabStageLifecycleScopes(state, stage) {
         parentId: stage.sessionScopeId,
     });
     state.scopeOperations.addScopeResource(stage.previewScopeId, () => {
-        state.activeTransformPreview = null;
+        clearActiveTransformPreview(state);
     });
 }
 function selectPrefabStageItem(state, itemId) {
@@ -5550,13 +6688,13 @@ function clearArmedPlacement(state) {
     state.armedPlacement = null;
     state.gizmo?.setPlacementMarker(null);
 }
-function addAssetToDocument(state, options, assetId, createOptions = {}) {
+function addAssetToDocument(state, options, assetId, createOptions = {}, sessionOverride) {
     if (state.mode !== 'editor') {
         state.status = 'Asset creation rejected: editor is not active';
         return { ok: false, assetId, changed: false, status: state.status, error: 'editor_not_active' };
     }
     cancelActiveOperation(state);
-    const session = state.session;
+    const session = sessionOverride ?? state.session;
     const beforeDocument = session?.getState().workingDocument;
     if (!session || !beforeDocument) {
         state.status = 'Asset creation rejected: document is not loaded';
@@ -5618,13 +6756,13 @@ function addAssetToDocument(state, options, assetId, createOptions = {}) {
         createdId: createdId ?? null,
     };
 }
-function patchSerializedProperty(state, options, input) {
+function patchSerializedProperty(state, options, input, onCommitted) {
     if (state.mode !== 'editor')
         return false;
     cancelActiveOperation(state);
-    return getLocalEditorEditingContext(state).patchInspectorProperty(input);
+    return getLocalEditorEditingContext(state).patchInspectorProperty(input, onCommitted);
 }
-function patchSceneSerializedProperty(state, options, input) {
+function patchSceneSerializedProperty(state, options, input, onCommitted) {
     if (!state.session)
         return false;
     const sessionState = state.session.getState({ cloneDocuments: false });
@@ -5656,6 +6794,7 @@ function patchSceneSerializedProperty(state, options, input) {
         if (!patch)
             return false;
         const changedIds = patch.changedIds ?? targetIds;
+        const serializedNamePatch = isSerializedNamePath(payload.path);
         const projectionMetadataPatch = isSerializedProjectionMetadataPath(payload.path);
         const projectionMetadataSyncIds = projectionMetadataPatch
             ? resolveSerializedProjectionMetadataSyncIds(options, document, payload.path, changedIds)
@@ -5667,15 +6806,18 @@ function patchSceneSerializedProperty(state, options, input) {
             label: patch.label ?? `Patch ${payload.path} on ${targetIds.length} objects`,
             patch: patch.patch,
             targetId: sessionState.selection.activeId ?? undefined,
-            ...withProjectionImpact(resolveProjectionImpact(patch, patch.reprojectIds?.length
-                ? createReprojectProjectionImpact(patch.reprojectIds)
-                : shouldReprojectInspectorEdit
-                    ? createReprojectProjectionImpact(changedIds)
-                    : isSerializedTransformPath(payload.path)
-                        ? createTransformProjectionImpact(targetIds)
-                        : projectionMetadataPatch
-                            ? createMetadataProjectionImpact(projectionMetadataSyncIds)
-                            : undefined)),
+            ...withProjectionImpact(serializedNamePatch
+                ? createMetadataProjectionImpact(changedIds)
+                : resolveProjectionImpact(patch, patch.reprojectIds?.length
+                    ? createReprojectProjectionImpact(patch.reprojectIds)
+                    : shouldReprojectInspectorEdit
+                        ? createReprojectProjectionImpact(changedIds)
+                        : isSerializedTransformPath(payload.path)
+                            ? createTransformProjectionImpact(targetIds)
+                            : projectionMetadataPatch
+                                ? createMetadataProjectionImpact(projectionMetadataSyncIds)
+                                : undefined)),
+            ...withPresentationImpact(resolveSerializedPresentationImpact(payload.path, changedIds)),
         }, largeProjectionMetadataPatch
             ? {
                 assumeDocumentChanged: true,
@@ -5687,15 +6829,27 @@ function patchSceneSerializedProperty(state, options, input) {
         if (!result.documentChanged)
             return false;
         const workingDocument = result.workingDocument;
+        state.status = patch.label ?? `Patch ${payload.path} on ${targetIds.length} objects`;
+        if (isSerializedTransformPath(payload.path))
+            onCommitted?.();
         const projectionSyncIds = projectionMetadataPatch
             ? resolveSerializedProjectionMetadataSyncIds(options, workingDocument, payload.path, changedIds)
             : isSerializedTransformPath(payload.path)
                 ? targetIds
                 : changedIds;
-        if (patch.reprojectIds?.length)
-            reprojectProjectionForChangedIds(state, options, workingDocument, patch.reprojectIds);
-        else if (shouldReprojectInspectorEdit)
-            reprojectProjectionForChangedIds(state, options, workingDocument, changedIds);
+        if (serializedNamePatch) {
+            applyRenameProjectionImpact(state, options, workingDocument, result.selection, changedIds, 'inspector-name');
+        }
+        else if (patch.reprojectIds?.length) {
+            reprojectProjectionForChangedIds(state, options, workingDocument, patch.reprojectIds, {
+                refreshInspector: input.refreshInspector !== false,
+            });
+        }
+        else if (shouldReprojectInspectorEdit) {
+            reprojectProjectionForChangedIds(state, options, workingDocument, changedIds, {
+                refreshInspector: input.refreshInspector !== false,
+            });
+        }
         else if (projectionMetadataPatch) {
             syncProjectionMetadataForChangedIds(state, options, workingDocument, projectionSyncIds, {
                 deferShadowPreviewRefresh: largeProjectionMetadataPatch,
@@ -5708,7 +6862,6 @@ function patchSceneSerializedProperty(state, options, input) {
             state.gizmo?.refreshSelection();
         }
         state.summary = summarizeDocument(options, workingDocument, state.session.getSource());
-        state.status = patch.label ?? `Patch ${payload.path} on ${targetIds.length} objects`;
         return true;
     }
     const patch = options.documentAdapter.createSerializedPropertyPatch({
@@ -5726,6 +6879,7 @@ function patchSceneSerializedProperty(state, options, input) {
     if (!patch)
         return false;
     const changedIds = patch.changedIds ?? [patch.changedId ?? payload.targetId];
+    const serializedNamePatch = isSerializedNamePath(payload.path);
     const projectionMetadataPatch = isSerializedProjectionMetadataPath(payload.path);
     const projectionMetadataSyncIds = projectionMetadataPatch
         ? resolveSerializedProjectionMetadataSyncIds(options, document, payload.path, changedIds)
@@ -5734,20 +6888,34 @@ function patchSceneSerializedProperty(state, options, input) {
         type: 'document.patch',
         label: patch.label ?? `Patch ${payload.path}`,
         patch: patch.patch,
-        ...withProjectionImpact(resolveProjectionImpact(patch, patch.reprojectIds?.length
-            ? createReprojectProjectionImpact(patch.reprojectIds)
-            : shouldReprojectInspectorEdit
-                ? createReprojectProjectionImpact(changedIds)
-                : isSerializedTransformPath(payload.path)
-                    ? createTransformProjectionImpact([patch.changedId ?? payload.targetId])
-                    : projectionMetadataPatch
-                        ? createMetadataProjectionImpact(projectionMetadataSyncIds)
-                        : undefined)),
+        ...withProjectionImpact(serializedNamePatch
+            ? createMetadataProjectionImpact(changedIds)
+            : resolveProjectionImpact(patch, patch.reprojectIds?.length
+                ? createReprojectProjectionImpact(patch.reprojectIds)
+                : shouldReprojectInspectorEdit
+                    ? createReprojectProjectionImpact(changedIds)
+                    : isSerializedTransformPath(payload.path)
+                        ? createTransformProjectionImpact([patch.changedId ?? payload.targetId])
+                        : projectionMetadataPatch
+                            ? createMetadataProjectionImpact(projectionMetadataSyncIds)
+                            : undefined)),
+        ...withPresentationImpact(resolveSerializedPresentationImpact(payload.path, changedIds)),
     });
-    if (patch.reprojectIds?.length)
-        reprojectProjectionForChangedIds(state, options, result.workingDocument, patch.reprojectIds);
+    state.status = patch.label ?? `Patched ${payload.path}`;
+    if (result.documentChanged && isSerializedTransformPath(payload.path))
+        onCommitted?.();
+    if (result.documentChanged && serializedNamePatch) {
+        applyRenameProjectionImpact(state, options, result.workingDocument, result.selection, changedIds, 'inspector-name');
+    }
+    else if (patch.reprojectIds?.length) {
+        reprojectProjectionForChangedIds(state, options, result.workingDocument, patch.reprojectIds, {
+            refreshInspector: input.refreshInspector !== false,
+        });
+    }
     else if (shouldReprojectInspectorEdit) {
-        reprojectProjectionForChangedIds(state, options, result.workingDocument, changedIds);
+        reprojectProjectionForChangedIds(state, options, result.workingDocument, changedIds, {
+            refreshInspector: input.refreshInspector !== false,
+        });
     }
     else if (projectionMetadataPatch) {
         const syncIds = resolveSerializedProjectionMetadataSyncIds(options, result.workingDocument, payload.path, changedIds);
@@ -5764,7 +6932,6 @@ function patchSceneSerializedProperty(state, options, input) {
         state.gizmo?.refreshSelection();
     }
     state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
-    state.status = patch.label ?? `Patched ${payload.path}`;
     return true;
 }
 function patchPrefabSerializedProperty(state, options, input) {
@@ -6469,6 +7636,7 @@ function applyRenderingDocumentPatch(state, options, document, patch, fallbackLa
         patch: patch.patch,
         targetId: patch.changedId,
         ...withProjectionImpact(projectionImpact),
+        ...withPresentationImpact({ rendering: true }),
     });
     if (!result.documentChanged) {
         return { changed: false, workingDocument: result.workingDocument, label };
@@ -6574,6 +7742,9 @@ function isSerializedTransformPath(path) {
         || path.startsWith('transform.rotation.')
         || path.startsWith('transform.scale.');
 }
+function isSerializedNamePath(path) {
+    return path === 'name';
+}
 function isSerializedProjectionMetadataPath(path) {
     return isSerializedShadowMetadataPath(path);
 }
@@ -6586,12 +7757,30 @@ function resolveSerializedProjectionMetadataSyncIds(options, document, path, cha
     }
     return uniqueProjectionIds(changedIds);
 }
-function beginDuplicateDrag(state, options, input) {
-    if (state.mode !== 'editor' || !state.session)
+function isSerializedMaterialPath(path) {
+    return path.startsWith('overrides.material')
+        || path.startsWith('material.')
+        || path.startsWith('scene.materialAssets.');
+}
+function resolveSerializedPresentationImpact(path, targetIds = []) {
+    if (isSerializedNamePath(path)) {
+        const labelIds = uniqueProjectionIds(targetIds);
+        return labelIds.length > 0
+            ? { hierarchy: { labelIds }, inspector: ['summary'] }
+            : undefined;
+    }
+    if (isSerializedTransformPath(path))
+        return { inspector: ['transform'] };
+    if (isSerializedMaterialPath(path))
+        return { inspector: ['material'] };
+    return undefined;
+}
+function beginDuplicateDrag(state, options, input, sessionOverride) {
+    if (state.mode !== 'editor' || !(sessionOverride ?? state.session))
         return null;
     if (state.duplicateDrag)
         return null;
-    const session = state.session;
+    const session = sessionOverride ?? state.session;
     const document = session.getState().workingDocument;
     const patch = options.documentAdapter.createDuplicateSelectionPatch?.({
         document,
@@ -6619,7 +7808,7 @@ function beginDuplicateDrag(state, options, input) {
     const selectedIds = (patch.selectedIds?.length ? patch.selectedIds : patch.createdIds)
         .filter(id => isNodeSelectableInDocument(options, result.workingDocument, id));
     if (selectedIds.length === 0) {
-        const undone = state.session.undo();
+        const undone = session.undo();
         if (undone)
             rebuildProjectionFromDocument(state, options, undone.workingDocument, originalSelection);
         state.status = 'Duplicate drag rejected: duplicated selection is not selectable';
@@ -6628,7 +7817,7 @@ function beginDuplicateDrag(state, options, input) {
     const activeId = patch.activeId && selectedIds.includes(patch.activeId)
         ? patch.activeId
         : selectedIds[selectedIds.length - 1] ?? null;
-    const selectionResult = state.session.dispatch({
+    const selectionResult = session.dispatch({
         type: 'selection.replace',
         selectedIds,
         activeId,
@@ -7222,6 +8411,9 @@ function formatAssetLabel(asset, fallback) {
     const label = record?.label ?? record?.displayName ?? record?.name;
     return typeof label === 'string' && label.trim() ? label : fallback;
 }
+function withPresentationImpact(impact) {
+    return impact ? { presentationImpact: impact } : {};
+}
 function withProjectionImpact(impact) {
     return impact ? { projectionImpact: impact } : {};
 }
@@ -7234,6 +8426,18 @@ function createTransformProjectionImpact(ids) {
 function createMetadataProjectionImpact(ids) {
     return createIncrementalProjectionImpact({ syncMetadataIds: ids });
 }
+function applyRenameProjectionImpact(state, options, document, selection, ids, reason) {
+    const impact = createMetadataProjectionImpact(ids);
+    const applied = applyProjectionImpactToDocument(state, options, {
+        document,
+        selection,
+        impact,
+        reason,
+        syncWorld: false,
+    });
+    if (!applied)
+        rebuildProjectionFromDocument(state, options, document, selection);
+}
 function createReprojectProjectionImpact(ids) {
     return createIncrementalProjectionImpact({ reprojectIds: ids });
 }
@@ -7356,6 +8560,7 @@ function createHistoryOperationResult(state, input) {
         },
         status: input.status,
         projection: createHistoryProjectionResult(input.waitForProjection, null, state),
+        ...(input.result?.transaction.presentationImpact ? { presentationImpact: input.result.transaction.presentationImpact } : {}),
     };
 }
 function createHistoryProjectionResult(waitPolicy, idleState, state) {
@@ -7373,10 +8578,41 @@ function applyHistoryProjectionImpact(state, options, result, operation) {
         rebuildProjection(state, options, result);
         return;
     }
-    const applied = applyIncrementalHistoryProjectionImpact(state, options, result, operation, impact);
+    const applied = applyIncrementalHistoryProjectionImpact(state, options, result, operation, impact, !isRenameTransactionImpact(result.transaction));
     if (!applied)
         rebuildProjection(state, options, result);
 }
+function isRenameTransactionImpact(transaction) {
+    return isRenameImpact(transaction);
+}
+function resolveLocalEditorDocumentStructureChange(classify, command) {
+    if (isRenameImpact(command))
+        return false;
+    return classify?.(command) ?? true;
+}
+function isRenameImpact(input) {
+    const presentation = input.presentationImpact;
+    const projection = input.projectionImpact;
+    if (!presentation
+        || presentation.hierarchy === 'full'
+        || !presentation.hierarchy
+        || presentation.rendering === true
+        || !Array.isArray(presentation.inspector)
+        || presentation.inspector.length !== 1
+        || presentation.inspector[0] !== 'summary'
+        || !projection
+        || projection.type !== 'incremental')
+        return false;
+    const labelIds = uniqueProjectionIds(presentation.hierarchy.labelIds);
+    const metadataIds = uniqueProjectionIds(projection.syncMetadataIds);
+    return labelIds.length > 0
+        && labelIds.length === metadataIds.length
+        && labelIds.every(id => metadataIds.includes(id))
+        && uniqueProjectionIds(projection.syncTransformIds).length === 0
+        && uniqueProjectionIds(projection.reprojectIds).length === 0
+        && uniqueProjectionIds(projection.createdNodeIds).length === 0
+        && uniqueProjectionIds(projection.deletedNodeIds).length === 0;
+}
 function applyProjectionImpactToDocument(state, options, input) {
     if (!input.impact || input.impact.type === 'rebuild')
         return false;
@@ -7389,12 +8625,13 @@ function applyProjectionImpactToDocument(state, options, input) {
         projectNodeIds: input.impact.createdNodeIds,
         removeNodeIds: input.impact.deletedNodeIds,
         reason: input.reason,
+        syncWorld: input.syncWorld,
     });
 }
 function rebuildProjection(state, options, result) {
     rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
 }
-function applyIncrementalHistoryProjectionImpact(state, options, result, operation, impact) {
+function applyIncrementalHistoryProjectionImpact(state, options, result, operation, impact, syncWorld) {
     const projectNodeIds = operation === 'redo'
         ? uniqueProjectionIds(impact.createdNodeIds)
         : uniqueProjectionIds(impact.deletedNodeIds);
@@ -7410,6 +8647,7 @@ function applyIncrementalHistoryProjectionImpact(state, options, result, operati
         projectNodeIds,
         removeNodeIds,
         reason: 'history-impact',
+        syncWorld,
     });
 }
 function applyIncrementalProjectionImpactToDocument(state, options, input) {
@@ -7498,14 +8736,16 @@ function applyIncrementalProjectionImpactToDocument(state, options, input) {
     applyPreviewVisibilityStateToProjection(state);
     const sanitized = sanitizeSelection(state, options, input.document, input.selection);
     syncSelectionToProjection(state, options, sanitized ?? input.selection);
-    syncEditorWorldAppearanceFromDocument(state, options, input.document, `world-appearance-${input.reason}`);
-    if (syncMetadataNodes.length > 0) {
-        syncEditorWorldRenderingFromDocument(state, options, input.document, `world-rendering-${input.reason}`, {
-            staticProjectedMetadataChanged: true,
-        });
-    }
-    else {
-        syncEditorWorldRenderingFromDocument(state, options, input.document, `world-rendering-${input.reason}`, true);
+    if (input.syncWorld !== false) {
+        syncEditorWorldAppearanceFromDocument(state, options, input.document, `world-appearance-${input.reason}`);
+        if (syncMetadataNodes.length > 0) {
+            syncEditorWorldRenderingFromDocument(state, options, input.document, `world-rendering-${input.reason}`, {
+                staticProjectedMetadataChanged: true,
+            });
+        }
+        else {
+            syncEditorWorldRenderingFromDocument(state, options, input.document, `world-rendering-${input.reason}`, true);
+        }
     }
     invalidateEditorScene(state, `projection-${input.reason}`, options);
     return true;
@@ -7697,7 +8937,7 @@ function syncProjectionMetadataForChangedIds(state, options, document, changedId
     }
     invalidateEditorScene(state, 'projection-sync-metadata-ids');
 }
-function reprojectProjectionForChangedIds(state, options, document, changedIds) {
+function reprojectProjectionForChangedIds(state, options, document, changedIds, syncOptions = {}) {
     if (state.prefabStage) {
         rebuildProjectionFromDocument(state, options, document, EMPTY_EDITOR_SELECTION);
         return;
@@ -7706,8 +8946,18 @@ function reprojectProjectionForChangedIds(state, options, document, changedIds)
         const projectedNodes = resolveProjectionNodesForTarget(options, document, changedId);
         if (projectedNodes) {
             removeSceneProjectionTarget(state, changedId);
-            for (const projectedNode of projectedNodes)
+            for (const projectedNode of projectedNodes) {
                 state.projection?.projectNode(projectedNode);
+                if (syncOptions.refreshInspector === false) {
+                    const batch = state.projection?.getLastProjectionBatch();
+                    if (batch) {
+                        suppressProjectionInspectorRefreshForBatch(state, batch.batchId, projectedNode.id);
+                        void batch.settled.then(() => {
+                            releaseProjectionInspectorRefreshSuppression(state, batch.batchId);
+                        });
+                    }
+                }
+            }
         }
     }
     applyPreviewVisibilityStateToProjection(state);
@@ -7716,6 +8966,24 @@ function reprojectProjectionForChangedIds(state, options, document, changedIds)
     syncEditorWorldRenderingFromDocument(state, options, document, 'world-rendering-reproject-changed-ids', true);
     invalidateEditorScene(state, 'projection-reproject-changed-ids', options);
 }
+function suppressProjectionInspectorRefreshForBatch(state, batchId, nodeId) {
+    state.suppressedProjectionInspectorRefreshBatchIds.add(batchId);
+    const batches = state.suppressedProjectionInspectorRefreshNodeBatches.get(nodeId) ?? new Set();
+    batches.add(batchId);
+    state.suppressedProjectionInspectorRefreshNodeBatches.set(nodeId, batches);
+}
+function isProjectionInspectorRefreshSuppressed(state, nodeId, batchId) {
+    return (batchId !== undefined && state.suppressedProjectionInspectorRefreshBatchIds.has(batchId))
+        || state.suppressedProjectionInspectorRefreshNodeBatches.has(nodeId);
+}
+function releaseProjectionInspectorRefreshSuppression(state, batchId) {
+    state.suppressedProjectionInspectorRefreshBatchIds.delete(batchId);
+    for (const [nodeId, batches] of state.suppressedProjectionInspectorRefreshNodeBatches) {
+        batches.delete(batchId);
+        if (batches.size === 0)
+            state.suppressedProjectionInspectorRefreshNodeBatches.delete(nodeId);
+    }
+}
 function removeLocalEditorMaterialProfileDiagnostics(state, projectionNodeId) {
     state.materialProfileDiagnostics = state.materialProfileDiagnostics.filter(diagnostic => diagnostic.locator?.objectId !== projectionNodeId);
 }
@@ -7826,8 +9094,7 @@ function syncViewportMeasurementState(state) {
     if (measurement)
         state.viewportMeasurement = measurement;
 }
-function hasSceneCameraPreviewRig(state, options) {
-    const document = state.session?.getState().workingDocument ?? null;
+function hasSceneCameraPreviewRig(options, document) {
     return !!document && !!options.documentAdapter.getSceneCameraPreviewRig?.(document);
 }
 function applyActiveTransformPreviewToInspectorObject(state, options, document, inspectorObject) {
@@ -8053,7 +9320,7 @@ function tryFreezeHierarchyContributionDocument(document) {
         return null;
     }
 }
-export function createLocalEditorSceneHierarchyScopeAdapter(state, options) {
+export function createLocalEditorSceneHierarchyScopeAdapter(state, options, applyRenamePresentation) {
     const clipboard = new Map();
     return {
         id: 'fps.editor.product.scene-hierarchy',
@@ -8061,7 +9328,7 @@ export function createLocalEditorSceneHierarchyScopeAdapter(state, options) {
         canProvide: () => !state.prefabStage,
         getTree(cache) {
             const sessionState = state.session?.getState({ cloneDocuments: false });
-            const structureKey = `scene:${String(sessionState?.documentStructureRevision ?? 0)}:${String(state.markerGraphVisibilityRevision)}`;
+            const structureKey = `scene:${String(sessionState?.documentStructureRevision ?? 0)}:${String(state.markerGraphVisibilityRevision)}:${String(state.hierarchyPresentationFallbackRevision)}`;
             const revision = resolveLocalEditorHierarchyRevision(state);
             if (cache?.structureKey === structureKey && cache.snapshot.revision === revision)
                 return cache;
@@ -8163,7 +9430,8 @@ export function createLocalEditorSceneHierarchyScopeAdapter(state, options) {
                     : []),
             ];
         },
-        async executeOperation({ snapshot, invocation, operation, render, getSnapshot }) {
+        async executeOperation({ snapshot, invocation, operation, render, getSnapshot, state: operationState }) {
+            const state = operationState;
             const resolve = (rowId) => this.resolveTarget(snapshot, rowId);
             if (invocation.operationId === 'hierarchy.node.focus') {
                 const target = invocation.contextNodeId ? resolve(invocation.contextNodeId) : null;
@@ -8239,7 +9507,7 @@ export function createLocalEditorSceneHierarchyScopeAdapter(state, options) {
                 if (!targetId || !name || snapshot.readonly)
                     return createHarnessHierarchyOperationResult(false, false, snapshot.revision, 'hierarchy.rename.invalid', 'Rename target or name is invalid.');
                 const outcome = renameSceneGraphNode(state, options, { id: resolve(targetId)?.authoredId ?? targetId, name });
-                if (outcome === 'changed')
+                if (outcome === 'changed' && !applyRenamePresentation?.({ id: targetId, name }))
                     render();
                 return outcome === 'changed'
                     ? createHarnessHierarchyOperationResult(true, true, getSnapshot().revision)
@@ -8407,7 +9675,8 @@ export function createLocalEditorPrefabHierarchyScopeAdapter(state, options) {
                     : []),
             ].flat();
         },
-        async executeOperation({ snapshot, invocation, operation, render, getSnapshot, executorStates }) {
+        async executeOperation({ snapshot, invocation, operation, render, getSnapshot, executorStates, state: operationState }) {
+            const state = operationState;
             const resolve = (rowId) => this.resolveTarget(snapshot, rowId);
             if (invocation.operationId === 'hierarchy.node.focus') {
                 const target = invocation.contextNodeId ? resolve(invocation.contextNodeId) : null;
@@ -8679,6 +9948,10 @@ export function createLocalEditorHarnessHierarchyScopeProvider(state, options, r
         applySelection: applyHierarchySelection,
         listOperations,
         async executeOperation(invocation) {
+            const serializedAccess = getSerializedHierarchyInvocationAccess(invocation);
+            const serializedOperationState = serializedAccess === undefined
+                ? state
+                : createSerializedHierarchyOperationState(state, serializedAccess);
             const validated = validateContext(invocation);
             if ('ok' in validated)
                 return validated;
@@ -8698,13 +9971,16 @@ export function createLocalEditorHarnessHierarchyScopeProvider(state, options, r
                         ? invocation.input.visibleIds.filter((id) => typeof id === 'string')
                         : [...validated.nodeById.keys()];
                     const selectableIds = requestedIds.filter(id => validated.nodeById.get(id)?.selectable === true);
-                    return applyHierarchySelection({
+                    const apply = () => applyHierarchySelection({
                         ...invocation,
                         selectedIds: selectableIds,
                         activeId: selectableIds.includes(invocation.activeId ?? '')
                             ? invocation.activeId
                             : selectableIds[selectableIds.length - 1] ?? null,
                     });
+                    return serializedAccess === undefined
+                        ? apply()
+                        : callWithEditorAuthoringSerializedAccess(serializedAccess, apply);
                 }
                 const contextNodeId = invocation.contextNodeId;
                 const contextNode = contextNodeId ? validated.nodeById.get(contextNodeId) : null;
@@ -8728,11 +10004,14 @@ export function createLocalEditorHarnessHierarchyScopeProvider(state, options, r
                     selectedIds = descendants;
                 }
                 const selectableIds = selectedIds.filter(id => validated.nodeById.get(id)?.selectable === true);
-                return applyHierarchySelection({
+                const apply = () => applyHierarchySelection({
                     ...invocation,
                     selectedIds: selectableIds,
                     activeId: selectableIds[0] ?? null,
                 });
+                return serializedAccess === undefined
+                    ? apply()
+                    : callWithEditorAuthoringSerializedAccess(serializedAccess, apply);
             }
             const contribution = (options.hierarchy?.operations ?? []).find(operation => operation.id === invocation.operationId);
             if (contribution) {
@@ -8742,36 +10021,48 @@ export function createLocalEditorHarnessHierarchyScopeProvider(state, options, r
                 const beforeRevision = validated.revision;
                 try {
                     return await runExclusiveResult(state, render, async () => {
-                        const preparedSnapshot = validateContext(invocation);
-                        if ('ok' in preparedSnapshot)
-                            return preparedSnapshot;
-                        const visibleContext = createOperationContributionContext(preparedSnapshot, invocation, invocation.input);
-                        if (!visibleContext || contribution.visible?.(visibleContext) === false) {
-                            return createHarnessHierarchyOperationResult(false, false, preparedSnapshot.revision, 'hierarchy.operation.unsupported', `Unsupported Hierarchy operation: ${invocation.operationId}`);
-                        }
-                        const disabledContext = createOperationContributionContext(preparedSnapshot, invocation, invocation.input);
-                        const disabled = disabledContext ? contribution.disabled?.(disabledContext) : true;
-                        if (disabled === true || typeof disabled === 'string') {
-                            return createHarnessHierarchyOperationResult(false, false, preparedSnapshot.revision, 'hierarchy.operation.disabled', typeof disabled === 'string' ? disabled : 'Hierarchy operation is disabled.');
-                        }
-                        const runContext = createOperationContributionContext(preparedSnapshot, invocation, invocation.input, 'isolated');
-                        if (!runContext) {
-                            return createHarnessHierarchyOperationResult(false, false, preparedSnapshot.revision, 'hierarchy.operation.unsupported', `Unsupported Hierarchy operation: ${invocation.operationId}`);
-                        }
-                        const contributionResult = await contribution.run(runContext);
-                        const commitSnapshot = validateContext(invocation);
-                        if ('ok' in commitSnapshot) {
-                            return createHarnessHierarchyOperationResult(false, false, commitSnapshot.revision, 'hierarchy.operation.stale-before-commit', 'Hierarchy scope changed while the operation was being prepared; no patch was applied.');
-                        }
-                        const handled = applyHierarchyOperationContributionResult(state, options, contributionResult, contribution.label);
-                        if (handled)
-                            render();
-                        const current = getSnapshot();
-                        const changed = current.revision > beforeRevision;
-                        if (handled && (contribution.effect !== 'authoring' || changed)) {
-                            return createHarnessHierarchyOperationResult(true, changed, current.revision);
-                        }
-                        return createHarnessHierarchyOperationResult(false, changed, current.revision, 'hierarchy.operation.rejected', `${contribution.label} was rejected.`);
+                        const executeContribution = async (operationState = state) => {
+                            const preparedSnapshot = validateContext(invocation);
+                            if ('ok' in preparedSnapshot)
+                                return preparedSnapshot;
+                            const visibleContext = createOperationContributionContext(preparedSnapshot, invocation, invocation.input);
+                            if (!visibleContext || contribution.visible?.(visibleContext) === false) {
+                                return createHarnessHierarchyOperationResult(false, false, preparedSnapshot.revision, 'hierarchy.operation.unsupported', `Unsupported Hierarchy operation: ${invocation.operationId}`);
+                            }
+                            const disabledContext = createOperationContributionContext(preparedSnapshot, invocation, invocation.input);
+                            const disabled = disabledContext ? contribution.disabled?.(disabledContext) : true;
+                            if (disabled === true || typeof disabled === 'string') {
+                                return createHarnessHierarchyOperationResult(false, false, preparedSnapshot.revision, 'hierarchy.operation.disabled', typeof disabled === 'string' ? disabled : 'Hierarchy operation is disabled.');
+                            }
+                            const runContext = createOperationContributionContext(preparedSnapshot, invocation, invocation.input, 'isolated');
+                            if (!runContext) {
+                                return createHarnessHierarchyOperationResult(false, false, preparedSnapshot.revision, 'hierarchy.operation.unsupported', `Unsupported Hierarchy operation: ${invocation.operationId}`);
+                            }
+                            const contributionResult = await contribution.run(runContext);
+                            const commitSnapshot = validateContext(invocation);
+                            if ('ok' in commitSnapshot) {
+                                return createHarnessHierarchyOperationResult(false, false, commitSnapshot.revision, 'hierarchy.operation.stale-before-commit', 'Hierarchy scope changed while the operation was being prepared; no patch was applied.');
+                            }
+                            if (isLocalEditorHarnessPatchResult(contributionResult)
+                                && contribution.effect !== undefined
+                                && contribution.effect !== 'authoring') {
+                                return createHarnessHierarchyOperationResult(false, false, commitSnapshot.revision, 'hierarchy.operation.effect-mismatch', `${contribution.label} declared effect '${contribution.effect}' and cannot return an authoring patch.`);
+                            }
+                            const handled = applyHierarchyOperationContributionResult(operationState, options, contributionResult, contribution.label);
+                            if (handled)
+                                render();
+                            const current = getSnapshot();
+                            const changed = current.revision > beforeRevision;
+                            if (handled && (contribution.effect !== 'authoring' || changed)) {
+                                return createHarnessHierarchyOperationResult(true, changed, current.revision);
+                            }
+                            return createHarnessHierarchyOperationResult(false, changed, current.revision, 'hierarchy.operation.rejected', `${contribution.label} was rejected.`);
+                        };
+                        return contribution.effect === 'view'
+                            || contribution.effect === 'selection'
+                            || serializedAccess !== undefined
+                            ? executeContribution(serializedOperationState)
+                            : state.runBrowserAuthoringMutation(invocation.operationId, JSON.stringify([invocation, validated.scopeKey, validated.revision]), executeContribution);
                     }, executorStates);
                 }
                 catch (error) {
@@ -8785,21 +10076,29 @@ export function createLocalEditorHarnessHierarchyScopeProvider(state, options, r
             const beforeRevision = validated.revision;
             try {
                 return await runExclusiveResult(state, render, async () => {
-                    const preparedSnapshot = validateContext(invocation);
-                    if ('ok' in preparedSnapshot)
-                        return preparedSnapshot;
-                    return adapter.executeOperation({
-                        snapshot: preparedSnapshot,
-                        context: invocation,
-                        invocation,
-                        operation: listedOperation,
-                        state,
-                        options,
-                        render,
-                        getSnapshot,
-                        executorStates,
-                    });
-                }, executorStates);
+                    const executeAdapter = async (operationState = state) => {
+                        const preparedSnapshot = validateContext(invocation);
+                        if ('ok' in preparedSnapshot)
+                            return preparedSnapshot;
+                        return adapter.executeOperation({
+                            snapshot: preparedSnapshot,
+                            context: invocation,
+                            invocation,
+                            operation: listedOperation,
+                            state: operationState,
+                            options,
+                            render,
+                            getSnapshot,
+                            executorStates,
+                        });
+                    };
+                    return listedOperation.effect === 'authoring' && serializedAccess === undefined
+                        ? state.runBrowserAuthoringMutation(invocation.operationId, JSON.stringify([invocation, validated.scopeKey, validated.revision]), executeAdapter)
+                        : executeAdapter(serializedOperationState);
+                }, executorStates, {
+                    renderBoundary: !(adapter.id === 'fps.editor.product.scene-hierarchy'
+                        && invocation.operationId === 'hierarchy.node.rename'),
+                });
             }
             catch (error) {
                 const current = getSnapshot();
@@ -8808,6 +10107,28 @@ export function createLocalEditorHarnessHierarchyScopeProvider(state, options, r
         },
     };
 }
+function getSerializedHierarchyInvocationAccess(invocation) {
+    return invocation[SERIALIZED_HIERARCHY_INVOCATION];
+}
+function createSerializedHierarchyOperationState(state, serializedAccess) {
+    const session = state.session;
+    if (!session)
+        return state;
+    const authorizedSession = createEditorAuthoringSerializedSessionView(session, serializedAccess);
+    return new Proxy(state, {
+        get(target, property, receiver) {
+            if (property === 'session')
+                return authorizedSession;
+            return Reflect.get(target, property, receiver);
+        },
+        set(target, property, value, receiver) {
+            if (property === 'session') {
+                throw new Error('Serialized Hierarchy operations cannot replace the active Session.');
+            }
+            return Reflect.set(target, property, value, receiver);
+        },
+    });
+}
 const BUILT_IN_HIERARCHY_OPERATION_IDS = new Set([
     'hierarchy.node.focus',
     'hierarchy.node.rename',
@@ -8857,6 +10178,13 @@ function createHarnessHierarchyOperationResult(ok, changed, revision, code, mess
             : Object.freeze([]),
     });
 }
+function reportBrowserAuthoringFailure(state, render, error) {
+    state.status = 'Editor command failed';
+    state.statusTone = 'error';
+    state.statusToneStatus = state.status;
+    state.statusDetails = error instanceof Error ? error.message : String(error);
+    render();
+}
 function sameHierarchySelection(left, right) {
     return left.length === right.length && left.every((id, index) => id === right[index]);
 }
@@ -8884,6 +10212,32 @@ function getCachedLocalEditorHierarchyItems(state, options, document) {
     }
     return state.hierarchyItemsCache;
 }
+function resolveAuthoritativeHierarchyLabels(state, options, document, ids) {
+    const cachedItems = getCachedLocalEditorHierarchyItems(state, options, document);
+    const cachedById = new Map(cachedItems.map(item => [item.id, item]));
+    const labels = {};
+    let changed = false;
+    const nextItems = [...cachedItems];
+    for (const id of ids) {
+        const cached = cachedById.get(id);
+        const projectedName = options.documentAdapter.getProjectionNode(document, id)?.name;
+        const label = typeof projectedName === 'string' && projectedName.trim()
+            ? projectedName
+            : cached?.label;
+        if (!label)
+            continue;
+        labels[id] = label;
+        if (cached && cached.label !== label) {
+            const index = nextItems.findIndex(item => item.id === id);
+            if (index >= 0)
+                nextItems[index] = Object.freeze({ ...cached, label, name: label });
+            changed = true;
+        }
+    }
+    if (changed)
+        state.hierarchyItemsCache = Object.freeze(nextItems);
+    return labels;
+}
 function getLocalEditorDiagnosticContext(state) {
     return {
         scopeId: state.prefabStage
@@ -9149,6 +10503,23 @@ function toBrowserStatusDiagnostic(diagnostic, context) {
         ...(diagnostic.details ? { details: normalizeEditorDiagnosticDetails(diagnostic.details) } : {}),
     };
 }
+function createUiSessionState(state) {
+    const sessionState = state.session?.getState({ cloneDocuments: false });
+    const projectSnapshot = state.prefabStage ? null : state.projectAuthoringSnapshot;
+    return sessionState
+        ? {
+            source: sessionState.source,
+            dirty: state.prefabStage?.transaction.snapshot().documentDirty
+                ?? projectSnapshot?.dirty
+                ?? sessionState.dirty,
+            canUndo: projectSnapshot?.canUndo ?? sessionState.canUndo,
+            canRedo: projectSnapshot?.canRedo ?? sessionState.canRedo,
+            history: projectSnapshot
+                ? { entries: projectSnapshot.history.entries.map(entry => ({ ...entry })) }
+                : sessionState.history,
+        }
+        : null;
+}
 function createUiState(state, options, hierarchySnapshot, toolManager) {
     const sessionState = state.session?.getState({ cloneDocuments: false });
     const document = sessionState?.workingDocument ?? null;
@@ -9188,7 +10559,6 @@ function createUiState(state, options, hierarchySnapshot, toolManager) {
     const uiState = {
         mode: state.mode,
         busy: state.busy,
-        agentBridge: state.agentBridgeStatus,
         status: state.status,
         statusTone: state.statusToneStatus === state.status ? state.statusTone : 'default',
         statusDetails: state.statusToneStatus === state.status ? state.statusDetails : '',
@@ -9207,6 +10577,7 @@ function createUiState(state, options, hierarchySnapshot, toolManager) {
         inspectorObject: previewInspectorObject,
         inspectorMultiObject: previewInspectorMultiObject,
         inspectorPending: false,
+        inspectorPresentationGeneration: state.inspectorPresentationGeneration,
         renderingPanel: document
             ? options.documentAdapter.getRenderingPanelState?.(document, {
                 scene: state.world?.scene ?? null,
@@ -9251,22 +10622,14 @@ function createUiState(state, options, hierarchySnapshot, toolManager) {
         performanceStats: cloneLocalEditorPerformanceStats(state.performanceStats),
         sceneCameraPreview: {
             enabled: state.sceneCameraPreviewEnabled,
-            available: hasSceneCameraPreviewRig(state, options),
+            available: hasSceneCameraPreviewRig(options, document),
         },
         prefabStage: createBrowserPrefabStageState(state, options, document),
         grid: {
             visible: state.gridVisible,
             available: !!state.grid,
         },
-        session: sessionState
-            ? {
-                source: sessionState.source,
-                dirty: state.prefabStage?.transaction.snapshot().documentDirty ?? sessionState.dirty,
-                canUndo: sessionState.canUndo,
-                canRedo: sessionState.canRedo,
-                history: sessionState.history,
-            }
-            : null,
+        session: createUiSessionState(state),
     };
     uiState.documentRevision = sessionState?.documentRevision ?? 0;
     const diagnosticContext = getLocalEditorDiagnosticContext(state);
@@ -9342,25 +10705,25 @@ function createBrowserPrefabStageState(state, options, document, includeInspecto
         previewNodeId: descriptor.previewNodeId,
     };
 }
-function summarizeAgentBridgePrefabStage(state, options) {
+function summarizeEditorCommandPrefabStage(state, options) {
     const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;
     const stage = createBrowserPrefabStageState(state, options, document);
     if (!stage)
         return null;
-    return createAgentBridgePrefabStageState(stage);
+    return createEditorCommandPrefabStageState(stage);
 }
-function summarizeAgentBridgePrefabStageDetails(state, options) {
+function summarizeEditorCommandPrefabStageDetails(state, options) {
     const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;
     const stage = createBrowserPrefabStageState(state, options, document);
     if (!stage)
         return null;
     return {
-        stage: createAgentBridgePrefabStageState(stage),
-        nodeDetails: createAgentBridgePrefabNodeDetails(stage.structureItems),
+        stage: createEditorCommandPrefabStageState(stage),
+        nodeDetails: createEditorCommandPrefabNodeDetails(stage.structureItems),
         inspectorObject: stage.inspectorObject ?? null,
     };
 }
-function createAgentBridgePrefabNodeDetails(items) {
+function createEditorCommandPrefabNodeDetails(items) {
     const details = [];
     const stack = [...items].reverse();
     while (stack.length > 0) {
@@ -9389,7 +10752,7 @@ function createAgentBridgePrefabNodeDetails(items) {
     }
     return details;
 }
-function createAgentBridgePrefabStageState(stage) {
+function createEditorCommandPrefabStageState(stage) {
     return {
         assetId: stage.assetId,
         ...(stage.browserAssetId ? { browserAssetId: stage.browserAssetId } : {}),
@@ -9405,7 +10768,7 @@ function createAgentBridgePrefabStageState(stage) {
         canDiscard: stage.canDiscard,
     };
 }
-function createAgentBridgePrefabSummaryFromStage(stage) {
+function createEditorCommandPrefabSummaryFromStage(stage) {
     return {
         assetId: stage.assetId,
         ...(stage.browserAssetId ? { browserAssetId: stage.browserAssetId } : {}),
@@ -9416,7 +10779,7 @@ function createAgentBridgePrefabSummaryFromStage(stage) {
         status: 'ready',
     };
 }
-function isSameAgentBridgePrefabStage(left, right) {
+function isSameEditorCommandPrefabStage(left, right) {
     if (!left || !right)
         return false;
     return left.assetId === right.assetId
@@ -9583,10 +10946,10 @@ function createLocalEditorEditingContextProviders(state, options) {
             return focusProjectionNode(state, activeId);
         },
         commitTransform: event => commitSceneGizmoTransform(state, options, event),
-        beginDuplicateDrag: input => beginDuplicateDrag(state, options, input),
+        beginDuplicateDrag: (input, session) => beginDuplicateDrag(state, options, input, session),
         getInspectorObject: (document, targetId) => createSceneEditingContextInspectorObject(state, options, document, targetId),
         getInspectorMultiObject: (document, targetIds, activeId) => createSceneEditingContextInspectorMultiObject(state, options, document, targetIds, activeId),
-        patchInspectorProperty: input => patchSceneSerializedProperty(state, options, input),
+        patchInspectorProperty: (input, onCommitted) => patchSceneSerializedProperty(state, options, input, onCommitted),
         resolveInspectorPreviewTransform(document, targetId, transform, preview) {
             const createInspectorPreview = options.documentAdapter.createTransformInspectorPreview;
             if (!document || !createInspectorPreview)
@@ -9799,6 +11162,7 @@ function createUiToolPresentationPreviewState(state, snapshot) {
     };
 }
 function publishLocalEditorSelectionPresentation(state, options, renderPreviewUi, reason) {
+    cancelInspectorPresentationPreview(state);
     syncViewportSpatialOverlay(state, options);
     renderPreviewUi(createUiSelectionPresentationPreviewState(state, options));
     requestEditorSceneFrame(state, reason);
@@ -9811,6 +11175,7 @@ function createUiSelectionPresentationPreviewState(state, options) {
     const transformSelectionIsLarge = isLargeSelection(selectedIds);
     const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;
     return {
+        inspectorPresentationGeneration: state.inspectorPresentationGeneration,
         selectedIds,
         activeId,
         selectionSummary: {
@@ -9837,6 +11202,7 @@ function createUiSelectionInspectorPreviewState(state, options) {
     const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;
     if (!document) {
         return {
+            inspectorPresentationGeneration: state.inspectorPresentationGeneration,
             inspectorObject: null,
             inspectorMultiObject: null,
             inspectorPending: false,
@@ -9846,6 +11212,7 @@ function createUiSelectionInspectorPreviewState(state, options) {
     if (state.prefabStage) {
         const prefabStage = createBrowserPrefabStageState(state, options, document);
         return {
+            inspectorPresentationGeneration: state.inspectorPresentationGeneration,
             prefabStage,
             inspectorObject: prefabStage?.inspectorObject ?? null,
             inspectorMultiObject: null,
@@ -9854,6 +11221,7 @@ function createUiSelectionInspectorPreviewState(state, options) {
     }
     const editingContext = getLocalEditorEditingContext(state);
     return {
+        inspectorPresentationGeneration: state.inspectorPresentationGeneration,
         inspectorObject: editingContext.getInspectorObject(document),
         inspectorMultiObject: editingContext.getInspectorMultiObject(document),
         inspectorPending: false,
@@ -9861,10 +11229,6 @@ function createUiSelectionInspectorPreviewState(state, options) {
 }
 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;
@@ -9892,18 +11256,7 @@ function scheduleSelectionInspectorRefresh(state, options, renderPreviewUi) {
             });
         }
     };
-    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);
-    }
+    state.selectionInspectorRefreshTimeout = globalThis.setTimeout(publish, 0);
 }
 function isLocalEditorSelectionDebugEnabled() {
     return typeof globalThis.location?.search === 'string'
@@ -9935,6 +11288,7 @@ function createUiPreviewState(state, options) {
         ? applyActiveTransformPreviewToInspectorObject(state, options, document, withRuntimeInspectorSections(state, options, document, inspectorObjectBase))
         : null;
     return {
+        inspectorPresentationGeneration: state.inspectorPresentationGeneration,
         status: state.status,
         statusTone: state.statusToneStatus === state.status ? state.statusTone : 'default',
         statusDetails: state.statusToneStatus === state.status ? state.statusDetails : '',