@oml/language 0.7.0

package/src/oml/oml-formatter.ts

@@ -0,0 +1,390 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type { Formatter } from 'langium/lsp';
+import type { LangiumDocument } from 'langium';
+import type {
+    DocumentFormattingParams,
+    DocumentOnTypeFormattingOptions,
+    DocumentOnTypeFormattingParams,
+    DocumentRangeFormattingParams,
+    TextEdit,
+} from 'vscode-languageserver-protocol';
+import { TextEdit as VsTextEdit } from 'vscode-languageserver-protocol';
+import { isOntology } from './generated/ast.js';
+import { serializeOntology } from './oml-serializer.js';
+
+export class OmlFormatter implements Formatter {
+    private readonly formattedTextCache = new Map<string, { version: number; text: string }>();
+
+    formatDocument(document: LangiumDocument, _params: DocumentFormattingParams): TextEdit[] {
+        const formatted = this.getFormattedText(document);
+        if (formatted === undefined) {
+            return [];
+        }
+        const textDocument = document.textDocument;
+        const end = textDocument.positionAt(textDocument.getText().length);
+        return [VsTextEdit.replace({ start: { line: 0, character: 0 }, end }, formatted)];
+    }
+
+    formatDocumentRange(document: LangiumDocument, params: DocumentRangeFormattingParams): TextEdit[] {
+        return this.formatRange(document, params.range);
+    }
+
+    formatDocumentOnType(document: LangiumDocument, params: DocumentOnTypeFormattingParams): TextEdit[] {
+        const textDocument = document.textDocument;
+        const text = textDocument.getText();
+        const lines = text.split('\n');
+        const line = Math.min(params.position.line, lines.length - 1);
+        if (line < 0) {
+            return [];
+        }
+        const currentLine = lines[line] ?? '';
+        const desiredIndent = this.computeOnTypeIndent(lines, line);
+        if (desiredIndent === undefined) {
+            return [];
+        }
+
+        const currentIndent = currentLine.match(/^\s*/)?.[0] ?? '';
+        if (currentIndent === desiredIndent) {
+            return [];
+        }
+
+        return [VsTextEdit.replace(
+            { start: { line, character: 0 }, end: { line, character: currentIndent.length } },
+            desiredIndent
+        )];
+    }
+
+    get formatOnTypeOptions(): DocumentOnTypeFormattingOptions | undefined {
+        return {
+            firstTriggerCharacter: '\n'
+        };
+    }
+
+    private getFormattedText(document: LangiumDocument): string | undefined {
+        const parseResult = document.parseResult;
+        if (!parseResult || parseResult.lexerErrors.length || parseResult.parserErrors.length) {
+            return undefined;
+        }
+        const uri = document.uri?.toString() ?? document.textDocument.uri;
+        const version = document.textDocument.version ?? 0;
+        const cached = this.formattedTextCache.get(uri);
+        if (cached && cached.version === version) {
+            return cached.text;
+        }
+        const root = parseResult.value;
+        if (!root || !isOntology(root)) {
+            return undefined;
+        }
+        const formatted = serializeOntology(root);
+        const text = this.mergeComments(document.textDocument.getText(), formatted);
+        this.formattedTextCache.set(uri, { version, text });
+        if (this.formattedTextCache.size > 200) {
+            this.formattedTextCache.clear();
+        }
+        return text;
+    }
+
+    private formatRange(document: LangiumDocument, range: { start: { line: number; character: number }; end: { line: number; character: number } }): TextEdit[] {
+        const formatted = this.getFormattedText(document);
+        if (formatted === undefined) {
+            return [];
+        }
+        const textDocument = document.textDocument;
+        const original = textDocument.getText();
+        const startOffset = textDocument.offsetAt(range.start);
+        const endOffset = textDocument.offsetAt(range.end);
+        const prefix = original.slice(0, startOffset);
+        const suffix = original.slice(endOffset);
+        if (!formatted.startsWith(prefix) || !formatted.endsWith(suffix)) {
+            const originalLines = original.split('\n');
+            const formattedLines = formatted.split('\n');
+            const startLine = Math.max(0, range.start.line);
+            const endLine = Math.min(range.end.line, originalLines.length - 1);
+            const commonPrefix = this.countCommonPrefixLines(originalLines, formattedLines);
+            const commonSuffix = this.countCommonSuffixLines(originalLines, formattedLines, commonPrefix);
+            const delta = formattedLines.length - originalLines.length;
+            let startLineFormatted = startLine;
+            let endLineFormatted = endLine;
+            if (startLine >= commonPrefix && endLine <= originalLines.length - commonSuffix - 1) {
+                startLineFormatted = startLine + delta;
+                endLineFormatted = endLine + delta;
+            }
+            if (
+                startLineFormatted < 0 ||
+                endLineFormatted < startLineFormatted ||
+                endLineFormatted >= formattedLines.length
+            ) {
+                return [];
+            }
+            const replacementLines = formattedLines.slice(startLineFormatted, endLineFormatted + 1);
+            const rangeForLines = {
+                start: { line: startLine, character: 0 },
+                end: { line: endLine, character: originalLines[endLine]?.length ?? 0 }
+            };
+            return [VsTextEdit.replace(rangeForLines, replacementLines.join('\n'))];
+        }
+        const replacement = formatted.slice(prefix.length, formatted.length - suffix.length);
+        return [VsTextEdit.replace(range, replacement)];
+    }
+
+    private mergeComments(original: string, formatted: string): string {
+        const originalLines = original.split('\n');
+        const formattedLines = formatted.split('\n');
+        const blocks = this.collectCommentBlocks(originalLines);
+        const inlineComments = this.collectInlineComments(originalLines);
+        const anchorLookup = this.buildAnchorIndex(formattedLines);
+        let insertOffset = 0;
+        for (const block of blocks) {
+            const anchorLine = block.anchorText
+                ? this.findAnchorLine(anchorLookup, block.anchorText, insertOffset)
+                : -1;
+            const insertAt = anchorLine === -1 ? formattedLines.length : anchorLine;
+            const insertLines = block.trailingBlankLines
+                ? [...block.lines, ...Array.from({ length: block.trailingBlankLines }, () => '')]
+                : block.lines;
+            formattedLines.splice(insertAt, 0, ...insertLines);
+            insertOffset = insertAt + insertLines.length;
+        }
+        if (inlineComments.size > 0) {
+            for (let i = 0; i < formattedLines.length; i += 1) {
+                const line = formattedLines[i];
+                if (this.findLineCommentIndex(line) !== -1) {
+                    continue;
+                }
+                const code = line.trim();
+                const queue = inlineComments.get(code);
+                if (!queue || queue.length === 0) {
+                    continue;
+                }
+                const suffix = queue.shift() ?? '';
+                formattedLines[i] = `${line}${suffix}`;
+            }
+        }
+        return formattedLines.join('\n');
+    }
+
+    private collectCommentBlocks(lines: string[]): Array<{ lines: string[]; anchorText?: string; trailingBlankLines: number }> {
+        const blocks: Array<{ lines: string[]; anchorText?: string; trailingBlankLines: number }> = [];
+        let index = 0;
+        let inBlock = false;
+        while (index < lines.length) {
+            const line = lines[index];
+            const trimmed = line.trim();
+            const isLineComment = trimmed.startsWith('//');
+            const isBlockStart = trimmed.startsWith('/*');
+            const isBlockContinue = inBlock || trimmed.startsWith('*');
+            if (isLineComment || isBlockStart || isBlockContinue) {
+                const blockLines: string[] = [];
+                while (index < lines.length) {
+                    const current = lines[index];
+                    const currentTrimmed = current.trim();
+                    const currentLineComment = currentTrimmed.startsWith('//');
+                    const currentBlockStart = currentTrimmed.startsWith('/*');
+                    const currentBlockContinue = inBlock || currentTrimmed.startsWith('*');
+                    if (!(currentLineComment || currentBlockStart || currentBlockContinue)) {
+                        break;
+                    }
+                    blockLines.push(current);
+                    if (currentTrimmed.includes('*/')) {
+                        inBlock = false;
+                    } else if (currentBlockStart) {
+                        inBlock = true;
+                    }
+                    index += 1;
+                }
+                let anchorText: string | undefined;
+                let trailingBlankLines = 0;
+                let lookahead = index;
+                while (lookahead < lines.length) {
+                    const next = lines[lookahead].trim();
+                    if (!next) {
+                        trailingBlankLines += 1;
+                        lookahead += 1;
+                        continue;
+                    }
+                    if (next && !next.startsWith('//') && !next.startsWith('/*') && !next.startsWith('*')) {
+                        anchorText = next;
+                        break;
+                    }
+                    lookahead += 1;
+                }
+                blocks.push({ lines: blockLines, anchorText, trailingBlankLines });
+                continue;
+            }
+            index += 1;
+        }
+        return blocks;
+    }
+
+    private collectInlineComments(lines: string[]): Map<string, string[]> {
+        const inline = new Map<string, string[]>();
+        for (const line of lines) {
+            const commentIndex = this.findLineCommentIndex(line);
+            if (commentIndex === -1) {
+                continue;
+            }
+            const codePart = line.slice(0, commentIndex);
+            const commentPart = line.slice(commentIndex);
+            if (!codePart.trim()) {
+                continue;
+            }
+            const key = codePart.trim();
+            const bucket = inline.get(key) ?? [];
+            bucket.push(` ${commentPart.trimStart()}`);
+            inline.set(key, bucket);
+        }
+        return inline;
+    }
+
+    private findLineCommentIndex(line: string): number {
+        let inSingle = false;
+        let inDouble = false;
+        let inTripleSingle = false;
+        let inTripleDouble = false;
+        let inAngle = false;
+        for (let i = 0; i < line.length - 1; i += 1) {
+            const ch = line[i];
+            const next = line[i + 1];
+            if (!inSingle && !inDouble && !inTripleSingle && !inTripleDouble && ch === '<') {
+                inAngle = true;
+            } else if (inAngle && ch === '>') {
+                inAngle = false;
+            }
+            if (!inAngle) {
+                if (!inSingle && !inDouble && ch === '\'' && next === '\'' && line[i + 2] === '\'') {
+                    inTripleSingle = !inTripleSingle;
+                    i += 2;
+                    continue;
+                }
+                if (!inSingle && !inDouble && ch === '"' && next === '"' && line[i + 2] === '"') {
+                    inTripleDouble = !inTripleDouble;
+                    i += 2;
+                    continue;
+                }
+                if (!inTripleSingle && !inTripleDouble && ch === '\'' && !inDouble) {
+                    inSingle = !inSingle;
+                    continue;
+                }
+                if (!inTripleSingle && !inTripleDouble && ch === '"' && !inSingle) {
+                    inDouble = !inDouble;
+                    continue;
+                }
+            }
+            if (!inSingle && !inDouble && !inTripleSingle && !inTripleDouble && !inAngle && ch === '/' && next === '/') {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private buildAnchorIndex(lines: string[]): Map<string, { indices: number[]; cursor: number }> {
+        const index = new Map<string, { indices: number[]; cursor: number }>();
+        for (let i = 0; i < lines.length; i += 1) {
+            const key = lines[i].trim();
+            if (!key) {
+                continue;
+            }
+            let entry = index.get(key);
+            if (!entry) {
+                entry = { indices: [], cursor: 0 };
+                index.set(key, entry);
+            }
+            entry.indices.push(i);
+        }
+        return index;
+    }
+
+    private findAnchorLine(index: Map<string, { indices: number[]; cursor: number }>, anchorText: string, startIndex: number): number {
+        const entry = index.get(anchorText);
+        if (!entry) {
+            return -1;
+        }
+        while (entry.cursor < entry.indices.length && entry.indices[entry.cursor] < startIndex) {
+            entry.cursor += 1;
+        }
+        if (entry.cursor >= entry.indices.length) {
+            return -1;
+        }
+        const line = entry.indices[entry.cursor];
+        entry.cursor += 1;
+        return line;
+    }
+
+    private countCommonPrefixLines(originalLines: string[], formattedLines: string[]): number {
+        const limit = Math.min(originalLines.length, formattedLines.length);
+        let index = 0;
+        while (index < limit && originalLines[index] === formattedLines[index]) {
+            index += 1;
+        }
+        return index;
+    }
+
+    private countCommonSuffixLines(originalLines: string[], formattedLines: string[], prefixCount: number): number {
+        const originalLimit = originalLines.length - prefixCount;
+        const formattedLimit = formattedLines.length - prefixCount;
+        const limit = Math.min(originalLimit, formattedLimit);
+        let count = 0;
+        while (count < limit) {
+            const originalIndex = originalLines.length - 1 - count;
+            const formattedIndex = formattedLines.length - 1 - count;
+            if (originalLines[originalIndex] !== formattedLines[formattedIndex]) {
+                break;
+            }
+            count += 1;
+        }
+        return count;
+    }
+
+    private computeOnTypeIndent(lines: string[], line: number): string | undefined {
+        const currentLine = lines[line] ?? '';
+        const trimmedCurrent = currentLine.trim();
+        if (trimmedCurrent.startsWith('//') || trimmedCurrent.startsWith('/*') || trimmedCurrent.startsWith('*')) {
+            return undefined;
+        }
+        const indentUnit = this.detectIndentUnit(lines);
+
+        let previousIndex = line - 1;
+        while (previousIndex >= 0 && !(lines[previousIndex] ?? '').trim()) {
+            previousIndex -= 1;
+        }
+        if (previousIndex < 0) {
+            return '';
+        }
+
+        const previousLine = lines[previousIndex] ?? '';
+        const previousIndent = previousLine.match(/^\s*/)?.[0] ?? '';
+        const previousTrimmed = previousLine.trim();
+        let level = previousIndent.length;
+
+        if (previousTrimmed.endsWith('{')) {
+            level += indentUnit.length;
+        }
+        if (trimmedCurrent.startsWith('}')) {
+            level -= indentUnit.length;
+        }
+
+        level = Math.max(0, level);
+        if (indentUnit.startsWith('\t')) {
+            return '\t'.repeat(Math.floor(level / indentUnit.length));
+        }
+        return ' '.repeat(level);
+    }
+
+    private detectIndentUnit(lines: string[]): string {
+        for (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            const indent = line.match(/^\s+/)?.[0];
+            if (!indent) {
+                continue;
+            }
+            if (indent.includes('\t')) {
+                return '\t';
+            }
+            return ' '.repeat(Math.min(indent.length, 4));
+        }
+        return '    ';
+    }
+}

package/src/oml/oml-hover.ts

@@ -0,0 +1,93 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+/**
+ * OML Hover Provider
+ * Provides rich hover information for OML elements with type and namespace details
+ */
+
+import type { AstNode, LangiumDocument, MaybePromise } from 'langium';
+import { CstUtils } from 'langium';
+import { AstNodeHoverProvider } from 'langium/lsp';
+import type { LangiumServices } from 'langium/lsp';
+import type { Hover, HoverParams } from 'vscode-languageserver-protocol';
+import { MarkupKind } from 'vscode-languageserver-protocol';
+import { findOwningOntologyNode, humanizeTypeName } from './oml-utils.js';
+
+export class OmlHoverProvider extends AstNodeHoverProvider {
+
+    constructor(services: LangiumServices) {
+        super(services);
+    }
+
+    override async getHoverContent(document: LangiumDocument, params: HoverParams): Promise<Hover | undefined> {
+        const rootNode = document.parseResult?.value?.$cstNode;
+        if (rootNode) {
+            const offset = document.textDocument.offsetAt(params.position);
+            const cstNode = CstUtils.findDeclarationNodeAtOffset(rootNode, offset, this.grammarConfig.nameRegexp);
+            if (cstNode && cstNode.offset + cstNode.length > offset) {
+                const contents: string[] = [];
+                const targetNodes = this.references.findDeclarations(cstNode);
+                for (const targetNode of targetNodes) {
+                    const content = await this.getAstNodeHoverContent(targetNode);
+                    if (typeof content === 'string') {
+                        contents.push(content);
+                    }
+                }
+                if (contents.length > 0) {
+                    // Override to use proper MarkupKind.Markdown instead of 'markdown' with language
+                    return {
+                        contents: {
+                            kind: MarkupKind.Markdown,
+                            value: contents.join('\n\n---\n\n')
+                        }
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+
+    protected getAstNodeHoverContent(node: AstNode): MaybePromise<string | undefined> {
+        // The node here is the AST node under the cursor
+        // Check if it has a name property (it's a definition)
+        if ((node as any).name) {
+            const elementType = node.$type || 'element';
+            const keyword = humanizeTypeName(elementType);
+            const name = (node as any).name;
+
+            let hoverText = `**${keyword}** \`${name}\``;
+
+            const ontology = findOwningOntologyNode(node);
+            if (ontology?.namespace) {
+                const namespace = ontology.namespace.replace(/^<|>$/g, '');
+                hoverText += `\n\nDefined in: \`${namespace}\``;
+            }
+
+            return hoverText;
+        }
+
+        // For references, we want to show info about the referenced element
+        const ref = (node as any).ref;
+
+        if (ref && ref.name) {
+            // Get the element type
+            const elementType = ref.$type || 'element';
+            const keyword = humanizeTypeName(elementType);
+
+            // Build hover text: "keyword name"
+            let hoverText = `**${keyword}** \`${ref.name}\``;
+
+            // Add namespace if available
+            const ontology = findOwningOntologyNode(ref);
+            if (ontology?.namespace) {
+                const namespace = ontology.namespace.replace(/^<|>$/g, '');
+                hoverText += `\n\nDefined in: \`${namespace}\``;
+            }
+
+            return hoverText;
+        }
+
+        return undefined;
+    }
+
+}

package/src/oml/oml-index-manager.ts

@@ -0,0 +1,56 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { AstUtils, DefaultIndexManager, URI, UriUtils, stream, type AstNode, type LangiumDocument, type LangiumSharedCoreServices, type ReferenceDescription } from 'langium';
+import type { CancellationToken } from 'vscode-jsonrpc';
+import { canonicalizeWorkspaceDocumentUri } from './oml-workspace.js';
+
+export class OmlIndexManager extends DefaultIndexManager {
+    private readonly services: LangiumSharedCoreServices;
+
+    constructor(services: LangiumSharedCoreServices) {
+        super(services);
+        this.services = services;
+    }
+
+    override findAllReferences(targetNode: AstNode, astNodePath: string) {
+        const targetDocUri = this.canonicalizeUri(AstUtils.getDocument(targetNode).uri);
+        const result: ReferenceDescription[] = [];
+        this.referenceIndex.forEach(docRefs => {
+            docRefs.forEach(refDescr => {
+                if (UriUtils.equals(this.canonicalizeUri(refDescr.targetUri), targetDocUri) && refDescr.targetPath === astNodePath) {
+                    result.push(refDescr);
+                }
+            });
+        });
+        return stream(result);
+    }
+
+    override async updateReferences(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void> {
+        const services = this.serviceRegistry.getServices(document.uri);
+        const references = await services.workspace.ReferenceDescriptionProvider.createDescriptions(document, cancelToken);
+        const sourceUri = this.canonicalizeUri(document.uri);
+        this.referenceIndex.set(document.uri.toString(), references.map(ref => {
+            const targetUri = this.canonicalizeUri(ref.targetUri);
+            return {
+                ...ref,
+                sourceUri,
+                targetUri,
+                local: UriUtils.equals(sourceUri, targetUri),
+            };
+        }));
+    }
+
+    override isAffected(document: LangiumDocument, changedUris: Set<string>): boolean {
+        const references = this.referenceIndex.get(document.uri.toString());
+        if (!references) {
+            return false;
+        }
+        const canonicalChangedUris = new Set(Array.from(changedUris, uri => this.canonicalizeUri(uri).toString()));
+        return references.some(ref => !ref.local && canonicalChangedUris.has(this.canonicalizeUri(ref.targetUri).toString()));
+    }
+
+    private canonicalizeUri(uri: URI | string): URI {
+        const parsedUri = typeof uri === 'string' ? URI.parse(uri) : uri;
+        return canonicalizeWorkspaceDocumentUri(this.services.workspace.WorkspaceManager, parsedUri);
+    }
+}

package/src/oml/oml-index.ts

@@ -0,0 +1,145 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { DocumentState, type LangiumDocument } from 'langium';
+import type { LangiumSharedServices } from 'langium/lsp';
+import { isOntology } from './generated/ast.js';
+import { isTransientEditorDocumentUri } from './oml-utils.js';
+
+const ontologyIndexByShared = new WeakMap<object, OntologyModelIndex>();
+
+export function getOntologyModelIndex(shared: LangiumSharedServices): OntologyModelIndex {
+    const key = shared as object;
+    const existing = ontologyIndexByShared.get(key);
+    if (existing) {
+        return existing;
+    }
+    const created = new OntologyModelIndex(shared);
+    ontologyIndexByShared.set(key, created);
+    return created;
+}
+
+export class OntologyModelIndex {
+    private readonly ontologyIdentifierToModelUri = new Map<string, string>();
+    private readonly modelUriToOntologyIri = new Map<string, string>();
+    private readonly workspaceModelUrisByOntologyIri = new Map<string, Set<string>>();
+    private readonly workspaceOntologyIriByModelUri = new Map<string, string>();
+    private readonly workspaceNamespaceByModelUri = new Map<string, string>();
+
+    constructor(private readonly shared: LangiumSharedServices) {
+        this.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Parsed, (document) => {
+            this.indexDocument(document);
+        });
+    }
+
+    resolveModelUri(identifier: string): string | undefined {
+        this.ensureIndexedFromLoadedDocuments();
+        const normalized = this.normalizeNamespace(identifier);
+        if (!normalized) {
+            return undefined;
+        }
+        const ontologyIri = this.ontologyIriFromNamespace(normalized);
+        const candidates = this.workspaceModelUrisByOntologyIri.get(ontologyIri);
+        if (!candidates || candidates.size !== 1) {
+            return undefined;
+        }
+        return [...candidates][0];
+    }
+
+    resolveOntologyIri(modelUri: string): string | undefined {
+        this.ensureIndexedFromLoadedDocuments();
+        return this.modelUriToOntologyIri.get(modelUri);
+    }
+
+    removeModel(modelUri: string): void {
+        this.unindexModelUri(modelUri);
+    }
+
+    private ensureIndexedFromLoadedDocuments(): void {
+        const docs: any = this.shared.workspace.LangiumDocuments;
+        const all = docs.all ?? [];
+        const iterable: Iterable<LangiumDocument> = Array.isArray(all)
+            ? all
+            : (typeof all?.toArray === 'function' ? all.toArray() : all);
+        for (const document of iterable) {
+            this.indexDocument(document);
+        }
+    }
+
+    private indexDocument(document: LangiumDocument): void {
+        const modelUri = document.uri.toString();
+        this.unindexModelUri(modelUri);
+        const root = document.parseResult?.value;
+        if (!isOntology(root)) {
+            return;
+        }
+        const namespace = this.normalizeNamespace((root as any).namespace ?? '');
+        if (!namespace) {
+            return;
+        }
+        if (isTransientEditorDocumentUri(modelUri)) {
+            return;
+        }
+        const ontologyIri = this.ontologyIriFromNamespace(namespace);
+        const modelUris = this.workspaceModelUrisByOntologyIri.get(ontologyIri) ?? new Set<string>();
+        modelUris.add(modelUri);
+        this.workspaceModelUrisByOntologyIri.set(ontologyIri, modelUris);
+        this.workspaceOntologyIriByModelUri.set(modelUri, ontologyIri);
+        this.workspaceNamespaceByModelUri.set(modelUri, namespace);
+        this.modelUriToOntologyIri.set(modelUri, ontologyIri);
+        if (modelUris.size === 1) {
+            this.ontologyIdentifierToModelUri.set(namespace, modelUri);
+            this.ontologyIdentifierToModelUri.set(ontologyIri, modelUri);
+            return;
+        }
+        this.ontologyIdentifierToModelUri.delete(namespace);
+        this.ontologyIdentifierToModelUri.delete(ontologyIri);
+    }
+
+    private unindexModelUri(modelUri: string): void {
+        for (const [identifier, uri] of this.ontologyIdentifierToModelUri.entries()) {
+            if (uri === modelUri) {
+                this.ontologyIdentifierToModelUri.delete(identifier);
+            }
+        }
+        const ontologyIri = this.workspaceOntologyIriByModelUri.get(modelUri);
+        if (ontologyIri) {
+            const modelUris = this.workspaceModelUrisByOntologyIri.get(ontologyIri);
+            modelUris?.delete(modelUri);
+            if (!modelUris || modelUris.size === 0) {
+                this.workspaceModelUrisByOntologyIri.delete(ontologyIri);
+            } else if (modelUris.size === 1) {
+                const survivingModelUri = [...modelUris][0];
+                const survivingNamespace = this.workspaceNamespaceByModelUri.get(survivingModelUri);
+                this.ontologyIdentifierToModelUri.set(ontologyIri, survivingModelUri);
+                if (survivingNamespace) {
+                    this.ontologyIdentifierToModelUri.set(survivingNamespace, survivingModelUri);
+                }
+            }
+            this.workspaceOntologyIriByModelUri.delete(modelUri);
+            this.workspaceNamespaceByModelUri.delete(modelUri);
+        }
+        this.modelUriToOntologyIri.delete(modelUri);
+    }
+
+    getDuplicateWorkspaceModelUris(identifier: string): string[] {
+        this.ensureIndexedFromLoadedDocuments();
+        const normalized = this.normalizeNamespace(identifier);
+        if (!normalized) {
+            return [];
+        }
+        const ontologyIri = this.ontologyIriFromNamespace(normalized);
+        const modelUris = this.workspaceModelUrisByOntologyIri.get(ontologyIri);
+        if (!modelUris || modelUris.size <= 1) {
+            return [];
+        }
+        return [...modelUris].sort();
+    }
+
+    private normalizeNamespace(namespace: string): string {
+        return namespace.replace(/^<|>$/g, '');
+    }
+
+    private ontologyIriFromNamespace(namespace: string): string {
+        return namespace.replace(/[\/#]+$/, '');
+    }
+}