opentology 0.1.0

package/dist/lib/oxigraph.js

@@ -0,0 +1,323 @@
+import { Parser, Writer } from 'n3';
+export async function sparqlQuery(endpoint, query) {
+    const url = `${endpoint}/query`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/sparql-query',
+            Accept: 'application/sparql-results+json',
+        },
+        body: query,
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`SPARQL query failed (${response.status} ${response.statusText})${body ? `: ${body}` : ''}`);
+    }
+    return response.json();
+}
+export async function sparqlUpdate(endpoint, update) {
+    const url = `${endpoint}/update`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/sparql-update',
+        },
+        body: update,
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`SPARQL update failed (${response.status} ${response.statusText})${body ? `: ${body}` : ''}`);
+    }
+}
+function termToSparql(term) {
+    switch (term.termType) {
+        case 'NamedNode':
+            return `<${term.value}>`;
+        case 'BlankNode':
+            return `_:${term.value}`;
+        case 'Literal': {
+            const escaped = term.value
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"')
+                .replace(/\n/g, '\\n')
+                .replace(/\r/g, '\\r')
+                .replace(/\t/g, '\\t');
+            if (term.language) {
+                return `"${escaped}"@${term.language}`;
+            }
+            if (term.datatype && term.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
+                return `"${escaped}"^^<${term.datatype.value}>`;
+            }
+            return `"${escaped}"`;
+        }
+        default:
+            throw new Error(`Unsupported term type: ${term.termType}`);
+    }
+}
+function parseTurtle(turtle) {
+    return new Promise((resolve, reject) => {
+        const parser = new Parser();
+        const quads = [];
+        parser.parse(turtle, (err, quad) => {
+            if (err) {
+                reject(new Error(`Failed to parse Turtle: ${err.message}`));
+                return;
+            }
+            if (quad) {
+                quads.push(quad);
+            }
+            else {
+                resolve(quads);
+            }
+        });
+    });
+}
+export async function insertTurtle(endpoint, graphUri, turtle) {
+    const quads = await parseTurtle(turtle);
+    if (quads.length === 0) {
+        return;
+    }
+    const tripleLines = quads
+        .map((q) => `  ${termToSparql(q.subject)} ${termToSparql(q.predicate)} ${termToSparql(q.object)} .`)
+        .join('\n');
+    const update = `INSERT DATA {\n  GRAPH <${graphUri}> {\n${tripleLines}\n  }\n}`;
+    await sparqlUpdate(endpoint, update);
+}
+export async function getGraphTripleCount(endpoint, graphUri) {
+    const query = `SELECT (COUNT(*) AS ?count) WHERE { GRAPH <${graphUri}> { ?s ?p ?o } }`;
+    const results = await sparqlQuery(endpoint, query);
+    const binding = results.results.bindings[0];
+    if (!binding || !binding['count']) {
+        return 0;
+    }
+    return parseInt(binding['count'].value, 10);
+}
+/**
+ * Returns true if the query already manages its own graph scoping.
+ * Matches GRAPH, FROM NAMED, or FROM < (case-insensitive).
+ */
+export function hasGraphScope(sparql) {
+    return /\bGRAPH\b|\bFROM\s+NAMED\b|\bFROM\s*</i.test(sparql);
+}
+/**
+ * Wraps the WHERE body of a SPARQL SELECT/CONSTRUCT/ASK/DESCRIBE query so
+ * that all triple patterns are scoped to `graphUri`.
+ *
+ * Handles:
+ *   SELECT ... WHERE { ... }          → standard form
+ *   SELECT ... { ... }               → shorthand (no WHERE keyword)
+ *
+ * Returns null if the outermost `{ ... }` block cannot be located safely.
+ */
+export function autoScopeQuery(sparql, graphUri) {
+    // Find the first `{` that opens the body.
+    // We look for WHERE { or, as a fallback, any { after the projection clause.
+    const whereMatch = sparql.match(/\bWHERE\s*\{/i);
+    let braceStart;
+    if (whereMatch && whereMatch.index !== undefined) {
+        // Position of `{` inside `WHERE {`
+        braceStart = whereMatch.index + whereMatch[0].length - 1;
+    }
+    else {
+        // Shorthand: find the first `{`
+        const firstBrace = sparql.indexOf('{');
+        if (firstBrace === -1)
+            return null;
+        braceStart = firstBrace;
+    }
+    // Walk forward to find the matching closing `}` (respecting nesting).
+    let depth = 0;
+    let braceEnd = -1;
+    for (let i = braceStart; i < sparql.length; i++) {
+        if (sparql[i] === '{')
+            depth++;
+        else if (sparql[i] === '}') {
+            depth--;
+            if (depth === 0) {
+                braceEnd = i;
+                break;
+            }
+        }
+    }
+    if (braceEnd === -1)
+        return null;
+    const before = sparql.slice(0, braceStart + 1); // up to and including `{`
+    const inner = sparql.slice(braceStart + 1, braceEnd); // content between `{ … }`
+    const after = sparql.slice(braceEnd); // from `}` onwards
+    return `${before} GRAPH <${graphUri}> {${inner}} ${after}`;
+}
+const WELL_KNOWN_PREFIXES = {
+    'http://www.w3.org/1999/02/22-rdf-syntax-ns#': 'rdf',
+    'http://www.w3.org/2000/01/rdf-schema#': 'rdfs',
+    'http://www.w3.org/2002/07/owl#': 'owl',
+    'http://schema.org/': 'schema',
+    'http://xmlns.com/foaf/0.1/': 'foaf',
+    'http://www.w3.org/2001/XMLSchema#': 'xsd',
+    'http://purl.org/dc/elements/1.1/': 'dc',
+    'http://purl.org/dc/terms/': 'dcterms',
+    'http://www.w3.org/2004/02/skos/core#': 'skos',
+    'http://www.w3.org/ns/prov#': 'prov',
+};
+function extractPrefixes(uris) {
+    const prefixes = {};
+    for (const uri of uris) {
+        // Check well-known prefixes first
+        for (const [ns, prefix] of Object.entries(WELL_KNOWN_PREFIXES)) {
+            if (uri.startsWith(ns) && !(prefix in Object.values(prefixes))) {
+                prefixes[prefix] = ns;
+                break;
+            }
+        }
+        // If not matched by well-known, derive from URI structure
+        if (!Object.values(prefixes).some((ns) => uri.startsWith(ns))) {
+            // Try hash-based namespace (e.g. http://example.org/ontology#)
+            const hashIdx = uri.lastIndexOf('#');
+            if (hashIdx !== -1) {
+                const ns = uri.slice(0, hashIdx + 1);
+                if (!Object.values(prefixes).includes(ns)) {
+                    // Derive a short prefix from the last path segment before the hash
+                    const pathSegments = ns.replace(/#$/, '').split('/').filter(Boolean);
+                    const candidate = pathSegments[pathSegments.length - 1]
+                        ?.toLowerCase()
+                        .replace(/[^a-z0-9]/g, '')
+                        .slice(0, 8);
+                    if (candidate && !(candidate in prefixes)) {
+                        prefixes[candidate] = ns;
+                    }
+                }
+            }
+            else {
+                // Slash-based namespace (e.g. http://example.org/ontology/)
+                const slashIdx = uri.lastIndexOf('/');
+                if (slashIdx !== -1) {
+                    const ns = uri.slice(0, slashIdx + 1);
+                    if (!Object.values(prefixes).includes(ns)) {
+                        const pathSegments = ns.replace(/\/$/, '').split('/').filter(Boolean);
+                        const candidate = pathSegments[pathSegments.length - 1]
+                            ?.toLowerCase()
+                            .replace(/[^a-z0-9]/g, '')
+                            .slice(0, 8);
+                        if (candidate && !(candidate in prefixes)) {
+                            prefixes[candidate] = ns;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return prefixes;
+}
+export async function dropGraph(endpoint, graphUri) {
+    await sparqlUpdate(endpoint, `DROP SILENT GRAPH <${graphUri}>`);
+}
+export async function deleteTriples(endpoint, graphUri, options) {
+    if (options.turtle !== undefined) {
+        const quads = await parseTurtle(options.turtle);
+        if (quads.length === 0) {
+            return;
+        }
+        const tripleLines = quads
+            .map((q) => `  ${termToSparql(q.subject)} ${termToSparql(q.predicate)} ${termToSparql(q.object)} .`)
+            .join('\n');
+        const update = `DELETE DATA {\n  GRAPH <${graphUri}> {\n${tripleLines}\n  }\n}`;
+        await sparqlUpdate(endpoint, update);
+    }
+    else if (options.where !== undefined) {
+        const update = `DELETE { GRAPH <${graphUri}> { ?s ?p ?o } } WHERE { GRAPH <${graphUri}> { ?s ?p ?o . ${options.where} } }`;
+        await sparqlUpdate(endpoint, update);
+    }
+    else {
+        throw new Error('deleteTriples: either options.turtle or options.where must be provided');
+    }
+}
+export async function getSchemaOverview(endpoint, graphUri) {
+    const tripleCount = await getGraphTripleCount(endpoint, graphUri);
+    const classResults = await sparqlQuery(endpoint, `SELECT DISTINCT ?class WHERE { GRAPH <${graphUri}> { ?s a ?class } } ORDER BY ?class`);
+    const classes = classResults.results.bindings
+        .map((b) => b['class']?.value)
+        .filter((v) => v !== undefined);
+    const propResults = await sparqlQuery(endpoint, `SELECT DISTINCT ?prop WHERE { GRAPH <${graphUri}> { ?s ?prop ?o } } ORDER BY ?prop`);
+    const properties = propResults.results.bindings
+        .map((b) => b['prop']?.value)
+        .filter((v) => v !== undefined);
+    const prefixes = extractPrefixes([...classes, ...properties]);
+    return { prefixes, classes, properties, tripleCount };
+}
+export async function getClassDetails(endpoint, graphUri, classUri) {
+    const countResults = await sparqlQuery(endpoint, `SELECT (COUNT(?s) as ?count) WHERE { GRAPH <${graphUri}> { ?s a <${classUri}> } }`);
+    const countBinding = countResults.results.bindings[0];
+    const instanceCount = countBinding?.['count']
+        ? parseInt(countBinding['count'].value, 10)
+        : 0;
+    const propResults = await sparqlQuery(endpoint, `SELECT ?prop (COUNT(?prop) as ?count) WHERE { GRAPH <${graphUri}> { ?s a <${classUri}> . ?s ?prop ?o } } GROUP BY ?prop ORDER BY DESC(?count)`);
+    const properties = propResults.results.bindings
+        .filter((b) => b['prop'] && b['count'])
+        .map((b) => ({
+        property: b['prop'].value,
+        count: parseInt(b['count'].value, 10),
+    }));
+    const sampleResults = await sparqlQuery(endpoint, `SELECT ?s ?p ?o WHERE { GRAPH <${graphUri}> { ?s a <${classUri}> . ?s ?p ?o } } LIMIT 5`);
+    const sampleTriples = sampleResults.results.bindings
+        .filter((b) => b['s'] && b['p'] && b['o'])
+        .map((b) => ({
+        s: b['s'].value,
+        p: b['p'].value,
+        o: b['o'].value,
+    }));
+    return { classUri, instanceCount, properties, sampleTriples };
+}
+export async function diffGraph(endpoint, graphUri, localTurtle) {
+    const localQuads = await parseTurtle(localTurtle);
+    const localSet = new Set(localQuads.map((q) => `${termToSparql(q.subject)} ${termToSparql(q.predicate)} ${termToSparql(q.object)}`));
+    // Fetch remote quads via CONSTRUCT
+    const query = `CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <${graphUri}> { ?s ?p ?o } }`;
+    const response = await fetch(`${endpoint}/query`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/sparql-query',
+            Accept: 'text/turtle',
+        },
+        body: query,
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`SPARQL CONSTRUCT query failed (${response.status} ${response.statusText})${body ? `: ${body}` : ''}`);
+    }
+    const remoteTurtle = await response.text();
+    const remoteQuads = remoteTurtle.trim() ? await parseTurtle(remoteTurtle) : [];
+    const remoteSet = new Set(remoteQuads.map((q) => `${termToSparql(q.subject)} ${termToSparql(q.predicate)} ${termToSparql(q.object)}`));
+    const added = [...localSet].filter((t) => !remoteSet.has(t));
+    const removed = [...remoteSet].filter((t) => !localSet.has(t));
+    const unchanged = [...localSet].filter((t) => remoteSet.has(t)).length;
+    return { added, removed, unchanged };
+}
+export async function exportGraph(endpoint, graphUri) {
+    const query = `CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <${graphUri}> { ?s ?p ?o } }`;
+    const response = await fetch(`${endpoint}/query`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/sparql-query',
+            Accept: 'text/turtle',
+        },
+        body: query,
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`SPARQL CONSTRUCT query failed (${response.status} ${response.statusText})${body ? `: ${body}` : ''}`);
+    }
+    const turtleText = await response.text();
+    // Re-serialize through n3.Writer to ensure consistent formatting
+    const quads = await parseTurtle(turtleText);
+    return new Promise((resolve, reject) => {
+        const writer = new Writer({ format: 'Turtle' });
+        writer.addQuads(quads);
+        writer.end((err, result) => {
+            if (err) {
+                reject(new Error(`Failed to serialize Turtle: ${err.message}`));
+            }
+            else {
+                resolve(result);
+            }
+        });
+    });
+}

package/dist/lib/reasoner.d.ts

@@ -0,0 +1,19 @@
+import type { StoreAdapter } from './store-adapter.js';
+interface Triple {
+    s: string;
+    p: string;
+    o: string;
+    isLiteral: boolean;
+}
+export interface InferenceResult {
+    assertedCount: number;
+    inferredCount: number;
+    rules: Record<string, number>;
+}
+export declare function computeInferences(triples: Triple[]): {
+    inferred: Triple[];
+    rules: Record<string, number>;
+};
+export declare function clearInferences(adapter: StoreAdapter, graphUri: string): Promise<void>;
+export declare function materializeInferences(adapter: StoreAdapter, graphUri: string): Promise<InferenceResult>;
+export {};

package/dist/lib/reasoner.js

@@ -0,0 +1,310 @@
+import { Parser, Writer, DataFactory } from 'n3';
+import { getInferenceGraphUri } from './sparql-utils.js';
+const { namedNode } = DataFactory;
+// ── Constants ──────────────────────────────────────────────────────────
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const RDFS_SUBCLASS_OF = 'http://www.w3.org/2000/01/rdf-schema#subClassOf';
+const RDFS_SUBPROPERTY_OF = 'http://www.w3.org/2000/01/rdf-schema#subPropertyOf';
+const RDFS_DOMAIN = 'http://www.w3.org/2000/01/rdf-schema#domain';
+const RDFS_RANGE = 'http://www.w3.org/2000/01/rdf-schema#range';
+/** URIs in the RDF/RDFS/OWL meta-vocabulary — skip meta-level reasoning. */
+const META_NAMESPACES = [
+    'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    'http://www.w3.org/2000/01/rdf-schema#',
+    'http://www.w3.org/2002/07/owl#',
+];
+function isMeta(uri) {
+    return META_NAMESPACES.some((ns) => uri.startsWith(ns));
+}
+// ── Helpers ────────────────────────────────────────────────────────────
+function tripleKey(t) {
+    return `${t.s}\t${t.p}\t${t.o}\t${t.isLiteral}`;
+}
+/**
+ * Compute the transitive closure of a binary relation expressed as triples
+ * with a specific predicate. Returns all pairs (a, c) such that a R* c.
+ */
+function transitiveClosure(pairs) {
+    // Build adjacency map
+    const children = new Map();
+    for (const [a, b] of pairs) {
+        let set = children.get(a);
+        if (!set) {
+            set = new Set();
+            children.set(a, set);
+        }
+        set.add(b);
+    }
+    const result = [];
+    const visited = new Map();
+    function reachable(node) {
+        const cached = visited.get(node);
+        if (cached)
+            return cached;
+        const reach = new Set();
+        visited.set(node, reach); // guard against cycles
+        const direct = children.get(node);
+        if (direct) {
+            for (const child of direct) {
+                reach.add(child);
+                for (const grandchild of reachable(child)) {
+                    reach.add(grandchild);
+                }
+            }
+        }
+        return reach;
+    }
+    // Compute for every source node
+    const allNodes = new Set();
+    for (const [a, b] of pairs) {
+        allNodes.add(a);
+        allNodes.add(b);
+    }
+    for (const node of allNodes) {
+        for (const target of reachable(node)) {
+            result.push([node, target]);
+        }
+    }
+    return result;
+}
+// ── Pure inference engine ──────────────────────────────────────────────
+export function computeInferences(triples) {
+    const assertedSet = new Set(triples.map(tripleKey));
+    const inferredMap = new Map(); // tripleKey → rule name
+    const rules = {};
+    function addInferred(t, rule) {
+        const key = tripleKey(t);
+        if (assertedSet.has(key) || inferredMap.has(key))
+            return;
+        inferredMap.set(key, rule);
+        rules[rule] = (rules[rule] ?? 0) + 1;
+    }
+    // ── Extract schema information ─────────────────────────────────────
+    // Direct subClassOf pairs
+    const subClassPairs = [];
+    // Direct subPropertyOf pairs
+    const subPropertyPairs = [];
+    // Domain declarations: property → class
+    const domainMap = new Map();
+    // Range declarations: property → class
+    const rangeMap = new Map();
+    // Instance-of triples: subject → set of classes
+    const instanceOf = [];
+    // All property-usage triples (non-rdf:type, non-schema predicates)
+    const propertyUsages = [];
+    for (const t of triples) {
+        if (t.p === RDFS_SUBCLASS_OF && !t.isLiteral) {
+            subClassPairs.push([t.s, t.o]);
+        }
+        else if (t.p === RDFS_SUBPROPERTY_OF && !t.isLiteral) {
+            subPropertyPairs.push([t.s, t.o]);
+        }
+        else if (t.p === RDFS_DOMAIN && !t.isLiteral) {
+            const existing = domainMap.get(t.s);
+            if (existing)
+                existing.push(t.o);
+            else
+                domainMap.set(t.s, [t.o]);
+        }
+        else if (t.p === RDFS_RANGE && !t.isLiteral) {
+            const existing = rangeMap.get(t.s);
+            if (existing)
+                existing.push(t.o);
+            else
+                rangeMap.set(t.s, [t.o]);
+        }
+        else if (t.p === RDF_TYPE && !t.isLiteral) {
+            instanceOf.push({ s: t.s, c: t.o });
+        }
+        else {
+            propertyUsages.push(t);
+        }
+    }
+    // ── rdfs11: subClassOf transitivity ────────────────────────────────
+    const allSubClassPairs = transitiveClosure(subClassPairs);
+    const subClassDirect = new Set(subClassPairs.map(([a, b]) => `${a}\t${b}`));
+    for (const [a, c] of allSubClassPairs) {
+        if (!subClassDirect.has(`${a}\t${c}`)) {
+            addInferred({ s: a, p: RDFS_SUBCLASS_OF, o: c, isLiteral: false }, 'rdfs11');
+        }
+    }
+    // Build complete superclass map (including transitive)
+    const superClasses = new Map();
+    for (const [sub, sup] of allSubClassPairs) {
+        let set = superClasses.get(sub);
+        if (!set) {
+            set = new Set();
+            superClasses.set(sub, set);
+        }
+        set.add(sup);
+    }
+    // ── subPropertyOf transitivity (feeds rdfs7) ──────────────────────
+    const allSubPropertyPairs = transitiveClosure(subPropertyPairs);
+    const subPropDirect = new Set(subPropertyPairs.map(([a, b]) => `${a}\t${b}`));
+    for (const [a, c] of allSubPropertyPairs) {
+        if (!subPropDirect.has(`${a}\t${c}`)) {
+            addInferred({ s: a, p: RDFS_SUBPROPERTY_OF, o: c, isLiteral: false }, 'rdfs7');
+        }
+    }
+    // Build super-property map
+    const superProperties = new Map();
+    for (const [sub, sup] of allSubPropertyPairs) {
+        let set = superProperties.get(sub);
+        if (!set) {
+            set = new Set();
+            superProperties.set(sub, set);
+        }
+        set.add(sup);
+    }
+    // ── rdfs9: subClassOf instance propagation ─────────────────────────
+    for (const { s, c } of instanceOf) {
+        if (isMeta(s))
+            continue;
+        const supers = superClasses.get(c);
+        if (!supers)
+            continue;
+        for (const superClass of supers) {
+            addInferred({ s, p: RDF_TYPE, o: superClass, isLiteral: false }, 'rdfs9');
+        }
+    }
+    // ── rdfs7: subPropertyOf propagation ───────────────────────────────
+    for (const t of propertyUsages) {
+        if (isMeta(t.s))
+            continue;
+        const supers = superProperties.get(t.p);
+        if (!supers)
+            continue;
+        for (const superProp of supers) {
+            addInferred({ s: t.s, p: superProp, o: t.o, isLiteral: t.isLiteral }, 'rdfs7');
+        }
+    }
+    // ── rdfs2: domain inference ────────────────────────────────────────
+    for (const t of propertyUsages) {
+        if (isMeta(t.s))
+            continue;
+        const domains = domainMap.get(t.p);
+        if (!domains)
+            continue;
+        for (const domainClass of domains) {
+            addInferred({ s: t.s, p: RDF_TYPE, o: domainClass, isLiteral: false }, 'rdfs2');
+            // Also propagate superclasses of the domain class (rdfs9 follow-up)
+            const supers = superClasses.get(domainClass);
+            if (supers) {
+                for (const superClass of supers) {
+                    addInferred({ s: t.s, p: RDF_TYPE, o: superClass, isLiteral: false }, 'rdfs9');
+                }
+            }
+        }
+    }
+    // ── rdfs3: range inference ─────────────────────────────────────────
+    for (const t of propertyUsages) {
+        if (t.isLiteral || isMeta(t.o))
+            continue;
+        const ranges = rangeMap.get(t.p);
+        if (!ranges)
+            continue;
+        for (const rangeClass of ranges) {
+            addInferred({ s: t.o, p: RDF_TYPE, o: rangeClass, isLiteral: false }, 'rdfs3');
+            // Also propagate superclasses of the range class (rdfs9 follow-up)
+            const supers = superClasses.get(rangeClass);
+            if (supers) {
+                for (const superClass of supers) {
+                    addInferred({ s: t.o, p: RDF_TYPE, o: superClass, isLiteral: false }, 'rdfs9');
+                }
+            }
+        }
+    }
+    // ── Collect results ────────────────────────────────────────────────
+    const inferred = [];
+    for (const [key] of inferredMap) {
+        const parts = key.split('\t');
+        inferred.push({
+            s: parts[0],
+            p: parts[1],
+            o: parts[2],
+            isLiteral: parts[3] === 'true',
+        });
+    }
+    return { inferred, rules };
+}
+// ── Turtle serialization helpers ───────────────────────────────────────
+function triplesToTurtle(triples) {
+    return new Promise((resolve, reject) => {
+        const writer = new Writer({ format: 'Turtle' });
+        for (const t of triples) {
+            const subject = namedNode(t.s);
+            const predicate = namedNode(t.p);
+            // All inferred triples from RDFS rules produce URIs (rdf:type, subClassOf, etc.)
+            // Literals only appear in rdfs7 (subPropertyOf propagation), but those keep isLiteral flag.
+            // For safety, we always produce NamedNode for object since our rules only infer URI objects.
+            const object = namedNode(t.o);
+            writer.addQuad(subject, predicate, object);
+        }
+        writer.end((err, result) => {
+            if (err)
+                reject(new Error(`Failed to serialize inferred triples: ${err.message}`));
+            else
+                resolve(result);
+        });
+    });
+}
+// ── Turtle parsing ─────────────────────────────────────────────────────
+function parseTurtleToTriples(turtle) {
+    return new Promise((resolve, reject) => {
+        const parser = new Parser();
+        const result = [];
+        parser.parse(turtle, (err, quad) => {
+            if (err) {
+                reject(new Error(`Failed to parse Turtle: ${err.message}`));
+                return;
+            }
+            if (quad) {
+                result.push({
+                    s: quad.subject.value,
+                    p: quad.predicate.value,
+                    o: quad.object.value,
+                    isLiteral: quad.object.termType === 'Literal',
+                });
+            }
+            else {
+                resolve(result);
+            }
+        });
+    });
+}
+// ── Public API ─────────────────────────────────────────────────────────
+export async function clearInferences(adapter, graphUri) {
+    const inferenceGraph = getInferenceGraphUri(graphUri);
+    // Retrieve bookkeeping copy of inferred triples, then remove them from the main graph
+    const inferredTurtle = await adapter.exportGraph(inferenceGraph);
+    if (inferredTurtle.trim()) {
+        await adapter.deleteTriples(graphUri, { turtle: inferredTurtle });
+    }
+    // Drop the bookkeeping graph
+    await adapter.sparqlUpdate(`DROP SILENT GRAPH <${inferenceGraph}>`);
+}
+export async function materializeInferences(adapter, graphUri) {
+    // 1. Clear any previously materialised inferences first
+    await clearInferences(adapter, graphUri);
+    // 2. Fetch all triples from the (now clean) asserted graph
+    const turtle = await adapter.exportGraph(graphUri);
+    // 3. Parse into Triple[]
+    const triples = turtle.trim() ? await parseTurtleToTriples(turtle) : [];
+    // 4. Compute inferences (pure function)
+    const { inferred, rules } = computeInferences(triples);
+    // 5. Insert inferred triples if any
+    if (inferred.length > 0) {
+        const inferredTurtle = await triplesToTurtle(inferred);
+        // Insert into the MAIN graph so regular queries find them without cross-graph joins
+        await adapter.insertTurtle(graphUri, inferredTurtle);
+        // Also insert into the bookkeeping graph so status/clear can account for them
+        const inferenceGraph = getInferenceGraphUri(graphUri);
+        await adapter.insertTurtle(inferenceGraph, inferredTurtle);
+    }
+    // 6. Return result
+    return {
+        assertedCount: triples.length,
+        inferredCount: inferred.length,
+        rules,
+    };
+}

package/dist/lib/shacl.d.ts

@@ -0,0 +1,22 @@
+export interface ShaclViolation {
+    focusNode: string;
+    path: string | null;
+    message: string;
+    severity: string;
+}
+export interface ShaclReport {
+    conforms: boolean;
+    violations: ShaclViolation[];
+}
+/**
+ * Discover .ttl shape files in the given directory (defaults to shapes/ in cwd).
+ */
+export declare function discoverShapes(dir?: string): string[];
+/**
+ * Check whether the shapes directory exists and contains at least one .ttl file.
+ */
+export declare function hasShapes(shapesDir?: string): boolean;
+/**
+ * Validate a Turtle data string against the given SHACL shape files.
+ */
+export declare function validateWithShacl(dataTurtle: string, shapePaths: string[]): Promise<ShaclReport>;