@oml/owl 0.7.0

package/src/owl/owl-service.ts

@@ -0,0 +1,642 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { DocumentState, URI, type LangiumDocument } from 'langium';
+import type { NamedNode, Quad } from 'n3';
+import { OntologyModelIndex, getOntologyModelIndex, isDescription, isDescriptionBundle, isOntology, isVocabulary, isVocabularyBundle, type Import, type OmlServices, type Ontology } from '@oml/language';
+import { Oml2OwlMapper } from './owl-mapper.js';
+import { ReasoningStore } from './owl-store.js';
+import { ABoxChainer, ABoxEntailmentCache, type ChainingResult } from './owl-abox.js';
+import { ImportGraph } from './owl-imports.js';
+import { SparqlService } from './owl-sparql.js';
+import { TBoxChainer, TBoxIndexBuilder, TBoxIndexCache } from './owl-tbox.js';
+import type {
+    OwlABoxChainer,
+    OwlABoxEntailmentState,
+    OwlImportGraph,
+    OwlMapper,
+    OwlReasoningDependencies,
+    OwlSparqlService,
+    OwlStore,
+    OwlTBoxChainer,
+    OwlTBoxIndexBuilder,
+    OwlTBoxIndexCache
+} from './owl-interfaces.js';
+
+export class ReasoningService {
+    private readonly services: OmlServices;
+    private readonly mapper: OwlMapper;
+    private readonly reasoningStore: OwlStore;
+    private readonly tboxChainer: OwlTBoxChainer;
+    private readonly tboxIndexBuilder: OwlTBoxIndexBuilder;
+    private readonly tboxIndexCache: OwlTBoxIndexCache;
+    private readonly aboxChainer: OwlABoxChainer;
+    private readonly aboxEntailmentCache: OwlABoxEntailmentState;
+    private readonly importGraph: OwlImportGraph;
+    private readonly sparqlService: OwlSparqlService;
+    private readonly ontologyModelIndex: OntologyModelIndex;
+    private readonly preparedModelAliases = new Map<string, string>();
+    private readonly activeDocuments = new Set<string>();
+    private readonly modelLoadInFlight = new Map<string, Promise<void>>();
+    private readonly semanticChangeListeners = new Set<(modelUris: string[]) => void>();
+    private workspaceBuildPromise: Promise<void> | undefined;
+    private workspaceBuilt = false;
+
+    constructor(services: OmlServices, dependencies: Partial<OwlReasoningDependencies> = {}) {
+        this.services = services;
+        const resolved = createDefaultDependencies(dependencies);
+        this.mapper = resolved.mapper;
+        this.reasoningStore = resolved.reasoningStore;
+        this.importGraph = resolved.importGraph;
+        this.tboxIndexCache = resolved.tboxIndexCache;
+        this.tboxChainer = resolved.tboxChainer;
+        this.tboxIndexBuilder = resolved.tboxIndexBuilder;
+        this.aboxChainer = resolved.aboxChainer;
+        this.aboxEntailmentCache = resolved.aboxEntailmentCache;
+        this.sparqlService = resolved.createSparqlService(this);
+        this.ontologyModelIndex = getOntologyModelIndex(services.shared);
+
+        services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Validated, (document) => {
+            this.onDocumentValidated(document);
+        });
+    }
+
+    onDocumentValidated(document: LangiumDocument): void {
+        const ontology = document.parseResult.value;
+        if (!isOntology(ontology)) {
+            return;
+        }
+
+        const modelUri = document.uri.toString();
+        const importedModelUris = this.extractImportedModelUris(ontology as Ontology);
+        this.importGraph.update(modelUri, importedModelUris);
+
+        const quads = this.mapper.toQuads(ontology as Ontology);
+        const diff = this.reasoningStore.diffModel(modelUri, quads);
+        if (diff.isEmpty) {
+            return;
+        }
+        this.tboxIndexCache.invalidateMerged(modelUri);
+        this.reasoningStore.retractModel(modelUri);
+        this.reasoningStore.loadModel(modelUri, quads);
+        const impactedByLoad = [modelUri, ...this.importGraph.dependentsOf(modelUri)];
+        for (const uri of impactedByLoad) {
+            this.sparqlService.invalidateFilteredStore(uri);
+        }
+        this.notifySemanticChanged(impactedByLoad);
+        if (isVocabulary(ontology)) {
+            this.tboxChainer.chain(modelUri);
+            const tboxIndex = this.tboxIndexBuilder.buildOwn(modelUri, ontology);
+            this.tboxIndexCache.setOwn(modelUri, tboxIndex);
+            const dependents = this.importGraph.dependentsOf(modelUri);
+            this.tboxIndexCache.invalidateMergedAll(dependents);
+            this.aboxEntailmentCache.markDirtyAll(dependents);
+            for (const dependent of dependents) {
+                if (!this.isActiveDocument(dependent)) {
+                    continue;
+                }
+                this.tboxIndexCache.setMerged(dependent, this.tboxIndexBuilder.buildMerged(dependent));
+            }
+        } else if (isVocabularyBundle(ontology)) {
+            const dependents = this.importGraph.dependentsOf(modelUri);
+            const affected = [modelUri, ...dependents];
+            this.tboxIndexCache.invalidateMergedAll(affected);
+            this.aboxEntailmentCache.markDirtyAll(affected);
+            for (const uri of affected) {
+                if (!this.isActiveDocument(uri)) {
+                    continue;
+                }
+                this.tboxIndexCache.setMerged(uri, this.tboxIndexBuilder.buildMerged(uri));
+            }
+        } else if (isDescription(ontology)) {
+            this.aboxEntailmentCache.markDirty(modelUri);
+        } else if (isDescriptionBundle(ontology)) {
+            const dependents = this.importGraph.dependentsOf(modelUri);
+            const affected = [modelUri, ...dependents];
+            this.tboxIndexCache.invalidateMergedAll(affected);
+            this.aboxEntailmentCache.markDirtyAll(affected);
+            for (const uri of affected) {
+                if (!this.isActiveDocument(uri)) {
+                    continue;
+                }
+                this.tboxIndexCache.setMerged(uri, this.tboxIndexBuilder.buildMerged(uri));
+            }
+        }
+    }
+
+    runInference(modelUri: string): ChainingResult {
+        const chainOrder = this.resolveLoadedDependencyOrder(modelUri);
+        let complete = true;
+        let iterations = 0;
+        let newQuadsCount = 0;
+        const chainedModels: string[] = [];
+
+        for (const chainedModelUri of chainOrder) {
+            const shouldChain =
+                this.aboxEntailmentCache.isDirty(chainedModelUri)
+                || (chainedModelUri === modelUri && this.aboxEntailmentCache.isAbsent(chainedModelUri));
+            if (!shouldChain) {
+                continue;
+            }
+
+            this.ensureOwnTboxIndexesForDependencies(chainedModelUri);
+            let merged = this.tboxIndexCache.getMerged(chainedModelUri);
+            if (!merged || this.tboxIndexCache.isMergedDirty(chainedModelUri)) {
+                merged = this.tboxIndexBuilder.buildMerged(chainedModelUri);
+                this.tboxIndexCache.setMerged(chainedModelUri, merged);
+            }
+
+            const readScope = this.resolveLoadedDependencyOrder(chainedModelUri);
+            const delta = this.aboxEntailmentCache.consumeDelta(chainedModelUri);
+            const result = this.aboxChainer.chain(chainedModelUri, merged, readScope, delta.plus, delta.minus);
+            this.aboxEntailmentCache.setValidationWarnings(chainedModelUri, result.validationWarnings);
+            chainedModels.push(chainedModelUri);
+            complete = complete && result.complete;
+            iterations += result.iterations;
+            newQuadsCount += result.newQuadsCount;
+            if (result.complete) {
+                this.aboxEntailmentCache.markClean(chainedModelUri);
+            } else {
+                this.aboxEntailmentCache.markDirty(chainedModelUri);
+            }
+        }
+
+        if (!chainedModels.includes(modelUri)) {
+            return { complete: true, iterations: 0, newQuadsCount: 0, validationWarnings: [] };
+        }
+        return { complete, iterations, newQuadsCount, validationWarnings: [] };
+    }
+
+    removeModel(modelUri: string): void {
+        const dependents = this.importGraph.dependentsOf(modelUri);
+        this.importGraph.remove(modelUri);
+        this.reasoningStore.retractModel(modelUri);
+        this.ontologyModelIndex.removeModel(modelUri);
+        this.tboxIndexCache.invalidateOwn(modelUri);
+        this.tboxIndexCache.invalidateMerged(modelUri);
+        this.aboxEntailmentCache.invalidate(modelUri);
+        this.tboxIndexCache.invalidateMergedAll(dependents);
+        this.aboxEntailmentCache.markDirtyAll(dependents);
+        this.sparqlService.removeFilteredStore(modelUri);
+        for (const dependent of dependents) {
+            this.sparqlService.invalidateFilteredStore(dependent);
+        }
+        this.notifySemanticChanged([modelUri, ...dependents]);
+        this.activeDocuments.delete(modelUri);
+    }
+
+    onSemanticChanged(listener: (modelUris: string[]) => void): () => void {
+        this.semanticChangeListeners.add(listener);
+        return () => {
+            this.semanticChangeListeners.delete(listener);
+        };
+    }
+
+    getStore(): OwlStore {
+        return this.reasoningStore;
+    }
+
+    getImportGraph(): OwlImportGraph {
+        return this.importGraph;
+    }
+
+    getSparqlService(): OwlSparqlService {
+        return {
+            invalidateFilteredStore: (modelUri: string) => {
+                this.sparqlService.invalidateFilteredStore(this.resolveQueryModelUri(modelUri));
+            },
+            removeFilteredStore: (modelUri: string) => {
+                this.sparqlService.removeFilteredStore(this.resolveQueryModelUri(modelUri));
+            },
+            query: (modelUri: string, sparql: string) => {
+                return this.sparqlService.query(this.resolveQueryModelUri(modelUri), sparql);
+            },
+            construct: (modelUri: string, sparql: string) => {
+                return this.sparqlService.construct(this.resolveQueryModelUri(modelUri), sparql);
+            },
+        };
+    }
+
+    loadPreparedDataset(models: ReadonlyArray<PreparedReasonedModel>): void {
+        this.preparedModelAliases.clear();
+        for (const model of models) {
+            this.preparedModelAliases.set(model.modelUri, model.modelUri);
+            for (const alias of model.aliases ?? []) {
+                this.preparedModelAliases.set(alias, model.modelUri);
+            }
+            this.importGraph.update(model.modelUri, [...model.imports]);
+            this.reasoningStore.loadModel(model.modelUri, [...model.assertedQuads]);
+            this.reasoningStore.loadEntailments(model.modelUri, [...model.entailedQuads]);
+            this.aboxEntailmentCache.markClean(model.modelUri);
+            this.aboxEntailmentCache.setValidationWarnings(model.modelUri, [...(model.validationWarnings ?? [])]);
+            this.sparqlService.invalidateFilteredStore(model.modelUri);
+        }
+        this.workspaceBuilt = true;
+        this.workspaceBuildPromise = undefined;
+    }
+
+    async ensureQueryContext(modelUri: string): Promise<void> {
+        const resolvedModelUri = this.resolveQueryModelUri(modelUri);
+        await this.ensureWorkspaceBuilt();
+        await this.ensureModelLoaded(resolvedModelUri);
+        await this.ensureContextDatasetReady(resolvedModelUri);
+    }
+
+    getContextIri(modelUri: string): string {
+        return this.resolveOntologyIriForModelUri(this.resolveQueryModelUri(modelUri));
+    }
+
+    setActiveDocuments(modelUris: string[]): void {
+        this.activeDocuments.clear();
+        for (const modelUri of modelUris) {
+            this.activeDocuments.add(modelUri);
+        }
+    }
+
+    markDocumentActive(modelUri: string): void {
+        this.activeDocuments.add(modelUri);
+    }
+
+    markDocumentInactive(modelUri: string): void {
+        this.activeDocuments.delete(modelUri);
+    }
+
+    private extractImportedModelUris(ontology: Ontology): string[] {
+        const prefixes = this.buildPrefixMap(ontology);
+        const imports = ontology.ownedImports ?? [];
+        const importedModelUris = imports
+            .map((ownedImport) => this.resolveImportedModelUri(ownedImport, prefixes))
+            .filter((uri): uri is string => Boolean(uri));
+        return [...new Set(importedModelUris)];
+    }
+
+    private resolveImportedModelUri(ownedImport: Import, prefixes: Map<string, string>): string | undefined {
+        if (ownedImport.imported?.ref && isOntology(ownedImport.imported.ref)) {
+            const importedDocumentUri = (ownedImport.imported.ref as any)?.$document?.uri?.toString();
+            if (importedDocumentUri) {
+                return importedDocumentUri;
+            }
+            const importedNamespace = this.normalizeNamespace((ownedImport.imported.ref as any).namespace ?? '');
+            return this.resolveModelUriFromOntologyIdentifier(importedNamespace);
+        }
+        const refText = (ownedImport.imported as any)?.$refText ?? (ownedImport.imported as any)?.refText;
+        if (!refText) {
+            return undefined;
+        }
+        const ontologyIdentifier = this.resolveFromRefText(refText, prefixes);
+        if (!ontologyIdentifier || BUILT_IN_ONTOLOGIES.has(ontologyIdentifier)) {
+            return undefined;
+        }
+        return this.resolveModelUriFromOntologyIdentifier(ontologyIdentifier);
+    }
+
+    private buildPrefixMap(ontology: Ontology): Map<string, string> {
+        const map = new Map<string, string>();
+        const ontologyPrefix = (ontology as any).prefix;
+        const ontologyNamespace = this.normalizeNamespace((ontology as any).namespace ?? '');
+        if (ontologyPrefix && ontologyNamespace) {
+            map.set(ontologyPrefix, ontologyNamespace);
+        }
+        for (const ownedImport of ontology.ownedImports ?? []) {
+            const imported = ownedImport.imported?.ref;
+            const importedPrefix = ownedImport.prefix ?? (imported as any)?.prefix;
+            const importedNamespace = imported ? this.normalizeNamespace((imported as any).namespace ?? '') : undefined;
+            if (importedPrefix && importedNamespace) {
+                map.set(importedPrefix, importedNamespace);
+            }
+        }
+        return map;
+    }
+
+    private resolveFromRefText(refText: string, prefixes: Map<string, string>): string | undefined {
+        if (refText.startsWith('<') && refText.endsWith('>')) {
+            return refText.slice(1, -1);
+        }
+        const parts = refText.split(':');
+        if (parts.length === 2) {
+            const namespace = prefixes.get(parts[0]);
+            if (namespace) {
+                return `${namespace}${parts[1]}`;
+            }
+        }
+        return undefined;
+    }
+
+    private normalizeNamespace(namespace: string): string {
+        return namespace.replace(/^<|>$/g, '');
+    }
+
+    private resolveModelUriFromOntologyIdentifier(identifier: string): string | undefined {
+        return this.ontologyModelIndex.resolveModelUri(identifier);
+    }
+
+    private resolveQueryModelUri(modelUri: string): string {
+        return this.resolveWorkspaceModelUri(modelUri) ?? modelUri;
+    }
+
+    private isActiveDocument(modelUri: string): boolean {
+        return this.activeDocuments.has(modelUri);
+    }
+
+    private resolveOntologyIriForModelUri(modelUri: string): string {
+        const resolvedModelUri = this.resolveWorkspaceModelUri(modelUri) ?? modelUri;
+        return this.ontologyModelIndex.resolveOntologyIri(resolvedModelUri)
+            ?? this.reasoningStore.graphs(resolvedModelUri).own.value;
+    }
+    private async ensureModelLoaded(modelUri: string): Promise<void> {
+        try {
+            this.reasoningStore.graphs(modelUri);
+            return;
+        } catch {
+            // fall through to on-demand load
+        }
+
+        const inFlight = this.modelLoadInFlight.get(modelUri);
+        if (inFlight) {
+            await inFlight;
+        } else {
+            const loadPromise = (async () => {
+                const uri = URI.parse(modelUri);
+                let document = this.services.shared.workspace.LangiumDocuments.getDocument(uri);
+                if (!document) {
+                    try {
+                        document = await this.services.shared.workspace.LangiumDocuments.getOrCreateDocument(uri);
+                    } catch {
+                        // Another concurrent caller may have created it first.
+                        document = this.services.shared.workspace.LangiumDocuments.getDocument(uri);
+                        if (!document) {
+                            throw new Error(`Unable to access model document '${modelUri}'.`);
+                        }
+                    }
+                }
+                await this.services.shared.workspace.DocumentBuilder.build([document], { validation: true });
+            })().finally(() => {
+                this.modelLoadInFlight.delete(modelUri);
+            });
+
+            this.modelLoadInFlight.set(modelUri, loadPromise);
+            await loadPromise;
+        }
+
+        try {
+            this.reasoningStore.graphs(modelUri);
+        } catch {
+            throw new Error(`Unknown model '${modelUri}'. Load the model first.`);
+        }
+    }
+
+    private async ensureWorkspaceBuilt(): Promise<void> {
+        if (this.workspaceBuilt) {
+            return;
+        }
+        if (this.workspaceBuildPromise) {
+            await this.workspaceBuildPromise;
+            return;
+        }
+
+        this.workspaceBuildPromise = (async () => {
+            const workspace = this.services.shared.workspace.WorkspaceManager;
+            const documents = this.services.shared.workspace.LangiumDocuments;
+            const builder = this.services.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 uri = entry.toString();
+                    if (uri.toLowerCase().endsWith('.oml')) {
+                        omlUris.add(uri);
+                    }
+                }
+            }
+
+            if (omlUris.size === 0) {
+                this.workspaceBuilt = true;
+                return;
+            }
+
+            const docs = await Promise.all(
+                [...omlUris].map((uri) => documents.getOrCreateDocument(URI.parse(uri)))
+            );
+            await builder.build(docs, { validation: true });
+            this.workspaceBuilt = true;
+        })().finally(() => {
+            this.workspaceBuildPromise = undefined;
+        });
+
+        await this.workspaceBuildPromise;
+    }
+
+    private async ensureContextDatasetReady(modelUri: string): Promise<void> {
+        const attemptedLoads = new Set<string>();
+
+        while (true) {
+            const allUris = [modelUri, ...this.importGraph.dependenciesOf(modelUri)];
+            const unresolvedIdentifiers: string[] = [];
+            const resolvedModelUris: string[] = [];
+            const seenResolved = new Set<string>();
+            for (const uri of allUris) {
+                const workspaceModelUri = this.resolveWorkspaceModelUri(uri);
+                if (!workspaceModelUri) {
+                    unresolvedIdentifiers.push(uri);
+                    continue;
+                }
+                if (!seenResolved.has(workspaceModelUri)) {
+                    seenResolved.add(workspaceModelUri);
+                    resolvedModelUris.push(workspaceModelUri);
+                }
+            }
+
+            const unloadedModelUris = resolvedModelUris.filter((uri) => !this.isModelLoaded(uri));
+            if (unresolvedIdentifiers.length === 0 && unloadedModelUris.length === 0) {
+                return;
+            }
+
+            const loadFailures: string[] = [];
+            let loadedAny = false;
+            for (const uri of unloadedModelUris) {
+                if (attemptedLoads.has(uri)) {
+                    continue;
+                }
+                attemptedLoads.add(uri);
+                try {
+                    await this.ensureModelLoaded(uri);
+                    loadedAny = true;
+                } catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    loadFailures.push(`${uri} (${message})`);
+                }
+            }
+            if (loadFailures.length > 0) {
+                throw new Error(
+                    `Context dataset could not include the full import closure for '${modelUri}'. `
+                    + `Failed to load models: ${loadFailures.join(', ')}`
+                );
+            }
+            if (loadedAny) {
+                continue;
+            }
+
+            const unresolved = [...new Set(unresolvedIdentifiers)];
+            const unloaded = [...new Set(unloadedModelUris)];
+            const details: string[] = [];
+            if (unresolved.length > 0) {
+                details.push(`unresolved imports: ${unresolved.join(', ')}`);
+            }
+            if (unloaded.length > 0) {
+                details.push(`unloaded models: ${unloaded.join(', ')}`);
+            }
+            throw new Error(
+                `Context dataset could not include the full import closure for '${modelUri}'. `
+                + `${details.join('; ')}`
+            );
+        }
+    }
+
+    async countContextDatasetQuads(modelUri: string): Promise<number> {
+        await this.ensureWorkspaceBuilt();
+        await this.ensureModelLoaded(modelUri);
+        await this.ensureContextDatasetReady(modelUri);
+        const store = this.reasoningStore.getStore();
+        const queryGraphs = this.resolveContextGraphs(modelUri);
+        let total = 0;
+        for (const graph of queryGraphs) {
+            total += store.countQuads(null, null, null, graph);
+        }
+        return total;
+    }
+
+    private resolveWorkspaceModelUri(uri: string): string | undefined {
+        const prepared = this.preparedModelAliases.get(uri);
+        if (prepared) {
+            return prepared;
+        }
+        if (isWorkspaceModelUri(uri)) {
+            return uri;
+        }
+        return this.ontologyModelIndex.resolveModelUri(uri);
+    }
+
+    private resolveLoadedDependencyOrder(modelUri: string): string[] {
+        const ordered = [...this.importGraph.dependenciesOf(modelUri), modelUri];
+        const seen = new Set<string>();
+        const resolved: string[] = [];
+        for (const uri of ordered) {
+            const model = this.resolveWorkspaceModelUri(uri);
+            if (!model || seen.has(model) || !this.isModelLoaded(model)) {
+                continue;
+            }
+            seen.add(model);
+            resolved.push(model);
+        }
+        return resolved;
+    }
+
+    private resolveContextGraphs(modelUri: string): NamedNode[] {
+        const seen = new Set<string>();
+        const graphs: NamedNode[] = [];
+        for (const uri of [...this.importGraph.dependenciesOf(modelUri), modelUri]) {
+            const modelGraphs = this.reasoningStore.graphs(uri);
+            if (!seen.has(modelGraphs.own.value)) {
+                seen.add(modelGraphs.own.value);
+                graphs.push(modelGraphs.own);
+            }
+        }
+        const ownGraphs = this.reasoningStore.graphs(modelUri);
+        if (!seen.has(ownGraphs.entailments.value)) {
+            seen.add(ownGraphs.entailments.value);
+            graphs.push(ownGraphs.entailments);
+        }
+        return graphs;
+    }
+
+    private isModelLoaded(modelUri: string): boolean {
+        try {
+            this.reasoningStore.graphs(modelUri);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    private ensureOwnTboxIndexesForDependencies(modelUri: string): void {
+        const ordered = this.resolveLoadedDependencyOrder(modelUri);
+        for (const uri of ordered) {
+            if (this.tboxIndexCache.hasOwn(uri)) {
+                continue;
+            }
+            const document = this.services.shared.workspace.LangiumDocuments.getDocument(URI.parse(uri));
+            if (!document) {
+                continue;
+            }
+            const ontology = document.parseResult.value;
+            if (!isVocabulary(ontology)) {
+                continue;
+            }
+            this.tboxChainer.chain(uri);
+            this.tboxIndexCache.setOwn(uri, this.tboxIndexBuilder.buildOwn(uri));
+        }
+    }
+
+    private notifySemanticChanged(modelUris: string[]): void {
+        const unique = [...new Set(modelUris)];
+        for (const listener of this.semanticChangeListeners) {
+            listener(unique);
+        }
+    }
+}
+
+export interface PreparedReasonedModel {
+    modelUri: string;
+    aliases?: ReadonlyArray<string>;
+    imports: ReadonlyArray<string>;
+    assertedQuads: ReadonlyArray<Quad>;
+    entailedQuads: ReadonlyArray<Quad>;
+    validationWarnings?: ReadonlyArray<string>;
+}
+
+function isWorkspaceModelUri(modelUri: string): boolean {
+    try {
+        const parsed = URI.parse(modelUri);
+        return parsed.path.toLowerCase().endsWith('.oml');
+    } catch {
+        return false;
+    }
+}
+
+const BUILT_IN_ONTOLOGIES = new Set([
+    'http://www.w3.org/2001/XMLSchema',
+    'http://www.w3.org/1999/02/22-rdf-syntax-ns',
+    'http://www.w3.org/2000/01/rdf-schema',
+    'http://www.w3.org/2002/07/owl',
+    'http://www.w3.org/2003/11/swrlb',
+]);
+
+function createDefaultDependencies(overrides: Partial<OwlReasoningDependencies>): OwlReasoningDependencies {
+    const mapper = overrides.mapper ?? new Oml2OwlMapper();
+    const reasoningStore = overrides.reasoningStore ?? new ReasoningStore();
+    const importGraph = overrides.importGraph ?? new ImportGraph();
+    const tboxIndexCache = overrides.tboxIndexCache ?? new TBoxIndexCache();
+    const tboxChainer = overrides.tboxChainer ?? new TBoxChainer(reasoningStore);
+    const tboxIndexBuilder = overrides.tboxIndexBuilder ?? new TBoxIndexBuilder(reasoningStore, tboxIndexCache, importGraph);
+    const aboxChainer = overrides.aboxChainer ?? new ABoxChainer(reasoningStore);
+    const aboxEntailmentCache = overrides.aboxEntailmentCache ?? new ABoxEntailmentCache();
+    const createSparqlService = overrides.createSparqlService ?? ((runner) => new SparqlService(
+        reasoningStore,
+        importGraph,
+        aboxEntailmentCache,
+        runner,
+    ));
+    return {
+        mapper,
+        reasoningStore,
+        importGraph,
+        tboxChainer,
+        tboxIndexBuilder,
+        tboxIndexCache,
+        aboxChainer,
+        aboxEntailmentCache,
+        createSparqlService,
+    };
+}