@oml/language 0.13.0 → 0.14.0

package/out/oml/oml-diagram.js

@@ -0,0 +1,1549 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+import * as ElkModule from 'elkjs/lib/elk.bundled.js';
+import { URI } from 'langium';
+import { isAspect, isConcept, isConceptInstance, isDescription, isDescriptionBundle, isEquivalenceAxiom, isImport, isInstanceEnumerationAxiom, isLiteralEnumerationAxiom, isOntology, isPropertyValueAssertion, isRelation, isRelationEntity, isRelationInstance, isScalar, isScalarProperty, isSpecializationAxiom, isUnreifiedRelation, isVocabulary, isVocabularyBundle } from './generated/ast.js';
+import { getOntologyModelIndex } from './oml-index.js';
+import { collectOntologyMembers, findOntologyMemberByName, getIriForNode, getModelIdForNode, getNamedElementName, humanizeTypeName, normalizeNamespace, splitIri } from './oml-utils.js';
+const ElkConstructor = ElkModule.default || ElkModule;
+let elkPromise;
+const navigationIndex = new Map();
+async function getElk() {
+    if (!elkPromise) {
+        elkPromise = (async () => {
+            try {
+                const workerModule = await import('elkjs/lib/elk-worker.js');
+                const ElkWorkerCtor = workerModule.Worker
+                    || workerModule.default?.Worker
+                    || workerModule.default
+                    || workerModule;
+                return new ElkConstructor({
+                    algorithms: ['layered'],
+                    workerFactory: (url) => new ElkWorkerCtor(url)
+                });
+            }
+            catch (error) {
+                console.error('[OML Diagram] Failed to initialize ELK:', error);
+                return {
+                    layout: async (graph) => graph
+                };
+            }
+        })();
+    }
+    return await elkPromise;
+}
+function getAstNodeLocator(shared) {
+    const isLocator = (candidate) => !!candidate
+        && typeof candidate.getAstNodePath === 'function'
+        && typeof candidate.getAstNode === 'function';
+    const direct = shared?.workspace?.AstNodeLocator ?? shared?.AstNodeLocator;
+    if (isLocator(direct)) {
+        return direct;
+    }
+    const registry = 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 ?? [])));
+    for (const languageServices of services) {
+        const locator = languageServices?.workspace?.AstNodeLocator ?? languageServices?.AstNodeLocator;
+        if (isLocator(locator)) {
+            return locator;
+        }
+    }
+    return undefined;
+}
+function buildDiagramContext(root) {
+    const nsToPrefix = new Map();
+    for (const ownedImport of (root.ownedImports ?? [])) {
+        if (!isImport(ownedImport))
+            continue;
+        const importedOntology = ownedImport.imported?.ref;
+        const prefix = ownedImport.prefix;
+        if (!importedOntology || !prefix)
+            continue;
+        const ns = normalizeNamespace(String(importedOntology.namespace ?? '').replace(/^<|>$/g, ''));
+        if (!ns)
+            continue;
+        nsToPrefix.set(ns, prefix);
+    }
+    return { root, nsToPrefix };
+}
+function getContainingOntology(astNode) {
+    let current = astNode;
+    while (current && !isOntology(current)) {
+        current = current.$container;
+    }
+    return current;
+}
+function unwrapReferenceValue(candidate) {
+    if (!candidate || typeof candidate !== 'object') {
+        return candidate;
+    }
+    if ('$refText' in candidate && 'ref' in candidate) {
+        return candidate.ref;
+    }
+    return candidate;
+}
+function getQualifiedName(ctx, astNode) {
+    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.namespace ?? '').replace(/^<|>$/g, ''));
+        if (!namespace) {
+            return undefined;
+        }
+        const prefix = value.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?.namespace ?? '').replace(/^<|>$/g, ''));
+    const prefix = namespace ? ctx.nsToPrefix.get(namespace) : undefined;
+    return prefix ? `${prefix}:${name}` : name;
+}
+function getRefDisplayName(ctx, refLike) {
+    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) {
+    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, maxChars) {
+    if (maxChars <= 0)
+        return '';
+    if (text.length <= maxChars)
+        return text;
+    if (maxChars === 1)
+        return '…';
+    return `${text.slice(0, maxChars - 1)}…`;
+}
+function iriNamespace(iri) {
+    if (!iri)
+        return undefined;
+    const parts = splitIri(iri);
+    return parts?.base;
+}
+function formatHoverLikeTooltip(kind, qualified, iri) {
+    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) {
+    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, ctx, viewId, astNodeLocator, rootUri) {
+    const entries = [];
+    if (isLiteralEnumerationAxiom(statement)) {
+        let index = 0;
+        for (const literal of (statement.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.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, ctx) {
+    const qName = getQualifiedName(ctx, property);
+    if (!qName) {
+        return undefined;
+    }
+    const ranges = (property.ranges ?? [])
+        .map((rangeRef) => getRefDisplayName(ctx, rangeRef))
+        .filter((value) => typeof value === 'string' && value.length > 0)
+        .map((value) => toSimpleName(value));
+    return ranges.length > 0 ? `${toSimpleName(qName)}: ${ranges.join(' | ')}` : toSimpleName(qName);
+}
+function getAssertionValueLabel(ctx, assertion) {
+    const parts = [];
+    for (const literal of (assertion.literalValues ?? [])) {
+        parts.push(toLiteralLabel(literal));
+    }
+    for (const referenced of (assertion.referencedValues ?? [])) {
+        const qName = getRefDisplayName(ctx, referenced);
+        parts.push(qName ? toSimpleName(qName) : '[instance]');
+    }
+    for (const contained of (assertion.containedValues ?? [])) {
+        const qName = getQualifiedName(ctx, contained);
+        parts.push(qName ? toSimpleName(qName) : '[instance]');
+    }
+    return parts.join(', ');
+}
+export async function computeLaidOutSModelForUri(shared, modelUri) {
+    const documentUri = URI.parse(modelUri);
+    let document = shared.workspace.LangiumDocuments.getDocument(documentUri);
+    if (!document) {
+        return { id: 'root', type: 'graph', children: [] };
+    }
+    const root = document.parseResult?.value;
+    if (!root || !isOntology(root)) {
+        return { id: 'root', type: 'graph', children: [] };
+    }
+    const graph = await computeDiagramGraph(shared, document, root);
+    indexDiagramMappings(shared, graph);
+    return await layoutAndConvertToSModel(graph);
+}
+async function computeDiagramGraph(shared, document, root) {
+    const graph = {
+        rootUri: document.uri.toString(),
+        root,
+        nodes: [],
+        edges: [],
+        statementsById: new Map()
+    };
+    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, root, graph) {
+    const astNodeLocator = getAstNodeLocator(shared);
+    const ctx = buildDiagramContext(root);
+    const nodeByQName = new Map();
+    const statements = root.ownedStatements ?? [];
+    const ensureEntityNode = (candidate) => {
+        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 = isConcreteEntity && isUnreifiedRelation(statement) ? 'relation' : 'entity';
+        const node = {
+            id: viewId,
+            viewId,
+            modelId,
+            iri: isConcreteEntity ? getIriForNode(statement) : undefined,
+            label: toSimpleName(qName),
+            qualifiedLabel: qName,
+            tooltip: formatHoverLikeTooltip(isConcreteEntity ? humanizeTypeName(statement.$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.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) => ensureEntityNode(r)).filter(Boolean);
+            const targets = (statement.targets ?? []).map((r) => ensureEntityNode(r)).filter(Boolean);
+            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) => ensureEntityNode(r)).filter(Boolean);
+        const targets = (statement.targets ?? []).map((r) => ensureEntityNode(r)).filter(Boolean);
+        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, axiom, index) => {
+        if (!isSpecializationAxiom(axiom))
+            return;
+        const superTerm = axiom.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, axiom, index) => {
+        if (!isEquivalenceAxiom(axiom))
+            return;
+        const subNode = ensureEntityNode(owner);
+        if (!subNode)
+            return;
+        const superTerms = (axiom.superTerms ?? []).map((ref) => 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 = {
+                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.ownedSpecializations ?? [];
+        for (let i = 0; i < ownedSpecializations.length; i += 1) {
+            addSpecializationEdge(statement, ownedSpecializations[i], i);
+        }
+        const ownedEquivalences = statement.ownedEquivalences ?? [];
+        for (let i = 0; i < ownedEquivalences.length; i += 1) {
+            addEquivalenceEdges(statement, ownedEquivalences[i], i);
+        }
+    }
+}
+function computeDescriptionGraph(shared, root, graph) {
+    const astNodeLocator = getAstNodeLocator(shared);
+    const ctx = buildDiagramContext(root);
+    const nodeByQName = new Map();
+    const ensureInstanceNode = (candidate) => {
+        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.ownedTypes ?? [])
+            .map((typeAssertion) => getQualifiedName(ctx, typeAssertion?.type?.ref ?? typeAssertion?.type))
+            .filter((label) => typeof label === 'string' && label.length > 0))).map((label) => toSimpleName(label));
+        const label = toSimpleName(qName);
+        const propertyEntries = [];
+        let propertyIndex = 0;
+        for (const assertion of (statement.ownedPropertyValues ?? [])) {
+            if (getContainingOntology(assertion) !== root)
+                continue;
+            if (!isPropertyValueAssertion(assertion))
+                continue;
+            const propertyRef = assertion.property?.ref;
+            if (!propertyRef || !isScalarProperty(propertyRef))
+                continue;
+            const propertyName = getQualifiedName(ctx, propertyRef) ?? assertion.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 = {
+            id: viewId,
+            viewId,
+            modelId,
+            iri: getIriForNode(statement),
+            label,
+            instanceTypeLabels: typeLabels,
+            qualifiedLabel: qName,
+            tooltip: formatHoverLikeTooltip(humanizeTypeName(statement.$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, ownerNode) => {
+        if (!ownerNode)
+            return;
+        const ownedPropertyValues = ownerStatement.ownedPropertyValues ?? [];
+        for (const assertion of ownedPropertyValues) {
+            if (!isPropertyValueAssertion(assertion))
+                continue;
+            const propertyRef = assertion.property?.ref;
+            if (!propertyRef || !isRelation(propertyRef))
+                continue;
+            const relationName = getQualifiedName(ctx, propertyRef) ?? assertion.property?.$refText ?? 'relation';
+            const referencedValues = assertion.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) => ensureInstanceNode(r)).filter(Boolean);
+        const targets = (statement.targets ?? []).map((r) => ensureInstanceNode(r)).filter(Boolean);
+        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, root, graph) {
+    const astNodeLocator = getAstNodeLocator(shared);
+    const queue = [root];
+    const seen = new Set();
+    const nodeByNamespace = new Map();
+    const directImports = new Map();
+    const seedImports = (root.ownedImports ?? []);
+    for (const ownedImport of seedImports) {
+        const importedOntology = await resolveImportedOntology(shared, ownedImport);
+        if (!importedOntology)
+            continue;
+        queue.push(importedOntology);
+    }
+    const ensureOntologyNode = (ontology, namespace) => {
+        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.prefix || namespace.split('/').pop() || namespace;
+        const node = {
+            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.namespace ?? '');
+        if (!namespace || seen.has(namespace))
+            continue;
+        seen.add(namespace);
+        ensureOntologyNode(current, namespace);
+        for (const ownedImport of (current.ownedImports ?? [])) {
+            const importedOntology = await resolveImportedOntology(shared, ownedImport);
+            if (!importedOntology)
+                continue;
+            const importedNamespace = normalizeNamespace(importedOntology.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, target) => {
+        const visited = new Set([source]);
+        const work = [];
+        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, ownedImport) {
+    const refText = ownedImport?.imported?.$refText ?? '';
+    const namespace = normalizeNamespace(String(refText).replace(/^<|>$/g, ''));
+    if (namespace) {
+        const resolved = await findOntologyByNamespace(shared, namespace);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    const direct = ownedImport?.imported?.ref;
+    if (direct && isOntology(direct)) {
+        return direct;
+    }
+    return undefined;
+}
+function getNodeSize(node) {
+    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) {
+    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?.$type;
+    if (typeof explicitType === 'string' && explicitType.length > 0) {
+        return `«${humanizeTypeName(explicitType)}»`;
+    }
+    if (node.kind === 'ontology')
+        return '«ontology»';
+    return '«concept»';
+}
+async function layoutAndConvertToSModel(graph) {
+    if (graph.nodes.length === 0) {
+        return { id: 'root', type: 'graph', children: [] };
+    }
+    const selfLoopCountByNode = new Map();
+    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();
+    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 = {
+        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((laidOut.children ?? []).map((n) => [n.id, n]));
+    const edgeMap = new Map((laidOut.edges ?? []).map((e) => [e.id, e]));
+    const diagramNodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+    const extractRoutingPoints = (elkEdge) => {
+        if (!elkEdge || !Array.isArray(elkEdge.sections) || elkEdge.sections.length === 0)
+            return [];
+        const section = elkEdge.sections[0];
+        const points = [];
+        const pushPoint = (p) => {
+            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) => {
+        if (points.length <= 2)
+            return points;
+        const simplified = [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, loopIndex) => {
+        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();
+    const children = [];
+    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 }
+                    }
+                ]
+            });
+            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 = [
+            {
+                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 }
+                    }
+                ]
+            }
+        ];
+        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)
+                    }
+                }))
+            });
+            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)
+                    }
+                }))
+            });
+        }
+        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
+        });
+    }
+    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
+        });
+    }
+    return {
+        id: 'root',
+        type: 'graph',
+        children
+    };
+}
+function normalizeDiagramElementId(elementId) {
+    return elementId.endsWith(':label') ? elementId.slice(0, -':label'.length) : elementId;
+}
+function indexDiagramMappings(shared, graph) {
+    const astNodeLocator = getAstNodeLocator(shared);
+    if (!astNodeLocator) {
+        navigationIndex.set(graph.rootUri, new Map());
+        return;
+    }
+    const map = new Map();
+    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, contextUri, elementId) {
+    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 = 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, elementId, referencingUri) {
+    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 = 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, iri, modelUri) {
+    const langiumDocuments = shared.workspace.LangiumDocuments;
+    const builder = 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?.ref?.ref));
+        if (resolvedRefIri === targetIri) {
+            return true;
+        }
+        const rawRefText = normalizeIriText(candidate?.ref?.$refText);
+        return rawRefText === targetIri;
+    });
+    if (!member) {
+        return null;
+    }
+    return toRange(member.$document ?? document, member);
+}
+function normalizeIriText(value) {
+    return typeof value === 'string' ? value.replace(/^<|>$/g, '').trim() : '';
+}
+async function findOntologyByNamespace(shared, namespace) {
+    const index = getOntologyModelIndex(shared);
+    const modelUri = index?.resolveModelUri(normalizeNamespace(namespace));
+    if (!modelUri) {
+        return undefined;
+    }
+    const langiumDocuments = 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 async function resolveOntologyMemberLabels(shared, oml, modelUri) {
+    const langiumDocuments = shared.workspace.LangiumDocuments;
+    const builder = 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 = reasoningService && typeof reasoningService.getContextMemberLabelSnapshot === 'function'
+        ? await reasoningService.getContextMemberLabelSnapshot(modelUri)
+        : {};
+    const entries = [];
+    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, node) {
+    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
+    };
+}
+//# sourceMappingURL=oml-diagram.js.map