@oml/language 0.13.0 → 0.14.1

package/src/oml/oml-diagram.ts

@@ -0,0 +1,1708 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import * as ElkModule from 'elkjs/lib/elk.bundled.js';
+import { URI } from 'langium';
+import type { AstNode, LangiumDocument } from 'langium';
+import type { SModelElement, SModelRoot } from 'sprotty-protocol';
+import {
+    isAspect,
+    isConcept,
+    isConceptInstance,
+    isDescription,
+    isDescriptionBundle,
+    isEquivalenceAxiom,
+    isImport,
+    isInstanceEnumerationAxiom,
+    isLiteralEnumerationAxiom,
+    isOntology,
+    isPropertyValueAssertion,
+    isRelation,
+    isRelationEntity,
+    isRelationInstance,
+    isScalar,
+    isScalarProperty,
+    isSpecializationAxiom,
+    isUnreifiedRelation,
+    isVocabulary,
+    isVocabularyBundle,
+    type Import,
+    type Ontology
+} from './generated/ast.js';
+import { getOntologyModelIndex } from './oml-index.js';
+import {
+    collectOntologyMembers,
+    findOntologyMemberByName,
+    getIriForNode,
+    getModelIdForNode,
+    getNamedElementName,
+    humanizeTypeName,
+    normalizeNamespace,
+    splitIri
+} from './oml-utils.js';
+
+export type RangeResponse = {
+    uri: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+};
+
+type DiagramEntry = {
+    id: string;
+    modelId: string;
+    text: string;
+    qualifiedText?: string;
+    tooltip?: string;
+    statement?: AstNode;
+};
+
+type DiagramNode = {
+    id: string;
+    viewId: string;
+    modelId: string;
+    iri?: string;
+    label: string;
+    instanceTypeLabels?: string[];
+    qualifiedLabel?: string;
+    tooltip?: string;
+    propertyEntries?: DiagramEntry[];
+    compartmentEntries?: DiagramEntry[];
+    kind: 'entity' | 'instance' | 'ontology' | 'relation' | 'equivalence';
+    statement?: AstNode;
+};
+
+type DiagramEdge = {
+    id: string;
+    viewId: string;
+    modelId: string;
+    iri?: string;
+    sourceId: string;
+    targetId: string;
+    label: string;
+    qualifiedLabel?: string;
+    tooltip?: string;
+    kind: 'relation' | 'relation-source' | 'relation-target' | 'specialization' | 'equivalence' | 'equivalence-source' | 'import';
+    statement?: AstNode;
+};
+
+type DiagramGraph = {
+    rootUri: string;
+    root: Ontology;
+    nodes: DiagramNode[];
+    edges: DiagramEdge[];
+    statementsById: Map<string, AstNode>;
+};
+
+type AstRef = {
+    uri: string;
+    path: string;
+};
+
+type DiagramBuildContext = {
+    root: Ontology;
+    nsToPrefix: Map<string, string>;
+};
+
+const ElkConstructor = (ElkModule as any).default || ElkModule;
+let elkPromise: Promise<any> | undefined;
+const navigationIndex = new Map<string, Map<string, AstRef>>();
+
+async function getElk(): Promise<any> {
+    if (!elkPromise) {
+        elkPromise = (async () => {
+            try {
+                const workerModule = await import('elkjs/lib/elk-worker.js');
+                const ElkWorkerCtor = (workerModule as any).Worker
+                    || (workerModule as any).default?.Worker
+                    || (workerModule as any).default
+                    || workerModule;
+                return new ElkConstructor({
+                    algorithms: ['layered'],
+                    workerFactory: (url?: string) => new ElkWorkerCtor(url) as unknown
+                });
+            } catch (error) {
+                console.error('[OML Diagram] Failed to initialize ELK:', error);
+                return {
+                    layout: async (graph: any) => graph
+                };
+            }
+        })();
+    }
+    return await elkPromise;
+}
+
+function getAstNodeLocator(shared: any): { getAstNodePath(node: any): string; getAstNode(root: any, path: string): any } | undefined {
+    const isLocator = (candidate: any): boolean =>
+        !!candidate
+        && typeof candidate.getAstNodePath === 'function'
+        && typeof candidate.getAstNode === 'function';
+
+    const direct = shared?.workspace?.AstNodeLocator ?? shared?.AstNodeLocator;
+    if (isLocator(direct)) {
+        return direct;
+    }
+
+    const registry: any = shared?.ServiceRegistry;
+    if (!registry) {
+        return undefined;
+    }
+    const all = registry.all;
+    const services = Array.isArray(all)
+        ? all
+        : (typeof all?.toArray === 'function' ? all.toArray() : Array.from((all ?? []) as Iterable<any>));
+    for (const languageServices of services) {
+        const locator = languageServices?.workspace?.AstNodeLocator ?? languageServices?.AstNodeLocator;
+        if (isLocator(locator)) {
+            return locator;
+        }
+    }
+    return undefined;
+}
+
+function buildDiagramContext(root: Ontology): DiagramBuildContext {
+    const nsToPrefix = new Map<string, string>();
+    for (const ownedImport of (((root as any).ownedImports ?? []) as Import[])) {
+        if (!isImport(ownedImport)) continue;
+        const importedOntology = (ownedImport as any).imported?.ref;
+        const prefix = (ownedImport as any).prefix;
+        if (!importedOntology || !prefix) continue;
+        const ns = normalizeNamespace(String((importedOntology as any).namespace ?? '').replace(/^<|>$/g, ''));
+        if (!ns) continue;
+        nsToPrefix.set(ns, prefix);
+    }
+    return { root, nsToPrefix };
+}
+
+function getContainingOntology(astNode: any): any {
+    let current = astNode;
+    while (current && !isOntology(current)) {
+        current = current.$container;
+    }
+    return current;
+}
+
+function unwrapReferenceValue(candidate: any): any {
+    if (!candidate || typeof candidate !== 'object') {
+        return candidate;
+    }
+    if ('$refText' in candidate && 'ref' in candidate) {
+        return (candidate as any).ref;
+    }
+    return candidate;
+}
+
+function getQualifiedName(ctx: DiagramBuildContext, astNode: any): string | undefined {
+    const value = unwrapReferenceValue(astNode);
+    if (!value) {
+        return undefined;
+    }
+
+    const iri = getIriForNode(value);
+    if (iri) {
+        const parts = splitIri(iri);
+        if (parts?.fragment) {
+            const prefix = ctx.nsToPrefix.get(normalizeNamespace(parts.base));
+            return prefix ? `${prefix}:${parts.fragment}` : parts.fragment;
+        }
+    }
+
+    if (isOntology(value)) {
+        const namespace = normalizeNamespace(String((value as any).namespace ?? '').replace(/^<|>$/g, ''));
+        if (!namespace) {
+            return undefined;
+        }
+        const prefix = (value as any).prefix;
+        if (typeof prefix === 'string' && prefix.length > 0) {
+            return prefix;
+        }
+        return namespace;
+    }
+
+    const name = getNamedElementName(value);
+    if (!name) {
+        return undefined;
+    }
+
+    const owningOntology = getContainingOntology(value);
+    const namespace = normalizeNamespace(String((owningOntology as any)?.namespace ?? '').replace(/^<|>$/g, ''));
+    const prefix = namespace ? ctx.nsToPrefix.get(namespace) : undefined;
+    return prefix ? `${prefix}:${name}` : name;
+}
+
+function getRefDisplayName(ctx: DiagramBuildContext, refLike: any): string | undefined {
+    const direct = getQualifiedName(ctx, refLike?.ref ?? refLike);
+    if (direct) {
+        return direct;
+    }
+    const raw = typeof refLike?.$refText === 'string' ? refLike.$refText.trim() : '';
+    if (!raw) {
+        return undefined;
+    }
+    const normalized = raw.replace(/^<|>$/g, '');
+    const parts = splitIri(normalized);
+    if (!parts?.fragment) {
+        return normalized;
+    }
+    const prefix = ctx.nsToPrefix.get(normalizeNamespace(parts.base));
+    return prefix ? `${prefix}:${parts.fragment}` : parts.fragment;
+}
+
+function toSimpleName(label: string | undefined): string {
+    if (!label) return '';
+    const trimmed = label.trim();
+    if (!trimmed) return '';
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex >= 0 && colonIndex < trimmed.length - 1) {
+        return trimmed.slice(colonIndex + 1);
+    }
+    const parts = splitIri(trimmed);
+    return parts?.fragment || trimmed;
+}
+
+function truncateWithEllipsis(text: string, maxChars: number): string {
+    if (maxChars <= 0) return '';
+    if (text.length <= maxChars) return text;
+    if (maxChars === 1) return '…';
+    return `${text.slice(0, maxChars - 1)}…`;
+}
+
+function iriNamespace(iri: string | undefined): string | undefined {
+    if (!iri) return undefined;
+    const parts = splitIri(iri);
+    return parts?.base;
+}
+
+function formatHoverLikeTooltip(kind: string, qualified: string | undefined, iri?: string): string | undefined {
+    const parts = [kind];
+    if (qualified && qualified.length > 0) {
+        parts.push(qualified);
+    }
+    if (iri && iri.length > 0) {
+        const ns = iriNamespace(iri);
+        parts.push(ns ? `${iri}\nnamespace: ${ns}` : iri);
+    }
+    return parts.filter(Boolean).join('\n');
+}
+
+function toLiteralLabel(literal: any): string {
+    if (!literal) return '[literal]';
+    if (typeof literal.lexicalValue === 'string' && literal.lexicalValue.length > 0) {
+        return literal.lexicalValue;
+    }
+    if (typeof literal.value === 'string' && literal.value.length > 0) {
+        return literal.value;
+    }
+    if (typeof literal.stringValue === 'string' && literal.stringValue.length > 0) {
+        return literal.stringValue;
+    }
+    return '[literal]';
+}
+
+function getOneOfEntries(
+    statement: any,
+    ctx: DiagramBuildContext,
+    viewId: string,
+    astNodeLocator: { getAstNodePath(node: any): string } | undefined,
+    rootUri: string,
+): DiagramEntry[] {
+    const entries: DiagramEntry[] = [];
+    if (isLiteralEnumerationAxiom(statement)) {
+        let index = 0;
+        for (const literal of ((statement as any).literals ?? [])) {
+            const entryId = `${viewId}:oneOf:${index++}`;
+            entries.push({
+                id: entryId,
+                modelId: getModelIdForNode(statement, astNodeLocator, rootUri) ?? entryId,
+                text: toLiteralLabel(literal),
+                statement
+            });
+        }
+        return entries;
+    }
+    if (isInstanceEnumerationAxiom(statement)) {
+        let index = 0;
+        for (const instanceRef of ((statement as any).instances ?? [])) {
+            const qName = getRefDisplayName(ctx, instanceRef) ?? (instanceRef?.$refText ?? '[instance]');
+            const entryId = `${viewId}:oneOf:${index++}`;
+            entries.push({
+                id: entryId,
+                modelId: getModelIdForNode(statement, astNodeLocator, rootUri) ?? entryId,
+                text: toSimpleName(qName),
+                qualifiedText: qName,
+                statement
+            });
+        }
+    }
+    return entries;
+}
+
+function getScalarPropertyLabel(property: any, ctx: DiagramBuildContext): string | undefined {
+    const qName = getQualifiedName(ctx, property);
+    if (!qName) {
+        return undefined;
+    }
+    const ranges = ((property as any).ranges ?? [])
+        .map((rangeRef: any) => getRefDisplayName(ctx, rangeRef))
+        .filter((value: any): value is string => typeof value === 'string' && value.length > 0)
+        .map((value: string) => toSimpleName(value));
+    return ranges.length > 0 ? `${toSimpleName(qName)}: ${ranges.join(' | ')}` : toSimpleName(qName);
+}
+
+function getAssertionValueLabel(ctx: DiagramBuildContext, assertion: any): string {
+    const parts: string[] = [];
+    for (const literal of ((assertion as any).literalValues ?? [])) {
+        parts.push(toLiteralLabel(literal));
+    }
+    for (const referenced of ((assertion as any).referencedValues ?? [])) {
+        const qName = getRefDisplayName(ctx, referenced);
+        parts.push(qName ? toSimpleName(qName) : '[instance]');
+    }
+    for (const contained of ((assertion as any).containedValues ?? [])) {
+        const qName = getQualifiedName(ctx, contained);
+        parts.push(qName ? toSimpleName(qName) : '[instance]');
+    }
+    return parts.join(', ');
+}
+
+export async function computeLaidOutSModelForUri(shared: any, modelUri: string): Promise<SModelRoot> {
+    const documentUri = URI.parse(modelUri);
+    let document = shared.workspace.LangiumDocuments.getDocument(documentUri);
+    if (!document) {
+        return { id: 'root', type: 'graph', children: [] } as unknown as SModelRoot;
+    }
+    const root = document.parseResult?.value;
+    if (!root || !isOntology(root)) {
+        return { id: 'root', type: 'graph', children: [] } as unknown as SModelRoot;
+    }
+
+    const graph = await computeDiagramGraph(shared, document, root);
+    indexDiagramMappings(shared, graph);
+    return await layoutAndConvertToSModel(graph);
+}
+
+async function computeDiagramGraph(shared: any, document: LangiumDocument, root: Ontology): Promise<DiagramGraph> {
+    const graph: DiagramGraph = {
+        rootUri: document.uri.toString(),
+        root,
+        nodes: [],
+        edges: [],
+        statementsById: new Map<string, AstNode>()
+    };
+
+    if (isVocabulary(root)) {
+        computeVocabularyGraph(shared, root, graph);
+        return graph;
+    }
+
+    if (isDescription(root)) {
+        computeDescriptionGraph(shared, root, graph);
+        return graph;
+    }
+
+    if (isVocabularyBundle(root) || isDescriptionBundle(root)) {
+        await computeBundleGraph(shared, root, graph);
+        return graph;
+    }
+
+    return graph;
+}
+
+function computeVocabularyGraph(shared: any, root: any, graph: DiagramGraph): void {
+    const astNodeLocator = getAstNodeLocator(shared);
+    const ctx = buildDiagramContext(root);
+    const nodeByQName = new Map<string, DiagramNode>();
+    const statements = root.ownedStatements ?? [];
+
+    const ensureEntityNode = (candidate: any): DiagramNode | undefined => {
+        const isReferenceWrapper =
+            !!candidate
+            && typeof candidate === 'object'
+            && ('$refText' in candidate)
+            && ('ref' in candidate)
+            && !('$type' in candidate);
+        const statement = isReferenceWrapper ? candidate.ref : candidate;
+        const isConcreteEntity =
+            !!statement
+            && (isConcept(statement) || isAspect(statement) || isRelationEntity(statement) || isScalar(statement));
+        const qName = isConcreteEntity
+            ? getQualifiedName(ctx, statement)
+            : (isReferenceWrapper ? getRefDisplayName(ctx, candidate) : undefined);
+        if (!qName) return undefined;
+        const existing = nodeByQName.get(qName);
+        if (existing) return existing;
+
+        const viewId = `ent:${qName}`;
+        const modelId = isConcreteEntity
+            ? (getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? viewId)
+            : viewId;
+        const nodeKind: DiagramNode['kind'] = isConcreteEntity && isUnreifiedRelation(statement) ? 'relation' : 'entity';
+        const node: DiagramNode = {
+            id: viewId,
+            viewId,
+            modelId,
+            iri: isConcreteEntity ? getIriForNode(statement) : undefined,
+            label: toSimpleName(qName),
+            qualifiedLabel: qName,
+            tooltip: formatHoverLikeTooltip(
+                isConcreteEntity ? humanizeTypeName((statement as any).$type ?? 'entity') : 'entity',
+                qName,
+                isConcreteEntity ? getIriForNode(statement) : undefined
+            ),
+            propertyEntries: [],
+            compartmentEntries: isConcreteEntity
+                ? getOneOfEntries(statement, ctx, viewId, astNodeLocator, graph.rootUri)
+                : [],
+            kind: nodeKind,
+            statement: isConcreteEntity ? statement : undefined
+        };
+        graph.nodes.push(node);
+        if (isConcreteEntity) {
+            graph.statementsById.set(viewId, statement);
+        }
+        for (const entry of (node.compartmentEntries ?? [])) {
+            if (entry.statement) {
+                graph.statementsById.set(entry.id, entry.statement);
+            }
+        }
+        nodeByQName.set(qName, node);
+        return node;
+    };
+
+    for (const statement of statements) {
+        ensureEntityNode(statement);
+    }
+
+    for (const statement of statements) {
+        if (isScalarProperty(statement)) {
+            const propertyLabel = getScalarPropertyLabel(statement, ctx);
+            if (!propertyLabel) continue;
+            for (const domainRef of ((statement as any).domains ?? [])) {
+                const domainNode = ensureEntityNode(domainRef);
+                if (!domainNode) continue;
+                if (!domainNode.propertyEntries) domainNode.propertyEntries = [];
+                const entryId = `${domainNode.viewId}:properties:${domainNode.propertyEntries.length}`;
+                domainNode.propertyEntries.push({
+                    id: entryId,
+                    modelId: getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? entryId,
+                    text: propertyLabel,
+                    qualifiedText: propertyLabel,
+                    tooltip: formatHoverLikeTooltip('scalar property', getQualifiedName(ctx, statement), getIriForNode(statement)),
+                    statement
+                });
+                graph.statementsById.set(entryId, statement);
+            }
+            continue;
+        }
+
+        if (isRelationEntity(statement)) {
+            const relNode = ensureEntityNode(statement);
+            if (!relNode) continue;
+            const sources = (statement.sources ?? []).map((r: any) => ensureEntityNode(r)).filter(Boolean) as DiagramNode[];
+            const targets = (statement.targets ?? []).map((r: any) => ensureEntityNode(r)).filter(Boolean) as DiagramNode[];
+            let index = 0;
+            for (const src of sources) {
+                const edgeId = `relent:${relNode.id}:src:${index++}`;
+                const modelId = getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? edgeId;
+                graph.edges.push({
+                    id: edgeId,
+                    viewId: edgeId,
+                    modelId,
+                    iri: getIriForNode(statement),
+                    sourceId: src.id,
+                    targetId: relNode.id,
+                    label: '',
+                    kind: 'relation-source',
+                    statement
+                });
+                graph.statementsById.set(edgeId, statement);
+            }
+            index = 0;
+            for (const dst of targets) {
+                const edgeId = `relent:${relNode.id}:dst:${index++}`;
+                const modelId = getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? edgeId;
+                graph.edges.push({
+                    id: edgeId,
+                    viewId: edgeId,
+                    modelId,
+                    iri: getIriForNode(statement),
+                    sourceId: relNode.id,
+                    targetId: dst.id,
+                    label: '',
+                    kind: 'relation-target',
+                    statement
+                });
+                graph.statementsById.set(edgeId, statement);
+            }
+            continue;
+        }
+
+        if (!isUnreifiedRelation(statement)) continue;
+        const relationName = getQualifiedName(ctx, statement);
+        if (!relationName) continue;
+        const sources = (statement.sources ?? []).map((r: any) => ensureEntityNode(r)).filter(Boolean) as DiagramNode[];
+        const targets = (statement.targets ?? []).map((r: any) => ensureEntityNode(r)).filter(Boolean) as DiagramNode[];
+
+        if (sources.length === 1 && targets.length === 1) {
+            const edgeId = `urel:${relationName}`;
+            const modelId = getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? edgeId;
+            graph.edges.push({
+                id: edgeId,
+                viewId: edgeId,
+                modelId,
+                iri: getIriForNode(statement),
+                sourceId: sources[0].id,
+                targetId: targets[0].id,
+                label: toSimpleName(relationName),
+                qualifiedLabel: relationName,
+                tooltip: formatHoverLikeTooltip('relation', relationName, getIriForNode(statement)),
+                kind: 'relation',
+                statement
+            });
+            graph.statementsById.set(edgeId, statement);
+            continue;
+        }
+
+        const relationNodeViewId = `rel:${relationName}`;
+        let relationNode = nodeByQName.get(relationName);
+        if (!relationNode) {
+            const modelId = getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? relationNodeViewId;
+            relationNode = {
+                id: relationNodeViewId,
+                viewId: relationNodeViewId,
+                modelId,
+                iri: getIriForNode(statement),
+                label: toSimpleName(relationName),
+                qualifiedLabel: relationName,
+                tooltip: formatHoverLikeTooltip('relation', relationName, getIriForNode(statement)),
+                kind: 'relation',
+                statement
+            };
+            graph.nodes.push(relationNode);
+            graph.statementsById.set(relationNodeViewId, statement);
+            nodeByQName.set(relationName, relationNode);
+        }
+
+        let index = 0;
+        for (const src of sources) {
+            const edgeId = `urel:${relationName}:src:${index++}`;
+            const modelId = getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? edgeId;
+            graph.edges.push({
+                id: edgeId,
+                viewId: edgeId,
+                modelId,
+                iri: getIriForNode(statement),
+                sourceId: src.id,
+                targetId: relationNode.id,
+                label: '',
+                tooltip: formatHoverLikeTooltip('relation source', relationName, getIriForNode(statement)),
+                kind: 'relation-source',
+                statement
+            });
+            graph.statementsById.set(edgeId, statement);
+        }
+        index = 0;
+        for (const dst of targets) {
+            const edgeId = `urel:${relationName}:dst:${index++}`;
+            const modelId = getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? edgeId;
+            graph.edges.push({
+                id: edgeId,
+                viewId: edgeId,
+                modelId,
+                iri: getIriForNode(statement),
+                sourceId: relationNode.id,
+                targetId: dst.id,
+                label: '',
+                tooltip: formatHoverLikeTooltip('relation target', relationName, getIriForNode(statement)),
+                kind: 'relation-target',
+                statement
+            });
+            graph.statementsById.set(edgeId, statement);
+        }
+    }
+
+    const addSpecializationEdge = (owner: any, axiom: any, index: number): void => {
+        if (!isSpecializationAxiom(axiom)) return;
+        const superTerm = (axiom as any).superTerm?.ref;
+        const subNode = ensureEntityNode(owner);
+        const superNode = ensureEntityNode(superTerm);
+        if (!subNode || !superNode) return;
+        const edgeId = `spec:${subNode.id}:${superNode.id}:${index}`;
+        const modelId = getModelIdForNode(axiom, astNodeLocator, graph.rootUri) ?? edgeId;
+        graph.edges.push({
+            id: edgeId,
+            viewId: edgeId,
+            modelId,
+            iri: getIriForNode(axiom),
+            sourceId: subNode.id,
+            targetId: superNode.id,
+            label: '',
+            tooltip: formatHoverLikeTooltip('specialization', getQualifiedName(ctx, owner), getIriForNode(axiom)),
+            kind: 'specialization',
+            statement: axiom
+        });
+        graph.statementsById.set(edgeId, axiom);
+    };
+
+    const addEquivalenceEdges = (owner: any, axiom: any, index: number): void => {
+        if (!isEquivalenceAxiom(axiom)) return;
+        const subNode = ensureEntityNode(owner);
+        if (!subNode) return;
+        const superTerms = ((axiom as any).superTerms ?? []).map((ref: any) => ref?.ref).filter(Boolean);
+        if (superTerms.length === 1) {
+            const superNode = ensureEntityNode(superTerms[0]);
+            if (!superNode) return;
+            const edgeId = `eq:${subNode.id}:${superNode.id}:${index}:0`;
+            const modelId = getModelIdForNode(axiom, astNodeLocator, graph.rootUri) ?? edgeId;
+            graph.edges.push({
+                id: edgeId,
+                viewId: edgeId,
+                modelId,
+                iri: getIriForNode(axiom),
+                sourceId: subNode.id,
+                targetId: superNode.id,
+                label: '',
+                tooltip: formatHoverLikeTooltip('equivalence', getQualifiedName(ctx, owner), getIriForNode(axiom)),
+                kind: 'equivalence',
+                statement: axiom
+            });
+            graph.statementsById.set(edgeId, axiom);
+            return;
+        }
+
+        if (superTerms.length > 1) {
+            const eqNodeId = `eqnode:${subNode.id}:${index}`;
+            const eqNode: DiagramNode = {
+                id: eqNodeId,
+                viewId: eqNodeId,
+                modelId: getModelIdForNode(axiom, astNodeLocator, graph.rootUri) ?? eqNodeId,
+                iri: getIriForNode(axiom),
+                label: '&',
+                qualifiedLabel: getQualifiedName(ctx, owner),
+                tooltip: formatHoverLikeTooltip('equivalence', getQualifiedName(ctx, owner), getIriForNode(axiom)),
+                propertyEntries: [],
+                compartmentEntries: [],
+                kind: 'equivalence',
+                statement: axiom
+            };
+            graph.nodes.push(eqNode);
+            graph.statementsById.set(eqNodeId, axiom);
+
+            const inEdgeId = `eq:${subNode.id}:${eqNodeId}:${index}:in`;
+            graph.edges.push({
+                id: inEdgeId,
+                viewId: inEdgeId,
+                modelId: getModelIdForNode(axiom, astNodeLocator, graph.rootUri) ?? inEdgeId,
+                iri: getIriForNode(axiom),
+                sourceId: subNode.id,
+                targetId: eqNodeId,
+                label: '',
+                tooltip: formatHoverLikeTooltip('equivalence', getQualifiedName(ctx, owner), getIriForNode(axiom)),
+                kind: 'equivalence-source',
+                statement: axiom
+            });
+            graph.statementsById.set(inEdgeId, axiom);
+
+            let superIndex = 0;
+            for (const superTerm of superTerms) {
+                const superNode = ensureEntityNode(superTerm);
+                if (!superNode) continue;
+                const outEdgeId = `eq:${eqNodeId}:${superNode.id}:${index}:${superIndex++}`;
+                graph.edges.push({
+                    id: outEdgeId,
+                    viewId: outEdgeId,
+                    modelId: getModelIdForNode(axiom, astNodeLocator, graph.rootUri) ?? outEdgeId,
+                    iri: getIriForNode(axiom),
+                    sourceId: eqNodeId,
+                    targetId: superNode.id,
+                    label: '',
+                    tooltip: formatHoverLikeTooltip('equivalence', getQualifiedName(ctx, owner), getIriForNode(axiom)),
+                    kind: 'equivalence',
+                    statement: axiom
+                });
+                graph.statementsById.set(outEdgeId, axiom);
+            }
+        }
+    };
+
+    for (const statement of statements) {
+        const ownedSpecializations = (statement as any).ownedSpecializations ?? [];
+        for (let i = 0; i < ownedSpecializations.length; i += 1) {
+            addSpecializationEdge(statement, ownedSpecializations[i], i);
+        }
+        const ownedEquivalences = (statement as any).ownedEquivalences ?? [];
+        for (let i = 0; i < ownedEquivalences.length; i += 1) {
+            addEquivalenceEdges(statement, ownedEquivalences[i], i);
+        }
+    }
+}
+
+function computeDescriptionGraph(shared: any, root: any, graph: DiagramGraph): void {
+    const astNodeLocator = getAstNodeLocator(shared);
+    const ctx = buildDiagramContext(root);
+    const nodeByQName = new Map<string, DiagramNode>();
+
+    const ensureInstanceNode = (candidate: any): DiagramNode | undefined => {
+        const statement = unwrapReferenceValue(candidate);
+        if (!statement || (!isConceptInstance(statement) && !isRelationInstance(statement))) return undefined;
+        const qName = getQualifiedName(ctx, statement);
+        if (!qName) return undefined;
+        const existing = nodeByQName.get(qName);
+        if (existing) return existing;
+        const viewId = `ci:${qName}`;
+        const modelId = getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? viewId;
+        const typeLabels = Array.from(new Set(
+            ((statement as any).ownedTypes ?? [])
+                .map((typeAssertion: any) => getQualifiedName(ctx, typeAssertion?.type?.ref ?? typeAssertion?.type))
+                .filter((label: any) => typeof label === 'string' && label.length > 0)
+        )).map((label) => toSimpleName(label as string | undefined)) as string[];
+        const label = toSimpleName(qName);
+        const propertyEntries: DiagramEntry[] = [];
+        let propertyIndex = 0;
+        for (const assertion of (((statement as any).ownedPropertyValues ?? []) as any[])) {
+            if (getContainingOntology(assertion) !== root) continue;
+            if (!isPropertyValueAssertion(assertion)) continue;
+            const propertyRef = (assertion as any).property?.ref;
+            if (!propertyRef || !isScalarProperty(propertyRef)) continue;
+            const propertyName = getQualifiedName(ctx, propertyRef) ?? (assertion as any).property?.$refText ?? 'property';
+            const valueLabel = getAssertionValueLabel(ctx, assertion);
+            const text = valueLabel.length > 0
+                ? `${toSimpleName(propertyName)} = ${valueLabel}`
+                : toSimpleName(propertyName);
+            const entryId = `${viewId}:properties:${propertyIndex++}`;
+            propertyEntries.push({
+                id: entryId,
+                modelId: getModelIdForNode(assertion, astNodeLocator, graph.rootUri) ?? entryId,
+                text,
+                qualifiedText: propertyName,
+                statement: assertion
+            });
+        }
+        const node: DiagramNode = {
+            id: viewId,
+            viewId,
+            modelId,
+            iri: getIriForNode(statement),
+            label,
+            instanceTypeLabels: typeLabels,
+            qualifiedLabel: qName,
+            tooltip: formatHoverLikeTooltip(humanizeTypeName((statement as any).$type ?? 'instance'), qName, getIriForNode(statement)),
+            propertyEntries,
+            kind: 'instance',
+            statement
+        };
+        graph.nodes.push(node);
+        graph.statementsById.set(viewId, statement);
+        for (const entry of propertyEntries) {
+            if (entry.statement) {
+                graph.statementsById.set(entry.id, entry.statement);
+            }
+        }
+        nodeByQName.set(qName, node);
+        return node;
+    };
+
+    const statements = root.ownedStatements ?? [];
+    for (const statement of statements) {
+        ensureInstanceNode(statement);
+    }
+
+    let assertionEdgeIndex = 0;
+    const addRelationPropertyAssertionEdges = (ownerStatement: any, ownerNode: DiagramNode | undefined): void => {
+        if (!ownerNode) return;
+        const ownedPropertyValues = (ownerStatement as any).ownedPropertyValues ?? [];
+        for (const assertion of ownedPropertyValues) {
+            if (!isPropertyValueAssertion(assertion)) continue;
+            const propertyRef = (assertion as any).property?.ref;
+            if (!propertyRef || !isRelation(propertyRef)) continue;
+            const relationName = getQualifiedName(ctx, propertyRef) ?? (assertion as any).property?.$refText ?? 'relation';
+            const referencedValues = (assertion as any).referencedValues ?? [];
+            for (const valueRef of referencedValues) {
+                const targetNode = ensureInstanceNode(valueRef);
+                if (!targetNode) continue;
+                const edgeId = `pva:${ownerNode.id}:${targetNode.id}:${assertionEdgeIndex++}`;
+                const modelId = getModelIdForNode(assertion, astNodeLocator, graph.rootUri) ?? edgeId;
+                graph.edges.push({
+                    id: edgeId,
+                    viewId: edgeId,
+                    modelId,
+                    iri: getIriForNode(propertyRef),
+                    sourceId: ownerNode.id,
+                    targetId: targetNode.id,
+                    label: toSimpleName(relationName),
+                    qualifiedLabel: relationName,
+                    tooltip: formatHoverLikeTooltip('relation', relationName, getIriForNode(propertyRef)),
+                    kind: 'relation',
+                    statement: assertion
+                });
+                graph.statementsById.set(edgeId, assertion);
+            }
+        }
+    };
+
+    for (const statement of statements) {
+        const ownerNode = ensureInstanceNode(statement);
+        addRelationPropertyAssertionEdges(statement, ownerNode);
+
+        if (!isRelationInstance(statement)) continue;
+        if (!ownerNode) continue;
+        const relName = getQualifiedName(ctx, statement) ?? statement.name ?? 'relation';
+        const sources = (statement.sources ?? []).map((r: any) => ensureInstanceNode(r)).filter(Boolean) as DiagramNode[];
+        const targets = (statement.targets ?? []).map((r: any) => ensureInstanceNode(r)).filter(Boolean) as DiagramNode[];
+        let index = 0;
+        for (const src of sources) {
+            const edgeId = `ri:${relName}:src:${index++}`;
+            const modelId = getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? edgeId;
+            graph.edges.push({
+                id: edgeId,
+                viewId: edgeId,
+                modelId,
+                iri: getIriForNode(statement),
+                sourceId: src.id,
+                targetId: ownerNode.id,
+                label: '',
+                tooltip: formatHoverLikeTooltip('relation source', relName, getIriForNode(statement)),
+                kind: 'relation-source',
+                statement
+            });
+            graph.statementsById.set(edgeId, statement);
+        }
+        index = 0;
+        for (const dst of targets) {
+            const edgeId = `ri:${relName}:dst:${index++}`;
+            const modelId = getModelIdForNode(statement, astNodeLocator, graph.rootUri) ?? edgeId;
+            graph.edges.push({
+                id: edgeId,
+                viewId: edgeId,
+                modelId,
+                iri: getIriForNode(statement),
+                sourceId: ownerNode.id,
+                targetId: dst.id,
+                label: '',
+                tooltip: formatHoverLikeTooltip('relation target', relName, getIriForNode(statement)),
+                kind: 'relation-target',
+                statement
+            });
+            graph.statementsById.set(edgeId, statement);
+        }
+    }
+}
+
+async function computeBundleGraph(shared: any, root: Ontology, graph: DiagramGraph): Promise<void> {
+    const astNodeLocator = getAstNodeLocator(shared);
+    const queue: Ontology[] = [root];
+    const seen = new Set<string>();
+    const nodeByNamespace = new Map<string, DiagramNode>();
+    const directImports = new Map<string, Array<{ targetNamespace: string; ownedImport: Import }>>();
+
+    const seedImports = ((root as any).ownedImports ?? []) as Import[];
+    for (const ownedImport of seedImports) {
+        const importedOntology = await resolveImportedOntology(shared, ownedImport);
+        if (!importedOntology) continue;
+        queue.push(importedOntology);
+    }
+    const ensureOntologyNode = (ontology: Ontology, namespace: string): DiagramNode => {
+        const existing = nodeByNamespace.get(namespace);
+        if (existing) return existing;
+        const nodeId = `ont:${namespace}`;
+        const modelId = namespace || getModelIdForNode(ontology, astNodeLocator, graph.rootUri) || nodeId;
+        const label = (ontology as any).prefix || namespace.split('/').pop() || namespace;
+        const node: DiagramNode = {
+            id: nodeId,
+            viewId: nodeId,
+            modelId,
+            iri: getIriForNode(ontology),
+            label,
+            kind: 'ontology',
+            statement: ontology
+        };
+        node.tooltip = getIriForNode(ontology);
+        graph.nodes.push(node);
+        graph.statementsById.set(nodeId, ontology);
+        nodeByNamespace.set(namespace, node);
+        return node;
+    };
+
+    while (queue.length > 0) {
+        const current = queue.shift()!;
+        const namespace = normalizeNamespace((current as any).namespace ?? '');
+        if (!namespace || seen.has(namespace)) continue;
+        seen.add(namespace);
+
+        ensureOntologyNode(current, namespace);
+
+        for (const ownedImport of ((current as any).ownedImports ?? []) as Import[]) {
+            const importedOntology = await resolveImportedOntology(shared, ownedImport);
+            if (!importedOntology) continue;
+            const importedNamespace = normalizeNamespace((importedOntology as any).namespace ?? '');
+            if (!importedNamespace) continue;
+
+            if (!seen.has(importedNamespace)) {
+                queue.push(importedOntology);
+            }
+
+            ensureOntologyNode(importedOntology, importedNamespace);
+            const existing = directImports.get(namespace) ?? [];
+            existing.push({ targetNamespace: importedNamespace, ownedImport });
+            directImports.set(namespace, existing);
+        }
+    }
+
+    const reachabilityWithoutDirectEdge = (source: string, target: string): boolean => {
+        const visited = new Set<string>([source]);
+        const work: string[] = [];
+        const firstHops = directImports.get(source) ?? [];
+        for (const hop of firstHops) {
+            if (hop.targetNamespace === target) continue;
+            work.push(hop.targetNamespace);
+        }
+        while (work.length > 0) {
+            const current = work.shift()!;
+            if (current === target) return true;
+            if (visited.has(current)) continue;
+            visited.add(current);
+            for (const next of (directImports.get(current) ?? [])) {
+                if (!visited.has(next.targetNamespace)) {
+                    work.push(next.targetNamespace);
+                }
+            }
+        }
+        return false;
+    };
+
+    for (const [sourceNamespace, imports] of directImports.entries()) {
+        const sourceNode = nodeByNamespace.get(sourceNamespace);
+        if (!sourceNode) continue;
+        for (const imported of imports) {
+            const targetNode = nodeByNamespace.get(imported.targetNamespace);
+            if (!targetNode) continue;
+            if (reachabilityWithoutDirectEdge(sourceNamespace, imported.targetNamespace)) {
+                continue;
+            }
+            const edgeId = `imp:${sourceNamespace}->${imported.targetNamespace}`;
+            const edgeModelId = getModelIdForNode(imported.ownedImport, astNodeLocator, graph.rootUri) ?? edgeId;
+            graph.edges.push({
+                id: edgeId,
+                viewId: edgeId,
+                modelId: edgeModelId,
+                iri: getIriForNode(imported.ownedImport),
+                sourceId: sourceNode.id,
+                targetId: targetNode.id,
+                label: '',
+                tooltip: getIriForNode(imported.ownedImport),
+                kind: 'import',
+                statement: imported.ownedImport
+            });
+            graph.statementsById.set(edgeId, imported.ownedImport);
+        }
+    }
+}
+
+async function resolveImportedOntology(shared: any, ownedImport: Import): Promise<Ontology | undefined> {
+    const refText = (ownedImport as any)?.imported?.$refText ?? '';
+    const namespace = normalizeNamespace(String(refText).replace(/^<|>$/g, ''));
+    if (namespace) {
+        const resolved = await findOntologyByNamespace(shared, namespace);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    const direct = (ownedImport as any)?.imported?.ref;
+    if (direct && isOntology(direct)) {
+        return direct;
+    }
+    return undefined;
+}
+
+function getNodeSize(node: DiagramNode): { width: number; height: number } {
+    if (node.kind === 'equivalence') {
+        return { width: 28, height: 28 };
+    }
+    const properties = node.propertyEntries ?? [];
+    const entries = node.compartmentEntries ?? [];
+    const maxHeaderChars = 34;
+    const maxBodyChars = 38;
+    const headerName = Math.min(node.label.length, maxHeaderChars);
+    const headerType = Math.min(getNodeTypeLabel(node).length, maxHeaderChars);
+    const widestHeaderPx = Math.max(
+        Math.round(headerName * 8.2),
+        Math.round(headerType * 6.9)
+    );
+    const widestBodyPx = Math.max(
+        ...[...properties, ...entries].map((entry) => Math.round(Math.min(entry.text.length, maxBodyChars) * 6.0)),
+        0
+    );
+    const contentWidth = Math.max(widestHeaderPx, widestBodyPx);
+    const width = Math.max(120, Math.min(340, contentWidth + 28));
+    const headerHeight = 34;
+    const compartmentPadding = 10;
+    const entryHeight = 16;
+    const propertyHeight = properties.length > 0
+        ? (compartmentPadding * 2) + (properties.length * entryHeight)
+        : 0;
+    const oneOfHeight = entries.length > 0
+        ? (compartmentPadding * 2) + (entries.length * entryHeight)
+        : 0;
+    const gap = properties.length > 0 && entries.length > 0 ? 4 : 0;
+    const bodyHeight = propertyHeight + gap + oneOfHeight + (propertyHeight + oneOfHeight > 0 ? 0 : 22);
+    return { width, height: headerHeight + bodyHeight };
+}
+
+function getNodeTypeLabel(node: DiagramNode): string {
+    if (node.kind === 'equivalence') return '«equivalence»';
+    if (node.kind === 'instance') {
+        const types = (node.instanceTypeLabels ?? []).filter((t) => t.length > 0);
+        if (types.length > 0) {
+            return `«${types.join(', ')}»`;
+        }
+        return '«concept instance»';
+    }
+    const explicitType = (node.statement as any)?.$type;
+    if (typeof explicitType === 'string' && explicitType.length > 0) {
+        return `«${humanizeTypeName(explicitType)}»`;
+    }
+    if (node.kind === 'ontology') return '«ontology»';
+    return '«concept»';
+}
+
+async function layoutAndConvertToSModel(graph: DiagramGraph): Promise<SModelRoot> {
+    if (graph.nodes.length === 0) {
+        return { id: 'root', type: 'graph', children: [] } as unknown as SModelRoot;
+    }
+
+    const selfLoopCountByNode = new Map<string, number>();
+    for (const edge of graph.edges) {
+        if (edge.sourceId === edge.targetId) {
+            const current = selfLoopCountByNode.get(edge.sourceId) ?? 0;
+            selfLoopCountByNode.set(edge.sourceId, current + 1);
+        }
+    }
+    const layoutNodeSizeById = new Map<string, { width: number; height: number }>();
+    for (const node of graph.nodes) {
+        const baseSize = getNodeSize(node);
+        const selfLoopCount = selfLoopCountByNode.get(node.id) ?? 0;
+        if (selfLoopCount === 0) {
+            layoutNodeSizeById.set(node.id, baseSize);
+            continue;
+        }
+        const labelHeight = 16;
+        const loopSpacing = labelHeight + 8;
+        const baseLoopHeight = 40;
+        const outermostLoopIndex = selfLoopCount - 1;
+        const outermostLoopHeight = baseLoopHeight + (outermostLoopIndex * loopSpacing);
+        const minLoopHostHeight = outermostLoopHeight + 20;
+        layoutNodeSizeById.set(node.id, {
+            width: baseSize.width,
+            height: Math.max(baseSize.height, minLoopHostHeight)
+        });
+    }
+
+    const elk = await getElk();
+
+    const elkGraph: any = {
+        id: 'root',
+        layoutOptions: {
+            'elk.algorithm': 'org.eclipse.elk.layered',
+            'elk.direction': 'DOWN',
+            'elk.layered.nodePlacement.strategy': 'BRANDES_KOEPF',
+            'elk.spacing.nodeNode': '50',
+            'elk.layered.spacing.nodeNodeBetweenLayers': '80',
+            'elk.selfLoopDistribution': 'EQUALLY_SPACED',
+            'elk.selfLoopOrdering': 'STACKED',
+            'elk.spacing.edgeSelfLoop': '72',
+            'elk.spacing.edgeEdge': '20',
+            'elk.spacing.edgeNode': '20',
+            'elk.edgeRouting': 'ORTHOGONAL',
+            'elk.layered.crossingMinimization.strategy': 'LAYER_SWEEP',
+            'elk.layered.unnecessaryBendpoints': 'true',
+            'elk.layered.nodePlacement.bk.fixedAlignment': 'BALANCED',
+            'elk.layered.considerModelOrder.strategy': 'NODES_AND_EDGES',
+            'elk.hierarchyHandling': 'INCLUDE_CHILDREN'
+        },
+        children: graph.nodes.map((n) => {
+            const size = layoutNodeSizeById.get(n.id) ?? getNodeSize(n);
+            return { id: n.id, width: size.width, height: size.height };
+        }),
+        edges: graph.edges.map((e) => ({
+            id: e.id,
+            sources: [e.sourceId],
+            targets: [e.targetId],
+            labels: e.label
+                ? [{
+                    id: `${e.id}:elk-label`,
+                    text: e.label,
+                    width: e.label.length * 7 + 8,
+                    height: 14,
+                    layoutOptions: {
+                        'elk.edgeLabels.inline': 'false',
+                        'elk.edgeLabels.placement': e.sourceId === e.targetId ? 'TAIL' : 'CENTER'
+                    }
+                }]
+                : []
+        }))
+    };
+
+    const laidOut = await elk.layout(elkGraph);
+    const nodeMap = new Map<string, any>((laidOut.children ?? []).map((n: any) => [n.id, n]));
+    const edgeMap = new Map<string, any>((laidOut.edges ?? []).map((e: any) => [e.id, e]));
+    const diagramNodeById = new Map<string, DiagramNode>(graph.nodes.map((node) => [node.id, node]));
+
+    const extractRoutingPoints = (elkEdge: any): Array<{ x: number; y: number }> => {
+        if (!elkEdge || !Array.isArray(elkEdge.sections) || elkEdge.sections.length === 0) return [];
+        const section = elkEdge.sections[0];
+        const points: Array<{ x: number; y: number }> = [];
+        const pushPoint = (p: any): void => {
+            if (!p || typeof p.x !== 'number' || typeof p.y !== 'number') return;
+            const x = Number(p.x);
+            const y = Number(p.y);
+            if (!Number.isFinite(x) || !Number.isFinite(y)) return;
+            const last = points[points.length - 1];
+            if (!last || Math.abs(last.x - x) > 0.001 || Math.abs(last.y - y) > 0.001) {
+                points.push({ x, y });
+            }
+        };
+        pushPoint(section.startPoint);
+        for (const bend of Array.isArray(section.bendPoints) ? section.bendPoints : []) {
+            pushPoint(bend);
+        }
+        pushPoint(section.endPoint);
+        return simplifyRoutingPoints(points);
+    };
+
+    const simplifyRoutingPoints = (points: Array<{ x: number; y: number }>): Array<{ x: number; y: number }> => {
+        if (points.length <= 2) return points;
+        const simplified: Array<{ x: number; y: number }> = [points[0]];
+        for (let i = 1; i < points.length - 1; i++) {
+            const prev = points[i - 1];
+            const curr = points[i];
+            const next = points[i + 1];
+            const isHorizontalLine = Math.abs(prev.y - curr.y) < 0.001 && Math.abs(curr.y - next.y) < 0.001;
+            const isVerticalLine = Math.abs(prev.x - curr.x) < 0.001 && Math.abs(curr.x - next.x) < 0.001;
+            if (!isHorizontalLine && !isVerticalLine) {
+                simplified.push(curr);
+            }
+        }
+        simplified.push(points[points.length - 1]);
+        return simplified;
+    };
+
+    const rectangularSelfLoopRoutingPoints = (
+        nodeLayout: { x: number; y: number; width: number; height: number },
+        loopIndex: number
+    ): Array<{ x: number; y: number }> => {
+        const leftX = nodeLayout.x;
+        const centerY = nodeLayout.y + (nodeLayout.height / 2);
+        const labelHeight = 16;
+        const loopSpacing = labelHeight + 8;
+        const baseLoopWidth = 60;
+        const baseLoopHeight = 40;
+        const loopWidth = baseLoopWidth + (loopIndex * loopSpacing);
+        const loopHeight = baseLoopHeight + (loopIndex * loopSpacing);
+        const top = centerY - (loopHeight / 2);
+        const bottom = centerY + (loopHeight / 2);
+        const outerX = leftX - loopWidth;
+        return [
+            { x: leftX, y: top },
+            { x: outerX, y: top },
+            { x: outerX, y: bottom },
+            { x: leftX, y: bottom }
+        ];
+    };
+
+    const selfLoopOrdinalByNode = new Map<string, number>();
+
+    const children: SModelElement[] = [];
+    const headerHeight = 34;
+    const entryHeight = 16;
+    const compartmentPadding = 10;
+    for (const node of graph.nodes) {
+        const laid = nodeMap.get(node.viewId);
+        const size = getNodeSize(node);
+        const width = laid?.width ?? size.width;
+        const height = laid?.height ?? size.height;
+        if (node.kind === 'equivalence') {
+            children.push({
+                id: node.viewId,
+                viewId: node.viewId,
+                modelId: node.modelId,
+                tooltip: node.iri,
+                type: 'node:rect',
+                position: { x: laid?.x ?? 0, y: laid?.y ?? 0 },
+                size: { width, height },
+                kind: node.kind,
+                children: [
+                    {
+                        id: `${node.viewId}:name`,
+                        viewId: `${node.viewId}:name`,
+                        modelId: node.modelId,
+                        tooltip: node.iri,
+                        type: 'label',
+                        text: '&',
+                        position: { x: width / 2, y: height / 2 }
+                    } as unknown as SModelElement
+                ]
+            } as unknown as SModelElement);
+            continue;
+        }
+        const propertyEntries = node.propertyEntries ?? [];
+        const entries = node.compartmentEntries ?? [];
+        const maxBodyChars = Math.max(8, Math.floor((width - 24) / 6.0));
+        const propertyHeight = propertyEntries.length > 0
+            ? (compartmentPadding * 2) + (propertyEntries.length * entryHeight)
+            : 0;
+        const oneOfHeight = entries.length > 0
+            ? (compartmentPadding * 2) + (entries.length * entryHeight)
+            : 0;
+        const gap = propertyEntries.length > 0 && entries.length > 0 ? 4 : 0;
+        const nodeChildren: SModelElement[] = [
+            {
+                id: `${node.viewId}:header`,
+                viewId: `${node.viewId}:header`,
+                modelId: node.modelId,
+                tooltip: node.iri,
+                type: 'node:rect',
+                position: { x: 0, y: 0 },
+                size: { width, height: headerHeight },
+                kind: 'label-box',
+                children: [
+                    {
+                        id: `${node.viewId}:type`,
+                        viewId: `${node.viewId}:type`,
+                        modelId: node.modelId,
+                        tooltip: node.iri,
+                        type: 'label',
+                        text: getNodeTypeLabel(node),
+                        position: { x: width / 2, y: 10 }
+                    },
+                    {
+                        id: `${node.viewId}:name`,
+                        viewId: `${node.viewId}:name`,
+                        modelId: node.modelId,
+                        tooltip: node.iri,
+                        type: 'label',
+                        text: node.label,
+                        position: { x: width / 2, y: 24 }
+                    }
+                ]
+            } as unknown as SModelElement
+        ];
+
+        let compartmentY = headerHeight;
+        if (propertyEntries.length > 0) {
+            nodeChildren.push({
+                id: `${node.viewId}:properties`,
+                viewId: `${node.viewId}:properties`,
+                modelId: node.modelId,
+                tooltip: node.iri,
+                type: 'node:rect',
+                position: { x: 0, y: compartmentY },
+                size: { width, height: propertyHeight },
+                kind: 'property-compartment',
+                children: propertyEntries.map((entry, index) => ({
+                    id: entry.id,
+                    viewId: entry.id,
+                    modelId: entry.modelId,
+                    tooltip: getIriForNode(entry.statement) ?? node.iri,
+                    type: 'label',
+                    text: truncateWithEllipsis(entry.text, maxBodyChars),
+                    position: {
+                        x: 12,
+                        y: compartmentPadding + 8 + (index * entryHeight)
+                    }
+                })) as unknown as SModelElement[]
+            } as unknown as SModelElement);
+            compartmentY += propertyHeight + gap;
+        }
+
+        if (entries.length > 0) {
+            nodeChildren.push({
+                id: `${node.viewId}:compartment`,
+                viewId: `${node.viewId}:compartment`,
+                modelId: node.modelId,
+                tooltip: node.iri,
+                type: 'node:rect',
+                position: { x: 0, y: compartmentY },
+                size: { width, height: oneOfHeight },
+                kind: 'compartment',
+                children: entries.map((entry, index) => ({
+                    id: entry.id,
+                    viewId: entry.id,
+                    modelId: entry.modelId,
+                    tooltip: getIriForNode(entry.statement) ?? node.iri,
+                    type: 'label',
+                    text: truncateWithEllipsis(entry.text, maxBodyChars),
+                    position: {
+                        x: 12,
+                        y: compartmentPadding + 8 + (index * entryHeight)
+                    }
+                })) as unknown as SModelElement[]
+            } as unknown as SModelElement);
+        }
+
+        children.push({
+            id: node.viewId,
+            viewId: node.viewId,
+            modelId: node.modelId,
+            tooltip: node.iri,
+            type: 'node:rect',
+            position: { x: laid?.x ?? 0, y: laid?.y ?? 0 },
+            size: { width, height },
+            kind: node.kind,
+            children: nodeChildren
+        } as unknown as SModelElement);
+    }
+
+    for (const edge of graph.edges) {
+        const laidEdge = edgeMap.get(edge.viewId);
+        const isSelfLoop = edge.sourceId === edge.targetId;
+        const selfLoopIndex = isSelfLoop
+            ? (selfLoopOrdinalByNode.get(edge.sourceId) ?? 0)
+            : -1;
+        if (isSelfLoop) {
+            selfLoopOrdinalByNode.set(edge.sourceId, selfLoopIndex + 1);
+        }
+        const routingPoints = (() => {
+            if (!isSelfLoop) return extractRoutingPoints(laidEdge);
+            const laidNode = nodeMap.get(edge.sourceId);
+            const fallbackNode = diagramNodeById.get(edge.sourceId);
+            const fallbackSize = fallbackNode ? getNodeSize(fallbackNode) : { width: 120, height: 56 };
+            const nodeLayout = {
+                x: laidNode?.x ?? 0,
+                y: laidNode?.y ?? 0,
+                width: laidNode?.width ?? fallbackSize.width,
+                height: laidNode?.height ?? fallbackSize.height
+            };
+            return rectangularSelfLoopRoutingPoints(nodeLayout, selfLoopIndex);
+        })();
+        const edgeChild = edge.label
+            ? [(() => {
+                if (isSelfLoop) {
+                    return {
+                        id: `${edge.viewId}:label`,
+                        viewId: `${edge.viewId}:label`,
+                        modelId: edge.modelId,
+                        tooltip: edge.iri,
+                        type: 'label:edge',
+                        text: edge.label,
+                        edgePlacement: {
+                            rotate: false,
+                            side: 'top',
+                            position: 0.75,
+                            offset: 8,
+                            moveMode: 'edge'
+                        }
+                    };
+                }
+                return {
+                    id: `${edge.viewId}:label`,
+                    viewId: `${edge.viewId}:label`,
+                    modelId: edge.modelId,
+                    tooltip: edge.iri,
+                    type: 'label:edge',
+                    text: edge.label,
+                    edgePlacement: {
+                        rotate: false,
+                        side: 'top',
+                        position: 0.5,
+                        offset: 8,
+                        moveMode: 'edge'
+                    }
+                };
+            })()]
+            : [];
+        children.push({
+            id: edge.viewId,
+            viewId: edge.viewId,
+            modelId: edge.modelId,
+            tooltip: edge.iri,
+            type: `edge:${edge.kind}`,
+            sourceId: edge.sourceId,
+            targetId: edge.targetId,
+            routerKind: 'polyline',
+            routingPoints,
+            kind: edge.kind,
+            children: edgeChild
+        } as unknown as SModelElement);
+    }
+
+    return {
+        id: 'root',
+        type: 'graph',
+        children
+    } as unknown as SModelRoot;
+}
+
+function normalizeDiagramElementId(elementId: string): string {
+    return elementId.endsWith(':label') ? elementId.slice(0, -':label'.length) : elementId;
+}
+
+function indexDiagramMappings(shared: any, graph: DiagramGraph): void {
+    const astNodeLocator = getAstNodeLocator(shared);
+    if (!astNodeLocator) {
+        navigationIndex.set(graph.rootUri, new Map());
+        return;
+    }
+    const map = new Map<string, AstRef>();
+    for (const node of graph.nodes) {
+        const statement = node.statement;
+        if (!statement) continue;
+        const root = statement.$document?.parseResult?.value;
+        if (!root) continue;
+        const path = astNodeLocator.getAstNodePath(statement);
+        if (!path) continue;
+        const uri = statement.$document?.uri?.toString() ?? graph.rootUri;
+        const astRef = { uri, path };
+        map.set(normalizeDiagramElementId(node.viewId), astRef);
+        map.set(normalizeDiagramElementId(node.modelId), astRef);
+    }
+    for (const edge of graph.edges) {
+        const statement = edge.statement;
+        if (!statement) continue;
+        const root = statement.$document?.parseResult?.value;
+        if (!root) continue;
+        const path = astNodeLocator.getAstNodePath(statement);
+        if (!path) continue;
+        const uri = statement.$document?.uri?.toString() ?? graph.rootUri;
+        const astRef = { uri, path };
+        map.set(normalizeDiagramElementId(edge.viewId), astRef);
+        map.set(normalizeDiagramElementId(edge.modelId), astRef);
+    }
+    for (const [id, statement] of graph.statementsById.entries()) {
+        const root = statement.$document?.parseResult?.value;
+        if (!root) continue;
+        const path = astNodeLocator.getAstNodePath(statement);
+        if (!path) continue;
+        const uri = statement.$document?.uri?.toString() ?? graph.rootUri;
+        map.set(normalizeDiagramElementId(id), { uri, path });
+    }
+    navigationIndex.set(graph.rootUri, map);
+}
+
+export async function navigateToElement(shared: any, contextUri: string, elementId: string): Promise<RangeResponse | null> {
+    const astNodeLocator = getAstNodeLocator(shared);
+    if (!astNodeLocator) {
+        return null;
+    }
+    const normalizedId = normalizeDiagramElementId(elementId);
+    const directSeparator = normalizedId.indexOf('#');
+    const directUri = directSeparator > 0 ? normalizedId.slice(0, directSeparator) : undefined;
+    const directPath = directSeparator > 0 ? normalizedId.slice(directSeparator + 1) : undefined;
+    const indexed = !directUri || !directPath
+        ? navigationIndex.get(contextUri)?.get(normalizedId)
+        : undefined;
+    const resolvedUri = directUri ?? indexed?.uri;
+    const resolvedPath = directPath ?? indexed?.path;
+    if (!resolvedUri || !resolvedPath) {
+        const ontologyIri = normalizedId.startsWith('ont:')
+            ? normalizeNamespace(normalizedId.slice(4))
+            : normalizeNamespace(normalizedId);
+        if (ontologyIri && ontologyIri.includes('://')) {
+            const ontology = await findOntologyByNamespace(shared, ontologyIri);
+            if (ontology?.$document) {
+                return toRange(ontology.$document, ontology);
+            }
+        }
+    }
+    if (!resolvedUri || !resolvedPath) {
+        return null;
+    }
+    const langiumDocuments: any = shared.workspace.LangiumDocuments;
+    const resolvedDocUri = URI.parse(resolvedUri);
+    const doc = langiumDocuments.getDocument(resolvedDocUri)
+        ?? (typeof langiumDocuments.getOrCreateDocument === 'function'
+            ? await langiumDocuments.getOrCreateDocument(resolvedDocUri)
+            : undefined);
+    if (!doc) {
+        return null;
+    }
+    const root = doc.parseResult?.value;
+    if (!root) {
+        return null;
+    }
+    const node = astNodeLocator.getAstNode(root, resolvedPath);
+    if (!node) {
+        return null;
+    }
+    return toRange(node.$document ?? doc, node);
+}
+
+export async function resolveDefinition(shared: any, elementId: string, referencingUri?: string): Promise<RangeResponse | null> {
+    const normalizedElementId = String(elementId ?? '').trim();
+    if (!normalizedElementId) {
+        return null;
+    }
+
+    const directSeparator = normalizedElementId.indexOf('#');
+    const directUri = directSeparator > 0 ? normalizedElementId.slice(0, directSeparator) : undefined;
+    const directPath = directSeparator > 0 ? normalizedElementId.slice(directSeparator + 1) : undefined;
+    if (directUri && directPath && directPath.startsWith('/')) {
+        try {
+            const langiumDocuments: any = shared.workspace.LangiumDocuments;
+            const resolvedDocUri = URI.parse(directUri);
+            const doc = langiumDocuments.getDocument(resolvedDocUri)
+                ?? (typeof langiumDocuments.getOrCreateDocument === 'function'
+                    ? await langiumDocuments.getOrCreateDocument(resolvedDocUri)
+                    : undefined);
+            const root = doc?.parseResult?.value;
+            const astNodeLocator = getAstNodeLocator(shared);
+            if (doc && root && astNodeLocator) {
+                const node = astNodeLocator.getAstNode(root, directPath);
+                if (node) {
+                    return toRange(node.$document ?? doc, node);
+                }
+            }
+        } catch {
+            // Fall through to IRI-based resolution when this is not a resolvable document URI.
+        }
+    }
+
+    const normalizedIri = normalizedElementId.replace(/^<|>$/g, '').trim();
+    if (!normalizedIri) {
+        return null;
+    }
+    if (referencingUri) {
+        const preferredRange = await resolveDefinitionByIriInModel(shared, normalizedIri, referencingUri);
+        if (preferredRange) {
+            return preferredRange;
+        }
+    }
+    const parts = splitIri(normalizedIri);
+    if (!parts || !parts.base || !parts.fragment) {
+        return null;
+    }
+    const ontology = await findOntologyByNamespace(shared, parts.base);
+    if (!ontology?.$document) {
+        return null;
+    }
+    const member = findOntologyMemberByName(ontology, parts.fragment);
+    if (!member) {
+        return null;
+    }
+    return toRange(member.$document ?? ontology.$document, member);
+}
+
+async function resolveDefinitionByIriInModel(shared: any, iri: string, modelUri: string): Promise<RangeResponse | null> {
+    const langiumDocuments: any = shared.workspace.LangiumDocuments;
+    const builder: any = shared.workspace.DocumentBuilder;
+    const uri = URI.parse(modelUri);
+    const document = langiumDocuments.getDocument(uri)
+        ?? (typeof langiumDocuments.getOrCreateDocument === 'function'
+            ? await langiumDocuments.getOrCreateDocument(uri)
+            : undefined);
+    if (!document) {
+        return null;
+    }
+    if (builder?.build) {
+        await builder.build([document], { validation: false });
+    }
+    const root = document.parseResult?.value;
+    if (!root || !isOntology(root) || (!isVocabulary(root) && !isDescription(root))) {
+        return null;
+    }
+    const targetIri = normalizeIriText(iri);
+    const member = collectOntologyMembers(root).find((candidate) => {
+        const candidateIri = normalizeIriText(getIriForNode(candidate));
+        if (candidateIri === targetIri) {
+            return true;
+        }
+        const resolvedRefIri = normalizeIriText(getIriForNode((candidate as any)?.ref?.ref));
+        if (resolvedRefIri === targetIri) {
+            return true;
+        }
+        const rawRefText = normalizeIriText((candidate as any)?.ref?.$refText);
+        return rawRefText === targetIri;
+    });
+    if (!member) {
+        return null;
+    }
+    return toRange(member.$document ?? document, member);
+}
+
+function normalizeIriText(value: unknown): string {
+    return typeof value === 'string' ? value.replace(/^<|>$/g, '').trim() : '';
+}
+
+async function findOntologyByNamespace(shared: any, namespace: string): Promise<Ontology | undefined> {
+    const index = getOntologyModelIndex(shared);
+    const modelUri = index?.resolveModelUri(normalizeNamespace(namespace));
+    if (!modelUri) {
+        return undefined;
+    }
+    const langiumDocuments: any = shared.workspace.LangiumDocuments;
+    const uri = URI.parse(modelUri);
+    const document = langiumDocuments.getDocument(uri)
+        ?? (typeof langiumDocuments.getOrCreateDocument === 'function'
+            ? await langiumDocuments.getOrCreateDocument(uri)
+            : undefined);
+    const root = document?.parseResult?.value;
+    return root && isOntology(root) ? root : undefined;
+}
+
+export type OntologyMemberLabelEntry = {
+    iri: string;
+    name: string;
+    label?: string;
+};
+
+export async function resolveOntologyMemberLabels(
+    shared: any,
+    oml: any,
+    modelUri: string,
+): Promise<OntologyMemberLabelEntry[]> {
+    const langiumDocuments: any = shared.workspace.LangiumDocuments;
+    const builder: any = shared.workspace.DocumentBuilder;
+    const uri = URI.parse(modelUri);
+    const document = langiumDocuments.getDocument(uri)
+        ?? (typeof langiumDocuments.getOrCreateDocument === 'function'
+            ? await langiumDocuments.getOrCreateDocument(uri)
+            : undefined);
+    if (!document) {
+        return [];
+    }
+    if (builder?.build) {
+        await builder.build([document], { validation: false });
+    }
+    const root = document.parseResult?.value;
+    if (!root || !isOntology(root) || (!isVocabulary(root) && !isDescription(root))) {
+        return [];
+    }
+    const reasoningService = oml?.reasoning?.ReasoningService;
+    const labelSnapshot: Record<string, string> = reasoningService && typeof reasoningService.getContextMemberLabelSnapshot === 'function'
+        ? await reasoningService.getContextMemberLabelSnapshot(modelUri)
+        : {};
+
+    const entries: OntologyMemberLabelEntry[] = [];
+    for (const member of collectOntologyMembers(root)) {
+        const iri = getIriForNode(member)?.trim();
+        const name = getNamedElementName(member)?.trim();
+        if (!iri || !name) {
+            continue;
+        }
+        const label = labelSnapshot[iri]?.trim();
+        entries.push({
+            iri,
+            name,
+            label: label && label.length > 0 ? label : undefined,
+        });
+    }
+    entries.sort((left, right) =>
+        left.name.localeCompare(right.name)
+        || left.iri.localeCompare(right.iri)
+    );
+    return entries;
+}
+
+function toRange(document: LangiumDocument | undefined, node: AstNode): RangeResponse | null {
+    if (!document?.textDocument) return null;
+    const cstNode = node.$cstNode;
+    if (!cstNode) return null;
+    const start = document.textDocument.positionAt(cstNode.offset);
+    const end = document.textDocument.positionAt(cstNode.offset + cstNode.length);
+    return {
+        uri: document.uri.toString(),
+        startLine: start.line + 1,
+        startColumn: start.character,
+        endLine: end.line + 1,
+        endColumn: end.character
+    };
+}