rdf-reasoner-konclude 0.2.1 → 0.3.0

package/README.md

@@ -114,26 +114,107 @@ The browser build requires COOP/COEP HTTP headers for `SharedArrayBuffer` (used
 const reasoner = new RdfReasoner();
 await reasoner.ready; // resolves when WASM module is loaded
 
-await reasoner.reason(store); // classify + write inferred triples into store
-await reasoner.classify(store); // alias for reason(store)
-const ok = await reasoner.checkConsistency(store); // returns boolean
+// TBox: class hierarchy (rdfs:subClassOf, owl:equivalentClass)
+await reasoner.classify(store);
+
+// ABox: individual type entailments (rdf:type)
+await reasoner.materialize(store);
+await reasoner.materialize(store, { includeClassHierarchy: true }); // TBox + ABox
+
+// Property hierarchy (rdfs:subPropertyOf)
+await reasoner.classifyProperties(store);
+
+// Consistency
+const ok = await reasoner.checkConsistency(store); // true = consistent
+
+// Entailment queries (post-reasoning)
+const entailed = await reasoner.isEntailed(store, quad);
+const results = await reasoner.isEntailed(store, [quad1, quad2]);
+
+// Hypothetical reasoning
+const { added, removed } = await reasoner.whatIf(store, [newAxiom]);
+
+// Explanation / justification
+const justs = await reasoner.explain(store, quad, { maxJustifications: 3 });
+const inconsJusts = await reasoner.explainInconsistency(store);
+
+// Satisfiability
+const classes = await reasoner.getUnsatisfiableClasses(store);
+const ok2 = await reasoner.isSatisfiable(store, "http://example.org/MyClass");
+
+// Combined diagnostic
+const report = await reasoner.validate(store);
+// report.consistent, report.errors (Quad[][]), report.warnings (ClassWarning[])
 
 reasoner.terminate(); // shut down the Worker
 ```
 
-`reason(store)` and `classify(store)` write inferred triples into the
-`INFERRED_GRAPH_IRI` named graph inside the store. The graph is cleared before
-each call — do not store ontology triples there.
+`classify(store)`, `materialize(store)`, and `classifyProperties(store)` write
+inferred triples into the `INFERRED_GRAPH_IRI` named graph inside the store.
+The graph is cleared before each call — do not store ontology triples there.
 
 Named graphs in the input are dropped at the WASM boundary (NTriples wire
 format is triple-only). Reasoning runs over the union of all graphs.
 
-Options for `reason(store, opts)` and `classify(store, opts)`:
+Options for `classify(store, opts)`, `materialize(store, opts)`, and `classifyProperties(store, opts)`:
 
 ```typescript
+// classify, classifyProperties
 interface StoreReasoningOptions {
-  inferredGraph?: string; // IRI of the named graph for inferred triples
-  // default: INFERRED_GRAPH_IRI
+  inferredGraph?: string; // default: INFERRED_GRAPH_IRI
+}
+
+// materialize
+interface MaterializeStoreOptions {
+  inferredGraph?: string; // default: INFERRED_GRAPH_IRI
+  includeClassHierarchy?: boolean; // also emit subClassOf/equivalentClass; default false
+}
+```
+
+Options for the Phase 2 axiom-work methods:
+
+```typescript
+// isEntailed: no options
+
+// whatIf
+interface WhatIfOptions {
+  removals?: Quad[]; // quads to remove from the base ontology
+  outputGraph?: string; // named graph for hypothetical inferences
+}
+
+// explain / explainInconsistency
+interface ExplainOptions {
+  maxJustifications?: number; // default: 1
+  axiomFilter?: (q: Quad) => boolean; // restrict candidate axiom set
+}
+
+// validate
+interface ValidateOptions {
+  maxJustificationsPerError?: number; // default: 1
+  maxJustificationsPerWarning?: number; // default: 1  (pass 0 for IRI-only scan)
+  axiomFilter?: (q: Quad) => boolean;
+}
+```
+
+Return types for the Phase 2 axiom-work methods:
+
+```typescript
+// Return types
+isEntailed(store, axiom: Quad):    Promise<boolean | null>
+isEntailed(store, axioms: Quad[]): Promise<(boolean | null)[]>
+whatIf(store, additions):          Promise<{ added: Quad[], removed: Quad[] }>
+explain(store, axiom):             Promise<Quad[][]>          // [] if not entailed; throws for unsupported predicate
+explainInconsistency(store):       Promise<Quad[][]>          // [] if consistent
+validate(store):                   Promise<ValidationResult>
+// where:
+interface ValidationResult {
+  consistent: boolean;
+  errors:     Quad[][];       // MIPS; non-empty only when consistent === false
+  warnings:   ClassWarning[]; // one per unsatisfiable class
+}
+interface ClassWarning {
+  classIRI:       string;
+  justifications: Quad[][];
 }
 ```
 
@@ -144,11 +225,315 @@ import { INFERRED_GRAPH_IRI } from "rdf-reasoner-konclude";
 // "urn:konclude:inferred"
 ```
 
-The default named graph where inferred triples are written by `reason(store)`.
+The default named graph where inferred triples are written.
 
 ### Deprecated overloads
 
-`reason(quads: Iterable<Quad>)` and `classify(quads)` / `checkConsistency(quads)` accept a raw `Iterable<Quad>` and return `Promise<Quad[]>` / `Promise<boolean>`. These overloads are deprecated — use the `Store`-based API instead.
+`reason(quads)`, `classify(quads)`, `checkConsistency(quads)`, and `materialize(quads)` accept a raw `Iterable<Quad>` and return `Promise<Quad[]>` / `Promise<boolean>`. These overloads are deprecated — use the `Store`-based API instead.
+
+## Common workflows
+
+All examples assume a single `RdfReasoner` instance:
+
+```typescript
+import { RdfReasoner, INFERRED_GRAPH_IRI } from "rdf-reasoner-konclude";
+import { Store, Parser, DataFactory } from "n3";
+
+const reasoner = new RdfReasoner();
+await reasoner.ready;
+```
+
+### TBox only: classify a class hierarchy
+
+Use `classify(store)` when the ontology has no named individuals. Returns
+`rdfs:subClassOf` and `owl:equivalentClass` entailments.
+
+```typescript
+await reasoner.classify(store);
+const subClasses = store.getQuads(
+  null,
+  "http://www.w3.org/2000/01/rdf-schema#subClassOf",
+  null,
+  INFERRED_GRAPH_IRI,
+);
+```
+
+### ABox: derive individual types
+
+Use `materialize(store)` when the ontology includes named individuals. Returns
+`rdf:type` entailments for every individual that can be classified under the
+TBox. Classification runs internally as part of realization — no separate call
+needed.
+
+```typescript
+await reasoner.materialize(store);
+const types = store.getQuads(
+  null,
+  "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
+  null,
+  INFERRED_GRAPH_IRI,
+);
+```
+
+To also receive the class hierarchy in the same call:
+
+```typescript
+await reasoner.materialize(store, { includeClassHierarchy: true });
+```
+
+### Property hierarchy
+
+Use `classifyProperties(store)` to infer `rdfs:subPropertyOf` entailments.
+Requires `owl:ObjectProperty` / `owl:DatatypeProperty` declarations in the
+ontology.
+
+```typescript
+await reasoner.classifyProperties(store);
+const subProps = store.getQuads(
+  null,
+  "http://www.w3.org/2000/01/rdf-schema#subPropertyOf",
+  null,
+  INFERRED_GRAPH_IRI,
+);
+```
+
+### Combine class hierarchy + property hierarchy
+
+`INFERRED_GRAPH_IRI` is cleared by each call, so write results to separate
+named graphs if you need both at once:
+
+```typescript
+await reasoner.classify(store, { inferredGraph: "urn:myapp:class-inferred" });
+await reasoner.classifyProperties(store, {
+  inferredGraph: "urn:myapp:prop-inferred",
+});
+```
+
+Or if storing them together is fine, call in sequence and read after both:
+
+```typescript
+await reasoner.classify(store);
+const classTriples = store.getQuads(null, null, null, INFERRED_GRAPH_IRI);
+
+await reasoner.classifyProperties(store); // clears + repopulates INFERRED_GRAPH_IRI
+const propTriples = store.getQuads(null, null, null, INFERRED_GRAPH_IRI);
+```
+
+### Consistency checking
+
+```typescript
+const consistent = await reasoner.checkConsistency(store);
+if (!consistent) {
+  console.error("Ontology is inconsistent");
+}
+```
+
+### Incremental ontology evolution
+
+The reasoner resets and re-loads the full store on every call. To reason over
+an evolving ontology, mutate the store and call again:
+
+```typescript
+await reasoner.classify(store);
+// → first inference written to INFERRED_GRAPH_IRI
+
+// Add new axioms
+store.addQuad(
+  DataFactory.quad(
+    DataFactory.namedNode("http://example.org/Cat"),
+    DataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf"),
+    DataFactory.namedNode("http://example.org/Animal"),
+  ),
+);
+
+// Re-reason: INFERRED_GRAPH_IRI is cleared and fully repopulated
+await reasoner.classify(store);
+```
+
+Concurrent calls on the same `RdfReasoner` instance are serialized
+automatically — queued calls run in order, never interleaved.
+
+### Checking if a specific entailment holds (`isEntailed`)
+
+`isEntailed` supports `rdfs:subClassOf`, `owl:equivalentClass`, `rdf:type`, and
+`rdfs:subPropertyOf`. Returns `null` for unsupported predicates.
+
+```typescript
+await reasoner.materialize(store);
+const isAnimal = await reasoner.isEntailed(
+  store,
+  DataFactory.quad(
+    DataFactory.namedNode("http://example.org/Fido"),
+    DataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
+    DataFactory.namedNode("http://example.org/Animal"),
+  ),
+);
+// true if Fido rdf:type Animal is entailed
+```
+
+### Hypothetical reasoning (`whatIf`)
+
+`whatIf` reasons over a temporary store mutation without modifying the input store.
+
+```typescript
+const { added, removed } = await reasoner.whatIf(store, [newAxiom]);
+// added/removed are deltas relative to the current INFERRED_GRAPH_IRI
+```
+
+### Explaining an entailment (`explain`)
+
+`explain` returns minimal justifications — each is the smallest set of axioms
+that alone entails the target. Returns `[]` if the axiom is not entailed.
+Each BlackBox call issues multiple Worker round-trips; use `maxJustifications: 1`
+for cheap first-justification lookups.
+
+```typescript
+const justs = await reasoner.explain(store, quad, { maxJustifications: 3 });
+// justs: Quad[][] — each inner array is one minimal justification
+```
+
+### Diagnosing an inconsistency (`explainInconsistency`)
+
+Returns minimal inconsistent sub-ontologies (MIPS). Returns `[]` on consistent ontologies.
+
+```typescript
+const mips = await reasoner.explainInconsistency(store);
+if (mips.length > 0) {
+  console.log("Minimal inconsistent core:", mips[0]);
+}
+```
+
+### Finding unsatisfiable classes (`getUnsatisfiableClasses`, `isSatisfiable`)
+
+`owl:Nothing` is excluded from the output. Classes absent from the taxonomy
+return `true` from `isSatisfiable` (open-world assumption).
+
+```typescript
+const unsatClasses = await reasoner.getUnsatisfiableClasses(store);
+// ["http://example.org/EmptyClass", ...]
+
+const ok = await reasoner.isSatisfiable(store, "http://example.org/MyClass");
+// false if MyClass is equivalent to owl:Nothing in the ontology
+```
+
+### Full ontology validation (`validate`)
+
+`validate` combines consistency checking, unsatisfiable-class detection, and
+optional justification computation in a single call.
+
+```typescript
+const report = await reasoner.validate(store);
+// report.consistent — true/false
+// report.errors     — Quad[][], minimal inconsistent sub-ontologies (non-empty when inconsistent)
+// report.warnings   — ClassWarning[], one per unsatisfiable class
+
+// Cheap IRI-only scan (skip BlackBox justifications for warnings):
+const quickReport = await reasoner.validate(store, {
+  maxJustificationsPerWarning: 0,
+});
+```
+
+`errors` are non-empty only when `consistent` is `false`. When `consistent` is
+`true`, only `warnings` may be present. Callers should check `consistent` before
+acting on `warnings`.
+
+### Separate inferred graph per operation
+
+The `INFERRED_GRAPH_IRI` graph is cleared before each call. If you need to
+preserve results from a previous call while re-reasoning with a different
+operation, use separate named graphs:
+
+```typescript
+await reasoner.classify(store, { inferredGraph: "urn:myapp:class-hierarchy" });
+await reasoner.materialize(store, { inferredGraph: "urn:myapp:abox-types" });
+
+// Both named graphs now coexist in the store
+const classTriples = store.getQuads(
+  null,
+  null,
+  null,
+  "urn:myapp:class-hierarchy",
+);
+const typeTriples = store.getQuads(null, null, null, "urn:myapp:abox-types");
+```
+
+### Node.js and browser: same API
+
+`RdfReasoner` is identical in both environments. Under Node.js the `"node"`
+export condition in `package.json` loads `index.node.mjs`, which installs a
+`NodeWorkerShim` over `node:worker_threads` that matches the browser `Worker`
+interface. The worker dispatch code (`dist/worker.js`) and all protocol messages
+are shared. No code changes are needed when porting between environments.
+
+## OWL 2 DL coverage
+
+Konclude implements the full OWL 2 DL tableau (expressivity SROIQ(D)). The sections below
+document what has been verified to work, what is known not to work, and what the WASM port
+does not yet surface as output.
+
+### Consistency checking (`checkConsistency`)
+
+Violation detection verified against native Konclude v0.7.0 ground truth:
+
+| #   | Violation pattern                                         | Native             | WASM           | Status                             |
+| --- | --------------------------------------------------------- | ------------------ | -------------- | ---------------------------------- |
+| 1   | `owl:disjointWith` (direct)                               | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+| 2   | `owl:disjointWith` (via domain/range inference)           | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+| 3   | `owl:AsymmetricProperty` bidirectional assertion          | consistent ✗ (bug) | inconsistent ✓ | **PARITY (WASM surpasses native)** |
+| 4   | `owl:IrreflexiveProperty` self-reference                  | consistent ✗ (bug) | inconsistent ✓ | **PARITY (WASM surpasses native)** |
+| 5   | `owl:maxQualifiedCardinality` + `owl:differentFrom`       | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+| 6   | `owl:allValuesFrom` + `owl:disjointWith`                  | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+| 7   | `owl:ReflexiveProperty` + `ObjectComplementOf(HasSelf)`   | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+| 8   | `owl:InverseFunctionalProperty` + `DifferentIndividuals`  | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+| 9   | `owl:AllDisjointClasses` (3-way) + double membership      | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+| 10  | `DisjointObjectProperties` + `EquivalentObjectProperties` | consistent ✗ (bug) | inconsistent ✓ | **PARITY (WASM surpasses native)** |
+| 11  | `owl:disjointUnionOf` + double membership                 | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+| 12  | `owl:NegativeObjectPropertyAssertion` contradiction       | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+| 13  | `DataAllValuesFrom xsd:minInclusive` (consistent case)    | consistent ✓       | consistent ✓   | **PARITY**                         |
+| 14  | `DataAllValuesFrom xsd:minInclusive` (inconsistent case)  | inconsistent ✓     | inconsistent ✓ | **PARITY**                         |
+
+**PARITY (WASM surpasses native v0.7.0)** means native Konclude v0.7.0 has a kernel bug for this
+construct; this package fixes it via patches 011–012 (role axiom correctness, NPA builder fix).
+
+`owl:AllDisjointClasses`, `owl:disjointUnionOf`, and `owl:NegativePropertyAssertion` all work in
+`materialize()` — the JS layer expands list axioms to pairwise form before handing off to WASM.
+The only known remaining gap is `owl:FunctionalProperty` + `owl:InverseFunctionalProperty` on the
+same role with a single filler (ALIF+ precompute hang). This case is tracked in
+`tests/integration/known-limitations.test.ts`.
+
+### Classification (`classify`)
+
+Verified working:
+
+- `rdfs:subClassOf` — transitive closure, with `owl:equivalentClass` folding
+- `owl:intersectionOf`, `owl:unionOf`, `owl:complementOf`
+- `owl:someValuesFrom`, `owl:allValuesFrom`
+- `owl:minCardinality`, `owl:maxCardinality`, `owl:exactCardinality`
+- `owl:minQualifiedCardinality`, `owl:maxQualifiedCardinality`, `owl:qualifiedCardinality`
+- `owl:ObjectProperty` with `rdfs:domain`, `rdfs:range`, `owl:inverseOf`
+- `owl:TransitiveProperty`, `owl:FunctionalProperty`, `owl:InverseFunctionalProperty`
+- `owl:ReflexiveProperty`, `owl:SymmetricProperty`
+- `owl:propertyChainAxiom`
+
+### ABox realization (`materialize`)
+
+`materialize(store)` infers `rdf:type` entailments for named individuals under the
+class hierarchy. Verified working on ontologies up to ~25 000 individuals (LUBM + data).
+
+Input ABox axioms accepted:
+
+- `rdf:type` assertions
+- Object property assertions (`owl:ObjectProperty`)
+- `owl:differentFrom` / `owl:AllDifferent`
+
+### Known output gaps
+
+| Feature                                   | Status                                    |
+| ----------------------------------------- | ----------------------------------------- |
+| `rdfs:subPropertyOf` (property hierarchy) | Available via `classifyProperties(store)` |
+| `owl:sameAs` entailments                  | Emitted by `materialize()` ✓              |
+| `owl:differentFrom` entailments           | Not emitted (accepted as input ✓)         |
+| Data property assertions                  | Emitted by `materialize()` ✓              |
 
 ## Browser deployment
 
@@ -214,10 +599,11 @@ LUBM + data) — matching WASM's operation selection. LUBM schema ratio is domin
 fixed WASM startup cost (pthreads pool init) on a tiny 307-triple ontology.
 
 ² WASM timing covers binary buffer encode (Quads → buffer) + `loadTripleBuffer` + realization
-+ decode. Input RDF is pre-parsed into quads before the timing window — NTriples/Turtle parsing
-is excluded, matching what your application pays after data is already loaded into a Store.
-Node.js 20 and Chromium 135 are within ~12% of each other on most ontologies; Roberts family
-(SROIQ with ABox realization) is effectively equal.
+
+- decode. Input RDF is pre-parsed into quads before the timing window — NTriples/Turtle parsing
+  is excluded, matching what your application pays after data is already loaded into a Store.
+  Node.js 20 and Chromium 135 are within ~12% of each other on most ontologies; Roberts family
+  (SROIQ with ABox realization) is effectively equal.
 
 Run `npm run bench` to reproduce (requires a built WASM binary — see [Build from source](#build-from-source)).
 

package/dist/index.d.ts

@@ -14,9 +14,9 @@
  */
 import type { Quad } from "@rdfjs/types";
 import { Store } from "n3";
-export type { ReasoningOptions, ReasoningResult, StoreReasoningOptions, MaterializeOptions, MaterializeStoreOptions, ClassifyPropertiesStoreOptions } from "./types.js";
-export { INFERRED_GRAPH_IRI } from "./types.js";
-import type { ReasoningOptions, StoreReasoningOptions, MaterializeOptions, MaterializeStoreOptions, ClassifyPropertiesStoreOptions } from "./types.js";
+export type { ReasoningOptions, ReasoningResult, StoreReasoningOptions, MaterializeOptions, MaterializeStoreOptions, ClassifyPropertiesStoreOptions, InferenceDelta, WhatIfOptions, ExplainOptions, ClassWarning, ValidationResult, ValidateOptions } from "./types.js";
+export { INFERRED_GRAPH_IRI, HYPOTHETICAL_IRI } from "./types.js";
+import type { ReasoningOptions, StoreReasoningOptions, MaterializeOptions, MaterializeStoreOptions, ClassifyPropertiesStoreOptions, InferenceDelta, WhatIfOptions, ExplainOptions, ValidationResult, ValidateOptions } from "./types.js";
 export declare class RdfReasoner {
     /** Resolves when the Worker WASM module is ready; rejects on init failure. */
     readonly ready: Promise<void>;
@@ -29,6 +29,10 @@ export declare class RdfReasoner {
      * loadTripleBuffer → realization → getInferredTripleBuffer sequences.
      */
     private _queue;
+    private _classifyCache;
+    private _materializeCache;
+    private _classifyPropertiesCache;
+    private _consistencyCache;
     constructor();
     /**
      * Send a method call to the Worker and return a Promise for the result.
@@ -53,14 +57,21 @@ export declare class RdfReasoner {
     reason(quads: Iterable<Quad>, opts?: ReasoningOptions): Promise<Quad[]>;
     private _reasonOnStore;
     private _reasonOnQuads;
-    /** Classify a Store (alias for `reason(store)`). */
+    /** Classify a Store. Inferred rdfs:subClassOf and owl:equivalentClass triples
+     *  are written into `opts.inferredGraph` (default `INFERRED_GRAPH_IRI`). The
+     *  graph is cleared before each call. Concurrent calls are serialized.
+     *
+     *  Internally sends a single `classification` command to the WASM worker, which
+     *  runs TBox-only reasoning (class hierarchy + property hierarchy). No ABox
+     *  realization is performed. For individual rdf:type entailments use
+     *  `materialize(store)` instead. */
     classify(store: Store, opts?: StoreReasoningOptions): Promise<void>;
     /**
      * @deprecated Use `classify(store)` instead. For ABox/rdf:type results, use `materialize(store)`.
      *
-     * Classify the given quads (alias for `reason(quads, { mode: 'classify' })`).
-     *
-     * Returns the inferred rdfs:subClassOf quads in the default graph.
+     * Classify the given quads. Returns the inferred rdfs:subClassOf quads in the
+     * default graph. Internally sends a single `classification` command to the
+     * WASM worker (TBox-only; no ABox realization).
      */
     classify(quads: Iterable<Quad>): Promise<Quad[]>;
     /** Check consistency of a Store. Does not write inferred triples. */
@@ -71,21 +82,43 @@ export declare class RdfReasoner {
      * Check whether the given quads form a consistent ontology.
      *
      * Internally: loadTripleBuffer → classification → consistency.
-     *
      * Concurrent calls are serialized: each call waits for the previous one to
      * complete before sending its first Worker message.
      */
     checkConsistency(quads: Iterable<Quad>): Promise<boolean>;
-    /** Materialize ABox entailments (rdf:type) into a Store. Inferred triples are
-     *  written into `opts.inferredGraph` (default `INFERRED_GRAPH_IRI`). The
-     *  graph is cleared before each call. When `opts.includeClassHierarchy` is
-     *  `true`, rdfs:subClassOf and owl:equivalentClass triples are also included.
-     *  Concurrent calls are serialized. */
+    /** Materialize ABox entailments (rdf:type, owl:sameAs, role assertions) into
+     *  a Store. Inferred triples are written into `opts.inferredGraph` (default
+     *  `INFERRED_GRAPH_IRI`). The graph is cleared before each call. When
+     *  `opts.includeClassHierarchy` is `true`, rdfs:subClassOf and
+     *  owl:equivalentClass triples are also included. Concurrent calls are
+     *  serialized.
+     *
+     *  Individuals are recognized from any `rdf:type <domain-class>` assertion —
+     *  explicit `rdf:type owl:NamedIndividual` declarations are not required.
+     *  If the ontology contains no individuals, only TBox inferences are produced
+     *  (same result as `classify(store)` with `includeClassHierarchy: true`).
+     *
+     *  Internally sends a single `realization` command to the WASM worker.
+     *  Classification (TBox: class hierarchy + property hierarchy) is always a
+     *  prerequisite inside the realization pipeline — it is NOT a separate call.
+     *  Both TBox and ABox steps are submitted together in one `prepareOntology()`
+     *  invocation at the C++ level.
+     *
+     *  Pass `{ returnDelta: true }` to receive `{ delta: InferenceDelta }` with the
+     *  quads added and removed compared to the previous inferred state. */
+    materialize(store: Store, opts: MaterializeStoreOptions & {
+        returnDelta: true;
+    }): Promise<{
+        delta: InferenceDelta;
+    }>;
     materialize(store: Store, opts?: MaterializeStoreOptions): Promise<void>;
     /**
      * Materialize ABox entailments (rdf:type assertions) for the given quads.
      *
-     * Runs the full TBox+ABox realization pipeline. By default only rdf:type
+     * Internally sends a single `realization` command to the WASM worker.
+     * Classification (TBox: class hierarchy + property hierarchy) is always a
+     * prerequisite inside the realization pipeline — it runs as part of the same
+     * `prepareOntology()` call, not as a separate step. By default only rdf:type
      * entailments are returned. Pass `{ includeClassHierarchy: true }` to also
      * receive rdfs:subClassOf and owl:equivalentClass triples.
      *
@@ -116,6 +149,103 @@ export declare class RdfReasoner {
     classifyProperties(quads: Iterable<Quad>): Promise<Quad[]>;
     private _classifyPropertiesOnStore;
     private _classifyPropertiesOnQuads;
+    private _opForPredicate;
+    private _classifyInline;
+    private _materializeInline;
+    private _classifyPropertiesInline;
+    /**
+     * Private helper — like _classifyInline but also calls getUnsatisfiableClassBuffer
+     * and returns the list of unsatisfiable class IRIs.  Updates _classifyCache and
+     * writes inferred triples into the store on cache miss (same invariant as
+     * _classifyInline).  Must be called from inside a _queue slot only.
+     */
+    private _getUnsatisfiableClassesInternal;
+    /** Return the IRIs of all classes that are unsatisfiable (equivalent to
+     *  owl:Nothing) in the ontology.  owl:Nothing itself is excluded.
+     *  Classes absent from the taxonomy are NOT included (open-world). */
+    getUnsatisfiableClasses(store: Store): Promise<string[]>;
+    /** Return `false` if `classIRI` is equivalent to owl:Nothing in the ontology.
+     *  Returns `true` for any class absent from the taxonomy (open-world assumption).
+     *  owl:Nothing is always unsatisfiable; returns `false` without a Worker call. */
+    isSatisfiable(store: Store, classIRI: string): Promise<boolean>;
+    /** Check whether a single axiom is entailed by the store's ontology. Returns
+     *  null for unsupported predicates (a warning is logged). Triggers reasoning
+     *  internally if the store has changed since the last call. */
+    isEntailed(store: Store, axiom: Quad): Promise<boolean | null>;
+    /** Check whether each axiom in a batch is entailed. Returns null for
+     *  individual unsupported predicates. Reasoning is triggered at most once
+     *  per required operation type. */
+    isEntailed(store: Store, axioms: Quad[]): Promise<(boolean | null)[]>;
+    /** Reason over a hypothetical extension of the store without mutating it.
+     *
+     * Computes full-materialize inferences over `store ∪ additions \ removals`
+     * without changing the store's base triples or INFERRED_GRAPH_IRI.
+     *
+     * Returns `{ added, removed }` relative to the current INFERRED_GRAPH_IRI
+     * content (both quads carry `graph = INFERRED_GRAPH_IRI` named node).
+     *
+     * If `opts.outputGraph` is provided the hypothetical inferences are also
+     * written to that named graph in the store (must not equal INFERRED_GRAPH_IRI).
+     */
+    whatIf(store: Store, additions: Quad[], opts?: WhatIfOptions): Promise<{
+        added: Quad[];
+        removed: Quad[];
+    }>;
+    /**
+     * Identical to _call. Named separately to mark it safe for use inside a
+     * _queue.then() body (no queue gating — callers must already hold the slot).
+     * Calling the public methods (classify, materialize, etc.) from inside a
+     * _queue body would deadlock.
+     */
+    private _callDirect;
+    private _isBuiltInDeclaration;
+    private _opForAxiom;
+    private _checkEntailmentDirect;
+    /**
+     * Returns true if the candidate subset is inconsistent.
+     * Uses the consistency Worker pipeline (not triple lookup).
+     * Safe to call from inside a _queue body.
+     */
+    private _checkInconsistencyDirect;
+    /**
+     * Returns true if `classIRI` is unsatisfiable in the candidate set.
+     * Uses buildUnsatisfiableClassBuffer as the oracle (not _checkEntailmentDirect,
+     * because buildInferredTripleBuffer suppresses `X rdfs:subClassOf owl:Nothing`).
+     * Safe to call from inside a _queue body.
+     */
+    private _checkUnsatisfiabilityDirect;
+    /** Compute minimal justifications for an axiom using the BlackBox algorithm.
+     *
+     * Returns a list of minimal subsets of the store's base quads, each of which
+     * alone entails the axiom. Returns [] if the axiom is not entailed.
+     * Each inner Quad[] is a minimal justification.
+     *
+     * Throws for unsupported predicates (unlike isEntailed which returns null).
+     *
+     * All BlackBox sub-calls run inside this method's single _queue slot using
+     * _callDirect. Do NOT call the public methods classify/materialize from inside.
+     */
+    explain(store: Store, axiom: Quad, opts?: ExplainOptions): Promise<Quad[][]>;
+    /** Compute minimal inconsistent sub-ontologies (MIPS) for an inconsistent
+     *  ontology. Returns [] if the ontology is consistent.
+     *
+     * Uses the consistency oracle directly (loadTripleBuffer → classification →
+     * consistency) for all BlackBox iterations. Does not depend on
+     * owl:Thing rdfs:subClassOf owl:Nothing being emitted as an inferred triple.
+     */
+    explainInconsistency(store: Store, opts?: ExplainOptions): Promise<Quad[][]>;
+    /** Run a combined diagnostic: check consistency, find unsatisfiable classes,
+     *  and (optionally) compute minimal justifications for each.
+     *
+     *  Returns `{ consistent, errors, warnings }` where:
+     *  - `consistent` — `true` when the ontology has at least one model
+     *  - `errors` — MIPS (minimal inconsistent sub-ontologies); non-empty only when inconsistent
+     *  - `warnings` — one `ClassWarning` per unsatisfiable class (owl:Nothing excluded)
+     *
+     *  All BlackBox iterations run inside this method's single _queue slot.
+     *  Do NOT call public methods from inside — use private helpers only.
+     */
+    validate(store: Store, opts?: ValidateOptions): Promise<ValidationResult>;
     /** Terminate the underlying Worker and reject all pending calls. */
     terminate(): void;
 }

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,KAAK,EAAe,MAAM,IAAI,CAAC;AAGxC,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AACxK,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AAqCvJ,qBAAa,WAAW;IACtB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAGpB;IAEJ;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAoC;;IAoElD;;;OAGG;IACH,OAAO,CAAC,KAAK;IAiBb;;6DAEyD;IACzD,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IACjE;;;;;;;;;;OAUG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAWvE,OAAO,CAAC,cAAc;IA6BtB,OAAO,CAAC,cAAc;IAkCtB,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IACnE;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAehD,qEAAqE;IACrE,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC;IAChD;;;;;;;;;OASG;IACH,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAsBzD;;;;2CAIuC;IACvC,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IACxE;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAW9E,OAAO,CAAC,mBAAmB;IAoC3B,OAAO,CAAC,mBAAmB;IA8B3B;;8EAE0E;IAC1E,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,8BAA8B,GAAG,OAAO,CAAC,IAAI,CAAC;IACtF;;;;;;;;;;OAUG;IACH,kBAAkB,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAW1D,OAAO,CAAC,0BAA0B;IA4BlC,OAAO,CAAC,0BAA0B;IAiBlC,oEAAoE;IACpE,SAAS,IAAI,IAAI;CAQlB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"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"}