@oml/owl 0.19.3 → 0.20.1

package/src/owl/owl-imports.ts

@@ -68,9 +68,11 @@ export class ImportGraph {
     dependentsOf(modelUri: string): string[] {
         const visited = new Set<string>();
         const worklist = [modelUri];
+        let cursor = 0;
 
-        while (worklist.length > 0) {
-            const current = worklist.shift();
+        while (cursor < worklist.length) {
+            const current = worklist[cursor];
+            cursor += 1;
             if (!current || visited.has(current)) continue;
             visited.add(current);
             const importers = this.importedBy.get(current) ?? new Set<string>();

package/src/owl/owl-interfaces.ts

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
-import type { NamedNode, Quad, Store } from 'n3';
+import type { NamedNode, Quad, Store, Term } from 'n3';
 import type * as RDF from '@rdfjs/types';
 import type { Ontology } from '@oml/language';
 import type { ChainingResult } from './owl-abox.js';
@@ -11,14 +11,26 @@ export interface OwlMapper {
     toQuads(ontology: Ontology): Quad[];
 }
 
+/**
+ * Visits a model's stored facts as (subject, predicate, object, key) — `key` is the dedup key
+ * `${subject.id}|${predicate.id}|${object.id}`. Lets the ABox chainer read scope facts without the
+ * store materializing per-model `Quad` arrays (the lean store yields them straight from its columns).
+ */
+export type ScopeFactVisitor = (subject: Term, predicate: NamedNode, object: Term, key: string) => void;
+
 export interface OwlStore {
     loadModel(modelUri: string, quads: Quad[]): void;
     loadEntailments(modelUri: string, quads: Quad[]): void;
+    addEntailment(modelUri: string, quad: Quad): void;
+    removeEntailment(modelUri: string, quad: Quad): void;
     applyModelDelta(modelUri: string, quads: Quad[], retracted: Quad[], asserted: Quad[]): void;
     retractModel(modelUri: string): void;
     diffModel(modelUri: string, newQuads: Quad[]): ModelDiff;
     clearEntailments(modelUri: string): void;
     graphs(modelUri: string): ModelGraphs;
+    forEachAssertedFact(modelUri: string, visit: ScopeFactVisitor): void;
+    forEachEntailedFact(modelUri: string, visit: ScopeFactVisitor): void;
+    getModelDataGen(modelUri: string): number;
     getStore(): Store;
 }
 
@@ -115,6 +127,21 @@ export interface OwlSparqlService {
     query(modelUri: string, sparql: string): Promise<OwlQueryResult>;
     construct(modelUri: string, sparql: string): Promise<OwlConstructResult>;
     ask(modelUri: string, sparql: string): Promise<OwlAskResult>;
+    /**
+     * Make `quads` visible to queries run inside `action`, then drop them. Used to chain SHACL
+     * `sh:rule` CONSTRUCT outputs (each rule's quads feed the next). Each engine reflects the
+     * quads wherever its queries read: Comunica into the live N3 store, Oxigraph into its mirror.
+     */
+    withMaterializedQuads<T>(modelUri: string, quads: RDF.Quad[], action: () => Promise<T>): Promise<T>;
+}
+
+/**
+ * A swappable SPARQL engine: an OwlSparqlService plus the construction-time wiring the
+ * ReasoningService needs. Concrete engines (Comunica, Oxigraph) implement this so they are
+ * fully interchangeable behind the factory in owl-sparql-engine.ts.
+ */
+export interface OwlSparqlEngine extends OwlSparqlService {
+    setOntologyIriResolver(resolver: (modelUri: string) => string): void;
 }
 
 export interface OwlShaclValidationIssue {

package/src/owl/owl-mapper.ts

@@ -48,7 +48,6 @@ import {
     isAnonymousConceptInstance,
     isAnonymousRelationInstance,
     isAspect,
-    isBooleanLiteral,
     isBuiltInPredicate,
     isBuiltIn,
     isConcept,
@@ -67,7 +66,6 @@ import {
     isPropertyValueRestrictionAxiom,
     isQuantity,
     isQuantityProperty,
-    isQuotedLiteral,
     isRelation,
     isRelationEntityPredicate,
     isRelationEntity,
@@ -284,9 +282,20 @@ const BUILT_IN_ONTOLOGIES = new Set([
     'http://www.w3.org/2003/11/swrlb',
 ]);
 
-const { blankNode, namedNode, literal, quad } = DataFactory;
+const { blankNode, literal, quad } = DataFactory;
 type TermNode = ReturnType<typeof namedNode> | ReturnType<typeof blankNode>;
 
+const namedNodeCache = new Map<string, ReturnType<typeof DataFactory.namedNode>>();
+
+function namedNode(iri: string): ReturnType<typeof DataFactory.namedNode> {
+    let node = namedNodeCache.get(iri);
+    if (!node) {
+        node = DataFactory.namedNode(iri);
+        namedNodeCache.set(iri, node);
+    }
+    return node;
+}
+
 function fnv1a(input: string): string {
     let hash = 2166136261;
     for (let i = 0; i < input.length; i += 1) {
@@ -354,6 +363,9 @@ export class Oml2OwlMapper {
             });
         }
 
+        if (isDescription(ontology)) {
+            return triples;
+        }
         return this.deduplicateQuads(triples);
     }
 
@@ -593,12 +605,14 @@ export class Oml2OwlMapper {
   }
 
   private mapConceptInstance(instance: ConceptInstance, ctx: MappingContext, triples: Quad[]): void {
-    const iri = this.elementIri(instance, ctx);
+    const iri = (instance as any).ref ? this.elementIri(instance, ctx) : this.ownedElementIri(instance, ctx);
     if (!iri) return;
     const node = namedNode(iri);
     const isDefinition = !(instance as any).ref;
 
-    instance.ownedTypes?.forEach((typeAssertion) => this.mapTypeAssertion(node, typeAssertion, ctx, triples));
+    instance.ownedTypes?.forEach((typeAssertion) => {
+      this.mapTypeAssertion(node, typeAssertion, ctx, triples);
+    });
     if (isDefinition) {
       triples.push(this.quadWithGraph(node, namedNode(OML.type), namedNode(OML.ConceptInstance)));
     }
@@ -607,7 +621,7 @@ export class Oml2OwlMapper {
   }
 
   private mapRelationInstance(instance: RelationInstance, ctx: MappingContext, triples: Quad[]): void {
-    const iri = this.elementIri(instance, ctx);
+    const iri = (instance as any).ref ? this.elementIri(instance, ctx) : this.ownedElementIri(instance, ctx);
     if (!iri) return;
     const node = namedNode(iri);
     const isDefinition = !(instance as any).ref;
@@ -873,14 +887,16 @@ export class Oml2OwlMapper {
     const propertyIri = this.resolveIri(assertion.property, ctx);
     if (!propertyIri) return;
     const propertyNode = namedNode(propertyIri);
-
-    const propertyRef = assertion.property?.ref as any;
-    const isQuantityProp = propertyRef && isQuantityProperty(propertyRef);
+    let isQuantityProp: boolean | undefined;
 
     assertion.literalValues?.forEach((lit, index) => {
       const isNumeric = isIntegerLiteral(lit) || isDecimalLiteral(lit) || isDoubleLiteral(lit);
       const unitRef = (lit as any)?.unit;
       const explicitUnitIri = unitRef ? this.resolveIri(unitRef, ctx) : undefined;
+      if (isNumeric && explicitUnitIri === undefined && isQuantityProp === undefined) {
+        const propertyRef = assertion.property?.ref as any;
+        isQuantityProp = propertyRef && isQuantityProperty(propertyRef);
+      }
       // Always wrap numeric literals on quantity properties in a QuantityLiteral
       // (the property's range is oml:QuantityLiteral). Plain literals only when
       // the property isn't a quantity property.
@@ -915,7 +931,6 @@ export class Oml2OwlMapper {
       triples.push(this.quadWithGraph(subject, propertyNode, valueNode));
       this.mapAnonymousInstance(contained, valueNode, ctx, triples, subject);
     });
-
   }
 
   private mapAnnotations(
@@ -1450,9 +1465,14 @@ export class Oml2OwlMapper {
       map[prefix] = ns;
     }
     ontology.ownedImports?.forEach((imp: Import) => {
-      const imported = imp.imported?.ref as Ontology | undefined;
-      const importedNs = imported ? this.normalizeNamespace((imported as any).namespace ?? '') : undefined;
-      const importedPrefix = imp.prefix ?? (imported as any)?.prefix;
+      const refText = (imp.imported as any)?.$refText ?? (imp.imported as any)?.refText;
+      let importedNs = refText ? this.resolveFromRefText(refText, { ...this.emptyContext(), prefixes: map }) : undefined;
+      let importedPrefix = imp.prefix;
+      if (!importedNs || !importedPrefix) {
+        const imported = imp.imported?.ref as Ontology | undefined;
+        importedNs = importedNs ?? (imported ? this.normalizeNamespace((imported as any).namespace ?? '') : undefined);
+        importedPrefix = importedPrefix ?? (imported as any)?.prefix;
+      }
       if (importedPrefix && importedNs) {
         map[importedPrefix] = importedNs;
       }
@@ -1469,13 +1489,13 @@ export class Oml2OwlMapper {
   }
 
   private importedOntologyIri(imp: Import, ctx: MappingContext): string | undefined {
-    if (imp.imported?.ref && isOntology(imp.imported.ref)) {
-      return this.normalizeNamespace((imp.imported.ref as any).namespace ?? '').replace(/[\/#]+$/, '');
-    }
     const refText = (imp.imported as any)?.$refText ?? (imp.imported as any)?.refText;
     if (refText) {
       return this.resolveFromRefText(refText, ctx)?.replace(/[\/#]+$/, '');
     }
+    if (imp.imported?.ref && isOntology(imp.imported.ref)) {
+      return this.normalizeNamespace((imp.imported.ref as any).namespace ?? '').replace(/[\/#]+$/, '');
+    }
     return undefined;
   }
 
@@ -1505,6 +1525,12 @@ export class Oml2OwlMapper {
     return `${namespace}${name.replace(/^\^/, '')}`;
   }
 
+  private ownedElementIri(element: { name?: string }, ctx: MappingContext): string | undefined {
+    const name = (element as any)?.name;
+    if (!name) return undefined;
+    return `${ctx.namespace}${name.replace(/^\^/, '')}`;
+  }
+
   private getOntology(element: any): Ontology | undefined {
     let current: any = element;
     while (current && !isOntology(current)) {
@@ -1518,19 +1544,28 @@ export class Oml2OwlMapper {
     if (typeof ref === 'string') {
       return this.resolveFromRefText(ref, ctx);
     }
+    const refText = ref.$refText ?? ref.refText;
+    if (refText) {
+      return this.resolveFromRefText(refText, ctx);
+    }
     if (ref.ref && (ref.ref as any).name) {
       return this.elementIri(ref.ref as any, ctx);
     }
     if (ref.name) {
       return this.elementIri(ref, ctx);
     }
-    const refText = ref.$refText ?? ref.refText;
-    if (refText) {
-      return this.resolveFromRefText(refText, ctx);
-    }
     return undefined;
   }
 
+  private emptyContext(): MappingContext {
+    return {
+      ontologyIri: '',
+      namespace: '',
+      prefix: '',
+      prefixes: {},
+    };
+  }
+
   private resolveFromRefText(refText: string, ctx: MappingContext): string | undefined {
     if (refText.startsWith('<') && refText.endsWith('>')) {
       return refText.slice(1, -1);
@@ -1543,6 +1578,9 @@ export class Oml2OwlMapper {
         return `${ns}${local}`;
       }
     }
+    if (!refText.includes(':') && ctx.namespace) {
+      return `${ctx.namespace}${refText.replace(/^\^/, '')}`;
+    }
     return undefined;
   }
 
@@ -1561,29 +1599,29 @@ export class Oml2OwlMapper {
   }
 
   private toLiteral(value: Literal, ctx: MappingContext): Quad_Object | undefined {
-    if (isBooleanLiteral(value)) {
-      return literal(String(value.value), namedNode(XSD.boolean));
-    }
-    if (isIntegerLiteral(value)) {
-      return literal(String(value.value), namedNode(XSD.integer));
-    }
-    if (isDecimalLiteral(value)) {
-      return literal(String(value.value), namedNode(XSD.decimal));
-    }
-    if (isDoubleLiteral(value)) {
-      return literal(formatDoubleLiteralValue(value.value), namedNode(XSD.double));
-    }
-    if (isQuotedLiteral(value)) {
-      if (value.type) {
-        const dt = this.resolveIri(value.type, ctx);
-        return literal(value.value, dt ? namedNode(dt) : undefined);
-      }
-      if (value.langTag) {
-        return literal(value.value, value.langTag);
+    switch ((value as any).$type) {
+      case 'BooleanLiteral':
+        return literal(String(value.value), namedNode(XSD.boolean));
+      case 'IntegerLiteral':
+        return literal(String(value.value), namedNode(XSD.integer));
+      case 'DecimalLiteral':
+        return literal(String(value.value), namedNode(XSD.decimal));
+      case 'DoubleLiteral':
+        return literal(formatDoubleLiteralValue(value.value), namedNode(XSD.double));
+      case 'QuotedLiteral': {
+        const quoted = value as any;
+        if (quoted.type) {
+          const dt = this.resolveIri(quoted.type, ctx);
+          return literal(quoted.value, dt ? namedNode(dt) : undefined);
+        }
+        if (quoted.langTag) {
+          return literal(quoted.value, quoted.langTag);
+        }
+        return literal(quoted.value);
       }
-      return literal(value.value);
+      default:
+        return undefined;
     }
-    return undefined;
   }
 
   private toFirstUpper(name: string): string {

package/src/owl/owl-service.ts

@@ -2,13 +2,14 @@
 
 import { DocumentState, URI, type LangiumDocument } from 'langium';
 import { DataFactory, type NamedNode, type Quad } from 'n3';
+import type * as RDF from '@rdfjs/types';
 import { OmlIndex, getOntologyModelIndex, isDescription, isDescriptionBundle, isOntology, isVocabulary, isVocabularyBundle, type Import, type OmlServices, type Ontology } from '@oml/language';
 import { Oml2OwlMapper } from './owl-mapper.js';
 import { VocabularyBundleClosureBuilder } from './owl-closure.js';
-import { ReasoningStore } from './owl-store.js';
+import { LeanReasoningStore } from './owl-store-lean.js';
 import { ABoxChainer, ABoxEntailmentCache, type ChainingResult } from './owl-abox.js';
 import { ImportGraph } from './owl-imports.js';
-import { SparqlService } from './owl-sparql.js';
+import { createSparqlEngine, resolveSparqlEngineKind } from './owl-sparql-engine.js';
 import { TBoxChainer, TBoxIndexBuilder, TBoxIndexCache } from './owl-tbox.js';
 import type {
     OwlABoxChainer,
@@ -38,6 +39,7 @@ export class ReasoningService {
     private readonly preparedModelAliases = new Map<string, string>();
     private readonly activeDocuments = new Set<string>();
     private readonly modelLoadInFlight = new Map<string, Promise<void>>();
+    private readonly importModelUriResolutionCache = new Map<string, string | undefined>();
     private readonly semanticChangeListeners = new Set<(modelUris: string[]) => void>();
     private readonly pendingSemanticChangedUris = new Set<string>();
     private semanticChangeSuppressionDepth = 0;
@@ -54,8 +56,9 @@ export class ReasoningService {
         this.aboxChainer = resolved.aboxChainer;
         this.aboxEntailmentCache = resolved.aboxEntailmentCache;
         this.sparqlService = resolved.createSparqlService(this);
-        if (this.sparqlService instanceof SparqlService) {
-            this.sparqlService.setOntologyIriResolver((modelUri) => this.resolveOntologyIriForModelUri(modelUri));
+        const sparqlWithResolver = this.sparqlService as { setOntologyIriResolver?: (resolver: (modelUri: string) => string) => void };
+        if (typeof sparqlWithResolver.setOntologyIriResolver === 'function') {
+            sparqlWithResolver.setOntologyIriResolver((modelUri) => this.resolveOntologyIriForModelUri(modelUri));
         }
         this.ontologyModelIndex = getOntologyModelIndex(services.shared);
 
@@ -69,6 +72,9 @@ export class ReasoningService {
                 this.notifySemanticChanged(uris);
             }
         });
+        services.shared.workspace.DocumentBuilder.onUpdate(() => {
+            this.importModelUriResolutionCache.clear();
+        });
     }
 
     onDocumentValidated(document: LangiumDocument): void {
@@ -83,20 +89,24 @@ export class ReasoningService {
 
         const quads = this.mapOntologyToQuads(ontology as Ontology);
         const wasModelLoaded = this.isModelLoaded(modelUri);
-        const diff = this.reasoningStore.diffModel(modelUri, quads);
-        if (diff.isEmpty) {
-            return;
+        if (wasModelLoaded) {
+            const diff = this.reasoningStore.diffModel(modelUri, quads);
+            if (diff.isEmpty) {
+                return;
+            }
+            this.reasoningStore.retractModel(modelUri);
         }
         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);
-            if (!wasModelLoaded || this.semanticChangeSuppressionDepth > 0) {
-                continue;
+        if (wasModelLoaded) {
+            const impactedByLoad = [modelUri, ...this.importGraph.dependentsOf(modelUri)];
+            for (const uri of impactedByLoad) {
+                this.sparqlService.invalidateFilteredStore(uri);
+                if (this.semanticChangeSuppressionDepth > 0) {
+                    continue;
+                }
+                this.pendingSemanticChangedUris.add(uri);
             }
-            this.pendingSemanticChangedUris.add(uri);
         }
         if (isVocabulary(ontology)) {
             this.tboxChainer.chain(modelUri);
@@ -158,7 +168,16 @@ export class ReasoningService {
             let merged = this.tboxIndexCache.getMerged(chainedModelUri);
             if (!merged || this.tboxIndexCache.isMergedDirty(chainedModelUri)) {
                 merged = this.tboxIndexBuilder.buildMerged(chainedModelUri);
-                this.tboxIndexCache.setMerged(chainedModelUri, merged);
+                // Retain the merged TBox index only for active (open/edited) documents — matching
+                // the policy in onDocumentValidated. For the rest it is just a transient input to
+                // this chain pass; caching it for all models keeps thousands of largely-duplicate
+                // merged vocabulary TBoxes resident. getMerged's only consumer is right here and it
+                // rebuilds on demand, so skipping the cache is correctness-neutral and costs one
+                // buildMerged on the next chain of that model (cheap — the per-vocabulary own
+                // indexes it merges stay cached).
+                if (this.isActiveDocument(chainedModelUri)) {
+                    this.tboxIndexCache.setMerged(chainedModelUri, merged);
+                }
             }
 
             const readScope = this.resolveLoadedDependencyOrder(chainedModelUri);
@@ -236,6 +255,9 @@ export class ReasoningService {
             ask: (modelUri: string, sparql: string) => {
                 return this.sparqlService.ask(this.resolveQueryModelUri(modelUri), sparql);
             },
+            withMaterializedQuads: <T>(modelUri: string, quads: RDF.Quad[], action: () => Promise<T>) => {
+                return this.sparqlService.withMaterializedQuads(this.resolveQueryModelUri(modelUri), quads, action);
+            },
         };
     }
 
@@ -312,28 +334,54 @@ export class ReasoningService {
     }
 
     private resolveImportedModelUri(ownedImport: Import, prefixes: Map<string, string>, referencingModelUri?: string): string | undefined {
-        if (ownedImport.imported?.ref && isOntology(ownedImport.imported.ref)) {
-            const importedNamespace = this.normalizeNamespace((ownedImport.imported.ref as any).namespace ?? '');
-            const viaIndex = this.ontologyModelIndex.resolveModelUri(importedNamespace, referencingModelUri);
-            if (viaIndex) {
-                return viaIndex;
-            }
-            const importedDocumentUri = (ownedImport.imported.ref as any)?.$document?.uri?.toString();
-            if (importedDocumentUri) {
-                return importedDocumentUri;
+        const refText = this.getImportRefText(ownedImport);
+        if (refText) {
+            const ontologyIdentifier = this.resolveFromRefText(refText, prefixes);
+            if (!ontologyIdentifier || BUILT_IN_ONTOLOGIES.has(ontologyIdentifier)) {
+                return undefined;
             }
-            return this.resolveModelUriFromOntologyIdentifier(importedNamespace);
+            return this.resolveImportedOntologyIdentifier(ontologyIdentifier, referencingModelUri);
         }
-        const refText = (ownedImport.imported as any)?.$refText ?? (ownedImport.imported as any)?.refText;
-        if (!refText) {
+
+        const imported = ownedImport.imported?.ref;
+        if (!imported || !isOntology(imported)) {
             return undefined;
         }
-        const ontologyIdentifier = this.resolveFromRefText(refText, prefixes);
-        if (!ontologyIdentifier || BUILT_IN_ONTOLOGIES.has(ontologyIdentifier)) {
-            return undefined;
+        const importedNamespace = this.normalizeNamespace((imported as any).namespace ?? '');
+        const viaIndex = this.ontologyModelIndex.resolveModelUri(importedNamespace, referencingModelUri);
+        if (viaIndex) {
+            return viaIndex;
+        }
+        const importedDocumentUri = (imported as any)?.$document?.uri?.toString();
+        if (importedDocumentUri) {
+            return importedDocumentUri;
+        }
+        return this.resolveModelUriFromOntologyIdentifier(importedNamespace);
+    }
+
+    private resolveImportedOntologyIdentifier(identifier: string, referencingModelUri?: string): string | undefined {
+        const globalCacheKey = `|${identifier}`;
+        if (this.importModelUriResolutionCache.has(globalCacheKey)) {
+            const resolved = this.importModelUriResolutionCache.get(globalCacheKey);
+            if (resolved) {
+                return resolved;
+            }
+        } else {
+            const globallyResolved = this.resolveModelUriFromOntologyIdentifier(identifier);
+            this.importModelUriResolutionCache.set(globalCacheKey, globallyResolved);
+            if (globallyResolved) {
+                return globallyResolved;
+            }
+        }
+
+        const cacheKey = `${referencingModelUri ?? ''}|${identifier}`;
+        if (this.importModelUriResolutionCache.has(cacheKey)) {
+            return this.importModelUriResolutionCache.get(cacheKey);
         }
-        return this.ontologyModelIndex.resolveModelUri(ontologyIdentifier, referencingModelUri)
-            ?? this.resolveModelUriFromOntologyIdentifier(ontologyIdentifier);
+        const resolved = this.ontologyModelIndex.resolveModelUri(identifier, referencingModelUri)
+            ?? this.resolveModelUriFromOntologyIdentifier(identifier);
+        this.importModelUriResolutionCache.set(cacheKey, resolved);
+        return resolved;
     }
 
     private buildPrefixMap(ontology: Ontology): Map<string, string> {
@@ -344,9 +392,12 @@ export class ReasoningService {
             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;
+            const importedPrefix = ownedImport.prefix;
+            if (!importedPrefix) {
+                continue;
+            }
+            const refText = this.getImportRefText(ownedImport);
+            const importedNamespace = refText ? this.resolveFromRefText(refText, map) : undefined;
             if (importedPrefix && importedNamespace) {
                 map.set(importedPrefix, importedNamespace);
             }
@@ -354,6 +405,11 @@ export class ReasoningService {
         return map;
     }
 
+    private getImportRefText(ownedImport: Import): string | undefined {
+        const imported = ownedImport.imported as any;
+        return imported?.$refText ?? imported?.refText;
+    }
+
     private resolveFromRefText(refText: string, prefixes: Map<string, string>): string | undefined {
         if (refText.startsWith('<') && refText.endsWith('>')) {
             return refText.slice(1, -1);
@@ -418,8 +474,12 @@ export class ReasoningService {
                     }
                 }
                 await this.withSemanticChangeSuppressed(async () => {
-                    await this.services.shared.workspace.DocumentBuilder.build([document], { validation: true });
+                    await this.services.shared.workspace.DocumentBuilder.build([document], { validation: false, eagerLinking: false });
                 });
+                const root = document.parseResult.value;
+                if (isOntology(root)) {
+                    this.onDocumentValidated(document);
+                }
             })().finally(() => {
                 this.modelLoadInFlight.delete(modelUri);
             });
@@ -462,8 +522,10 @@ export class ReasoningService {
 
     private async ensureContextDatasetReady(modelUri: string): Promise<void> {
         const attemptedLoads = new Set<string>();
+        let pass = 0;
 
         while (true) {
+            pass += 1;
             const allUris = [modelUri, ...this.importGraph.dependenciesOf(modelUri)];
             const unresolvedIdentifiers: string[] = [];
             const resolvedModelUris: string[] = [];
@@ -487,17 +549,17 @@ export class ReasoningService {
 
             const loadFailures: string[] = [];
             let loadedAny = false;
-            for (const uri of unloadedModelUris) {
-                if (attemptedLoads.has(uri)) {
-                    continue;
-                }
+            const loadTargets = unloadedModelUris.filter((uri) => !attemptedLoads.has(uri));
+            for (const uri of loadTargets) {
                 attemptedLoads.add(uri);
+            }
+            if (loadTargets.length > 0) {
                 try {
-                    await this.ensureModelLoaded(uri);
+                    await this.ensureModelsLoaded(loadTargets);
                     loadedAny = true;
                 } catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
-                    loadFailures.push(`${uri} (${message})`);
+                    loadFailures.push(`${loadTargets.length} model(s) (${message})`);
                 }
             }
             if (loadFailures.length > 0) {
@@ -526,6 +588,46 @@ export class ReasoningService {
         }
     }
 
+    private async ensureModelsLoaded(modelUris: ReadonlyArray<string>): Promise<void> {
+        const uniqueUris = [...new Set(modelUris)].filter((uri) => !this.isModelLoaded(uri));
+        if (uniqueUris.length === 0) {
+            return;
+        }
+
+        const documents: LangiumDocument[] = [];
+        for (const modelUri of uniqueUris) {
+            const inFlight = this.modelLoadInFlight.get(modelUri);
+            if (inFlight) {
+                await inFlight;
+                continue;
+            }
+            if (this.isModelLoaded(modelUri)) {
+                continue;
+            }
+            const uri = URI.parse(modelUri);
+            let document = this.services.shared.workspace.LangiumDocuments.getDocument(uri);
+            if (!document) {
+                document = await this.services.shared.workspace.LangiumDocuments.getOrCreateDocument(uri);
+            }
+            documents.push(document);
+        }
+
+        if (documents.length === 0) {
+            return;
+        }
+
+        await this.withSemanticChangeSuppressed(async () => {
+            await this.services.shared.workspace.DocumentBuilder.build(documents, { validation: false, eagerLinking: false });
+        });
+
+        for (const document of documents) {
+            const root = document.parseResult.value;
+            if (isOntology(root)) {
+                this.onDocumentValidated(document);
+            }
+        }
+    }
+
     async countContextDatasetQuads(modelUri: string): Promise<number> {
         const resolvedModelUri = this.resolveQueryModelUri(modelUri);
         await this.services.shared.workspace.WorkspaceManager.ready;
@@ -744,19 +846,17 @@ const BUILT_IN_ONTOLOGIES = new Set([
 
 function createDefaultDependencies(overrides: Partial<OwlReasoningDependencies>): OwlReasoningDependencies {
     const mapper = overrides.mapper ?? new Oml2OwlMapper();
-    const reasoningStore = overrides.reasoningStore ?? new ReasoningStore();
+    // LeanReasoningStore is term-interned with packed columns — ~9x less memory than the
+    // n3-backed ReasoningStore, and faster scans.
+    const reasoningStore = overrides.reasoningStore ?? new LeanReasoningStore();
     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,
-    ));
+    const createSparqlService = overrides.createSparqlService ?? ((runner) =>
+        createSparqlEngine(resolveSparqlEngineKind(), reasoningStore, importGraph, aboxEntailmentCache, runner));
     return {
         mapper,
         reasoningStore,