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

package/dist/local-editor-marker-graph.js

@@ -0,0 +1,1432 @@
+import { SPATIAL_MARKER_GRAPH_SCHEMA_VERSION, } from '@fps-games/editor-protocol';
+export const LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_ID = '__marker_graph__';
+const LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_COLLISION_SEPARATOR = ':';
+const LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_MARKER_SEGMENT = ':marker:';
+export function resolveSpatialMarkerGraph(graph) {
+    if (!graph)
+        return null;
+    return {
+        ...graph,
+        schemaVersion: graph.schemaVersion ?? SPATIAL_MARKER_GRAPH_SCHEMA_VERSION,
+        markers: graph.markers.map(resolveSpatialMarkerNode),
+        relations: graph.relations.map(relation => ({ ...relation })),
+        metadata: graph.metadata ? { ...graph.metadata } : undefined,
+    };
+}
+export function createMarkerGraphHierarchyItems(hierarchy, graph, visibility = {}) {
+    const markers = graph?.markers ?? [];
+    const hiddenMarkerIds = normalizeHiddenMarkerIds(visibility.hiddenMarkerIds);
+    const markerIds = new Set(markers.map(marker => marker.id));
+    const hierarchyWithMarkerVisibility = hierarchy.map((item) => {
+        if (item.role !== 'marker' || !markerIds.has(item.id))
+            return item;
+        const documentEnabled = item.enabled !== false;
+        const documentDirectEnabled = item.directEnabled !== false;
+        const visible = documentEnabled && !hiddenMarkerIds.has(item.id);
+        const directVisible = documentDirectEnabled && !hiddenMarkerIds.has(item.id);
+        return {
+            ...item,
+            enabled: visible,
+            directEnabled: directVisible,
+            canToggleEnabled: item.canToggleEnabled ?? true,
+        };
+    });
+    const virtualMarkers = markers.filter(marker => !isMarkerBackedByHierarchyRow(hierarchy, marker.id));
+    if (virtualMarkers.length === 0)
+        return hierarchyWithMarkerVisibility;
+    const rootId = resolveMarkerGraphHierarchyRootId(hierarchy, virtualMarkers);
+    const rootVisible = visibility.rootVisible !== false;
+    return [
+        ...hierarchyWithMarkerVisibility,
+        {
+            id: rootId,
+            label: 'Markers',
+            role: 'group',
+            icon: 'view-overlay',
+            selectable: true,
+            enabled: rootVisible,
+            directEnabled: rootVisible,
+            canToggleEnabled: true,
+            protected: false,
+            canHaveChildren: false,
+            renamable: false,
+            deletable: false,
+            draggable: false,
+        },
+        ...virtualMarkers.map(marker => ({
+            id: createMarkerGraphHierarchyMarkerIdForRoot(rootId, marker.id),
+            label: marker.label,
+            parentId: rootId,
+            role: 'marker',
+            icon: 'view-overlay',
+            selectable: true,
+            enabled: !hiddenMarkerIds.has(marker.id),
+            directEnabled: !hiddenMarkerIds.has(marker.id),
+            canToggleEnabled: true,
+            protected: false,
+            canHaveChildren: false,
+            renamable: false,
+            deletable: false,
+            draggable: false,
+        })),
+    ];
+}
+export function isSpatialMarkerHierarchyVisible(markerId, visibility = {}) {
+    return visibility.rootVisible !== false
+        && !normalizeHiddenMarkerIds(visibility.hiddenMarkerIds).has(markerId);
+}
+export function isMarkerGraphHierarchyId(graph, id, hierarchy) {
+    return readSpatialMarkerIdFromHierarchySelection(graph, id, hierarchy) !== null;
+}
+export function isMarkerGraphHierarchyRootRowId(graph, id, hierarchy) {
+    const markers = graph?.markers ?? [];
+    const virtualMarkers = markers.filter(marker => !isMarkerBackedByHierarchyRow(hierarchy, marker.id));
+    if (!id || virtualMarkers.length === 0)
+        return false;
+    return id === resolveMarkerGraphHierarchyRootId(hierarchy, virtualMarkers);
+}
+export function createMarkerGraphHierarchyMarkerId(markerId) {
+    return createMarkerGraphHierarchyMarkerIdForRoot(LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_ID, markerId);
+}
+export function isMarkerGraphHierarchyRootId(id) {
+    return id === LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_ID
+        || isMarkerGraphHierarchyRootCollisionId(id);
+}
+export function readMarkerGraphHierarchyMarkerId(id) {
+    if (!id)
+        return null;
+    const markerSegmentIndex = id.indexOf(LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_MARKER_SEGMENT);
+    if (markerSegmentIndex < 0)
+        return null;
+    const rootId = id.slice(0, markerSegmentIndex);
+    if (!isMarkerGraphHierarchyRootId(rootId))
+        return null;
+    const encoded = id.slice(markerSegmentIndex + LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_MARKER_SEGMENT.length);
+    try {
+        return decodeURIComponent(encoded);
+    }
+    catch {
+        return null;
+    }
+}
+export function readMarkerGraphHierarchyMarkerIdForGraph(graph, id, hierarchy) {
+    const markerId = readMarkerGraphHierarchyMarkerId(id);
+    if (!markerId)
+        return null;
+    const markers = graph?.markers ?? [];
+    if (!markers.some(marker => marker.id === markerId))
+        return null;
+    if (!hierarchy)
+        return markerId;
+    const virtualMarkers = markers.filter(marker => !isMarkerBackedByHierarchyRow(hierarchy, marker.id));
+    if (!virtualMarkers.some(marker => marker.id === markerId))
+        return null;
+    const rootId = resolveMarkerGraphHierarchyRootId(hierarchy, virtualMarkers);
+    return id === createMarkerGraphHierarchyMarkerIdForRoot(rootId, markerId)
+        ? markerId
+        : null;
+}
+export function isSpatialMarkerBackedByHierarchyRow(graph, id, hierarchy) {
+    if (!id)
+        return false;
+    return !!graph?.markers.some(marker => marker.id === id)
+        && isMarkerBackedByHierarchyRow(hierarchy, id);
+}
+export function readSpatialMarkerIdFromHierarchySelection(graph, id, hierarchy) {
+    if (!id)
+        return null;
+    const markers = graph?.markers ?? [];
+    if (!hierarchy && markers.some(marker => marker.id === id))
+        return id;
+    if (hierarchy && isMarkerBackedByHierarchyRow(hierarchy, id) && markers.some(marker => marker.id === id)) {
+        return id;
+    }
+    return readMarkerGraphHierarchyMarkerIdForGraph(graph, id, hierarchy);
+}
+function resolveMarkerGraphHierarchyRootId(hierarchy, markers) {
+    const existingIds = new Set(hierarchy.map(item => item.id));
+    if (isMarkerGraphRootCandidateAvailable(LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_ID, existingIds, markers)) {
+        return LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_ID;
+    }
+    let index = 1;
+    let candidate = `${LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_ID}${LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_COLLISION_SEPARATOR}${index}`;
+    while (!isMarkerGraphRootCandidateAvailable(candidate, existingIds, markers)) {
+        index += 1;
+        candidate = `${LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_ID}${LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_COLLISION_SEPARATOR}${index}`;
+    }
+    return candidate;
+}
+function isMarkerGraphRootCandidateAvailable(rootId, existingIds, markers) {
+    if (existingIds.has(rootId))
+        return false;
+    return markers.every(marker => !existingIds.has(createMarkerGraphHierarchyMarkerIdForRoot(rootId, marker.id)));
+}
+function isMarkerGraphHierarchyRootCollisionId(id) {
+    if (!id?.startsWith(`${LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_ID}${LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_COLLISION_SEPARATOR}`)) {
+        return false;
+    }
+    const suffix = id.slice(LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_ID.length + LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_ROOT_COLLISION_SEPARATOR.length);
+    return /^[1-9]\d*$/.test(suffix);
+}
+function createMarkerGraphHierarchyMarkerIdForRoot(rootId, markerId) {
+    return `${rootId}${LOCAL_EDITOR_MARKER_GRAPH_HIERARCHY_MARKER_SEGMENT}${encodeURIComponent(markerId)}`;
+}
+function isMarkerBackedByHierarchyRow(hierarchy, markerId) {
+    return hierarchy.some(item => item.id === markerId && item.role === 'marker');
+}
+function normalizeHiddenMarkerIds(value) {
+    if (!value)
+        return new Set();
+    return value instanceof Set ? value : new Set(value);
+}
+export function createMarkerGraphInspectorObject(input) {
+    const markerId = readSpatialMarkerIdFromHierarchySelection(input.graph, input.markerId, input.hierarchy);
+    if (!markerId)
+        return null;
+    const marker = findSpatialMarkerById(input.graph, markerId);
+    if (!marker)
+        return null;
+    const virtualHierarchyMarkerId = readMarkerGraphHierarchyMarkerIdForGraph(input.graph, input.markerId, input.hierarchy);
+    const hierarchyMarkerId = (input.hierarchy && isMarkerBackedByHierarchyRow(input.hierarchy, marker.id)) || virtualHierarchyMarkerId
+        ? input.markerId
+        : createMarkerGraphHierarchyMarkerId(marker.id);
+    const resolvedMarker = resolveSpatialMarkerNode(marker);
+    const directRelations = input.graph ? getSpatialMarkerDirectRelations(input.graph, marker.id) : [];
+    const sections = [
+        createMarkerIdentityInspectorSection(input.document, resolvedMarker, input.markerTypes ?? []),
+        createMarkerGeometryInspectorSection(input.document, resolvedMarker),
+        createMarkerSpatialInspectorSection(input.document, resolvedMarker),
+        createMarkerRelationsInspectorSection(input.document, marker.id, directRelations, input.markerTypes ?? [], input.relationTypes ?? [], input.graph, input.hierarchy ?? [], input.activeRelationId ?? null, input.relationPick ?? null, input.relationVisibility ?? {}),
+    ];
+    return {
+        targetIds: [hierarchyMarkerId],
+        activeId: hierarchyMarkerId,
+        label: marker.label,
+        document: input.document,
+        selection: {
+            targetIds: [hierarchyMarkerId],
+            activeId: hierarchyMarkerId,
+            targetKind: 'marker',
+            document: input.document,
+            capabilities: ['markerGraph'],
+        },
+        sections,
+    };
+}
+export function createMarkerGraphRootInspectorObject(input) {
+    if (!isMarkerGraphHierarchyRootRowId(input.graph, input.rootId, input.hierarchy))
+        return null;
+    const graph = input.graph ?? {
+        schemaVersion: SPATIAL_MARKER_GRAPH_SCHEMA_VERSION,
+        markers: [],
+        relations: [],
+    };
+    const markerTypes = input.markerTypes ?? [];
+    const relationTypes = input.relationTypes ?? [];
+    return {
+        targetIds: [input.rootId],
+        activeId: input.rootId,
+        label: 'Markers',
+        document: input.document,
+        selection: {
+            targetIds: [input.rootId],
+            activeId: input.rootId,
+            targetKind: 'marker-graph',
+            document: input.document,
+            capabilities: ['markerGraph'],
+        },
+        sections: [
+            {
+                id: 'markerGraph',
+                title: 'Marker Graph',
+                order: 0,
+                persistence: 'readonly',
+                properties: [
+                    createMarkerInspectorProperty(input.document, {
+                        path: 'markerGraph.schemaVersion',
+                        label: 'Schema',
+                        value: graph.schemaVersion,
+                        valueType: 'number',
+                        control: 'readonly',
+                        readOnly: true,
+                        persistence: 'readonly',
+                        order: 0,
+                    }),
+                    createMarkerInspectorProperty(input.document, {
+                        path: 'markerGraph.markers.count',
+                        label: 'Markers',
+                        value: graph.markers.length,
+                        valueType: 'number',
+                        control: 'readonly',
+                        readOnly: true,
+                        persistence: 'readonly',
+                        order: 1,
+                    }),
+                    createMarkerInspectorProperty(input.document, {
+                        path: 'markerGraph.relations.count',
+                        label: 'Relations',
+                        value: graph.relations.length,
+                        valueType: 'number',
+                        control: 'readonly',
+                        readOnly: true,
+                        persistence: 'readonly',
+                        order: 2,
+                    }),
+                ],
+            },
+            {
+                id: 'markerGraphCatalog',
+                title: 'Catalog',
+                order: 10,
+                persistence: 'readonly',
+                properties: [
+                    createMarkerInspectorProperty(input.document, {
+                        path: 'markerGraph.markerTypes.summary',
+                        label: 'Types',
+                        value: markerTypes.map(definition => definition.label).join(', ') || 'None',
+                        valueType: 'string',
+                        control: 'readonly',
+                        readOnly: true,
+                        persistence: 'readonly',
+                        order: 0,
+                    }),
+                    createMarkerInspectorProperty(input.document, {
+                        path: 'markerGraph.relationTypes.summary',
+                        label: 'Relations',
+                        value: relationTypes.map(definition => definition.label).join(', ') || 'None',
+                        valueType: 'string',
+                        control: 'readonly',
+                        readOnly: true,
+                        persistence: 'readonly',
+                        order: 1,
+                    }),
+                ],
+            },
+        ],
+    };
+}
+export function createMarkerPanelState(graph, markerTypes, relationTypes = [], hierarchy = [], activeMarkerId = null, activeRelationId = null, relationPick = null, visibility = {}) {
+    if (!graph)
+        return null;
+    const usedByType = new Map();
+    const markerKindByType = new Map();
+    for (const marker of graph.markers) {
+        if (!marker.markerType.trim())
+            continue;
+        usedByType.set(marker.markerType, (usedByType.get(marker.markerType) ?? 0) + 1);
+        if (!markerKindByType.has(marker.markerType))
+            markerKindByType.set(marker.markerType, marker.kind);
+    }
+    const entries = new Map();
+    for (const definition of markerTypes)
+        entries.set(definition.type, definition);
+    for (const marker of graph.markers) {
+        if (!marker.markerType.trim())
+            continue;
+        if (!entries.has(marker.markerType)) {
+            entries.set(marker.markerType, {
+                type: marker.markerType,
+                label: marker.markerType,
+                kind: markerKindByType.get(marker.markerType) ?? marker.kind,
+                description: 'Marker type referenced by authored markers but not present in the catalog.',
+                metadata: {
+                    builtIn: false,
+                    inferred: true,
+                },
+            });
+        }
+    }
+    const createMarkerTypeItem = (definition) => {
+        const usedByCount = usedByType.get(definition.type) ?? 0;
+        const builtIn = definition.metadata?.builtIn === true;
+        return {
+            type: definition.type,
+            label: definition.label,
+            kind: definition.kind,
+            description: definition.description,
+            defaultTags: definition.defaultTags ? [...definition.defaultTags] : undefined,
+            builtIn,
+            usedByCount,
+            deletable: !builtIn && usedByCount === 0,
+        };
+    };
+    const markerTypeItems = [...entries.values()]
+        .sort((left, right) => left.label.localeCompare(right.label))
+        .map(createMarkerTypeItem);
+    const panel = {
+        title: '标记',
+        summary: '管理项目标记类型与标记关系。',
+        markerTypes: markerTypeItems,
+        relationTypes: createMarkerRelationTypeItems(relationTypes),
+        relationEndpointOptions: createMarkerRelationEndpointOptions(graph, hierarchy, visibility),
+        relations: createMarkerRelationItems(graph, relationTypes, hierarchy, activeMarkerId, activeRelationId, visibility),
+        activeMarkerId,
+        activeRelationId,
+        relationPick,
+        markersCount: graph.markers.length,
+        relationsCount: graph.relations.length,
+        markersVisible: visibility.markersVisible !== false,
+        ...(visibility.markersVisible === false
+            ? { status: '标记视图已关闭，关系线暂不显示。', statusTone: 'warning' }
+            : {}),
+    };
+    return panel;
+}
+export function createMarkerRelationCommand(input, graph, relationTypes = [], hierarchy = [], activeMarkerId = null) {
+    if (!graph) {
+        return { command: null, status: '当前文档没有 marker graph。', statusTone: 'warning' };
+    }
+    if (input.action === 'select') {
+        const relationId = input.relationId.trim();
+        if (!relationId)
+            return { command: null, status: '请选择要高亮的关系。', statusTone: 'warning' };
+        if (!graph.relations.some(relation => relation.id === relationId)) {
+            return { command: null, status: `关系不存在：${relationId}`, statusTone: 'warning' };
+        }
+        return { command: null, status: `高亮关系：${relationId}`, statusTone: 'success' };
+    }
+    if (input.action === 'delete') {
+        const relationId = input.relationId.trim();
+        if (!relationId)
+            return { command: null, status: '请选择要删除的关系。', statusTone: 'warning' };
+        if (!graph.relations.some(relation => relation.id === relationId)) {
+            return { command: null, status: `关系不存在：${relationId}`, statusTone: 'warning' };
+        }
+        return {
+            command: { type: 'relation.delete', relationId },
+            status: `删除关系：${relationId}`,
+            statusTone: 'success',
+        };
+    }
+    if (input.action !== 'create') {
+        return { command: null, status: '暂不支持的关系操作。', statusTone: 'warning' };
+    }
+    const type = input.type.trim();
+    if (!type)
+        return { command: null, status: '请选择关系类型。', statusTone: 'warning' };
+    const fromId = input.fromId?.trim() || activeMarkerId || '';
+    const fromKind = input.fromKind?.trim() || (fromId && activeMarkerId && fromId === activeMarkerId ? 'marker' : undefined);
+    const from = createRelationEndpointFromInput(fromKind, fromId, graph, hierarchy);
+    const to = createRelationEndpointFromInput(input.toKind, input.toId || '', graph, hierarchy);
+    if (!from)
+        return { command: null, status: '请选择有效的起点。', statusTone: 'warning' };
+    if (!to)
+        return { command: null, status: '请选择有效的终点。', statusTone: 'warning' };
+    if (from.kind === to.kind && from.id === to.id) {
+        return { command: null, status: '关系起点和终点不能相同。', statusTone: 'warning' };
+    }
+    const duplicate = graph.relations.find(relation => (relation.type === type
+        && relation.from.kind === from.kind
+        && relation.from.id === from.id
+        && relation.to.kind === to.kind
+        && relation.to.id === to.id));
+    if (duplicate) {
+        return { command: null, status: `关系已存在：${duplicate.id}`, statusTone: 'warning' };
+    }
+    const typeDefinition = relationTypes.find(definition => definition.type === type);
+    const directed = input.directed ?? typeDefinition?.directed ?? true;
+    const relation = {
+        id: createUniqueSpatialRelationId(graph.relations, type, from, to),
+        type,
+        label: typeDefinition?.label,
+        from,
+        to,
+        directed,
+    };
+    return {
+        command: { type: 'relation.create', relation },
+        status: `创建关系：${from.label ?? from.id} ${typeDefinition?.label ?? type} ${to.label ?? to.id}`,
+        statusTone: 'success',
+    };
+}
+export function createMarkerRelationCreateManyCommand(input, graph, relationTypes = [], hierarchy = [], activeMarkerId = null) {
+    if (!graph)
+        return { command: null, status: '当前文档没有 marker graph。', statusTone: 'warning' };
+    const type = input.type.trim();
+    if (!type)
+        return { command: null, status: '请选择关系类型。', statusTone: 'warning' };
+    const fromId = input.fromId?.trim() || activeMarkerId || '';
+    const fromKind = input.fromKind?.trim() || (fromId && activeMarkerId && fromId === activeMarkerId ? 'marker' : undefined);
+    const from = createRelationEndpointFromInput(fromKind, fromId, graph, hierarchy);
+    if (!from)
+        return { command: null, status: '请选择有效的起点。', statusTone: 'warning' };
+    const typeDefinition = relationTypes.find(definition => definition.type === type);
+    const directed = input.directed ?? typeDefinition?.directed ?? true;
+    const nextRelations = [];
+    let duplicateCount = 0;
+    let invalidCount = 0;
+    const seenTargets = new Set();
+    for (const endpointInput of input.toEndpoints) {
+        const targetKey = createRelationEndpointKey(endpointInput.kind ?? '', endpointInput.id ?? '');
+        if (seenTargets.has(targetKey)) {
+            duplicateCount += 1;
+            continue;
+        }
+        seenTargets.add(targetKey);
+        const to = createRelationEndpointFromInput(endpointInput.kind, endpointInput.id ?? '', graph, hierarchy);
+        if (!to || (from.kind === to.kind && from.id === to.id)) {
+            invalidCount += 1;
+            continue;
+        }
+        const duplicate = [...graph.relations, ...nextRelations].find(relation => isSameRelationIdentity(relation, type, from, to));
+        if (duplicate) {
+            duplicateCount += 1;
+            continue;
+        }
+        nextRelations.push({
+            id: createUniqueSpatialRelationId([...graph.relations, ...nextRelations], type, from, to),
+            type,
+            label: typeDefinition?.label,
+            from,
+            to,
+            directed,
+        });
+    }
+    if (nextRelations.length === 0) {
+        const reason = invalidCount > 0 && duplicateCount > 0
+            ? `无可创建关系：${invalidCount} 个无效端点，${duplicateCount} 个重复关系。`
+            : invalidCount > 0
+                ? `无可创建关系：${invalidCount} 个无效端点。`
+                : duplicateCount > 0
+                    ? `关系已存在，跳过 ${duplicateCount} 个重复关系。`
+                    : '请选择有效的终点。';
+        return { command: null, status: reason, statusTone: 'warning' };
+    }
+    const skippedParts = [
+        duplicateCount > 0 ? `跳过 ${duplicateCount} 个重复关系` : '',
+        invalidCount > 0 ? `跳过 ${invalidCount} 个无效端点` : '',
+    ].filter(Boolean);
+    return {
+        command: nextRelations.length === 1
+            ? { type: 'relation.create', relation: nextRelations[0] }
+            : { type: 'relation.create-many', relations: nextRelations },
+        status: skippedParts.length > 0
+            ? `创建 ${nextRelations.length} 条关系，${skippedParts.join('，')}。`
+            : `创建 ${nextRelations.length} 条关系。`,
+        statusTone: skippedParts.length > 0 ? 'warning' : 'success',
+    };
+}
+export function createMarkerRelationDeleteManyCommand(relationIds, graph) {
+    if (!graph)
+        return { command: null, status: '当前文档没有 marker graph。', statusTone: 'warning' };
+    const existingIds = new Set(graph.relations.map(relation => relation.id));
+    const ids = [...new Set(relationIds.map(id => id.trim()).filter(id => id && existingIds.has(id)))];
+    if (ids.length === 0)
+        return { command: null, status: '请选择要删除的关系。', statusTone: 'warning' };
+    return {
+        command: ids.length === 1
+            ? { type: 'relation.delete', relationId: ids[0] }
+            : { type: 'relation.delete-many', relationIds: ids },
+        status: `删除 ${ids.length} 条关系。`,
+        statusTone: 'success',
+    };
+}
+export function createMarkerRelationDeleteConnectedCommand(markerId, graph) {
+    const id = markerId.trim();
+    if (!id)
+        return { command: null, status: '请选择标记。', statusTone: 'warning' };
+    const relationIds = (graph?.relations ?? [])
+        .filter(relation => endpointMatchesMarker(relation.from, id) || endpointMatchesMarker(relation.to, id))
+        .map(relation => relation.id);
+    return createMarkerRelationDeleteManyCommand(relationIds, graph);
+}
+export function createMarkerRelationReverseCommand(relationId, graph) {
+    if (!graph)
+        return { command: null, status: '当前文档没有 marker graph。', statusTone: 'warning' };
+    const id = relationId.trim();
+    if (!id)
+        return { command: null, status: '请选择要反转的关系。', statusTone: 'warning' };
+    const relation = graph.relations.find(candidate => candidate.id === id) ?? null;
+    if (!relation)
+        return { command: null, status: `关系不存在：${id}`, statusTone: 'warning' };
+    const duplicate = graph.relations.find(candidate => (candidate.id !== relation.id
+        && isSameRelationIdentity(candidate, relation.type, relation.to, relation.from)));
+    if (duplicate)
+        return { command: null, status: `反转后关系会重复：${duplicate.id}`, statusTone: 'warning' };
+    return {
+        command: { type: 'relation.reverse', relationId: relation.id },
+        status: `反转关系：${relation.label ?? relation.type}`,
+        statusTone: 'success',
+    };
+}
+function createMarkerRelationTypeItems(relationTypes) {
+    return relationTypes.map(definition => ({
+        type: definition.type,
+        label: definition.label || definition.type,
+        directed: definition.directed,
+        description: definition.description,
+    }));
+}
+export function createMarkerRelationEndpointOptions(graph, hierarchy = [], visibility = {}) {
+    if (!graph)
+        return [];
+    const endpoints = new Map();
+    for (const marker of graph.markers) {
+        const hidden = isMarkerEndpointHiddenForRelationPanel(marker.id, graph, hierarchy, visibility);
+        endpoints.set(createRelationEndpointKey('marker', marker.id), {
+            kind: 'marker',
+            id: marker.id,
+            label: marker.label || marker.id,
+            ...(hidden ? { visibility: 'hidden', status: '已隐藏' } : {}),
+        });
+    }
+    for (const item of hierarchy) {
+        if (!isSceneObjectRelationEndpoint(item))
+            continue;
+        const key = createRelationEndpointKey('scene-object', item.id);
+        if (endpoints.has(key))
+            continue;
+        endpoints.set(key, {
+            kind: 'scene-object',
+            id: item.id,
+            label: item.label || item.id,
+        });
+    }
+    return [...endpoints.values()].sort((left, right) => {
+        const kindOrder = relationEndpointKindOrder(left.kind) - relationEndpointKindOrder(right.kind);
+        return kindOrder || left.label.localeCompare(right.label) || left.id.localeCompare(right.id);
+    });
+}
+function isMarkerEndpointHiddenForRelationPanel(markerId, graph, hierarchy, visibility) {
+    const hiddenMarkerIds = normalizeHiddenMarkerIds(visibility.hiddenMarkerIds);
+    if (hiddenMarkerIds.has(markerId))
+        return true;
+    if (isMarkerBackedByHierarchyRow(hierarchy, markerId)) {
+        return hierarchy.find(item => item.id === markerId)?.enabled === false;
+    }
+    return visibility.rootVisible === false;
+}
+function createMarkerRelationItems(graph, relationTypes, hierarchy, activeMarkerId, activeRelationId, visibility) {
+    const endpointOptions = new Map(createMarkerRelationEndpointOptions(graph, hierarchy, visibility).map(endpoint => [createRelationEndpointKey(endpoint.kind, endpoint.id), endpoint]));
+    const relationTypeLabels = new Map(relationTypes.map(definition => [definition.type, definition.label || definition.type]));
+    return graph.relations.map((relation) => {
+        const from = createRelationEndpointItem(relation.from, endpointOptions);
+        const to = createRelationEndpointItem(relation.to, endpointOptions);
+        const endpointStatus = [from.status, to.status].filter(Boolean).join('; ');
+        const visibilityStatus = visibility.markersVisible === false
+            ? '标记视图已关闭，关系线暂不显示'
+            : endpointStatus;
+        return {
+            id: relation.id,
+            type: relation.type,
+            typeLabel: relation.label || relationTypeLabels.get(relation.type) || relation.type,
+            directed: relation.directed ?? relationTypes.find(definition => definition.type === relation.type)?.directed ?? true,
+            from,
+            to,
+            selected: !!activeMarkerId && (endpointMatchesMarker(relation.from, activeMarkerId) || endpointMatchesMarker(relation.to, activeMarkerId)),
+            active: !!activeRelationId && relation.id === activeRelationId,
+            ...(visibilityStatus ? { status: visibilityStatus, statusTone: 'warning' } : {}),
+        };
+    });
+}
+function isSameRelationIdentity(relation, type, from, to) {
+    return relation.type === type
+        && relation.from.kind === from.kind
+        && relation.from.id === from.id
+        && relation.to.kind === to.kind
+        && relation.to.id === to.id;
+}
+function createRelationEndpointItem(endpoint, endpointOptions) {
+    const match = endpointOptions.get(createRelationEndpointKey(endpoint.kind, endpoint.id));
+    if (match)
+        return { ...match };
+    return {
+        kind: endpoint.kind,
+        id: endpoint.id,
+        label: endpoint.label || endpoint.id,
+        disabled: true,
+        status: isSupportedRelationEndpointKind(endpoint.kind)
+            ? '目标不存在'
+            : `暂不支持的端点类型：${endpoint.kind}`,
+    };
+}
+function createRelationEndpointFromInput(kindInput, idInput, graph, hierarchy) {
+    const kind = normalizeRelationEndpointKind(kindInput);
+    const id = idInput?.trim() ?? '';
+    if (!kind || !id)
+        return null;
+    const endpoint = createMarkerRelationEndpointOptions(graph, hierarchy)
+        .find(candidate => candidate.kind === kind && candidate.id === id && candidate.disabled !== true);
+    if (!endpoint)
+        return null;
+    return {
+        kind,
+        id,
+        label: endpoint.label,
+    };
+}
+function normalizeRelationEndpointKind(kind) {
+    const normalized = kind?.trim();
+    return normalized === 'marker' || normalized === 'scene-object' ? normalized : null;
+}
+function isSupportedRelationEndpointKind(kind) {
+    return kind === 'marker' || kind === 'scene-object';
+}
+function isSceneObjectRelationEndpoint(item) {
+    return item.role !== 'root' && item.role !== 'group' && item.role !== 'marker';
+}
+function createUniqueSpatialRelationId(relations, type, from, to) {
+    const existing = new Set(relations.map(relation => relation.id));
+    const base = [
+        'rel',
+        relationIdSegment(type),
+        relationIdSegment(from.kind),
+        relationIdSegment(from.id),
+        relationIdSegment(to.kind),
+        relationIdSegment(to.id),
+    ].join('_');
+    if (!existing.has(base))
+        return base;
+    let index = 2;
+    let candidate = `${base}-${index}`;
+    while (existing.has(candidate)) {
+        index += 1;
+        candidate = `${base}-${index}`;
+    }
+    return candidate;
+}
+function relationIdSegment(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'unknown';
+}
+function createRelationEndpointKey(kind, id) {
+    return `${kind}:${id}`;
+}
+function relationEndpointKindOrder(kind) {
+    if (kind === 'marker')
+        return 0;
+    if (kind === 'scene-object')
+        return 1;
+    return 2;
+}
+export function createMarkerGraphPatchFromInspectorEdit(graph, payload, hierarchy, markerTypes = []) {
+    const markerId = readSpatialMarkerIdFromHierarchySelection(graph, payload.targetId, hierarchy);
+    if (!markerId)
+        return null;
+    const marker = findSpatialMarkerById(graph, markerId);
+    if (!marker)
+        return null;
+    if (payload.path === 'marker.label') {
+        const label = typeof payload.value === 'string' ? payload.value.trim() : '';
+        if (!label)
+            return null;
+        return {
+            type: 'marker.update',
+            markerId: marker.id,
+            patch: { label },
+        };
+    }
+    if (payload.path === 'marker.markerType') {
+        const markerType = typeof payload.value === 'string' ? payload.value.trim() : '';
+        if (!markerType)
+            return null;
+        const markerTypeDefinition = markerTypes.find(definition => definition.type === markerType) ?? null;
+        if (markerTypeDefinition) {
+            return {
+                type: 'marker.update',
+                markerId: marker.id,
+                patch: createMarkerPresentationPatch(marker, markerTypeDefinition),
+            };
+        }
+        return {
+            type: 'marker.update',
+            markerId: marker.id,
+            patch: { markerType },
+        };
+    }
+    if (payload.path === 'marker.tags') {
+        return {
+            type: 'marker.update',
+            markerId: marker.id,
+            patch: {
+                tags: readMarkerTags(payload.value),
+            },
+        };
+    }
+    if (payload.path === 'marker.metadata.color') {
+        const color = readMarkerColor(payload.value);
+        if (!color)
+            return null;
+        return {
+            type: 'marker.update',
+            markerId: marker.id,
+            patch: {
+                metadata: {
+                    ...(marker.metadata ?? {}),
+                    color,
+                },
+            },
+        };
+    }
+    if (payload.path === 'marker.metadata.note') {
+        const note = typeof payload.value === 'string' ? payload.value.trim() : '';
+        return {
+            type: 'marker.update',
+            markerId: marker.id,
+            patch: {
+                metadata: {
+                    ...(marker.metadata ?? {}),
+                    note,
+                },
+            },
+        };
+    }
+    return null;
+}
+export function resolveSpatialMarkerNode(marker) {
+    return {
+        ...marker,
+        tags: marker.tags ? [...marker.tags] : undefined,
+        metadata: marker.metadata ? { ...marker.metadata } : undefined,
+        spatial: resolveSpatialFacts(marker.geometry, marker),
+    };
+}
+export function resolveSpatialFacts(geometry, marker) {
+    switch (geometry.kind) {
+        case 'box':
+            return resolveBoxSpatialFacts(geometry.center, geometry.size, geometry.rotation, marker);
+        case 'point':
+            if (geometry.coordinateSpace === 'world') {
+                return {
+                    status: 'resolved',
+                    coordinateSpace: 'world',
+                    origin: cloneVec3(geometry.position),
+                    bounds: createBounds([geometry.position]),
+                    dimensions: createVec3(0, 0, 0),
+                    localFrame: createMarkerLocalFrame(geometry.position, marker),
+                    target: geometry.target,
+                };
+            }
+            return createUnresolvedSpatialFacts('Local-space point markers require a target transform resolver and are not resolved in the MVP.', geometry.target);
+        case 'object-bounds':
+            if (marker?.semanticFrame?.origin) {
+                return {
+                    status: 'resolved',
+                    coordinateSpace: 'world',
+                    origin: cloneVec3(marker.semanticFrame.origin),
+                    bounds: createBounds([marker.semanticFrame.origin]),
+                    dimensions: createVec3(0, 0, 0),
+                    localFrame: createMarkerLocalFrame(marker.semanticFrame.origin, marker),
+                    target: geometry.target,
+                };
+            }
+            return createUnresolvedSpatialFacts('Object-bounds markers require an object bounds resolver and are not resolved in this pure graph pass.', geometry.target);
+        case 'polyhedron':
+            if (geometry.vertices.length === 0) {
+                return createUnresolvedSpatialFacts('Polyhedron marker has no vertices.');
+            }
+            return {
+                status: 'resolved',
+                coordinateSpace: 'world',
+                origin: averageVec3(geometry.vertices),
+                bounds: createBounds(geometry.vertices),
+                dimensions: createBounds(geometry.vertices).size,
+                corners: geometry.vertices.map(cloneVec3),
+                localFrame: createMarkerLocalFrame(averageVec3(geometry.vertices), marker),
+            };
+    }
+}
+export function getSpatialMarkerDirectRelations(graph, markerId) {
+    return graph.relations
+        .filter(relation => endpointMatchesMarker(relation.from, markerId) || endpointMatchesMarker(relation.to, markerId))
+        .map(relation => ({ ...relation }));
+}
+export function getSpatialRelationRelatedIds(relations, markerId) {
+    const markerIds = new Set();
+    const objectIds = new Set();
+    for (const relation of relations) {
+        collectRelatedEndpoint(relation.from, markerId, markerIds, objectIds);
+        collectRelatedEndpoint(relation.to, markerId, markerIds, objectIds);
+    }
+    return {
+        markerIds: [...markerIds],
+        objectIds: [...objectIds],
+    };
+}
+export function findSpatialMarkerById(graph, markerId) {
+    return graph?.markers.find(marker => marker.id === markerId) ?? null;
+}
+function createMarkerIdentityInspectorSection(document, marker, markerTypes) {
+    const markerTypeOptions = [
+        { label: '未选择', value: '' },
+        ...markerTypes.map(definition => ({
+            label: formatMarkerTypeLabel(definition.type, definition.label),
+            value: definition.type,
+        })),
+    ];
+    return {
+        id: 'marker',
+        title: '标记',
+        order: 0,
+        persistence: 'document',
+        properties: [
+            createMarkerInspectorProperty(document, {
+                path: 'marker.label',
+                label: '名称',
+                value: marker.label,
+                valueType: 'string',
+                control: 'string',
+                order: 0,
+            }),
+            createMarkerInspectorProperty(document, {
+                path: 'marker.markerType',
+                label: '标记类型',
+                value: marker.markerType,
+                valueType: 'enum',
+                control: markerTypeOptions.length > 0 ? 'enum' : 'string',
+                options: markerTypeOptions.length > 0 ? markerTypeOptions : undefined,
+                order: 1,
+            }),
+            createMarkerInspectorProperty(document, {
+                path: 'marker.kind',
+                label: '空间类别',
+                value: marker.kind,
+                valueType: 'string',
+                control: 'readonly',
+                readOnly: true,
+                persistence: 'readonly',
+                order: 2,
+            }),
+            createMarkerInspectorProperty(document, {
+                path: 'marker.tags',
+                label: '标签',
+                value: marker.tags?.join(', ') ?? '',
+                valueType: 'string',
+                control: 'string',
+                order: 3,
+            }),
+            createMarkerInspectorProperty(document, {
+                path: 'marker.metadata.color',
+                label: '颜色',
+                value: readMarkerColor(marker.metadata?.color) ?? createMarkerColor(0.1, 0.85, 1),
+                valueType: 'color',
+                control: 'color',
+                commitMode: 'immediate',
+                order: 4,
+            }),
+            createMarkerInspectorProperty(document, {
+                path: 'marker.metadata.note',
+                label: '备注',
+                value: typeof marker.metadata?.note === 'string' ? marker.metadata.note : '',
+                valueType: 'string',
+                control: 'string',
+                order: 5,
+            }),
+        ],
+    };
+}
+function createMarkerGeometryInspectorSection(document, marker) {
+    return {
+        id: 'markerGeometry',
+        title: '几何',
+        order: 10,
+        persistence: 'readonly',
+        properties: [
+            createMarkerInspectorProperty(document, {
+                path: 'marker.geometry.kind',
+                label: '几何',
+                value: marker.geometry.kind,
+                valueType: 'string',
+                control: 'readonly',
+                readOnly: true,
+                persistence: 'readonly',
+                order: 0,
+            }),
+        ],
+    };
+}
+function createMarkerSpatialInspectorSection(document, marker) {
+    const spatial = marker.spatial;
+    const properties = [
+        createMarkerInspectorProperty(document, {
+            path: 'marker.spatial.status',
+            label: '空间',
+            value: spatial.status,
+            valueType: 'string',
+            control: 'readonly',
+            readOnly: true,
+            persistence: 'readonly',
+            order: 0,
+        }),
+    ];
+    if (spatial.bounds) {
+        properties.push(createMarkerInspectorProperty(document, {
+            path: 'marker.spatial.bounds.center',
+            label: '包围盒中心',
+            value: spatial.bounds.center,
+            valueType: 'vec3',
+            control: 'readonly',
+            readOnly: true,
+            persistence: 'readonly',
+            order: 1,
+        }), createMarkerInspectorProperty(document, {
+            path: 'marker.spatial.bounds.size',
+            label: '包围盒尺寸',
+            value: spatial.bounds.size,
+            valueType: 'vec3',
+            control: 'readonly',
+            readOnly: true,
+            persistence: 'readonly',
+            order: 2,
+        }));
+    }
+    if (spatial.origin) {
+        properties.push(createMarkerInspectorProperty(document, {
+            path: 'marker.spatial.origin',
+            label: '锚点',
+            value: spatial.origin,
+            valueType: 'vec3',
+            control: 'readonly',
+            readOnly: true,
+            persistence: 'readonly',
+            order: 3,
+        }));
+    }
+    if (spatial.localFrame?.forward) {
+        properties.push(createMarkerInspectorProperty(document, {
+            path: 'marker.spatial.localFrame.forward',
+            label: '朝向',
+            value: spatial.localFrame.forward,
+            valueType: 'vec3',
+            control: 'readonly',
+            readOnly: true,
+            persistence: 'readonly',
+            order: 4,
+        }));
+    }
+    if (spatial.localFrame?.right) {
+        properties.push(createMarkerInspectorProperty(document, {
+            path: 'marker.spatial.localFrame.right',
+            label: '右向',
+            value: spatial.localFrame.right,
+            valueType: 'vec3',
+            control: 'readonly',
+            readOnly: true,
+            persistence: 'readonly',
+            order: 5,
+        }));
+    }
+    if (spatial.localFrame?.up) {
+        properties.push(createMarkerInspectorProperty(document, {
+            path: 'marker.spatial.localFrame.up',
+            label: '上向',
+            value: spatial.localFrame.up,
+            valueType: 'vec3',
+            control: 'readonly',
+            readOnly: true,
+            persistence: 'readonly',
+            order: 6,
+        }));
+    }
+    if (spatial.unresolvedReason) {
+        properties.push(createMarkerInspectorProperty(document, {
+            path: 'marker.spatial.unresolvedReason',
+            label: '原因',
+            value: spatial.unresolvedReason,
+            valueType: 'string',
+            control: 'readonly',
+            readOnly: true,
+            persistence: 'readonly',
+            order: 7,
+        }));
+    }
+    return {
+        id: 'markerSpatial',
+        title: '空间',
+        order: 20,
+        persistence: 'readonly',
+        properties,
+    };
+}
+function createMarkerRelationsInspectorSection(document, activeMarkerId, relations, markerTypes, relationTypes, graph, hierarchy, activeRelationId, relationPick, visibility) {
+    const typeLabels = new Map(relationTypes.map(definition => [definition.type, definition.label]));
+    const markerLabels = new Map((graph?.markers ?? []).map(marker => [marker.id, marker.label || marker.id]));
+    const sceneObjectLabels = new Map(hierarchy.map(item => [item.id, item.label || item.id]));
+    const sceneObjectIds = new Set(hierarchy.map(item => item.id));
+    const invalidRelations = relations.filter(relation => (isRelationEndpointInvalid(relation.from, markerLabels, sceneObjectIds)
+        || isRelationEndpointInvalid(relation.to, markerLabels, sceneObjectIds)));
+    const relationPanel = graph
+        ? createMarkerPanelState(graph, markerTypes, relationTypes, hierarchy, activeMarkerId, activeRelationId, relationPick, visibility)
+        : null;
+    const hiddenRelationCount = (relationPanel?.relations ?? []).filter(relation => (relation.selected
+        && (relation.from.visibility === 'hidden' || relation.to.visibility === 'hidden'))).length;
+    const relationStatus = visibility.markersVisible === false
+        ? '标记视图已关闭，关系线暂不显示'
+        : invalidRelations.length > 0
+            ? `${invalidRelations.length} 个关系包含异常端点`
+            : hiddenRelationCount > 0
+                ? `${hiddenRelationCount} 个关系端点已隐藏`
+                : '正常';
+    const relationEditorPanel = graph
+        ? relationPanel
+        : null;
+    return {
+        id: 'markerRelations',
+        title: '关系',
+        order: 30,
+        persistence: 'readonly',
+        properties: [
+            createMarkerInspectorProperty(document, {
+                path: 'marker.relations.count',
+                label: '数量',
+                value: relations.length,
+                valueType: 'number',
+                control: 'readonly',
+                readOnly: true,
+                persistence: 'readonly',
+                order: 0,
+            }),
+            createMarkerInspectorProperty(document, {
+                path: 'marker.relations.summary',
+                label: '直接关系',
+                value: relations.map(relation => ([
+                    formatRelationEndpointSummary(relation.from, markerLabels, sceneObjectLabels),
+                    typeLabels.get(relation.type) ?? relation.type,
+                    formatRelationEndpointSummary(relation.to, markerLabels, sceneObjectLabels),
+                ].join(' '))).join(', ') || '无',
+                valueType: 'string',
+                control: 'readonly',
+                readOnly: true,
+                persistence: 'readonly',
+                order: 1,
+            }),
+            createMarkerInspectorProperty(document, {
+                path: 'marker.relations.status',
+                label: '状态',
+                value: relationStatus,
+                valueType: 'string',
+                control: 'readonly',
+                readOnly: true,
+                persistence: 'readonly',
+                order: 2,
+            }),
+            createMarkerInspectorProperty(document, {
+                path: 'marker.relations.editor',
+                label: '关系设置',
+                value: relationEditorPanel,
+                valueType: 'object',
+                control: 'custom',
+                customControl: 'marker-relation-editor',
+                controlOptions: {
+                    markerPanel: relationEditorPanel,
+                },
+                readOnly: true,
+                persistence: 'readonly',
+                order: 3,
+            }),
+        ],
+    };
+}
+function formatRelationEndpointSummary(endpoint, markerLabels, sceneObjectLabels) {
+    const kindLabel = endpoint.kind === 'marker'
+        ? '标记'
+        : endpoint.kind === 'scene-object'
+            ? '对象'
+            : endpoint.kind;
+    const label = endpoint.label
+        || (endpoint.kind === 'marker'
+            ? markerLabels.get(endpoint.id)
+            : endpoint.kind === 'scene-object'
+                ? sceneObjectLabels.get(endpoint.id)
+                : null)
+        || endpoint.id;
+    return `${kindLabel}:${label}`;
+}
+function isRelationEndpointInvalid(endpoint, markerLabels, sceneObjectIds) {
+    if (!isSupportedRelationEndpointKind(endpoint.kind))
+        return true;
+    if (endpoint.kind === 'marker')
+        return !markerLabels.has(endpoint.id);
+    if (endpoint.kind === 'scene-object')
+        return !sceneObjectIds.has(endpoint.id);
+    return true;
+}
+function formatMarkerTypeLabel(type, fallback) {
+    switch (type) {
+        case 'collection-area': return '采集区域';
+        case 'trade-zone': return '交易区';
+        case 'entrance': return '入口';
+        case 'exit': return '出口';
+        case 'effect-socket': return '特效挂点';
+        default: return fallback;
+    }
+}
+function createMarkerInspectorProperty(document, input) {
+    const readOnly = input.readOnly === true;
+    return {
+        ...input,
+        readOnly,
+        persistence: input.persistence ?? (readOnly ? 'readonly' : 'document'),
+        commitMode: input.commitMode ?? (readOnly ? 'change' : 'blur'),
+        document,
+        validate: input.readOnly ? undefined : createMarkerInspectorValidator(input.path),
+    };
+}
+function createMarkerInspectorValidator(path) {
+    if (path === 'marker.label' || path === 'marker.markerType') {
+        return (value) => {
+            if (typeof value === 'string' && value.trim())
+                return { ok: true, value: value.trim() };
+            return { ok: false, message: 'Marker value must be a non-empty string.' };
+        };
+    }
+    if (path === 'marker.tags') {
+        return (value) => ({ ok: true, value: readMarkerTags(value).join(', ') });
+    }
+    if (path === 'marker.metadata.color') {
+        return (value) => {
+            const color = readMarkerColor(value);
+            return color
+                ? { ok: true, value: color }
+                : { ok: false, message: 'Marker color must be a valid RGB color.' };
+        };
+    }
+    if (path === 'marker.metadata.note') {
+        return (value) => ({
+            ok: true,
+            value: typeof value === 'string' ? value.trim() : '',
+        });
+    }
+    return undefined;
+}
+function createMarkerPresentationPatch(marker, markerTypeDefinition) {
+    const markerKind = normalizeMarkerPresentationKind(markerTypeDefinition.kind ?? marker.kind);
+    return {
+        markerType: markerTypeDefinition.type,
+        kind: markerKind,
+        geometry: createMarkerPresentationGeometry(marker.geometry, markerKind),
+    };
+}
+function createMarkerPresentationGeometry(geometry, markerKind) {
+    if (markerKind === 'region') {
+        if (geometry.kind === 'box')
+            return structuredClone(geometry);
+        return {
+            kind: 'box',
+            coordinateSpace: 'world',
+            center: getSpatialMarkerGeometryOrigin(geometry),
+            size: { x: 4, y: 1, z: 4 },
+        };
+    }
+    if (markerKind === 'object' && geometry.kind === 'object-bounds')
+        return structuredClone(geometry);
+    if (geometry.kind === 'point')
+        return structuredClone(geometry);
+    return {
+        kind: 'point',
+        coordinateSpace: 'world',
+        position: getSpatialMarkerGeometryOrigin(geometry),
+        ...(geometry.kind === 'object-bounds' ? { target: structuredClone(geometry.target) } : {}),
+    };
+}
+function getSpatialMarkerGeometryOrigin(geometry) {
+    switch (geometry.kind) {
+        case 'box':
+            return { ...geometry.center };
+        case 'point':
+            return { ...geometry.position };
+        case 'object-bounds':
+            return { x: 0, y: 0, z: 0 };
+        case 'polyhedron':
+            return geometry.vertices.length > 0
+                ? createBoundsCenter(geometry.vertices)
+                : { x: 0, y: 0, z: 0 };
+    }
+}
+function normalizeMarkerPresentationKind(kind) {
+    const normalized = kind?.trim();
+    if (!normalized)
+        return 'point';
+    if (normalized === 'object-bound' || normalized === 'object-bounds')
+        return 'object';
+    return normalized;
+}
+function createBoundsCenter(points) {
+    const min = {
+        x: Math.min(...points.map(point => point.x)),
+        y: Math.min(...points.map(point => point.y)),
+        z: Math.min(...points.map(point => point.z)),
+    };
+    const max = {
+        x: Math.max(...points.map(point => point.x)),
+        y: Math.max(...points.map(point => point.y)),
+        z: Math.max(...points.map(point => point.z)),
+    };
+    return {
+        x: (min.x + max.x) / 2,
+        y: (min.y + max.y) / 2,
+        z: (min.z + max.z) / 2,
+    };
+}
+function readVec3(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const candidate = value;
+    const x = Number(candidate.x);
+    const y = Number(candidate.y);
+    const z = Number(candidate.z);
+    return Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z)
+        ? createVec3(x, y, z)
+        : null;
+}
+function resolveBoxSpatialFacts(center, size, rotation, marker) {
+    const corners = createBoxCorners(center, size, rotation);
+    const bounds = createBounds(corners);
+    return {
+        status: 'resolved',
+        coordinateSpace: 'world',
+        origin: cloneVec3(center),
+        bounds,
+        dimensions: cloneVec3(size),
+        corners,
+        localFrame: {
+            ...createBoxLocalFrame(center, rotation),
+            label: marker?.label,
+        },
+    };
+}
+function createUnresolvedSpatialFacts(unresolvedReason, target) {
+    return {
+        status: 'unresolved',
+        coordinateSpace: 'world',
+        target,
+        unresolvedReason,
+    };
+}
+function createBoxCorners(center, size, rotation) {
+    const half = {
+        x: size.x / 2,
+        y: size.y / 2,
+        z: size.z / 2,
+    };
+    const offsets = [
+        createVec3(-half.x, -half.y, -half.z),
+        createVec3(half.x, -half.y, -half.z),
+        createVec3(-half.x, half.y, -half.z),
+        createVec3(half.x, half.y, -half.z),
+        createVec3(-half.x, -half.y, half.z),
+        createVec3(half.x, -half.y, half.z),
+        createVec3(-half.x, half.y, half.z),
+        createVec3(half.x, half.y, half.z),
+    ];
+    return offsets.map(offset => addVec3(center, rotateVec3(offset, rotation)));
+}
+function createBoxLocalFrame(origin, rotation) {
+    return {
+        origin: cloneVec3(origin),
+        right: rotateVec3(createVec3(1, 0, 0), rotation),
+        up: rotateVec3(createVec3(0, 1, 0), rotation),
+        forward: rotateVec3(createVec3(0, 0, 1), rotation),
+    };
+}
+function createMarkerLocalFrame(origin, marker) {
+    const authoredFrame = marker?.semanticFrame;
+    return {
+        origin: cloneVec3(origin),
+        right: authoredFrame?.right ? cloneVec3(authoredFrame.right) : createVec3(1, 0, 0),
+        up: authoredFrame?.up ? cloneVec3(authoredFrame.up) : createVec3(0, 1, 0),
+        forward: authoredFrame?.forward ? cloneVec3(authoredFrame.forward) : createVec3(0, 0, 1),
+        label: authoredFrame?.label ?? marker?.label,
+        ...(authoredFrame?.description ? { description: authoredFrame.description } : {}),
+    };
+}
+function createBounds(points) {
+    const first = points[0] ?? createVec3(0, 0, 0);
+    const min = cloneVec3(first);
+    const max = cloneVec3(first);
+    for (const point of points.slice(1)) {
+        min.x = Math.min(min.x, point.x);
+        min.y = Math.min(min.y, point.y);
+        min.z = Math.min(min.z, point.z);
+        max.x = Math.max(max.x, point.x);
+        max.y = Math.max(max.y, point.y);
+        max.z = Math.max(max.z, point.z);
+    }
+    const size = createVec3(max.x - min.x, max.y - min.y, max.z - min.z);
+    return {
+        min,
+        max,
+        size,
+        center: createVec3(min.x + size.x / 2, min.y + size.y / 2, min.z + size.z / 2),
+    };
+}
+function rotateVec3(vector, rotation) {
+    if (!rotation)
+        return cloneVec3(vector);
+    const cx = Math.cos(rotation.x);
+    const sx = Math.sin(rotation.x);
+    const cy = Math.cos(rotation.y);
+    const sy = Math.sin(rotation.y);
+    const cz = Math.cos(rotation.z);
+    const sz = Math.sin(rotation.z);
+    const y1 = vector.y * cx - vector.z * sx;
+    const z1 = vector.y * sx + vector.z * cx;
+    const x1 = vector.x;
+    const x2 = x1 * cy + z1 * sy;
+    const z2 = -x1 * sy + z1 * cy;
+    const y2 = y1;
+    return {
+        x: x2 * cz - y2 * sz,
+        y: x2 * sz + y2 * cz,
+        z: z2,
+    };
+}
+function addVec3(left, right) {
+    return createVec3(left.x + right.x, left.y + right.y, left.z + right.z);
+}
+function averageVec3(points) {
+    const sum = points.reduce((accumulator, point) => addVec3(accumulator, point), createVec3(0, 0, 0));
+    return createVec3(sum.x / points.length, sum.y / points.length, sum.z / points.length);
+}
+function readMarkerTags(value) {
+    if (Array.isArray(value)) {
+        return [...new Set(value
+                .map(item => typeof item === 'string' ? item.trim() : '')
+                .filter(Boolean))];
+    }
+    if (typeof value !== 'string')
+        return [];
+    return [...new Set(value
+            .split(',')
+            .map(item => item.trim())
+            .filter(Boolean))];
+}
+function readMarkerColor(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const candidate = value;
+    const r = readColorChannel(candidate.r);
+    const g = readColorChannel(candidate.g);
+    const b = readColorChannel(candidate.b);
+    return r == null || g == null || b == null
+        ? null
+        : createMarkerColor(r, g, b);
+}
+function readColorChannel(value) {
+    const channel = Number(value);
+    if (!Number.isFinite(channel))
+        return null;
+    return Math.min(1, Math.max(0, channel));
+}
+function createMarkerColor(r, g, b) {
+    return { r, g, b };
+}
+function cloneVec3(value) {
+    return createVec3(value.x, value.y, value.z);
+}
+function createVec3(x, y, z) {
+    return { x, y, z };
+}
+function endpointMatchesMarker(endpoint, markerId) {
+    return endpoint.kind === 'marker' && endpoint.id === markerId;
+}
+function collectRelatedEndpoint(endpoint, markerId, markerIds, objectIds) {
+    if (endpoint.kind === 'marker') {
+        if (endpoint.id !== markerId)
+            markerIds.add(endpoint.id);
+        return;
+    }
+    if (endpoint.kind === 'scene-object') {
+        objectIds.add(endpoint.id);
+    }
+}
+//# sourceMappingURL=local-editor-marker-graph.js.map