Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.
Rust ai-nativedescription-logicsformal-verificationinfrastructure-as-codeisabelle-languageknowledge-graphleanlean4mcpmcp-serverontologyowlowl2reasoningrustshaclsparqltheorem-proving
A value that is not a well-typed literal of D no longer satisfies sh:datatype D anywhere in the SHACL engine (#333)
FABIOTESSff59676ebaee
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.ymlindex 4a300db7..2be5fde6 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -939,7 +939,8 @@ jobs:# and no named PASS may regress against tests/w3c_shacl_baseline.json, in each# of two columns: the (focus, source shape, component) set, 61 of 120 PASS on# 24 Oct 2026, and the full tuple with path, value and severity as a multiset,- # 51 of 120 (#319; 12 before #318 put sh:value on default-path results).+ # 52 of 120 on 28 Oct 2026 (#319; 12 before #318 put sh:value on default-path+ # results, 51 before #333 fixed the sh:or datatype false negative).# Pretending otherwise would be exactly the silent success# this repository keeps finding elsewhere. See the module docs in# tests/w3c_shacl_conformance_test.rs.diff --git a/CHANGELOG.md b/CHANGELOG.mdindex ad73c3aa..11bc9a6e 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -46,6 +46,19 @@ All notable changes to Open Ontologies are documented here.### Fixed+- **A value that is not a well-typed literal of D no longer satisfies a+ `sh:datatype D` test anywhere in the SHACL engine** (#333). The test was+ spliced as `DATATYPE(?v) = <D>`, a SPARQL type error for an IRI or blank+ node, and FILTER drops a row whose test errors: an IRI value under `sh:or`+ over datatypes matched no alternative and was never reported, and an IRI+ passed a property shape's `sh:datatype` and a datatype nested under+ `sh:node` or a node-level `sh:or`. Separately, the `sh:or`, `sh:not`,+ `sh:qualifiedValueShape` and `sh:node` member tests lacked the lexical check+ the direct constraints had, so `"none"^^xsd:boolean` counted as an+ xsd:boolean. One helper, `datatype_conforms`, is now spliced at all eight+ sites and cannot error. W3C `core/property/or-datatypes-001` reports 3 of 3+ violations where it reported 1: full-tuple column 51 to 52 PASS, report+ match 48 to 49 of 56, gated column unchanged at 61.- **`diff` and `drift` no longer hang on a symmetric blank-node graph** (#293).Both canonicalised blank nodes through oxrdf's RDFC-1.0, which sets no limiton `hash_n_degree_quads` calls, so the cost was factorial: a 7-nodediff --git a/src/shacl.rs b/src/shacl.rsindex d10b2672..7421015e 100644--- a/src/shacl.rs+++ b/src/shacl.rs@@ -568,14 +568,10 @@ impl ShaclValidator {// datatype's lexical space is ill-typed and violates// sh:datatype (SHACL 4.1.2), and DATATYPE() alone// cannot see that: "aldi"^^xsd:integer answers- // xsd:integer. The lexical test below catches it for- // the datatypes whose lexical space is written down.- let ill = ill_typed_test(&dt, "focus")- .map(|t| format!(" || {t}"))- .unwrap_or_default();+ // xsd:integer. `datatype_conforms` tests both.checks.push(("datatype".into(),- format!("(!isLiteral(?focus) || DATATYPE(?focus) != <{dt}>{ill})"),+ format!("!{}", datatype_conforms(&dt, "focus")),format!("Value does not have datatype <{dt}>"),));}@@ -842,7 +838,7 @@ impl ShaclValidator {continue;}let clause = if let Some(dt) = row.get("datatype") {- format!("DATATYPE(?val) = <{}>", strip_angle_brackets(dt))+ datatype_conforms(&strip_angle_brackets(dt), "val")} else if let Some(c) = row.get("class") {format!("EXISTS {{ ?val <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>/<http://www.w3.org/2000/01/rdf-schema#subClassOf>* <{}> }}",@@ -925,7 +921,7 @@ impl ShaclValidator {continue;}let clause = if let Some(dt) = row.get("datatype") {- format!("DATATYPE(?val) = <{}>", strip_angle_brackets(dt))+ datatype_conforms(&strip_angle_brackets(dt), "val")} else if let Some(c) = row.get("class") {format!("EXISTS {{ ?val <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>/<http://www.w3.org/2000/01/rdf-schema#subClassOf>* <{}> }}",@@ -1059,7 +1055,8 @@ impl ShaclValidator {break;}clauses.push(format!(- "NOT EXISTS {{ ?focus <{path}> ?{v} . FILTER(DATATYPE(?{v}) != <{dt}>) }}"+ "NOT EXISTS {{ ?focus <{path}> ?{v} . FILTER(!{}) }}",+ datatype_conforms(&dt, &v)));}if let Some(nk) = row.get("nodeKind") {@@ -1204,7 +1201,7 @@ impl ShaclValidator {strip_angle_brackets(c)))} else if let Some(dt) = row.get("datatype") {- Some(format!("DATATYPE(?val) = <{}>", strip_angle_brackets(dt)))+ Some(datatype_conforms(&strip_angle_brackets(dt), "val"))} else {row.get("hasValue").map(|hv| format!("?val = {}", hv.trim()))};@@ -1489,7 +1486,7 @@ impl ShaclValidator {// One evaluator gave two answers to one constraint. SHACL// 4.1.2 makes a literal whose lexical form is outside its// datatype's lexical space a violation, `DATATYPE()` alone- // cannot see that, and `ill_typed_test` is the helper that+ // cannot see that, and `datatype_conforms` is the helper that// can. The node-shape path above has spliced it in since it// was written; this path never did. Measured over one// store: `"aldi"^^xsd:integer` and `"31/02/2026"^^xsd:date`@@ -1499,20 +1496,24 @@ impl ShaclValidator {// the constraint.//// This closes the divergence and NOT the wider gap.- // `ill_typed_test` tests a REGEX, and the date regex is+ // `datatype_conforms` tests a REGEX, and the date regex is// syntactic: `"2026-02-31"^^xsd:date` matches it, so a day// that does not exist still conforms on both paths. The// verified evaluator in `lean/Shacl/Term.lean` checks the// day against `daysInMonth` and reports it, so Lean and// Rust disagree there. See decision 0018.- let ill = ill_typed_test(&dt, "val")- .map(|t| format!(" || {t}"))- .unwrap_or_default();+ //+ // The filter is the negation of `datatype_conforms`, which+ // cannot be a type error. `DATATYPE(?val) != <dt>` was one+ // for an IRI or blank-node value, and FILTER drops a row+ // whose test errors, so a value that is not a literal at+ // all passed `sh:datatype` here (#333).+ let conforms = datatype_conforms(&dt, "val");let query = format!(r#"SELECT ?focus ?val WHERE {{{focus_pattern}?focus {path_expr} ?val .- FILTER(DATATYPE(?val) != <{dt}>{ill})+ FILTER(!{conforms})}}"#);let results = graph_sparql_select(graph, scope, &query)?;@@ -2813,10 +2814,7 @@ fn compile_node_shape("EXISTS {{ ?{var} <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>/<http://www.w3.org/2000/01/rdf-schema#subClassOf>* <{}> }}",strip_angle_brackets(obj))),- "datatype" => clauses.push(format!(- "DATATYPE(?{var}) = <{}>",- strip_angle_brackets(obj)- )),+ "datatype" => clauses.push(datatype_conforms(&strip_angle_brackets(obj), var)),"nodeKind" => clauses.push(node_kind_test(&strip_angle_brackets(obj), var)?),_ => return None,}@@ -2902,7 +2900,8 @@ fn compile_node_shape(return None;}clauses.push(format!(- "NOT EXISTS {{ ?{var} <{path}> ?{inner} . FILTER(DATATYPE(?{inner}) != <{dt}>) }}"+ "NOT EXISTS {{ ?{var} <{path}> ?{inner} . FILTER(!{}) }}",+ datatype_conforms(&dt, &inner)));}if let Some(nk) = row.get("nodeKind") {@@ -3273,15 +3272,41 @@ fn constraint_component(constraint: &str) -> String {format!("http://www.w3.org/ns/shacl#{name}ConstraintComponent")}-/// `Some(test)` that is TRUE when `?var` is a literal of `datatype` whose-/// lexical form is outside that datatype's lexical space, for the datatypes-/// whose lexical space is written down here. `None` for any other datatype,-/// where an ill-typed literal cannot be told from a well-typed one.+/// The SPARQL test that is TRUE exactly when `?var` conforms to+/// `sh:datatype <datatype>` (SHACL 4.1.2): it is a literal, its datatype is+/// `datatype`, and, for the datatypes whose lexical space is written down+/// below, its lexical form is inside that space. Every place the engine asks+/// "does this value have datatype D" splices this one expression, positively+/// for `sh:or`, `sh:qualifiedValueShape` and `sh:not` members and a nested+/// `sh:node`, negated for the constraint itself.+///+/// It is never a SPARQL type error, and that is the point (#333). The bare+/// `DATATYPE(?v) = <D>` it replaces is an error for an IRI or blank node, an+/// error inside `!(a || b)` stays an error, and FILTER drops a row whose test+/// errors. So an IRI value of a property under `sh:or` over datatypes matched+/// no alternative and was never reported; the same drop let an IRI pass a+/// property shape's `sh:datatype` and a nested `sh:node` datatype. Here+/// `isLiteral` comes first and `false && error` is `false`. And `DATATYPE()`+/// alone answers `xsd:boolean` for the ill-typed `"none"^^xsd:boolean`, which+/// is why every member test now carries the lexical check that only the+/// direct `sh:datatype` constraints had: W3C `core/property/or-datatypes-001`+/// reported one of its three violations.+fn datatype_conforms(datatype: &str, var: &str) -> String {+ let lexical = lexical_space_regex(datatype)+ .map(|re| format!(" && REGEX(STR(?{var}), \"{re}\")"))+ .unwrap_or_default();+ format!("(isLiteral(?{var}) && DATATYPE(?{var}) = <{datatype}>{lexical})")+}++/// The XSD lexical space of `datatype` as a regex already escaped for a+/// SPARQL string literal, for the datatypes whose lexical space is written+/// down here. `None` for any other datatype, where an ill-typed literal cannot+/// be told from a well-typed one.////// The patterns are the XSD lexical spaces, not the value spaces: `01` is a/// valid integer lexical form and `1.` a valid decimal one. Backslashes are/// doubled once for the SPARQL string literal they are spliced into.-fn ill_typed_test(datatype: &str, var: &str) -> Option<String> {+fn lexical_space_regex(datatype: &str) -> Option<String> {const XSD: &str = "http://www.w3.org/2001/XMLSchema#";let local = datatype.strip_prefix(XSD)?;let re = match local {@@ -3305,8 +3330,7 @@ fn ill_typed_test(datatype: &str, var: &str) -> Option<String> {// | '"' | '\'' | '\\']` and the validator returned Err, so a shapes graph// that named a decimal, double, float or dateTime could not be evaluated// at all.- let escaped = re.replace('\\', "\\\\");- Some(format!("(DATATYPE(?{var}) = <{datatype}> && !REGEX(STR(?{var}), \"{escaped}\"))"))+ Some(re.replace('\\', "\\\\"))}/// `<http://www.w3.org/ns/shacl#class>` -> `class`, for the node-level rows.diff --git a/tests/shacl_or_test.rs b/tests/shacl_or_test.rsindex 9b907c03..5faad3b1 100644--- a/tests/shacl_or_test.rs+++ b/tests/shacl_or_test.rs@@ -202,3 +202,218 @@ fn unrecognised_node_kind_is_skipped_not_passed() {);assert!(r["conforms"].is_null(), "verdict must be suppressed: {r}");}++// ── #333: a datatype test that cannot be a type error ───────────────────────+//+// W3C `core/property/or-datatypes-001` expects three `sh:or` violations on one+// focus node and the engine reported one. Two causes, both in how "value V+// has datatype D" was spliced into SPARQL as `DATATYPE(?v) = <D>`:+//+// * `DATATYPE()` of an IRI or blank node is a type error. Inside+// `FILTER(!(a || b))` the error propagates and the FILTER drops the row,+// so an IRI value was never counted as matching no alternative.+// * `"none"^^xsd:boolean` answers `DATATYPE() = xsd:boolean` though its+// lexical form is outside xsd:boolean's lexical space. SHACL 4.1.2 makes+// an ill-typed literal a non-match of `sh:datatype`.++const OR_DATATYPES_SHAPE: &str = r#"+@prefix sh: <http://www.w3.org/ns/shacl#> .+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+@prefix : <http://ex.org/> .+:S a sh:NodeShape ; sh:targetClass :T ;+ sh:property [ sh:path :comment ;+ sh:or ( [ sh:datatype xsd:string ] [ sh:datatype rdf:HTML ]+ [ sh:datatype rdf:langString ] [ sh:datatype xsd:boolean ] ) ] .+"#;++fn values_of(r: &serde_json::Value) -> Vec<String> {+ let mut v: Vec<String> = r["violations"]+ .as_array()+ .cloned()+ .unwrap_or_default()+ .iter()+ .map(|x| x["value"].as_str().unwrap_or("(none)").to_string())+ .collect();+ v.sort();+ v+}++/// The W3C case in miniature: an IRI, an integer and an ill-typed boolean+/// each match no alternative, and each is its own violation.+#[test]+fn or_over_datatypes_reports_an_iri_and_an_ill_typed_literal() {+ let data = r#"+@prefix : <http://ex.org/> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+:bad a :T ; :comment :SomeIri , 42 , "A string" , "none"^^xsd:boolean , "true"^^xsd:boolean .+"#;+ let r = validate(data, OR_DATATYPES_SHAPE);+ assert_eq!(r["conforms"], false, "{r}");+ assert_eq!(+ values_of(&r),+ vec![+ "\"42\"^^<http://www.w3.org/2001/XMLSchema#integer>".to_string(),+ "\"none\"^^<http://www.w3.org/2001/XMLSchema#boolean>".to_string(),+ "http://ex.org/SomeIri".to_string(),+ ],+ "{r}"+ );+}++/// The other direction: every alternative's well-typed values still conform.+#[test]+fn or_over_datatypes_still_admits_every_alternative() {+ let data = r#"+@prefix : <http://ex.org/> .+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+:good a :T ; :comment "<div>HTML</div>"^^rdf:HTML , "a language string"@en , "A string" ,+ "false"^^xsd:boolean , "1"^^xsd:boolean .+"#;+ let r = validate(data, OR_DATATYPES_SHAPE);+ assert_eq!(r["violation_count"], 0, "{r}");+ assert_eq!(r["conforms"], true, "{r}");+}++/// Same cause on a plain `sh:datatype` property constraint: the violation+/// filter was `DATATYPE(?val) != <D>`, which is a type error for an IRI, so an+/// IRI value passed `sh:datatype xsd:string`.+#[test]+fn an_iri_value_violates_sh_datatype() {+ let shapes = r#"+@prefix sh: <http://www.w3.org/ns/shacl#> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+@prefix : <http://ex.org/> .+:S a sh:NodeShape ; sh:targetClass :T ;+ sh:property [ sh:path :label ; sh:datatype xsd:string ] .+"#;+ let data = r#"+@prefix : <http://ex.org/> .+:a a :T ; :label :NotALiteral , "fine" .+"#;+ let r = validate(data, shapes);+ assert_eq!(values_of(&r), vec!["http://ex.org/NotALiteral".to_string()], "{r}");+}++/// Node-level `sh:or` over member shapes: a member whose property carries+/// `sh:datatype` must not be satisfied by an IRI or an ill-typed value.+#[test]+fn node_level_or_member_datatype_is_not_satisfied_by_an_iri_or_ill_typed_value() {+ let shapes = r#"+@prefix sh: <http://www.w3.org/ns/shacl#> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+@prefix : <http://ex.org/> .+:S a sh:NodeShape ; sh:targetClass :T ;+ sh:or ( [ sh:property [ sh:path :flag ; sh:datatype xsd:boolean ] ]+ [ sh:property [ sh:path :flag ; sh:datatype xsd:integer ] ] ) .+"#;+ let data = r#"+@prefix : <http://ex.org/> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+:iri a :T ; :flag :NotALiteral .+:ill a :T ; :flag "none"^^xsd:boolean .+:ok a :T ; :flag true .+"#;+ let r = validate(data, shapes);+ let mut foci: Vec<String> = r["violations"]+ .as_array()+ .cloned()+ .unwrap_or_default()+ .iter()+ .map(|x| x["focus_node"].as_str().unwrap_or_default().to_string())+ .collect();+ foci.sort();+ assert_eq!(foci, vec!["http://ex.org/ill".to_string(), "http://ex.org/iri".to_string()], "{r}");+}++/// `sh:not [ sh:datatype xsd:boolean ]`: an ill-typed boolean does not+/// conform to the inner shape, so the negation is satisfied.+#[test]+fn an_ill_typed_literal_satisfies_sh_not_datatype() {+ let shapes = r#"+@prefix sh: <http://www.w3.org/ns/shacl#> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+@prefix : <http://ex.org/> .+:S a sh:NodeShape ; sh:targetClass :T ;+ sh:property [ sh:path :flag ; sh:not [ sh:datatype xsd:boolean ] ] .+"#;+ let data = r#"+@prefix : <http://ex.org/> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+:a a :T ; :flag "none"^^xsd:boolean , true .+"#;+ let r = validate(data, shapes);+ assert_eq!(+ values_of(&r),+ vec!["\"true\"^^<http://www.w3.org/2001/XMLSchema#boolean>".to_string()],+ "{r}"+ );+}++/// `sh:qualifiedValueShape [ sh:datatype xsd:boolean ]`: an ill-typed boolean+/// is not a value that conforms, so it does not count towards the minimum.+#[test]+fn an_ill_typed_literal_does_not_count_towards_a_qualified_datatype_shape() {+ let shapes = r#"+@prefix sh: <http://www.w3.org/ns/shacl#> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+@prefix : <http://ex.org/> .+:S a sh:NodeShape ; sh:targetClass :T ;+ sh:property [ sh:path :flag ;+ sh:qualifiedValueShape [ sh:datatype xsd:boolean ] ; sh:qualifiedMinCount 1 ] .+"#;+ let data = r#"+@prefix : <http://ex.org/> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+:a a :T ; :flag "none"^^xsd:boolean .+"#;+ let r = validate(data, shapes);+ assert_eq!(r["violation_count"], 1, "{r}");+ assert_eq!(r["violations"][0]["constraint"], "qualifiedMinCount", "{r}");+}++/// `sh:node` compiles the referenced shape into one boolean expression and+/// reports `FILTER(!(expr))`. A datatype test in that expression erroring on+/// an IRI dropped the row, so an IRI passed a nested `sh:datatype`, both on+/// the referenced shape itself and on a property shape inside it; an+/// ill-typed literal passed both too.+#[test]+fn sh_node_datatype_rejects_an_iri_and_an_ill_typed_value() {+ let shapes = r#"+@prefix sh: <http://www.w3.org/ns/shacl#> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+@prefix : <http://ex.org/> .+:S a sh:NodeShape ; sh:targetClass :T ;+ sh:property [ sh:path :flag ; sh:node :Boolean ] ;+ sh:property [ sh:path :child ; sh:node :HasBooleanFlag ] .+:Boolean a sh:NodeShape ; sh:datatype xsd:boolean .+:HasBooleanFlag a sh:NodeShape ; sh:property [ sh:path :flag ; sh:datatype xsd:boolean ] .+"#;+ let data = r#"+@prefix : <http://ex.org/> .+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .+:iri a :T ; :flag :NotALiteral .+:ill a :T ; :flag "none"^^xsd:boolean .+:ok a :T ; :flag true ; :child :c1 .+:c1 :flag true .+:childIri a :T ; :child :c2 .+:c2 :flag :NotALiteral .+:childIll a :T ; :child :c3 .+:c3 :flag "none"^^xsd:boolean .+"#;+ let r = validate(data, shapes);+ let mut foci: Vec<String> = r["violations"]+ .as_array()+ .cloned()+ .unwrap_or_default()+ .iter()+ .map(|x| x["focus_node"].as_str().unwrap_or_default().to_string())+ .collect();+ foci.sort();+ assert_eq!(+ foci,+ ["childIll", "childIri", "ill", "iri"].map(|f| format!("http://ex.org/{f}")).to_vec(),+ "{r}"+ );+}diff --git a/tests/shacl_validation_report_w3c_test.rs b/tests/shacl_validation_report_w3c_test.rsindex 37cd1e55..37ab8a6b 100644--- a/tests/shacl_validation_report_w3c_test.rs+++ b/tests/shacl_validation_report_w3c_test.rs@@ -47,15 +47,17 @@ use std::sync::Arc;/// Measured on 24 Oct 2026, suite commit 94d8bc2: 48 of the 56 core/ cases the/// conformance baseline records as PASS produce a report that matches the-/// expected one on every compared predicate. The other eight are named below.-const MATCHED_FLOOR: usize = 48;+/// expected one on every compared predicate. 49 since #333 (28 Oct 2026, same+/// suite commit), when `core/property/or-datatypes-001` started reporting all+/// three of its `sh:or` violations. The other seven are named below.+const MATCHED_FLOOR: usize = 49;/// The PASS cases whose full report differs, each with the measured cause./// None is a defect of the report writer: each graph says what the JSON/// already said. They are the gaps the set comparison in/// `w3c_shacl_conformance_test.rs` cannot see, which is why this file exists./// A case not listed here that stops matching fails by name.-const KNOWN_DIFFERENCES: [(&str, &str); 8] = [+const KNOWN_DIFFERENCES: [(&str, &str); 7] = [("core/node/class-003","ex:John is selected by sh:targetClass AND sh:targetNode and reported once per target \@@ -83,13 +85,6 @@ const KNOWN_DIFFERENCES: [(&str, &str); 8] = [result where SHACL gives two",),("core/property/node-002", "sh:node selects DISTINCT ?focus, so no sh:value"),- (- "core/property/or-datatypes-001",- "an ENGINE false negative: of the three sh:or violations only the integer is reported. \- DATATYPE(owl:Thing) is a type error that drops the row inside FILTER, and \- \"none\"^^xsd:boolean satisfies DATATYPE() = xsd:boolean though it is ill-typed. The \- set comparison passes it because all three share one (focus, shape, component)",- ),];const SUITE_BASE: &str = "https://w3c.github.io/data-shapes/data-shapes-test-suite/tests/";diff --git a/tests/w3c_shacl_baseline.json b/tests/w3c_shacl_baseline.jsonindex 18eed219..d5504050 100644--- a/tests/w3c_shacl_baseline.json+++ b/tests/w3c_shacl_baseline.json@@ -134,8 +134,8 @@"full_tuple": {"counts": {"total": 120,- "pass": 51,- "fail": 25,+ "pass": 52,+ "fail": 24,"undetermined": 44,"error": 0},@@ -221,7 +221,7 @@"core/property/nodeKind-001": "PASS","core/property/not-001": "PASS","core/property/or-001": "PASS",- "core/property/or-datatypes-001": "FAIL",+ "core/property/or-datatypes-001": "PASS","core/property/pattern-001": "PASS","core/property/pattern-002": "UNDETERMINED","core/property/property-001": "FAIL",diff --git a/tests/w3c_shacl_conformance_test.rs b/tests/w3c_shacl_conformance_test.rsindex 8c33d73f..88e3f0c0 100644--- a/tests/w3c_shacl_conformance_test.rs+++ b/tests/w3c_shacl_conformance_test.rs@@ -62,6 +62,10 @@//! `or-datatypes-001` (an `sh:or` false negative), and `pre-binding-001`,//! `-002` and `-007` under `sparql/`.//!+//! With #333 fixed, `or-datatypes-001` reports all three of its violations+//! (an IRI value and an ill-typed `"none"^^xsd:boolean` had been dropped) and+//! the column scores PASS 52 (measured 2026-10-28, same suite commit).+//!//! Severity is in the full-tuple column and NOT in the gated one, by//! measurement rather than by principle. The old reason for leaving it out//! ("the engine's `severity` field is not yet driven by `sh:severity`") is