@oml/language 0.14.17 → 0.15.0

package/src/oml/oml-update.ts

@@ -6,6 +6,7 @@ import {
     isAnnotation,
     isConceptInstance,
     isDescription,
+    isDescriptionBundle,
     isDescriptionBox,
     isImport,
     isOntology,
@@ -20,9 +21,20 @@ import { getOntologyModelIndex } from './oml-index.js';
 import { serializeOntology } from './oml-serializer.js';
 import {
     collectOntologyMembers,
+    expandRefTextToIri,
     findOntologyMemberByName,
+    getLocalNameForNamespace,
+    getRefText,
     getIriForNode,
+    isSameIriTarget,
+    localNameFromRefText,
+    normalizeIri,
     normalizeNamespace,
+    parseIriParts,
+    pickImportPrefix,
+    resolveImportNamespaceRaw,
+    resolveImportPrefix,
+    withNamespaceSeparator,
 } from './oml-utils.js';
 
 type ConnectionLike = {
@@ -32,56 +44,122 @@ type ConnectionLike = {
     };
 };
 
-const OmlEditRequestType = new RequestType<OmlEditRequest, OmlEditResponse, void>('oml/update');
+const OmlUpdateRequestType = new RequestType<OmlUpdateRequest, OmlUpdateResponse, 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 }
-    | { 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: 'updateAssertion'; ontologyIri: string; subjectIri: string; predicateIri: string; object: unknown }
-    | { kind: 'removeAssertion'; ontologyIri: string; subjectIri: string; predicateIri: string; object?: unknown }
+type OmlUpdateOperation =
+    | { kind: 'createInstance'; descriptionIri: string; instanceName: string }
+    | { kind: 'createRelationInstance'; descriptionIri: string; instanceName: string }
+    | { kind: 'createInstanceRef'; descriptionIri: string; instanceIri: string; typeIri?: string }
+    | { kind: 'createRelationInstanceRef'; descriptionIri: string; instanceIri: string; typeIri?: string }
+    | { kind: 'addAssertion'; descriptionIri: string; subjectIri: string; predicateIri: string; object: unknown }
+    | { kind: 'updateAssertion'; descriptionIri: string; subjectIri: string; predicateIri: string; object: unknown }
+    | { kind: 'removeAssertion'; descriptionIri: string; subjectIri: string; predicateIri: string; object?: unknown }
     | { kind: 'addAnnotation'; ontologyIri: string; subjectIri: string; predicateIri: string; object: unknown }
     | { kind: 'updateAnnotation'; 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 };
+    | { kind: 'deleteMemberRef'; ontologyIri: string; memberIri: string; typeIri?: string }
+    | { kind: 'deleteOntology'; ontologyIri: string }
+    | { kind: 'addImport'; importingIri: string; importedIri: string }
+    | { kind: 'removeImport'; importingIri: string; importedIri: string }
+    | {
+        kind: 'createOntology';
+        ontologyKind: 'vocabulary' | 'description' | 'vocabulary bundle' | 'description bundle';
+        ontologyNamespace: string;
+        ontologyPrefix: string;
+        targetFolder?: string;
+    };
 
-export type OmlEditRequest = {
-    operations: OmlEditOperation[];
+export type OmlUpdateRequest = {
+    operations: OmlUpdateOperation[];
     referencingUri?: string;
 };
 
-export type OmlEditError = {
+export type OmlUpdateError = {
     operationIndex: number;
     message: string;
 };
 
-export type OmlEditResponse = {
+export type OmlUpdateResponse = {
     edit?: WorkspaceEdit;
-    errors?: OmlEditError[];
+    errors?: OmlUpdateError[];
 };
 
 export async function applyOmlUpdate(
     shared: any,
-    params: OmlEditRequest,
+    params: OmlUpdateRequest,
     logError?: (message: string) => void,
-): Promise<OmlEditResponse> {
+    workspaceUri?: string,
+    preview?: boolean,
+): Promise<OmlUpdateResponse> {
     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>();
+    const createdOntologyByIri = new Map<string, CreatedOntology>();
+    const deletedOntologyModelUriByIri = new Map<string, string>();
     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);
@@ -92,7 +170,7 @@ export async function applyOmlUpdate(
             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,
@@ -101,13 +179,40 @@ export async function applyOmlUpdate(
             };
         }
     }
-    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: ConnectionLike, shared: any): void {
-    connection.onRequest(OmlEditRequestType, async (params: OmlEditRequest): Promise<OmlEditResponse> => {
-        return await applyOmlUpdate(shared, params, (message) => connection.console?.error(message));
+function resolveModelUriFromLoadedDocuments(shared: any, ontologyIri: string): string | undefined {
+    const normalized = normalizeOntologyIriKey(ontologyIri);
+    const documentsService: any = shared.workspace.LangiumDocuments;
+    const all = documentsService?.all ?? [];
+    const iterable: any[] = Array.isArray(all)
+        ? all
+        : (typeof all?.toArray === 'function' ? all.toArray() : Array.from(all as Iterable<any>));
+    for (const document of iterable) {
+        const root = document?.parseResult?.value;
+        if (!root || !isOntology(root)) {
+            continue;
+        }
+        const namespace = normalizeNamespace(String((root as any).namespace ?? ''));
+        if (!namespace) {
+            continue;
+        }
+        if (normalizeOntologyIriKey(namespace) === normalized) {
+            return String(document.uri);
+        }
+    }
+    return undefined;
+}
+
+export function registerOmlUpdateRequests(connection: ConnectionLike, shared: any): void {
+    connection.onRequest(OmlUpdateRequestType, async (params: OmlUpdateRequest): Promise<OmlUpdateResponse> => {
+        return await applyOmlUpdate(shared, params, (message) => connection.console?.error(message), params.referencingUri);
     });
 }
 
@@ -118,13 +223,34 @@ type OntologyContext = {
     document: any;
 };
 
+function getOperationTargetOntologyIri(operation: OmlUpdateOperation): string {
+    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 as any).kind}'.`);
+    }
+}
+
 async function resolveOntologyContext(
     shared: any,
     ontologyIri: string,
     cache: Map<string, OntologyContext>,
     referencingUri?: string
 ): Promise<OntologyContext> {
-    const normalizedOntologyIri = normalizeIri(ontologyIri);
+    const normalizedOntologyIri = normalizeOntologyIriKey(ontologyIri);
     const cached = cache.get(normalizedOntologyIri);
     if (cached) {
         return cached;
@@ -157,7 +283,7 @@ async function resolveOntologyContext(
 async function executeOperation(
     shared: any,
     context: OntologyContext,
-    operation: OmlEditOperation,
+    operation: OmlUpdateOperation,
     contexts: Map<string, OntologyContext>
 ): Promise<ReadonlySet<string>> {
     switch (operation.kind) {
@@ -1064,93 +1190,6 @@ function toRefText(ontology: any, iri: string): string {
     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}`;
-}
-
 async function ensureReferenceImport(shared: any, ontology: any, iri: string): Promise<void> {
     const target = parseIriParts(iri);
     if (!target) {
@@ -1161,23 +1200,28 @@ async function ensureReferenceImport(shared: any, ontology: any, iri: string): P
         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 p = resolveImportPrefix(imp);
+        if (p) {
+            usedPrefixes.add(p);
+        }
+    }
+    const existingImport = imports.find((imp: any) => {
+        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}>`;
@@ -1191,15 +1235,97 @@ async function ensureReferenceImport(shared: any, ontology: any, iri: string): P
     pushAstArrayChild(ontology, 'ownedImports', importStatement);
 }
 
-async function resolveImportKind(shared: any, importing: any, importedNamespace: string): Promise<'extends' | 'includes' | 'uses'> {
-    const imported = await findOntologyByNamespace(shared, importedNamespace);
+async function addImport(shared: any, importingOntology: any, importedOntology: any): Promise<boolean> {
+    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: any) => {
+        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<string>();
+    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: string | undefined;
+    if (importKind !== 'includes') {
+        const candidatePrefix = typeof importedOntology?.prefix === 'string' ? importedOntology.prefix.trim() : '';
+        prefix = candidatePrefix && !usedPrefixes.has(candidatePrefix)
+            ? candidatePrefix
+            : pickImportPrefix(importedNamespace, usedPrefixes);
+    }
+    const importStatement: any = {
+        $type: 'Import',
+        kind: importKind,
+        ...(prefix ? { prefix } : {}),
+        imported: { $refText: importedRef }
+    };
+    pushAstArrayChild(importingOntology, 'ownedImports', importStatement);
+    return true;
+}
+
+function removeImport(importingOntology: any, importedOntology: any): boolean {
+    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: any) => {
+        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: any, importing: any, importedNamespace: string, importedOntology?: any): Promise<'extends' | 'includes' | 'uses'> {
+    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';
         }
@@ -1232,43 +1358,6 @@ async function findOntologyByNamespace(shared: any, namespace: string): Promise<
     return ontology && isOntology(ontology) ? ontology : undefined;
 }
 
-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,
@@ -1328,59 +1417,6 @@ function matchesRefTextFragment(statement: any, fragment: string): boolean {
     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(ontology: any, value: unknown): any {
     if (isTypedQuotedLiteralTransport(value)) {
         const literalValue = String(value.value ?? '');
@@ -1541,8 +1577,8 @@ function isIriLike(value: unknown): boolean {
     return trimmed.includes('://');
 }
 
-function normalizeIri(value: string): string {
-    return String(value ?? '').trim().replace(/^<|>$/g, '');
+function normalizeOntologyIriKey(value: string): string {
+    return normalizeNamespace(normalizeIri(value));
 }
 
 function normalizePropertyAssertionGroup(subject: any, target: any, duplicates: any[]): void {
@@ -1662,17 +1698,26 @@ function isTargetPredicate(predicateIri: string): boolean {
 
 function buildWorkspaceEdit(
     contexts: Map<string, OntologyContext>,
-    changedOntologyIris: ReadonlySet<string>
+    changedOntologyIris: ReadonlySet<string>,
+    createdOntologyByIri: ReadonlyMap<string, CreatedOntology>,
+    deletedOntologyModelUriByIri: ReadonlyMap<string, string>
 ): WorkspaceEdit | undefined {
-    if (changedOntologyIris.size === 0) {
+    if (changedOntologyIris.size === 0 && createdOntologyByIri.size === 0 && deletedOntologyModelUriByIri.size === 0) {
         return undefined;
     }
     const changes: NonNullable<WorkspaceEdit['changes']> = {};
+    const deletedModelUris = new Set<string>([...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) {
@@ -1687,15 +1732,206 @@ function buildWorkspaceEdit(
             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' as const, 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 };
+}
+
+type CreatedOntology = {
+    ontologyIri: string;
+    modelUri: string;
+    content: string;
+    ontology: any;
+};
+
+function detectOmlSrcDocument(shared: any): string | undefined {
+    const documentsService: any = shared.workspace.LangiumDocuments;
+    const all = documentsService?.all ?? [];
+    const iterable: any[] = Array.isArray(all)
+        ? all
+        : (typeof all?.toArray === 'function' ? all.toArray() : Array.from(all as Iterable<any>));
+    for (const document of iterable) {
+        const uri = String(document?.uri ?? '');
+        if (uri.includes('/oml/')) {
+            return uri;
+        }
+    }
+    return undefined;
+}
+
+async function createOntologyOperation(
+    shared: any,
+    operation: Extract<OmlUpdateOperation, { kind: 'createOntology' }>,
+    workspaceUri?: string
+): Promise<CreatedOntology> {
+    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 as any);
+    return {
+        ontologyIri,
+        modelUri,
+        content,
+        ontology
+    };
+}
+
+function deriveNewOntologyModelUri(namespaceCore: string, referencingUri?: string, targetFolder?: string, workspaceUri?: string): string {
+    let namespaceUrl: URL;
+    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: URI;
+    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: 'vocabulary' | 'description' | 'vocabulary bundle' | 'description bundle',
+    namespace: string,
+    prefix: string
+): any {
+    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 as any)}'.`);
+    }
 }
 
 async function restoreContextsFromDocuments(shared: any, contexts: Map<string, OntologyContext>): Promise<void> {
     const uris = [...new Set([...contexts.values()].map((context) => URI.parse(context.modelUri)))];
+    const langiumDocuments: any = 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 as any;
+        if (root) {
+            root.$cstNode = undefined;
+        }
+    }
     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));