@oml/owl 0.19.3 → 0.20.1

package/src/owl/owl-store-lean.ts

@@ -0,0 +1,438 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+// Memory-lean reasoning store (the default OwlStore implementation).
+//
+// Rationale: the n3 Store builds full S/P/O/G index Maps + Quad/Term object wrappers over every
+// quad (~1.3 KB/quad → ~1 GB on mass-props). The reasoners don't need general SPARQL indexing of
+// the canonical store (oxigraph owns querying via the mirror); they need per-graph scans, bound
+// pattern lookups over small graphs (TBox/SHACL), membership, and add/remove. LeanQuadStore stores
+// quads as interned uint32 term-id columns with per-graph + per-predicate id lists (~130 B/quad),
+// and exposes the n3-Store API subset the code actually calls — so it's a drop-in for the store
+// behind ReasoningStore, ~8–9x smaller and faster on those ops (benchmarked).
+//
+// There are no per-model Quad arrays: the ABox chainer reads scope facts via forEachAssertedFact/
+// forEachEntailedFact, which yield shared interned Term instances + a per-row cached key straight
+// from the columns — so a model's facts are re-read across dependents (~21x) without materializing
+// or retaining Quad objects, and without a separate factOf memo.
+
+import { DataFactory } from 'n3';
+import type { NamedNode, Quad, Store, Term } from 'n3';
+import type { ModelDiff, ModelGraphs } from './owl-store.js';
+import type { OwlStore, ScopeFactVisitor } from './owl-interfaces.js';
+
+const { namedNode, blankNode, literal, quad, defaultGraph } = DataFactory;
+const XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';
+
+// --- LeanQuadStore: interned-column quad store exposing the n3-Store API subset we use ----------
+
+const NULL_ID = -1;        // wildcard (term not bound in a query)
+const ABSENT_ID = -2;      // bound term that was never interned -> matches nothing
+
+class LeanQuadStore {
+    private readonly termToId = new Map<string, number>();
+    private readonly idToKey: string[] = [];
+    // Packed term-id columns; row index === quad id.
+    private readonly cs: number[] = [];
+    private readonly cp: number[] = [];
+    private readonly co: number[] = [];
+    private readonly cg: number[] = [];
+    private readonly graphRows = new Map<number, number[]>();
+    private readonly predRows = new Map<number, number[]>();
+    private readonly dead = new Set<number>();
+    // Caches for the chainer's scope-fact path: one shared Term instance per term id, and the dedup
+    // key (`${s.id}|${p.id}|${o.id}`) per row — computed once, reused across the ~21x re-reads.
+    private readonly idToTerm: (Term | undefined)[] = [];
+    private readonly rowKey: (string | undefined)[] = [];
+
+    private keyOfTerm(t: Term): string {
+        switch (t.termType) {
+            case 'NamedNode': return 'N\x00' + t.value;
+            case 'BlankNode': return 'B\x00' + t.value;
+            case 'DefaultGraph': return 'D';
+            default: {
+                const lit = t as { value: string; datatype?: { value: string }; language?: string };
+                const dt = lit.datatype ? lit.datatype.value : XSD_STRING;
+                return 'L\x00' + lit.value + '\x00' + dt + '\x00' + (lit.language || '');
+            }
+        }
+    }
+
+    private intern(key: string): number {
+        let id = this.termToId.get(key);
+        if (id === undefined) {
+            id = this.idToKey.length;
+            this.termToId.set(key, id);
+            this.idToKey.push(key);
+        }
+        return id;
+    }
+
+    // -1 for null/undefined (wildcard); -2 for a bound term that isn't interned (matches nothing).
+    private idOf(t: Term | null | undefined): number {
+        if (t === null || t === undefined) {
+            return NULL_ID;
+        }
+        const id = this.termToId.get(this.keyOfTerm(t));
+        return id === undefined ? ABSENT_ID : id;
+    }
+
+    private termAt(id: number): Term {
+        const k = this.idToKey[id];
+        const kind = k.charCodeAt(0);
+        if (kind === 78 /* N */) return namedNode(k.slice(2));
+        if (kind === 66 /* B */) return blankNode(k.slice(2));
+        if (kind === 68 /* D */) return defaultGraph();
+        const parts = k.slice(2).split('\x00');
+        const value = parts[0], dt = parts[1], lang = parts[2];
+        if (lang) return literal(value, lang);
+        if (dt && dt !== XSD_STRING) return literal(value, namedNode(dt));
+        return literal(value);
+    }
+
+    private materialize(row: number): Quad {
+        // Casts are safe: subjects are NamedNode/BlankNode, predicates NamedNode, objects any term,
+        // graphs NamedNode/DefaultGraph — guaranteed by how quads are inserted.
+        return quad(
+            this.termAt(this.cs[row]) as Quad['subject'],
+            this.termAt(this.cp[row]) as Quad['predicate'],
+            this.termAt(this.co[row]) as Quad['object'],
+            this.termAt(this.cg[row]) as Quad['graph'],
+        );
+    }
+
+    private addRow(si: number, pi: number, oi: number, gi: number): number {
+        const row = this.cs.length;
+        this.cs.push(si); this.cp.push(pi); this.co.push(oi); this.cg.push(gi);
+        let gl = this.graphRows.get(gi); if (!gl) { gl = []; this.graphRows.set(gi, gl); } gl.push(row);
+        let pl = this.predRows.get(pi); if (!pl) { pl = []; this.predRows.set(pi, pl); } pl.push(row);
+        return row;
+    }
+
+    private sharedTermAt(id: number): Term {
+        let t = this.idToTerm[id];
+        if (!t) { t = this.termAt(id); this.idToTerm[id] = t; }
+        return t;
+    }
+
+    private keyAt(row: number): string {
+        let k = this.rowKey[row];
+        if (k === undefined) {
+            k = `${this.sharedTermAt(this.cs[row]).id}|${this.sharedTermAt(this.cp[row]).id}|${this.sharedTermAt(this.co[row]).id}`;
+            this.rowKey[row] = k;
+        }
+        return k;
+    }
+
+    isDead(row: number): boolean {
+        return this.dead.has(row);
+    }
+
+    private visitFact(row: number, visit: (s: Term, p: NamedNode, o: Term, key: string) => void): void {
+        visit(this.sharedTermAt(this.cs[row]), this.sharedTermAt(this.cp[row]) as NamedNode, this.sharedTermAt(this.co[row]), this.keyAt(row));
+    }
+
+    // Scope-fact iteration for the ABox chainer: shared terms + cached keys, no Quad materialization.
+    forEachFactInGraph(graph: Term, visit: (s: Term, p: NamedNode, o: Term, key: string) => void): void {
+        const gid = this.idOf(graph);
+        if (gid < 0) return;
+        const rows = this.graphRows.get(gid);
+        if (!rows) return;
+        for (const r of rows) {
+            if (!this.dead.has(r)) this.visitFact(r, visit);
+        }
+    }
+
+    forEachFactInRows(rows: Iterable<number>, visit: (s: Term, p: NamedNode, o: Term, key: string) => void): void {
+        for (const r of rows) {
+            if (!this.dead.has(r)) this.visitFact(r, visit);
+        }
+    }
+
+    // Iterate rows matching the (possibly wildcard) pattern, skipping tombstoned rows.
+    private forEachMatch(si: number, pi: number, oi: number, gi: number, visit: (row: number) => void): void {
+        if (si === ABSENT_ID || pi === ABSENT_ID || oi === ABSENT_ID || gi === ABSENT_ID) {
+            return;
+        }
+        // Pick the most selective available index.
+        let candidates: number[] | undefined;
+        if (gi !== NULL_ID) candidates = this.graphRows.get(gi);
+        else if (pi !== NULL_ID) candidates = this.predRows.get(pi);
+        if (candidates) {
+            for (let i = 0; i < candidates.length; i++) {
+                const r = candidates[i];
+                if (this.dead.has(r)) continue;
+                if (si !== NULL_ID && this.cs[r] !== si) continue;
+                if (pi !== NULL_ID && this.cp[r] !== pi) continue;
+                if (oi !== NULL_ID && this.co[r] !== oi) continue;
+                if (gi !== NULL_ID && this.cg[r] !== gi) continue;
+                visit(r);
+            }
+            return;
+        }
+        // Full scan (no graph or predicate bound).
+        const n = this.cs.length;
+        for (let r = 0; r < n; r++) {
+            if (this.dead.has(r)) continue;
+            if (si !== NULL_ID && this.cs[r] !== si) continue;
+            if (pi !== NULL_ID && this.cp[r] !== pi) continue;
+            if (oi !== NULL_ID && this.co[r] !== oi) continue;
+            visit(r);
+        }
+    }
+
+    // --- n3-Store-compatible API (the subset used across the codebase) -----------------------
+
+    // Returns the new row id (used by LeanReasoningStore to track per-model entailment rows).
+    addQuad(subjectOrQuad: Quad | Term, predicate?: Term, object?: Term, graph?: Term): number {
+        let s: Term, p: Term, o: Term, g: Term;
+        if (predicate === undefined) {
+            const q = subjectOrQuad as Quad;
+            s = q.subject; p = q.predicate; o = q.object; g = q.graph;
+        } else {
+            s = subjectOrQuad as Term; p = predicate; o = object as Term; g = (graph ?? defaultGraph()) as Term;
+        }
+        return this.addRow(this.intern(this.keyOfTerm(s)), this.intern(this.keyOfTerm(p)), this.intern(this.keyOfTerm(o)), this.intern(this.keyOfTerm(g)));
+    }
+
+    addQuads(quads: Quad[]): void {
+        for (const q of quads) this.addQuad(q.subject, q.predicate, q.object, q.graph);
+    }
+
+    removeQuad(subjectOrQuad: Quad | Term, predicate?: Term, object?: Term, graph?: Term): void {
+        let s: Term, p: Term, o: Term, g: Term;
+        if (predicate === undefined) {
+            const q = subjectOrQuad as Quad;
+            s = q.subject; p = q.predicate; o = q.object; g = q.graph;
+        } else {
+            s = subjectOrQuad as Term; p = predicate; o = object as Term; g = (graph ?? defaultGraph()) as Term;
+        }
+        const si = this.idOf(s), pi = this.idOf(p), oi = this.idOf(o), gi = this.idOf(g);
+        this.forEachMatch(si, pi, oi, gi, (row) => { this.tombstone(row, gi); });
+    }
+
+    removeQuads(quads: Quad[]): void {
+        for (const q of quads) this.removeQuad(q.subject, q.predicate, q.object, q.graph);
+    }
+
+    private tombstone(row: number, gi: number): void {
+        if (this.dead.has(row)) return;
+        this.dead.add(row);
+        // Keep the graph list compact (graph removal is the common bulk case); predRows is filtered lazily via `dead`.
+        const gl = this.graphRows.get(gi >= 0 ? gi : this.cg[row]);
+        if (gl) {
+            const idx = gl.indexOf(row);
+            if (idx >= 0) gl.splice(idx, 1);
+        }
+    }
+
+    getQuads(subject: Term | null, predicate: Term | null, object: Term | null, graph: Term | null): Quad[] {
+        const out: Quad[] = [];
+        this.forEachMatch(this.idOf(subject), this.idOf(predicate), this.idOf(object), this.idOf(graph), (row) => {
+            out.push(this.materialize(row));
+        });
+        return out;
+    }
+
+    countQuads(subject: Term | null, predicate: Term | null, object: Term | null, graph: Term | null): number {
+        let count = 0;
+        this.forEachMatch(this.idOf(subject), this.idOf(predicate), this.idOf(object), this.idOf(graph), () => { count += 1; });
+        return count;
+    }
+
+    has(subjectOrQuad: Quad | Term, predicate?: Term, object?: Term, graph?: Term): boolean {
+        let s: Term, p: Term, o: Term, g: Term;
+        if (predicate === undefined) {
+            const q = subjectOrQuad as Quad;
+            s = q.subject; p = q.predicate; o = q.object; g = q.graph;
+        } else {
+            s = subjectOrQuad as Term; p = predicate; o = object as Term; g = (graph ?? defaultGraph()) as Term;
+        }
+        let found = false;
+        this.forEachMatch(this.idOf(s), this.idOf(p), this.idOf(o), this.idOf(g), () => { found = true; });
+        return found;
+    }
+}
+
+// --- LeanReasoningStore: OwlStore over LeanQuadStore (mirrors ReasoningStore exactly) -----------
+
+export class LeanReasoningStore implements OwlStore {
+    private readonly store = new LeanQuadStore();
+    private readonly modelGraphs = new Map<string, ModelGraphs>();
+    // Asserted facts live in the model's own graph (read straight from the store's columns, no
+    // per-model array). Entailed facts written via addEntailment/loadEntailments are tracked here
+    // by row id so forEachEntailedFact returns ONLY them (not TBox quads that the
+    // TBox chainer writes directly into the entailments graph via getStore().addQuads).
+    private readonly entailedRows = new Map<string, number[]>();
+    private readonly modelDataGen = new Map<string, number>();
+
+    private bumpDataGen(modelUri: string): void {
+        this.modelDataGen.set(modelUri, (this.modelDataGen.get(modelUri) ?? 0) + 1);
+    }
+
+    getModelDataGen(modelUri: string): number {
+        return this.modelDataGen.get(modelUri) ?? 0;
+    }
+
+    loadModel(modelUri: string, quads: Quad[]): void {
+        const existingGraphs = this.modelGraphs.get(modelUri);
+        const graphs = existingGraphs ?? this.graphsFromModelUri(modelUri);
+        if (existingGraphs) {
+            this.retractModel(modelUri);
+        }
+        this.modelGraphs.set(modelUri, graphs);
+        this.entailedRows.delete(modelUri);
+        for (const q of quads) {
+            this.store.addQuad(q.subject, q.predicate, q.object, graphs.own);
+        }
+        this.bumpDataGen(modelUri);
+    }
+
+    loadEntailments(modelUri: string, quads: Quad[]): void {
+        const graphs = this.requireGraphs(modelUri);
+        this.removeGraph(graphs.entailments);
+        this.bumpDataGen(modelUri);
+        if (quads.length === 0) {
+            this.entailedRows.set(modelUri, []);
+            return;
+        }
+        const rows: number[] = [];
+        for (const q of quads) {
+            rows.push(this.store.addQuad(q.subject, q.predicate, q.object, graphs.entailments));
+        }
+        this.entailedRows.set(modelUri, rows);
+    }
+
+    addEntailment(modelUri: string, q: Quad): void {
+        const graphs = this.requireGraphs(modelUri);
+        const row = this.store.addQuad(q.subject, q.predicate, q.object, graphs.entailments);
+        const rows = this.entailedRows.get(modelUri) ?? [];
+        rows.push(row);
+        this.entailedRows.set(modelUri, rows);
+        this.bumpDataGen(modelUri);
+    }
+
+    removeEntailment(modelUri: string, q: Quad): void {
+        const graphs = this.requireGraphs(modelUri);
+        this.store.removeQuad(quad(q.subject, q.predicate, q.object, graphs.entailments));
+        const rows = this.entailedRows.get(modelUri);
+        if (rows) {
+            this.entailedRows.set(modelUri, rows.filter((r) => !this.store.isDead(r)));
+        }
+        this.bumpDataGen(modelUri);
+    }
+
+    applyModelDelta(modelUri: string, quads: Quad[], retracted: Quad[], asserted: Quad[]): void {
+        const graphs = this.resolveGraphs(modelUri);
+        this.modelGraphs.set(modelUri, graphs);
+        if (retracted.length > 0) {
+            this.store.removeQuads(retracted.map((q) => this.withGraph(q, graphs.own)));
+        }
+        if (asserted.length > 0) {
+            for (const q of asserted) {
+                this.store.addQuad(q.subject, q.predicate, q.object, graphs.own);
+            }
+        }
+        this.bumpDataGen(modelUri);
+    }
+
+    retractModel(modelUri: string): void {
+        const graphs = this.modelGraphs.get(modelUri);
+        if (!graphs) return;
+        this.removeGraph(graphs.own);
+        this.removeGraph(graphs.entailments);
+        this.removeGraph(graphs.shaclRules);
+        this.modelGraphs.delete(modelUri);
+        this.entailedRows.delete(modelUri);
+        this.bumpDataGen(modelUri);
+    }
+
+    diffModel(modelUri: string, newQuads: Quad[]): ModelDiff {
+        const graphs = this.resolveGraphs(modelUri);
+        const existing = this.store.getQuads(null, null, null, graphs.own);
+        const next = newQuads.map((q) => this.withGraph(q, graphs.own));
+
+        const existingByKey = new Map(existing.map((q) => [this.quadKey(q), q]));
+        const nextByKey = new Map(next.map((q) => [this.quadKey(q), q]));
+
+        const retracted = [...existingByKey.entries()]
+            .filter(([key]) => !nextByKey.has(key))
+            .map(([, value]) => value)
+            .sort((a, b) => this.quadKey(a).localeCompare(this.quadKey(b)));
+
+        const asserted = [...nextByKey.entries()]
+            .filter(([key]) => !existingByKey.has(key))
+            .map(([, value]) => value)
+            .sort((a, b) => this.quadKey(a).localeCompare(this.quadKey(b)));
+
+        return {
+            isEmpty: retracted.length === 0 && asserted.length === 0,
+            retracted,
+            asserted,
+        };
+    }
+
+    clearEntailments(modelUri: string): void {
+        const graphs = this.requireGraphs(modelUri);
+        this.removeGraph(graphs.entailments);
+        this.entailedRows.set(modelUri, []);
+        this.bumpDataGen(modelUri);
+    }
+
+    graphs(modelUri: string): ModelGraphs {
+        return this.requireGraphs(modelUri);
+    }
+
+    getStore(): Store {
+        return this.store as unknown as Store;
+    }
+
+    forEachAssertedFact(modelUri: string, visit: ScopeFactVisitor): void {
+        const graphs = this.modelGraphs.get(modelUri);
+        if (!graphs) return;
+        this.store.forEachFactInGraph(graphs.own, visit);
+    }
+
+    forEachEntailedFact(modelUri: string, visit: ScopeFactVisitor): void {
+        const rows = this.entailedRows.get(modelUri);
+        if (!rows) return;
+        this.store.forEachFactInRows(rows, visit);
+    }
+
+    private resolveGraphs(modelUri: string): ModelGraphs {
+        const existing = this.modelGraphs.get(modelUri);
+        if (existing) {
+            return existing;
+        }
+        const graphs = this.graphsFromModelUri(modelUri);
+        this.modelGraphs.set(modelUri, graphs);
+        return graphs;
+    }
+
+    private graphsFromModelUri(modelUri: string): ModelGraphs {
+        return {
+            own: namedNode(modelUri),
+            entailments: namedNode(`${modelUri}__entailments`),
+            shaclRules: namedNode(`${modelUri}__shacl_rules`),
+        };
+    }
+
+    private requireGraphs(modelUri: string): ModelGraphs {
+        const graphs = this.modelGraphs.get(modelUri);
+        if (!graphs) {
+            throw new Error(`Unknown model '${modelUri}'. Load the model first.`);
+        }
+        return graphs;
+    }
+
+    private withGraph(q: Quad, graph: NamedNode): Quad {
+        return quad(q.subject, q.predicate, q.object, graph);
+    }
+
+    private removeGraph(graph: NamedNode): void {
+        this.store.removeQuads(this.store.getQuads(null, null, null, graph));
+    }
+
+    private quadKey(q: Quad): string {
+        return `${q.subject.id}|${q.predicate.id}|${q.object.id}|${q.graph.id}`;
+    }
+}

package/src/owl/owl-store.ts

@@ -1,7 +1,7 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
 import { DataFactory, Store } from 'n3';
-import type { NamedNode, Quad } from 'n3';
+import type { NamedNode, Quad, Term } from 'n3';
 
 const { namedNode, quad } = DataFactory;
 
@@ -14,40 +14,96 @@ export interface ModelDiff {
 export interface ModelGraphs {
     own: NamedNode;
     entailments: NamedNode;
+    shaclRules: NamedNode;
 }
 
 export class ReasoningStore {
     private readonly store = new Store();
     private readonly modelGraphs = new Map<string, ModelGraphs>();
+    private readonly assertedQuadsByModel = new Map<string, Quad[]>();
+    private readonly entailedQuadsByModel = new Map<string, Quad[]>();
+    // Monotonic per-model data version, bumped on every mutation of a model's asserted or entailed
+    // quads. Consumers (e.g. the Oxigraph mirror) compare it to detect exactly which models changed,
+    // without re-reading the data — so an edit re-syncs only the models that actually changed.
+    private readonly modelDataGen = new Map<string, number>();
+
+    private bumpDataGen(modelUri: string): void {
+        this.modelDataGen.set(modelUri, (this.modelDataGen.get(modelUri) ?? 0) + 1);
+    }
+
+    getModelDataGen(modelUri: string): number {
+        return this.modelDataGen.get(modelUri) ?? 0;
+    }
 
     // Load a model's quads into its named graph.
     // Retracts any existing quads for that model first.
     // Graph IRI is derived from the model URI to keep model snapshots isolated.
     loadModel(modelUri: string, quads: Quad[]): void {
-        const graphs = this.resolveGraphs(modelUri);
-        this.retractModel(modelUri);
+        const existingGraphs = this.modelGraphs.get(modelUri);
+        const graphs = existingGraphs ?? this.graphsFromModelUri(modelUri);
+        if (existingGraphs) {
+            this.retractModel(modelUri);
+        }
         this.modelGraphs.set(modelUri, graphs);
-        this.store.addQuads(quads.map((q) => this.withGraph(q, graphs.own)));
+        this.assertedQuadsByModel.set(modelUri, [...quads]);
+        this.entailedQuadsByModel.delete(modelUri);
+        for (const q of quads) {
+            this.store.addQuad(q.subject, q.predicate, q.object, graphs.own);
+        }
+        this.bumpDataGen(modelUri);
     }
 
     loadEntailments(modelUri: string, quads: Quad[]): void {
         const graphs = this.requireGraphs(modelUri);
         this.removeGraph(graphs.entailments);
+        this.bumpDataGen(modelUri);
         if (quads.length === 0) {
+            this.entailedQuadsByModel.set(modelUri, []);
             return;
         }
-        this.store.addQuads(quads.map((q) => this.withGraph(q, graphs.entailments)));
+        const entailed: Quad[] = [];
+        for (const q of quads) {
+            const entailedQuad = quad(q.subject, q.predicate, q.object, graphs.entailments);
+            entailed.push(entailedQuad);
+            this.store.addQuad(entailedQuad);
+        }
+        this.entailedQuadsByModel.set(modelUri, entailed);
+    }
+
+    addEntailment(modelUri: string, q: Quad): void {
+        const graphs = this.requireGraphs(modelUri);
+        const entailedQuad = quad(q.subject, q.predicate, q.object, graphs.entailments);
+        const entailed = this.entailedQuadsByModel.get(modelUri) ?? [];
+        entailed.push(entailedQuad);
+        this.entailedQuadsByModel.set(modelUri, entailed);
+        this.store.addQuad(entailedQuad);
+        this.bumpDataGen(modelUri);
+    }
+
+    removeEntailment(modelUri: string, q: Quad): void {
+        const graphs = this.requireGraphs(modelUri);
+        const entailedQuad = quad(q.subject, q.predicate, q.object, graphs.entailments);
+        const key = this.quadKey(entailedQuad);
+        const entailed = this.entailedQuadsByModel.get(modelUri) ?? [];
+        const next = entailed.filter((entry) => this.quadKey(entry) !== key);
+        this.entailedQuadsByModel.set(modelUri, next);
+        this.store.removeQuad(entailedQuad);
+        this.bumpDataGen(modelUri);
     }
 
     applyModelDelta(modelUri: string, quads: Quad[], retracted: Quad[], asserted: Quad[]): void {
         const graphs = this.resolveGraphs(modelUri);
         this.modelGraphs.set(modelUri, graphs);
+        this.assertedQuadsByModel.set(modelUri, [...quads]);
         if (retracted.length > 0) {
             this.store.removeQuads(retracted.map((q) => this.withGraph(q, graphs.own)));
         }
         if (asserted.length > 0) {
-            this.store.addQuads(asserted.map((q) => this.withGraph(q, graphs.own)));
+            for (const q of asserted) {
+                this.store.addQuad(q.subject, q.predicate, q.object, graphs.own);
+            }
         }
+        this.bumpDataGen(modelUri);
     }
 
     // Retract all quads in all named graphs for a model
@@ -57,7 +113,11 @@ export class ReasoningStore {
         if (!graphs) return;
         this.removeGraph(graphs.own);
         this.removeGraph(graphs.entailments);
+        this.removeGraph(graphs.shaclRules);
         this.modelGraphs.delete(modelUri);
+        this.assertedQuadsByModel.delete(modelUri);
+        this.entailedQuadsByModel.delete(modelUri);
+        this.bumpDataGen(modelUri);
     }
 
     // Compare newly mapped quads against what is currently in the store.
@@ -93,6 +153,8 @@ export class ReasoningStore {
     clearEntailments(modelUri: string): void {
         const graphs = this.requireGraphs(modelUri);
         this.removeGraph(graphs.entailments);
+        this.entailedQuadsByModel.set(modelUri, []);
+        this.bumpDataGen(modelUri);
     }
 
     // Returns the named graph IRIs for a model.
@@ -108,6 +170,22 @@ export class ReasoningStore {
         return this.store;
     }
 
+    forEachAssertedFact(modelUri: string, visit: (subject: Term, predicate: NamedNode, object: Term, key: string) => void): void {
+        const quads = this.assertedQuadsByModel.get(modelUri);
+        if (!quads) return;
+        for (const q of quads) {
+            visit(q.subject, q.predicate as NamedNode, q.object, `${q.subject.id}|${q.predicate.id}|${q.object.id}`);
+        }
+    }
+
+    forEachEntailedFact(modelUri: string, visit: (subject: Term, predicate: NamedNode, object: Term, key: string) => void): void {
+        const quads = this.entailedQuadsByModel.get(modelUri);
+        if (!quads) return;
+        for (const q of quads) {
+            visit(q.subject, q.predicate as NamedNode, q.object, `${q.subject.id}|${q.predicate.id}|${q.object.id}`);
+        }
+    }
+
     private resolveGraphs(modelUri: string): ModelGraphs {
         const existing = this.modelGraphs.get(modelUri);
         if (existing) {
@@ -121,7 +199,8 @@ export class ReasoningStore {
     private graphsFromModelUri(modelUri: string): ModelGraphs {
         return {
             own: namedNode(modelUri),
-            entailments: namedNode(`${modelUri}__entailments`)
+            entailments: namedNode(`${modelUri}__entailments`),
+            shaclRules: namedNode(`${modelUri}__shacl_rules`),
         };
     }