@oml/language 0.7.0

package/src/oml/generated/module.ts

@@ -0,0 +1,25 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.1.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+import type { LangiumSharedCoreServices, LangiumCoreServices, LangiumGeneratedCoreServices, LangiumGeneratedSharedCoreServices, LanguageMetaData, Module } from 'langium';
+import { OmlAstReflection } from './ast.js';
+import { OmlGrammar } from './grammar.js';
+
+export const OmlLanguageMetaData = {
+    languageId: 'oml',
+    fileExtensions: ['.oml'],
+    caseInsensitive: false,
+    mode: 'development'
+} as const satisfies LanguageMetaData;
+
+export const OmlGeneratedSharedModule: Module<LangiumSharedCoreServices, LangiumGeneratedSharedCoreServices> = {
+    AstReflection: () => new OmlAstReflection()
+};
+
+export const OmlGeneratedModule: Module<LangiumCoreServices, LangiumGeneratedCoreServices> = {
+    Grammar: () => OmlGrammar(),
+    LanguageMetaData: () => OmlLanguageMetaData,
+    parser: {}
+};

package/src/oml/index.ts

@@ -0,0 +1,19 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export * from './oml-module.js';
+export * from './oml-candidates.js';
+export * from './oml-completion.js';
+export * from './oml-converter.js';
+export * from './oml-edit.js';
+export * from './oml-formatter.js';
+export * from './oml-hover.js';
+export * from './oml-index.js';
+export * from './oml-rename.js';
+export * from './oml-serializer.js';
+export * from './oml-scope.js';
+export * from './oml-validator.js';
+export * from './oml-utils.js';
+export * from './oml-workspace.js';
+export * from './generated/ast.js';
+export * from './generated/grammar.js';
+export * from './generated/module.js';

package/src/oml/oml-candidates.ts

@@ -0,0 +1,176 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { URI, stream, type AstNodeDescription, type AstNodeLocator, type IndexManager, type LangiumDocuments, type Stream } from 'langium';
+import { isConceptInstance, isMember, isRelationInstance } from './generated/ast.js';
+import { getIriForNode, getWorkspaceSnapshot } from './oml-utils.js';
+
+export const OmlCandidatesRequest = 'oml/candidates';
+
+export interface OmlCandidatesParams {
+    referenceType: string;
+}
+
+export interface OmlCandidatesResult {
+    candidates: string[];
+}
+
+const MaxReferenceTypeCaches = 64;
+const workspacePreloadState = new WeakMap<object, { completed: boolean; promise?: Promise<void> }>();
+
+type ConnectionLike = {
+    onRequest: (type: string, handler: (params: OmlCandidatesParams) => OmlCandidatesResult | Promise<OmlCandidatesResult>) => void;
+};
+
+export class OmlCandidates {
+    private readonly referenceCandidatesCache = new Map<string, { snapshot: string; candidates: AstNodeDescription[] }>();
+    private readonly workspaceCandidateIrisCache = new Map<string, { snapshot: string; candidates: string[] }>();
+
+    constructor(
+        private readonly indexManager: IndexManager,
+        private readonly langiumDocuments: LangiumDocuments,
+        private readonly astNodeLocator: AstNodeLocator,
+    ) {}
+
+    getReferenceCandidates(referenceType: string, linkable: Stream<AstNodeDescription>): Stream<AstNodeDescription> {
+        const workspace = stream(this.getWorkspaceCandidates(referenceType));
+        return linkable.concat(workspace).distinct((desc) => `${desc.documentUri.toString()}|${desc.path}|${desc.name}`);
+    }
+
+    getWorkspaceCandidateIris(referenceType: string): string[] {
+        const normalizedReferenceType = referenceType.trim();
+        if (!normalizedReferenceType) {
+            return [];
+        }
+        const snapshot = getWorkspaceSnapshot(this.langiumDocuments);
+        const cached = this.workspaceCandidateIrisCache.get(normalizedReferenceType);
+        if (cached && cached.snapshot === snapshot) {
+            return cached.candidates;
+        }
+        const workspace = this.getWorkspaceCandidates(normalizedReferenceType);
+        const iris: string[] = [];
+        for (const description of workspace) {
+            const node = this.resolveDescriptionNode(description);
+            const iri = this.resolveNodeIri(node);
+            if (iri) {
+                iris.push(iri);
+            }
+        }
+        const candidates = [...new Set(iris)];
+        this.workspaceCandidateIrisCache.set(normalizedReferenceType, { snapshot, candidates });
+        this.pruneCache(this.workspaceCandidateIrisCache, MaxReferenceTypeCaches);
+        return candidates;
+    }
+
+    private getWorkspaceCandidates(referenceType: string): AstNodeDescription[] {
+        const snapshot = getWorkspaceSnapshot(this.langiumDocuments);
+        const cached = this.referenceCandidatesCache.get(referenceType);
+        if (cached && cached.snapshot === snapshot) {
+            return cached.candidates;
+        }
+        const candidates = this.indexManager.allElements(referenceType).toArray();
+        this.referenceCandidatesCache.set(referenceType, { snapshot, candidates });
+        this.pruneCache(this.referenceCandidatesCache, MaxReferenceTypeCaches);
+        return candidates;
+    }
+
+    private resolveNodeIri(node: unknown): string | undefined {
+        if (isMember(node)) {
+            const iri = getIriForNode(node);
+            if (iri) {
+                return iri;
+            }
+        }
+        if (isConceptInstance(node) || isRelationInstance(node)) {
+            const refText = node.ref?.$refText;
+            if (typeof refText === 'string' && refText.trim().length > 0) {
+                return refText.replace(/^<|>$/g, '').trim();
+            }
+        }
+        return undefined;
+    }
+
+    private resolveDescriptionNode(description: AstNodeDescription): unknown {
+        if (description.node) {
+            return description.node;
+        }
+        const document = this.langiumDocuments.getDocument(description.documentUri);
+        const root = document?.parseResult?.value;
+        if (!root) {
+            return undefined;
+        }
+        return this.astNodeLocator.getAstNode(root, description.path);
+    }
+
+    private pruneCache<T>(cache: Map<string, T>, maxSize: number): void {
+        if (cache.size <= maxSize) {
+            return;
+        }
+        const overflow = cache.size - maxSize;
+        const keys = cache.keys();
+        for (let i = 0; i < overflow; i += 1) {
+            const next = keys.next();
+            if (next.done) {
+                break;
+            }
+            cache.delete(next.value);
+        }
+    }
+}
+
+export function registerOmlCandidatesRequests(connection: ConnectionLike, shared: any): void {
+    const candidates = new OmlCandidates(
+        shared.workspace.IndexManager,
+        shared.workspace.LangiumDocuments,
+        shared.workspace.AstNodeLocator
+    );
+    connection.onRequest(OmlCandidatesRequest, async (params: OmlCandidatesParams): Promise<OmlCandidatesResult> => {
+        await ensureWorkspaceIndexed(shared);
+        const referenceType = (params?.referenceType ?? '').trim();
+        if (!referenceType) {
+            return { candidates: [] };
+        }
+        return { candidates: candidates.getWorkspaceCandidateIris(referenceType) };
+    });
+}
+
+async function ensureWorkspaceIndexed(shared: any): Promise<void> {
+    const key = shared as object;
+    const existing = workspacePreloadState.get(key);
+    if (existing?.completed) {
+        return;
+    }
+    if (existing?.promise) {
+        await existing.promise;
+        return;
+    }
+    const state = existing ?? { completed: false };
+    const promise = (async () => {
+        const workspace = shared.workspace.WorkspaceManager;
+        const documents = shared.workspace.LangiumDocuments;
+        const builder = shared.workspace.DocumentBuilder;
+        await workspace.ready;
+        const folderUris = workspace.workspaceFolders ?? [];
+        const omlUris = new Set<string>();
+        for (const folder of folderUris) {
+            const entries = await workspace.searchFolder(URI.parse(folder.uri));
+            for (const entry of entries) {
+                const entryUri = entry.toString();
+                if (entryUri.toLowerCase().endsWith('.oml')) {
+                    omlUris.add(entryUri);
+                }
+            }
+        }
+        if (omlUris.size > 0) {
+            const docs = await Promise.all(
+                [...omlUris].map((uri) => documents.getOrCreateDocument(URI.parse(uri)))
+            );
+            await builder.build(docs, { validation: { categories: ['built-in', 'fast'] } });
+        }
+        state.completed = true;
+    })().finally(() => {
+        state.promise = undefined;
+    });
+    state.promise = promise;
+    workspacePreloadState.set(key, state);
+    await promise;
+}

package/src/oml/oml-code-actions.ts

@@ -0,0 +1,120 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type { LangiumDocument, MaybePromise } from 'langium';
+import type { CodeActionProvider } from 'langium/lsp';
+import { CodeActionKind } from 'vscode-languageserver';
+import type { CodeAction, CodeActionParams, Command, Range } from 'vscode-languageserver';
+import { OmlEmptyDocumentDiagnosticCode } from './oml-document-validator.js';
+
+export class OmlCodeActionProvider implements CodeActionProvider {
+    getCodeActions(document: LangiumDocument, params: CodeActionParams): MaybePromise<Array<Command | CodeAction> | undefined> {
+        const hasEmptyDocumentDiagnostic = params.context.diagnostics.some(diagnostic =>
+            diagnostic.data?.code === OmlEmptyDocumentDiagnosticCode || diagnostic.code === OmlEmptyDocumentDiagnosticCode
+        );
+        if (!hasEmptyDocumentDiagnostic) {
+            return [];
+        }
+
+        const initializer = deriveOntologyInitializer(document.textDocument.uri);
+        if (!initializer) {
+            return [];
+        }
+
+        const text = document.textDocument.getText();
+        const replaceRange: Range = {
+            start: document.textDocument.positionAt(0),
+            end: document.textDocument.positionAt(text.length)
+        };
+
+        return [
+            createInitializeCodeAction(
+                document.textDocument.uri,
+                replaceRange,
+                `Initialize as description`,
+                renderOntologyStub('description', initializer.iri, initializer.prefix)
+            ),
+            createInitializeCodeAction(
+                document.textDocument.uri,
+                replaceRange,
+                `Initialize as vocabulary`,
+                renderOntologyStub('vocabulary', initializer.iri, initializer.prefix)
+            ),
+            createInitializeCodeAction(
+                document.textDocument.uri,
+                replaceRange,
+                `Initialize as description bundle`,
+                renderOntologyStub('description bundle', initializer.iri, initializer.prefix)
+            ),
+            createInitializeCodeAction(
+                document.textDocument.uri,
+                replaceRange,
+                `Initialize as vocabulary bundle`,
+                renderOntologyStub('vocabulary bundle', initializer.iri, initializer.prefix)
+            )
+        ];
+    }
+}
+
+function createInitializeCodeAction(uri: string, range: Range, title: string, newText: string): CodeAction {
+    return {
+        title,
+        kind: CodeActionKind.QuickFix,
+        edit: {
+            changes: {
+                [uri]: [{
+                    range,
+                    newText
+                }]
+            }
+        }
+    };
+}
+
+function renderOntologyStub(
+    kind: 'description' | 'vocabulary' | 'description bundle' | 'vocabulary bundle',
+    iri: string,
+    prefix: string
+): string {
+    return `${kind} <${iri}> as ${prefix} {\n}\n`;
+}
+
+function deriveOntologyInitializer(uri: string): { iri: string; prefix: string } | undefined {
+    let parsed: URL;
+    try {
+        parsed = new URL(uri);
+    } catch {
+        return undefined;
+    }
+
+    const decodedPath = decodeURIComponent(parsed.pathname);
+    const omlMarker = '/oml/';
+    const markerIndex = decodedPath.lastIndexOf(omlMarker);
+    if (markerIndex < 0) {
+        return undefined;
+    }
+
+    const relativePath = decodedPath.slice(markerIndex + omlMarker.length);
+    if (!relativePath.endsWith('.oml')) {
+        return undefined;
+    }
+
+    const withoutExtension = relativePath.slice(0, -'.oml'.length);
+    const segments = withoutExtension.split('/').filter(Boolean);
+    if (segments.length === 0) {
+        return undefined;
+    }
+
+    const prefix = sanitizePrefix(segments[segments.length - 1]);
+    if (!prefix) {
+        return undefined;
+    }
+
+    return {
+        iri: `http://${segments.join('/')}#`,
+        prefix
+    };
+}
+
+function sanitizePrefix(value: string): string {
+    return value.replace(/[^A-Za-z0-9_-]/g, '').trim();
+}

package/src/oml/oml-completion.ts

@@ -0,0 +1,222 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type { AstNodeDescription, ReferenceInfo, Stream, LangiumDocuments, AstNodeLocator, IndexManager } from 'langium';
+import type { CompletionItem, TextEdit } from 'vscode-languageserver-types';
+import { DefaultCompletionProvider, type CompletionContext, type CompletionValueItem, type LangiumServices } from 'langium/lsp';
+import { Element, isDescription, isDescriptionBox, isMember, isOntology, isVocabulary, isVocabularyBundle, Member, Ontology } from './generated/ast.js';
+import { getLangiumDocumentVersion } from './oml-utils.js';
+import { OmlCandidates } from './oml-candidates.js';
+
+interface PreparedCompletionContext {
+    key: string;
+    ontology: Ontology;
+    importsByNamespace: Map<string, { prefix?: string }>;
+    importInsertOffset: number;
+}
+
+/**
+ * OML Completion Provider - Grammar-aware completions using Langium LSP
+ * Extends Langium's DefaultCompletionProvider to customize completion behavior for OML
+ */
+export class OmlCompletionProvider extends DefaultCompletionProvider {
+    private static readonly MaxResolvedMemberCaches = 5000;
+    protected readonly indexManager: IndexManager;
+    protected readonly langiumDocuments: LangiumDocuments;
+    protected readonly astNodeLocator: AstNodeLocator;
+    private readonly candidates: OmlCandidates;
+    private readonly resolvedMemberCache = new Map<string, Member | null>();
+    private preparedCompletionContext?: PreparedCompletionContext;
+
+    constructor(services: LangiumServices) {
+        super(services);
+        this.indexManager = services.shared.workspace.IndexManager;
+        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+        this.astNodeLocator = services.workspace.AstNodeLocator;
+        this.candidates = new OmlCandidates(this.indexManager, this.langiumDocuments, this.astNodeLocator);
+    }
+
+    /**
+     * Get reference candidates - include both local definitions and imported IRIs
+     * Local definitions don't start with '<', imported ones do
+     */
+    protected override getReferenceCandidates(refInfo: ReferenceInfo, _context: CompletionContext): Stream<AstNodeDescription> {
+        const referenceType = this.astReflection.getReferenceType(refInfo);
+        const linkable = this.scopeProvider.getScope(refInfo).getAllElements();
+        return this.candidates.getReferenceCandidates(referenceType, linkable);
+    }
+
+    /**
+     * Customize completion text edit to replace the entire token
+     */
+    protected override buildCompletionTextEdit(context: CompletionContext, _label: string, newText: string): TextEdit | undefined {
+        const start = context.textDocument.positionAt(context.tokenOffset);
+        const end = context.position;
+        return { newText, range: { start, end } };
+    }
+
+    /**
+     * Fill completion item with OML-specific details:
+     * - Show abbreviated IRIs (prefix:name) instead of full IRIs
+     * - Include namespace in detail
+     * - Auto-generate import statements for cross-file references
+     */
+    protected override fillCompletionItem(context: CompletionContext, item: CompletionValueItem): CompletionItem | undefined {
+        if ('nodeDescription' in item) {
+            const desc = item.nodeDescription;
+            const prepared = this.getPreparedCompletionContext(context);
+            if (!prepared) {
+                return super.fillCompletionItem(context, item);
+            }
+
+            // Check if this is a member reference (could be a cross-file reference)
+            const member = this.resolveMember(desc);
+            if (member) {
+                const [namespace, name] = this.getIri(member);
+                const ontology = prepared.ontology;
+
+                // Find existing import for this namespace
+                const imp = prepared.importsByNamespace.get(namespace);
+
+                const importedOntology = this.getOntology(member);
+                const prefix = (imp && imp.prefix) ? imp.prefix : importedOntology.prefix;
+
+                // Build abbreviated IRI: prefix:name (or just name if same ontology)
+                const abbreviatedIri = (ontology !== importedOntology && prefix) ? `${prefix}:${name}` : name;
+
+                item = { ...item, detail: namespace, label: abbreviatedIri };
+
+                // Auto-generate import statement if not already imported and from different ontology
+                if (!imp && ontology !== importedOntology) {
+                    const importStatement = this.getImportStatement(ontology, importedOntology);
+
+                    if (importStatement) {
+                        const start = context.textDocument.positionAt(prepared.importInsertOffset);
+                        const addImportStatement: TextEdit = {
+                            newText: '\n\n\t' + importStatement,
+                            range: { start, end: start }
+                        };
+
+                        item = { ...item, additionalTextEdits: [addImportStatement] };
+                    }
+                }
+            }
+        }
+        return super.fillCompletionItem(context, item);
+    }
+
+    protected resolveMember(desc: AstNodeDescription): Member | undefined {
+        if (desc.node && isMember(desc.node)) {
+            return desc.node as Member;
+        }
+        const doc = this.langiumDocuments.getDocument(desc.documentUri);
+        const root = doc?.parseResult?.value;
+        if (!root) {
+            return undefined;
+        }
+        const key = `${desc.documentUri.toString()}@${getLangiumDocumentVersion(doc)}|${desc.path}`;
+        const cached = this.resolvedMemberCache.get(key);
+        if (cached !== undefined) {
+            return cached ?? undefined;
+        }
+        const resolved = this.astNodeLocator.getAstNode(root, desc.path);
+        const member = resolved && isMember(resolved) ? (resolved as Member) : undefined;
+        this.resolvedMemberCache.set(key, member ?? null);
+        this.pruneCache(this.resolvedMemberCache, OmlCompletionProvider.MaxResolvedMemberCaches);
+        return member;
+    }
+
+    /**
+     * Extract IRI components (namespace and name) from a member
+     */
+    getIri(member: Member): [string, string] {
+        return [this.getOntology(member).namespace.replace(/^<|>$/g, ''), member.name!];
+    }
+
+    /**
+     * Get the ontology containing an element
+     */
+    getOntology(element: Element): Ontology {
+        while (element && !isOntology(element)) {
+            element = (element as any).$container;
+        }
+        return element as Ontology;
+    }
+
+    /**
+     * Generate appropriate import statement based on ontology types
+     */
+    getImportStatement(importing: Ontology, imported: Ontology): string | undefined {
+        const namespace = imported.namespace.replace(/^<|>$/g, '');
+        const prefixPart = imported.prefix ? ` as ${imported.prefix}` : '';
+
+        if (importing.$type === imported.$type) {
+            return `extends <${namespace}>${prefixPart}`;
+        } else if (isVocabulary(importing) && isDescription(imported)) {
+            return `uses <${namespace}>${prefixPart}`;
+        } else if (isDescriptionBox(importing) && isVocabulary(imported)) {
+            return `uses <${namespace}>${prefixPart}`;
+        } else if (isVocabularyBundle(importing) && isVocabulary(imported)) {
+            return `includes <${namespace}>${prefixPart}`;
+        }
+        return undefined;
+    }
+
+    private getImportNamespace(ownedImport: any): string {
+        const raw = ownedImport?.imported?.$refText ?? ownedImport?.imported ?? '';
+        return typeof raw === 'string' ? raw.replace(/^<|>$/g, '') : '';
+    }
+
+    private getPreparedCompletionContext(context: CompletionContext): PreparedCompletionContext | undefined {
+        const ontology = context.document.parseResult?.value;
+        if (!ontology || !isOntology(ontology)) {
+            return undefined;
+        }
+        const uri = context.document.uri?.toString() ?? context.textDocument.uri;
+        const version = context.textDocument.version ?? 0;
+        const key = `${uri}@${version}@${context.tokenOffset}`;
+        if (this.preparedCompletionContext?.key === key) {
+            return this.preparedCompletionContext;
+        }
+
+        const importsByNamespace = new Map<string, { prefix?: string }>();
+        for (const ownedImport of ontology.ownedImports ?? []) {
+            const ns = this.getImportNamespace(ownedImport);
+            if (!ns || importsByNamespace.has(ns)) {
+                continue;
+            }
+            importsByNamespace.set(ns, { prefix: ownedImport.prefix });
+        }
+
+        const lastImport = ontology.ownedImports?.at(-1);
+        let importInsertOffset = 0;
+        if (lastImport?.$cstNode) {
+            importInsertOffset = lastImport.$cstNode.offset + lastImport.$cstNode.length;
+        } else {
+            const openBrace = context.textDocument.getText().indexOf('{');
+            importInsertOffset = openBrace >= 0 ? openBrace + 1 : 0;
+        }
+
+        this.preparedCompletionContext = {
+            key,
+            ontology,
+            importsByNamespace,
+            importInsertOffset
+        };
+        return this.preparedCompletionContext;
+    }
+
+    private pruneCache<T>(cache: Map<string, T>, maxSize: number): void {
+        if (cache.size <= maxSize) {
+            return;
+        }
+        const overflow = cache.size - maxSize;
+        const keys = cache.keys();
+        for (let i = 0; i < overflow; i += 1) {
+            const next = keys.next();
+            if (next.done) {
+                break;
+            }
+            cache.delete(next.value);
+        }
+    }
+}

package/src/oml/oml-converter.ts

@@ -0,0 +1,66 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { DefaultValueConverter, GrammarAST } from 'langium';
+import type { CstNode, ValueType } from 'langium';
+
+/**
+ * Normalizes NAMESPACE tokens by stripping surrounding angle brackets when used via RuleCall.
+ * This ensures that namespace values stored in the AST are consistent and don't include the brackets.
+ */
+export class OmlValueConverter extends DefaultValueConverter {
+    protected override runConverter(rule: GrammarAST.AbstractRule, input: string, cstNode: CstNode): ValueType {
+        const source: any = (cstNode as any).grammarSource;
+        if (rule.name === 'NAMESPACE' && source?.$type === 'RuleCall') {
+            // Strip angle brackets from namespace: <http://example.com#> -> http://example.com#
+            return input.substring(1, input.length - 1);
+        }
+        if (rule.name === 'STRING') {
+            if (input.startsWith('"""')) {
+                const content = input.substring(3, input.length - 3);
+                return this.stripIndentation(content);
+            } else if (input.startsWith("'''")) {
+                const content = input.substring(3, input.length - 3);
+                return this.stripIndentation(content);
+            } else if (input.startsWith('"')) {
+                return input.substring(1, input.length - 1);
+            } else if (input.startsWith("'")) {
+                return input.substring(1, input.length - 1);
+            }
+            return input;
+        }
+        return super.runConverter(rule, input, cstNode);
+    }
+
+    private stripIndentation(content: string): string {
+        const lines = content.split(/\r?\n/);
+        if (lines.length <= 1) {
+            return content;
+        }
+        const tail = lines.slice(1);
+        let minIndent = Infinity;
+
+        for (const line of tail) {
+            if (line.trim().length === 0) {
+                continue;
+            }
+            const match = line.match(/^[ \t]*/);
+            const indent = match ? match[0].length : 0;
+            if (indent < minIndent) {
+                minIndent = indent;
+            }
+        }
+
+        if (minIndent === Infinity || minIndent === 0) {
+            return content;
+        }
+
+        const newLines = [lines[0], ...tail.map(line => {
+            if (line.trim().length === 0) {
+                return '';
+            }
+            return line.substring(minIndent);
+        })];
+
+        return newLines.join('\n');
+    }
+}

package/src/oml/oml-document-validator.ts

@@ -0,0 +1,39 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { DefaultDocumentValidator, type ValidationOptions } from 'langium';
+import type { LangiumDocument } from 'langium';
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import type { Diagnostic } from 'vscode-languageserver-types';
+import type { CancellationToken } from 'vscode-jsonrpc';
+import type { OmlServices } from './oml-module.js';
+
+export const OmlEmptyDocumentDiagnosticCode = 'oml/empty-document';
+
+export class OmlDocumentValidator extends DefaultDocumentValidator {
+    constructor(services: OmlServices) {
+        super(services);
+    }
+
+    override async validateDocument(document: LangiumDocument, options: ValidationOptions = {}, cancelToken?: CancellationToken): Promise<Diagnostic[]> {
+        if (document.textDocument.getText().trim().length === 0) {
+            return [createEmptyDocumentDiagnostic()];
+        }
+        return super.validateDocument(document, options, cancelToken);
+    }
+}
+
+function createEmptyDocumentDiagnostic(): Diagnostic {
+    return {
+        severity: DiagnosticSeverity.Error,
+        range: {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 0 }
+        },
+        message: 'Empty OML file. Initialize it as a description, vocabulary, description bundle, or vocabulary bundle.',
+        code: OmlEmptyDocumentDiagnosticCode,
+        data: {
+            code: OmlEmptyDocumentDiagnosticCode
+        },
+        source: 'oml'
+    };
+}