@oml/language 0.14.17 → 0.16.0

package/out/oml/oml-update.js

@@ -1,26 +1,80 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 import { DocumentState, URI } from 'langium';
 import { RequestType } from 'vscode-languageserver-protocol';
-import { isAnnotation, isConceptInstance, isDescription, isDescriptionBox, isImport, isOntology, isPropertyValueAssertion, isRelationInstance, isRule, isTypeAssertion, isVocabulary, isVocabularyBundle, } from './generated/ast.js';
+import { isAnnotation, isConceptInstance, isDescription, isDescriptionBundle, isDescriptionBox, isImport, isOntology, isPropertyValueAssertion, isRelationInstance, isRule, isTypeAssertion, isVocabulary, isVocabularyBundle, } 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';
-const OmlEditRequestType = new RequestType('oml/update');
+import { collectOntologyMembers, expandRefTextToIri, findOntologyMemberByName, getLocalNameForNamespace, getRefText, getIriForNode, isSameIriTarget, localNameFromRefText, normalizeIri, normalizeNamespace, parseIriParts, pickImportPrefix, resolveImportNamespaceRaw, resolveImportPrefix, withNamespaceSeparator, } from './oml-utils.js';
+const OmlUpdateRequestType = new RequestType('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';
-export async function applyOmlUpdate(shared, params, logError) {
+export async function applyOmlUpdate(shared, params, logError, workspaceUri, preview) {
     const operations = Array.isArray(params?.operations) ? params.operations : [];
-    const referencingUri = typeof params?.referencingUri === 'string'
-        ? params.referencingUri.trim()
-        : undefined;
     const contexts = new Map();
     const changedOntologyIris = new Set();
+    const createdOntologyByIri = new Map();
+    const deletedOntologyModelUriByIri = new Map();
     for (let i = 0; i < operations.length; i += 1) {
         const operation = operations[i];
         try {
-            const context = await resolveOntologyContext(shared, operation.ontologyIri, contexts, referencingUri);
+            if (operation.kind === 'createOntology') {
+                const created = await createOntologyOperation(shared, operation, workspaceUri);
+                contexts.set(created.ontologyIri, {
+                    ontologyIri: created.ontologyIri,
+                    modelUri: created.modelUri,
+                    ontology: created.ontology,
+                    document: undefined
+                });
+                createdOntologyByIri.set(created.ontologyIri, created);
+                changedOntologyIris.add(created.ontologyIri);
+                continue;
+            }
+            if (operation.kind === 'deleteOntology') {
+                const normalizedOntologyIri = normalizeOntologyIriKey(operation.ontologyIri);
+                if (createdOntologyByIri.has(normalizedOntologyIri)) {
+                    createdOntologyByIri.delete(normalizedOntologyIri);
+                    contexts.delete(normalizedOntologyIri);
+                    changedOntologyIris.delete(normalizedOntologyIri);
+                    continue;
+                }
+                const existingContext = contexts.get(normalizedOntologyIri);
+                if (existingContext) {
+                    deletedOntologyModelUriByIri.set(existingContext.ontologyIri, existingContext.modelUri);
+                    contexts.delete(existingContext.ontologyIri);
+                    changedOntologyIris.delete(existingContext.ontologyIri);
+                    continue;
+                }
+                const modelUri = resolveModelUriFromLoadedDocuments(shared, normalizedOntologyIri);
+                if (!modelUri) {
+                    // Idempotent delete: if ontology is already absent, treat as successful no-op.
+                    continue;
+                }
+                deletedOntologyModelUriByIri.set(normalizedOntologyIri, modelUri);
+                contexts.delete(normalizedOntologyIri);
+                changedOntologyIris.delete(normalizedOntologyIri);
+                continue;
+            }
+            if (operation.kind === 'addImport') {
+                const importing = await resolveOntologyContext(shared, operation.importingIri, contexts, workspaceUri);
+                const imported = await resolveOntologyContext(shared, operation.importedIri, contexts, workspaceUri);
+                const changed = await addImport(shared, importing.ontology, imported.ontology);
+                if (changed) {
+                    changedOntologyIris.add(importing.ontologyIri);
+                }
+                continue;
+            }
+            if (operation.kind === 'removeImport') {
+                const importing = await resolveOntologyContext(shared, operation.importingIri, contexts, workspaceUri);
+                const imported = await resolveOntologyContext(shared, operation.importedIri, contexts, workspaceUri);
+                const changed = removeImport(importing.ontology, imported.ontology);
+                if (changed) {
+                    changedOntologyIris.add(importing.ontologyIri);
+                }
+                continue;
+            }
+            const context = await resolveOntologyContext(shared, getOperationTargetOntologyIri(operation), contexts, workspaceUri);
             const changed = await executeOperation(shared, context, operation, contexts);
             for (const ontologyIri of changed) {
                 changedOntologyIris.add(ontologyIri);
@@ -32,7 +86,7 @@ export async function applyOmlUpdate(shared, params, logError) {
             const details = error instanceof Error && error.stack
                 ? `${message}\n${error.stack}`
                 : message;
-            logError?.(`[oml] OmlEditRequest failed at operation ${i} (${operation.kind}): ${details}`);
+            logError?.(`[oml] OmlUpdateRequest failed at operation ${i} (${operation.kind}): ${details}`);
             return {
                 errors: [{
                         operationIndex: i,
@@ -41,16 +95,62 @@ export async function applyOmlUpdate(shared, params, logError) {
             };
         }
     }
-    const edit = buildWorkspaceEdit(contexts, changedOntologyIris);
+    const edit = buildWorkspaceEdit(contexts, changedOntologyIris, createdOntologyByIri, deletedOntologyModelUriByIri);
+    if (preview) {
+        const existingContexts = new Map([...contexts.entries()].filter(([iri]) => !createdOntologyByIri.has(iri)));
+        await restoreContextsFromDocuments(shared, existingContexts);
+    }
     return edit ? { edit } : {};
 }
-export function registerOmlEditRequests(connection, shared) {
-    connection.onRequest(OmlEditRequestType, async (params) => {
-        return await applyOmlUpdate(shared, params, (message) => connection.console?.error(message));
+function resolveModelUriFromLoadedDocuments(shared, ontologyIri) {
+    const normalized = normalizeOntologyIriKey(ontologyIri);
+    const documentsService = shared.workspace.LangiumDocuments;
+    const all = documentsService?.all ?? [];
+    const iterable = Array.isArray(all)
+        ? all
+        : (typeof all?.toArray === 'function' ? all.toArray() : Array.from(all));
+    for (const document of iterable) {
+        const root = document?.parseResult?.value;
+        if (!root || !isOntology(root)) {
+            continue;
+        }
+        const namespace = normalizeNamespace(String(root.namespace ?? ''));
+        if (!namespace) {
+            continue;
+        }
+        if (normalizeOntologyIriKey(namespace) === normalized) {
+            return String(document.uri);
+        }
+    }
+    return undefined;
+}
+export function registerOmlUpdateRequests(connection, shared) {
+    connection.onRequest(OmlUpdateRequestType, async (params) => {
+        return await applyOmlUpdate(shared, params, (message) => connection.console?.error(message), params.referencingUri);
     });
 }
+function getOperationTargetOntologyIri(operation) {
+    switch (operation.kind) {
+        case 'createInstance':
+        case 'createRelationInstance':
+        case 'createInstanceRef':
+        case 'createRelationInstanceRef':
+        case 'addAssertion':
+        case 'updateAssertion':
+        case 'removeAssertion':
+            return operation.descriptionIri;
+        case 'addAnnotation':
+        case 'updateAnnotation':
+        case 'removeAnnotation':
+        case 'deleteMemberCascade':
+        case 'deleteMemberRef':
+            return operation.ontologyIri;
+        default:
+            throw new Error(`Unsupported operation target resolution for '${operation.kind}'.`);
+    }
+}
 async function resolveOntologyContext(shared, ontologyIri, cache, referencingUri) {
-    const normalizedOntologyIri = normalizeIri(ontologyIri);
+    const normalizedOntologyIri = normalizeOntologyIriKey(ontologyIri);
     const cached = cache.get(normalizedOntologyIri);
     if (cached) {
         return cached;
@@ -933,88 +1033,6 @@ function toRefText(ontology, iri) {
     }
     return `<${normalizedIri}>`;
 }
-function getLocalNameForNamespace(iri, rawNamespace) {
-    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) {
-    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) {
-    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, refText) {
-    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, localName) {
-    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}`;
-}
 async function ensureReferenceImport(shared, ontology, iri) {
     const target = parseIriParts(iri);
     if (!target) {
@@ -1025,23 +1043,28 @@ async function ensureReferenceImport(shared, ontology, iri) {
         return;
     }
     const imports = Array.isArray(ontology?.ownedImports) ? ontology.ownedImports : [];
-    const hasImport = imports.some((imp) => {
-        const importedNamespace = normalizeNamespace(String(resolveImportNamespaceRaw(imp) ?? ''));
-        return importedNamespace === target.namespace;
-    });
-    if (hasImport) {
-        return;
-    }
     const usedPrefixes = new Set();
     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 p = resolveImportPrefix(imp);
+        if (p) {
+            usedPrefixes.add(p);
+        }
+    }
+    const existingImport = imports.find((imp) => {
+        const importedNamespace = normalizeNamespace(String(resolveImportNamespaceRaw(imp) ?? ''));
+        return importedNamespace === target.namespace;
+    });
+    if (existingImport) {
+        // If the existing import has no prefix (e.g., a bundle `includes` added without one),
+        // patch it now so that the reference can use the abbreviated form.
+        if (!resolveImportPrefix(existingImport)) {
+            existingImport.prefix = pickImportPrefix(target.namespace, usedPrefixes);
         }
+        return;
     }
     const prefix = pickImportPrefix(target.namespace, usedPrefixes);
     const importedRef = `<${target.namespace}${target.separator}>`;
@@ -1054,15 +1077,93 @@ async function ensureReferenceImport(shared, ontology, iri) {
     };
     pushAstArrayChild(ontology, 'ownedImports', importStatement);
 }
-async function resolveImportKind(shared, importing, importedNamespace) {
-    const imported = await findOntologyByNamespace(shared, importedNamespace);
+async function addImport(shared, importingOntology, importedOntology) {
+    const importingNamespace = normalizeNamespace(String(importingOntology?.namespace ?? ''));
+    const importedNamespaceRaw = String(importedOntology?.namespace ?? '').trim();
+    const importedNamespace = normalizeNamespace(importedNamespaceRaw);
+    if (!importingNamespace || !importedNamespace) {
+        throw new Error('addImport requires both importing and imported ontologies to have valid namespaces.');
+    }
+    if (importingNamespace === importedNamespace) {
+        return false;
+    }
+    const imports = Array.isArray(importingOntology?.ownedImports) ? importingOntology.ownedImports : [];
+    const hasImport = imports.some((imp) => {
+        const imported = normalizeNamespace(String(resolveImportNamespaceRaw(imp) ?? ''));
+        return imported === importedNamespace;
+    });
+    if (hasImport) {
+        return false;
+    }
+    const separator = importedNamespaceRaw.endsWith('/') ? '/' : '#';
+    const importedRef = `<${importedNamespace}${separator}>`;
+    const importKind = await resolveImportKind(shared, importingOntology, importedNamespace, importedOntology);
+    const usedPrefixes = new Set();
+    const rootPrefix = typeof importingOntology?.prefix === 'string' ? importingOntology.prefix.trim() : '';
+    if (rootPrefix) {
+        usedPrefixes.add(rootPrefix);
+    }
+    for (const imp of imports) {
+        const p = resolveImportPrefix(imp);
+        if (p) {
+            usedPrefixes.add(p);
+        }
+    }
+    // `includes` never gets a prefix — if an annotation later references a term from this
+    // vocabulary, ensureReferenceImport will patch the prefix onto this import at that point.
+    let prefix;
+    if (importKind !== 'includes') {
+        const candidatePrefix = typeof importedOntology?.prefix === 'string' ? importedOntology.prefix.trim() : '';
+        prefix = candidatePrefix && !usedPrefixes.has(candidatePrefix)
+            ? candidatePrefix
+            : pickImportPrefix(importedNamespace, usedPrefixes);
+    }
+    const importStatement = {
+        $type: 'Import',
+        kind: importKind,
+        ...(prefix ? { prefix } : {}),
+        imported: { $refText: importedRef }
+    };
+    pushAstArrayChild(importingOntology, 'ownedImports', importStatement);
+    return true;
+}
+function removeImport(importingOntology, importedOntology) {
+    const importedNamespace = normalizeNamespace(String(importedOntology?.namespace ?? ''));
+    if (!importedNamespace) {
+        throw new Error('removeImport requires imported ontology to have a valid namespace.');
+    }
+    const imports = Array.isArray(importingOntology?.ownedImports) ? importingOntology.ownedImports : [];
+    if (imports.length === 0) {
+        return false;
+    }
+    const kept = imports.filter((imp) => {
+        const namespace = normalizeNamespace(String(resolveImportNamespaceRaw(imp) ?? ''));
+        return namespace !== importedNamespace;
+    });
+    if (kept.length === imports.length) {
+        return false;
+    }
+    importingOntology.ownedImports = kept;
+    return true;
+}
+async function resolveImportKind(shared, importing, importedNamespace, importedOntology) {
+    const imported = importedOntology ?? await findOntologyByNamespace(shared, importedNamespace);
     if (imported) {
         if (importing.$type === imported.$type) {
             return 'extends';
         }
+        if (isDescriptionBundle(importing) && isDescription(imported)) {
+            return 'includes';
+        }
         if (isVocabulary(importing) && isDescription(imported)) {
             return 'uses';
         }
+        if (isDescriptionBundle(importing) && isVocabularyBundle(imported)) {
+            return 'uses';
+        }
+        if (isDescriptionBundle(importing) && isVocabulary(imported)) {
+            return 'uses';
+        }
         if (isDescriptionBox(importing) && isVocabulary(imported)) {
             return 'uses';
         }
@@ -1093,41 +1194,6 @@ async function findOntologyByNamespace(shared, namespace) {
     const ontology = document?.parseResult?.value;
     return ontology && isOntology(ontology) ? ontology : undefined;
 }
-function parseIriParts(iri) {
-    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) {
-    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, statement, namespace, fragment) {
     const refText = getRefText(statement?.ref);
     if (!refText) {
@@ -1178,56 +1244,6 @@ function matchesRefTextFragment(statement, fragment) {
     const local = localNameFromRefText(refText);
     return !!local && local === fragment;
 }
-function localNameFromRefText(refText) {
-    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, right) {
-    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, usedPrefixes) {
-    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(ontology, value) {
     if (isTypedQuotedLiteralTransport(value)) {
         const literalValue = String(value.value ?? '');
@@ -1355,8 +1371,8 @@ function isIriLike(value) {
     }
     return trimmed.includes('://');
 }
-function normalizeIri(value) {
-    return String(value ?? '').trim().replace(/^<|>$/g, '');
+function normalizeOntologyIriKey(value) {
+    return normalizeNamespace(normalizeIri(value));
 }
 function normalizePropertyAssertionGroup(subject, target, duplicates) {
     if (!Array.isArray(subject?.ownedPropertyValues) || !target || duplicates.length === 0) {
@@ -1466,16 +1482,23 @@ function isSourcePredicate(predicateIri) {
 function isTargetPredicate(predicateIri) {
     return normalizeIri(predicateIri) === OML_HAS_TARGET_IRI;
 }
-function buildWorkspaceEdit(contexts, changedOntologyIris) {
-    if (changedOntologyIris.size === 0) {
+function buildWorkspaceEdit(contexts, changedOntologyIris, createdOntologyByIri, deletedOntologyModelUriByIri) {
+    if (changedOntologyIris.size === 0 && createdOntologyByIri.size === 0 && deletedOntologyModelUriByIri.size === 0) {
         return undefined;
     }
     const changes = {};
+    const deletedModelUris = new Set([...deletedOntologyModelUriByIri.values()]);
     for (const ontologyIri of [...changedOntologyIris].sort()) {
+        if (createdOntologyByIri.has(ontologyIri)) {
+            continue;
+        }
         const context = contexts.get(ontologyIri);
         if (!context) {
             continue;
         }
+        if (deletedModelUris.has(context.modelUri)) {
+            continue;
+        }
         const serialized = serializeOntology(context.ontology);
         const textDocument = context.document?.textDocument;
         if (!textDocument) {
@@ -1490,14 +1513,185 @@ function buildWorkspaceEdit(contexts, changedOntologyIris) {
                 newText: serialized
             }];
     }
-    return Object.keys(changes).length > 0 ? { changes } : undefined;
+    for (const [createdIri, created] of [...createdOntologyByIri.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const createdContext = contexts.get(createdIri);
+        const content = createdContext ? serializeOntology(createdContext.ontology) : created.content;
+        changes[created.modelUri] = [{
+                range: {
+                    start: { line: 0, character: 0 },
+                    end: { line: 0, character: 0 }
+                },
+                newText: content
+            }];
+    }
+    const documentChanges = [...deletedModelUris].sort().map((uri) => ({ kind: 'delete', uri }));
+    if (Object.keys(changes).length === 0 && documentChanges.length === 0) {
+        return undefined;
+    }
+    if (documentChanges.length === 0) {
+        return { changes };
+    }
+    if (Object.keys(changes).length === 0) {
+        return { documentChanges };
+    }
+    return { changes, documentChanges };
+}
+function detectOmlSrcDocument(shared) {
+    const documentsService = shared.workspace.LangiumDocuments;
+    const all = documentsService?.all ?? [];
+    const iterable = Array.isArray(all)
+        ? all
+        : (typeof all?.toArray === 'function' ? all.toArray() : Array.from(all));
+    for (const document of iterable) {
+        const uri = String(document?.uri ?? '');
+        if (uri.includes('/oml/')) {
+            return uri;
+        }
+    }
+    return undefined;
+}
+async function createOntologyOperation(shared, operation, workspaceUri) {
+    const namespaceCore = normalizeNamespace(operation.ontologyNamespace);
+    if (!namespaceCore) {
+        throw new Error('createOntology requires a non-empty ontologyNamespace.');
+    }
+    const ontologyPrefix = operation.ontologyPrefix.trim();
+    if (!ontologyPrefix) {
+        throw new Error('createOntology requires a non-empty ontologyPrefix.');
+    }
+    const namespaceWithSeparator = withNamespaceSeparator(operation.ontologyNamespace);
+    const index = getOntologyModelIndex(shared);
+    const referencingUri = operation.targetFolder ? undefined : detectOmlSrcDocument(shared) ?? workspaceUri;
+    const existingModelUri = index.resolveModelUri(namespaceCore, referencingUri);
+    if (existingModelUri) {
+        throw new Error(`Ontology '${namespaceWithSeparator}' already exists at '${existingModelUri}'.`);
+    }
+    const modelUri = deriveNewOntologyModelUri(namespaceCore, referencingUri, operation.targetFolder, workspaceUri);
+    const ontologyIri = normalizeOntologyIriKey(namespaceWithSeparator);
+    const ontology = createOntologyAst(operation.ontologyKind, namespaceWithSeparator, ontologyPrefix);
+    const content = serializeOntology(ontology);
+    return {
+        ontologyIri,
+        modelUri,
+        content,
+        ontology
+    };
+}
+function deriveNewOntologyModelUri(namespaceCore, referencingUri, targetFolder, workspaceUri) {
+    let namespaceUrl;
+    try {
+        namespaceUrl = new URL(namespaceCore.includes('://') ? namespaceCore : `http://${namespaceCore}`);
+    }
+    catch {
+        throw new Error(`Unable to derive ontology file path from namespace '${namespaceCore}'.`);
+    }
+    const nsHost = namespaceUrl.host;
+    const nsPath = (namespaceUrl.pathname ?? '').replace(/^\/+/, '').replace(/\/+$/, '');
+    const relative = [nsHost, ...nsPath.split('/').filter(Boolean)].join('/');
+    if (!relative) {
+        throw new Error(`Unable to derive ontology file path from namespace '${namespaceCore}'.`);
+    }
+    if (targetFolder) {
+        const normalizedFolder = targetFolder.trim().replace(/\/+$/, '');
+        if (!normalizedFolder) {
+            throw new Error('createOntology targetFolder must not be empty.');
+        }
+        let folderPath = normalizedFolder;
+        if (!normalizedFolder.startsWith('/') && workspaceUri) {
+            const workspacePath = URI.parse(workspaceUri).path ?? '';
+            folderPath = `${workspacePath.replace(/\/+$/, '')}/${normalizedFolder}`;
+        }
+        return URI.from({
+            scheme: 'file',
+            authority: '',
+            path: `${folderPath}/${relative}.oml`,
+            query: undefined,
+            fragment: undefined
+        }).toString();
+    }
+    if (!referencingUri) {
+        throw new Error('createOntology requires either targetFolder or referencingUri to derive output path.');
+    }
+    let reference;
+    try {
+        reference = URI.parse(referencingUri);
+    }
+    catch {
+        throw new Error(`Invalid referencingUri '${referencingUri}'.`);
+    }
+    const refPath = reference.path ?? '';
+    const marker = '/oml/';
+    const markerIndex = refPath.lastIndexOf(marker);
+    if (markerIndex < 0) {
+        throw new Error(`Unable to derive ontology path from referencingUri '${referencingUri}': missing '/oml/' segment.`);
+    }
+    const basePath = refPath.slice(0, markerIndex + marker.length);
+    const targetPath = `${basePath}${relative}.oml`;
+    return URI.from({
+        scheme: reference.scheme,
+        authority: reference.authority,
+        path: targetPath,
+        query: reference.query,
+        fragment: undefined
+    }).toString();
+}
+function createOntologyAst(ontologyKind, namespace, prefix) {
+    switch (ontologyKind) {
+        case 'vocabulary':
+            return {
+                $type: 'Vocabulary',
+                namespace,
+                prefix,
+                ownedAnnotations: [],
+                ownedImports: [],
+                ownedStatements: []
+            };
+        case 'description':
+            return {
+                $type: 'Description',
+                namespace,
+                prefix,
+                ownedAnnotations: [],
+                ownedImports: [],
+                ownedStatements: []
+            };
+        case 'vocabulary bundle':
+            return {
+                $type: 'VocabularyBundle',
+                namespace,
+                prefix,
+                ownedAnnotations: [],
+                ownedImports: []
+            };
+        case 'description bundle':
+            return {
+                $type: 'DescriptionBundle',
+                namespace,
+                prefix,
+                ownedAnnotations: [],
+                ownedImports: []
+            };
+        default:
+            throw new Error(`Unsupported ontology kind '${ontologyKind}'.`);
+    }
 }
 async function restoreContextsFromDocuments(shared, contexts) {
     const uris = [...new Set([...contexts.values()].map((context) => URI.parse(context.modelUri)))];
+    const langiumDocuments = shared.workspace.LangiumDocuments;
+    // Langium skips re-parsing when the on-disk text matches the CST text stored in the
+    // current parseResult. Preview modifies the AST in-place without changing the file, so
+    // the texts are still equal and the optimisation would keep the modified AST. Clearing
+    // $cstNode forces oldText to be undefined, guaranteeing a fresh parse from disk.
+    for (const context of contexts.values()) {
+        const doc = langiumDocuments.getDocument(URI.parse(context.modelUri));
+        const root = doc?.parseResult?.value;
+        if (root) {
+            root.$cstNode = undefined;
+        }
+    }
     if (uris.length > 0) {
         await shared.workspace.DocumentBuilder.update(uris, []);
     }
-    const langiumDocuments = shared.workspace.LangiumDocuments;
     for (const context of contexts.values()) {
         const refreshed = langiumDocuments.getDocument(URI.parse(context.modelUri))
             ?? await langiumDocuments.getOrCreateDocument(URI.parse(context.modelUri));