@oml/language 0.13.0 → 0.14.1

package/src/oml/{oml-edit.ts → oml-update.ts}

@@ -32,10 +32,11 @@ type ConnectionLike = {
     };
 };
 
-const OmlEditRequestType = new RequestType<OmlEditRequest, OmlEditResponse, void>('oml/edit');
+const OmlEditRequestType = new RequestType<OmlEditRequest, OmlEditResponse, void>('oml/update');
 const RDF_TYPE_IRI = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
 const OML_HAS_SOURCE_IRI = 'http://opencaesar.io/oml#hasSource';
 const OML_HAS_TARGET_IRI = 'http://opencaesar.io/oml#hasTarget';
+const XSD_STRING_IRI = 'http://www.w3.org/2001/XMLSchema#string';
 
 type OmlEditOperation =
     | { kind: 'createInstance'; ontologyIri: string; instanceName: string }
@@ -53,6 +54,7 @@ type OmlEditOperation =
 
 export type OmlEditRequest = {
     operations: OmlEditOperation[];
+    referencingUri?: string;
 };
 
 export type OmlEditError = {
@@ -65,36 +67,47 @@ export type OmlEditResponse = {
     errors?: OmlEditError[];
 };
 
-export function registerOmlEditRequests(connection: ConnectionLike, shared: any): void {
-    connection.onRequest(OmlEditRequestType, async (params: OmlEditRequest): Promise<OmlEditResponse> => {
-        const operations = Array.isArray(params?.operations) ? params.operations : [];
-        const contexts = new Map<string, OntologyContext>();
-        const changedOntologyIris = new Set<string>();
-        for (let i = 0; i < operations.length; i += 1) {
-            const operation = operations[i];
-            try {
-                const context = await resolveOntologyContext(shared, operation.ontologyIri, contexts);
-                const changed = await executeOperation(shared, context, operation, contexts);
-                for (const ontologyIri of changed) {
-                    changedOntologyIris.add(ontologyIri);
-                }
-            } catch (error) {
-                await restoreContextsFromDocuments(shared, contexts);
-                const message = error instanceof Error ? error.message : String(error);
-                const details = error instanceof Error && error.stack
-                    ? `${message}\n${error.stack}`
-                    : message;
-                connection.console?.error(`[oml] OmlEditRequest failed at operation ${i} (${operation.kind}): ${details}`);
-                return {
-                    errors: [{
-                        operationIndex: i,
-                        message
-                    }]
-                };
+export async function applyOmlUpdate(
+    shared: any,
+    params: OmlEditRequest,
+    logError?: (message: string) => void,
+): Promise<OmlEditResponse> {
+    const operations = Array.isArray(params?.operations) ? params.operations : [];
+    const referencingUri = typeof params?.referencingUri === 'string'
+        ? params.referencingUri.trim()
+        : undefined;
+    const contexts = new Map<string, OntologyContext>();
+    const changedOntologyIris = new Set<string>();
+    for (let i = 0; i < operations.length; i += 1) {
+        const operation = operations[i];
+        try {
+            const context = await resolveOntologyContext(shared, operation.ontologyIri, contexts, referencingUri);
+            const changed = await executeOperation(shared, context, operation, contexts);
+            for (const ontologyIri of changed) {
+                changedOntologyIris.add(ontologyIri);
             }
+        } catch (error) {
+            await restoreContextsFromDocuments(shared, contexts);
+            const message = error instanceof Error ? error.message : String(error);
+            const details = error instanceof Error && error.stack
+                ? `${message}\n${error.stack}`
+                : message;
+            logError?.(`[oml] OmlEditRequest failed at operation ${i} (${operation.kind}): ${details}`);
+            return {
+                errors: [{
+                    operationIndex: i,
+                    message
+                }]
+            };
         }
-        const edit = buildWorkspaceEdit(contexts, changedOntologyIris);
-        return edit ? { edit } : {};
+    }
+    const edit = buildWorkspaceEdit(contexts, changedOntologyIris);
+    return edit ? { edit } : {};
+}
+
+export function registerOmlEditRequests(connection: ConnectionLike, shared: any): void {
+    connection.onRequest(OmlEditRequestType, async (params: OmlEditRequest): Promise<OmlEditResponse> => {
+        return await applyOmlUpdate(shared, params, (message) => connection.console?.error(message));
     });
 }
 
@@ -105,14 +118,19 @@ type OntologyContext = {
     document: any;
 };
 
-async function resolveOntologyContext(shared: any, ontologyIri: string, cache: Map<string, OntologyContext>): Promise<OntologyContext> {
+async function resolveOntologyContext(
+    shared: any,
+    ontologyIri: string,
+    cache: Map<string, OntologyContext>,
+    referencingUri?: string
+): Promise<OntologyContext> {
     const normalizedOntologyIri = normalizeIri(ontologyIri);
     const cached = cache.get(normalizedOntologyIri);
     if (cached) {
         return cached;
     }
     const index = getOntologyModelIndex(shared);
-    const modelUri = index.resolveModelUri(normalizedOntologyIri);
+    const modelUri = index.resolveModelUri(normalizedOntologyIri, referencingUri);
     if (!modelUri) {
         throw new Error(`Unable to resolve ontology '${ontologyIri}'.`);
     }
@@ -357,7 +375,9 @@ async function addAssertion(shared: any, ontology: any, subjectIri: string, pred
     }
 
     subject.ownedPropertyValues ??= [];
-    let propertyAssertion = subject.ownedPropertyValues.find((assertion: any) => matchesPredicateRef(ontology, assertion?.property, normalizedPredicate));
+    const matchingAssertions = subject.ownedPropertyValues
+        .filter((assertion: any) => matchesPredicateRef(ontology, assertion?.property, normalizedPredicate));
+    let propertyAssertion = matchingAssertions[0];
     if (!propertyAssertion) {
         await ensureReferenceImport(shared, ontology, normalizedPredicate);
         propertyAssertion = {
@@ -368,6 +388,8 @@ async function addAssertion(shared: any, ontology: any, subjectIri: string, pred
             containedValues: []
         };
         pushAstArrayChild(subject, 'ownedPropertyValues', propertyAssertion);
+    } else if (matchingAssertions.length > 1) {
+        normalizePropertyAssertionGroup(subject, propertyAssertion, matchingAssertions.slice(1));
     }
     if (isIriLike(objectValue)) {
         await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'assertion object')));
@@ -375,6 +397,7 @@ async function addAssertion(shared: any, ontology: any, subjectIri: string, pred
         await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
     }
     appendAssertionValue(ontology, propertyAssertion, objectValue);
+    normalizeAllPropertyAssertions(subject, ontology);
     return true;
 }
 
@@ -507,19 +530,27 @@ async function addAnnotation(shared: any, ontology: any, subjectIri: string, pre
     const normalizedPredicate = normalizeIri(predicateIri);
     await ensureReferenceImport(shared, ontology, normalizedPredicate);
     subject.ownedAnnotations ??= [];
-    const annotation: any = {
-        $type: 'Annotation',
-        property: asRef(ontology, normalizedPredicate),
-        literalValues: [],
-        referencedValues: []
-    };
+    const matchingAnnotations = subject.ownedAnnotations
+        .filter((entry: any) => matchesPredicateRef(ontology, entry?.property, normalizedPredicate));
+    let annotation = matchingAnnotations[0];
+    if (!annotation) {
+        annotation = {
+            $type: 'Annotation',
+            property: asRef(ontology, normalizedPredicate),
+            literalValues: [],
+            referencedValues: []
+        };
+        pushAstArrayChild(subject, 'ownedAnnotations', annotation);
+    } else if (matchingAnnotations.length > 1) {
+        normalizeAnnotationGroup(subject, annotation, matchingAnnotations.slice(1));
+    }
     if (isIriLike(objectValue)) {
         await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'annotation object')));
     } else {
         await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
     }
     appendAnnotationValue(ontology, annotation, objectValue);
-    pushAstArrayChild(subject, 'ownedAnnotations', annotation);
+    normalizeAllAnnotations(subject, ontology);
     return true;
 }
 
@@ -928,7 +959,7 @@ function removeAssertionValue(ontology: any, assertion: any, objectValue: unknow
         assertion.referencedValues = (assertion.referencedValues ?? []).filter((ref: any) => !matchesPredicateRef(ontology, ref, normalizedIri));
         return;
     }
-    const expectedLiteral = asLiteral(ontology, objectValue);
+    const expectedLiteral = toLiteralRemovalMatchSpec(ontology, objectValue);
     assertion.literalValues = (assertion.literalValues ?? []).filter((literal: any) => !matchesLiteralForRemoval(ontology, literal, expectedLiteral));
 }
 
@@ -949,7 +980,7 @@ function removeAnnotationValue(ontology: any, annotation: any, objectValue: unkn
         annotation.referencedValues = (annotation.referencedValues ?? []).filter((ref: any) => !matchesPredicateRef(ontology, ref, normalizedIri));
         return;
     }
-    const expectedLiteral = asLiteral(ontology, objectValue);
+    const expectedLiteral = toLiteralRemovalMatchSpec(ontology, objectValue);
     annotation.literalValues = (annotation.literalValues ?? []).filter((literal: any) => !matchesLiteralForRemoval(ontology, literal, expectedLiteral));
 }
 
@@ -968,15 +999,44 @@ function literalTypeIri(ontology: any, literal: any): string {
     return normalizeIri(expandRefTextToIri(ontology, refText) ?? refText);
 }
 
-function matchesLiteralForRemoval(ontology: any, existingLiteral: any, expectedLiteral: any): boolean {
-    if (lexicalLiteralValue(existingLiteral) !== lexicalLiteralValue(expectedLiteral)) {
+type LiteralRemovalMatchSpec = {
+    lexical: string;
+    languageTag?: string;
+    typeIri?: string;
+};
+
+function toLiteralRemovalMatchSpec(ontology: any, objectValue: unknown): LiteralRemovalMatchSpec {
+    if (isTypedQuotedLiteralTransport(objectValue)) {
+        return {
+            lexical: String(objectValue.value ?? ''),
+            languageTag: literalLanguageTagFromTransport(objectValue),
+            typeIri: literalDatatypeIriFromTransport(ontology, objectValue),
+        };
+    }
+    const expectedLiteral = asLiteral(ontology, objectValue);
+    return {
+        lexical: lexicalLiteralValue(expectedLiteral),
+        languageTag: literalLanguageTag(expectedLiteral),
+        typeIri: literalTypeIri(ontology, expectedLiteral),
+    };
+}
+
+function matchesLiteralForRemoval(ontology: any, existingLiteral: any, expected: LiteralRemovalMatchSpec): boolean {
+    if (lexicalLiteralValue(existingLiteral) !== expected.lexical) {
+        return false;
+    }
+    const existingLanguage = literalLanguageTag(existingLiteral);
+    if (existingLanguage && expected.languageTag && normalizeLanguageTag(existingLanguage) !== normalizeLanguageTag(expected.languageTag)) {
         return false;
     }
-    const expectedType = literalTypeIri(ontology, expectedLiteral);
+    const expectedType = expected.typeIri ?? '';
     if (!expectedType) {
         return true;
     }
     const existingType = literalTypeIri(ontology, existingLiteral);
+    if (!existingType) {
+        return true;
+    }
     return isSameIriTarget(existingType, expectedType);
 }
 
@@ -1324,13 +1384,19 @@ function pickImportPrefix(namespace: string, usedPrefixes: ReadonlySet<string>):
 function asLiteral(ontology: any, value: unknown): any {
     if (isTypedQuotedLiteralTransport(value)) {
         const literalValue = String(value.value ?? '');
-        const datatypeIri = typeof value.datatypeIri === 'string' ? value.datatypeIri.trim() : '';
-        const datatypeRefText = typeof value.datatypeRefText === 'string' ? value.datatypeRefText.trim() : '';
-        return datatypeIri
-            ? { $type: 'QuotedLiteral', value: literalValue, type: { $refText: toRefText(ontology, normalizeIri(datatypeIri)) } }
-            : datatypeRefText
-                ? { $type: 'QuotedLiteral', value: literalValue, type: { $refText: datatypeRefText } }
-            : { $type: 'QuotedLiteral', value: literalValue };
+        const langTag = literalLanguageTagFromTransport(value);
+        const datatypeIri = literalDatatypeIriFromTransport(ontology, value);
+        const literal: Record<string, unknown> = {
+            $type: 'QuotedLiteral',
+            value: literalValue,
+        };
+        if (langTag) {
+            literal.langTag = langTag;
+        }
+        if (datatypeIri && !isXsdStringDatatypeIri(ontology, datatypeIri)) {
+            literal.type = { $refText: toRefText(ontology, datatypeIri) };
+        }
+        return literal;
     }
     if (typeof value === 'boolean') {
         return { $type: 'BooleanLiteral', value };
@@ -1348,14 +1414,24 @@ async function ensureTypedLiteralDatatypeImport(shared: any, ontology: any, valu
     if (!isTypedQuotedLiteralTransport(value)) {
         return;
     }
-    const datatypeIri = typeof value.datatypeIri === 'string' ? normalizeIri(value.datatypeIri) : '';
-    if (!datatypeIri) {
+    const datatypeIri = literalDatatypeIriFromTransport(ontology, value);
+    if (!datatypeIri || isXsdStringDatatypeIri(ontology, datatypeIri)) {
         return;
     }
     await ensureReferenceImport(shared, ontology, datatypeIri);
 }
 
-function isTypedQuotedLiteralTransport(value: unknown): value is { $type?: unknown; value?: unknown; datatypeIri?: unknown; datatypeRefText?: unknown } {
+function isTypedQuotedLiteralTransport(value: unknown): value is {
+    $type?: unknown;
+    value?: unknown;
+    langTag?: unknown;
+    language?: unknown;
+    datatypeIri?: unknown;
+    datatypeRefText?: unknown;
+    typeIri?: unknown;
+    typeRefText?: unknown;
+    type?: unknown;
+} {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return false;
     }
@@ -1363,7 +1439,71 @@ function isTypedQuotedLiteralTransport(value: unknown): value is { $type?: unkno
     if (record.$type === 'QuotedLiteral') {
         return true;
     }
-    return (typeof record.datatypeIri === 'string' || typeof record.datatypeRefText === 'string') && 'value' in record;
+    return (
+        typeof record.datatypeIri === 'string'
+        || typeof record.datatypeRefText === 'string'
+        || typeof record.typeIri === 'string'
+        || typeof record.typeRefText === 'string'
+        || typeof record.type === 'string'
+    ) && 'value' in record;
+}
+
+function literalLanguageTag(literal: any): string {
+    if (!literal || typeof literal !== 'object') {
+        return '';
+    }
+    return typeof literal.langTag === 'string' ? literal.langTag.trim() : '';
+}
+
+function literalLanguageTagFromTransport(value: {
+    langTag?: unknown;
+    language?: unknown;
+}): string {
+    if (typeof value.langTag === 'string') {
+        return value.langTag.trim();
+    }
+    if (typeof value.language === 'string') {
+        return value.language.trim();
+    }
+    return '';
+}
+
+function normalizeLanguageTag(value: string): string {
+    return value.trim().toLowerCase();
+}
+
+function literalDatatypeIriFromTransport(ontology: any, value: {
+    datatypeIri?: unknown;
+    datatypeRefText?: unknown;
+    typeIri?: unknown;
+    typeRefText?: unknown;
+    type?: unknown;
+}): string {
+    const directIri = typeof value.datatypeIri === 'string'
+        ? value.datatypeIri.trim()
+        : typeof value.typeIri === 'string'
+            ? value.typeIri.trim()
+            : '';
+    if (directIri) {
+        const expanded = expandRefTextToIri(ontology, directIri);
+        return normalizeIri(expanded ?? directIri);
+    }
+    const refText = typeof value.datatypeRefText === 'string'
+        ? value.datatypeRefText.trim()
+        : typeof value.typeRefText === 'string'
+            ? value.typeRefText.trim()
+            : typeof value.type === 'string'
+                ? value.type.trim()
+                : '';
+    if (!refText) {
+        return '';
+    }
+    return normalizeIri(expandRefTextToIri(ontology, refText) ?? refText);
+}
+
+function isXsdStringDatatypeIri(ontology: any, value: string): boolean {
+    const normalized = normalizeIri(expandRefTextToIri(ontology, value) ?? value);
+    return normalized === XSD_STRING_IRI;
 }
 
 function attachAstNode<T extends Record<string, any>>(node: T, parent: any, containerProperty: string): T {
@@ -1405,6 +1545,113 @@ function normalizeIri(value: string): string {
     return String(value ?? '').trim().replace(/^<|>$/g, '');
 }
 
+function normalizePropertyAssertionGroup(subject: any, target: any, duplicates: any[]): void {
+    if (!Array.isArray(subject?.ownedPropertyValues) || !target || duplicates.length === 0) {
+        return;
+    }
+    target.literalValues ??= [];
+    target.referencedValues ??= [];
+    target.containedValues ??= [];
+    for (const duplicate of duplicates) {
+        for (const literal of duplicate?.literalValues ?? []) {
+            attachAstNode(literal, target, 'literalValues');
+            target.literalValues.push(literal);
+        }
+        for (const ref of duplicate?.referencedValues ?? []) {
+            target.referencedValues.push(ref);
+        }
+        for (const contained of duplicate?.containedValues ?? []) {
+            attachAstNode(contained, target, 'containedValues');
+            target.containedValues.push(contained);
+        }
+    }
+    const duplicateSet = new Set(duplicates);
+    subject.ownedPropertyValues = subject.ownedPropertyValues.filter((entry: any) => !duplicateSet.has(entry));
+}
+
+function normalizeAnnotationGroup(subject: any, target: any, duplicates: any[]): void {
+    if (!Array.isArray(subject?.ownedAnnotations) || !target || duplicates.length === 0) {
+        return;
+    }
+    target.literalValues ??= [];
+    target.referencedValues ??= [];
+    for (const duplicate of duplicates) {
+        for (const literal of duplicate?.literalValues ?? []) {
+            attachAstNode(literal, target, 'literalValues');
+            target.literalValues.push(literal);
+        }
+        for (const ref of duplicate?.referencedValues ?? []) {
+            target.referencedValues.push(ref);
+        }
+    }
+    const duplicateSet = new Set(duplicates);
+    subject.ownedAnnotations = subject.ownedAnnotations.filter((entry: any) => !duplicateSet.has(entry));
+}
+
+function normalizeAllPropertyAssertions(subject: any, ontology: any): void {
+    if (!Array.isArray(subject?.ownedPropertyValues) || subject.ownedPropertyValues.length < 2) {
+        return;
+    }
+    const groups = new Map<string, { target: any; duplicates: any[] }>();
+    for (const assertion of subject.ownedPropertyValues) {
+        const key = propertyRefMergeKey(ontology, assertion?.property);
+        if (!key) {
+            continue;
+        }
+        const group = groups.get(key);
+        if (!group) {
+            groups.set(key, { target: assertion, duplicates: [] });
+            continue;
+        }
+        group.duplicates.push(assertion);
+    }
+    for (const { target, duplicates } of groups.values()) {
+        if (duplicates.length > 0) {
+            normalizePropertyAssertionGroup(subject, target, duplicates);
+        }
+    }
+}
+
+function normalizeAllAnnotations(subject: any, ontology: any): void {
+    if (!Array.isArray(subject?.ownedAnnotations) || subject.ownedAnnotations.length < 2) {
+        return;
+    }
+    const groups = new Map<string, { target: any; duplicates: any[] }>();
+    for (const annotation of subject.ownedAnnotations) {
+        const key = propertyRefMergeKey(ontology, annotation?.property);
+        if (!key) {
+            continue;
+        }
+        const group = groups.get(key);
+        if (!group) {
+            groups.set(key, { target: annotation, duplicates: [] });
+            continue;
+        }
+        group.duplicates.push(annotation);
+    }
+    for (const { target, duplicates } of groups.values()) {
+        if (duplicates.length > 0) {
+            normalizeAnnotationGroup(subject, target, duplicates);
+        }
+    }
+}
+
+function propertyRefMergeKey(ontology: any, ref: any): string | undefined {
+    const refText = getRefText(ref);
+    if (refText) {
+        const expanded = expandRefTextToIri(ontology, refText);
+        return expanded
+            ? `iri:${normalizeIri(expanded)}`
+            : `ref:${normalizeIri(refText)}`;
+    }
+    const resolved = ref?.ref ?? ref?._ref;
+    const resolvedIri = resolved ? getIriForNode(resolved) : undefined;
+    if (resolvedIri) {
+        return `iri:${normalizeIri(resolvedIri)}`;
+    }
+    return undefined;
+}
+
 function isSourcePredicate(predicateIri: string): boolean {
     return normalizeIri(predicateIri) === OML_HAS_SOURCE_IRI;
 }

package/src/oml/oml-utils.ts

@@ -160,16 +160,15 @@ export const getWorkspaceSnapshot = (documents: LangiumDocuments): string =>
         .sort()
         .join('|');
 
-const GITHUB_COPILOT_TRANSIENT_DOCUMENT_SCHEMES = new Set([
+const OML_LS_IGNORED_DOCUMENT_SCHEMES = new Set([
     'chat-editing-text-model',
     'chat-editing-snapshot-text-model',
     'vscode-chat-code-block',
-    'git',
 ]);
 
-export function isTransientEditorDocumentUri(uri: string): boolean {
+export function isIgnoredByOmlLsDocumentUri(uri: string): boolean {
     try {
-        return GITHUB_COPILOT_TRANSIENT_DOCUMENT_SCHEMES.has(URI.parse(uri).scheme);
+        return OML_LS_IGNORED_DOCUMENT_SCHEMES.has(URI.parse(uri).scheme);
     } catch {
         return false;
     }

package/src/oml/oml-validator.ts

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
-import { AstUtils } from 'langium';
+import { AstUtils, URI } from 'langium';
 import type { ValidationAcceptor, ValidationChecks } from 'langium';
 import type { OmlServices } from './oml-module.js';
 import { getOntologyModelIndex } from './oml-index.js';
@@ -270,8 +270,15 @@ export class OmlValidator {
         const namespace = rawNamespace.replace(/^<|>$/g, '');
         const iri = namespace.replace(/[#/]?$/, '');
         const docUri = ontology?.$document?.uri?.toString?.() ?? '';
+        const currentScheme = this.getUriScheme(docUri);
         const duplicateModelUris = getOntologyModelIndex(this.services.shared).getDuplicateWorkspaceModelUris(iri);
-        const conflictingModelUris = duplicateModelUris.filter((modelUri) => modelUri !== docUri);
+        const conflictingModelUris = duplicateModelUris.filter((modelUri) => {
+            if (modelUri === docUri) {
+                return false;
+            }
+            const otherScheme = this.getUriScheme(modelUri);
+            return !currentScheme || !otherScheme || currentScheme === otherScheme;
+        });
         if (conflictingModelUris.length > 0) {
             accept('error', `Ontology IRI '${iri}' is also declared by '${conflictingModelUris[0]}'`, {
                 node: ontology,
@@ -309,6 +316,14 @@ export class OmlValidator {
         }
     }
 
+    private getUriScheme(value: string): string | undefined {
+        try {
+            return URI.parse(value).scheme;
+        } catch {
+            return undefined;
+        }
+    }
+
     checkQuotedLiteralNonStandardType(literal: QuotedLiteral, accept: ValidationAcceptor): void {
         const scalar = literal.type?.ref as any;
         if (!scalar) {