@@ -150,6 +150,26 @@ All notable changes to Open Ontologies are documented here.
   and it no longer claims that the ceiling "cannot" fire, since that was
   arithmetic about the tableaux and not about the run.
 
+- **A datatype the store cannot tell apart is refused inside `sh:or`,
+  `sh:not` and `sh:qualifiedValueShape`, as it already was on its own.** The
+  store widens xsd:int, xsd:nonNegativeInteger and the other integer-derived
+  types (and xsd:dateTimeStamp) to the type they derive from, and the direct
+  `sh:datatype` constraint refuses to decide them. A member naming one did
+  not: `sh:or` and a qualified minimum reported every conforming value, and
+  `sh:not [ sh:datatype xsd:nonNegativeInteger ]` returned `conforms: true`
+  over values of exactly that type. Each now records the constraint in
+  `skipped_constraints` with the direct path's reason and suppresses the
+  verdict. W3C columns unchanged (61, 53).
+- **`sh:node` to a shape whose own `sh:datatype` the store cannot tell apart
+  is refused rather than answered.** The shape compiler refused such a
+  datatype on a property inside the referenced shape and not on the shape
+  itself, so every value the store had widened was reported. The `sh:node` is
+  now recorded as not evaluated. W3C columns unchanged.
+- **A node-level `sh:or` result carries the node shape's `sh:severity`.** It
+  was written `"Violation"` whatever the shape declared, and the RDF report
+  followed it with `sh:resultSeverity sh:Violation`; it now uses the declared
+  term, through the same `severity_name` as every other path (#334). W3C
+  columns unchanged.
 - **A custom `sh:severity` keeps its namespace in the JSON report** (#334).
   Every path set `severity` to the text after the last `#` of the declared
   IRI, and every reader takes a bare name as `sh:`, so W3C
 
@@ -796,6 +796,10 @@ impl ShaclValidator {
             // and the run came back CLEAN. Same defect in sh:in and sh:not.
             let mut or_alternatives: HashMap<String, Vec<String>> = HashMap::new();
             let mut or_unsupported: HashSet<String> = HashSet::new();
+            // Property shape -> a member datatype the store does not preserve.
+            // The direct sh:datatype path refuses that question; a member
+            // answering it reported every widened value as matching nothing.
+            let mut or_unpreserved: HashMap<String, String> = HashMap::new();
             let or_rows = query_solutions_bound(
                 &shapes_store,
                 &format!(
@@ -835,7 +839,12 @@ impl ShaclValidator {
                     continue;
                 }
                 let clause = if let Some(dt) = row.get("datatype") {
-                    datatype_conforms(&strip_angle_brackets(dt), "val")
+                    let dt = strip_angle_brackets(dt);
+                    if datatype_is_indistinguishable_in_store(&dt) {
+                        or_unpreserved.insert(p, dt);
+                        continue;
+                    }
+                    datatype_conforms(&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>* <{}> }}",
@@ -849,6 +858,13 @@ impl ShaclValidator {
                 };
                 or_alternatives.entry(p).or_default().push(clause);
             }
+            for (p, dt) in &or_unpreserved {
+                or_alternatives.remove(p);
+                if !or_unsupported.contains(p) {
+                    let path = or_paths.get(p).cloned().unwrap_or_default();
+                    skipped.push(unpreserved_datatype_skip(&shape_iri, "sh:or", &path, dt));
+                }
+            }
             for p in &or_unsupported {
                 or_alternatives.remove(p);
                 skipped.push(serde_json::json!({
@@ -876,6 +892,10 @@ impl ShaclValidator {
             // and 198 real violations were reported as a clean run.
             let mut not_clauses: HashMap<String, Vec<String>> = HashMap::new();
             let mut not_unsupported: HashSet<String> = HashSet::new();
+            // As `or_unpreserved`. Here answering anyway was a false clean: a
+            // value of the forbidden datatype read as xsd:integer, did not
+            // match, and satisfied the negation.
+            let mut not_unpreserved: HashMap<String, String> = HashMap::new();
             let not_rows = query_solutions_bound(
                 &shapes_store,
                 &format!(
@@ -918,7 +938,12 @@ impl ShaclValidator {
                     continue;
                 }
                 let clause = if let Some(dt) = row.get("datatype") {
-                    datatype_conforms(&strip_angle_brackets(dt), "val")
+                    let dt = strip_angle_brackets(dt);
+                    if datatype_is_indistinguishable_in_store(&dt) {
+                        not_unpreserved.insert(p, dt);
+                        continue;
+                    }
+                    datatype_conforms(&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>* <{}> }}",
@@ -939,6 +964,13 @@ impl ShaclValidator {
                 };
                 not_clauses.entry(p).or_default().push(clause);
             }
+            for (p, dt) in &not_unpreserved {
+                not_clauses.remove(p);
+                if !not_unsupported.contains(p) {
+                    let path = not_paths.get(p).cloned().unwrap_or_default();
+                    skipped.push(unpreserved_datatype_skip(&shape_iri, "sh:not", &path, dt));
+                }
+            }
             for p in &not_unsupported {
                 not_clauses.remove(p);
                 skipped.push(serde_json::json!({
@@ -1087,20 +1119,30 @@ impl ShaclValidator {
                         .collect();
                     members.sort();
                     let disjunction = members.join(" || ");
-                    let node_message_term = query_solutions(
+                    let node_terms = query_solutions(
                         &shapes_store,
                         &format!(
                             r#"PREFIX sh: <http://www.w3.org/ns/shacl#>
-                               SELECT ?m WHERE {{ {} sh:message ?m }}"#,
-                            shape_term
+                               SELECT ?m ?sev WHERE {{
+                                   OPTIONAL {{ {shape_term} sh:message ?m }}
+                                   OPTIONAL {{ {shape_term} sh:severity ?sev }}
+                               }}"#
                         ),
-                    )?
-                    .first()
-                    .and_then(|r| r.get("m").cloned());
+                    )?;
+                    let node_term = |k: &str| node_terms.first().and_then(|r| r.get(k).cloned());
+                    let node_message_term = node_term("m");
                     let node_message =
                         node_message_term.as_deref().map(strip_quotes).unwrap_or_default();
+                    // The node shape's sh:severity, as on every other path.
+                    // This one wrote "Violation" whatever was declared, and
+                    // the RDF report followed it with sh:Violation.
+                    let node_severity_term = node_term("sev");
+                    let node_severity = node_severity_term
+                        .as_deref()
+                        .map(severity_name)
+                        .unwrap_or_else(|| "Violation".to_string());
                     let node_or_rdf = RdfTerms::new(
-                        None,
+                        node_severity_term,
                         node_message_term.filter(|_| !node_message.is_empty()),
                     );
                     let query = format!(
@@ -1117,7 +1159,7 @@ impl ShaclValidator {
                                 node_message.clone()
                             };
                             violations.push(attribute(&shape_iri, &shape_iri, &node_or_rdf, serde_json::json!({
-                                "severity": "Violation",
+                                "severity": node_severity,
                                 "focus_node": strip_angle_brackets(focus),
                                 "value": strip_angle_brackets(focus),
                                 "constraint": "or",
@@ -1184,6 +1226,17 @@ impl ShaclValidator {
                     row.get("message").cloned().filter(|_| !q_message.is_empty()),
                 );
 
+                if let Some(dt) = row.get("datatype").map(|d| strip_angle_brackets(d))
+                    && datatype_is_indistinguishable_in_store(&dt)
+                {
+                    skipped.push(unpreserved_datatype_skip(
+                        &shape_iri,
+                        "sh:qualifiedValueShape",
+                        &q_path,
+                        &dt,
+                    ));
+                    continue;
+                }
                 let clause = if row.get("other").is_some() {
                     None
                 } else if let Some(c) = row.get("class") {
@@ -1460,15 +1513,7 @@ impl ShaclValidator {
                     // for every value that satisfied the shape: nine of them in
                     // jsonld-escaping-conformance, which is how this was found.
                     if datatype_is_indistinguishable_in_store(&dt) {
-                        skipped.push(serde_json::json!({
-                            "shape": strip_angle_brackets(&shape_iri),
-                            "constraint": "sh:datatype",
-                            "path": path,
-                            "datatype": dt,
-                            "reason": "the store does not preserve this datatype IRI, so a value \
-                                       carrying it is indistinguishable from one carrying the type \
-                                       it derives from; the constraint was not evaluated",
-                        }));
+                        skipped.push(unpreserved_datatype_skip(&shape_iri, "sh:datatype", &path, &dt));
                         continue;
                     }
                     // One evaluator gave two answers to one constraint. SHACL
@@ -2796,7 +2841,18 @@ 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(datatype_conforms(&strip_angle_brackets(obj), var)),
+            "datatype" => {
+                // Refused for the same reason as on a property inside the
+                // shape, below: the store cannot tell the datatype from the
+                // one it derives from. Only the property form was guarded, so
+                // `sh:node` to a shape declaring `sh:datatype xsd:int` itself
+                // reported every value the store had widened to xsd:integer.
+                let dt = strip_angle_brackets(obj);
+                if datatype_is_indistinguishable_in_store(&dt) {
+                    return None;
+                }
+                clauses.push(datatype_conforms(&dt, var))
+            }
             "nodeKind" => clauses.push(node_kind_test(&strip_angle_brackets(obj), var)?),
             _ => return None,
         }
@@ -2978,6 +3034,24 @@ fn datatype_is_indistinguishable_in_store(datatype: &str) -> bool {
 }
 
 
+/// The `skipped_constraints` entry for a constraint that names a datatype
+/// [`datatype_is_indistinguishable_in_store`] says cannot be decided. One
+/// record, so the direct `sh:datatype` constraint and the `sh:or`, `sh:not`
+/// and `sh:qualifiedValueShape` members that name such a datatype refuse in
+/// the same words: the member paths used to answer the question the direct
+/// path refuses, and answered it wrongly.
+fn unpreserved_datatype_skip(shape: &str, constraint: &str, path: &str, datatype: &str) -> serde_json::Value {
+    serde_json::json!({
+        "shape": strip_angle_brackets(shape),
+        "constraint": constraint,
+        "path": path,
+        "datatype": datatype,
+        "reason": "the store does not preserve this datatype IRI, so a value \
+                   carrying it is indistinguishable from one carrying the type \
+                   it derives from; the constraint was not evaluated",
+    })
+}
+
 /// The SPARQL pattern selecting the focus nodes of one target, bound to `var`.
 ///
 /// Note for anyone counting over the result: the class selector binds a focus
 
@@ -109,3 +109,105 @@ fn plain_integer_is_still_evaluated() {
     let r = report(&store(), shapes);
     assert!(!r["conforms"].is_null(), "must give a verdict: {r}");
 }
+
+// ── The same guard on every path that tests a datatype ───────────────────────
+//
+// The direct `sh:datatype` constraint (on a property shape and on a node shape)
+// consults `datatype_is_indistinguishable_in_store` and refuses to answer. The
+// paths that test a datatype as a MEMBER of something else did not, so the
+// question the direct path refuses was answered anyway, wrongly, by them: every
+// value the store had widened to `xsd:integer` failed a member of
+// `xsd:nonNegativeInteger`. Each test below names its path, asserts the refusal
+// the direct path gives, and asserts that no violation is reported.
+
+const PREFIXES: &str = r#"
+    @prefix sh: <http://www.w3.org/ns/shacl#> .
+    @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+    @prefix ex: <http://example.org/> .
+"#;
+
+fn refused(shapes_body: &str, constraint: &str) {
+    let r = report(&store(), &format!("{PREFIXES}{shapes_body}"));
+    assert_eq!(
+        r["violation_count"],
+        serde_json::json!(0),
+        "the data satisfies this shape; reporting a violation is the bug: {r}"
+    );
+    assert!(r["conforms"].is_null(), "the datatype cannot be decided, so there is no verdict: {r}");
+    let skipped = r["skipped_constraints"].as_array().cloned().unwrap_or_default();
+    assert!(
+        skipped.iter().any(|s| s["constraint"] == constraint),
+        "{constraint} must be recorded as not evaluated: {r}"
+    );
+}
+
+/// `sh:or` over a property shape's values, one member naming the datatype.
+#[test]
+fn an_or_member_naming_an_unpreserved_datatype_is_not_answered() {
+    refused(
+        "ex:S a sh:NodeShape ; sh:targetClass ex:Profile ;
+           sh:property [ sh:path ex:passes ;
+             sh:or ( [ sh:datatype xsd:nonNegativeInteger ] [ sh:datatype xsd:string ] ) ] .",
+        "sh:or",
+    );
+}
+
+/// `sh:not [ sh:datatype D ]`. Here the wrong answer was a FALSE CLEAN: every
+/// value is an xsd:nonNegativeInteger and so violates the negation, but the
+/// store said xsd:integer and the run came back `conforms: true`.
+#[test]
+fn a_not_member_naming_an_unpreserved_datatype_is_not_answered() {
+    refused(
+        "ex:S a sh:NodeShape ; sh:targetClass ex:Profile ;
+           sh:property [ sh:path ex:passes ; sh:not [ sh:datatype xsd:nonNegativeInteger ] ] .",
+        "sh:not",
+    );
+}
+
+/// `sh:qualifiedValueShape [ sh:datatype D ]`: no value counted as conforming.
+#[test]
+fn a_qualified_shape_naming_an_unpreserved_datatype_is_not_answered() {
+    refused(
+        "ex:S a sh:NodeShape ; sh:targetClass ex:Profile ;
+           sh:property [ sh:path ex:passes ;
+             sh:qualifiedValueShape [ sh:datatype xsd:nonNegativeInteger ] ; sh:qualifiedMinCount 1 ] .",
+        "sh:qualifiedValueShape",
+    );
+}
+
+/// `sh:node` to a shape whose OWN constraint is the datatype. The compiler
+/// already refused the same datatype on a property inside the referenced shape
+/// and not on the shape itself.
+#[test]
+fn a_node_shape_reference_naming_an_unpreserved_datatype_is_not_answered() {
+    refused(
+        "ex:S a sh:NodeShape ; sh:targetClass ex:Profile ;
+           sh:property [ sh:path ex:passes ; sh:node ex:Count ] .
+         ex:Count a sh:NodeShape ; sh:datatype xsd:nonNegativeInteger .",
+        "sh:node",
+    );
+}
+
+/// The guard must not swallow the decidable members: the same four paths over
+/// `xsd:integer` and `xsd:string` still give a verdict and still catch a value
+/// that matches none of them.
+#[test]
+fn members_naming_a_preserved_datatype_are_still_evaluated() {
+    let cases = [
+        "ex:S a sh:NodeShape ; sh:targetClass ex:Profile ;
+           sh:property [ sh:path ex:name ; sh:or ( [ sh:datatype xsd:integer ] [ sh:datatype xsd:date ] ) ] .",
+        "ex:S a sh:NodeShape ; sh:targetClass ex:Profile ;
+           sh:property [ sh:path ex:name ; sh:not [ sh:datatype xsd:string ] ] .",
+        "ex:S a sh:NodeShape ; sh:targetClass ex:Profile ;
+           sh:property [ sh:path ex:name ;
+             sh:qualifiedValueShape [ sh:datatype xsd:integer ] ; sh:qualifiedMinCount 1 ] .",
+        "ex:S a sh:NodeShape ; sh:targetClass ex:Profile ;
+           sh:property [ sh:path ex:name ; sh:node ex:Int ] .
+         ex:Int a sh:NodeShape ; sh:datatype xsd:integer .",
+    ];
+    for body in cases {
+        let r = report(&store(), &format!("{PREFIXES}{body}"));
+        assert_eq!(r["conforms"], serde_json::json!(false), "{body}\n{r}");
+        assert_eq!(r["violation_count"], serde_json::json!(2), "{body}\n{r}");
+    }
+}
@@ -285,6 +285,40 @@ ex:SparqlLevel a sh:NodeShape ; sh:targetClass ex:Person ;
     assert_eq!(got, want, "{j}");
 }
 
+/// `sh:or` asserted on a node shape over member shapes wrote every result as
+/// `"Violation"` whatever the shape declared, and the RDF report followed it
+/// with `sh:resultSeverity sh:Violation`. The node shape's `sh:severity` is
+/// the result's severity (SHACL 3.6.2) as on every other path.
+#[test]
+fn a_node_level_or_result_carries_the_shapes_declared_severity() {
+    for (declared, json, rdf) in [
+        ("sh:Warning", "Warning", "sh:Warning"),
+        ("sev:MySeverity", "http://ex.org/sev#MySeverity", "<http://ex.org/sev#MySeverity>"),
+        ("", "Violation", "sh:Violation"),
+    ] {
+        let severity = if declared.is_empty() { String::new() } else { format!("sh:severity {declared} ;") };
+        let shapes = format!(
+            r#"
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix ex: <http://ex.org/> .
+@prefix sev: <http://ex.org/sev#> .
+ex:S a sh:NodeShape ; sh:targetClass ex:Person ; {severity}
+    sh:or ( [ sh:property [ sh:path ex:email ; sh:minCount 1 ] ]
+            [ sh:property [ sh:path ex:phone ; sh:minCount 1 ] ] ) .
+"#
+        );
+        let j = json_report(DATA, &shapes);
+        assert_eq!(j["violation_count"], 1, "{declared}: {j}");
+        assert_eq!(j["violations"][0]["constraint"], "or", "{declared}: {j}");
+        assert_eq!(j["violations"][0]["severity"], json, "{declared}: {j}");
+        let s = parsed(&rdf_report(DATA, &shapes, ReportFormat::Turtle), RdfFormat::Turtle);
+        assert!(
+            ask(&s, &format!("?x sh:sourceConstraintComponent sh:OrConstraintComponent ; sh:resultSeverity {rdf}")),
+            "{declared}: the RDF report must carry {rdf}"
+        );
+    }
+}
+
 /// #335, MEASURED AND NOT FIXED IN THIS REPOSITORY. This test pins the loss
 /// so that it cannot be mistaken for a report-writer bug, and so that it fails,
 /// by name, on the day the store starts keeping lexical forms.