@@ -150,6 +150,40 @@ 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.
 
+- **The store gives a literal back as it was written** (#335; the store fix
+  is oxigraph/oxigraph#2010 by Fabio Rovai, backported onto the pinned fork
+  as rev 6409fa1c). Oxigraph 0.5.9 stored every literal of an XSD datatype it
+  could value-encode by value and gave it back in canonical form:
+  `"4.0"^^xsd:decimal` came back as `"4"`, `"1"^^xsd:boolean` as `"true"`,
+  `"5"^^xsd:int` as `"5"^^xsd:integer`, and `"4.0"` and `"4"` loaded as one
+  triple. The pinned store value-encodes a literal only when decoding gives it
+  back as written. So `sh:value` and a literal focus node now carry the term as
+  written (W3C `core/node/maxExclusive-001` and `minExclusive-001` match their
+  expected reports: report match 49 to 51 of 56; gated column 61 and full-tuple
+  column 53 unchanged, baseline byte-identical), a load-then-serialise round
+  trip no longer rewrites literals, and `asserted.tsv` carries literals as
+  written. NOT fixed, because the SPARQL evaluator (`spareval`) is unpatched:
+  inside a query `STR("4.0"^^xsd:decimal)` is still `"4"` and
+  `DATATYPE("5"^^xsd:int)` still `xsd:integer`, so `sh:pattern "\.0$"` still
+  reports `"4.0"^^xsd:decimal`, and `sh:datatype` naming one of the twelve
+  integer-derived types or `xsd:dateTimeStamp` is still recorded as not
+  evaluated (measured over every XSD datatype; pinned in
+  `tests/datatype_preservation_test.rs` and
+  `inside_a_query_a_known_datatype_literal_is_still_read_by_value`).
+
+- **A projection-entailment goal written with a literal is asked as written**
+  (consequence of #335). Goals are still round-tripped through a store, but the
+  store no longer respells `"01"^^xsd:integer` as `"1"`, so a goal `"01"` asked
+  of a source that says `"1"` is `ungrounded_in_source`, where it used to come
+  back `preserved_asserted`. One value, two terms, which is what the checker
+  has always done.
+
+- **A `sh:datatype` skipped for an integer-derived type or `xsd:dateTimeStamp`
+  names the real cause.** The skip reason said the store does not preserve the
+  datatype; since #335 it does, and what cannot report it is `DATATYPE()` in the
+  SPARQL evaluator. The reason now says so (`... so DATATYPE() cannot tell a
+  value carrying it from one carrying that type ...`). The set of datatypes and
+  every verdict are unchanged, by measurement on the new pin.
 - **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
 
@@ -119,18 +119,26 @@ toml = "0.8"
 # not grow by a single crate.
 proptest = "1"
 
-# A patched Oxigraph, pinned by revision.
+# A patched Oxigraph, pinned by revision. Two changes over 0.5.9, on branch
+# `oo/lexical-forms-0.5.9` of the fork.
 #
-# `Store::snapshot` is not in Oxigraph 0.5.9. It is a read view pinned to one
-# state that takes no lock, and decision 0010 explains at length why neither
-# thing the unpatched crate offers will do: a transaction pins the state but
-# stops every writer for the length of a reasoning run on the memory backend,
-# and copying the graph costs about 221 bytes a triple. The patch is a public
-# wrapper over `Storage::snapshot`, which `Store::len` and
-# `Store::quads_for_pattern` already call internally on every read.
+# 1. `Store::snapshot`, not in Oxigraph 0.5.9. It is a read view pinned to one
+#    state that takes no lock, and decision 0010 explains at length why neither
+#    thing the unpatched crate offers will do: a transaction pins the state but
+#    stops every writer for the length of a reasoning run on the memory backend,
+#    and copying the graph costs about 221 bytes a triple. The patch is a public
+#    wrapper over `Storage::snapshot`, which `Store::len` and
+#    `Store::quads_for_pattern` already call internally on every read.
+# 2. A literal is kept as written (oxigraph/oxigraph#2010, fixing #1989; here
+#    #335). 0.5.9 stored every literal of an XSD datatype with a value encoding
+#    by value and gave it back in the canonical form of the primitive type, so
+#    "4.0"^^xsd:decimal came back as "4", "1"^^xsd:boolean as "true",
+#    "5"^^xsd:int as "5"^^xsd:integer, and "4.0" and "4" loaded as one triple.
+#    A literal is now value-encoded only when decoding gives back the same
+#    datatype and lexical form; any other takes the generic typed-literal path.
 #
 # Pinned by REVISION and not by branch, so that what CI builds is what was
-# reviewed. Upstream at oxigraph/oxigraph; when it lands this stanza goes and
+# reviewed. Upstream at oxigraph/oxigraph; when both land this stanza goes and
 # the version bound below is all that remains.
 [patch.crates-io]
-oxigraph = { git = "https://github.com/fabio-rovai/oxigraph.git", rev = "abf36ef22b61f9c4d810b94b647d500c05ee791c" }
+oxigraph = { git = "https://github.com/fabio-rovai/oxigraph.git", rev = "6409fa1c8ad5880399d0ca69b38e43cbb2052ad7" }
@@ -8,6 +8,17 @@ send.
 
 ## 1. Twelve XSD integer-derived datatypes, and `xsd:dateTimeStamp`, are not preserved
 
+**Status, 28 Oct 2026.** 1a is fixed in the pinned fork and filed upstream as
+oxigraph/oxigraph#2010 (issue #1989): the store value-encodes a literal only
+when decoding gives it back as written, so these datatypes, and non-canonical
+lexical forms such as `"4.0"^^xsd:decimal`, now survive a load (here #335,
+`tests/datatype_preservation_test.rs::the_store_keeps_every_declared_datatype`).
+1b is NOT fixed: measured on the new pin, `DATATYPE()` still answers
+`xsd:integer` for the twelve and `xsd:dateTime` for `xsd:dateTimeStamp`, and
+`STR()` of a known-datatype literal is still its canonical form, inside any
+query, whether the literal is stored or written in the query text. So the
+workaround below stays.
+
 **Two independent defects, in two crates.** They were first reported here as one,
 blamed on storage. That was wrong, and the correction matters for anyone acting
 on it: fixing the storage encoder alone leaves `DATATYPE()` still returning the
@@ -113,9 +124,11 @@ up here rather than attempted blind.
 ### Our workaround
 
 `datatype_is_indistinguishable_in_store` in `src/shacl.rs` records a
-`sh:datatype` constraint naming one of these as unevaluated rather than answering
-it wrongly. `tests/datatype_preservation_test.rs` pins the exact affected set and
-fails in both directions, so the workaround is removed when this is fixed.
+`sh:datatype` constraint (and, since the #333 follow-ups, an `sh:or`, `sh:not`,
+qualified or `sh:node` member) naming one of these as unevaluated rather than
+answering it wrongly. With 1a fixed it rests on 1b alone.
+`tests/datatype_preservation_test.rs` pins the exact set `DATATYPE()` misreports
+and fails in both directions, so the workaround is removed when 1b is fixed.
 
 ---
 
 
@@ -215,6 +215,10 @@ test fails if the gate is disarmed on more than half the corpus.
    certificate and is reported LOST, which is a false loss with a green-looking pipeline round it. Goals are
    now round-tripped through a real `GraphStore`, one triple per named graph so a set cannot collapse
    duplicates or shift the caller's pairing, and both `as_written` and `goal` are printed.
+   *Superseded in part by #335 (28 Oct 2026):* the pinned store no longer canonicalises, so the
+   round trip leaves `"01"` as `"01"`, and a goal `"01"` asked of a source holding `"1"` is
+   ungrounded rather than preserved. The round trip stays so that goal and store are spelled by the
+   same code.
 
 4. **`GraphStore::canonicalize_blank_nodes` is the wrong tool and is now pinned as such.** RDFC-1.0
    labels are a function of the WHOLE graph. Measured on `pizza-reference.owl`, taking a genuine
 
@@ -204,10 +204,11 @@ line between the buckets was drawn.
 
 ## The control, and the bound it actually has
 
-`"300"^^xsd:byte` is outside the byte range and is the W3C suite's own ill-formed case. Oxigraph does
-not preserve `xsd:byte`, so the literal arrives as `"300"^^xsd:integer`,
-`datatype_is_indistinguishable_in_store` routes the constraint to `skipped_constraints`, and the
-verdict is `null`. An attack surface where every probe succeeds is not a measurement, so this one is
+`"300"^^xsd:byte` is outside the byte range and is the W3C suite's own ill-formed case. Oxigraph
+0.5.9 did not preserve `xsd:byte`, so the literal arrived as `"300"^^xsd:integer`. Since #335 the
+store keeps it as written, but the SPARQL evaluator still reads `xsd:byte` as `xsd:integer`, so
+`DATATYPE()` cannot judge it, `datatype_is_indistinguishable_in_store` routes the constraint to
+`skipped_constraints`, and the verdict is `null`. An attack surface where every probe succeeds is not a measurement, so this one is
 kept beside the failures rather than in a passing-cases file.
 
 The bound is one-directional and the test now says so. A consumer reading for a PASS is protected,
 
@@ -922,8 +922,9 @@ Stated rather than discovered later.
   exactly their own rule once. No rule in the table is unreachable, so the seven were a gap in the
   corpus and not a defect in the engine.
 - **`asserted.tsv` is the store, not your file.** Quads are flattened, so a triple present in two
-  named graphs appears on two lines. Literals are in the store's post-parse canonical spelling, so
-  `"01"^^xsd:integer` is written `"1"^^xsd:integer`. The guarantee is relative to that file.
+  named graphs appears on two lines. Literals are as the store gives them back, which since #335
+  is as they were written: `"01"^^xsd:integer` stays `"01"` (under Oxigraph 0.5.9 it was written
+  `"1"^^xsd:integer`). The guarantee is relative to that file.
 - **`asserted.tsv` is the store the run SELECTED, and the checker cannot see the selection.** By
   default that is every graph. Over a store that keeps several versions of an entity in several
   named graphs, the union of every version is a state that held at no instant, and a certificate
 
@@ -48,9 +48,11 @@ EOF
 ```
 
 `--goals` is a Turtle document in which every triple is a claim. It is parsed by the SAME parser the
-store uses and round-tripped through a store, which is the only thing that makes a caller's spelling
-of a term comparable with the interner's: `"01"^^xsd:integer` is stored as `"1"^^xsd:integer`, and a
-goal that skipped the store would match nothing and be reported lost. A TSV works too, with
+store uses and round-tripped through a store, so a caller's spelling of a term is the interner's. A
+literal is asked as written: since #335 the store keeps `"01"^^xsd:integer` as `"01"`, so the goal
+matches a source that says `"01"` and not one that says `"1"`. One value, two terms; nothing here
+compares literals by value. (Under Oxigraph 0.5.9 the store respelled both as `"1"`, and the two
+matched.) A TSV works too, with
 `--goals-skip-columns 1` so `derivations.tsv` from `reason --certificate` pipes straight in.
 
 Over MCP, `graph_projection_entailment_check` takes `goals_ttl` and either `projected_ttl` or
 
@@ -1392,13 +1392,14 @@ impl GraphStore {
     /// Round-trip triples through a STORE, in order, keeping duplicates.
     ///
     /// Parsing alone is not enough, and this is measured rather than assumed:
-    /// oxigraph's parser preserves a literal's lexical form, and it is the
-    /// STORE that normalises it. `"01"^^xsd:integer` comes back from
-    /// [`parse_triples_ordered`](Self::parse_triples_ordered) exactly as
-    /// written and out of [`all_triples`](Self::all_triples) as
-    /// `"1"^^xsd:integer`. A caller that compares its own spelling of a term
-    /// against what a certificate holds therefore has to push the term through
-    /// a store first, or it matches nothing and the miss looks like data loss.
+    /// A caller that compares its own spelling of a term against what a
+    /// certificate holds pushes the term through a store first, so the two are
+    /// spelled by the same code. Until #335 that was what made them match:
+    /// Oxigraph 0.5.9's parser kept `"01"^^xsd:integer` and its store gave it
+    /// back as `"1"^^xsd:integer`. The pinned store keeps literals as written,
+    /// so the round trip no longer respells a literal, and `"01"` and `"1"`
+    /// are two terms on both sides; it still refuses what no serialiser can
+    /// write, and it keeps the comparison honest if the store changes again.
     ///
     /// Each triple gets its own named graph, because a store is a SET: two
     /// identical inputs would otherwise collapse to one and the caller's
 
@@ -231,9 +231,13 @@ pub fn is_ofn_format(name: &str) -> bool {
 /// cannot disagree about what was left out.
 ///
 /// The document's triples are handed over as parsed, without passing through
-/// a store: Oxigraph's store re-types an `xsd:nonNegativeInteger` literal as
-/// `xsd:integer` (measured on `owl:minCardinality 2`), and every cardinality
-/// that had happened to would be refused as outside Table 1.
+/// a store, so nothing between the file and the writer can respell a term.
+/// That was first done because Oxigraph 0.5.9's store re-typed an
+/// `xsd:nonNegativeInteger` literal as `xsd:integer` (measured on
+/// `owl:minCardinality 2`), and every such cardinality would have been refused
+/// as outside Table 1. The pinned store keeps literals as written since #335
+/// (`tests/datatype_preservation_test.rs`); reading without one is kept
+/// because it is the shorter path, not because a store would now be wrong.
 pub fn convert_file(path: &str) -> anyhow::Result<OfnOutput> {
     let (quads, prefixes) = crate::graph::GraphStore::read_file_with_prefixes(path)?;
     let triples: Vec<Triple> = quads.into_iter().map(Triple::from).collect();