@oml/language 0.7.0

package/src/oml/oml-edit.ts

@@ -0,0 +1,1292 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { URI } from 'langium';
+import { RequestType, type WorkspaceEdit } from 'vscode-languageserver-protocol';
+import {
+    isAnnotation,
+    isConceptInstance,
+    isDescription,
+    isImport,
+    isOntology,
+    isPropertyValueAssertion,
+    isRelationInstance,
+    isRule,
+    isTypeAssertion,
+} from './generated/ast.js';
+import { getOntologyModelIndex } from './oml-index.js';
+import { serializeOntology } from './oml-serializer.js';
+import {
+    collectOntologyMembers,
+    findOntologyMemberByName,
+    getIriForNode,
+    normalizeNamespace,
+} from './oml-utils.js';
+
+type ConnectionLike = {
+    onRequest: (type: RequestType<any, any, any>, handler: (params: any) => any | Promise<any>) => void;
+    console?: {
+        error: (message: string) => void;
+    };
+};
+
+const OmlEditRequestType = new RequestType<OmlEditRequest, OmlEditResponse, void>('oml/edit');
+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';
+
+type OmlEditOperation =
+    | { kind: 'createInstance'; ontologyIri: string; instanceName: string }
+    | { kind: 'createRelationInstance'; ontologyIri: string; instanceName: string }
+    | { kind: 'createInstanceRef'; ontologyIri: string; instanceIri: string; typeIri?: string }
+    | { kind: 'createRelationInstanceRef'; ontologyIri: string; instanceIri: string; typeIri?: string }
+    | { kind: 'addAssertion'; ontologyIri: string; subjectIri: string; predicateIri: string; object: unknown }
+    | { kind: 'removeAssertion'; ontologyIri: string; subjectIri: string; predicateIri: string; object?: unknown }
+    | { kind: 'addAnnotation'; ontologyIri: string; subjectIri: string; predicateIri: string; object: unknown }
+    | { kind: 'removeAnnotation'; ontologyIri: string; subjectIri: string; predicateIri: string; object?: unknown }
+    | { kind: 'deleteMemberCascade'; ontologyIri: string; memberIri: string }
+    | { kind: 'deleteMemberRef'; ontologyIri: string; memberIri: string; typeIri?: string };
+
+export type OmlEditRequest = {
+    operations: OmlEditOperation[];
+};
+
+export type OmlEditError = {
+    operationIndex: number;
+    message: string;
+};
+
+export type OmlEditResponse = {
+    edit?: WorkspaceEdit;
+    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
+                    }]
+                };
+            }
+        }
+        const edit = buildWorkspaceEdit(contexts, changedOntologyIris);
+        return edit ? { edit } : {};
+    });
+}
+
+type OntologyContext = {
+    ontologyIri: string;
+    modelUri: string;
+    ontology: any;
+    document: any;
+};
+
+async function resolveOntologyContext(shared: any, ontologyIri: string, cache: Map<string, OntologyContext>): Promise<OntologyContext> {
+    const normalizedOntologyIri = normalizeIri(ontologyIri);
+    const cached = cache.get(normalizedOntologyIri);
+    if (cached) {
+        return cached;
+    }
+    const index = getOntologyModelIndex(shared);
+    const modelUri = index.resolveModelUri(normalizedOntologyIri);
+    if (!modelUri) {
+        throw new Error(`Unable to resolve ontology '${ontologyIri}'.`);
+    }
+    const uri = URI.parse(modelUri);
+    const langiumDocuments: any = shared.workspace.LangiumDocuments;
+    const builder: any = shared.workspace.DocumentBuilder;
+    const document = langiumDocuments.getDocument(uri)
+        ?? await langiumDocuments.getOrCreateDocument(uri);
+    await builder.build([document], { validation: true });
+    const ontology = document?.parseResult?.value;
+    if (!ontology || !isOntology(ontology)) {
+        throw new Error(`Resolved document '${modelUri}' is not an ontology.`);
+    }
+    const context: OntologyContext = {
+        ontologyIri: normalizedOntologyIri,
+        modelUri,
+        ontology,
+        document
+    };
+    cache.set(normalizedOntologyIri, context);
+    return context;
+}
+
+async function executeOperation(
+    shared: any,
+    context: OntologyContext,
+    operation: OmlEditOperation,
+    contexts: Map<string, OntologyContext>
+): Promise<ReadonlySet<string>> {
+    switch (operation.kind) {
+        case 'createInstance':
+            ensureDescriptionOntology(context.ontology, operation.kind);
+            ensureUniqueLocalName(context.ontology, operation.instanceName);
+            {
+                const statement: any = {
+                $type: 'ConceptInstance',
+                name: operation.instanceName,
+                ownedAnnotations: [],
+                ownedPropertyValues: [],
+                ownedTypes: []
+                };
+                statement.$container = context.ontology;
+                context.ontology.ownedStatements.push(statement);
+            }
+            return new Set([context.ontologyIri]);
+        case 'createRelationInstance':
+            ensureDescriptionOntology(context.ontology, operation.kind);
+            ensureUniqueLocalName(context.ontology, operation.instanceName);
+            {
+                const statement: any = {
+                $type: 'RelationInstance',
+                name: operation.instanceName,
+                ownedAnnotations: [],
+                ownedPropertyValues: [],
+                ownedTypes: [],
+                sources: [],
+                targets: []
+                };
+                statement.$container = context.ontology;
+                context.ontology.ownedStatements.push(statement);
+            }
+            return new Set([context.ontologyIri]);
+        case 'createInstanceRef':
+            ensureDescriptionOntology(context.ontology, operation.kind);
+            ensureReferenceImport(context.ontology, operation.instanceIri);
+            if (operation.typeIri) {
+                ensureReferenceImport(context.ontology, operation.typeIri);
+            }
+            {
+                const ownedTypes: any[] = [];
+                if (operation.typeIri) {
+                    ownedTypes.push({
+                        $type: 'TypeAssertion',
+                        type: asRef(context.ontology, operation.typeIri)
+                    });
+                }
+                const statement: any = {
+                $type: 'ConceptInstance',
+                ref: asRef(context.ontology, operation.instanceIri),
+                ownedAnnotations: [],
+                ownedPropertyValues: [],
+                ownedTypes
+                };
+                statement.__targetIri = normalizeIri(operation.instanceIri);
+                statement.$container = context.ontology;
+                context.ontology.ownedStatements.push(statement);
+            }
+            return new Set([context.ontologyIri]);
+        case 'createRelationInstanceRef':
+            ensureDescriptionOntology(context.ontology, operation.kind);
+            ensureReferenceImport(context.ontology, operation.instanceIri);
+            if (operation.typeIri) {
+                ensureReferenceImport(context.ontology, operation.typeIri);
+            }
+            {
+                const ownedTypes: any[] = [];
+                if (operation.typeIri) {
+                    ownedTypes.push({
+                        $type: 'TypeAssertion',
+                        type: asRef(context.ontology, operation.typeIri)
+                    });
+                }
+                const statement: any = {
+                $type: 'RelationInstance',
+                ref: asRef(context.ontology, operation.instanceIri),
+                ownedAnnotations: [],
+                ownedPropertyValues: [],
+                ownedTypes,
+                sources: [],
+                targets: []
+                };
+                statement.__targetIri = normalizeIri(operation.instanceIri);
+                statement.$container = context.ontology;
+                context.ontology.ownedStatements.push(statement);
+            }
+            return new Set([context.ontologyIri]);
+        case 'addAssertion':
+            ensureDescriptionOntology(context.ontology, operation.kind);
+            return addAssertion(context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+                ? new Set([context.ontologyIri])
+                : new Set();
+        case 'removeAssertion':
+            ensureDescriptionOntology(context.ontology, operation.kind);
+            return removeAssertion(context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+                ? new Set([context.ontologyIri])
+                : new Set();
+        case 'addAnnotation':
+            return addAnnotation(context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+                ? new Set([context.ontologyIri])
+                : new Set();
+        case 'removeAnnotation':
+            return removeAnnotation(context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+                ? new Set([context.ontologyIri])
+                : new Set();
+        case 'deleteMemberCascade':
+            return deleteMemberCascade(shared, context, operation.memberIri, contexts);
+        case 'deleteMemberRef':
+            ensureDescriptionOntology(context.ontology, operation.kind);
+            return deleteMemberRef(context.ontology, operation.memberIri, operation.typeIri)
+                ? new Set([context.ontologyIri])
+                : new Set();
+        default:
+            throw new Error(`Unsupported operation '${(operation as { kind?: string })?.kind ?? 'unknown'}'.`);
+    }
+}
+
+async function resolveOntologyContextByModelUri(
+    shared: any,
+    modelUri: string,
+    cache: Map<string, OntologyContext>
+): Promise<OntologyContext> {
+    for (const context of cache.values()) {
+        if (context.modelUri === modelUri) {
+            return context;
+        }
+    }
+    const uri = URI.parse(modelUri);
+    const langiumDocuments: any = shared.workspace.LangiumDocuments;
+    const builder: any = shared.workspace.DocumentBuilder;
+    const document = langiumDocuments.getDocument(uri)
+        ?? await langiumDocuments.getOrCreateDocument(uri);
+    await builder.build([document], { validation: true });
+    const ontology = document?.parseResult?.value;
+    if (!ontology || !isOntology(ontology)) {
+        throw new Error(`Resolved document '${modelUri}' is not an ontology.`);
+    }
+    const ontologyIri = normalizeNamespace(String(ontology.namespace ?? ''));
+    const context: OntologyContext = {
+        ontologyIri,
+        modelUri,
+        ontology,
+        document
+    };
+    cache.set(ontologyIri, context);
+    return context;
+}
+
+function ensureDescriptionOntology(ontology: any, operationKind: string): void {
+    if (!isDescription(ontology)) {
+        throw new Error(`${operationKind} requires a description ontology.`);
+    }
+}
+
+function ensureUniqueLocalName(ontology: any, memberName: string): void {
+    if (findOntologyMemberByName(ontology, memberName)) {
+        throw new Error(`A member named '${memberName}' already exists in the ontology.`);
+    }
+}
+
+function addAssertion(ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): boolean {
+    const normalizedPredicate = normalizeIri(predicateIri);
+    const subject = findNamedInstanceByIri(ontology, subjectIri);
+    if (!subject) {
+        throw new Error(`Subject '${subjectIri}' was not found in the ontology.`);
+    }
+
+    if (normalizedPredicate === RDF_TYPE_IRI) {
+        const normalizedTypeIri = normalizeIri(asRequiredIri(objectValue, 'type assertion object'));
+        if ((subject.ownedTypes ?? []).some((entry: any) => matchesPredicateRef(ontology, entry?.type, normalizedTypeIri))) {
+            return false;
+        }
+        ensureReferenceImport(ontology, normalizedTypeIri);
+        subject.ownedTypes ??= [];
+        subject.ownedTypes.push({
+            $type: 'TypeAssertion',
+            type: asRef(ontology, normalizedTypeIri)
+        });
+        return true;
+    }
+
+    if (isSourcePredicate(normalizedPredicate)) {
+        if (!isRelationInstance(subject)) {
+            throw new Error(`Predicate '${predicateIri}' applies only to relation instances.`);
+        }
+        const sourceIri = normalizeIri(asRequiredIri(objectValue, 'source assertion object'));
+        ensureReferenceImport(ontology, sourceIri);
+        subject.sources ??= [];
+        subject.sources.push(asRef(ontology, sourceIri));
+        return true;
+    }
+
+    if (isTargetPredicate(normalizedPredicate)) {
+        if (!isRelationInstance(subject)) {
+            throw new Error(`Predicate '${predicateIri}' applies only to relation instances.`);
+        }
+        const targetIri = normalizeIri(asRequiredIri(objectValue, 'target assertion object'));
+        ensureReferenceImport(ontology, targetIri);
+        subject.targets ??= [];
+        subject.targets.push(asRef(ontology, targetIri));
+        return true;
+    }
+
+    subject.ownedPropertyValues ??= [];
+    let propertyAssertion = subject.ownedPropertyValues.find((assertion: any) => matchesPredicateRef(ontology, assertion?.property, normalizedPredicate));
+    if (!propertyAssertion) {
+        propertyAssertion = {
+            $type: 'PropertyValueAssertion',
+            property: asRef(ontology, normalizedPredicate),
+            literalValues: [],
+            referencedValues: [],
+            containedValues: []
+        };
+        subject.ownedPropertyValues.push(propertyAssertion);
+    }
+    appendAssertionValue(ontology, propertyAssertion, objectValue);
+    return true;
+}
+
+function removeAssertion(ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): boolean {
+    const subject = findNamedInstanceByIri(ontology, subjectIri);
+    if (!subject) {
+        throw new Error(`Subject '${subjectIri}' was not found in the ontology.`);
+    }
+    const normalizedPredicate = normalizeIri(predicateIri);
+    let changed = false;
+
+    if (normalizedPredicate === RDF_TYPE_IRI) {
+        if (!Array.isArray(subject.ownedTypes) || subject.ownedTypes.length === 0) {
+            return false;
+        }
+        const before = subject.ownedTypes.length;
+        if (objectValue === undefined) {
+            subject.ownedTypes = [];
+        } else {
+            const iri = normalizeIri(asRequiredIri(objectValue, 'type assertion object'));
+            subject.ownedTypes = subject.ownedTypes.filter((entry: any) => !matchesPredicateRef(ontology, entry?.type, iri));
+        }
+        changed = before !== subject.ownedTypes.length;
+        return changed;
+    }
+
+    if (isSourcePredicate(normalizedPredicate)) {
+        if (!isRelationInstance(subject) || !Array.isArray(subject.sources)) {
+            return false;
+        }
+        const before = subject.sources.length;
+        if (objectValue === undefined) {
+            subject.sources = [];
+        } else {
+            const iri = normalizeIri(asRequiredIri(objectValue, 'source assertion object'));
+            subject.sources = subject.sources.filter((ref: any) => !matchesPredicateRef(ontology, ref, iri));
+        }
+        return before !== subject.sources.length;
+    }
+
+    if (isTargetPredicate(normalizedPredicate)) {
+        if (!isRelationInstance(subject) || !Array.isArray(subject.targets)) {
+            return false;
+        }
+        const before = subject.targets.length;
+        if (objectValue === undefined) {
+            subject.targets = [];
+        } else {
+            const iri = normalizeIri(asRequiredIri(objectValue, 'target assertion object'));
+            subject.targets = subject.targets.filter((ref: any) => !matchesPredicateRef(ontology, ref, iri));
+        }
+        return before !== subject.targets.length;
+    }
+
+    if (!Array.isArray(subject.ownedPropertyValues) || subject.ownedPropertyValues.length === 0) {
+        return false;
+    }
+
+    const remaining: any[] = [];
+    for (const assertion of subject.ownedPropertyValues) {
+        if (!matchesPredicateRef(ontology, assertion?.property, normalizedPredicate)) {
+            remaining.push(assertion);
+            continue;
+        }
+        if (objectValue === undefined) {
+            changed = true;
+            continue;
+        }
+        const beforeCounts = {
+            literal: assertion.literalValues?.length ?? 0,
+            referenced: assertion.referencedValues?.length ?? 0,
+            contained: assertion.containedValues?.length ?? 0
+        };
+        removeAssertionValue(ontology, assertion, objectValue);
+        const afterCounts = {
+            literal: assertion.literalValues?.length ?? 0,
+            referenced: assertion.referencedValues?.length ?? 0,
+            contained: assertion.containedValues?.length ?? 0
+        };
+        const hasValues = afterCounts.literal > 0
+            || afterCounts.referenced > 0
+            || afterCounts.contained > 0;
+        if (hasValues) {
+            remaining.push(assertion);
+        }
+        changed ||= beforeCounts.literal !== afterCounts.literal
+            || beforeCounts.referenced !== afterCounts.referenced
+            || beforeCounts.contained !== afterCounts.contained
+            || !hasValues;
+    }
+    subject.ownedPropertyValues = remaining;
+    return changed;
+}
+
+function addAnnotation(ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): boolean {
+    const subject = findAnnotationSubjectByIri(ontology, subjectIri);
+    if (!subject) {
+        throw new Error(`Annotation subject '${subjectIri}' was not found in the ontology.`);
+    }
+    subject.ownedAnnotations ??= [];
+    const annotation: any = {
+        $type: 'Annotation',
+        property: asRef(ontology, predicateIri),
+        literalValues: [],
+        referencedValues: []
+    };
+    appendAnnotationValue(ontology, annotation, objectValue);
+    subject.ownedAnnotations.push(annotation);
+    return true;
+}
+
+function removeAnnotation(ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): boolean {
+    const subject = findAnnotationSubjectByIri(ontology, subjectIri);
+    if (!subject || !Array.isArray(subject.ownedAnnotations) || subject.ownedAnnotations.length === 0) {
+        return false;
+    }
+    const normalizedPredicate = normalizeIri(predicateIri);
+    let changed = false;
+    const kept: any[] = [];
+    for (const annotation of subject.ownedAnnotations) {
+        if (!matchesPredicateRef(ontology, annotation?.property, normalizedPredicate)) {
+            kept.push(annotation);
+            continue;
+        }
+        if (objectValue === undefined) {
+            changed = true;
+            continue;
+        }
+        const beforeCounts = {
+            literal: annotation.literalValues?.length ?? 0,
+            referenced: annotation.referencedValues?.length ?? 0
+        };
+        removeAnnotationValue(ontology, annotation, objectValue);
+        const afterCounts = {
+            literal: annotation.literalValues?.length ?? 0,
+            referenced: annotation.referencedValues?.length ?? 0
+        };
+        const hasValues = afterCounts.literal > 0 || afterCounts.referenced > 0;
+        if (hasValues) {
+            kept.push(annotation);
+        }
+        changed ||= beforeCounts.literal !== afterCounts.literal
+            || beforeCounts.referenced !== afterCounts.referenced
+            || !hasValues;
+    }
+    subject.ownedAnnotations = kept;
+    return changed;
+}
+
+function deleteMemberRef(ontology: any, memberIri: string, typeIri: string | undefined): boolean {
+    if (!Array.isArray(ontology.ownedStatements)) {
+        return false;
+    }
+    const normalizedMemberIri = normalizeIri(memberIri);
+    const normalizedTypeIri = typeIri ? normalizeIri(typeIri) : undefined;
+    const before = ontology.ownedStatements.length;
+    ontology.ownedStatements = ontology.ownedStatements.filter((statement: any) => {
+        const ref = statement?.ref;
+        if (!ref) {
+            return true;
+        }
+        if (!matchesPredicateRef(ontology, ref, normalizedMemberIri)) {
+            return true;
+        }
+        if (!normalizedTypeIri) {
+            return false;
+        }
+        const typeMatches = (statement?.ownedTypes ?? []).some((typeAssertion: any) => matchesPredicateRef(ontology, typeAssertion?.type, normalizedTypeIri));
+        return !typeMatches;
+    });
+    return before !== ontology.ownedStatements.length;
+}
+
+async function deleteMemberCascade(
+    shared: any,
+    context: OntologyContext,
+    memberIri: string,
+    contexts: Map<string, OntologyContext>
+): Promise<ReadonlySet<string>> {
+    const targetMember = findOntologyMemberByIri(context.ontology, memberIri);
+    if (!targetMember) {
+        throw new Error(`Member '${memberIri}' was not found in the ontology.`);
+    }
+    const languageServices = getLanguageServicesForModelUri(shared, context.modelUri);
+    const rawReferences = languageServices.references.References
+        .findReferences(targetMember, { includeDeclaration: false })
+        .toArray();
+    const references = rawReferences;
+    const astNodeLocator = languageServices.workspace.AstNodeLocator;
+    const resolvedReferences: Array<{ context: OntologyContext; sourceNode: any }> = [];
+    for (const reference of references) {
+        const sourceContext = await resolveOntologyContextByModelUri(shared, reference.sourceUri.toString(), contexts);
+        const sourceNode = astNodeLocator.getAstNode(sourceContext.ontology, reference.sourcePath);
+        if (sourceNode) {
+            resolvedReferences.push({ context: sourceContext, sourceNode });
+        }
+    }
+
+    const changedOntologyIris = new Set<string>();
+    if (deleteOwningStatement(context.ontology, targetMember)) {
+        changedOntologyIris.add(context.ontologyIri);
+    }
+    for (const reference of resolvedReferences) {
+        const changed = deleteCascadeReference(reference.context.ontology, reference.sourceNode, memberIri);
+        if (changed) {
+            changedOntologyIris.add(reference.context.ontologyIri);
+        }
+    }
+    return changedOntologyIris;
+}
+
+function getLanguageServicesForModelUri(shared: any, modelUri: string): any {
+    const registry = shared?.ServiceRegistry;
+    if (registry?.getServices) {
+        return registry.getServices(URI.parse(modelUri));
+    }
+    const all = registry?.all;
+    const services = Array.isArray(all)
+        ? all[0]
+        : (typeof all?.toArray === 'function' ? all.toArray()[0] : Array.from((all ?? []) as Iterable<any>)[0]);
+    if (!services) {
+        throw new Error(`Unable to resolve language services for '${modelUri}'.`);
+    }
+    return services;
+}
+
+function findOntologyMemberByIri(ontology: any, iri: string): any | undefined {
+    const normalizedIri = normalizeIri(iri);
+    return collectOntologyMembers(ontology).find((member: any) => isSameIriTarget(getIriForNode(member) ?? '', normalizedIri));
+}
+
+function deleteCascadeReference(ontology: any, sourceNode: any, targetIri: string): boolean {
+    if (!sourceNode || !sourceNode.$container) {
+        return false;
+    }
+    if (isConceptInstance(sourceNode) || isRelationInstance(sourceNode)) {
+        return deleteCascadeFromMember(ontology, sourceNode, targetIri);
+    }
+    if (isTypeAssertion(sourceNode)) {
+        const owner = sourceNode.$container;
+        if ((owner?.ownedTypes?.length ?? 0) <= 1) {
+            return deleteOwningStatement(ontology, owner);
+        }
+        const before = owner.ownedTypes.length;
+        owner.ownedTypes = owner.ownedTypes.filter((entry: any) => entry !== sourceNode);
+        return before !== owner.ownedTypes.length;
+    }
+    if (isPropertyValueAssertion(sourceNode)) {
+        const before = sourceNode.referencedValues?.length ?? 0;
+        sourceNode.referencedValues = (sourceNode.referencedValues ?? []).filter((ref: any) => !matchesPredicateRef(ontology, ref, targetIri));
+        if (before === (sourceNode.referencedValues?.length ?? 0)) {
+            return false;
+        }
+        if ((sourceNode.referencedValues?.length ?? 0) === 0
+            && (sourceNode.literalValues?.length ?? 0) === 0
+            && (sourceNode.containedValues?.length ?? 0) === 0) {
+            return removeNodeFromParent(sourceNode);
+        }
+        return true;
+    }
+    if (isAnnotation(sourceNode)) {
+        const before = sourceNode.referencedValues?.length ?? 0;
+        sourceNode.referencedValues = (sourceNode.referencedValues ?? []).filter((ref: any) => !matchesPredicateRef(ontology, ref, targetIri));
+        if (before === (sourceNode.referencedValues?.length ?? 0)) {
+            return false;
+        }
+        if ((sourceNode.referencedValues?.length ?? 0) === 0 && (sourceNode.literalValues?.length ?? 0) === 0) {
+            return removeNodeFromParent(sourceNode);
+        }
+        return true;
+    }
+    if (isImport(sourceNode)) {
+        return removeNodeFromParent(sourceNode);
+    }
+    const changed = removeNodeFromParent(sourceNode);
+    if (!changed) {
+        return false;
+    }
+    const parent = sourceNode.$container;
+    if (isRule(parent) && ((parent.antecedent?.length ?? 0) === 0 || (parent.consequent?.length ?? 0) === 0)) {
+        return deleteOwningStatement(ontology, parent) || changed;
+    }
+    return changed;
+}
+
+function deleteCascadeFromMember(ontology: any, member: any, targetIri: string): boolean {
+    let changed = false;
+    if (matchesPredicateRef(ontology, member.ref, targetIri)) {
+        return deleteOwningStatement(ontology, member);
+    }
+    if (Array.isArray(member.ownedTypes) && member.ownedTypes.some((entry: any) => matchesPredicateRef(ontology, entry?.type, targetIri))) {
+        if (member.ownedTypes.length <= 1) {
+            return deleteOwningStatement(ontology, member);
+        }
+        const before = member.ownedTypes.length;
+        member.ownedTypes = member.ownedTypes.filter((entry: any) => !matchesPredicateRef(ontology, entry?.type, targetIri));
+        changed ||= before !== member.ownedTypes.length;
+    }
+    if (isRelationInstance(member)) {
+        if (Array.isArray(member.sources) && member.sources.some((ref: any) => matchesPredicateRef(ontology, ref, targetIri))) {
+            if (member.sources.length <= 1) {
+                return deleteOwningStatement(ontology, member);
+            }
+            const before = member.sources.length;
+            member.sources = member.sources.filter((ref: any) => !matchesPredicateRef(ontology, ref, targetIri));
+            changed ||= before !== member.sources.length;
+        }
+        if (Array.isArray(member.targets) && member.targets.some((ref: any) => matchesPredicateRef(ontology, ref, targetIri))) {
+            if (member.targets.length <= 1) {
+                return deleteOwningStatement(ontology, member);
+            }
+            const before = member.targets.length;
+            member.targets = member.targets.filter((ref: any) => !matchesPredicateRef(ontology, ref, targetIri));
+            changed ||= before !== member.targets.length;
+        }
+    }
+    if (Array.isArray(member.ownedPropertyValues)) {
+        const remainingAssertions: any[] = [];
+        for (const assertion of member.ownedPropertyValues) {
+            if (!deleteCascadeReference(ontology, assertion, targetIri)) {
+                remainingAssertions.push(assertion);
+                continue;
+            }
+            changed = true;
+            const stillOwned = Array.isArray(member.ownedPropertyValues) && member.ownedPropertyValues.includes(assertion);
+            if (stillOwned) {
+                remainingAssertions.push(assertion);
+            }
+        }
+        member.ownedPropertyValues = remainingAssertions;
+    }
+    if (Array.isArray(member.ownedAnnotations)) {
+        const remainingAnnotations: any[] = [];
+        for (const annotation of member.ownedAnnotations) {
+            if (!deleteCascadeReference(ontology, annotation, targetIri)) {
+                remainingAnnotations.push(annotation);
+                continue;
+            }
+            changed = true;
+            const stillOwned = Array.isArray(member.ownedAnnotations) && member.ownedAnnotations.includes(annotation);
+            if (stillOwned) {
+                remainingAnnotations.push(annotation);
+            }
+        }
+        member.ownedAnnotations = remainingAnnotations;
+    }
+    return changed;
+}
+
+function deleteOwningStatement(ontology: any, node: any): boolean {
+    const statement = findOwningStatement(ontology, node);
+    if (!statement) {
+        return false;
+    }
+    if (!Array.isArray(ontology.ownedStatements)) {
+        return false;
+    }
+    const before = ontology.ownedStatements.length;
+    ontology.ownedStatements = ontology.ownedStatements.filter((entry: any) => entry !== statement);
+    return before !== ontology.ownedStatements.length;
+}
+
+function findOwningStatement(ontology: any, node: any): any | undefined {
+    let current = node;
+    while (current) {
+        if (current?.$container === ontology) {
+            return current;
+        }
+        current = current.$container;
+    }
+    return undefined;
+}
+
+function removeNodeFromParent(node: any): boolean {
+    const parent = node?.$container;
+    if (!parent || typeof parent !== 'object') {
+        return false;
+    }
+    for (const [key, value] of Object.entries(parent)) {
+        if (key.startsWith('$')) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const index = value.indexOf(node);
+            if (index >= 0) {
+                value.splice(index, 1);
+                return true;
+            }
+            continue;
+        }
+        if (value === node) {
+            (parent as Record<string, unknown>)[key] = undefined;
+            return true;
+        }
+    }
+    return false;
+}
+
+function findNamedInstanceByIri(ontology: any, iri: string): any | undefined {
+    const normalized = normalizeIri(iri);
+    const targetParts = parseIriParts(normalized);
+    const statements = Array.isArray(ontology.ownedStatements) ? ontology.ownedStatements : [];
+    for (const statement of statements) {
+        if (!isConceptInstance(statement) && !isRelationInstance(statement)) {
+            continue;
+        }
+        const marker = statement as any;
+        const directTarget = typeof marker.__targetIri === 'string' ? normalizeIri(marker.__targetIri) : '';
+        if (directTarget && isSameIriTarget(directTarget, normalized)) {
+            return statement;
+        }
+        const effectiveIri = resolveInstanceIri(ontology, statement);
+        if (effectiveIri && isSameIriTarget(effectiveIri, normalized)) {
+            return statement;
+        }
+    }
+    if (!targetParts) {
+        return undefined;
+    }
+    const fragmentMatches: any[] = [];
+    for (const statement of statements) {
+        if (!isConceptInstance(statement) && !isRelationInstance(statement)) {
+            continue;
+        }
+        if (matchesRefTextTarget(ontology, statement, targetParts.namespace, targetParts.fragment)) {
+            return statement;
+        }
+        if (matchesRefTextFragment(statement, targetParts.fragment)) {
+            fragmentMatches.push(statement);
+        }
+    }
+    if (fragmentMatches.length === 1) {
+        return fragmentMatches[0];
+    }
+    return undefined;
+}
+
+function resolveInstanceIri(ontology: any, statement: any): string | undefined {
+    const namedIri = getIriForNode(statement);
+    if (namedIri) {
+        return normalizeIri(namedIri);
+    }
+    const refText = getRefText(statement?.ref);
+    if (refText) {
+        return normalizeIri(expandRefTextToIri(ontology, refText) ?? refText);
+    }
+    const resolved = statement?.ref?.ref ?? statement?.ref?._ref;
+    const resolvedIri = resolved ? getIriForNode(resolved) : undefined;
+    return resolvedIri ? normalizeIri(resolvedIri) : undefined;
+}
+
+function findAnnotationSubjectByIri(ontology: any, iri: string): any | undefined {
+    const normalized = normalizeIri(iri);
+    const ontologyIri = normalizeNamespace((ontology as any).namespace ?? '');
+    if (normalizeIri(ontologyIri) === normalized) {
+        return ontology;
+    }
+    return collectOntologyMembers(ontology).find((member: any) => normalizeIri(getIriForNode(member) ?? '') === normalized);
+}
+
+function matchesPredicateRef(ontology: any, ref: any, iri: string): boolean {
+    if (!ref) {
+        return false;
+    }
+    const normalizedWanted = normalizeIri(iri);
+    const refText = typeof ref === 'string'
+        ? ref
+        : (typeof ref.$refText === 'string' ? ref.$refText : undefined);
+    if (refText) {
+        const normalizedRefText = normalizeIri(expandRefTextToIri(ontology, refText) ?? refText);
+        if (isSameIriTarget(normalizedRefText, normalizedWanted)) {
+            return true;
+        }
+    }
+    const resolved = ref.ref ?? ref._ref;
+    const resolvedIri = resolved ? getIriForNode(resolved) : undefined;
+    return isSameIriTarget(normalizeIri(resolvedIri ?? ''), normalizedWanted);
+}
+
+function appendAssertionValue(ontology: any, assertion: any, objectValue: unknown): void {
+    if (isIriLike(objectValue)) {
+        const normalizedObjectIri = normalizeIri(asRequiredIri(objectValue, 'assertion object'));
+        ensureReferenceImport(ontology, normalizedObjectIri);
+        assertion.referencedValues ??= [];
+        assertion.referencedValues.push(asRef(ontology, normalizedObjectIri));
+        return;
+    }
+    assertion.literalValues ??= [];
+    assertion.literalValues.push(asLiteral(objectValue));
+}
+
+function removeAssertionValue(ontology: any, assertion: any, objectValue: unknown): void {
+    if (isIriLike(objectValue)) {
+        const normalizedIri = normalizeIri(asRequiredIri(objectValue, 'assertion object'));
+        assertion.referencedValues = (assertion.referencedValues ?? []).filter((ref: any) => !matchesPredicateRef(ontology, ref, normalizedIri));
+        return;
+    }
+    const normalizedLiteral = normalizeLiteralValue(asLiteral(objectValue));
+    assertion.literalValues = (assertion.literalValues ?? []).filter((literal: any) => normalizeLiteralValue(literal) !== normalizedLiteral);
+}
+
+function appendAnnotationValue(ontology: any, annotation: any, objectValue: unknown): void {
+    if (isIriLike(objectValue)) {
+        const normalizedObjectIri = normalizeIri(asRequiredIri(objectValue, 'annotation object'));
+        ensureReferenceImport(ontology, normalizedObjectIri);
+        annotation.referencedValues ??= [];
+        annotation.referencedValues.push(asRef(ontology, normalizedObjectIri));
+        return;
+    }
+    annotation.literalValues ??= [];
+    annotation.literalValues.push(asLiteral(objectValue));
+}
+
+function removeAnnotationValue(ontology: any, annotation: any, objectValue: unknown): void {
+    if (isIriLike(objectValue)) {
+        const normalizedIri = normalizeIri(asRequiredIri(objectValue, 'annotation object'));
+        annotation.referencedValues = (annotation.referencedValues ?? []).filter((ref: any) => !matchesPredicateRef(ontology, ref, normalizedIri));
+        return;
+    }
+    const normalizedLiteral = normalizeLiteralValue(asLiteral(objectValue));
+    annotation.literalValues = (annotation.literalValues ?? []).filter((literal: any) => normalizeLiteralValue(literal) !== normalizedLiteral);
+}
+
+function normalizeLiteralValue(literal: any): string {
+    if (!literal || typeof literal !== 'object') {
+        return String(literal);
+    }
+    if (literal.$type === 'BooleanLiteral') {
+        return `bool:${literal.value ? 'true' : 'false'}`;
+    }
+    if (literal.$type === 'IntegerLiteral') {
+        return `int:${String(literal.value)}`;
+    }
+    if (literal.$type === 'DecimalLiteral') {
+        return `decimal:${String(literal.value)}`;
+    }
+    if (literal.$type === 'DoubleLiteral') {
+        return `double:${String(literal.value)}`;
+    }
+    return `quoted:${String(literal.value ?? '')}:${String(literal.langTag ?? '')}:${normalizeIri(literal.type?.$refText ?? '')}`;
+}
+
+function asRef(ontology: any, iri: string): any {
+    return { $refText: toRefText(ontology, iri) };
+}
+
+function toRefText(ontology: any, iri: string): string {
+    const normalizedIri = normalizeIri(iri);
+    const localInCurrentOntology = getLocalNameForNamespace(normalizedIri, ontology?.namespace);
+    if (localInCurrentOntology) {
+        return localInCurrentOntology;
+    }
+    const imports = Array.isArray(ontology?.ownedImports) ? ontology.ownedImports : [];
+    for (const imp of imports) {
+        const prefix = resolveImportPrefix(imp);
+        if (!prefix) {
+            continue;
+        }
+        const localInImport = getLocalNameForNamespace(normalizedIri, resolveImportNamespaceRaw(imp));
+        if (localInImport) {
+            return `${prefix}:${localInImport}`;
+        }
+    }
+    return `<${normalizedIri}>`;
+}
+
+function getLocalNameForNamespace(iri: string, rawNamespace: string | undefined): string | undefined {
+    const namespace = normalizeNamespace(String(rawNamespace ?? ''));
+    if (!namespace) {
+        return undefined;
+    }
+    const hashPrefix = `${namespace}#`;
+    if (iri.startsWith(hashPrefix) && iri.length > hashPrefix.length) {
+        return iri.slice(hashPrefix.length);
+    }
+    const slashPrefix = `${namespace}/`;
+    if (iri.startsWith(slashPrefix) && iri.length > slashPrefix.length) {
+        return iri.slice(slashPrefix.length);
+    }
+    return undefined;
+}
+
+function resolveImportPrefix(imp: any): string | undefined {
+    const explicitPrefix = typeof imp?.prefix === 'string' ? imp.prefix.trim() : '';
+    if (explicitPrefix) {
+        return explicitPrefix;
+    }
+    const resolvedPrefix = typeof imp?.imported?.ref?.prefix === 'string' ? imp.imported.ref.prefix.trim() : '';
+    return resolvedPrefix || undefined;
+}
+
+function resolveImportNamespaceRaw(imp: any): string | undefined {
+    const resolvedNamespace = typeof imp?.imported?.ref?.namespace === 'string' ? imp.imported.ref.namespace : '';
+    if (resolvedNamespace.trim().length > 0) {
+        return resolvedNamespace.trim();
+    }
+    const refText = typeof imp?.imported?.$refText === 'string' ? imp.imported.$refText.trim() : '';
+    return refText || undefined;
+}
+
+function expandRefTextToIri(ontology: any, refText: string): string | undefined {
+    const trimmed = String(refText ?? '').trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed === 'a') {
+        return RDF_TYPE_IRI;
+    }
+    if (trimmed.startsWith('<') && trimmed.endsWith('>')) {
+        return normalizeIri(trimmed);
+    }
+    if (trimmed.includes('://')) {
+        return normalizeIri(trimmed);
+    }
+    const localInCurrentOntology = expandLocalRefText(ontology?.namespace, trimmed);
+    if (localInCurrentOntology) {
+        return localInCurrentOntology;
+    }
+    const separatorIndex = trimmed.indexOf(':');
+    if (separatorIndex <= 0) {
+        return undefined;
+    }
+    const prefix = trimmed.slice(0, separatorIndex);
+    const local = trimmed.slice(separatorIndex + 1);
+    if (!local) {
+        return undefined;
+    }
+    if (typeof ontology?.prefix === 'string' && ontology.prefix.trim() === prefix) {
+        return expandLocalRefText(ontology.namespace, local);
+    }
+    const imports = Array.isArray(ontology?.ownedImports) ? ontology.ownedImports : [];
+    for (const imp of imports) {
+        if (resolveImportPrefix(imp) !== prefix) {
+            continue;
+        }
+        return expandLocalRefText(resolveImportNamespaceRaw(imp), local);
+    }
+    return undefined;
+}
+
+function expandLocalRefText(rawNamespace: string | undefined, localName: string): string | undefined {
+    const namespaceText = String(rawNamespace ?? '').trim();
+    const local = String(localName ?? '').trim();
+    if (!namespaceText || !local) {
+        return undefined;
+    }
+    const namespace = normalizeIri(namespaceText);
+    if (namespace.endsWith('#') || namespace.endsWith('/')) {
+        return `${namespace}${local}`;
+    }
+    return `${namespace}#${local}`;
+}
+
+function ensureReferenceImport(ontology: any, iri: string): void {
+    const target = parseIriParts(iri);
+    if (!target) {
+        return;
+    }
+    const localNamespace = normalizeNamespace(String(ontology?.namespace ?? ''));
+    if (!localNamespace || target.namespace === localNamespace) {
+        return;
+    }
+    const imports = Array.isArray(ontology?.ownedImports) ? ontology.ownedImports : [];
+    const hasImport = imports.some((imp: any) => {
+        const importedNamespace = normalizeNamespace(String(resolveImportNamespaceRaw(imp) ?? ''));
+        return importedNamespace === target.namespace;
+    });
+    if (hasImport) {
+        return;
+    }
+    const usedPrefixes = new Set<string>();
+    const rootPrefix = typeof ontology?.prefix === 'string' ? ontology.prefix.trim() : '';
+    if (rootPrefix) {
+        usedPrefixes.add(rootPrefix);
+    }
+    for (const imp of imports) {
+        const prefix = resolveImportPrefix(imp);
+        if (prefix) {
+            usedPrefixes.add(prefix);
+        }
+    }
+    const prefix = pickImportPrefix(target.namespace, usedPrefixes);
+    const importedRef = `<${target.namespace}${target.separator}>`;
+    const importStatement: any = {
+        $type: 'Import',
+        kind: 'extends',
+        prefix,
+        imported: { $refText: importedRef }
+    };
+    importStatement.$container = ontology;
+    if (!Array.isArray(ontology.ownedImports)) {
+        ontology.ownedImports = [];
+    }
+    ontology.ownedImports.push(importStatement);
+}
+
+function parseIriParts(iri: string): { namespace: string; fragment: string; separator: '#' | '/' } | undefined {
+    const normalized = normalizeIri(iri);
+    if (!normalized) {
+        return undefined;
+    }
+    const hashIndex = normalized.lastIndexOf('#');
+    if (hashIndex > 0 && hashIndex < normalized.length - 1) {
+        return {
+            namespace: normalizeNamespace(normalized.slice(0, hashIndex)),
+            fragment: normalized.slice(hashIndex + 1),
+            separator: '#',
+        };
+    }
+    const slashIndex = normalized.lastIndexOf('/');
+    if (slashIndex > 0 && slashIndex < normalized.length - 1) {
+        return {
+            namespace: normalizeNamespace(normalized.slice(0, slashIndex)),
+            fragment: normalized.slice(slashIndex + 1),
+            separator: '/',
+        };
+    }
+    return undefined;
+}
+
+function getRefText(ref: any): string | undefined {
+    if (typeof ref === 'string') {
+        return ref;
+    }
+    if (typeof ref?.$refText === 'string') {
+        return ref.$refText;
+    }
+    if (typeof ref?.$refNode?.text === 'string') {
+        return ref.$refNode.text;
+    }
+    return undefined;
+}
+
+function matchesRefTextTarget(
+    ontology: any,
+    statement: any,
+    namespace: string,
+    fragment: string
+): boolean {
+    const refText = getRefText(statement?.ref);
+    if (!refText) {
+        return false;
+    }
+    const expanded = expandRefTextToIri(ontology, refText);
+    if (expanded) {
+        return isSameIriTarget(expanded, `${namespace}#${fragment}`);
+    }
+
+    const trimmed = refText.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const separatorIndex = trimmed.indexOf(':');
+    if (separatorIndex > 0) {
+        const prefix = trimmed.slice(0, separatorIndex);
+        const local = trimmed.slice(separatorIndex + 1);
+        if (local !== fragment) {
+            return false;
+        }
+        if (typeof ontology?.prefix === 'string' && ontology.prefix.trim() === prefix) {
+            return normalizeNamespace(String(ontology?.namespace ?? '')) === namespace;
+        }
+        const imports = Array.isArray(ontology?.ownedImports) ? ontology.ownedImports : [];
+        for (const imp of imports) {
+            if (resolveImportPrefix(imp) !== prefix) {
+                continue;
+            }
+            const importedNamespace = normalizeNamespace(String(resolveImportNamespaceRaw(imp) ?? ''));
+            return importedNamespace === namespace;
+        }
+        return false;
+    }
+
+    const localInCurrent = trimmed.replace(/^<|>$/g, '');
+    if (localInCurrent !== fragment) {
+        return false;
+    }
+    return normalizeNamespace(String(ontology?.namespace ?? '')) === namespace;
+}
+
+function matchesRefTextFragment(statement: any, fragment: string): boolean {
+    if (!fragment) {
+        return false;
+    }
+    const refText = getRefText(statement?.ref);
+    if (!refText) {
+        return false;
+    }
+    const local = localNameFromRefText(refText);
+    return !!local && local === fragment;
+}
+
+function localNameFromRefText(refText: string): string | undefined {
+    const trimmed = refText.trim().replace(/^<|>$/g, '');
+    if (!trimmed) {
+        return undefined;
+    }
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex > 0 && colonIndex < trimmed.length - 1) {
+        return trimmed.slice(colonIndex + 1);
+    }
+    const hashIndex = trimmed.lastIndexOf('#');
+    if (hashIndex >= 0 && hashIndex < trimmed.length - 1) {
+        return trimmed.slice(hashIndex + 1);
+    }
+    const slashIndex = trimmed.lastIndexOf('/');
+    if (slashIndex >= 0 && slashIndex < trimmed.length - 1) {
+        return trimmed.slice(slashIndex + 1);
+    }
+    return trimmed;
+}
+
+function isSameIriTarget(left: string, right: string): boolean {
+    const leftNorm = normalizeIri(left);
+    const rightNorm = normalizeIri(right);
+    if (leftNorm === rightNorm) {
+        return true;
+    }
+    const leftParts = parseIriParts(leftNorm);
+    const rightParts = parseIriParts(rightNorm);
+    if (!leftParts || !rightParts) {
+        return false;
+    }
+    return leftParts.namespace === rightParts.namespace
+        && leftParts.fragment === rightParts.fragment;
+}
+
+function pickImportPrefix(namespace: string, usedPrefixes: ReadonlySet<string>): string {
+    const normalizedNamespace = normalizeNamespace(namespace);
+    const pieces = normalizedNamespace.split('/').filter((piece) => piece.length > 0);
+    const tail = (pieces[pieces.length - 1] ?? normalizedNamespace)
+        .replace(/[^A-Za-z0-9_]/g, '')
+        .toLowerCase();
+    const base = /^[A-Za-z_]/.test(tail) ? tail : `ns${tail}`;
+    const candidateBase = (base || 'ns').slice(0, 32);
+    if (!usedPrefixes.has(candidateBase)) {
+        return candidateBase;
+    }
+    let suffix = 1;
+    while (usedPrefixes.has(`${candidateBase}${suffix}`)) {
+        suffix += 1;
+    }
+    return `${candidateBase}${suffix}`;
+}
+
+function asLiteral(value: unknown): any {
+    if (typeof value === 'boolean') {
+        return { $type: 'BooleanLiteral', value };
+    }
+    if (typeof value === 'number' && Number.isInteger(value)) {
+        return { $type: 'IntegerLiteral', value };
+    }
+    if (typeof value === 'number') {
+        return { $type: 'DecimalLiteral', value };
+    }
+    return { $type: 'QuotedLiteral', value: String(value ?? '') };
+}
+
+function asRequiredIri(value: unknown, context: string): string {
+    if (!isIriLike(value)) {
+        throw new Error(`Expected IRI for ${context}.`);
+    }
+    return String(value);
+}
+
+function isIriLike(value: unknown): boolean {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return false;
+    }
+    if (trimmed.startsWith('<') && trimmed.endsWith('>')) {
+        return true;
+    }
+    return trimmed.includes('://');
+}
+
+function normalizeIri(value: string): string {
+    return String(value ?? '').trim().replace(/^<|>$/g, '');
+}
+
+function isSourcePredicate(predicateIri: string): boolean {
+    return normalizeIri(predicateIri) === OML_HAS_SOURCE_IRI;
+}
+
+function isTargetPredicate(predicateIri: string): boolean {
+    return normalizeIri(predicateIri) === OML_HAS_TARGET_IRI;
+}
+
+function buildWorkspaceEdit(
+    contexts: Map<string, OntologyContext>,
+    changedOntologyIris: ReadonlySet<string>
+): WorkspaceEdit | undefined {
+    if (changedOntologyIris.size === 0) {
+        return undefined;
+    }
+    const changes: NonNullable<WorkspaceEdit['changes']> = {};
+    for (const ontologyIri of [...changedOntologyIris].sort()) {
+        const context = contexts.get(ontologyIri);
+        if (!context) {
+            continue;
+        }
+        const serialized = serializeOntology(context.ontology);
+        const textDocument = context.document?.textDocument;
+        if (!textDocument) {
+            continue;
+        }
+        const end = textDocument.positionAt(textDocument.getText().length);
+        changes[context.modelUri] = [{
+            range: {
+                start: { line: 0, character: 0 },
+                end: { line: end.line, character: end.character }
+            },
+            newText: serialized
+        }];
+    }
+    return Object.keys(changes).length > 0 ? { changes } : undefined;
+}
+
+async function restoreContextsFromDocuments(shared: any, contexts: Map<string, OntologyContext>): Promise<void> {
+    const uris = [...new Set([...contexts.values()].map((context) => URI.parse(context.modelUri)))];
+    if (uris.length > 0) {
+        await shared.workspace.DocumentBuilder.update(uris, []);
+    }
+    const langiumDocuments: any = shared.workspace.LangiumDocuments;
+    for (const context of contexts.values()) {
+        const refreshed = langiumDocuments.getDocument(URI.parse(context.modelUri))
+            ?? await langiumDocuments.getOrCreateDocument(URI.parse(context.modelUri));
+        const refreshedOntology = refreshed?.parseResult?.value;
+        if (refreshedOntology && isOntology(refreshedOntology)) {
+            context.document = refreshed;
+            context.ontology = refreshedOntology;
+        }
+    }
+}