@@ -39,6 +39,7 @@ Most callers want the typed wrapper instead: `import { checkOwlDl } from '@sparq
   { "consistent": true | false | "unknown",
     "reason": null | { "kind": "OutOfFragment", "construct", "triples" }
                    | { "kind": "NotInDl", "violations" } | { "kind": "ResourceBudget" }
+                   | { "kind": "DatatypeUnknown", "triples" }
                    | { "kind": "ImportsNotLoaded", "imports" }
                    | { "kind": "Unparsed" | "Malformed" | "Ambiguous" | "Unsupported", "detail", "triples" },
     "profile": { "dl": true | false | "unknown", "violations": [{ "kind", "detail", "triples" }],
@@ -51,8 +52,9 @@ Most callers want the typed wrapper instead: `import { checkOwlDl } from '@sparq
   [`skills/javascript-wasm/references/owl-dl.md`](../../skills/javascript-wasm/references/owl-dl.md).
 - **Fail-closed.** An ontology the reverse mapping refuses is a result
   (`"consistent": "unknown"` with the refusal as `reason`), not an error; only a parse error
-  or malformed options throw. Data properties, datatypes and nominals are outside the
-  decided fragment and answer `"unknown"` with reason `OutOfFragment`.
+  or malformed options throw. Nominals, keys and other chains are outside the decided
+  fragment and answer `"unknown"` with reason `OutOfFragment`; an undecided datatype question
+  answers `DatatypeUnknown`.
 - **No serde.** The JSON is written (and the options object parsed) by a small hand-written,
   unit-tested JSON module; all logic is the plain-Rust `check_owl_dl_json`, tested natively
   with `cargo test -p sparq-dl-wasm`. The `#[wasm_bindgen]` export only maps the error;
 
@@ -184,6 +184,7 @@ fn reason_kind(reason: &UnknownReason) -> &'static str {
         UnknownReason::NotInDl(_) => "NotInDl",
         UnknownReason::ResourceBudget => "ResourceBudget",
         UnknownReason::ImportsNotLoaded(_) => "ImportsNotLoaded",
+        UnknownReason::DatatypeUnknown { .. } => "DatatypeUnknown",
     }
 }
 
@@ -262,6 +263,11 @@ impl Writer<'_> {
                 self.key("imports");
                 json::push_str_array(&mut self.out, iris.iter().map(String::as_str));
             }
+            UnknownReason::DatatypeUnknown { source } => {
+                self.raw(",");
+                self.key("triples");
+                self.triples(source);
+            }
             UnknownReason::ResourceBudget => {}
         }
         self.raw("}");
 
@@ -156,25 +156,56 @@ fn unsatisfiable_class_and_inferred_subclass() {
 }
 
 #[test]
-fn data_properties_are_out_of_fragment_with_the_offending_triple() {
+fn data_properties_are_decided_and_ill_typed_literals_are_inconsistent() {
+    let age = format!(
+        "{ALCHIQ} :age a owl:DatatypeProperty , owl:FunctionalProperty ; rdfs:domain :Person ; rdfs:range xsd:nonNegativeInteger ."
+    );
+    let r = run(&age);
+    assert_eq!(get(&r, "consistent"), &Value::Bool(true));
+    assert_eq!(s(get(&r, "classification")), "complete");
+    let r = run_with(&age, Some(":ann :age 16 ."), None);
+    assert_eq!(get(&r, "consistent"), &Value::Bool(true));
+    let r = run_with(&age, Some(":ann :age -1 ."), None);
+    assert_eq!(get(&r, "consistent"), &Value::Bool(false));
+    let r = run_with(
+        &age,
+        Some(":ann :age \"sixteen\"^^xsd:nonNegativeInteger ."),
+        None,
+    );
+    assert_eq!(get(&r, "consistent"), &Value::Bool(false));
+}
+
+#[test]
+fn nominals_are_out_of_fragment_with_the_offending_triple() {
     let r = run(&format!(
-        "{ALCHIQ} :age a owl:DatatypeProperty ; rdfs:domain :Person ; rdfs:range xsd:integer ."
+        "{ALCHIQ} :ann a owl:NamedIndividual . :Ann owl:equivalentClass [ a owl:Class ; owl:oneOf ( :ann ) ] ."
     ));
     assert_eq!(s(get(&r, "consistent")), "unknown");
     let reason = get(&r, "reason");
     assert_eq!(s(get(reason, "kind")), "OutOfFragment");
     assert!(!s(get(reason, "construct")).is_empty());
     let triples = strs(get(reason, "triples"));
     assert!(!triples.is_empty());
-    assert!(
-        triples.iter().all(|t| t.contains("<http://ex/age>")),
-        "{triples:?}"
-    );
     for t in &triples {
         assert!(t.ends_with(" ."), "{t}");
     }
-    // The profile check still ran and the ontology is in OWL 2 DL; only reasoning abstains.
-    assert_eq!(get(get(&r, "profile"), "dl"), &Value::Bool(true));
+    assert_eq!(get(&r, "classification"), &Value::Null);
+}
+
+#[test]
+fn an_undecided_datatype_question_is_datatype_unknown_with_its_triples() {
+    let r = run(&format!(
+        "{ALCHIQ} :d a owl:DatatypeProperty ; rdfs:range [ a rdfs:Datatype ; owl:onDatatype xsd:string ; owl:withRestrictions ( [ xsd:pattern \"\\\\p{{IsBasicLatin}}+\" ] ) ] . :a :d \"x\" ."
+    ));
+    assert_eq!(s(get(&r, "consistent")), "unknown");
+    let reason = get(&r, "reason");
+    assert_eq!(keys(reason), ["kind", "triples"]);
+    assert_eq!(s(get(reason, "kind")), "DatatypeUnknown");
+    let triples = strs(get(reason, "triples"));
+    assert!(!triples.is_empty());
+    for t in &triples {
+        assert!(t.ends_with(" ."), "{t}");
+    }
     assert_eq!(get(&r, "classification"), &Value::Null);
 }
Original file line number	Diff line number	Diff line change
`@@ -184,6 +184,7 @@ fn reason_kind(reason: &UnknownReason) -> &'static str {`
`184`	`184`	`UnknownReason::NotInDl(_) => "NotInDl",`
`185`	`185`	`UnknownReason::ResourceBudget => "ResourceBudget",`
`186`	`186`	`UnknownReason::ImportsNotLoaded(_) => "ImportsNotLoaded",`
	`187`	`+ UnknownReason::DatatypeUnknown { .. } => "DatatypeUnknown",`
`187`	`188`	`}`
`188`	`189`	`}`
`189`	`190`
`@@ -262,6 +263,11 @@ impl Writer<'_> {`
`262`	`263`	`self.key("imports");`
`263`	`264`	`json::push_str_array(&mut self.out, iris.iter().map(String::as_str));`
`264`	`265`	`}`
	`266`	`+ UnknownReason::DatatypeUnknown { source } => {`
	`267`	`+ self.raw(",");`
	`268`	`+ self.key("triples");`
	`269`	`+ self.triples(source);`
	`270`	`+ }`
`265`	`271`	`UnknownReason::ResourceBudget => {}`
`266`	`272`	`}`
`267`	`273`	`self.raw("}");`