@oml/owl 0.7.0

package/out/owl/owl-abox.js

@@ -0,0 +1,765 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+import { DataFactory } from 'n3';
+const { namedNode, quad } = DataFactory;
+const RDF_TYPE = namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+export class ABoxEntailmentCache {
+    constructor() {
+        this.state = new Map();
+        this.deltaPlus = new Map();
+        this.deltaMinus = new Map();
+        this.validationWarnings = new Map();
+    }
+    markDirty(modelUri) {
+        this.state.set(modelUri, 'dirty');
+    }
+    markDirtyWithDelta(modelUri, asserted, retracted) {
+        if (asserted.length > 0) {
+            const plus = this.deltaPlus.get(modelUri) ?? new Map();
+            for (const q of asserted) {
+                plus.set(this.quadKey(q), q);
+            }
+            this.deltaPlus.set(modelUri, plus);
+        }
+        if (retracted.length > 0) {
+            const minus = this.deltaMinus.get(modelUri) ?? new Map();
+            for (const q of retracted) {
+                minus.set(this.quadKey(q), q);
+            }
+            this.deltaMinus.set(modelUri, minus);
+        }
+        this.markDirty(modelUri);
+    }
+    markClean(modelUri) {
+        this.state.set(modelUri, 'clean');
+    }
+    markDirtyAll(modelUris) {
+        for (const modelUri of modelUris) {
+            this.markDirty(modelUri);
+        }
+    }
+    isDirty(modelUri) {
+        return this.state.get(modelUri) === 'dirty';
+    }
+    isAbsent(modelUri) {
+        const value = this.state.get(modelUri);
+        return value === undefined || value === 'absent';
+    }
+    consumeDelta(modelUri) {
+        const plus = [...(this.deltaPlus.get(modelUri)?.values() ?? [])];
+        const minus = [...(this.deltaMinus.get(modelUri)?.values() ?? [])];
+        this.deltaPlus.delete(modelUri);
+        this.deltaMinus.delete(modelUri);
+        return { plus, minus };
+    }
+    getValidationWarnings(modelUri) {
+        return this.validationWarnings.get(modelUri) ?? [];
+    }
+    setValidationWarnings(modelUri, warnings) {
+        this.validationWarnings.set(modelUri, [...new Set(warnings)]);
+    }
+    invalidate(modelUri) {
+        this.state.delete(modelUri);
+        this.deltaPlus.delete(modelUri);
+        this.deltaMinus.delete(modelUri);
+        this.validationWarnings.delete(modelUri);
+    }
+    quadKey(q) {
+        return `${q.subject.id}|${q.predicate.id}|${q.object.id}|${q.graph.id}`;
+    }
+}
+export class ABoxChainer {
+    constructor(reasoningStore) {
+        this.reasoningStore = reasoningStore;
+    }
+    chain(modelUri, tboxIndex, readModelUris, deltaPlus, deltaMinus) {
+        const scope = this.resolveScope(modelUri, readModelUris);
+        const store = this.reasoningStore.getStore();
+        const index = this.buildIndex(scope.facts);
+        const plusFacts = deltaPlus.map((q) => this.asFact(q));
+        const minusFacts = deltaMinus.map((q) => this.asFact(q));
+        const fullRecompute = plusFacts.length === 0 && minusFacts.length === 0;
+        let iterations = 0;
+        let newQuadsCount = 0;
+        if (fullRecompute) {
+            for (const key of [...scope.ownEntKeys]) {
+                const fact = scope.facts.get(key);
+                if (fact) {
+                    this.removeOwnEntailedFact(scope, index, store, fact);
+                }
+            }
+        }
+        const over = fullRecompute ? [] : this.overdelete(scope, index, tboxIndex, minusFacts, store);
+        const seed = fullRecompute ? scope.ownBaseFacts : [...plusFacts, ...over];
+        const result = this.materializeAdd(scope, index, tboxIndex, seed, store);
+        iterations += result.iterations;
+        newQuadsCount += result.newQuads;
+        return {
+            complete: true,
+            iterations,
+            newQuadsCount,
+            validationWarnings: this.collectValidationWarnings(index, tboxIndex),
+        };
+    }
+    overdelete(scope, index, tbox, minusFacts, store) {
+        const queue = [...minusFacts];
+        const overByKey = new Map();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current) {
+                continue;
+            }
+            for (const head of this.reverseAnchoredHeads(current, index, tbox)) {
+                const key = this.factKey(head);
+                if (!scope.ownEntKeys.has(key)) {
+                    continue;
+                }
+                this.removeOwnEntailedFact(scope, index, store, head);
+                overByKey.set(key, head);
+                queue.push(head);
+            }
+        }
+        return [...overByKey.values()];
+    }
+    materializeAdd(scope, index, tbox, seedFacts, store) {
+        const queue = [];
+        const queued = new Set();
+        let iterations = 0;
+        let newQuads = 0;
+        const enqueue = (fact) => {
+            const key = this.factKey(fact);
+            if (queued.has(key)) {
+                return;
+            }
+            queue.push(fact);
+            queued.add(key);
+        };
+        for (const seed of seedFacts) {
+            const key = this.factKey(seed);
+            if (scope.baseKeys.has(key)) {
+                enqueue(seed);
+                continue;
+            }
+            if (!this.canInsertEntailedFact(scope, seed) || !this.hasSupport(seed, index, tbox)) {
+                continue;
+            }
+            this.insertOwnEntailedFact(scope, index, store, seed);
+            newQuads += 1;
+            enqueue(seed);
+        }
+        while (queue.length > 0) {
+            const fact = queue.shift();
+            if (!fact) {
+                continue;
+            }
+            iterations += 1;
+            for (const head of this.forwardRules(fact, index, tbox)) {
+                if (!this.canInsertEntailedFact(scope, head) || !this.hasSupport(head, index, tbox)) {
+                    continue;
+                }
+                this.insertOwnEntailedFact(scope, index, store, head);
+                newQuads += 1;
+                enqueue(head);
+            }
+        }
+        return { iterations, newQuads };
+    }
+    forwardRules(fact, index, tbox) {
+        const heads = [];
+        if (this.isTypeFact(fact)) {
+            for (const superClass of this.getSuperClasses(tbox, fact.object.value)) {
+                if (superClass !== fact.object.value) {
+                    heads.push(this.typeFact(fact.subject, superClass));
+                }
+            }
+        }
+        const p = fact.predicate.value;
+        const x = fact.subject;
+        const y = fact.object;
+        for (const q of this.getSuperProperties(tbox, p)) {
+            if (q !== p) {
+                heads.push(this.edgeFact(x, q, y));
+            }
+        }
+        for (const d of this.getDomains(tbox, p)) {
+            heads.push(this.typeFact(x, d));
+        }
+        if (y.termType !== 'Literal') {
+            for (const c of this.getObjectRanges(tbox, p)) {
+                heads.push(this.typeFact(y, c));
+            }
+            for (const inverse of this.getInverses(tbox, p)) {
+                heads.push(this.edgeFact(y, inverse, x));
+            }
+            if (this.isSymmetricProperty(tbox, p)) {
+                heads.push(this.edgeFact(y, p, x));
+            }
+            if (this.isTransitiveProperty(tbox, p)) {
+                for (const next of this.getEdgeFacts(index, y, p)) {
+                    heads.push(this.edgeFact(x, p, next.object));
+                }
+                for (const prev of this.getIncomingEdgesByProperty(index, x, p)) {
+                    heads.push(this.edgeFact(prev.subject, p, y));
+                }
+            }
+        }
+        heads.push(...this.applyForwardRulesTriggeredByFact(fact, index, tbox));
+        return this.uniqueFacts(heads);
+    }
+    reverseAnchoredHeads(fact, index, tbox) {
+        return this.forwardRules(fact, index, tbox);
+    }
+    hasSupport(fact, index, tbox) {
+        if (index.facts.has(this.factKey(fact))) {
+            return true;
+        }
+        if (this.isTypeFact(fact)) {
+            const types = this.getTypes(index, fact.subject);
+            for (const type of types) {
+                if (type === fact.object.value || this.getSuperClasses(tbox, type).includes(fact.object.value)) {
+                    return true;
+                }
+            }
+            for (const edge of this.getOutgoingEdges(index, fact.subject)) {
+                if (this.getDomains(tbox, edge.predicate.value).includes(fact.object.value)) {
+                    return true;
+                }
+            }
+            for (const edge of this.getIncomingEdges(index, fact.subject)) {
+                if (edge.object.termType !== 'Literal' && this.getObjectRanges(tbox, edge.predicate.value).includes(fact.object.value)) {
+                    return true;
+                }
+            }
+            if (this.hasForwardRuleSupport(fact, index, tbox)) {
+                return true;
+            }
+            return false;
+        }
+        const x = fact.subject;
+        const p = fact.predicate.value;
+        const y = fact.object;
+        for (const edge of this.getOutgoingEdges(index, x)) {
+            if (edge.object.id === y.id && this.getSuperProperties(tbox, edge.predicate.value).includes(p)) {
+                return true;
+            }
+        }
+        if (y.termType !== 'Literal') {
+            for (const edge of this.getOutgoingEdges(index, y)) {
+                if (edge.object.id === x.id && this.getInverses(tbox, edge.predicate.value).includes(p)) {
+                    return true;
+                }
+                if (edge.object.id === x.id && edge.predicate.value === p && this.isSymmetricProperty(tbox, p)) {
+                    return true;
+                }
+            }
+            if (this.isTransitiveProperty(tbox, p) && this.hasTransitiveSupport(index, x, p, y)) {
+                return true;
+            }
+        }
+        if (this.hasForwardRuleSupport(fact, index, tbox)) {
+            return true;
+        }
+        return false;
+    }
+    hasTransitiveSupport(index, subject, property, object) {
+        for (const left of this.getEdgeFacts(index, subject, property)) {
+            if (left.object.id === object.id || left.object.termType === 'Literal') {
+                continue;
+            }
+            for (const right of this.getEdgeFacts(index, left.object, property)) {
+                if (right.object.id === object.id) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    applyForwardRulesTriggeredByFact(fact, index, tbox) {
+        const heads = [];
+        for (const rule of tbox.forwardRules) {
+            rule.body.forEach((atom, anchorIndex) => {
+                const bindings = this.matchAtomToFact(atom, fact, new Map());
+                if (!bindings) {
+                    return;
+                }
+                for (const resolved of this.resolveRuleBody(rule.body, index, bindings, anchorIndex)) {
+                    for (const head of rule.head) {
+                        const inferred = this.instantiateRuleAtom(head, resolved);
+                        if (inferred) {
+                            heads.push(inferred);
+                        }
+                    }
+                }
+            });
+        }
+        return this.uniqueFacts(heads);
+    }
+    hasForwardRuleSupport(fact, index, tbox) {
+        for (const rule of tbox.forwardRules) {
+            for (const head of rule.head) {
+                const bindings = this.matchAtomToFact(head, fact, new Map());
+                if (!bindings) {
+                    continue;
+                }
+                const resolved = this.resolveRuleBody(rule.body, index, bindings, -1);
+                if (resolved.length > 0) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    resolveRuleBody(body, index, bindings, satisfiedIndex) {
+        const pending = body.filter((_atom, index) => index !== satisfiedIndex);
+        return this.resolvePendingAtoms(pending, index, bindings);
+    }
+    resolvePendingAtoms(pending, index, bindings) {
+        if (pending.length === 0) {
+            return [bindings];
+        }
+        const [current, ...rest] = pending;
+        const matches = this.findMatchesForAtom(current, index, bindings);
+        const resolved = [];
+        for (const nextBindings of matches) {
+            resolved.push(...this.resolvePendingAtoms(rest, index, nextBindings));
+        }
+        return resolved;
+    }
+    findMatchesForAtom(atom, index, bindings) {
+        const matches = [];
+        for (const fact of this.candidateFacts(atom, index, bindings)) {
+            const nextBindings = this.matchAtomToFact(atom, fact, bindings);
+            if (nextBindings) {
+                matches.push(nextBindings);
+            }
+        }
+        return matches;
+    }
+    candidateFacts(atom, index, bindings) {
+        if (atom.kind === 'class') {
+            const bound = this.resolvePatternTerm(atom.argument, bindings);
+            if (bound) {
+                return [...this.getTypes(index, bound)].map((classIri) => this.typeFact(bound, classIri));
+            }
+            const subjects = index.subjectsByType.get(atom.classIri) ?? new Set();
+            return [...subjects]
+                .map((subjectKey) => index.termByKey.get(subjectKey))
+                .filter((term) => Boolean(term))
+                .map((subject) => this.typeFact(subject, atom.classIri));
+        }
+        const left = this.resolvePatternTerm(atom.argument1, bindings);
+        const right = this.resolvePatternTerm(atom.argument2, bindings);
+        if (left) {
+            return this.getEdgeFacts(index, left, atom.propertyIri);
+        }
+        if (right) {
+            return this.getIncomingEdgesByProperty(index, right, atom.propertyIri);
+        }
+        return index.edgeFactsByProperty.get(atom.propertyIri) ?? [];
+    }
+    matchAtomToFact(atom, fact, bindings) {
+        if (atom.kind === 'class') {
+            if (!this.isTypeFact(fact) || fact.object.value !== atom.classIri) {
+                return undefined;
+            }
+            return this.matchPattern(atom.argument, fact.subject, bindings);
+        }
+        if (fact.predicate.value !== atom.propertyIri) {
+            return undefined;
+        }
+        const afterLeft = this.matchPattern(atom.argument1, fact.subject, bindings);
+        if (!afterLeft) {
+            return undefined;
+        }
+        return this.matchPattern(atom.argument2, fact.object, afterLeft);
+    }
+    matchPattern(pattern, term, bindings) {
+        if (pattern.kind === 'variable') {
+            const existing = bindings.get(pattern.name);
+            if (existing) {
+                return this.sameTerm(existing, term) ? bindings : undefined;
+            }
+            const next = new Map(bindings);
+            next.set(pattern.name, term);
+            return next;
+        }
+        if (pattern.kind === 'named') {
+            return term.termType === 'NamedNode' && term.value === pattern.iri ? bindings : undefined;
+        }
+        if (term.termType !== 'Literal') {
+            return undefined;
+        }
+        return term.value === pattern.value
+            && term.datatype.value === pattern.datatype
+            && term.language === pattern.language
+            ? bindings
+            : undefined;
+    }
+    resolvePatternTerm(pattern, bindings) {
+        if (pattern.kind === 'variable') {
+            return bindings.get(pattern.name);
+        }
+        if (pattern.kind === 'named') {
+            return namedNode(pattern.iri);
+        }
+        return DataFactory.literal(pattern.value, pattern.language || namedNode(pattern.datatype));
+    }
+    instantiateRuleAtom(atom, bindings) {
+        if (atom.kind === 'class') {
+            const subject = this.resolvePatternTerm(atom.argument, bindings);
+            if (!subject || subject.termType === 'Literal') {
+                return undefined;
+            }
+            return this.typeFact(subject, atom.classIri);
+        }
+        const subject = this.resolvePatternTerm(atom.argument1, bindings);
+        const object = this.resolvePatternTerm(atom.argument2, bindings);
+        if (!subject || !object || subject.termType === 'Literal') {
+            return undefined;
+        }
+        return this.edgeFact(subject, atom.propertyIri, object);
+    }
+    sameTerm(left, right) {
+        return left.termType === right.termType
+            && left.value === right.value
+            && (left.termType !== 'Literal'
+                || (right.termType === 'Literal'
+                    && left.datatype.value === right.datatype.value
+                    && left.language === right.language));
+    }
+    resolveScope(modelUri, readModelUris) {
+        const store = this.reasoningStore.getStore();
+        const facts = new Map();
+        const baseKeys = new Set();
+        const importEntKeys = new Set();
+        const ownEntKeys = new Set();
+        const ownBaseFacts = [];
+        const ownGraphs = this.reasoningStore.graphs(modelUri);
+        for (const uri of readModelUris) {
+            let graphs;
+            try {
+                graphs = this.reasoningStore.graphs(uri);
+            }
+            catch {
+                continue;
+            }
+            for (const q of store.getQuads(null, null, null, graphs.own)) {
+                const fact = this.asFact(q);
+                const key = this.factKey(fact);
+                facts.set(key, fact);
+                baseKeys.add(key);
+                if (uri === modelUri) {
+                    ownBaseFacts.push(fact);
+                }
+            }
+            for (const q of store.getQuads(null, null, null, graphs.entailments)) {
+                const fact = this.asFact(q);
+                const key = this.factKey(fact);
+                facts.set(key, fact);
+                if (uri === modelUri) {
+                    ownEntKeys.add(key);
+                }
+                else {
+                    importEntKeys.add(key);
+                }
+            }
+        }
+        return {
+            ownEntailmentGraph: ownGraphs.entailments,
+            ownBaseFacts: this.uniqueFacts(ownBaseFacts),
+            baseKeys,
+            importEntKeys,
+            ownEntKeys,
+            facts,
+        };
+    }
+    buildIndex(facts) {
+        const typesBySubject = new Map();
+        const subjectsByType = new Map();
+        const edgeFactsBySubjectProperty = new Map();
+        const edgeFactsByProperty = new Map();
+        const subjectsByPropertyObject = new Map();
+        const termByKey = new Map();
+        for (const fact of facts.values()) {
+            const sKey = fact.subject.id;
+            const oKey = fact.object.id;
+            termByKey.set(sKey, fact.subject);
+            termByKey.set(oKey, fact.object);
+            if (fact.predicate.value === RDF_TYPE.value && fact.object.termType === 'NamedNode') {
+                const values = typesBySubject.get(sKey) ?? new Set();
+                values.add(fact.object.value);
+                typesBySubject.set(sKey, values);
+                const subjects = subjectsByType.get(fact.object.value) ?? new Set();
+                subjects.add(sKey);
+                subjectsByType.set(fact.object.value, subjects);
+                continue;
+            }
+            const spKey = `${sKey}|${fact.predicate.value}`;
+            const bySp = edgeFactsBySubjectProperty.get(spKey) ?? [];
+            bySp.push(fact);
+            edgeFactsBySubjectProperty.set(spKey, bySp);
+            const byProperty = edgeFactsByProperty.get(fact.predicate.value) ?? [];
+            byProperty.push(fact);
+            edgeFactsByProperty.set(fact.predicate.value, byProperty);
+            const poKey = `${fact.predicate.value}|${oKey}`;
+            const subjects = subjectsByPropertyObject.get(poKey) ?? new Set();
+            subjects.add(sKey);
+            subjectsByPropertyObject.set(poKey, subjects);
+        }
+        return {
+            facts,
+            typesBySubject,
+            subjectsByType,
+            edgeFactsBySubjectProperty,
+            edgeFactsByProperty,
+            subjectsByPropertyObject,
+            termByKey,
+        };
+    }
+    insertOwnEntailedFact(scope, index, store, fact) {
+        const key = this.factKey(fact);
+        if (scope.ownEntKeys.has(key)) {
+            return;
+        }
+        scope.ownEntKeys.add(key);
+        scope.facts.set(key, fact);
+        index.facts.set(key, fact);
+        this.indexAdd(index, fact);
+        store.addQuad(quad(this.asQuadSubject(fact.subject), fact.predicate, this.asQuadObject(fact.object), scope.ownEntailmentGraph));
+    }
+    removeOwnEntailedFact(scope, index, store, fact) {
+        const key = this.factKey(fact);
+        if (!scope.ownEntKeys.has(key)) {
+            return;
+        }
+        scope.ownEntKeys.delete(key);
+        scope.facts.delete(key);
+        index.facts.delete(key);
+        this.indexRemove(index, fact);
+        store.removeQuad(quad(this.asQuadSubject(fact.subject), fact.predicate, this.asQuadObject(fact.object), scope.ownEntailmentGraph));
+    }
+    canInsertEntailedFact(scope, fact) {
+        const key = this.factKey(fact);
+        return !scope.baseKeys.has(key) && !scope.importEntKeys.has(key) && !scope.ownEntKeys.has(key);
+    }
+    getTypes(index, subject) {
+        return index.typesBySubject.get(subject.id) ?? new Set();
+    }
+    getEdgeFacts(index, subject, property) {
+        return index.edgeFactsBySubjectProperty.get(`${subject.id}|${property}`) ?? [];
+    }
+    getOutgoingEdges(index, subject) {
+        const edges = [];
+        const prefix = `${subject.id}|`;
+        for (const [key, facts] of index.edgeFactsBySubjectProperty.entries()) {
+            if (key.startsWith(prefix)) {
+                edges.push(...facts);
+            }
+        }
+        return edges;
+    }
+    getIncomingEdges(index, object) {
+        const edges = [];
+        const suffix = `|${object.id}`;
+        for (const [key, subjects] of index.subjectsByPropertyObject.entries()) {
+            if (!key.endsWith(suffix)) {
+                continue;
+            }
+            const property = key.slice(0, key.length - suffix.length);
+            for (const subjectKey of subjects) {
+                const subject = index.termByKey.get(subjectKey);
+                if (subject) {
+                    edges.push(...this.getEdgeFacts(index, subject, property));
+                }
+            }
+        }
+        return edges;
+    }
+    getIncomingEdgesByProperty(index, object, property) {
+        const subjects = index.subjectsByPropertyObject.get(`${property}|${object.id}`) ?? new Set();
+        const edges = [];
+        for (const subjectKey of subjects) {
+            const subject = index.termByKey.get(subjectKey);
+            if (subject) {
+                edges.push(...this.getEdgeFacts(index, subject, property));
+            }
+        }
+        return edges;
+    }
+    getSuperClasses(tbox, clazz) {
+        return tbox.superClasses.get(clazz) ?? [];
+    }
+    getSuperProperties(tbox, property) {
+        return tbox.subProperties.get(property) ?? [property];
+    }
+    getDomains(tbox, property) {
+        return tbox.domain.get(property) ?? [];
+    }
+    getObjectRanges(tbox, property) {
+        return tbox.objectRange.get(property) ?? [];
+    }
+    getInverses(tbox, property) {
+        return tbox.inverseRoles.get(property) ?? [];
+    }
+    isSymmetricProperty(tbox, property) {
+        return tbox.symmetricProperties.has(property);
+    }
+    isTransitiveProperty(tbox, property) {
+        return tbox.transitiveProperties.has(property);
+    }
+    typeFact(subject, classIri) {
+        return { subject, predicate: RDF_TYPE, object: namedNode(classIri) };
+    }
+    edgeFact(subject, propertyIri, object) {
+        return { subject, predicate: namedNode(propertyIri), object };
+    }
+    isTypeFact(fact) {
+        return fact.predicate.value === RDF_TYPE.value && fact.object.termType === 'NamedNode';
+    }
+    asFact(q) {
+        return {
+            subject: q.subject,
+            predicate: q.predicate,
+            object: q.object,
+        };
+    }
+    asQuadSubject(term) {
+        if (term.termType === 'NamedNode' || term.termType === 'BlankNode' || term.termType === 'Variable') {
+            return term;
+        }
+        throw new Error(`Invalid inferred subject term '${term.termType}'.`);
+    }
+    asQuadObject(term) {
+        if (term.termType === 'NamedNode'
+            || term.termType === 'BlankNode'
+            || term.termType === 'Variable'
+            || term.termType === 'Literal') {
+            return term;
+        }
+        throw new Error(`Invalid inferred object term '${term.termType}'.`);
+    }
+    factKey(fact) {
+        return `${fact.subject.id}|${fact.predicate.id}|${fact.object.id}`;
+    }
+    uniqueFacts(facts) {
+        const byKey = new Map();
+        for (const fact of facts) {
+            byKey.set(this.factKey(fact), fact);
+        }
+        return [...byKey.values()];
+    }
+    indexAdd(index, fact) {
+        index.termByKey.set(fact.subject.id, fact.subject);
+        index.termByKey.set(fact.object.id, fact.object);
+        if (fact.predicate.value === RDF_TYPE.value && fact.object.termType === 'NamedNode') {
+            const values = index.typesBySubject.get(fact.subject.id) ?? new Set();
+            values.add(fact.object.value);
+            index.typesBySubject.set(fact.subject.id, values);
+            const subjects = index.subjectsByType.get(fact.object.value) ?? new Set();
+            subjects.add(fact.subject.id);
+            index.subjectsByType.set(fact.object.value, subjects);
+            return;
+        }
+        const spKey = `${fact.subject.id}|${fact.predicate.value}`;
+        const bySp = index.edgeFactsBySubjectProperty.get(spKey) ?? [];
+        bySp.push(fact);
+        index.edgeFactsBySubjectProperty.set(spKey, bySp);
+        const byProperty = index.edgeFactsByProperty.get(fact.predicate.value) ?? [];
+        byProperty.push(fact);
+        index.edgeFactsByProperty.set(fact.predicate.value, byProperty);
+        const poKey = `${fact.predicate.value}|${fact.object.id}`;
+        const subjects = index.subjectsByPropertyObject.get(poKey) ?? new Set();
+        subjects.add(fact.subject.id);
+        index.subjectsByPropertyObject.set(poKey, subjects);
+    }
+    indexRemove(index, fact) {
+        if (fact.predicate.value === RDF_TYPE.value && fact.object.termType === 'NamedNode') {
+            const values = index.typesBySubject.get(fact.subject.id);
+            if (!values) {
+                return;
+            }
+            values.delete(fact.object.value);
+            if (values.size === 0) {
+                index.typesBySubject.delete(fact.subject.id);
+            }
+            const subjects = index.subjectsByType.get(fact.object.value);
+            if (subjects) {
+                subjects.delete(fact.subject.id);
+                if (subjects.size === 0) {
+                    index.subjectsByType.delete(fact.object.value);
+                }
+            }
+            return;
+        }
+        const spKey = `${fact.subject.id}|${fact.predicate.value}`;
+        const bySp = index.edgeFactsBySubjectProperty.get(spKey) ?? [];
+        const nextBySp = bySp.filter((entry) => this.factKey(entry) !== this.factKey(fact));
+        if (nextBySp.length === 0) {
+            index.edgeFactsBySubjectProperty.delete(spKey);
+        }
+        else {
+            index.edgeFactsBySubjectProperty.set(spKey, nextBySp);
+        }
+        const byProperty = index.edgeFactsByProperty.get(fact.predicate.value) ?? [];
+        const nextByProperty = byProperty.filter((entry) => this.factKey(entry) !== this.factKey(fact));
+        if (nextByProperty.length === 0) {
+            index.edgeFactsByProperty.delete(fact.predicate.value);
+        }
+        else {
+            index.edgeFactsByProperty.set(fact.predicate.value, nextByProperty);
+        }
+        const poKey = `${fact.predicate.value}|${fact.object.id}`;
+        const subjects = index.subjectsByPropertyObject.get(poKey);
+        if (!subjects) {
+            return;
+        }
+        const stillHas = nextBySp.some((entry) => entry.object.id === fact.object.id);
+        if (!stillHas) {
+            subjects.delete(fact.subject.id);
+        }
+        if (subjects.size === 0) {
+            index.subjectsByPropertyObject.delete(poKey);
+        }
+    }
+    collectValidationWarnings(index, tbox) {
+        const warnings = [];
+        for (const fact of index.facts.values()) {
+            if (fact.predicate.value === RDF_TYPE.value) {
+                continue;
+            }
+            const ranges = tbox.datatypeRange.get(fact.predicate.value) ?? [];
+            if (ranges.length === 0) {
+                continue;
+            }
+            if (fact.object.termType !== 'Literal') {
+                warnings.push(`Datatype range violation on ${fact.predicate.value}: expected literal object.`);
+                continue;
+            }
+            if (!ranges.includes(fact.object.datatype.value)) {
+                warnings.push(`Datatype range violation on ${fact.predicate.value}: expected ${ranges.join(', ')}, got ${fact.object.datatype.value}.`);
+            }
+        }
+        for (const [subjectProperty, facts] of index.edgeFactsBySubjectProperty.entries()) {
+            const [subjectId, property] = subjectProperty.split('|', 2);
+            if (subjectId.length === 0 || !tbox.functionalProperties.has(property)) {
+                continue;
+            }
+            const objectIds = [...new Set(facts.map((fact) => fact.object.id))];
+            if (objectIds.length > 1) {
+                warnings.push(`Functional property violation on ${property}: ${facts[0]?.subject.value ?? subjectId} has ${objectIds.length} distinct values.`);
+            }
+        }
+        for (const [propertyObject, subjectIds] of index.subjectsByPropertyObject.entries()) {
+            const split = propertyObject.indexOf('|');
+            const property = split >= 0 ? propertyObject.slice(0, split) : propertyObject;
+            const objectId = split >= 0 ? propertyObject.slice(split + 1) : '';
+            if (!tbox.inverseFunctionalProperties.has(property) || subjectIds.size <= 1) {
+                continue;
+            }
+            const object = index.termByKey.get(objectId);
+            const objectLabel = object?.value ?? objectId;
+            warnings.push(`Inverse-functional property violation on ${property}: ${objectLabel} has ${subjectIds.size} distinct sources.`);
+        }
+        return [...new Set(warnings)];
+    }
+}
+//# sourceMappingURL=owl-abox.js.map