@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.1

package/node_modules/@fps-games/editor-browser/dist/local-editor-ui-hierarchy-controller.js

@@ -1,106 +1,256 @@
-import { createLocalEditorHierarchyBlankMenu, createLocalEditorHierarchyCopyShortcutAction, createLocalEditorHierarchyDeleteShortcutAction, createLocalEditorHierarchyDuplicateShortcutAction, createLocalEditorHierarchyNodeMenu, createLocalEditorHierarchyPasteShortcutAction, createLocalEditorHierarchySelectAllShortcutAction, } from './local-editor-ui-hierarchy-actions.js';
-import { canLocalEditorHierarchyNodeHaveChildren, canLocalEditorHierarchyNodeRename, canLocalEditorHierarchyNodeToggleEnabled, createLocalEditorHierarchyTreeModel, isLocalEditorHierarchyNodeSelectable, isLocalEditorHierarchyNodeMovable, } from './local-editor-ui-hierarchy-tree.js';
+import {} from '@fps-games/plugin-hierarchy';
 import { resolveLocalEditorHierarchyDragOperation, } from './local-editor-ui-hierarchy-drag-policy.js';
 import { resolveLocalEditorHierarchyAutoScroll, } from './local-editor-ui-hierarchy-auto-scroll.js';
 import { clearLocalEditorStructuredDragSession, createLocalEditorStructuredDragSession, hasLocalEditorStructuredDragSessionFeedback, } from './local-editor-ui-structured-drag-session.js';
-import { renderLocalEditorHierarchyPanel, syncLocalEditorHierarchyDropPreview, } from './local-editor-ui-hierarchy-view.js';
-import { createLocalEditorActiveHierarchyScope, } from './local-editor-ui-hierarchy-scope.js';
-import { createLocalEditorHierarchyProjection, isLocalEditorHierarchyProjectionCurrent, } from './local-editor-ui-hierarchy-projection.js';
-import { resolveLocalEditorHierarchyCommandAdapter, } from './local-editor-ui-hierarchy-command-adapter.js';
+import { LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT, renderLocalEditorHierarchyPanel, syncLocalEditorHierarchyDropPreview, } from './local-editor-ui-hierarchy-view.js';
 import { createLocalEditorViewportRevealController, } from './local-editor-ui-dock-panel.js';
-import { createLocalEditorHierarchyAttachDialog, } from './local-editor-ui-hierarchy-attach-dialog.js';
+import { createLocalEditorHierarchyViewAdapter } from './local-editor-ui-hierarchy-view-adapter.js';
 const HIERARCHY_DRAG_INDENT_WIDTH = 16;
-export function resolveLocalEditorHierarchyCreateMarkerParentId(activeNode) {
-    return activeNode && activeNode.item.canHaveChildren === true && activeNode.item.role !== 'marker'
-        ? activeNode.id
-        : null;
+export function createHierarchyEnabledOperationRequest(node, directEnabled) {
+    const nextValue = directEnabled === false;
+    return node?.authoredEnabled === undefined
+        ? Object.freeze({ operationId: 'hierarchy.node.set-visible', input: Object.freeze({ visible: nextValue }) })
+        : Object.freeze({ operationId: 'hierarchy.node.set-enabled', input: Object.freeze({ enabled: nextValue }) });
 }
-export function resolveLocalEditorHierarchyToolbarActiveId(scope) {
-    return scope.activeId && scope.nodes.some(node => node.id === scope.activeId)
-        ? scope.activeId
-        : null;
+export function createHierarchyOperationMenuItems(operations) {
+    const root = { id: '', label: '', order: 0, children: new Map(), operations: [] };
+    const operationIds = new Set();
+    for (const operation of operations) {
+        if (operationIds.has(operation.id))
+            throw new Error(`Duplicate Hierarchy operation id: ${operation.id}.`);
+        operationIds.add(operation.id);
+    }
+    operations.forEach((operation, sourceIndex) => {
+        if (operation.menu === false)
+            return;
+        const presentation = resolveHierarchyOperationMenuPresentation(operation);
+        let parent = root;
+        for (const segment of presentation.path) {
+            const existing = parent.children.get(segment.id);
+            if (existing && (existing.label !== segment.label || existing.order !== (segment.order ?? 0))) {
+                throw new Error(`Hierarchy menu path conflict for segment ${segment.id}.`);
+            }
+            const node = existing ?? {
+                id: segment.id, label: segment.label, order: segment.order ?? 0, children: new Map(), operations: [],
+            };
+            parent.children.set(segment.id, node);
+            parent = node;
+        }
+        parent.operations.push({ operation, presentation, sourceIndex });
+    });
+    const materialize = (node, parentPath = []) => {
+        const entries = [
+            ...[...node.children.values()].map(child => ({ kind: 'path', order: child.order, group: `path:${child.id}`, sourceIndex: -1, child })),
+            ...node.operations.map(entry => ({
+                kind: 'operation',
+                order: entry.presentation.order,
+                group: entry.presentation.group,
+                sourceIndex: entry.sourceIndex,
+                operation: entry.operation,
+            })),
+        ].sort((left, right) => left.order - right.order || left.sourceIndex - right.sourceIndex);
+        return entries.map((entry, index) => {
+            const previous = entries[index - 1];
+            const separatorBefore = index > 0 && previous?.group !== entry.group;
+            if (entry.kind === 'path') {
+                const path = [...parentPath, entry.child.id];
+                const presentationId = `hierarchy.menu.path:${path.map(segment => encodeURIComponent(segment)).join('/')}`;
+                if (operationIds.has(presentationId)) {
+                    throw new Error(`Hierarchy operation id conflicts with menu presentation id: ${presentationId}.`);
+                }
+                return {
+                    id: presentationId,
+                    label: entry.child.label,
+                    separatorBefore,
+                    children: materialize(entry.child, path),
+                };
+            }
+            const operation = entry.operation;
+            return {
+                id: operation.id, label: operation.label, shortcut: operation.shortcut, danger: operation.danger,
+                disabled: !!operation.disabledReason, disabledReason: operation.disabledReason, separatorBefore,
+            };
+        });
+    };
+    return materialize(root);
+    function resolveHierarchyOperationMenuPresentation(operation) {
+        if (operation.menu !== undefined && operation.menu !== false) {
+            return {
+                path: operation.menu.path ?? [],
+                group: operation.menu.group ?? '',
+                order: operation.menu.order ?? 0,
+            };
+        }
+        const placement = operation.placement ?? 'bottom';
+        const placementOrder = {
+            top: -100,
+            'after-primary': 5,
+            'after-edit': 15,
+            'after-create': 25,
+            'after-clipboard': 45,
+            bottom: 100,
+        };
+        return { path: [], group: `legacy:${placement}`, order: placementOrder[placement] };
+    }
+}
+export function createHierarchyToolbarCreateMenuItems(operations) {
+    const createOperations = operations.flatMap(operation => {
+        if (operation.menu === false || !operation.menu?.path?.length || operation.menu.path[0]?.id !== 'create')
+            return [];
+        return [{
+                ...operation,
+                menu: {
+                    ...operation.menu,
+                    path: operation.menu.path.slice(1),
+                },
+            }];
+    });
+    return createHierarchyOperationMenuItems(createOperations);
+}
+export function canUseHierarchyProviderReparent(model, operationAvailable = model?.operations.some(operation => operation.id === 'hierarchy.node.reparent') === true) {
+    return !!model
+        && !model.snapshot.readonly
+        && model.snapshot.capabilities.reparent === true
+        && operationAvailable;
+}
+export function matchesHierarchyOperationShortcut(event, shortcut) {
+    const tokens = shortcut.toLowerCase().split('+').map(token => token.trim()).filter(Boolean);
+    const keyToken = tokens[tokens.length - 1];
+    if (!keyToken)
+        return false;
+    const primary = event.metaKey || event.ctrlKey;
+    if (tokens.includes('ctrl/cmd') !== primary)
+        return false;
+    if (tokens.includes('alt') !== event.altKey)
+        return false;
+    if (tokens.includes('shift') !== event.shiftKey)
+        return false;
+    const key = event.key.toLowerCase();
+    return keyToken === 'delete'
+        ? key === 'delete' || key === 'backspace'
+        : keyToken === key;
 }
 export function createLocalEditorHierarchyController(options) {
-    const { doc, panel, callbacks, inputRouter, contextMenu, getState, requestRender } = options;
-    const collapsedIdsByScope = new Map();
-    const hierarchySearchByScope = new Map();
-    let hierarchyRename = null;
-    let hierarchyDrag = null;
-    let hierarchyDrop = null;
+    const { doc, panel, inputRouter, contextMenu, getState, requestRender, kernel } = options;
     let hierarchyRootDrop = false;
     const hierarchyDragSession = createLocalEditorStructuredDragSession();
     let hierarchyShortcutScopeActive = false;
-    let hierarchyClipboard = null;
-    let hierarchySearchComposing = false;
-    let currentModel = null;
+    let hierarchySearchComposition = null;
+    let hierarchyRenameComposition = null;
+    let nativeHierarchyDragActive = false;
     let lastRenderedActiveId;
     let lastRenderedScopeId;
-    let lastRenderedDocumentRevision = null;
-    let lastRenderedProjectionRevision = null;
-    let lastRenderedCommandPrecondition = null;
-    let attachDialogPrecondition = null;
     let pendingHierarchyScrollId = null;
-    let hierarchySelectionAnchorId = null;
-    const attachDialog = createLocalEditorHierarchyAttachDialog({
-        doc,
-        getTheme: resolveActiveTheme,
-        onOpenChange: open => inputRouter.setModalOpen(open, 'hierarchy-attach'),
-        onConfirm: selection => submitAttachSelection(selection),
-    });
+    let currentBridgeState = null;
+    let currentKernelViewModel = null;
+    let cachedVisibleIds = null;
+    let renderedHierarchyAuthority = null;
+    let renderedHierarchyProjection = null;
+    let renderedHierarchyDragId = null;
+    let hierarchyRenderReplacingRenameInput = false;
+    let pendingHierarchyDragOver = null;
+    let hierarchyDragOverFrame = null;
+    let hierarchyViewportRectFrame = -1;
+    let hierarchyViewportRect = null;
+    let hierarchyHoverExpandTimer = null;
+    let hierarchyHoverExpandId = null;
+    let lastHierarchyDropPreviewKey = '';
+    function cancelPendingHierarchyDragOver() {
+        if (hierarchyDragOverFrame !== null)
+            doc.defaultView?.cancelAnimationFrame(hierarchyDragOverFrame);
+        hierarchyDragOverFrame = null;
+        pendingHierarchyDragOver = null;
+    }
     const treeViewportReveal = createLocalEditorViewportRevealController({
         getViewport: findHierarchyTreeViewport,
         margin: 4,
     });
-    const getModel = (state) => {
-        if (currentModel)
-            return currentModel;
-        currentModel = createModel(state);
-        return currentModel;
-    };
-    const render = (state) => {
-        const rawScope = resolveScope(state);
-        const projection = isLocalEditorHierarchyProjectionCurrent(state.hierarchyProjection, rawScope)
-            ? state.hierarchyProjection
-            : createLocalEditorHierarchyProjection(rawScope);
-        const scope = {
-            ...rawScope,
-            nodes: projection.nodes,
-            selectedIds: projection.selectedIds,
-            activeId: projection.activeId,
-            readonly: rawScope.readonly || !projection.interactive,
-            commandSurface: projection.interactive ? rawScope.commandSurface : 'readonly',
-        };
-        const projectionChanged = lastRenderedScopeId != null && (scope.scopeId !== lastRenderedScopeId
-            || scope.documentRevision !== lastRenderedDocumentRevision
-            || scope.projectionRevision !== lastRenderedProjectionRevision);
-        if (projectionChanged)
-            resetHierarchyTransientState();
-        const commandAdapter = resolveHierarchyCommandAdapter(scope);
-        if (hierarchyRename && !scope.nodes.some(item => item.id === hierarchyRename?.id))
-            hierarchyRename = null;
+    const renderPanel = (state) => {
+        const scope = resolveScope(state);
+        const toolbarOperations = currentKernelViewModel
+            ? kernel.listOperations({
+                scopeKey: currentKernelViewModel.snapshot.scopeKey,
+                expectedRevision: currentKernelViewModel.snapshot.revision,
+                contextNodeId: null,
+                targetIds: [],
+                activeId: currentKernelViewModel.snapshot.activeId,
+            }, currentKernelViewModel.authorityToken)
+            : [];
         const scopeChanged = scope.scopeId !== lastRenderedScopeId;
+        if (scopeChanged) {
+            hierarchySearchComposition = null;
+            hierarchyRenameComposition = null;
+            clearHierarchyDragFeedback();
+        }
         const activeIdChanged = scope.activeId !== lastRenderedActiveId || scopeChanged;
         const treeScrollSnapshot = treeViewportReveal.captureScrollSnapshot();
+        const activeRenameInput = doc.activeElement instanceof HTMLInputElement
+            && doc.activeElement.dataset.editorHierarchyRenameInput
+            ? doc.activeElement
+            : null;
+        const renameFocus = activeRenameInput
+            ? {
+                id: activeRenameInput.dataset.editorHierarchyRenameInput,
+                start: activeRenameInput.selectionStart,
+                end: activeRenameInput.selectionEnd,
+                direction: activeRenameInput.selectionDirection,
+            }
+            : null;
+        const activeSearchInput = doc.activeElement instanceof HTMLInputElement
+            && doc.activeElement.dataset.editorHierarchySearch != null
+            ? doc.activeElement
+            : null;
+        const searchFocus = activeSearchInput
+            ? {
+                start: activeSearchInput.selectionStart,
+                end: activeSearchInput.selectionEnd,
+                direction: activeSearchInput.selectionDirection,
+            }
+            : null;
         if (activeIdChanged) {
             pendingHierarchyScrollId = null;
-            expandActiveHierarchyPath(state, scope);
+            lastRenderedActiveId = scope.activeId;
+            lastRenderedScopeId = scope.scopeId;
+        }
+        hierarchyRenderReplacingRenameInput = renameFocus !== null;
+        try {
+            renderLocalEditorHierarchyPanel(doc, panel, {
+                viewModel: currentKernelViewModel,
+                presentationRevision: `${currentKernelViewModel.snapshot.structureRevision}:${JSON.stringify(currentKernelViewModel.snapshot.capabilities)}`,
+                rename: currentKernelViewModel?.snapshot.scopeKey === scope.scopeId
+                    ? currentKernelViewModel.state.rename
+                    : null,
+                dragId: currentKernelViewModel?.snapshot.scopeKey === scope.scopeId
+                    ? currentKernelViewModel.state.dragId
+                    : null,
+                dropPreview: hierarchyDragSession.preview,
+                rootDrop: hierarchyRootDrop,
+                searchQuery: currentKernelViewModel?.snapshot.scopeKey === scope.scopeId
+                    ? currentKernelViewModel.state.searchQuery
+                    : getScopeSearch(scope.scopeId),
+                title: scope.title,
+                searchPlaceholder: scope.searchPlaceholder,
+                showCreateMenu: createHierarchyToolbarCreateMenuItems(toolbarOperations).length > 0,
+            });
+            if (renameFocus) {
+                const replacement = [...panel.querySelectorAll('[data-editor-hierarchy-rename-input]')]
+                    .find(input => input.dataset.editorHierarchyRenameInput === renameFocus.id);
+                replacement?.focus({ preventScroll: true });
+                if (replacement && renameFocus.start !== null && renameFocus.end !== null) {
+                    replacement.setSelectionRange(renameFocus.start, renameFocus.end, renameFocus.direction ?? undefined);
+                }
+            }
+            if (searchFocus) {
+                const replacement = panel.querySelector('input[data-editor-hierarchy-search]');
+                replacement?.focus({ preventScroll: true });
+                if (replacement && searchFocus.start !== null && searchFocus.end !== null) {
+                    replacement.setSelectionRange(searchFocus.start, searchFocus.end, searchFocus.direction ?? undefined);
+                }
+            }
         }
-        currentModel = createModel(state, scope);
-        if (hierarchySelectionAnchorId && !currentModel.getNode(hierarchySelectionAnchorId)) {
-            hierarchySelectionAnchorId = null;
+        finally {
+            hierarchyRenderReplacingRenameInput = false;
         }
-        renderLocalEditorHierarchyPanel(doc, panel, {
-            model: currentModel,
-            rename: hierarchyRename,
-            drop: hierarchyDrop,
-            dropPreview: hierarchyDragSession.preview,
-            rootDrop: hierarchyRootDrop,
-            searchQuery: getScopeSearch(scope.scopeId),
-            title: scope.title,
-            searchPlaceholder: scope.searchPlaceholder,
-            showCreateGroup: commandAdapter.showCreateGroupToolbar,
-            showCreateMarker: commandAdapter.kind === 'scene',
-        });
         treeViewportReveal.restoreScrollSnapshot(treeScrollSnapshot);
         const suppressActiveScroll = scope.activeId
             ? treeViewportReveal.consumeRevealSuppression(scope.activeId, { clearWhenDifferent: activeIdChanged })
@@ -110,16 +260,122 @@ export function createLocalEditorHierarchyController(options) {
         }
         lastRenderedActiveId = scope.activeId;
         lastRenderedScopeId = scope.scopeId;
-        lastRenderedDocumentRevision = scope.documentRevision;
-        lastRenderedProjectionRevision = scope.projectionRevision;
-        lastRenderedCommandPrecondition = createHierarchyCommandPrecondition(scope);
+    };
+    const hierarchyViewAdapter = createLocalEditorHierarchyViewAdapter(model => {
+        currentKernelViewModel = model;
+        if (currentBridgeState && model) {
+            const compositionActive = (hierarchySearchComposition?.scopeKey === model.snapshot.scopeKey
+                && panel.contains(hierarchySearchComposition.input)) || (hierarchyRenameComposition?.scopeKey === model.snapshot.scopeKey
+                && panel.contains(hierarchyRenameComposition.input));
+            if (shouldDeferHierarchyDomRender({
+                renderedAuthority: renderedHierarchyAuthority,
+                renderedProjection: renderedHierarchyProjection,
+                renderedDragId: renderedHierarchyDragId,
+                model,
+                nativeDragActive: nativeHierarchyDragActive,
+                compositionActive,
+            })) {
+                return;
+            }
+            if (renderedHierarchyAuthority
+                && !isHierarchyRenderedAuthorityCurrent(renderedHierarchyAuthority, model)) {
+                nativeHierarchyDragActive = false;
+                hierarchySearchComposition = null;
+                hierarchyRenameComposition = null;
+                clearHierarchyDragFeedback();
+            }
+            // Invalidate the old DOM before attempting replacement. If rendering
+            // throws, events from that old DOM cannot retain write authority.
+            renderedHierarchyAuthority = null;
+            renderedHierarchyProjection = null;
+            renderPanel(currentBridgeState);
+            renderedHierarchyAuthority = Object.freeze({
+                token: model.authorityToken,
+                scopeKey: model.snapshot.scopeKey,
+                revision: model.snapshot.revision,
+            });
+            renderedHierarchyProjection = model.projection;
+            renderedHierarchyDragId = model.state.dragId;
+        }
+        else if (!model) {
+            panel.textContent = '';
+            const unavailable = doc.createElement('div');
+            unavailable.textContent = 'Hierarchy scope unavailable.';
+            unavailable.style.cssText = 'padding:12px;color:var(--fps-editor-muted);font-size:11px';
+            panel.appendChild(unavailable);
+            renderedHierarchyAuthority = null;
+            renderedHierarchyProjection = null;
+            renderedHierarchyDragId = null;
+        }
+    });
+    const detachKernelView = kernel.attachView(hierarchyViewAdapter.adapter);
+    const dispatchHierarchyIntent = async (intent) => {
+        const authority = renderedHierarchyAuthority;
+        const result = await hierarchyViewAdapter.dispatch({
+            ...intent,
+            expectedAuthorityToken: authority?.token ?? -1,
+            expectedScopeKey: authority?.scopeKey ?? '',
+            expectedRevision: authority?.revision ?? -1,
+        });
+        if (!result.ok || result.diagnostics.length > 0)
+            options.onOperationResult?.(result);
+        return result;
+    };
+    const executeCurrentHierarchyOperation = (operationId, input, context) => {
+        const model = currentKernelViewModel;
+        const authority = renderedHierarchyAuthority;
+        if (!model || !authority
+            || model.authorityToken !== authority.token
+            || model.snapshot.scopeKey !== authority.scopeKey
+            || model.snapshot.revision !== authority.revision) {
+            return Promise.resolve({
+                ok: false,
+                changed: false,
+                revision: model?.snapshot.revision ?? 0,
+                diagnostics: [{ code: 'hierarchy.operation.view-authority-changed', message: 'Hierarchy view authority changed.', severity: 'error' }],
+            });
+        }
+        return dispatchHierarchyIntent({
+            type: 'operation.execute',
+            operationId,
+            expectedAuthorityToken: authority.token,
+            context: {
+                scopeKey: authority.scopeKey,
+                expectedRevision: authority.revision,
+                contextNodeId: context?.contextNodeId === undefined ? model.snapshot.activeId : context.contextNodeId,
+                targetIds: context?.targetIds ?? model.snapshot.selectedIds,
+                activeId: context?.activeId === undefined ? model.snapshot.activeId : context.activeId,
+            },
+            ...(input ? { input } : {}),
+        });
+    };
+    const executePresentedHierarchyOperation = async (operation, context, expectedAuthorityToken) => {
+        let input = operation.payload;
+        if (operation.inputPresentation) {
+            const requested = await options.requestOperationInput?.(operation, context) ?? null;
+            if (!requested)
+                return;
+            if (!isHierarchyMenuAuthorityCurrent(kernel.getViewModel(), expectedAuthorityToken, context))
+                return;
+            input = Object.freeze({ ...(operation.payload ?? {}), ...requested });
+        }
+        await dispatchHierarchyIntent({
+            type: 'operation.execute',
+            operationId: operation.id,
+            expectedAuthorityToken,
+            context,
+            ...(input ? { input } : {}),
+        });
+    };
+    const render = (state) => {
+        currentBridgeState = state;
+        kernel.refresh();
     };
     const onClick = (event) => {
         const target = event.target instanceof HTMLElement ? event.target : null;
         if (target?.closest('[data-editor-hierarchy-rename-input]'))
             return;
         if (target?.closest('input[data-editor-hierarchy-search]')) {
-            clearSelectionFromSearchClick(event);
             return;
         }
         const enabledToggle = target?.closest('[data-editor-hierarchy-enabled-toggle]');
@@ -137,32 +393,11 @@ export function createLocalEditorHierarchyController(options) {
             toggleExpanded(toggle);
             return;
         }
-        const createGroupButton = target?.closest('[data-editor-hierarchy-create-group]');
-        if (createGroupButton) {
-            const state = getState();
-            if (!state)
-                return;
-            const scope = resolveScope(state);
-            if (hasCurrentHierarchyProjection(scope) && scope.commandSurface !== 'scene-graph')
-                return;
-            const parentId = resolveLocalEditorHierarchyToolbarActiveId(scope);
-            if (parentId)
-                expandNode(parentId);
-            const precondition = lastRenderedCommandPrecondition;
-            if (!precondition)
-                return;
-            callbacks.onSceneGraphCreateGroup?.({
-                parentId,
-                activeId: parentId,
-                name: 'Empty',
-            }, precondition);
-            return;
-        }
-        const createMarkerButton = target?.closest('[data-editor-hierarchy-create-marker]');
-        if (createMarkerButton) {
+        const createMenuButton = target?.closest('[data-editor-hierarchy-create-menu]');
+        if (createMenuButton) {
             event.preventDefault();
             event.stopPropagation();
-            createHierarchyMarkerFromButton();
+            openHierarchyCreateMenu(createMenuButton);
             return;
         }
         const hierarchyButton = target?.closest('[data-editor-hierarchy-id]');
@@ -178,12 +413,11 @@ export function createLocalEditorHierarchyController(options) {
         }
         if (shouldClearSelectionFromBlankClick(event, target)) {
             event.preventDefault();
-            hierarchySelectionAnchorId = null;
-            submitSelectionCommand({ type: 'selection.clear', label: 'Clear Selection' }, getState() ?? undefined);
+            void dispatchHierarchyIntent({ type: 'selection', targetId: null, modifier: 'replace' });
         }
     };
     const onContextMenu = (event) => {
-        openHierarchyContextMenu(event);
+        void openHierarchyContextMenu(event);
     };
     const onDocumentPointerDown = (event) => {
         hierarchyShortcutScopeActive = isEventInsideHierarchyPanel(event);
@@ -201,45 +435,53 @@ export function createLocalEditorHierarchyController(options) {
             return;
         event.preventDefault();
         event.stopPropagation();
-        hierarchySelectionAnchorId = id;
-        selectSingleHierarchyItem(id);
-        if (resolveScopeForCurrentState()?.kind === 'scene')
-            callbacks.onFocusSelection?.();
+        void (async () => {
+            const selection = await dispatchHierarchyIntent({ type: 'selection', targetId: id, modifier: 'replace' });
+            if (!selection.ok)
+                return;
+            kernel.refresh();
+            const refreshed = kernel.getViewModel()?.snapshot;
+            if (!refreshed || !refreshed.selectedIds.includes(id) || refreshed.activeId !== id)
+                return;
+            if (!refreshed.primaryOperationId)
+                return;
+            await dispatchHierarchyIntent({ type: 'primary', targetId: id });
+        })();
     };
     const onInput = (event) => {
         const input = event.target instanceof HTMLInputElement ? event.target : null;
         if (input?.dataset.editorHierarchySearch != null) {
-            const scopeId = resolveScopeForCurrentState()?.scopeId ?? 'scene';
-            hierarchySearchByScope.set(scopeId, input.value);
-            if (!hierarchySearchComposing && !isComposingInputEvent(event))
-                requestRender();
+            if (!isHierarchyCompositionSessionCurrent(hierarchySearchComposition, input, resolveCurrentScopeKey())
+                && !isComposingInputEvent(event)) {
+                void dispatchHierarchyIntent({ type: 'search.change', value: input.value });
+            }
             return;
         }
-        if (!input?.dataset.editorHierarchyRenameInput || !hierarchyRename)
-            return;
-        hierarchyRename = {
-            id: input.dataset.editorHierarchyRenameInput,
-            value: input.value,
-            initialValue: hierarchyRename.initialValue,
-            commandTargetId: hierarchyRename.commandTargetId,
-            precondition: hierarchyRename.precondition,
-        };
+        if (!input?.dataset.editorHierarchyRenameInput || !currentKernelViewModel?.state.rename)
+            return;
+        if (isHierarchyCompositionSessionCurrent(hierarchyRenameComposition, input, resolveCurrentScopeKey())
+            || isComposingInputEvent(event))
+            return;
+        void dispatchHierarchyIntent({ type: 'rename.change', value: input.value });
     };
     const onKeyDown = (event) => {
         const input = event.target instanceof HTMLInputElement ? event.target : null;
         if (input?.dataset.editorHierarchySearch != null) {
-            if (event.isComposing || hierarchySearchComposing)
+            if (event.isComposing
+                || isHierarchyCompositionSessionCurrent(hierarchySearchComposition, input, resolveCurrentScopeKey()))
                 return;
             const scopeId = resolveScopeForCurrentState()?.scopeId ?? 'scene';
             if (event.key !== 'Escape' || getScopeSearch(scopeId).length === 0)
                 return;
             event.preventDefault();
-            hierarchySearchByScope.set(scopeId, '');
-            requestRender();
+            void dispatchHierarchyIntent({ type: 'search.change', value: '' });
             return;
         }
         if (!input?.dataset.editorHierarchyRenameInput)
             return;
+        if (event.isComposing
+            || isHierarchyCompositionSessionCurrent(hierarchyRenameComposition, input, resolveCurrentScopeKey()))
+            return;
         if (event.key === 'Enter') {
             event.preventDefault();
             commitHierarchyRename(input.dataset.editorHierarchyRenameInput, input.value);
@@ -247,29 +489,51 @@ export function createLocalEditorHierarchyController(options) {
         }
         if (event.key === 'Escape') {
             event.preventDefault();
-            hierarchyRename = null;
-            requestRender();
+            void dispatchHierarchyIntent({ type: 'rename.cancel' });
         }
     };
     const onCompositionStart = (event) => {
         const input = event.target instanceof HTMLInputElement ? event.target : null;
-        if (input?.dataset.editorHierarchySearch == null)
-            return;
-        hierarchySearchComposing = true;
+        const scopeKey = resolveCurrentScopeKey();
+        if (input?.dataset.editorHierarchySearch != null)
+            hierarchySearchComposition = { input, scopeKey };
+        if (input?.dataset.editorHierarchyRenameInput)
+            hierarchyRenameComposition = { input, scopeKey };
     };
     const onCompositionEnd = (event) => {
         const input = event.target instanceof HTMLInputElement ? event.target : null;
-        if (input?.dataset.editorHierarchySearch == null)
+        if (input?.dataset.editorHierarchySearch != null) {
+            const isCurrent = isHierarchyCompositionSessionCurrent(hierarchySearchComposition, input, resolveCurrentScopeKey());
+            hierarchySearchComposition = null;
+            if (!isCurrent)
+                return;
+            void dispatchHierarchyIntent({ type: 'search.change', value: input.value });
             return;
-        hierarchySearchComposing = false;
-        const scopeId = resolveScopeForCurrentState()?.scopeId ?? 'scene';
-        hierarchySearchByScope.set(scopeId, input.value);
-        requestRender();
+        }
+        if (!input?.dataset.editorHierarchyRenameInput)
+            return;
+        const isCurrent = isHierarchyCompositionSessionCurrent(hierarchyRenameComposition, input, resolveCurrentScopeKey());
+        hierarchyRenameComposition = null;
+        if (!isCurrent)
+            return;
+        const renameId = input.dataset.editorHierarchyRenameInput;
+        void (async () => {
+            await dispatchHierarchyIntent({ type: 'rename.change', value: input.value });
+            const renameInputs = [...panel.querySelectorAll('[data-editor-hierarchy-rename-input]')];
+            const currentInput = renameInputs.find(candidate => candidate.dataset.editorHierarchyRenameInput === renameId);
+            if (shouldCommitHierarchyRenameAfterCompositionEnd(doc.activeElement, renameInputs, renameId)) {
+                commitHierarchyRename(renameId, currentInput?.value ?? input.value);
+            }
+        })();
     };
     const onFocusOut = (event) => {
         const input = event.target instanceof HTMLInputElement ? event.target : null;
         if (!input?.dataset.editorHierarchyRenameInput)
             return;
+        if (hierarchyRenderReplacingRenameInput)
+            return;
+        if (isHierarchyCompositionSessionCurrent(hierarchyRenameComposition, input, resolveCurrentScopeKey()))
+            return;
         commitHierarchyRename(input.dataset.editorHierarchyRenameInput, input.value);
     };
     const onDragStart = (event) => {
@@ -279,28 +543,44 @@ export function createLocalEditorHierarchyController(options) {
         const id = button?.dataset.editorHierarchyId;
         if (!id || !state)
             return;
-        if (!resolveHierarchyCommandAdapter(resolveScope(state)).menuCapabilities.hasMoveHandler) {
+        const viewModel = currentKernelViewModel;
+        const node = viewModel?.snapshot.nodeById.get(id);
+        if (!viewModel || !node?.draggable || node.editorLocked === true) {
             event.preventDefault();
             return;
         }
-        const model = getModel(state);
-        const node = model.getNode(id);
-        if (!isLocalEditorHierarchyNodeMovable(node)) {
+        const draggedIds = resolveDraggedIds(viewModel, id);
+        if (draggedIds.length === 0) {
             event.preventDefault();
             return;
         }
-        const precondition = lastRenderedCommandPrecondition;
-        if (!precondition) {
+        const authority = renderedHierarchyAuthority;
+        const reparentAvailable = !!authority
+            && viewModel.authorityToken === authority.token
+            && kernel.listOperations({
+                scopeKey: authority.scopeKey,
+                expectedRevision: authority.revision,
+                contextNodeId: id,
+                targetIds: draggedIds,
+                activeId: id,
+            }, authority.token).some(operation => operation.id === 'hierarchy.node.reparent');
+        if (!canUseHierarchyProviderReparent(viewModel, reparentAvailable)) {
             event.preventDefault();
             return;
         }
-        hierarchyDrag = { id, precondition };
-        const draggedIds = resolveDraggedIds(state, model, id);
         event.dataTransfer?.setData('text/plain', draggedIds.join(','));
         if (event.dataTransfer)
             event.dataTransfer.effectAllowed = 'move';
+        nativeHierarchyDragActive = true;
+        void dispatchHierarchyIntent({ type: 'drag.begin', targetId: id });
+        if (currentKernelViewModel?.state.dragId !== id
+            || !sameHierarchyIdSet(draggedIds, currentKernelViewModel.state.dragIds)) {
+            nativeHierarchyDragActive = false;
+            event.preventDefault();
+            return;
+        }
     };
-    const onDragOver = (event) => {
+    const processHierarchyDragOver = (event, frameTime) => {
         const state = getState();
         const target = event.target instanceof HTMLElement ? event.target : null;
         const draggedIds = readDraggedIds(event);
@@ -308,121 +588,138 @@ export function createLocalEditorHierarchyController(options) {
             clearHierarchyDragFeedbackAndRender();
             return;
         }
-        if (!resolveHierarchyCommandAdapter(resolveScope(state)).menuCapabilities.hasMoveHandler) {
+        if (!sameHierarchyIdSet(draggedIds, currentKernelViewModel?.state.dragIds ?? [])) {
+            clearHierarchyDragFeedbackAndRender();
+            return;
+        }
+        if (!nativeHierarchyDragActive || !canUseHierarchyProviderReparent(currentKernelViewModel, true)) {
+            clearHierarchyDragFeedbackAndRender();
+            return;
+        }
+        const viewModel = currentKernelViewModel;
+        if (!viewModel) {
             clearHierarchyDragFeedbackAndRender();
             return;
         }
-        const model = getModel(state);
         if (!isInsideHierarchyTreeViewport(target)) {
             clearHierarchyDragFeedbackAndRender();
             return;
         }
         hierarchyDragSession.pointer = { x: event.clientX, y: event.clientY };
-        updateHierarchyAutoScroll();
-        const operation = resolveHierarchyDragOperation(event, model, draggedIds);
+        const viewportRect = measureHierarchyViewportRect(frameTime);
+        updateHierarchyAutoScroll(viewportRect);
+        const operation = resolveHierarchyDragOperation(event, viewModel, draggedIds, viewportRect);
         if (!operation || operation.status === 'idle') {
             clearHierarchyDragFeedbackAndRender();
             return;
         }
         event.preventDefault();
         hierarchyDragSession.operation = operation;
+        updateHierarchyHoverExpand(operation, viewModel);
         const canSubmitDrop = operation.status === 'valid'
-            && (!!callbacks.onSceneGraphMove || operation.slot?.placement === 'inside');
+            && nativeHierarchyDragActive
+            && canUseHierarchyProviderReparent(currentKernelViewModel, true);
         if (event.dataTransfer)
             event.dataTransfer.dropEffect = canSubmitDrop ? 'move' : 'none';
         if (operation.status !== 'valid' || !operation.slot || !operation.resolution?.ok) {
             hierarchyDragSession.preview = operation.preview;
-            hierarchyDrop = null;
             hierarchyRootDrop = false;
             syncHierarchyDropPreview();
             return;
         }
         if (operation.slot.placement === 'root') {
             hierarchyDragSession.preview = operation.preview;
-            hierarchyDrop = null;
             hierarchyRootDrop = true;
             syncHierarchyDropPreview();
             return;
         }
-        const targetId = operation.slot.targetId;
-        if (!targetId)
-            return;
-        const nextDrop = {
-            draggedId: operation.resolution.draggedIds[0] ?? draggedIds[0],
-            targetId,
-            placement: operation.slot.placement,
-            preserveWorldTransform: true,
-        };
         hierarchyDragSession.preview = operation.preview;
-        hierarchyDrop = nextDrop;
         hierarchyRootDrop = false;
         syncHierarchyDropPreview();
     };
+    const onDragOver = (event) => {
+        if (readDraggedIds(event).length > 0 && isInsideHierarchyTreeViewport(event.target instanceof HTMLElement ? event.target : null)) {
+            event.preventDefault();
+        }
+        pendingHierarchyDragOver = event;
+        if (hierarchyDragOverFrame !== null)
+            return;
+        hierarchyDragOverFrame = doc.defaultView?.requestAnimationFrame(frameTime => {
+            hierarchyDragOverFrame = null;
+            const latest = pendingHierarchyDragOver;
+            pendingHierarchyDragOver = null;
+            if (latest)
+                processHierarchyDragOver(latest, frameTime);
+        }) ?? null;
+        if (hierarchyDragOverFrame === null) {
+            const latest = pendingHierarchyDragOver;
+            pendingHierarchyDragOver = null;
+            if (latest)
+                processHierarchyDragOver(latest);
+        }
+    };
     const onDragLeave = (event) => {
         if (!panel.contains(event.relatedTarget)) {
+            cancelPendingHierarchyDragOver();
             clearHierarchyDragFeedback();
             requestRender();
         }
     };
     const onDragEnd = () => {
-        hierarchyDrag = null;
+        cancelPendingHierarchyDragOver();
+        nativeHierarchyDragActive = false;
+        void dispatchHierarchyIntent({ type: 'drag.cancel' });
         clearHierarchyDragFeedback();
         requestRender();
     };
     const onDrop = (event) => {
+        cancelPendingHierarchyDragOver();
         const state = getState();
         const target = event.target instanceof HTMLElement ? event.target : null;
-        const activeDrag = hierarchyDrag;
         const draggedIds = readDraggedIds(event);
-        if (!state || !activeDrag || draggedIds.length === 0) {
+        if (!state || draggedIds.length === 0) {
             clearHierarchyDragFeedbackAndRender();
             return;
         }
-        const scope = resolveScope(state);
-        if (!resolveHierarchyCommandAdapter(scope).menuCapabilities.hasMoveHandler) {
+        if (!sameHierarchyIdSet(draggedIds, currentKernelViewModel?.state.dragIds ?? [])) {
             clearHierarchyDragFeedbackAndRender();
             return;
         }
-        const model = getModel(state);
-        if (!isInsideHierarchyTreeViewport(target)) {
+        if (!nativeHierarchyDragActive || !canUseHierarchyProviderReparent(currentKernelViewModel, true)) {
             clearHierarchyDragFeedbackAndRender();
             return;
         }
-        const operation = hierarchyDragSession.operation ?? resolveHierarchyDragOperation(event, model, draggedIds);
-        if (!operation || operation.status !== 'valid' || !operation.slot || !operation.resolution?.ok) {
+        const viewModel = currentKernelViewModel;
+        if (!viewModel) {
             clearHierarchyDragFeedbackAndRender();
             return;
         }
-        event.preventDefault();
-        const dropPrecondition = activeDrag.precondition;
-        hierarchyDrag = null;
-        clearHierarchyDragFeedback();
-        if (operation.slot.placement === 'root') {
-            if (scope.commandSurface === 'prefab-composition') {
-                requestRender();
-                return;
-            }
-            submitResolvedRootDrop(operation.resolution, dropPrecondition);
+        if (!isInsideHierarchyTreeViewport(target)) {
+            clearHierarchyDragFeedbackAndRender();
             return;
         }
-        const targetId = operation.slot.targetId;
-        if (!targetId) {
-            requestRender();
+        const operation = resolveHierarchyDragOperation(event, viewModel, draggedIds);
+        if (!operation || operation.status !== 'valid' || !operation.slot || !operation.resolution?.ok) {
+            clearHierarchyDragFeedbackAndRender();
             return;
         }
+        event.preventDefault();
+        nativeHierarchyDragActive = false;
+        const committedDraggedIds = operation.resolution.draggedIds;
+        const dragContextNodeId = currentKernelViewModel?.state.dragId && committedDraggedIds.includes(currentKernelViewModel.state.dragId)
+            ? currentKernelViewModel.state.dragId
+            : committedDraggedIds[0] ?? null;
+        clearHierarchyDragFeedback();
         expandDropParent(operation.resolution);
-        if (scope.commandSurface === 'prefab-composition') {
-            if (operation.slot.placement !== 'inside') {
-                requestRender();
-                return;
-            }
-            if (dropPrecondition) {
-                submitPrefabNodeReparent(scope, operation.resolution.draggedIds[0] ?? draggedIds[0], targetId, dropPrecondition);
-            }
-            requestRender();
-            return;
-        }
-        submitResolvedDrop(operation.resolution, targetId, operation.slot.placement, draggedIds, dropPrecondition);
+        void executeCurrentHierarchyOperation('hierarchy.node.reparent', {
+            draggedIds: committedDraggedIds,
+            targetId: operation.slot.targetId,
+            placement: operation.slot.placement,
+            parentId: operation.resolution.parentId,
+            beforeId: operation.resolution.beforeId,
+            afterId: operation.resolution.afterId,
+            preserveWorldTransform: true,
+        }, { contextNodeId: dragContextNodeId, targetIds: committedDraggedIds, activeId: dragContextNodeId });
     };
     panel.addEventListener('click', onClick);
     panel.addEventListener('contextmenu', onContextMenu);
@@ -448,6 +745,10 @@ export function createLocalEditorHierarchyController(options) {
             return handleEditShortcut(event);
         },
         dispose() {
+            nativeHierarchyDragActive = false;
+            hierarchySearchComposition = null;
+            hierarchyRenameComposition = null;
+            detachKernelView();
             clearHierarchyDragFeedback();
             panel.removeEventListener('click', onClick);
             panel.removeEventListener('contextmenu', onContextMenu);
@@ -462,134 +763,97 @@ export function createLocalEditorHierarchyController(options) {
             panel.removeEventListener('dragleave', onDragLeave);
             panel.removeEventListener('dragend', onDragEnd);
             panel.removeEventListener('drop', onDrop);
+            cancelPendingHierarchyDragOver();
             doc.removeEventListener('pointerdown', onDocumentPointerDown, { capture: true });
             doc.removeEventListener('focusin', onDocumentFocusIn, { capture: true });
-            attachDialog.dispose();
         },
     };
     function handleDeleteShortcut(event) {
-        const state = getState();
-        if (!state)
-            return false;
-        const scope = resolveScope(state);
-        if (scope.kind !== 'scene')
-            return false;
-        const commandAdapter = resolveHierarchyCommandAdapter(scope);
-        const action = createLocalEditorHierarchyDeleteShortcutAction({
-            state,
-            model: getModel(state),
-            ...commandAdapter.menuCapabilities,
-        });
-        if (!action)
-            return false;
-        event.preventDefault();
-        const precondition = lastRenderedCommandPrecondition;
-        if (!precondition)
-            return false;
-        submitHierarchyAction(action, precondition);
-        return true;
+        return handleOperationShortcut(event);
     }
     function handleEditShortcut(event) {
-        const key = event.key.toLowerCase();
-        if (key === 'delete' || key === 'backspace')
-            return handleDeleteShortcut(event);
-        if (event.altKey || (!event.metaKey && !event.ctrlKey))
-            return false;
-        if (key === 'a' && (event.shiftKey || !isHierarchyShortcutScope(event)))
-            return false;
-        const state = getState();
-        if (!state)
-            return false;
-        const scope = resolveScope(state);
-        if (scope.kind !== 'scene')
-            return false;
-        const commandAdapter = resolveHierarchyCommandAdapter(scope);
-        const input = {
-            state,
-            model: getModel(state),
-            clipboardIds: hierarchyClipboard?.ids ?? null,
-            clipboardActiveId: hierarchyClipboard?.activeId ?? null,
-            ...commandAdapter.menuCapabilities,
-        };
-        const action = key === 'd'
-            ? createLocalEditorHierarchyDuplicateShortcutAction(input)
-            : key === 'c'
-                ? createLocalEditorHierarchyCopyShortcutAction(input)
-                : key === 'v'
-                    ? createLocalEditorHierarchyPasteShortcutAction(input)
-                    : key === 'a'
-                        ? createLocalEditorHierarchySelectAllShortcutAction(input)
-                        : null;
-        if (!action)
+        return handleOperationShortcut(event);
+    }
+    function handleOperationShortcut(event) {
+        const operation = currentKernelViewModel?.operations.find(candidate => (!!candidate.shortcut
+            && matchesHierarchyOperationShortcut(event, candidate.shortcut)
+            && (candidate.shortcutScope !== 'hierarchy' || isHierarchyShortcutScope(event))));
+        if (!operation)
             return false;
         event.preventDefault();
-        const precondition = lastRenderedCommandPrecondition;
-        if (!precondition)
-            return false;
-        submitHierarchyAction(action, precondition);
+        if (operation.disabledReason)
+            return true;
+        if (operation.id === 'hierarchy.node.rename') {
+            const targetId = currentKernelViewModel?.snapshot.activeId;
+            if (targetId)
+                beginHierarchyRename(targetId);
+            return true;
+        }
+        const input = operation.id === 'hierarchy.selection.all'
+            ? { visibleIds: currentKernelViewModel
+                    ? currentKernelViewModel.projection.getRange(0, currentKernelViewModel.projection.totalCount - 1)
+                    : [] }
+            : operation.payload;
+        void executeCurrentHierarchyOperation(operation.id, input);
         return true;
     }
     function isComposingInputEvent(event) {
         return event.isComposing === true;
     }
-    function resolveScope(state) {
-        const scope = createLocalEditorActiveHierarchyScope(state);
-        const projection = isLocalEditorHierarchyProjectionCurrent(state.hierarchyProjection, scope)
-            ? state.hierarchyProjection
-            : createLocalEditorHierarchyProjection(scope);
-        return {
-            ...scope,
-            nodes: projection.nodes,
-            selectedIds: projection.selectedIds,
-            activeId: projection.activeId,
-            readonly: scope.readonly || !projection.interactive,
-            commandSurface: projection.interactive ? scope.commandSurface : 'readonly',
-        };
+    function resolveCurrentScopeKey() {
+        return currentKernelViewModel?.snapshot.scopeKey ?? renderedHierarchyAuthority?.scopeKey ?? '';
     }
-    function hasCurrentHierarchyProjection(scope) {
-        return scope.scopeId === lastRenderedScopeId
-            && scope.documentRevision === lastRenderedDocumentRevision
-            && scope.projectionRevision === lastRenderedProjectionRevision;
+    function resolveScope(state) {
+        const snapshot = currentKernelViewModel?.snapshot;
+        return snapshot
+            ? {
+                scopeId: snapshot.scopeKey,
+                revision: snapshot.revision,
+                kind: snapshot.scopeType,
+                title: snapshot.title,
+                searchPlaceholder: snapshot.searchPlaceholder,
+                selectedIds: snapshot.selectedIds,
+                activeId: snapshot.activeId,
+                readonly: snapshot.readonly,
+            }
+            : {
+                scopeId: 'hierarchy:unavailable',
+                revision: 0,
+                kind: 'unavailable',
+                title: 'Hierarchy',
+                searchPlaceholder: 'Hierarchy unavailable',
+                selectedIds: [],
+                activeId: null,
+                readonly: true,
+            };
     }
     function resolveScopeForCurrentState() {
         const state = getState();
         return state ? resolveScope(state) : null;
     }
-    function getScopeCollapsedIds(scopeId) {
-        const existing = collapsedIdsByScope.get(scopeId);
-        if (existing)
-            return existing;
-        const created = new Set();
-        collapsedIdsByScope.set(scopeId, created);
-        return created;
-    }
     function getScopeSearch(scopeId) {
-        return hierarchySearchByScope.get(scopeId) ?? '';
+        if (currentKernelViewModel?.snapshot.scopeKey === scopeId)
+            return currentKernelViewModel.state.searchQuery;
+        return '';
     }
-    function createModel(state, scope = resolveScope(state)) {
-        return createLocalEditorHierarchyTreeModel(scope.nodes, scope.selectedIds, scope.activeId, {
-            collapsedIds: getScopeCollapsedIds(scope.scopeId),
-            defaultExpanded: true,
-        });
+    function resolveVisibleIds() {
+        const projection = currentKernelViewModel?.projection;
+        if (!projection)
+            return [];
+        if (cachedVisibleIds?.projection === projection)
+            return cachedVisibleIds.ids;
+        const ids = projection.getRange(0, projection.totalCount - 1);
+        cachedVisibleIds = { projection, ids };
+        return ids;
     }
     function selectHierarchyItemFromClick(id, event) {
-        const scope = resolveScopeForCurrentState();
-        const precondition = lastRenderedCommandPrecondition;
-        if (!scope || !precondition)
-            return;
-        if (hasCurrentHierarchyProjection(scope) && scope.commandSurface === 'readonly')
-            return;
         const toggle = event.metaKey || event.ctrlKey;
         const range = event.shiftKey && !toggle;
-        if (range) {
-            selectHierarchyVisibleRange(id);
-            return;
-        }
-        hierarchySelectionAnchorId = id;
-        if (precondition.scopeId.startsWith('prefab-stage:'))
-            callbacks.onSelectPrefabStageItem?.(id, precondition);
-        else
-            callbacks.onSelectHierarchyItem?.({ id, additive: false, toggle }, precondition);
+        void dispatchHierarchyIntent({
+            type: 'selection',
+            targetId: id,
+            modifier: range ? 'range' : toggle ? 'toggle' : 'replace',
+        });
     }
     function toggleHierarchyItemEnabled(id, toggle) {
         if (toggle.dataset.editorHierarchyEnabledToggleDisabled === 'true')
@@ -597,114 +861,35 @@ export function createLocalEditorHierarchyController(options) {
         const state = getState();
         if (!state)
             return;
-        const scope = resolveScope(state);
-        if (hasCurrentHierarchyProjection(scope) && scope.commandSurface !== 'scene-graph')
-            return;
-        const node = getModel(state).getNode(id);
-        if (!node || !canLocalEditorHierarchyNodeToggleEnabled(node))
-            return;
-        const directEnabled = typeof node.item.directEnabled === 'boolean'
-            ? node.item.directEnabled
-            : node.item.enabled;
-        const precondition = lastRenderedCommandPrecondition;
-        if (!precondition)
+        const snapshot = currentKernelViewModel?.snapshot;
+        const node = snapshot?.nodeById.get(id);
+        if (!snapshot || !node || node.editorLocked === true)
             return;
-        callbacks.onHierarchyItemEnabledChange?.({
-            id,
-            enabled: directEnabled === false,
-        }, precondition);
+        const directEnabled = node.authoredEnabled ?? node.editorVisible;
+        const request = createHierarchyEnabledOperationRequest(node, directEnabled);
+        void executeCurrentHierarchyOperation(request.operationId, request.input, { contextNodeId: id, targetIds: [id], activeId: id });
     }
-    function selectHierarchyVisibleRange(targetId) {
-        const state = getState();
-        if (!state) {
-            selectSingleHierarchyItem(targetId);
-            hierarchySelectionAnchorId = targetId;
-            return;
-        }
-        const scope = resolveScope(state);
-        if (scope.kind !== 'scene') {
-            hierarchySelectionAnchorId = targetId;
-            const precondition = lastRenderedCommandPrecondition;
-            if (!precondition)
-                return;
-            callbacks.onSelectPrefabStageItem?.(targetId, precondition);
-            return;
-        }
-        const model = getModel(state);
-        const anchorId = hierarchySelectionAnchorId ?? scope.activeId ?? targetId;
-        const selectedIds = model.getVisibleRangeSelection(anchorId, targetId);
-        if (selectedIds.length === 0) {
-            hierarchySelectionAnchorId = targetId;
-            selectSingleHierarchyItem(targetId);
-            return;
-        }
-        const activeId = selectedIds.includes(targetId)
-            ? targetId
-            : selectedIds[selectedIds.length - 1] ?? null;
-        submitSelectionCommand({
-            type: 'selection.replace',
-            label: 'Select Hierarchy Range',
-            selectedIds,
-            activeId,
-        }, state);
-    }
-    function resolveDraggedIds(state, model, draggedId) {
-        const scope = resolveScope(state);
-        const selectedIds = scope.selectedIds.includes(draggedId) ? scope.selectedIds : [draggedId];
-        return model.getTopLevelSelection(selectedIds);
+    function resolveDraggedIds(viewModel, draggedId) {
+        const selectedIds = viewModel.snapshot.selectedIds.includes(draggedId)
+            ? viewModel.snapshot.selectedIds
+            : [draggedId];
+        return [...viewModel.projection.getTopLevelSelection(selectedIds)];
     }
     function readDraggedIds(event) {
-        const dataTransferIds = event.dataTransfer?.getData('text/plain')
-            .split(',')
-            .map(id => id.trim())
-            .filter(Boolean) ?? [];
-        return dataTransferIds.length > 0 ? dataTransferIds : hierarchyDrag?.id ? [hierarchyDrag.id] : [];
-    }
-    function submitResolvedRootDrop(resolved, precondition) {
-        const state = getState();
-        if (!state)
-            return;
-        const scope = resolveScope(state);
-        if (hasCurrentHierarchyProjection(scope) && scope.commandSurface !== 'scene-graph')
-            return;
-        if (!precondition)
-            return;
-        callbacks.onSceneGraphMove?.({
-            ids: resolved.draggedIds,
-            targetId: null,
-            placement: 'root',
-            preserveWorldTransform: true,
-        }, precondition);
-        requestRender();
+        return resolveHierarchyTransportDragIds(event.dataTransfer?.getData('text/plain'), currentKernelViewModel?.state.dragIds ?? []);
     }
     function toggleExpanded(id) {
-        const scope = resolveScopeForCurrentState();
-        const collapsedIds = getScopeCollapsedIds(scope?.scopeId ?? 'scene');
-        if (collapsedIds.has(id))
-            collapsedIds.delete(id);
-        else
-            collapsedIds.add(id);
-        requestRender();
+        void dispatchHierarchyIntent({ type: 'disclosure.toggle', targetId: id });
     }
     function expandNode(id) {
         if (!id)
             return;
-        const scope = resolveScopeForCurrentState();
-        getScopeCollapsedIds(scope?.scopeId ?? 'scene').delete(id);
-    }
-    function expandActiveHierarchyPath(state, scope = resolveScope(state)) {
-        if (!scope.activeId)
-            return;
-        const model = createModel(state, scope);
-        if (!model.getNode(scope.activeId))
-            return;
-        const collapsedIds = getScopeCollapsedIds(scope.scopeId);
-        for (const ancestor of model.getAncestors(scope.activeId)) {
-            collapsedIds.delete(ancestor.id);
-        }
+        void dispatchHierarchyIntent({ type: 'disclosure.expand', targetId: id });
     }
     function shouldAutoScrollActiveHierarchyNode() {
-        return !hierarchyRename && !hierarchyDrag && !hasHierarchyDragFeedback();
+        return !currentKernelViewModel?.state.rename
+            && !currentKernelViewModel?.state.dragId
+            && !hasHierarchyDragFeedback();
     }
     function scheduleActiveHierarchyScroll(activeId) {
         pendingHierarchyScrollId = activeId;
@@ -712,10 +897,23 @@ export function createLocalEditorHierarchyController(options) {
             if (pendingHierarchyScrollId !== activeId)
                 return;
             pendingHierarchyScrollId = null;
-            const row = findHierarchyRow(activeId);
+            const viewport = findHierarchyTreeViewport();
+            let row = findHierarchyRow(activeId);
+            if (!row && viewport && currentKernelViewModel) {
+                const index = currentKernelViewModel.projection.indexOf(activeId);
+                if (index >= 0) {
+                    const rowTop = index * LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT;
+                    const rowBottom = rowTop + LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT;
+                    if (rowTop < viewport.scrollTop)
+                        viewport.scrollTop = rowTop;
+                    else if (rowBottom > viewport.scrollTop + viewport.clientHeight) {
+                        viewport.scrollTop = Math.max(0, rowBottom - viewport.clientHeight);
+                    }
+                    row = findHierarchyRow(activeId);
+                }
+            }
             if (!row)
                 return;
-            const viewport = findHierarchyTreeViewport();
             if (viewport) {
                 treeViewportReveal.revealElement(row, { behavior: 'smooth' });
                 return;
@@ -753,26 +951,44 @@ export function createLocalEditorHierarchyController(options) {
         hierarchyDragSession.autoScrollFrame = null;
     }
     function clearHierarchyDragFeedback() {
-        hierarchyDrop = null;
+        cancelPendingHierarchyDragOver();
         hierarchyRootDrop = false;
+        lastHierarchyDropPreviewKey = '';
         stopHierarchyAutoScroll();
+        clearHierarchyHoverExpand();
         clearLocalEditorStructuredDragSession(hierarchyDragSession);
     }
-    function resetHierarchyTransientState() {
-        hierarchyRename = null;
-        hierarchyDrag = null;
-        hierarchySelectionAnchorId = null;
-        hierarchyClipboard = null;
-        hierarchySearchComposing = false;
-        pendingHierarchyScrollId = null;
-        attachDialogPrecondition = null;
-        clearHierarchyDragFeedback();
-        attachDialog.close();
-        contextMenu.close();
+    function clearHierarchyHoverExpand() {
+        if (hierarchyHoverExpandTimer !== null)
+            doc.defaultView?.clearTimeout(hierarchyHoverExpandTimer);
+        hierarchyHoverExpandTimer = null;
+        hierarchyHoverExpandId = null;
+    }
+    function updateHierarchyHoverExpand(operation, viewModel) {
+        const targetId = operation.status === 'valid' && operation.slot?.placement === 'inside'
+            ? operation.slot.targetId
+            : null;
+        const node = targetId ? viewModel.snapshot.nodeById.get(targetId) : null;
+        const expanded = targetId ? !viewModel.state.collapsedIds.has(targetId) : false;
+        const childCount = targetId ? viewModel.snapshot.childrenByParentId.get(targetId)?.length ?? 0 : 0;
+        if (!targetId || !node || expanded || childCount === 0) {
+            clearHierarchyHoverExpand();
+            return;
+        }
+        if (hierarchyHoverExpandId === targetId && hierarchyHoverExpandTimer !== null)
+            return;
+        clearHierarchyHoverExpand();
+        hierarchyHoverExpandId = targetId;
+        hierarchyHoverExpandTimer = doc.defaultView?.setTimeout(() => {
+            const id = hierarchyHoverExpandId;
+            hierarchyHoverExpandTimer = null;
+            hierarchyHoverExpandId = null;
+            if (id)
+                expandNode(id);
+        }, 600) ?? null;
     }
     function hasHierarchyDragFeedback() {
-        return hierarchyDrop !== null
-            || hierarchyRootDrop
+        return hierarchyRootDrop
             || hasLocalEditorStructuredDragSessionFeedback(hierarchyDragSession);
     }
     function clearHierarchyDragFeedbackAndRender() {
@@ -782,19 +998,28 @@ export function createLocalEditorHierarchyController(options) {
             syncHierarchyDropPreview();
     }
     function syncHierarchyDropPreview() {
+        const preview = hierarchyDragSession.preview;
+        const key = [
+            hierarchyRootDrop, preview?.kind ?? '', preview?.targetId ?? '', preview?.placement ?? '', preview?.valid ?? '',
+        ].join(':');
+        if (key === lastHierarchyDropPreviewKey)
+            return;
+        lastHierarchyDropPreviewKey = key;
         syncLocalEditorHierarchyDropPreview(doc, panel, {
             dropPreview: hierarchyDragSession.preview,
             rootDrop: hierarchyRootDrop,
         });
     }
-    function tickHierarchyAutoScroll() {
+    function tickHierarchyAutoScroll(frameTime) {
         hierarchyDragSession.autoScrollFrame = null;
         if (!hierarchyDragSession.pointer)
             return;
         const viewport = findHierarchyTreeViewport();
         if (!viewport)
             return;
-        const rect = viewport.getBoundingClientRect();
+        const rect = measureHierarchyViewportRect(frameTime);
+        if (!rect)
+            return;
         const scroll = resolveLocalEditorHierarchyAutoScroll({
             pointerY: hierarchyDragSession.pointer.y,
             viewportTop: rect.top,
@@ -810,13 +1035,13 @@ export function createLocalEditorHierarchyController(options) {
             armHierarchyAutoScroll();
         }
     }
-    function updateHierarchyAutoScroll() {
+    function updateHierarchyAutoScroll(measuredRect) {
         const viewport = findHierarchyTreeViewport();
         if (!viewport || !hierarchyDragSession.pointer) {
             stopHierarchyAutoScroll();
             return;
         }
-        const rect = viewport.getBoundingClientRect();
+        const rect = measuredRect ?? viewport.getBoundingClientRect();
         const scroll = resolveLocalEditorHierarchyAutoScroll({
             pointerY: hierarchyDragSession.pointer.y,
             viewportTop: rect.top,
@@ -832,43 +1057,60 @@ export function createLocalEditorHierarchyController(options) {
         }
         armHierarchyAutoScroll();
     }
-    function resolveHierarchyDragOperation(event, model, draggedIds) {
-        const layout = createHierarchyDragLayout(model);
+    function measureHierarchyViewportRect(frameTime) {
+        if (frameTime !== undefined && hierarchyViewportRectFrame === frameTime && hierarchyViewportRect) {
+            return hierarchyViewportRect;
+        }
+        const rect = findHierarchyTreeViewport()?.getBoundingClientRect();
+        if (frameTime !== undefined && rect) {
+            hierarchyViewportRectFrame = frameTime;
+            hierarchyViewportRect = rect;
+        }
+        return rect;
+    }
+    function resolveHierarchyDragOperation(event, viewModel, draggedIds, measuredRect) {
+        const layout = createHierarchyDragLayout(viewModel, measuredRect);
         if (!layout)
             return null;
         return resolveLocalEditorHierarchyDragOperation({
             layout,
             pointer: { x: event.clientX, y: event.clientY },
             draggedIds,
-            resolveDrop: model.resolveDrop.bind(model),
+            resolveDrop: input => viewModel.projection.resolveDrop(input),
         });
     }
-    function createHierarchyDragLayout(model) {
+    function createHierarchyDragLayout(viewModel, measuredRect) {
         const viewport = findHierarchyTreeViewport();
-        if (!viewport)
+        const projection = viewModel.projection;
+        if (!viewport || !projection)
             return null;
-        const viewportRect = viewport.getBoundingClientRect();
+        const viewportRect = measuredRect ?? viewport.getBoundingClientRect();
         const rows = [];
-        for (const element of panel.querySelectorAll('[data-editor-hierarchy-id]')) {
-            const id = element.dataset.editorHierarchyId;
-            const node = model.getNode(id);
-            if (!id || !node)
+        const start = Math.max(0, Math.floor(viewport.scrollTop / LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT));
+        const count = Math.min(projection.totalCount - start, Math.ceil(viewportRect.height / LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT) + 1);
+        for (let offset = 0; offset < Math.max(0, count); offset += 1) {
+            const index = start + offset;
+            const projected = projection.getRow(index);
+            if (!projected)
+                continue;
+            const node = viewModel.snapshot.nodeById.get(projected.id);
+            if (!node)
                 continue;
-            const rect = element.getBoundingClientRect();
+            const canAcceptInside = node.canHaveChildren && node.editorLocked !== true;
             rows.push({
-                id,
-                depth: node.depth,
+                id: projected.id,
+                depth: projected.depth,
                 parentId: node.parentId,
-                canHaveChildren: canLocalEditorHierarchyNodeHaveChildren(node),
+                canHaveChildren: canAcceptInside,
+                canAcceptInside,
                 rect: {
-                    left: rect.left,
-                    top: rect.top,
-                    width: rect.width,
-                    height: rect.height,
+                    left: viewportRect.left,
+                    top: viewportRect.top + index * LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT - viewport.scrollTop,
+                    width: viewportRect.width,
+                    height: LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT,
                 },
             });
         }
-        rows.sort((left, right) => left.rect.top - right.rect.top);
         return {
             rows,
             viewport: {
@@ -885,94 +1127,68 @@ export function createLocalEditorHierarchyController(options) {
             expandNode(resolved.parentId);
     }
     function commitHierarchyRename(id, value) {
-        if (!hierarchyRename || hierarchyRename.id !== id)
+        const rename = currentKernelViewModel?.state.rename;
+        if (!rename || rename.id !== id)
             return;
-        const precondition = hierarchyRename.precondition;
-        const initialValue = hierarchyRename.initialValue;
-        const commandTargetId = hierarchyRename.commandTargetId;
-        const trimmed = value.trim();
-        const state = getState();
-        const scope = state ? resolveScope(state) : null;
-        hierarchyRename = null;
-        if (trimmed && trimmed !== initialValue) {
-            if (!precondition.scopeId.startsWith('prefab-stage:')) {
-                callbacks.onSceneGraphRename?.({ id, name: trimmed }, precondition);
-            }
-            else if (scope) {
-                callbacks.onAssetAction?.(createPrefabNodeAssetAction(scope, 'prefab.node.rename', commandTargetId, {
-                    value: trimmed,
-                }, precondition));
-            }
-        }
-        requestRender();
+        void (async () => {
+            await dispatchHierarchyIntent({ type: 'rename.change', value });
+            await dispatchHierarchyIntent({ type: 'rename.commit' });
+        })();
     }
-    function openHierarchyContextMenu(event) {
+    async function openHierarchyContextMenu(event) {
         const target = inputRouter.claimContextMenu(event);
         const hadHierarchyFeedback = hasHierarchyDragFeedback();
-        hierarchyDrag = null;
         clearHierarchyDragFeedback();
         if (!target) {
             if (hadHierarchyFeedback)
                 requestRender();
             return;
         }
-        const initialState = getState();
-        if (!initialState || initialState.mode !== 'editor' || initialState.busy) {
+        const state = getState();
+        if (!state || state.mode !== 'editor' || state.busy) {
             if (hadHierarchyFeedback)
                 requestRender();
             return;
         }
-        const initialScope = resolveScope(initialState);
-        const initialPrecondition = lastRenderedCommandPrecondition;
-        if (!initialPrecondition)
-            return;
-        const initialModel = getModel(initialState);
+        let scope = resolveScope(state);
         const hierarchyButton = target.closest('[data-editor-hierarchy-id]');
-        const requestedNodeId = hierarchyButton?.dataset.editorHierarchyId;
-        const initialNode = initialModel.getNode(requestedNodeId);
-        if (initialNode && !initialScope.selectedIds.includes(initialNode.id) && isLocalEditorHierarchyNodeSelectable(initialNode)) {
-            hierarchySelectionAnchorId = initialNode.id;
-            if (initialScope.kind === 'prefab-stage')
-                callbacks.onSelectPrefabStageItem?.(initialNode.id, initialPrecondition);
-            else
-                callbacks.onSelectHierarchyItem?.({ id: initialNode.id, additive: false, toggle: false }, initialPrecondition);
-        }
-        const state = getState();
-        if (!state || state.mode !== 'editor' || state.busy)
-            return;
-        const scope = resolveScope(state);
-        const precondition = lastRenderedCommandPrecondition;
-        if (!precondition)
-            return;
-        const commandAdapter = resolveHierarchyCommandAdapter(scope);
-        const model = getModel(state);
-        const node = model.getNode(requestedNodeId);
-        if (!commandAdapter.canOpenContextMenu) {
+        let node = hierarchyButton?.dataset.editorHierarchyId
+            ? currentKernelViewModel?.snapshot.nodeById.get(hierarchyButton.dataset.editorHierarchyId)
+            : undefined;
+        if (node && !scope.selectedIds.includes(node.id) && node.selectable && node.editorLocked !== true) {
+            const selection = await dispatchHierarchyIntent({ type: 'selection', targetId: node.id, modifier: 'replace' });
+            if (!selection.ok)
+                return;
+            kernel.refresh();
+            const refreshedState = getState() ?? state;
+            scope = resolveScope(refreshedState);
+            if (!scope.selectedIds.includes(node.id) || scope.activeId !== node.id)
+                return;
+            node = hierarchyButton?.dataset.editorHierarchyId
+                ? currentKernelViewModel?.snapshot.nodeById.get(hierarchyButton.dataset.editorHierarchyId)
+                : undefined;
+        }
+        const operationContext = Object.freeze({
+            scopeKey: scope.scopeId,
+            expectedRevision: scope.revision,
+            contextNodeId: node?.id ?? null,
+            targetIds: Object.freeze([...scope.selectedIds]),
+            activeId: scope.activeId,
+        });
+        const expectedAuthorityToken = renderedHierarchyAuthority?.token;
+        const providerOperations = kernel.listOperations(operationContext, expectedAuthorityToken);
+        if (expectedAuthorityToken === undefined
+            || currentKernelViewModel?.authorityToken !== expectedAuthorityToken
+            || currentKernelViewModel.snapshot.scopeKey !== operationContext.scopeKey
+            || currentKernelViewModel.snapshot.revision !== operationContext.expectedRevision)
+            return;
+        if (providerOperations.length === 0) {
             if (hadHierarchyFeedback)
                 requestRender();
             return;
         }
         options.onBeforeOpenContextMenu?.();
-        const menuState = createScopedHierarchyMenuState(state, scope);
-        const menu = node
-            ? createLocalEditorHierarchyNodeMenu({
-                state: menuState,
-                model,
-                node,
-                clipboardIds: hierarchyClipboard?.ids ?? null,
-                clipboardActiveId: hierarchyClipboard?.activeId ?? null,
-                ...commandAdapter.menuCapabilities,
-                contextActions: options.contextActions,
-            })
-            : createLocalEditorHierarchyBlankMenu({
-                state: menuState,
-                model,
-                clipboardIds: hierarchyClipboard?.ids ?? null,
-                clipboardActiveId: hierarchyClipboard?.activeId ?? null,
-                ...commandAdapter.menuCapabilities,
-                contextActions: options.contextActions,
-            });
-        const menuItems = commandAdapter.filterMenuItems(menu.items);
+        const menuItems = createHierarchyOperationMenuItems(providerOperations);
         if (menuItems.length === 0) {
             if (hadHierarchyFeedback)
                 requestRender();
@@ -983,198 +1199,88 @@ export function createLocalEditorHierarchyController(options) {
             y: event.clientY,
             items: menuItems,
             onAction(item) {
-                const action = menu.actions.get(item.id);
-                if (action)
-                    submitHierarchyAction(action, precondition);
+                if (!isHierarchyMenuAuthorityCurrent(kernel.getViewModel(), expectedAuthorityToken, operationContext))
+                    return;
+                const operation = providerOperations.find(candidate => candidate.id === item.id);
+                if (operation) {
+                    if (operation.id === 'hierarchy.node.rename' && operationContext.contextNodeId) {
+                        const latest = kernel.getViewModel();
+                        if (latest?.authorityToken === expectedAuthorityToken
+                            && latest.snapshot.scopeKey === operationContext.scopeKey
+                            && latest.snapshot.revision === operationContext.expectedRevision) {
+                            beginHierarchyRename(operationContext.contextNodeId);
+                        }
+                        return;
+                    }
+                    void executePresentedHierarchyOperation(operation, operationContext, expectedAuthorityToken);
+                }
             },
         });
         if (hadHierarchyFeedback)
             requestRender();
     }
-    function createHierarchyMarkerFromButton() {
+    function openHierarchyCreateMenu(button) {
         const state = getState();
         if (!state || state.mode !== 'editor' || state.busy)
             return;
-        const scope = resolveScope(state);
-        if (hasCurrentHierarchyProjection(scope) && scope.commandSurface !== 'scene-graph')
-            return;
-        const precondition = lastRenderedCommandPrecondition;
-        if (!precondition)
-            return;
-        const model = getModel(state);
-        const toolbarActiveId = resolveLocalEditorHierarchyToolbarActiveId(scope);
-        const activeNode = model.getNode(toolbarActiveId);
-        const parentId = resolveLocalEditorHierarchyCreateMarkerParentId(activeNode);
-        if (parentId)
-            expandNode(parentId);
-        callbacks.onSceneGraphCreateMarker?.({
-            parentId,
-            activeId: parentId ?? toolbarActiveId,
-            name: 'Marker',
-        }, precondition);
-        requestRender();
-    }
-    function submitHierarchyAction(action, precondition) {
-        const state = getState();
-        if (!state || !precondition)
-            return;
-        const scope = resolveScope(state);
-        if (hasCurrentHierarchyProjection(scope) && scope.commandSurface === 'readonly')
-            return;
-        if (action.kind === 'begin-rename') {
-            beginHierarchyRename(action.targetId, precondition);
-            return;
-        }
-        if (action.kind === 'copy-selection') {
-            hierarchyClipboard = {
-                ids: action.targetIds,
-                activeId: action.activeId && action.targetIds.includes(action.activeId)
-                    ? action.activeId
-                    : action.targetIds[action.targetIds.length - 1] ?? null,
-            };
-            return;
-        }
-        if (action.kind === 'group-selection') {
-            callbacks.onSceneGraphGroupSelection?.(action.intent, precondition);
-            return;
-        }
-        if (action.kind === 'open-attach-picker') {
-            openAttachPicker(action.targetIds, action.activeId, precondition);
-            return;
-        }
-        if (action.kind === 'selection-command') {
-            submitSelectionCommand(action.command, state, precondition);
-            return;
-        }
-        submitHierarchyContextAction(action.action, precondition);
-    }
-    function createScopedHierarchyMenuState(state, scope) {
-        return {
-            ...state,
-            hierarchy: scope.nodes,
-            selectedIds: scope.selectedIds,
-            activeId: scope.activeId,
-        };
-    }
-    function submitSelectionCommand(command, state = getState() ?? undefined, precondition = lastRenderedCommandPrecondition) {
-        if (!state)
+        const model = currentKernelViewModel;
+        if (!model)
             return;
         const scope = resolveScope(state);
-        if (!precondition)
-            return;
-        if (hasCurrentHierarchyProjection(scope) && scope.kind !== 'scene')
-            return;
-        callbacks.onSelectionCommand?.(command, precondition);
-    }
-    function openAttachPicker(targetIds, activeId, precondition = lastRenderedCommandPrecondition) {
-        const state = getState();
-        if (!state || !precondition || state.mode !== 'editor' || state.busy || targetIds.length === 0)
+        const activeNode = model.snapshot.activeId
+            ? model.snapshot.nodeById.get(model.snapshot.activeId)
+            : undefined;
+        const parentNode = activeNode?.canHaveChildren === true && activeNode.editorLocked !== true
+            ? activeNode
+            : undefined;
+        const operationContext = Object.freeze({
+            scopeKey: scope.scopeId,
+            expectedRevision: scope.revision,
+            contextNodeId: parentNode?.id ?? null,
+            targetIds: Object.freeze(parentNode ? [parentNode.id] : []),
+            activeId: parentNode?.id ?? scope.activeId,
+        });
+        const expectedAuthorityToken = renderedHierarchyAuthority?.token;
+        const operations = kernel.listOperations(operationContext, expectedAuthorityToken);
+        if (expectedAuthorityToken === undefined
+            || !isHierarchyMenuAuthorityCurrent(model, expectedAuthorityToken, operationContext))
             return;
-        if (!resolveHierarchyCommandAdapter(resolveScope(state)).menuCapabilities.hasMoveHandler)
+        const items = createHierarchyToolbarCreateMenuItems(operations);
+        if (items.length === 0)
             return;
-        attachDialogPrecondition = precondition;
-        attachDialog.open({
-            model: getModel(state),
-            targetIds,
-            activeId,
+        options.onBeforeOpenContextMenu?.();
+        const rect = button.getBoundingClientRect();
+        contextMenu.open({
+            x: rect.left,
+            y: rect.bottom,
+            items,
+            onAction(item) {
+                if (!isHierarchyMenuAuthorityCurrent(kernel.getViewModel(), expectedAuthorityToken, operationContext))
+                    return;
+                hierarchyShortcutScopeActive = true;
+                const operation = operations.find(candidate => candidate.id === item.id);
+                if (!operation)
+                    return;
+                if (parentNode)
+                    expandNode(parentNode.id);
+                void executePresentedHierarchyOperation(operation, operationContext, expectedAuthorityToken);
+            },
         });
     }
-    function submitAttachSelection(selection) {
-        const state = getState();
-        const precondition = attachDialogPrecondition;
-        attachDialogPrecondition = null;
-        if (!state || !precondition || state.mode !== 'editor' || state.busy)
-            return { ok: false, reason: 'Editor is not ready.' };
-        const scope = resolveScope(state);
-        if (scope.commandSurface === 'prefab-composition') {
-            return submitPrefabAttachSelection(scope, selection, precondition);
-        }
-        if (scope.commandSurface !== 'scene-graph')
-            return { ok: false, reason: 'Hierarchy move pipeline is not connected yet.' };
-        const ids = selection.resolution.draggedIds;
-        if (ids.length === 0)
-            return { ok: false, reason: 'Select one or more movable nodes first.' };
-        if (!callbacks.onSceneGraphMove)
-            return { ok: false, reason: 'Hierarchy move pipeline is not connected yet.' };
-        if (selection.placement === 'root') {
-            const result = normalizeAttachSceneGraphMoveResult(callbacks.onSceneGraphMove({
-                ids,
-                placement: 'root',
-                preserveWorldTransform: true,
-            }, precondition));
-            requestRender();
-            return result;
-        }
-        if (!selection.targetId)
-            return { ok: false, reason: 'Select a valid target first.' };
-        expandNode(selection.targetId);
-        const result = normalizeAttachSceneGraphMoveResult(callbacks.onSceneGraphMove({
-            ids,
-            targetId: selection.targetId,
-            placement: 'inside',
-            parentId: selection.resolution.parentId,
-            beforeId: selection.resolution.beforeId,
-            afterId: selection.resolution.afterId,
-            preserveWorldTransform: true,
-        }, precondition));
-        requestRender();
-        return result;
-    }
-    function submitPrefabAttachSelection(scope, selection, precondition) {
-        const ids = selection.resolution.draggedIds;
-        if (ids.length !== 1)
-            return { ok: false, reason: 'Move one prefab node at a time.' };
-        if (selection.placement !== 'inside')
-            return { ok: false, reason: 'Prefab node reparent supports inside placement only.' };
-        if (!selection.targetId)
-            return { ok: false, reason: 'Select a valid prefab parent first.' };
-        if (!submitPrefabNodeReparent(scope, ids[0], selection.targetId, precondition)) {
-            return { ok: false, reason: 'Select valid prefab nodes first.' };
-        }
-        expandNode(selection.targetId);
-        requestRender();
-        return { ok: true };
-    }
-    function submitPrefabNodeReparent(scope, hierarchyId, parentHierarchyId, precondition) {
-        const nodeId = resolvePrefabCommandTargetId(scope, hierarchyId);
-        const parentNodeId = resolvePrefabCommandTargetId(scope, parentHierarchyId);
-        if (!nodeId || !parentNodeId)
-            return false;
-        callbacks.onAssetAction?.(createPrefabNodeAssetAction(scope, 'prefab.node.reparent', nodeId, {
-            parentNodeId,
-        }, precondition));
-        return true;
-    }
-    function normalizeAttachSceneGraphMoveResult(result) {
-        if (typeof result === 'boolean')
-            return { ok: result };
-        if (typeof result === 'string')
-            return { ok: false, reason: result };
-        if (result && typeof result === 'object')
-            return result;
-        return { ok: true };
-    }
     function shouldClearSelectionFromBlankClick(event, target) {
         if (event.button !== 0 || event.shiftKey || event.metaKey || event.ctrlKey || event.altKey)
             return false;
         if (!target?.closest('[data-editor-hierarchy-root-drop]'))
             return false;
-        if (hierarchyRename || hierarchyDrag || hasHierarchyDragFeedback())
+        if (currentKernelViewModel?.state.rename || currentKernelViewModel?.state.dragId || hasHierarchyDragFeedback())
             return false;
         const state = getState();
         if (!state)
             return false;
         const scope = resolveScope(state);
-        return scope.kind === 'scene' && scope.selectedIds.length > 0;
-    }
-    function clearSelectionFromSearchClick(event) {
-        if (event.button !== 0 || event.shiftKey || event.metaKey || event.ctrlKey || event.altKey)
-            return;
-        const state = getState();
-        if (!state || resolveScope(state).kind !== 'scene' || state.selectedIds.length === 0)
-            return;
-        hierarchySelectionAnchorId = null;
-        submitSelectionCommand({ type: 'selection.clear', label: 'Clear Selection' }, state);
+        return currentKernelViewModel?.snapshot.scopeKey === scope.scopeId
+            && currentKernelViewModel.snapshot.capabilities.clearSelection === true
+            && scope.selectedIds.length > 0;
     }
     function isHierarchyShortcutScope(event) {
         const target = event.target instanceof Node ? event.target : null;
@@ -1187,202 +1293,59 @@ export function createLocalEditorHierarchyController(options) {
         const target = event.target instanceof Node ? event.target : null;
         return target !== null && panel.contains(target);
     }
-    function submitHierarchyContextAction(action, precondition) {
-        if (action.action === 'rename')
-            return;
-        const scope = resolveScopeForCurrentState();
-        if (!scope)
-            return;
-        const current = hasCurrentHierarchyProjection(scope);
-        if (precondition.scopeId.startsWith('prefab-stage:')) {
-            if (current && scope.commandSurface !== 'prefab-composition')
-                return;
-            submitPrefabHierarchyContextAction(scope, action, precondition);
-            return;
-        }
-        if (current && scope.commandSurface !== 'scene-graph')
+    function beginHierarchyRename(id) {
+        const node = currentKernelViewModel?.snapshot.nodeById.get(id);
+        if (!node?.renamable || node.editorLocked === true)
             return;
-        if (action.action === 'create-group' || action.action === 'create-primitive' || action.action === 'create-marker') {
-            expandNode(action.parentId);
-        }
-        if (callbacks.onContextAction) {
-            callbacks.onContextAction(action, precondition);
-            return;
-        }
-        if (action.action === 'focus')
-            callbacks.onFocusSelection?.();
-        else if (action.action === 'duplicate') {
-            callbacks.onSceneGraphDuplicate?.({
-                targetIds: action.targetIds,
-                activeId: action.activeId ?? null,
-            }, precondition);
-        }
-        else if (action.action === 'paste') {
-            callbacks.onSceneGraphDuplicate?.({
-                targetIds: action.sourceIds,
-                activeId: action.activeId ?? null,
-            }, precondition);
-        }
-        else if (action.action === 'create-group') {
-            callbacks.onSceneGraphCreateGroup?.({
-                parentId: action.parentId ?? null,
-                activeId: action.activeId ?? null,
-                name: 'Empty',
-            }, precondition);
-        }
-        else if (action.action === 'create-marker') {
-            callbacks.onSceneGraphCreateMarker?.({
-                parentId: action.parentId ?? null,
-                activeId: action.activeId ?? null,
-                markerType: action.markerType,
-                name: action.name,
-            }, precondition);
-        }
-        else if (action.action === 'create-primitive') {
-            callbacks.onSceneGraphCreatePrimitive?.({
-                parentId: action.parentId ?? null,
-                activeId: action.activeId ?? null,
-                shape: action.shape,
-                name: action.name,
-            }, precondition);
-        }
-        else if (action.action === 'delete') {
-            callbacks.onSceneGraphDelete?.({
-                ids: action.targetIds,
-                activeId: action.activeId ?? null,
-            }, precondition);
-        }
-    }
-    function submitPrefabHierarchyContextAction(scope, action, precondition) {
-        if (action.action === 'focus') {
-            const targetId = action.activeId ?? action.targetIds[0] ?? null;
-            if (targetId)
-                callbacks.onSelectPrefabStageItem?.(targetId, precondition);
-            return;
-        }
-        if (action.action === 'create-primitive') {
-            if (action.parentId)
-                expandNode(action.parentId);
-            callbacks.onAssetAction?.(createPrefabNodeAssetAction(scope, 'prefab.node.createPrimitive', resolvePrefabCommandTargetId(scope, action.parentId ?? scope.activeId), {
-                primitiveShape: action.shape,
-            }, precondition));
-            return;
-        }
-        if (action.action === 'create-group') {
-            if (action.parentId)
-                expandNode(action.parentId);
-            callbacks.onAssetAction?.(createPrefabNodeAssetAction(scope, 'prefab.node.createGroup', resolvePrefabCommandTargetId(scope, action.parentId ?? scope.activeId), {
-                value: { name: 'Empty' },
-            }, precondition));
-            return;
-        }
-        if (action.action === 'delete') {
-            const nodeId = action.activeId && action.targetIds.includes(action.activeId)
-                ? action.activeId
-                : action.targetIds[0] ?? null;
-            if (!nodeId)
-                return;
-            callbacks.onAssetAction?.(createPrefabNodeAssetAction(scope, 'prefab.node.delete', resolvePrefabCommandTargetId(scope, nodeId), {}, precondition));
-        }
-    }
-    function resolvePrefabCommandTargetId(scope, hierarchyId) {
-        if (!hierarchyId)
-            return null;
-        const node = scope.nodes.find(candidate => candidate.id === hierarchyId);
-        return node?.commandTargetId ?? hierarchyId;
-    }
-    function createPrefabNodeAssetAction(scope, actionId, nodeId, extra = {}, precondition) {
-        const stageAssetId = precondition.scopeId.startsWith('prefab-stage:')
-            ? precondition.scopeId.slice('prefab-stage:'.length)
-            : undefined;
-        return {
-            actionId,
-            assetId: stageAssetId,
-            browserAssetId: stageAssetId ? `prefab:${stageAssetId}` : undefined,
-            assetKind: 'prefab',
-            targetPrefabAssetId: stageAssetId,
-            hierarchyPrecondition: precondition,
-            ...(nodeId ? { nodeId, parentNodeId: nodeId } : {}),
-            ...extra,
-        };
-    }
-    function resolveHierarchyCommandAdapter(scope) {
-        return resolveLocalEditorHierarchyCommandAdapter(scope, {
-            hasDuplicateHandler: typeof callbacks.onSceneGraphDuplicate === 'function',
-            hasMoveHandler: typeof callbacks.onSceneGraphMove === 'function',
-            hasGroupSelectionHandler: typeof callbacks.onSceneGraphGroupSelection === 'function',
-        });
-    }
-    function resolveActiveTheme() {
-        const themed = panel.closest('.fps-editor-workbench[data-fps-editor-theme]');
-        const theme = themed?.dataset.fpsEditorTheme;
-        return theme === 'light' || theme === 'dark' ? theme : undefined;
-    }
-    function beginHierarchyRename(id, precondition) {
-        const state = getState();
-        const scope = state ? resolveScope(state) : null;
-        const model = state ? getModel(state) : null;
-        const node = model?.getNode(id) ?? null;
-        if (!node || !canLocalEditorHierarchyNodeRename(node))
-            return;
-        hierarchyRename = {
-            id,
-            value: node.label,
-            initialValue: node.label,
-            commandTargetId: scope?.nodes.find(candidate => candidate.id === id)?.commandTargetId ?? id,
-            precondition,
-        };
-        requestRender();
-    }
-    function selectSingleHierarchyItem(id) {
-        const scope = resolveScopeForCurrentState();
-        const precondition = lastRenderedCommandPrecondition;
-        if (!scope || !precondition)
-            return;
-        if (hasCurrentHierarchyProjection(scope) && scope.commandSurface === 'readonly')
-            return;
-        if (precondition.scopeId.startsWith('prefab-stage:'))
-            callbacks.onSelectPrefabStageItem?.(id, precondition);
-        else
-            callbacks.onSelectHierarchyItem?.({ id, additive: false, toggle: false }, precondition);
-    }
-    function submitResolvedDrop(resolved, targetId, placement, draggedIds, precondition) {
-        const scope = resolveScopeForCurrentState();
-        if (!scope)
-            return;
-        if (hasCurrentHierarchyProjection(scope) && scope.commandSurface !== 'scene-graph')
-            return;
-        if (!precondition)
-            return;
-        if (callbacks.onSceneGraphMove) {
-            callbacks.onSceneGraphMove({
-                ids: resolved.draggedIds,
-                targetId,
-                placement,
-                parentId: resolved.parentId,
-                beforeId: resolved.beforeId,
-                afterId: resolved.afterId,
-                preserveWorldTransform: true,
-            }, precondition);
-        }
-        else if (placement === 'inside') {
-            callbacks.onSceneGraphDrop?.({
-                draggedId: resolved.draggedIds[0] ?? draggedIds[0],
-                targetId,
-                placement,
-                preserveWorldTransform: true,
-            }, precondition);
-        }
-        else {
-            requestRender();
+        const projectionIndex = currentKernelViewModel?.projection.indexOf(id) ?? -1;
+        const viewport = findHierarchyTreeViewport();
+        if (viewport && projectionIndex >= 0) {
+            const rowTop = projectionIndex * LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT;
+            const rowBottom = rowTop + LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT;
+            if (rowTop < viewport.scrollTop || rowBottom > viewport.scrollTop + viewport.clientHeight) {
+                viewport.scrollTop = Math.max(0, rowTop - Math.max(0, viewport.clientHeight - LOCAL_EDITOR_HIERARCHY_ROW_HEIGHT) / 2);
+            }
         }
+        void dispatchHierarchyIntent({ type: 'rename.begin', targetId: id });
     }
-    function createHierarchyCommandPrecondition(scope) {
-        return {
-            scopeId: scope.scopeId,
-            documentRevision: scope.documentRevision,
-            projectionRevision: scope.projectionRevision,
-        };
-    }
+}
+export function shouldCommitHierarchyRenameAfterCompositionEnd(activeElement, renameInputs, renameId) {
+    const currentInput = renameInputs.find(input => input.dataset.editorHierarchyRenameInput === renameId) ?? null;
+    return currentInput === null || activeElement !== currentInput;
+}
+export function isHierarchyMenuAuthorityCurrent(model, expectedAuthorityToken, context) {
+    return model?.authorityToken === expectedAuthorityToken
+        && model.snapshot.scopeKey === context.scopeKey
+        && model.snapshot.revision === context.expectedRevision;
+}
+export function sameHierarchyIdSet(left, right) {
+    if (left.length !== right.length)
+        return false;
+    if (new Set(left).size !== left.length || new Set(right).size !== right.length)
+        return false;
+    const expected = new Set(right);
+    return left.every(id => expected.has(id));
+}
+export function resolveHierarchyTransportDragIds(dataTransferValue, frozenDragIds) {
+    const dataTransferIds = dataTransferValue?.split(',')
+        .map(id => id.trim())
+        .filter(Boolean) ?? [];
+    return dataTransferIds.length > 0 ? dataTransferIds : [...frozenDragIds];
+}
+export function isHierarchyCompositionSessionCurrent(session, input, scopeKey) {
+    return session?.input === input && session.scopeKey === scopeKey;
+}
+export function isHierarchyRenderedAuthorityCurrent(authority, model) {
+    return authority.token === model.authorityToken
+        && authority.scopeKey === model.snapshot.scopeKey
+        && authority.revision === model.snapshot.revision;
+}
+export function shouldDeferHierarchyDomRender(input) {
+    return input.renderedAuthority !== null
+        && isHierarchyRenderedAuthorityCurrent(input.renderedAuthority, input.model)
+        && (input.compositionActive
+            || (input.nativeDragActive
+                && input.renderedProjection === input.model.projection
+                && input.renderedDragId === input.model.state.dragId));
 }
 //# sourceMappingURL=local-editor-ui-hierarchy-controller.js.map