@oml/owl 0.9.0 → 0.10.0

package/src/owl/owl-mapper.ts

@@ -257,8 +257,8 @@ const BUILT_IN_ONTOLOGIES = new Set([
     'http://www.w3.org/2003/11/swrlb',
 ]);
 
-const { namedNode, literal, quad } = DataFactory;
-type TermNode = ReturnType<typeof namedNode>;
+const { blankNode, namedNode, literal, quad } = DataFactory;
+type TermNode = ReturnType<typeof namedNode> | ReturnType<typeof blankNode>;
 
 function fnv1a(input: string): string {
     let hash = 2166136261;
@@ -578,24 +578,24 @@ export class Oml2OwlMapper {
     const sourceVar = this.toSwrlVariable('s', triples);
     const targetVar = this.toSwrlVariable('t', triples);
 
-    const classAtom = skolemize(ctx.namespace, 'rule-atom', relationEntityIri, 'relationEntity', 'class');
+    const classAtom = blankNode();
     triples.push(this.quadWithGraph(classAtom, namedNode(RDF.type), namedNode(SWRL.ClassAtom)));
     triples.push(this.quadWithGraph(classAtom, namedNode(SWRL.classPredicate), namedNode(relationEntityIri)));
     triples.push(this.quadWithGraph(classAtom, namedNode(SWRL.argument1), relationVar));
 
-    const sourceAtom = skolemize(ctx.namespace, 'rule-atom', relationEntityIri, 'relationEntity', 'source');
+    const sourceAtom = blankNode();
     triples.push(this.quadWithGraph(sourceAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
     triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.propertyPredicate), namedNode(OML.hasSource)));
     triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.argument1), relationVar));
     triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.argument2), sourceVar));
 
-    const targetAtom = skolemize(ctx.namespace, 'rule-atom', relationEntityIri, 'relationEntity', 'target');
+    const targetAtom = blankNode();
     triples.push(this.quadWithGraph(targetAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
     triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.propertyPredicate), namedNode(OML.hasTarget)));
     triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.argument1), relationVar));
     triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.argument2), targetVar));
 
-    const headAtom = skolemize(ctx.namespace, 'rule-atom', relationEntityIri, 'relationEntity', 'forward');
+    const headAtom = blankNode();
     triples.push(this.quadWithGraph(headAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
     triples.push(this.quadWithGraph(headAtom, namedNode(SWRL.propertyPredicate), namedNode(forwardIri)));
     triples.push(this.quadWithGraph(headAtom, namedNode(SWRL.argument1), sourceVar));
@@ -635,7 +635,7 @@ export class Oml2OwlMapper {
       if (predicate.type.ref && isScalar(predicate.type.ref)) {
         const argument = this.toSwrlDArgument(predicate.argument, ctx, triples);
         if (!argument) return [];
-        const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'type', 'dataRange', typeIri, this.termKey(argument));
+        const atom = blankNode();
         triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.DataRangeAtom)));
         triples.push(this.quadWithGraph(atom, namedNode(SWRL.dataRange), namedNode(typeIri)));
         triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument));
@@ -644,7 +644,7 @@ export class Oml2OwlMapper {
 
       const argument = this.toSwrlIArgument(predicate.argument, ctx, triples);
       if (!argument) return [];
-      const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'type', 'class', typeIri, this.termKey(argument));
+      const atom = blankNode();
       triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.ClassAtom)));
       triples.push(this.quadWithGraph(atom, namedNode(SWRL.classPredicate), namedNode(typeIri)));
       triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument));
@@ -658,18 +658,18 @@ export class Oml2OwlMapper {
       const argument2 = this.toSwrlIArgument(predicate.argument2, ctx, triples);
       if (!typeIri || !argument || !argument1 || !argument2) return [];
 
-      const typeAtom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'relationEntity', 'type', typeIri, this.termKey(argument));
+      const typeAtom = blankNode();
       triples.push(this.quadWithGraph(typeAtom, namedNode(RDF.type), namedNode(SWRL.ClassAtom)));
       triples.push(this.quadWithGraph(typeAtom, namedNode(SWRL.classPredicate), namedNode(typeIri)));
       triples.push(this.quadWithGraph(typeAtom, namedNode(SWRL.argument1), argument));
 
-      const sourceAtom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'relationEntity', 'source', this.termKey(argument), this.termKey(argument1));
+      const sourceAtom = blankNode();
       triples.push(this.quadWithGraph(sourceAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
       triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.propertyPredicate), namedNode(OML.hasSource)));
       triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.argument1), argument));
       triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.argument2), argument1));
 
-      const targetAtom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'relationEntity', 'target', this.termKey(argument), this.termKey(argument2));
+      const targetAtom = blankNode();
       triples.push(this.quadWithGraph(targetAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
       triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.propertyPredicate), namedNode(OML.hasTarget)));
       triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.argument1), argument));
@@ -686,9 +686,7 @@ export class Oml2OwlMapper {
       const isDataPredicate =
         (predicate.property.ref && isScalarProperty(predicate.property.ref)) ||
         (predicate.property.ref && isAnnotationProperty(predicate.property.ref) && Boolean(predicate.argument2.literal));
-      const atom = isDataPredicate
-        ? skolemize(ctx.namespace, 'rule-atom', atomSeed, 'property', 'data', propertyIri, this.termKey(argument1))
-        : skolemize(ctx.namespace, 'rule-atom', atomSeed, 'property', 'object', propertyIri, this.termKey(argument1));
+      const atom = blankNode();
       if (isDataPredicate) {
         const argument2 = this.toSwrlDArgument(predicate.argument2, ctx, triples);
         if (!argument2) return [];
@@ -711,7 +709,7 @@ export class Oml2OwlMapper {
       const argument1 = this.toSwrlIArgument(predicate.argument1, ctx, triples);
       const argument2 = this.toSwrlIArgument(predicate.argument2, ctx, triples);
       if (!argument1 || !argument2) return [];
-      const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'sameAs', this.termKey(argument1), this.termKey(argument2));
+      const atom = blankNode();
       triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.SameIndividualAtom)));
       triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument1));
       triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument2), argument2));
@@ -722,7 +720,7 @@ export class Oml2OwlMapper {
       const argument1 = this.toSwrlIArgument(predicate.argument1, ctx, triples);
       const argument2 = this.toSwrlIArgument(predicate.argument2, ctx, triples);
       if (!argument1 || !argument2) return [];
-      const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'differentFrom', this.termKey(argument1), this.termKey(argument2));
+      const atom = blankNode();
       triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.DifferentIndividualsAtom)));
       triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument1));
       triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument2), argument2));
@@ -735,7 +733,7 @@ export class Oml2OwlMapper {
       const argumentsList = predicate.arguments
         .map((argument) => this.toSwrlDArgument(argument, ctx, triples))
         .filter((argument): argument is Quad_Object => Boolean(argument));
-      const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'builtin', builtInIri, ...argumentsList.map((argument) => this.termKey(argument)));
+      const atom = blankNode();
       triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.BuiltinAtom)));
       triples.push(this.quadWithGraph(atom, namedNode(SWRL.builtin), namedNode(builtInIri)));
       triples.push(this.quadWithGraph(atom, namedNode(SWRL.arguments), this.createRdfList(ctx, argumentsList, triples, `rule-builtin-args|${atomSeed}|${builtInIri}`)));
@@ -836,7 +834,7 @@ export class Oml2OwlMapper {
 
   private mapAnonymousInstance(
     instance: AnonymousInstance,
-    node: ReturnType<typeof namedNode>,
+    node: TermNode,
     ctx: MappingContext,
     triples: Quad[],
     source?: TermNode,
@@ -947,7 +945,7 @@ export class Oml2OwlMapper {
       .filter((iri): iri is string => Boolean(iri))
       .map((iri) => namedNode(iri));
     if (!instanceNodes.length) return;
-    const listHead = this.createRdfList(ctx, instanceNodes, triples, `instance-enum|${classNode.value}|${instanceNodes.map((node) => node.value).join('|')}`);
+    const listHead = this.createBlankNodeRdfList(instanceNodes, triples);
     triples.push(this.quadWithGraph(classNode, namedNode(OWL.oneOf), listHead));
   }
 
@@ -963,9 +961,8 @@ export class Oml2OwlMapper {
       .map((lit) => this.toLiteral(lit, ctx))
       .filter((node): node is Quad_Object => Boolean(node));
     if (!literalNodes.length) return;
-    const literalSignature = literalNodes.map((node) => this.termKey(node)).join('|');
-    const listHead = this.createRdfList(ctx, literalNodes, triples, `scalar-enum|${scalarNode.value}|${literalSignature}`);
-    const dataRangeNode = skolemize(ctx.namespace, 'datatype-enum', scalarNode.value, literalSignature);
+    const listHead = this.createBlankNodeRdfList(literalNodes, triples);
+    const dataRangeNode = blankNode();
     triples.push(this.quadWithGraph(dataRangeNode, namedNode(RDF.type), namedNode(RDFS.Datatype)));
     triples.push(this.quadWithGraph(dataRangeNode, namedNode(OWL.oneOf), listHead));
     triples.push(this.quadWithGraph(scalarNode, namedNode(OWL.equivalentClass), dataRangeNode));
@@ -1005,7 +1002,7 @@ export class Oml2OwlMapper {
     axiom: ScalarEquivalenceAxiom,
     ctx: MappingContext,
     triples: Quad[],
-  ): Array<ReturnType<typeof namedNode>> {
+  ): TermNode[] {
     const facets: Array<{ iri: string; value: Quad_Object }> = [];
 
     axiom.length.forEach((value) => {
@@ -1061,10 +1058,10 @@ export class Oml2OwlMapper {
 
     return datatypes.map((datatypeIri) => {
       const facetSignature = facets.map((facet) => `${facet.iri}=${this.termKey(facet.value)}`).join('|');
-      const restrictionNode = skolemize(ctx.namespace, 'restriction', 'datatype', datatypeIri, facetSignature);
+      const restrictionNode = blankNode();
       triples.push(this.quadWithGraph(restrictionNode, namedNode(OWL.onDatatype), namedNode(datatypeIri)));
       const restrictionItems = facets.map((facet, index) => {
-        const facetNode = skolemize(ctx.namespace, 'restriction-facet', datatypeIri, String(index), facet.iri, this.termKey(facet.value));
+        const facetNode = blankNode();
         triples.push(this.quadWithGraph(facetNode, namedNode(facet.iri), facet.value));
         return facetNode;
       });
@@ -1078,7 +1075,7 @@ export class Oml2OwlMapper {
     axiom: PropertyRestrictionAxiom,
     ctx: MappingContext,
     triples: Quad[],
-  ): ReturnType<typeof namedNode> | undefined {
+  ): TermNode | undefined {
     if (isPropertyRangeRestrictionAxiom(axiom)) {
       return this.mapRangeRestriction(axiom, ctx, triples);
     }
@@ -1098,11 +1095,11 @@ export class Oml2OwlMapper {
     axiom: PropertyRangeRestrictionAxiom,
     ctx: MappingContext,
     triples: Quad[],
-  ): ReturnType<typeof namedNode> | undefined {
+  ): TermNode | undefined {
     const propertyIri = this.resolveIri(axiom.property, ctx);
     const rangeIri = this.resolveIri(axiom.range, ctx);
     if (!propertyIri || !rangeIri) return undefined;
-    const node = skolemize(ctx.namespace, 'restriction', propertyIri, axiom.kind, rangeIri, 'range');
+    const node = blankNode();
 
     triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Restriction)));
     triples.push(this.quadWithGraph(node, namedNode(OWL.onProperty), namedNode(propertyIri)));
@@ -1115,12 +1112,12 @@ export class Oml2OwlMapper {
     axiom: PropertyCardinalityRestrictionAxiom,
     ctx: MappingContext,
     triples: Quad[],
-  ): ReturnType<typeof namedNode> | undefined {
+  ): TermNode | undefined {
     const propertyIri = this.resolveIri(axiom.property, ctx);
     if (!propertyIri) return undefined;
     const resolvedProperty = (axiom.property as any)?.ref as SemanticProperty | undefined;
     const rangeIri = this.resolveIri(axiom.range, ctx) ?? '';
-    const node = skolemize(ctx.namespace, 'restriction', propertyIri, axiom.kind, String(axiom.cardinality), rangeIri);
+    const node = blankNode();
     triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Restriction)));
     triples.push(this.quadWithGraph(node, namedNode(OWL.onProperty), namedNode(propertyIri)));
     if (rangeIri) {
@@ -1141,15 +1138,10 @@ export class Oml2OwlMapper {
     axiom: PropertyValueRestrictionAxiom,
     ctx: MappingContext,
     triples: Quad[],
-  ): ReturnType<typeof namedNode> | undefined {
+  ): TermNode | undefined {
     const propertyIri = this.resolveIri(axiom.property, ctx);
     if (!propertyIri) return undefined;
-    const valueSeed = axiom.literalValue
-      ? this.literalKey(axiom.literalValue, ctx)
-      : axiom.referencedValue
-        ? this.resolveIri(axiom.referencedValue, ctx) ?? ''
-        : 'contained';
-    const node = skolemize(ctx.namespace, 'restriction', propertyIri, 'hasValue', valueSeed);
+    const node = blankNode();
     triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Restriction)));
     triples.push(this.quadWithGraph(node, namedNode(OWL.onProperty), namedNode(propertyIri)));
 
@@ -1175,10 +1167,10 @@ export class Oml2OwlMapper {
     axiom: PropertySelfRestrictionAxiom,
     ctx: MappingContext,
     triples: Quad[],
-  ): ReturnType<typeof namedNode> | undefined {
+  ): TermNode | undefined {
     const propertyIri = this.resolveIri(axiom.property, ctx);
     if (!propertyIri) return undefined;
-    const node = skolemize(ctx.namespace, 'restriction', propertyIri, 'hasSelf');
+    const node = blankNode();
     triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Restriction)));
     triples.push(this.quadWithGraph(node, namedNode(OWL.onProperty), namedNode(propertyIri)));
     triples.push(this.quadWithGraph(node, namedNode(OWL.hasSelf), literal('true', namedNode(XSD.boolean))));
@@ -1261,19 +1253,40 @@ export class Oml2OwlMapper {
     items: Quad_Object[],
     triples: Quad[],
     listSeed: string,
-  ): ReturnType<typeof namedNode> {
+  ): TermNode {
     if (!items.length) {
       return namedNode(RDF.nil);
     }
-    const base = `${listSeed}|${items.map((item) => this.termKey(item)).join('|')}`;
-    const head = skolemize(ctx.namespace, 'list', base, '0');
+    const head = blankNode();
     let current = head;
     items.forEach((item, index) => {
       triples.push(this.quadWithGraph(current, namedNode(RDF.first), item));
       if (index === items.length - 1) {
         triples.push(this.quadWithGraph(current, namedNode(RDF.rest), namedNode(RDF.nil)));
       } else {
-        const next = skolemize(ctx.namespace, 'list', base, String(index + 1));
+        const next = blankNode();
+        triples.push(this.quadWithGraph(current, namedNode(RDF.rest), next));
+        current = next;
+      }
+    });
+    return head;
+  }
+
+  private createBlankNodeRdfList(
+    items: Quad_Object[],
+    triples: Quad[],
+  ): ReturnType<typeof blankNode> | ReturnType<typeof namedNode> {
+    if (!items.length) {
+      return namedNode(RDF.nil);
+    }
+    const head = blankNode();
+    let current = head;
+    items.forEach((item, index) => {
+      triples.push(this.quadWithGraph(current, namedNode(RDF.first), item));
+      if (index === items.length - 1) {
+        triples.push(this.quadWithGraph(current, namedNode(RDF.rest), namedNode(RDF.nil)));
+      } else {
+        const next = blankNode();
         triples.push(this.quadWithGraph(current, namedNode(RDF.rest), next));
         current = next;
       }
@@ -1286,7 +1299,7 @@ export class Oml2OwlMapper {
     items: Quad_Object[],
     triples: Quad[],
     listSeed: string,
-  ): ReturnType<typeof namedNode> {
+  ): TermNode {
     const head = this.createRdfList(ctx, items, triples, listSeed);
     if (head.value === RDF.nil) {
       return head;
@@ -1295,12 +1308,11 @@ export class Oml2OwlMapper {
     while (current.value !== RDF.nil) {
       triples.push(this.quadWithGraph(current, namedNode(RDF.type), namedNode(SWRL.AtomList)));
       const next = triples.find(
-        (quad) => quad.subject.termType === 'NamedNode'
-          && quad.subject.value === current.value
+        (quad) => quad.subject.value === current.value
           && quad.predicate.value === RDF.rest
-          && quad.object.termType === 'NamedNode',
+          && (quad.object.termType === 'NamedNode' || quad.object.termType === 'BlankNode'),
       )?.object;
-      if (!next || next.termType !== 'NamedNode') {
+      if (!next || (next.termType !== 'NamedNode' && next.termType !== 'BlankNode')) {
         break;
       }
       current = next;
@@ -1437,11 +1449,6 @@ export class Oml2OwlMapper {
     return `${term.termType}:${term.value}`;
   }
 
-  private literalKey(value: Literal, ctx: MappingContext): string {
-    const term = this.toLiteral(value, ctx);
-    return term ? this.termKey(term) : '';
-  }
-
   private toLiteral(value: Literal, ctx: MappingContext): Quad_Object | undefined {
     if (isBooleanLiteral(value)) {
       return literal(String(value.value), namedNode(XSD.boolean));

package/src/owl/owl-service.ts

@@ -2,7 +2,7 @@
 
 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 { OmlIndex, 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';
@@ -33,7 +33,7 @@ export class ReasoningService {
     private readonly aboxEntailmentCache: OwlABoxEntailmentState;
     private readonly importGraph: OwlImportGraph;
     private readonly sparqlService: OwlSparqlService;
-    private readonly ontologyModelIndex: OntologyModelIndex;
+    private readonly ontologyModelIndex: OmlIndex;
     private readonly preparedModelAliases = new Map<string, string>();
     private readonly activeDocuments = new Set<string>();
     private readonly modelLoadInFlight = new Map<string, Promise<void>>();
@@ -166,11 +166,11 @@ export class ReasoningService {
         return { complete, iterations, newQuadsCount, validationWarnings: [] };
     }
 
-    removeModel(modelUri: string): void {
+    onDocumentDeleted(document: LangiumDocument): void {
+        const modelUri = document.uri.toString();
         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);
@@ -241,6 +241,27 @@ export class ReasoningService {
         await this.ensureContextDatasetReady(resolvedModelUri);
     }
 
+    async getContextMemberLabelSnapshot(modelUri: string): Promise<Record<string, string>> {
+        const resolvedModelUri = this.resolveQueryModelUri(modelUri);
+        await this.ensureWorkspaceBuilt();
+        await this.ensureModelLoaded(resolvedModelUri);
+        await this.ensureContextDatasetReady(resolvedModelUri);
+        const modelUris = [resolvedModelUri, ...this.importGraph.dependenciesOf(resolvedModelUri)]
+            .map((uri) => this.resolveDocumentModelUri(uri))
+            .filter((uri): uri is string => Boolean(uri));
+        await this.ensureOntologyDocumentsLoaded(modelUris);
+        return this.ontologyModelIndex.getMemberLabelSnapshot(modelUris);
+    }
+
+    async getWorkspaceMemberLabelSnapshot(): Promise<Record<string, string>> {
+        await this.ensureWorkspaceBuilt();
+        const modelUris = [...new Set(this.preparedModelAliases.values())]
+            .map((uri) => this.resolveDocumentModelUri(uri))
+            .filter((uri): uri is string => Boolean(uri));
+        await this.ensureOntologyDocumentsLoaded(modelUris);
+        return this.ontologyModelIndex.getMemberLabelSnapshot(modelUris);
+    }
+
     getContextIri(modelUri: string): string {
         return this.resolveOntologyIriForModelUri(this.resolveQueryModelUri(modelUri));
     }
@@ -248,16 +269,16 @@ export class ReasoningService {
     setActiveDocuments(modelUris: string[]): void {
         this.activeDocuments.clear();
         for (const modelUri of modelUris) {
-            this.activeDocuments.add(modelUri);
+            this.activeDocuments.add(resolveCanonicalWorkspaceModelUri(modelUri));
         }
     }
 
     markDocumentActive(modelUri: string): void {
-        this.activeDocuments.add(modelUri);
+        this.activeDocuments.add(resolveCanonicalWorkspaceModelUri(modelUri));
     }
 
     markDocumentInactive(modelUri: string): void {
-        this.activeDocuments.delete(modelUri);
+        this.activeDocuments.delete(resolveCanonicalWorkspaceModelUri(modelUri));
     }
 
     private extractImportedModelUris(ontology: Ontology): string[] {
@@ -360,11 +381,13 @@ export class ReasoningService {
                 if (!document) {
                     try {
                         document = await this.services.shared.workspace.LangiumDocuments.getOrCreateDocument(uri);
-                    } catch {
+                    } catch (error) {
                         // 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}'.`);
+                            const wrapped = new Error(`Unable to access model document '${modelUri}'.`);
+                            (wrapped as any).cause = error;
+                            throw wrapped;
                         }
                     }
                 }
@@ -384,6 +407,29 @@ export class ReasoningService {
         }
     }
 
+    private async ensureOntologyDocumentsLoaded(modelUris: Iterable<string>): Promise<void> {
+        const documents = this.services.shared.workspace.LangiumDocuments;
+        const builder = this.services.shared.workspace.DocumentBuilder;
+        const loadTargets: LangiumDocument[] = [];
+        for (const modelUri of new Set(modelUris)) {
+            const uri = URI.parse(modelUri);
+            const document = documents.getDocument(uri)
+                ?? (typeof documents.getOrCreateDocument === 'function'
+                    ? await documents.getOrCreateDocument(uri)
+                    : undefined);
+            if (!document) {
+                continue;
+            }
+            if ((document as any).state >= DocumentState.Linked) {
+                continue;
+            }
+            loadTargets.push(document);
+        }
+        if (loadTargets.length > 0) {
+            await builder.build(loadTargets, { validation: false });
+        }
+    }
+
     private async ensureWorkspaceBuilt(): Promise<void> {
         if (this.workspaceBuilt) {
             return;
@@ -495,11 +541,12 @@ export class ReasoningService {
     }
 
     async countContextDatasetQuads(modelUri: string): Promise<number> {
+        const resolvedModelUri = this.resolveQueryModelUri(modelUri);
         await this.ensureWorkspaceBuilt();
-        await this.ensureModelLoaded(modelUri);
-        await this.ensureContextDatasetReady(modelUri);
+        await this.ensureModelLoaded(resolvedModelUri);
+        await this.ensureContextDatasetReady(resolvedModelUri);
         const store = this.reasoningStore.getStore();
-        const queryGraphs = this.resolveContextGraphs(modelUri);
+        const queryGraphs = this.resolveContextGraphs(resolvedModelUri);
         let total = 0;
         for (const graph of queryGraphs) {
             total += store.countQuads(null, null, null, graph);
@@ -508,16 +555,37 @@ export class ReasoningService {
     }
 
     private resolveWorkspaceModelUri(uri: string): string | undefined {
-        const prepared = this.preparedModelAliases.get(uri);
+        const canonicalUri = resolveCanonicalWorkspaceModelUri(uri);
+        const prepared = this.preparedModelAliases.get(uri) ?? this.preparedModelAliases.get(canonicalUri);
         if (prepared) {
             return prepared;
         }
-        if (isWorkspaceModelUri(uri)) {
-            return uri;
+        if (isWorkspaceModelUri(canonicalUri)) {
+            return canonicalUri;
         }
         return this.ontologyModelIndex.resolveModelUri(uri);
     }
 
+    private resolveDocumentModelUri(uri: string): string | undefined {
+        const normalizedUri = uri.trim();
+        if (!normalizedUri) {
+            return undefined;
+        }
+        if (isWorkspaceModelUri(normalizedUri)) {
+            return normalizedUri;
+        }
+        const indexed = this.ontologyModelIndex.resolveModelUri(normalizedUri);
+        if (indexed) {
+            return indexed;
+        }
+        const canonicalUri = resolveCanonicalWorkspaceModelUri(normalizedUri);
+        const prepared = this.preparedModelAliases.get(normalizedUri) ?? this.preparedModelAliases.get(canonicalUri);
+        if (!prepared || prepared === normalizedUri) {
+            return undefined;
+        }
+        return this.ontologyModelIndex.resolveModelUri(prepared) ?? (isWorkspaceModelUri(prepared) ? prepared : undefined);
+    }
+
     private resolveLoadedDependencyOrder(modelUri: string): string[] {
         const ordered = [...this.importGraph.dependenciesOf(modelUri), modelUri];
         const seen = new Set<string>();
@@ -605,6 +673,18 @@ function isWorkspaceModelUri(modelUri: string): boolean {
     }
 }
 
+export function resolveCanonicalWorkspaceModelUri(modelUri: string): string {
+    try {
+        const parsed = URI.parse(modelUri);
+        if (!parsed.path.toLowerCase().endsWith('.oml')) {
+            return modelUri;
+        }
+        return parsed.with({ query: '', fragment: '' }).toString();
+    } catch {
+        return modelUri;
+    }
+}
+
 const BUILT_IN_ONTOLOGIES = new Set([
     'http://www.w3.org/2001/XMLSchema',
     'http://www.w3.org/1999/02/22-rdf-syntax-ns',

package/src/owl/owl-shacl.ts

@@ -36,6 +36,7 @@ type ParsedShaclNodeShape = {
     targetClasses: Term[];
     targetNodes: Term[];
     columns: ParsedShaclColumn[];
+    includeEntailments: boolean;
 };
 
 type ConnectionLike = {
@@ -58,7 +59,7 @@ const SH_PATH = 'http://www.w3.org/ns/shacl#path';
 const SH_PROPERTY = 'http://www.w3.org/ns/shacl#property';
 const SH_TARGET_CLASS = 'http://www.w3.org/ns/shacl#targetClass';
 const SH_TARGET_NODE = 'http://www.w3.org/ns/shacl#targetNode';
-
+const OML_ENTAILED = 'http://opencaesar.io/oml#entailed';
 export class ShaclService implements OwlShaclService {
     constructor(
         private readonly sparqlService: OwlSparqlService,
@@ -219,11 +220,15 @@ export function deriveSelectQueryFromShacl(shaclSource: string, graphIri: string
     ].join(' ');
     const whereLines: string[] = [];
     const graphLines: string[] = [];
+    const graphPattern = (pattern: string): string =>
+        nodeShape.includeEntailments
+            ? `{ GRAPH <${escapeIriForSparql(graphIri)}> { ${pattern} } } UNION { GRAPH <${escapeIriForSparql(`${graphIri}__entailments`)}> { ${pattern} } }`
+            : `GRAPH <${escapeIriForSparql(graphIri)}> { ${pattern} }`;
 
     if (nodeShape.targetClasses.length > 0) {
         const values = nodeShape.targetClasses.map((term: Term) => `<${term.value}>`).join(' ');
         whereLines.push(`  VALUES ?__targetClass { ${values} }`);
-        graphLines.push('    ?focus a ?__targetClass .');
+        graphLines.push(`    ${graphPattern('?focus a ?__targetClass .')}`);
     }
 
     if (nodeShape.targetNodes.length > 0) {
@@ -232,12 +237,9 @@ export function deriveSelectQueryFromShacl(shaclSource: string, graphIri: string
     }
 
     for (const entry of variables) {
-        graphLines.push(`    OPTIONAL { ?focus <${entry.path}> ?${entry.sourceVariable} . }`);
+        graphLines.push(`    OPTIONAL { ${graphPattern(`?focus <${entry.path}> ?${entry.sourceVariable} .`)} }`);
     }
-
-    whereLines.push(`  GRAPH <${escapeIriForSparql(graphIri)}> {`);
     whereLines.push(...graphLines);
-    whereLines.push('  }');
 
     const columnVariables = ['focus', ...variables.map((entry) => entry.variable)];
     const columnLabels = new Map<string, string>([['focus', 'focus']]);
@@ -307,11 +309,14 @@ function parsePrimaryNodeShape(shapeQuads: readonly Quad[]): ParsedShaclNodeShap
                 };
             })
             .filter((column): column is ParsedShaclColumn => Boolean(column));
+        const includeEntailments = getObjects(shapesStore, shapeTerm, SH_PROPERTY)
+            .some((term) => isEntailedShape(shapesStore, term));
 
         return {
             targetClasses,
             targetNodes,
             columns,
+            includeEntailments,
         };
     }
 
@@ -344,8 +349,12 @@ function isDeactivatedShape(store: N3Store, subject: Term): boolean {
     return getObjects(store, subject, SH_DEACTIVATED).some((term) => isTruthyLiteral(term));
 }
 
-function isTruthyLiteral(term: Term): boolean {
-    return term.termType === 'Literal' && (term.value === 'true' || term.value === '1');
+function isTruthyLiteral(term: Term | undefined): boolean {
+    return term?.termType === 'Literal' && (term.value === 'true' || term.value === '1');
+}
+
+function isEntailedShape(store: N3Store, subject: Term): boolean {
+    return getObjects(store, subject, OML_ENTAILED).some((term) => isTruthyLiteral(term));
 }
 
 function getObjects(store: N3Store, subject: Term, predicateIri: string): Term[] {