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

package/node_modules/@fps-games/plugin-hierarchy/dist/kernel.js

@@ -0,0 +1,1237 @@
+export const FPS_HIERARCHY_SURFACE_CONTRIBUTION_ID = 'fps.editor.surface.hierarchy';
+export const FPS_HIERARCHY_SURFACE_CONTRIBUTION_TYPE = 'fps.hierarchy.surface';
+export function createHierarchySurfaceContribution() {
+    return Object.freeze({
+        type: FPS_HIERARCHY_SURFACE_CONTRIBUTION_TYPE,
+        id: 'hierarchy',
+        title: '层级',
+        area: 'left',
+        toolbar: 'scoped-hierarchy',
+        createKernel: createHierarchyKernel,
+    });
+}
+export function isHierarchySurfaceContribution(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return candidate.type === FPS_HIERARCHY_SURFACE_CONTRIBUTION_TYPE
+        && candidate.id === 'hierarchy'
+        && candidate.area === 'left'
+        && typeof candidate.createKernel === 'function';
+}
+export function createHierarchyScopeSnapshot(input) {
+    if (!input.scopeKey.trim())
+        throw new Error('Hierarchy scopeKey is required.');
+    if (!input.scopeType.trim())
+        throw new Error('Hierarchy scopeType is required.');
+    if (!Number.isSafeInteger(input.revision) || input.revision < 0)
+        throw new Error('Hierarchy revision must be a non-negative safe integer.');
+    const tree = input.tree ?? createHierarchyTreeSnapshot({
+        structureRevision: input.structureRevision ?? input.revision,
+        nodes: input.nodes ?? [],
+    });
+    if (input.tree && input.nodes)
+        throw new Error('Hierarchy snapshot accepts either tree or nodes, not both.');
+    const nodeById = tree.nodeById;
+    const childrenByParentId = tree.childrenByParentId;
+    const selectedIds = uniqueIds(input.selectedIds ?? []).filter(id => nodeById.get(id)?.selectable === true);
+    const activeId = input.activeId && selectedIds.includes(input.activeId) ? input.activeId : selectedIds[0] ?? null;
+    return Object.freeze({
+        scopeKey: input.scopeKey,
+        scopeType: input.scopeType,
+        revision: input.revision,
+        structureRevision: tree.structureRevision,
+        title: input.title,
+        searchPlaceholder: input.searchPlaceholder ?? 'Filter hierarchy',
+        readonly: input.readonly === true,
+        rootIds: tree.rootIds,
+        nodeById: tree.nodeById,
+        childrenByParentId: tree.childrenByParentId,
+        selectedIds: Object.freeze(selectedIds),
+        activeId,
+        ...(input.primaryOperationId ? { primaryOperationId: input.primaryOperationId } : {}),
+        capabilities: Object.freeze({ ...input.capabilities }),
+    });
+}
+export function createHierarchyTreeSnapshot(input) {
+    if (!Number.isSafeInteger(input.structureRevision) || input.structureRevision < 0) {
+        throw new Error('Hierarchy structureRevision must be a non-negative safe integer.');
+    }
+    const nodeById = new Map();
+    const children = new Map();
+    for (const candidate of input.nodes) {
+        const node = snapshotNode(candidate);
+        if (nodeById.has(node.id))
+            throw new Error(`Duplicate Hierarchy node id: ${node.id}`);
+        nodeById.set(node.id, node);
+        const siblings = children.get(node.parentId) ?? [];
+        siblings.push(node.id);
+        children.set(node.parentId, siblings);
+    }
+    for (const node of nodeById.values()) {
+        if (node.parentId !== null && !nodeById.has(node.parentId)) {
+            throw new Error(`Hierarchy node ${node.id} references missing parent ${node.parentId}.`);
+        }
+    }
+    assertAcyclicAndReachable(nodeById, children);
+    const childrenByParentId = new Map();
+    for (const [parentId, ids] of children)
+        childrenByParentId.set(parentId, Object.freeze([...ids]));
+    return Object.freeze({
+        structureRevision: input.structureRevision,
+        rootIds: Object.freeze([...(childrenByParentId.get(null) ?? [])]),
+        nodeById: createReadonlyMapView(nodeById),
+        childrenByParentId: createReadonlyMapView(childrenByParentId),
+    });
+}
+export function resolveHierarchySelection(input) {
+    const { snapshot, targetId, modifier } = input;
+    if (targetId === null) {
+        if (!snapshot.capabilities.clearSelection) {
+            return Object.freeze({ selectedIds: snapshot.selectedIds, activeId: snapshot.activeId, anchorId: input.anchorId });
+        }
+        return Object.freeze({ selectedIds: Object.freeze([]), activeId: null, anchorId: null });
+    }
+    if (snapshot.nodeById.get(targetId)?.selectable !== true) {
+        return Object.freeze({ selectedIds: snapshot.selectedIds, activeId: snapshot.activeId, anchorId: input.anchorId });
+    }
+    if (modifier === 'toggle') {
+        const selected = new Set(snapshot.selectedIds);
+        if (selected.has(targetId))
+            selected.delete(targetId);
+        else
+            selected.add(targetId);
+        const selectedIds = [...selected];
+        return Object.freeze({
+            selectedIds: Object.freeze(selectedIds),
+            activeId: selected.has(targetId) ? targetId : selectedIds[selectedIds.length - 1] ?? null,
+            anchorId: targetId,
+        });
+    }
+    if (modifier === 'range' && snapshot.capabilities.rangeSelection && input.anchorId) {
+        const start = input.projection.indexOf(input.anchorId);
+        const end = input.projection.indexOf(targetId);
+        if (start >= 0 && end >= 0) {
+            const [from, to] = start <= end ? [start, end] : [end, start];
+            const selectedIds = input.projection.getRange(from, to)
+                .filter(id => snapshot.nodeById.get(id)?.selectable === true);
+            return Object.freeze({ selectedIds: Object.freeze(selectedIds), activeId: targetId, anchorId: input.anchorId });
+        }
+    }
+    return Object.freeze({ selectedIds: Object.freeze([targetId]), activeId: targetId, anchorId: targetId });
+}
+export function createHierarchyVisibleProjection(input) {
+    return createVisibleProjection(input.snapshot, {
+        collapsedIds: new Set(input.collapsedIds ?? []),
+        searchQuery: input.searchQuery ?? '',
+        projectionRevision: input.projectionRevision ?? 0,
+    });
+}
+export function createHierarchyKernel() {
+    const viewStates = new Map();
+    const revisionRecords = new Map();
+    const projections = new Map();
+    const viewStateSnapshots = new WeakMap();
+    const operationCache = new WeakMap();
+    const adapters = new Set();
+    let providers = [];
+    let activeProvider = null;
+    let activeScopeKey = null;
+    let authorityToken = 0;
+    const resolveProvider = (candidatesSource = providers) => {
+        const candidates = candidatesSource
+            .flatMap(provider => {
+            if (!provider.canProvide())
+                return [];
+            const snapshot = provider.getSnapshot();
+            return snapshot ? [{ provider, snapshot }] : [];
+        })
+            .sort((a, b) => (b.provider.priority ?? 0) - (a.provider.priority ?? 0)
+            || a.provider.id.localeCompare(b.provider.id));
+        if (candidates.length > 1
+            && (candidates[0].provider.priority ?? 0) === (candidates[1].provider.priority ?? 0)) {
+            throw new Error(`Ambiguous Hierarchy scope providers: ${candidates[0].provider.id}, ${candidates[1].provider.id}.`);
+        }
+        return candidates[0] ?? null;
+    };
+    const synchronize = () => {
+        const resolved = resolveProvider();
+        const nextProvider = resolved?.provider ?? null;
+        const snapshot = resolved?.snapshot ?? null;
+        if (snapshot && nextProvider)
+            assertMonotonicSnapshotRevision(revisionRecords, nextProvider, snapshot);
+        const nextScopeKey = snapshot?.scopeKey ?? null;
+        if (activeProvider !== nextProvider || activeScopeKey !== nextScopeKey) {
+            if (activeScopeKey)
+                cancelTransientState(viewStates.get(activeScopeKey));
+            if (nextScopeKey)
+                cancelTransientState(viewStates.get(nextScopeKey));
+            activeProvider = nextProvider;
+            activeScopeKey = nextScopeKey;
+            authorityToken += 1;
+        }
+        if (snapshot)
+            sanitizeViewState(getState(snapshot.scopeKey), snapshot);
+        return snapshot;
+    };
+    const getState = (scopeKey) => {
+        const current = viewStates.get(scopeKey);
+        if (current)
+            return current;
+        const created = {
+            collapsedIds: new Set(), searchQuery: '', selectionAnchorId: null, rename: null, dragId: null, revision: null,
+            dragIds: [],
+            observedActiveId: null,
+            sanitizedStructureRevision: null,
+            projectionRevision: 0,
+            selectionGeneration: 0, renameGeneration: 0, dragGeneration: 0,
+            pendingSelectionGeneration: null, pendingRenameGeneration: null, pendingDragGeneration: null,
+        };
+        viewStates.set(scopeKey, created);
+        return created;
+    };
+    const createViewModel = (snapshot, provider) => {
+        const state = getState(snapshot.scopeKey);
+        const projection = getVisibleProjection(snapshot, state, provider);
+        const operations = getCachedOperations(snapshot, provider, createOperationContext(snapshot, snapshot.activeId), 'view');
+        return Object.freeze({
+            providerId: provider.id,
+            authorityToken,
+            snapshot,
+            state: snapshotViewStateCached(state, viewStateSnapshots),
+            projection,
+            operations,
+        });
+    };
+    const getCachedOperations = (snapshot, provider, context, cacheNamespace) => {
+        let byProvider = operationCache.get(snapshot);
+        if (!byProvider) {
+            byProvider = new WeakMap();
+            operationCache.set(snapshot, byProvider);
+        }
+        let byContext = byProvider.get(provider);
+        if (!byContext) {
+            byContext = new Map();
+            byProvider.set(provider, byContext);
+        }
+        const key = `${cacheNamespace}\u0000${context.contextNodeId ?? ''}\u0000${context.activeId ?? ''}\u0000${context.targetIds.join('\u0001')}`;
+        const cached = byContext.get(key);
+        if (cached)
+            return cached;
+        const startingAuthorityToken = authorityToken;
+        const operations = Object.freeze([...provider.listOperations(context)]);
+        const current = synchronize();
+        if (authorityToken !== startingAuthorityToken
+            || activeProvider !== provider
+            || current?.scopeKey !== snapshot.scopeKey
+            || current.revision !== snapshot.revision)
+            return Object.freeze([]);
+        byContext.set(key, operations);
+        return operations;
+    };
+    const getVisibleProjection = (snapshot, state, provider) => {
+        const cached = projections.get(snapshot.scopeKey);
+        if (cached
+            && cached.provider === provider
+            && cached.structureRevision === snapshot.structureRevision
+            && cached.projectionRevision === state.projectionRevision)
+            return cached.projection;
+        const projection = createVisibleProjection(snapshot, state);
+        projections.set(snapshot.scopeKey, {
+            provider,
+            structureRevision: snapshot.structureRevision,
+            projectionRevision: state.projectionRevision,
+            projection,
+        });
+        return projection;
+    };
+    const getViewModel = () => {
+        for (let attempt = 0; attempt <= providers.length + 1; attempt += 1) {
+            const snapshot = synchronize();
+            const provider = activeProvider;
+            if (!snapshot || !provider)
+                return null;
+            const startingAuthorityToken = authorityToken;
+            const model = createViewModel(snapshot, provider);
+            if (authorityToken === startingAuthorityToken
+                && activeProvider === provider
+                && activeScopeKey === snapshot.scopeKey)
+                return model;
+        }
+        throw new Error('Hierarchy provider authority did not stabilize during operation discovery.');
+    };
+    const notifyAdapters = (model) => {
+        const errors = [];
+        for (const adapter of adapters) {
+            try {
+                adapter.render(model);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0)
+            throw errors[0];
+    };
+    const render = () => {
+        notifyAdapters(getViewModel());
+    };
+    const result = (snapshot, ok = true) => Object.freeze({
+        ok,
+        changed: false,
+        revision: snapshot?.revision ?? 0,
+        diagnostics: Object.freeze([]),
+    });
+    const commitViewMutation = (snapshot) => {
+        const committed = Object.freeze({
+            ok: true,
+            changed: true,
+            revision: snapshot.revision,
+            diagnostics: Object.freeze([]),
+        });
+        try {
+            render();
+            return committed;
+        }
+        catch (error) {
+            return createViewRenderFailure(committed, snapshot.revision, error);
+        }
+    };
+    const execute = async (operation, snapshot) => {
+        try {
+            const operationResult = snapshotOperationResult(await operation());
+            if (operationResult.revision < snapshot.revision) {
+                return createFailureResult(snapshot.revision, 'hierarchy.operation.revision-regressed', new Error(`Hierarchy operation revision regressed from ${snapshot.revision} to ${operationResult.revision}.`));
+            }
+            return operationResult;
+        }
+        catch (error) {
+            return createFailureResult(snapshot.revision, 'hierarchy.operation.failed', error);
+        }
+    };
+    const kernel = {
+        setProviders(nextProviders) {
+            const next = Object.freeze([...nextProviders]);
+            assertUniqueProviderIds(next);
+            const previousProviders = providers;
+            const previousActiveProvider = activeProvider;
+            const previousActiveScopeKey = activeScopeKey;
+            const previousAuthorityToken = authorityToken;
+            const previousRevisionRecords = cloneRevisionRecords(revisionRecords);
+            const previousViewStates = cloneMutableViewStates(viewStates);
+            const previousProjections = new Map(projections);
+            let model;
+            try {
+                providers = next;
+                model = getViewModel();
+            }
+            catch (error) {
+                providers = previousProviders;
+                activeProvider = previousActiveProvider;
+                activeScopeKey = previousActiveScopeKey;
+                authorityToken = previousAuthorityToken;
+                replaceMapContents(revisionRecords, previousRevisionRecords);
+                replaceMapContents(viewStates, previousViewStates);
+                replaceMapContents(projections, previousProjections);
+                throw error;
+            }
+            for (const provider of revisionRecords.keys()) {
+                if (!next.includes(provider))
+                    revisionRecords.delete(provider);
+            }
+            // Provider authority is committed before notifying UI edges. A failing
+            // adapter cannot roll the authoritative provider set back underneath an
+            // adapter that has already observed the new model.
+            notifyAdapters(model);
+        },
+        getProvider() { synchronize(); return activeProvider; },
+        getViewModel,
+        listOperations(context, expectedAuthorityToken) {
+            const previousProvider = activeProvider;
+            const previousScopeKey = activeScopeKey;
+            const snapshot = synchronize();
+            const provider = activeProvider;
+            if (previousProvider !== provider || previousScopeKey !== activeScopeKey) {
+                notifyAdapters(getViewModel());
+            }
+            if (!snapshot || !provider
+                || (expectedAuthorityToken !== undefined && expectedAuthorityToken !== authorityToken)
+                || context.scopeKey !== snapshot.scopeKey
+                || context.expectedRevision !== snapshot.revision)
+                return Object.freeze([]);
+            const operations = getCachedOperations(snapshot, provider, context, 'explicit');
+            if (activeProvider !== provider || activeScopeKey !== snapshot.scopeKey) {
+                notifyAdapters(getViewModel());
+                return Object.freeze([]);
+            }
+            return operations;
+        },
+        attachView(adapter) {
+            let unbind = null;
+            try {
+                unbind = adapter.bind(intent => kernel.dispatch(intent));
+                adapters.add(adapter);
+                adapter.render(getViewModel());
+            }
+            catch (error) {
+                adapters.delete(adapter);
+                if (unbind) {
+                    try {
+                        unbind();
+                    }
+                    catch (cleanupError) {
+                        const initializationError = new Error(`Hierarchy ViewAdapter initialization failed: ${formatError(error)}; cleanup failed: ${formatError(cleanupError)}`);
+                        Object.assign(initializationError, { retryCleanup: () => unbind?.() });
+                        throw initializationError;
+                    }
+                }
+                throw error;
+            }
+            let active = true;
+            return () => {
+                if (!active)
+                    return;
+                unbind?.();
+                adapters.delete(adapter);
+                active = false;
+            };
+        },
+        refresh: render,
+        async dispatch(intent) {
+            let fallbackRevision = activeScopeKey
+                ? getRevisionRecord(revisionRecords, activeProvider, activeScopeKey)?.revision
+                    ?? viewStates.get(activeScopeKey)?.revision ?? 0
+                : 0;
+            const fallbackDragState = intent.type === 'drag.commit' && activeScopeKey
+                ? viewStates.get(activeScopeKey) ?? null
+                : null;
+            const fallbackDragGeneration = fallbackDragState?.dragGeneration ?? null;
+            const fallbackDragId = fallbackDragState?.dragId ?? null;
+            try {
+                const snapshot = synchronize();
+                fallbackRevision = snapshot?.revision ?? 0;
+                const provider = activeProvider;
+                const startingAuthorityToken = authorityToken;
+                if (!snapshot || !provider) {
+                    return createFailureResult(snapshot?.revision ?? 0, 'hierarchy.scope.unavailable', new Error('No active Hierarchy scope provider is available.'));
+                }
+                if (intent.expectedAuthorityToken !== undefined && intent.expectedAuthorityToken !== startingAuthorityToken) {
+                    return createFailureResult(snapshot.revision, 'hierarchy.operation.provider-authority-changed', new Error('Hierarchy intent authority no longer matches the active provider.'));
+                }
+                if ((intent.expectedScopeKey !== undefined && intent.expectedScopeKey !== snapshot.scopeKey)
+                    || (intent.expectedRevision !== undefined && intent.expectedRevision !== snapshot.revision)) {
+                    return createFailureResult(snapshot.revision, 'hierarchy.operation.view-authority-changed', new Error('Hierarchy intent no longer matches the rendered scope revision.'));
+                }
+                const state = getState(snapshot.scopeKey);
+                const operations = getCachedOperations(snapshot, provider, createOperationContext(snapshot, snapshot.activeId), 'view');
+                if (authorityToken !== startingAuthorityToken || activeProvider !== provider || activeScopeKey !== snapshot.scopeKey) {
+                    return createFailureResult(snapshot.revision, 'hierarchy.operation.provider-authority-changed', new Error('Hierarchy provider authority changed during operation discovery.'));
+                }
+                const model = Object.freeze({
+                    providerId: provider.id,
+                    authorityToken: startingAuthorityToken,
+                    snapshot,
+                    state: snapshotViewStateCached(state, viewStateSnapshots),
+                    projection: getVisibleProjection(snapshot, state, provider),
+                    operations,
+                });
+                if (intent.type === 'search.change') {
+                    if (state.searchQuery === intent.value)
+                        return result(snapshot, false);
+                    state.searchQuery = intent.value;
+                    state.projectionRevision += 1;
+                    return commitViewMutation(snapshot);
+                }
+                if (intent.type === 'disclosure.toggle') {
+                    if (!snapshot.nodeById.has(intent.targetId) || !(snapshot.childrenByParentId.get(intent.targetId)?.length))
+                        return result(snapshot, false);
+                    if (state.collapsedIds.has(intent.targetId))
+                        state.collapsedIds.delete(intent.targetId);
+                    else
+                        state.collapsedIds.add(intent.targetId);
+                    state.projectionRevision += 1;
+                    return commitViewMutation(snapshot);
+                }
+                if (intent.type === 'disclosure.expand') {
+                    if (!snapshot.nodeById.has(intent.targetId))
+                        return result(snapshot, false);
+                    if (!state.collapsedIds.delete(intent.targetId))
+                        return result(snapshot, false);
+                    state.projectionRevision += 1;
+                    return commitViewMutation(snapshot);
+                }
+                if (intent.type === 'disclosure.reveal') {
+                    if (!snapshot.nodeById.has(intent.targetId))
+                        return result(snapshot, false);
+                    let changed = false;
+                    let parentId = snapshot.nodeById.get(intent.targetId)?.parentId ?? null;
+                    while (parentId) {
+                        changed = state.collapsedIds.delete(parentId) || changed;
+                        parentId = snapshot.nodeById.get(parentId)?.parentId ?? null;
+                    }
+                    // Revealing an already-visible target is a successful idempotent
+                    // navigation. Callers use `ok` to distinguish a missing/stale target
+                    // from a no-op reveal before continuing with selection.
+                    if (!changed)
+                        return result(snapshot);
+                    state.projectionRevision += 1;
+                    return commitViewMutation(snapshot);
+                }
+                if (intent.type === 'selection' || intent.type === 'selection.set') {
+                    const resolved = intent.type === 'selection'
+                        ? resolveHierarchySelection({ snapshot, targetId: intent.targetId, modifier: intent.modifier, projection: model.projection, anchorId: state.selectionAnchorId })
+                        : normalizeExplicitSelection(snapshot, intent.selectedIds, intent.activeId, intent.anchorId);
+                    const previousAnchor = state.selectionAnchorId;
+                    const selectionGeneration = ++state.selectionGeneration;
+                    state.pendingSelectionGeneration = selectionGeneration;
+                    const operationResult = await execute(() => provider.applySelection(Object.freeze({
+                        ...createOperationContext(snapshot, intent.type === 'selection' ? intent.targetId : intent.activeId),
+                        selectedIds: resolved.selectedIds,
+                        activeId: resolved.activeId,
+                    })), snapshot);
+                    if (operationResult.changed)
+                        operationCache.delete(snapshot);
+                    let currentModel;
+                    try {
+                        currentModel = getViewModel();
+                    }
+                    catch (error) {
+                        if (state.pendingSelectionGeneration === selectionGeneration)
+                            state.pendingSelectionGeneration = null;
+                        return createPostOperationRefreshFailure(operationResult, snapshot.revision, error);
+                    }
+                    const current = currentModel?.snapshot ?? null;
+                    const reconciledResult = currentModel?.authorityToken === startingAuthorityToken
+                        ? reconcilePostOperationResult(operationResult, snapshot, current)
+                        : createProviderAuthorityChangedResult(operationResult, snapshot.revision, startingAuthorityToken, currentModel?.authorityToken ?? null);
+                    if (selectionGeneration === state.selectionGeneration
+                        && current?.scopeKey === snapshot.scopeKey
+                        && current.revision === reconciledResult.revision) {
+                        state.revision = current.revision;
+                        state.selectionAnchorId = reconciledResult.ok ? resolved.anchorId : previousAnchor;
+                    }
+                    if (state.pendingSelectionGeneration === selectionGeneration)
+                        state.pendingSelectionGeneration = null;
+                    try {
+                        if (current && activeProvider)
+                            currentModel = createViewModel(current, activeProvider);
+                        notifyAdapters(currentModel);
+                    }
+                    catch (error) {
+                        return createViewRenderFailure(reconciledResult, snapshot.revision, error);
+                    }
+                    return reconciledResult;
+                }
+                if (intent.type === 'rename.begin') {
+                    const node = snapshot.nodeById.get(intent.targetId);
+                    if (!snapshot.readonly && snapshot.capabilities.rename && node?.renamable && node.editorLocked !== true) {
+                        state.renameGeneration += 1;
+                        state.rename = { id: node.id, value: node.label };
+                        return commitViewMutation(snapshot);
+                    }
+                    return result(snapshot, false);
+                }
+                if (intent.type === 'rename.change') {
+                    if (!state.rename)
+                        return result(snapshot, false);
+                    state.renameGeneration += 1;
+                    state.rename.value = intent.value;
+                    return commitViewMutation(snapshot);
+                }
+                if (intent.type === 'rename.cancel') {
+                    state.renameGeneration += 1;
+                    state.rename = null;
+                    return commitViewMutation(snapshot);
+                }
+                if (intent.type === 'drag.begin') {
+                    const node = snapshot.nodeById.get(intent.targetId);
+                    if (!snapshot.readonly && snapshot.capabilities.reparent && node?.draggable && node.editorLocked !== true) {
+                        const dragIds = model.projection.getTopLevelSelection(snapshot.selectedIds.includes(intent.targetId) ? snapshot.selectedIds : [intent.targetId]).filter(id => {
+                            const dragNode = snapshot.nodeById.get(id);
+                            return dragNode?.draggable === true && dragNode.editorLocked !== true;
+                        });
+                        if (dragIds.length === 0)
+                            return result(snapshot, false);
+                        state.dragGeneration += 1;
+                        state.dragId = intent.targetId;
+                        state.dragIds = Object.freeze(dragIds);
+                        return commitViewMutation(snapshot);
+                    }
+                    return result(snapshot, false);
+                }
+                if (intent.type === 'drag.cancel') {
+                    state.dragGeneration += 1;
+                    state.dragId = null;
+                    state.dragIds = [];
+                    return commitViewMutation(snapshot);
+                }
+                if (intent.type === 'context')
+                    return result(snapshot);
+                let operationId;
+                let operationInput;
+                let contextNodeId = snapshot.activeId;
+                if (intent.type === 'primary') {
+                    operationId = snapshot.primaryOperationId;
+                    contextNodeId = intent.targetId;
+                }
+                if (intent.type === 'rename.commit' && state.rename) {
+                    operationId = 'hierarchy.node.rename';
+                    operationInput = Object.freeze({ targetId: state.rename.id, name: state.rename.value });
+                    contextNodeId = state.rename.id;
+                }
+                if (intent.type === 'drag.commit' && state.dragId) {
+                    operationId = intent.operationId;
+                    operationInput = Object.freeze({ ...(intent.input ?? {}), draggedIds: Object.freeze([...state.dragIds]) });
+                    contextNodeId = state.dragId;
+                }
+                if (intent.type === 'operation.execute') {
+                    operationId = intent.operationId;
+                    operationInput = intent.input;
+                    if (intent.context
+                        && (intent.context.scopeKey !== snapshot.scopeKey || intent.context.expectedRevision !== snapshot.revision)) {
+                        return createFailureResult(snapshot.revision, 'hierarchy.operation.stale', new Error('Hierarchy operation context no longer matches the active scope revision.'));
+                    }
+                    contextNodeId = intent.context?.contextNodeId ?? contextNodeId;
+                }
+                if (!operationId)
+                    return result(snapshot, false);
+                const renameGeneration = state.renameGeneration;
+                const dragGeneration = state.dragGeneration;
+                if (intent.type === 'rename.commit')
+                    state.pendingRenameGeneration = renameGeneration;
+                if (intent.type === 'drag.commit')
+                    state.pendingDragGeneration = dragGeneration;
+                const transientId = intent.type === 'rename.commit' ? state.rename?.id : intent.type === 'drag.commit' ? state.dragId : null;
+                const invocationContext = intent.type === 'operation.execute' && intent.context
+                    ? intent.context
+                    : intent.type === 'drag.commit'
+                        ? Object.freeze({
+                            ...createOperationContext(snapshot, contextNodeId),
+                            targetIds: Object.freeze([...state.dragIds]),
+                        })
+                        : createOperationContext(snapshot, contextNodeId);
+                try {
+                    const discoveredOperations = provider.listOperations(invocationContext);
+                    const discoveredSnapshot = synchronize();
+                    const providerAuthorityChanged = authorityToken !== startingAuthorityToken
+                        || activeProvider !== provider
+                        || activeScopeKey !== snapshot.scopeKey;
+                    const revisionChanged = discoveredSnapshot?.revision !== snapshot.revision;
+                    if (providerAuthorityChanged || revisionChanged) {
+                        try {
+                            notifyAdapters(getViewModel());
+                        }
+                        catch { /* preserve the authority failure */ }
+                        return createFailureResult(discoveredSnapshot?.revision ?? snapshot.revision, providerAuthorityChanged
+                            ? 'hierarchy.operation.provider-authority-changed'
+                            : 'hierarchy.operation.stale', new Error(providerAuthorityChanged
+                            ? 'Hierarchy provider authority changed during operation discovery.'
+                            : 'Hierarchy scope revision changed during operation discovery.'));
+                    }
+                    const operationDescriptor = discoveredOperations.find(operation => operation.id === operationId);
+                    if (!operationDescriptor) {
+                        return createFailureResult(snapshot.revision, 'hierarchy.operation.unavailable', new Error(`Hierarchy operation is unavailable for this context: ${operationId}`));
+                    }
+                    if (operationDescriptor.disabledReason) {
+                        return createFailureResult(snapshot.revision, 'hierarchy.operation.disabled', new Error(operationDescriptor.disabledReason));
+                    }
+                    const operationResult = await execute(() => provider.executeOperation(Object.freeze({
+                        ...invocationContext, operationId, ...(operationInput ? { input: operationInput } : {}),
+                    })), snapshot);
+                    if (operationResult.ok || operationResult.changed)
+                        operationCache.delete(snapshot);
+                    let currentModel;
+                    try {
+                        currentModel = getViewModel();
+                    }
+                    catch (error) {
+                        if (intent.type === 'rename.commit' && state.pendingRenameGeneration === renameGeneration)
+                            state.pendingRenameGeneration = null;
+                        return createPostOperationRefreshFailure(operationResult, snapshot.revision, error);
+                    }
+                    const current = currentModel?.snapshot ?? null;
+                    const reconciledResult = currentModel?.authorityToken === startingAuthorityToken
+                        ? reconcilePostOperationResult(operationResult, snapshot, current)
+                        : createProviderAuthorityChangedResult(operationResult, snapshot.revision, startingAuthorityToken, currentModel?.authorityToken ?? null);
+                    const stillCurrent = current?.scopeKey === snapshot.scopeKey && current.revision === reconciledResult.revision;
+                    if (stillCurrent && current)
+                        state.revision = current.revision;
+                    if (reconciledResult.ok && intent.type === 'rename.commit' && stillCurrent
+                        && state.renameGeneration === renameGeneration && state.rename?.id === transientId)
+                        state.rename = null;
+                    if (!reconciledResult.ok && reconciledResult.changed && stillCurrent && current && current.revision !== snapshot.revision) {
+                        if (intent.type === 'rename.commit' && state.renameGeneration === renameGeneration)
+                            state.rename = null;
+                    }
+                    if (intent.type === 'rename.commit' && state.pendingRenameGeneration === renameGeneration)
+                        state.pendingRenameGeneration = null;
+                    try {
+                        if (current && activeProvider)
+                            currentModel = createViewModel(current, activeProvider);
+                        notifyAdapters(currentModel);
+                    }
+                    catch (error) {
+                        return createViewRenderFailure(reconciledResult, snapshot.revision, error);
+                    }
+                    return reconciledResult;
+                }
+                finally {
+                    if (intent.type === 'rename.commit' && state.pendingRenameGeneration === renameGeneration) {
+                        state.pendingRenameGeneration = null;
+                    }
+                    if (intent.type === 'drag.commit' && state.pendingDragGeneration === dragGeneration) {
+                        state.pendingDragGeneration = null;
+                        if (state.dragGeneration === dragGeneration && state.dragId === transientId) {
+                            state.dragId = null;
+                            state.dragIds = [];
+                            try {
+                                render();
+                            }
+                            catch { /* preserve the operation/discovery result */ }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                return createFailureResult(fallbackRevision, 'hierarchy.operation.failed', error);
+            }
+            finally {
+                if (fallbackDragState
+                    && fallbackDragGeneration !== null
+                    && fallbackDragState.dragGeneration === fallbackDragGeneration
+                    && fallbackDragState.dragId === fallbackDragId) {
+                    fallbackDragState.pendingDragGeneration = null;
+                    fallbackDragState.dragId = null;
+                    fallbackDragState.dragIds = [];
+                    try {
+                        render();
+                    }
+                    catch { /* preserve the terminal drag result */ }
+                }
+            }
+        },
+    };
+    return kernel;
+}
+function assertUniqueProviderIds(providers) {
+    const ids = new Set();
+    for (const provider of providers) {
+        if (!provider.id.trim())
+            throw new Error('Hierarchy scope provider id is required.');
+        if (ids.has(provider.id))
+            throw new Error(`Duplicate Hierarchy scope provider id: ${provider.id}.`);
+        ids.add(provider.id);
+    }
+}
+function cloneMutableViewStates(source) {
+    return new Map([...source].map(([scopeKey, state]) => [scopeKey, {
+            ...state,
+            collapsedIds: new Set(state.collapsedIds),
+            rename: state.rename ? { ...state.rename } : null,
+        }]));
+}
+function replaceMapContents(target, source) {
+    target.clear();
+    for (const [key, value] of source)
+        target.set(key, value);
+}
+function cloneRevisionRecords(source) {
+    return new Map([...source].map(([provider, records]) => [provider, new Map(records)]));
+}
+function getRevisionRecord(records, provider, scopeKey) {
+    return provider ? records.get(provider)?.get(scopeKey) : undefined;
+}
+function assertMonotonicSnapshotRevision(records, provider, snapshot) {
+    let providerRecords = records.get(provider);
+    if (!providerRecords) {
+        providerRecords = new Map();
+        records.set(provider, providerRecords);
+    }
+    const previous = providerRecords.get(snapshot.scopeKey);
+    if (previous && snapshot.revision < previous.revision) {
+        throw new Error(`Hierarchy scope ${snapshot.scopeKey} revision regressed from ${previous.revision} to ${snapshot.revision}.`);
+    }
+    if (previous && snapshot.revision === previous.revision && !sameSnapshotAuthority(previous.snapshot, snapshot)) {
+        throw new Error(`Hierarchy scope ${snapshot.scopeKey} reused revision ${snapshot.revision} for a different authority snapshot.`);
+    }
+    if (previous && snapshot.structureRevision < previous.structureRevision) {
+        throw new Error(`Hierarchy scope ${snapshot.scopeKey} structureRevision regressed from ${previous.structureRevision} to ${snapshot.structureRevision}.`);
+    }
+    if (previous && snapshot.structureRevision === previous.structureRevision
+        && (snapshot.rootIds !== previous.rootIds
+            || snapshot.nodeById !== previous.nodeById
+            || snapshot.childrenByParentId !== previous.childrenByParentId)) {
+        throw new Error(`Hierarchy scope ${snapshot.scopeKey} must structurally share tree indexes for structureRevision ${snapshot.structureRevision}.`);
+    }
+    if (!previous || snapshot.revision > previous.revision) {
+        providerRecords.set(snapshot.scopeKey, {
+            revision: snapshot.revision,
+            snapshot,
+            structureRevision: snapshot.structureRevision,
+            rootIds: snapshot.rootIds,
+            nodeById: snapshot.nodeById,
+            childrenByParentId: snapshot.childrenByParentId,
+        });
+    }
+}
+function sameSnapshotAuthority(left, right) {
+    if (left === right)
+        return true;
+    return left.scopeType === right.scopeType
+        && left.structureRevision === right.structureRevision
+        && left.title === right.title
+        && left.searchPlaceholder === right.searchPlaceholder
+        && left.readonly === right.readonly
+        && left.rootIds === right.rootIds
+        && left.nodeById === right.nodeById
+        && left.childrenByParentId === right.childrenByParentId
+        && left.activeId === right.activeId
+        && left.primaryOperationId === right.primaryOperationId
+        && sameStringArray(left.selectedIds, right.selectedIds)
+        && sameBooleanRecord(left.capabilities, right.capabilities);
+}
+function sameStringArray(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameBooleanRecord(left, right) {
+    const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+    for (const key of keys)
+        if (left[key] !== right[key])
+            return false;
+    return true;
+}
+function createOperationContext(snapshot, contextNodeId) {
+    return Object.freeze({ scopeKey: snapshot.scopeKey, expectedRevision: snapshot.revision, contextNodeId, targetIds: snapshot.selectedIds, activeId: snapshot.activeId });
+}
+function sanitizeViewState(state, snapshot) {
+    if (state.revision !== null && state.revision !== snapshot.revision) {
+        if (state.pendingSelectionGeneration === null)
+            state.selectionGeneration += 1;
+        if (state.pendingRenameGeneration === null) {
+            state.renameGeneration += 1;
+            state.rename = null;
+        }
+        if (state.pendingDragGeneration === null) {
+            state.dragGeneration += 1;
+            state.dragId = null;
+            state.dragIds = [];
+        }
+    }
+    state.revision = snapshot.revision;
+    if (state.observedActiveId !== snapshot.activeId) {
+        let projectionChanged = false;
+        if (state.collapsedIds.size > 0) {
+            let parentId = snapshot.activeId ? snapshot.nodeById.get(snapshot.activeId)?.parentId ?? null : null;
+            while (parentId) {
+                projectionChanged = state.collapsedIds.delete(parentId) || projectionChanged;
+                parentId = snapshot.nodeById.get(parentId)?.parentId ?? null;
+            }
+        }
+        if (projectionChanged)
+            state.projectionRevision += 1;
+        state.observedActiveId = snapshot.activeId;
+    }
+    if (state.sanitizedStructureRevision !== snapshot.structureRevision) {
+        if (state.selectionAnchorId && !snapshot.nodeById.has(state.selectionAnchorId))
+            state.selectionAnchorId = null;
+        if (state.rename && !snapshot.nodeById.has(state.rename.id))
+            state.rename = null;
+        if (state.dragId && !snapshot.nodeById.has(state.dragId))
+            state.dragId = null;
+        state.dragIds = state.dragIds.filter(id => snapshot.nodeById.has(id));
+        if (!state.dragId || state.dragIds.length === 0) {
+            state.dragId = null;
+            state.dragIds = [];
+        }
+        let removedCollapsed = false;
+        for (const id of state.collapsedIds) {
+            if (!snapshot.nodeById.has(id))
+                removedCollapsed = state.collapsedIds.delete(id) || removedCollapsed;
+        }
+        if (removedCollapsed)
+            state.projectionRevision += 1;
+        state.sanitizedStructureRevision = snapshot.structureRevision;
+    }
+}
+function cancelTransientState(state) {
+    if (!state)
+        return;
+    state.selectionGeneration += 1;
+    state.renameGeneration += 1;
+    state.dragGeneration += 1;
+    state.pendingSelectionGeneration = null;
+    state.pendingRenameGeneration = null;
+    state.pendingDragGeneration = null;
+    state.selectionAnchorId = null;
+    state.rename = null;
+    state.dragId = null;
+    state.dragIds = [];
+}
+function normalizeExplicitSelection(snapshot, ids, activeId, anchorId) {
+    const selectedIds = uniqueIds(ids).filter(id => snapshot.nodeById.get(id)?.selectable === true);
+    const resolvedActiveId = activeId && selectedIds.includes(activeId) ? activeId : selectedIds[0] ?? null;
+    const resolvedAnchorId = anchorId && snapshot.nodeById.has(anchorId) ? anchorId : resolvedActiveId;
+    return Object.freeze({ selectedIds: Object.freeze(selectedIds), activeId: resolvedActiveId, anchorId: resolvedAnchorId });
+}
+function createVisibleProjection(snapshot, state) {
+    const query = state.searchQuery.trim().toLocaleLowerCase();
+    const included = query ? new Set() : null;
+    if (included) {
+        for (const node of snapshot.nodeById.values()) {
+            if (!node.label.toLocaleLowerCase().includes(query) && !node.id.toLocaleLowerCase().includes(query))
+                continue;
+            let cursor = node;
+            while (cursor && !included.has(cursor.id)) {
+                included.add(cursor.id);
+                cursor = cursor.parentId ? snapshot.nodeById.get(cursor.parentId) : undefined;
+            }
+        }
+    }
+    const rows = [];
+    const indexById = new Map();
+    const stack = [...snapshot.rootIds].reverse().map(id => ({ id, depth: 0 }));
+    while (stack.length > 0) {
+        const { id, depth } = stack.pop();
+        const node = snapshot.nodeById.get(id);
+        if (!node || (included && !included.has(id)))
+            continue;
+        indexById.set(id, rows.length);
+        rows.push(Object.freeze({ id, depth }));
+        if (!included && state.collapsedIds.has(id))
+            continue;
+        const children = snapshot.childrenByParentId.get(id) ?? [];
+        for (let index = children.length - 1; index >= 0; index -= 1) {
+            stack.push({ id: children[index], depth: depth + 1 });
+        }
+    }
+    const frozenRows = Object.freeze(rows);
+    const emptyIds = Object.freeze([]);
+    const ancestorCache = new Map();
+    const ancestorSetCache = new Map();
+    const topLevelSelectionCache = new Map();
+    const rememberCachedIds = (cache, key, value) => {
+        if (cache.size > 256)
+            cache.clear();
+        cache.set(key, value);
+        return value;
+    };
+    const getAncestors = (id) => {
+        if (!id)
+            return emptyIds;
+        const cached = ancestorCache.get(id);
+        if (cached)
+            return cached;
+        const ancestors = [];
+        let parentId = snapshot.nodeById.get(id)?.parentId ?? null;
+        while (parentId) {
+            ancestors.push(parentId);
+            parentId = snapshot.nodeById.get(parentId)?.parentId ?? null;
+        }
+        return rememberCachedIds(ancestorCache, id, Object.freeze(ancestors));
+    };
+    const getAncestorSet = (id) => {
+        const cached = ancestorSetCache.get(id);
+        if (cached)
+            return cached;
+        if (ancestorSetCache.size > 256)
+            ancestorSetCache.clear();
+        const set = new Set(getAncestors(id));
+        ancestorSetCache.set(id, set);
+        return set;
+    };
+    const getTopLevelSelection = (ids) => {
+        const normalized = uniqueIds(ids).filter(id => snapshot.nodeById.has(id));
+        if (normalized.length === 0)
+            return emptyIds;
+        const cacheKey = normalized.join('\u0000');
+        const cached = topLevelSelectionCache.get(cacheKey);
+        if (cached)
+            return cached;
+        if (normalized.length === 1)
+            return rememberCachedIds(topLevelSelectionCache, cacheKey, Object.freeze([...normalized]));
+        const selectedIds = new Set(normalized);
+        return rememberCachedIds(topLevelSelectionCache, cacheKey, Object.freeze(normalized.filter(id => !getAncestors(id).some(ancestorId => selectedIds.has(ancestorId)))));
+    };
+    const isDescendant = (candidateId, ancestorId) => (candidateId !== ancestorId && getAncestorSet(candidateId).has(ancestorId));
+    const resolveDrop = (input) => {
+        const draggedIds = getTopLevelSelection(input.draggedIds);
+        const invalid = (reason) => Object.freeze({
+            ok: false, reason, placement: input.placement, draggedIds: Object.freeze([]),
+            targetId: input.targetId ?? null, parentId: null, beforeId: null, afterId: null,
+        });
+        if (draggedIds.length === 0)
+            return invalid('empty-drag');
+        for (const id of draggedIds) {
+            const node = snapshot.nodeById.get(id);
+            if (!node?.draggable || node.editorLocked === true)
+                return invalid('dragged-node-not-movable');
+        }
+        if (input.placement === 'root') {
+            return Object.freeze({
+                ok: true, placement: 'root', draggedIds, targetId: null, parentId: null, beforeId: null, afterId: null,
+            });
+        }
+        const targetId = input.targetId ?? null;
+        const target = targetId ? snapshot.nodeById.get(targetId) : undefined;
+        if (!target)
+            return invalid('missing-target');
+        const draggedSet = new Set(draggedIds);
+        if (draggedSet.has(target.id))
+            return invalid('cannot-drop-on-self');
+        if (draggedIds.some(id => isDescendant(target.id, id)))
+            return invalid('cannot-drop-on-descendant');
+        if (input.placement === 'inside') {
+            if (!target.canHaveChildren || target.editorLocked === true)
+                return invalid('target-cannot-have-children');
+            const children = (snapshot.childrenByParentId.get(target.id) ?? []).filter(id => !draggedSet.has(id));
+            return Object.freeze({
+                ok: true, placement: 'inside', draggedIds, targetId: target.id, parentId: target.id,
+                beforeId: null, afterId: children[children.length - 1] ?? null,
+            });
+        }
+        if (target.role === 'root')
+            return invalid('cannot-reorder-root');
+        if (target.editorLocked === true)
+            return invalid('target-node-locked');
+        const parent = target.parentId ? snapshot.nodeById.get(target.parentId) : undefined;
+        if (parent?.editorLocked === true)
+            return invalid('target-parent-locked');
+        const siblings = (snapshot.childrenByParentId.get(target.parentId) ?? []).filter(id => !draggedSet.has(id));
+        const targetIndex = siblings.indexOf(target.id);
+        return Object.freeze({
+            ok: true, placement: input.placement, draggedIds, targetId: target.id, parentId: target.parentId,
+            beforeId: input.placement === 'before' ? target.id : siblings[targetIndex + 1] ?? null,
+            afterId: input.placement === 'after' ? target.id : siblings[targetIndex - 1] ?? null,
+        });
+    };
+    return Object.freeze({
+        structureRevision: snapshot.structureRevision,
+        projectionRevision: state.projectionRevision,
+        totalCount: frozenRows.length,
+        indexOf(id) { return id ? indexById.get(id) ?? -1 : -1; },
+        getRow(index) { return Number.isInteger(index) && index >= 0 ? frozenRows[index] ?? null : null; },
+        getWindow(start, count) {
+            const from = Math.max(0, Math.trunc(start));
+            const length = Math.max(0, Math.trunc(count));
+            return Object.freeze(frozenRows.slice(from, from + length));
+        },
+        getRange(from, to) {
+            const start = Math.max(0, Math.min(Math.trunc(from), Math.trunc(to)));
+            const end = Math.min(frozenRows.length - 1, Math.max(Math.trunc(from), Math.trunc(to)));
+            if (end < start)
+                return Object.freeze([]);
+            return Object.freeze(frozenRows.slice(start, end + 1).map(row => row.id));
+        },
+        getAncestors,
+        getSelectableChildren(id) {
+            if (!id)
+                return Object.freeze([]);
+            return Object.freeze((snapshot.childrenByParentId.get(id) ?? [])
+                .filter(childId => snapshot.nodeById.get(childId)?.selectable === true));
+        },
+        getSelectableDescendants(id) {
+            if (!id || !snapshot.nodeById.has(id))
+                return Object.freeze([]);
+            const descendants = [];
+            const stack = [...(snapshot.childrenByParentId.get(id) ?? [])].reverse();
+            while (stack.length > 0) {
+                const childId = stack.pop();
+                if (snapshot.nodeById.get(childId)?.selectable === true)
+                    descendants.push(childId);
+                const children = snapshot.childrenByParentId.get(childId) ?? [];
+                for (let index = children.length - 1; index >= 0; index -= 1)
+                    stack.push(children[index]);
+            }
+            return Object.freeze(descendants);
+        },
+        getTopLevelSelection,
+        isDescendant,
+        resolveDrop,
+    });
+}
+function assertAcyclicAndReachable(nodes, children) {
+    const visited = new Set();
+    const stack = [...(children.get(null) ?? [])].reverse();
+    while (stack.length > 0) {
+        const id = stack.pop();
+        if (visited.has(id))
+            throw new Error(`Hierarchy contains a parent cycle at node ${id}.`);
+        visited.add(id);
+        const childIds = children.get(id) ?? [];
+        for (let index = childIds.length - 1; index >= 0; index -= 1)
+            stack.push(childIds[index]);
+    }
+    if (visited.size !== nodes.size) {
+        const unreachable = [...nodes.keys()].find(id => !visited.has(id));
+        throw new Error(`Hierarchy contains a parent cycle or unreachable node: ${unreachable ?? 'unknown'}.`);
+    }
+}
+function snapshotOperationResult(value) {
+    if (!value || typeof value !== 'object' || typeof value.ok !== 'boolean' || !Number.isSafeInteger(value.revision)) {
+        throw new Error('Hierarchy provider returned an invalid operation result.');
+    }
+    return Object.freeze({ ok: value.ok, changed: value.changed === true, revision: value.revision, diagnostics: Object.freeze([...(value.diagnostics ?? [])]) });
+}
+function createFailureResult(revision, code, error) {
+    return Object.freeze({ ok: false, changed: false, revision, diagnostics: Object.freeze([Object.freeze({ code, message: error instanceof Error ? error.message : String(error), severity: 'error' })]) });
+}
+function createPostOperationRefreshFailure(operationResult, fallbackRevision, error) {
+    const commitStatusUnknown = hasProviderExecutionFailure(operationResult);
+    return Object.freeze({
+        ok: false,
+        // The provider operation may already have committed before its follow-up
+        // snapshot failed. Preserve that fact instead of reporting a false no-op.
+        changed: operationResult.changed || commitStatusUnknown,
+        revision: Math.max(fallbackRevision, operationResult.revision),
+        diagnostics: Object.freeze([
+            ...operationResult.diagnostics,
+            Object.freeze({
+                code: 'hierarchy.snapshot.refresh-failed-after-operation',
+                message: error instanceof Error ? error.message : String(error),
+                severity: 'error',
+            }),
+            ...(commitStatusUnknown ? [Object.freeze({
+                    code: 'hierarchy.operation.commit-status-unknown',
+                    message: 'The provider failed before the refreshed snapshot could confirm whether its authored change committed.',
+                    severity: 'error',
+                })] : []),
+        ]),
+    });
+}
+function createViewRenderFailure(operationResult, fallbackRevision, error) {
+    const commitStatusUnknown = hasProviderExecutionFailure(operationResult);
+    return Object.freeze({
+        ok: false,
+        changed: operationResult.changed || commitStatusUnknown,
+        revision: Math.max(fallbackRevision, operationResult.revision),
+        diagnostics: Object.freeze([
+            ...operationResult.diagnostics,
+            Object.freeze({
+                code: 'hierarchy.view.render-failed-after-change',
+                message: error instanceof Error ? error.message : String(error),
+                severity: 'error',
+            }),
+            ...(commitStatusUnknown ? [Object.freeze({
+                    code: 'hierarchy.operation.commit-status-unknown',
+                    message: 'The provider failed before the refreshed snapshot could confirm whether its authored change committed.',
+                    severity: 'error',
+                })] : []),
+        ]),
+    });
+}
+function reconcilePostOperationResult(operationResult, startingSnapshot, currentSnapshot) {
+    if (!currentSnapshot || currentSnapshot.scopeKey !== startingSnapshot.scopeKey) {
+        return createPostOperationRefreshFailure(operationResult, startingSnapshot.revision, new Error(`Hierarchy scope ${startingSnapshot.scopeKey} was unavailable after the operation.`));
+    }
+    if (currentSnapshot.revision < operationResult.revision) {
+        return createPostOperationRefreshFailure(operationResult, startingSnapshot.revision, new Error(`Hierarchy operation reported revision ${operationResult.revision}, but the refreshed scope is still at ${currentSnapshot.revision}.`));
+    }
+    if (currentSnapshot.revision === operationResult.revision)
+        return operationResult;
+    const operationThrewAfterPossibleCommit = !operationResult.ok
+        && operationResult.diagnostics.some(diagnostic => diagnostic.code === 'hierarchy.operation.failed')
+        && currentSnapshot.revision > startingSnapshot.revision;
+    return Object.freeze({
+        ...operationResult,
+        changed: operationResult.changed || operationThrewAfterPossibleCommit,
+        revision: currentSnapshot.revision,
+        diagnostics: Object.freeze([
+            ...operationResult.diagnostics,
+            Object.freeze({
+                code: operationThrewAfterPossibleCommit
+                    ? 'hierarchy.operation.failed-after-revision-advanced'
+                    : 'hierarchy.operation.concurrent-revision-advanced',
+                message: operationThrewAfterPossibleCommit
+                    ? `The operation failed after the scope advanced from revision ${startingSnapshot.revision} to ${currentSnapshot.revision}; the authored result may already be committed.`
+                    : `The scope advanced to revision ${currentSnapshot.revision} while the operation completed.`,
+                severity: operationThrewAfterPossibleCommit ? 'error' : 'info',
+            }),
+        ]),
+    });
+}
+function createProviderAuthorityChangedResult(operationResult, fallbackRevision, startingAuthorityToken, currentAuthorityToken) {
+    const commitStatusUnknown = hasProviderExecutionFailure(operationResult);
+    return Object.freeze({
+        ok: false,
+        changed: operationResult.changed || commitStatusUnknown,
+        revision: Math.max(fallbackRevision, operationResult.revision),
+        diagnostics: Object.freeze([
+            ...operationResult.diagnostics,
+            Object.freeze({
+                code: 'hierarchy.operation.provider-authority-changed',
+                message: `Hierarchy provider authority changed from token ${startingAuthorityToken} to ${currentAuthorityToken ?? 'none'} while the operation was pending.`,
+                severity: 'error',
+            }),
+            ...(commitStatusUnknown ? [Object.freeze({
+                    code: 'hierarchy.operation.commit-status-unknown',
+                    message: 'Provider authority changed before the failed operation could confirm whether its authored change committed.',
+                    severity: 'error',
+                })] : []),
+        ]),
+    });
+}
+function hasProviderExecutionFailure(result) {
+    return result.diagnostics.some(diagnostic => diagnostic.code === 'hierarchy.operation.failed');
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function snapshotNode(node) {
+    if (!node.id.trim())
+        throw new Error('Hierarchy node id is required.');
+    return Object.freeze({ ...node, parentId: node.parentId ?? null, selectable: node.selectable === true, canHaveChildren: node.canHaveChildren === true, renamable: node.renamable === true, deletable: node.deletable === true, draggable: node.draggable === true });
+}
+function snapshotViewState(state) {
+    return Object.freeze({ collapsedIds: new Set(state.collapsedIds), searchQuery: state.searchQuery, selectionAnchorId: state.selectionAnchorId, rename: state.rename ? Object.freeze({ ...state.rename }) : null, dragId: state.dragId, dragIds: Object.freeze([...state.dragIds]) });
+}
+function snapshotViewStateCached(state, cache) {
+    const cached = cache.get(state);
+    if (cached
+        && cached.projectionRevision === state.projectionRevision
+        && cached.selectionGeneration === state.selectionGeneration
+        && cached.renameGeneration === state.renameGeneration
+        && cached.dragGeneration === state.dragGeneration
+        && cached.selectionAnchorId === state.selectionAnchorId
+        && cached.renameId === (state.rename?.id ?? null)
+        && cached.renameValue === (state.rename?.value ?? null)
+        && cached.dragId === state.dragId
+        && cached.dragIds === state.dragIds) {
+        return cached.snapshot;
+    }
+    const snapshot = Object.freeze({
+        collapsedIds: cached?.projectionRevision === state.projectionRevision
+            ? cached.snapshot.collapsedIds
+            : new Set(state.collapsedIds),
+        searchQuery: state.searchQuery,
+        selectionAnchorId: state.selectionAnchorId,
+        rename: state.rename ? Object.freeze({ ...state.rename }) : null,
+        dragId: state.dragId,
+        dragIds: cached?.dragGeneration === state.dragGeneration && cached.dragIds === state.dragIds
+            ? cached.snapshot.dragIds
+            : Object.freeze([...state.dragIds]),
+    });
+    cache.set(state, {
+        projectionRevision: state.projectionRevision,
+        selectionGeneration: state.selectionGeneration,
+        renameGeneration: state.renameGeneration,
+        dragGeneration: state.dragGeneration,
+        selectionAnchorId: state.selectionAnchorId,
+        renameId: state.rename?.id ?? null,
+        renameValue: state.rename?.value ?? null,
+        dragId: state.dragId,
+        dragIds: state.dragIds,
+        snapshot,
+    });
+    return snapshot;
+}
+function uniqueIds(ids) { return [...new Set(ids.filter(id => id.trim()))]; }
+function createReadonlyMapView(source) {
+    let view;
+    view = Object.freeze({
+        get size() { return source.size; }, has(key) { return source.has(key); }, get(key) { return source.get(key); }, entries() { return source.entries(); }, keys() { return source.keys(); }, values() { return source.values(); },
+        forEach(callback, thisArg) { source.forEach((value, key) => callback.call(thisArg, value, key, view)); },
+        [Symbol.iterator]() { return source[Symbol.iterator](); },
+    });
+    return view;
+}
+//# sourceMappingURL=kernel.js.map