From 3e9f6beccd83d32b20d8e3aa5e81dcee9df01adc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Tue, 18 Aug 2026 16:16:55 +0200
Subject: [PATCH 1/2] Version diffs in the history modal

Add From/To version selection to the Memento history modal and render a
client-side triple diff between the two selected versions as Turtle-style
hunks: subject header, then -/+ predicate-object lines (red/green, matching
the From/To column headers), changed values of the same property paired up.

The diff is the set difference over canonical triple keys, computed with the
new shared ldh:triples-map() extracted from the origin-vs-local comparison in
layout.xsl. The shared key gains an rdf:parseType="Literal" branch (XMLLiteral
objects previously keyed on empty text) and an opt-in numeric normalization:
layout.xsl keeps it for cross-serializer comparison, the version diff compares
exact lexical forms.

Both ?version= representations are fetched with a per-branch-context
ixsl:http-request fan-out joined by ixsl:all; no server changes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../xsl/bootstrap/2.3.2/client/memento.xsl    | 163 ++++++++++++++----
 .../xsl/bootstrap/2.3.2/imports/default.xsl   |  16 ++
 .../xsl/bootstrap/2.3.2/imports/memento.xsl   |  72 ++++++++
 .../xsl/bootstrap/2.3.2/layout.xsl            |  16 +-
 .../xsl/bootstrap/2.3.2/translations.rdf      |  16 ++
 5 files changed, 240 insertions(+), 43 deletions(-)

diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/memento.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/memento.xsl
index f3b46f4af..0c42d0162 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/memento.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/memento.xsl
@@ -71,35 +71,69 @@ version="3.0"
                         <div class="modal-body">
                             <xsl:choose>
                                 <xsl:when test="$response?status = 200 and $response?media-type = 'application/rdf+xml'">
-                                    <table class="table table-striped">
-                                        <colgroup>
-                                            <col style="width: 60%;"/>
-                                            <col style="width: 40%;"/>
-                                        </colgroup>
-                                        <thead>
-                                            <tr>
-                                                <th>
-                                                    <xsl:value-of>
-                                                        <xsl:apply-templates select="key('resources', 'version', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
-                                                    </xsl:value-of>
-                                                </th>
-                                                <th>
-                                                    <xsl:value-of>
-                                                        <xsl:apply-templates select="key('resources', 'agent', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
-                                                    </xsl:value-of>
-                                                </th>
-                                            </tr>
-                                        </thead>
-                                        <tbody>
-                                            <xsl:variable name="mementos" select="$response?body//*[@rdf:about][rdf:type/@rdf:resource = '&memento;Memento']" as="element()*"/>
-                                            <!-- on the live document view, the latest version is the one being viewed -->
-                                            <xsl:variable name="latest-memento" select="sort($mementos, (), function($memento) { string($memento/memento:mementoDatetime) })[last()]/@rdf:about" as="attribute()?"/>
-                                            <xsl:apply-templates select="$mementos" mode="bs2:MementoList">
-                                                <xsl:sort select="memento:mementoDatetime" order="descending"/>
-                                                <xsl:with-param name="current-memento" select="if (map:contains(ldh:query-params(), 'version')) then xs:anyURI(ac:absolute-path(ldh:request-uri()) || '?version=' || ldh:query-params()?version) else xs:anyURI($latest-memento)"/>
-                                            </xsl:apply-templates>
-                                        </tbody>
-                                    </table>
+                                    <xsl:variable name="mementos" select="$response?body//*[@rdf:about][rdf:type/@rdf:resource = '&memento;Memento']" as="element()*"/>
+                                    <xsl:variable name="sorted-mementos" select="sort($mementos, (), function($memento) { string($memento/memento:mementoDatetime) })" as="element()*"/>
+                                    <!-- on the live document view, the latest version is the one being viewed -->
+                                    <xsl:variable name="current-memento" select="if (map:contains(ldh:query-params(), 'version')) then xs:anyURI(ac:absolute-path(ldh:request-uri()) || '?version=' || ldh:query-params()?version) else xs:anyURI($sorted-mementos[last()]/@rdf:about)" as="xs:anyURI?"/>
+                                    <xsl:variable name="current-index" select="index-of($sorted-mementos ! string(@rdf:about), string($current-memento))[1]" as="xs:integer?"/>
+                                    <!-- preselect the viewed version as the diff target and its predecessor as the diff source (the viewed version itself when there is none) -->
+                                    <xsl:variable name="from-memento" select="(xs:anyURI($sorted-mementos[$current-index - 1]/@rdf:about), $current-memento)[1]" as="xs:anyURI?"/>
+                                    <form id="form-version-diff">
+                                        <table class="table table-striped">
+                                            <colgroup>
+                                                <col style="width: 45%;"/>
+                                                <col style="width: 25%;"/>
+                                                <col style="width: 15%;"/>
+                                                <col style="width: 15%;"/>
+                                            </colgroup>
+                                            <thead>
+                                                <tr>
+                                                    <th>
+                                                        <xsl:value-of>
+                                                            <xsl:apply-templates select="key('resources', 'version', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                                                        </xsl:value-of>
+                                                    </th>
+                                                    <th>
+                                                        <xsl:value-of>
+                                                            <xsl:apply-templates select="key('resources', 'agent', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                                                        </xsl:value-of>
+                                                    </th>
+                                                    <!-- header colors match the diff line colors: - lines come from the From version, + lines from the To version -->
+                                                    <th class="text-error">
+                                                        <xsl:value-of>
+                                                            <xsl:apply-templates select="key('resources', 'from', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                                                        </xsl:value-of>
+                                                    </th>
+                                                    <th class="text-success">
+                                                        <xsl:value-of>
+                                                            <xsl:apply-templates select="key('resources', 'to', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                                                        </xsl:value-of>
+                                                    </th>
+                                                </tr>
+                                            </thead>
+                                            <tbody>
+                                                <xsl:apply-templates select="$mementos" mode="bs2:MementoList">
+                                                    <xsl:sort select="memento:mementoDatetime" order="descending"/>
+                                                    <xsl:with-param name="current-memento" select="$current-memento"/>
+                                                    <xsl:with-param name="from-memento" select="$from-memento"/>
+                                                    <xsl:with-param name="to-memento" select="$current-memento"/>
+                                                </xsl:apply-templates>
+                                            </tbody>
+                                        </table>
+                                        <div class="form-actions modal-footer">
+                                            <button type="submit" class="btn btn-primary">
+                                                <xsl:value-of>
+                                                    <xsl:apply-templates select="key('resources', 'compare', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                                                </xsl:value-of>
+                                            </button>
+                                            <button type="button" class="btn btn-close">
+                                                <xsl:value-of>
+                                                    <xsl:apply-templates select="key('resources', 'close', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                                                </xsl:value-of>
+                                            </button>
+                                        </div>
+                                    </form>
+                                    <div id="version-diff"/>
                                 </xsl:when>
                                 <xsl:otherwise>
                                     <div class="alert alert-error">
@@ -114,4 +148,75 @@ version="3.0"
         </xsl:for-each>
     </xsl:function>
 
+    <!-- runs the version diff instead of submitting the form -->
+    <xsl:template match="form[@id = 'form-version-diff']" mode="ixsl:onsubmit">
+        <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])"/>
+        <xsl:variable name="from-uri" select=".//input[@name = 'from'][ixsl:get(., 'checked')] ! xs:anyURI(ixsl:get(., 'value'))" as="xs:anyURI?"/>
+        <xsl:variable name="to-uri" select=".//input[@name = 'to'][ixsl:get(., 'checked')] ! xs:anyURI(ixsl:get(., 'value'))" as="xs:anyURI?"/>
+
+        <xsl:if test="exists($from-uri) and exists($to-uri)">
+            <ixsl:set-style name="cursor" select="'progress'" object="ixsl:page()//body"/>
+
+            <xsl:variable name="context" select="map{ 'from-uri': $from-uri, 'to-uri': $to-uri }" as="map(*)"/>
+            <!-- seed a resolved promise so the fan-out's ixsl:http-request calls run in an active promise context -->
+            <ixsl:promise select="ixsl:resolve($context) => ixsl:then(ldh:version-diff-fanout#1)" on-failure="ldh:promise-failure#1"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- fan-out driver: runs as a promise callback (so ixsl:http-request is called in an active promise context), fetches both versions and joins them with ixsl:all -->
+    <xsl:function name="ldh:version-diff-fanout" as="item()*" ixsl:updating="yes">
+        <xsl:param name="context" as="map(*)"/>
+
+        <xsl:variable name="promises" as="array(*)" select="
+          array {
+            for $uri in ($context('from-uri'), $context('to-uri')) return
+              let $request := map{ 'method': 'GET', 'href': $uri, 'headers': map{ 'Accept': 'application/rdf+xml' } } return
+                ixsl:http-request($request)
+                  => ixsl:then(ldh:rethread-response(map{ 'request': $request }, ?))
+                  => ixsl:then(ldh:handle-response#1)
+          }"/>
+        <xsl:sequence select="ixsl:all($promises) => ixsl:then(ldh:version-diff-response#1)"/>
+    </xsl:function>
+
+    <!-- renders the triple diff between the two selected versions into the history modal -->
+    <xsl:function name="ldh:version-diff-response" as="item()?" ixsl:updating="yes">
+        <xsl:param name="results" as="array(*)"/>
+
+        <xsl:variable name="from-response" select="$results?1?response" as="map(*)"/>
+        <xsl:variable name="to-response" select="$results?2?response" as="map(*)"/>
+
+        <ixsl:set-style name="cursor" select="'default'" object="ixsl:page()//body"/>
+
+        <xsl:for-each select="id('version-diff', ixsl:page())">
+            <xsl:result-document href="?." method="ixsl:replace-content">
+                <xsl:choose>
+                    <xsl:when test="every $response in ($from-response, $to-response) satisfies ($response?status = 200 and $response?media-type = 'application/rdf+xml')">
+                        <xsl:variable name="from-triples" select="ldh:triples-map($from-response?body, false())" as="map(xs:string, element())"/>
+                        <xsl:variable name="to-triples" select="ldh:triples-map($to-response?body, false())" as="map(xs:string, element())"/>
+                        <xsl:variable name="removed" select="for $triple-key in ac:value-except(map:keys($from-triples), map:keys($to-triples)) return map:get($from-triples, $triple-key)" as="element()*"/>
+                        <xsl:variable name="added" select="for $triple-key in ac:value-except(map:keys($to-triples), map:keys($from-triples)) return map:get($to-triples, $triple-key)" as="element()*"/>
+
+                        <xsl:choose>
+                            <xsl:when test="exists(($removed, $added))">
+                                <xsl:sequence select="ldh:version-diff($removed, $added)"/>
+                            </xsl:when>
+                            <xsl:otherwise>
+                                <p class="text-info">
+                                    <xsl:value-of>
+                                        <xsl:apply-templates select="key('resources', 'no-changes', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                                    </xsl:value-of>
+                                </p>
+                            </xsl:otherwise>
+                        </xsl:choose>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <div class="alert alert-error">
+                            <xsl:text>Could not load the versions</xsl:text>
+                        </div>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:result-document>
+        </xsl:for-each>
+    </xsl:function>
+
 </xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/default.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/default.xsl
index 841d3ad42..29207f21f 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/default.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/default.xsl
@@ -478,6 +478,22 @@ exclude-result-prefixes="#all"
         <xsl:sequence select="distinct-values($arg1[not(.=$arg2)])"/>
     </xsl:function>
 
+    <!-- one map entry per triple of a flat RDF/XML document, keyed on subject | predicate | object identity.
+         With $normalize-numerics, numeric literals are normalized so lexically different but equal values (1 vs 1.0) compare
+         equal across serializations; without it, comparison is exactly lexical (canonical same-writer output makes that safe).
+         XMLLiterals are keyed on their serialized content. Blank node labels are serializer-generated, so bnode-involving
+         triples never compare equal across two documents -->
+    <xsl:function name="ldh:triples-map" as="map(xs:string, element())">
+        <xsl:param name="doc" as="document-node()"/>
+        <xsl:param name="normalize-numerics" as="xs:boolean"/>
+
+        <xsl:map>
+            <xsl:for-each select="$doc/rdf:RDF/rdf:Description/*">
+                <xsl:map-entry key="concat(../@rdf:about, '|', ../@rdf:nodeID, '|', namespace-uri(), local-name(), '|', @rdf:resource, @rdf:nodeID, if (@rdf:parseType = 'Literal') then serialize(node()) else if ($normalize-numerics and text() castable as xs:float) then xs:float(text()) else text(), '|', @rdf:datatype, @xml:lang)" select="."/>
+            </xsl:for-each>
+        </xsl:map>
+    </xsl:function>
+
     <xsl:function name="ldh:url-decode" as="xs:string" use-when="system-property('xsl:product-name') eq 'SaxonJS'">
         <xsl:param name="encoded-string" as="xs:string"/>
         
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/memento.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/memento.xsl
index 6c7de7518..661c25c45 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/memento.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/memento.xsl
@@ -23,6 +23,9 @@ exclude-result-prefixes="#all"
     <xsl:template match="*[@rdf:about][rdf:type/@rdf:resource = '&memento;Memento']" mode="bs2:MementoList">
         <!-- the memento URI of the version currently being viewed; when the live document is viewed, callers pass the latest memento -->
         <xsl:param name="current-memento" select="if (map:contains(ldh:query-params(), 'version')) then xs:anyURI(ac:absolute-path(ldh:request-uri()) || '?version=' || ldh:query-params()?version) else ()" as="xs:anyURI?"/>
+        <!-- preselected diff endpoints: the version being viewed and its predecessor -->
+        <xsl:param name="from-memento" as="xs:anyURI?"/>
+        <xsl:param name="to-memento" as="xs:anyURI?"/>
 
         <tr>
             <td>
@@ -43,7 +46,76 @@ exclude-result-prefixes="#all"
             <td>
                 <xsl:apply-templates select="dct:creator/@rdf:resource"/>
             </td>
+            <td>
+                <input type="radio" name="from" value="{@rdf:about}">
+                    <xsl:if test="@rdf:about = $from-memento">
+                        <xsl:attribute name="checked" select="'checked'"/>
+                    </xsl:if>
+                </input>
+            </td>
+            <td>
+                <input type="radio" name="to" value="{@rdf:about}">
+                    <xsl:if test="@rdf:about = $to-memento">
+                        <xsl:attribute name="checked" select="'checked'"/>
+                    </xsl:if>
+                </input>
+            </td>
         </tr>
     </xsl:template>
 
+    <!-- Turtle display form of an RDF/XML property element's subject (read from the parent rdf:Description) -->
+    <xsl:function name="ldh:format-subject" as="xs:string">
+        <xsl:param name="property" as="element()"/>
+
+        <xsl:sequence select="if ($property/../@rdf:about) then '&lt;' || $property/../@rdf:about || '&gt;' else '_:' || $property/../@rdf:nodeID"/>
+    </xsl:function>
+
+    <!-- Turtle display form of an RDF/XML property element's predicate and object -->
+    <xsl:function name="ldh:format-predicate-object" as="xs:string">
+        <xsl:param name="property" as="element()"/>
+
+        <xsl:variable name="predicate" select="'&lt;' || namespace-uri($property) || local-name($property) || '&gt;'" as="xs:string"/>
+        <xsl:variable name="object" select="if ($property/@rdf:resource) then '&lt;' || $property/@rdf:resource || '&gt;' else if ($property/@rdf:nodeID) then '_:' || $property/@rdf:nodeID else if ($property/@rdf:parseType = 'Literal') then '&quot;' || serialize($property/node()) || '&quot;^^&lt;&rdf;XMLLiteral&gt;' else if ($property/@rdf:datatype) then '&quot;' || string($property) || '&quot;^^&lt;' || $property/@rdf:datatype || '&gt;' else if ($property/@xml:lang) then '&quot;' || string($property) || '&quot;@' || $property/@xml:lang else '&quot;' || string($property) || '&quot;'" as="xs:string"/>
+
+        <xsl:sequence select="$predicate || ' ' || $object || ' ;'"/>
+    </xsl:function>
+
+    <!-- triple diff rendered as Turtle-style hunks: subject header, then one -/+ predicate-object line per removed/added triple, sorted so changed values of the same property pair up -->
+    <xsl:function name="ldh:version-diff" as="element()">
+        <xsl:param name="removed" as="element()*"/>
+        <xsl:param name="added" as="element()*"/>
+
+        <pre class="pre-scrollable">
+            <xsl:for-each-group select="$removed, $added" group-by="ldh:format-subject(.)">
+                <xsl:sort select="current-grouping-key()"/>
+
+                <xsl:value-of select="current-grouping-key()"/>
+                <xsl:text>&#10;</xsl:text>
+
+                <xsl:for-each select="current-group()">
+                    <xsl:sort select="ldh:format-predicate-object(.)"/>
+                    <xsl:sort select="if (exists(. intersect $removed)) then 0 else 1"/>
+
+                    <xsl:choose>
+                        <xsl:when test="exists(. intersect $removed)">
+                            <span class="text-error">
+                                <xsl:value-of select="'-   ' || ldh:format-predicate-object(.)"/>
+                            </span>
+                        </xsl:when>
+                        <xsl:otherwise>
+                            <span class="text-success">
+                                <xsl:value-of select="'+   ' || ldh:format-predicate-object(.)"/>
+                            </span>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                    <xsl:text>&#10;</xsl:text>
+                </xsl:for-each>
+
+                <xsl:if test="position() != last()">
+                    <xsl:text>&#10;</xsl:text>
+                </xsl:if>
+            </xsl:for-each-group>
+        </pre>
+    </xsl:function>
+
 </xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/layout.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/layout.xsl
index 79c32f80f..29fa94a74 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/layout.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/layout.xsl
@@ -932,20 +932,8 @@ WHERE
             </xsl:try>
         </xsl:variable>
 
-        <xsl:variable name="triples-original" as="map(xs:string, element())">
-            <xsl:map>
-                <xsl:for-each select="$original-doc/rdf:RDF/rdf:Description/*">
-                    <xsl:map-entry key="concat(../@rdf:about, '|', ../@rdf:nodeID, '|', namespace-uri(), local-name(), '|', @rdf:resource, @rdf:nodeID, if (text() castable as xs:float) then xs:float(text()) else text(), '|', @rdf:datatype, @xml:lang)" select="."/>
-                </xsl:for-each>
-            </xsl:map>
-        </xsl:variable>
-        <xsl:variable name="triples-local" as="map(xs:string, element())">
-            <xsl:map>
-                <xsl:for-each select="$local-doc/rdf:RDF/rdf:Description/*">
-                    <xsl:map-entry key="concat(../@rdf:about, '|', ../@rdf:nodeID, '|', namespace-uri(), local-name(), '|', @rdf:resource, @rdf:nodeID, if (text() castable as xs:float) then xs:float(text()) else text(), '|', @rdf:datatype, @xml:lang)" select="."/>
-                </xsl:for-each>
-            </xsl:map>
-        </xsl:variable>
+        <xsl:variable name="triples-original" select="ldh:triples-map($original-doc, true())" as="map(xs:string, element())"/>
+        <xsl:variable name="triples-local" select="ldh:triples-map($local-doc, true())" as="map(xs:string, element())"/>
 
         <xsl:variable name="properties-original" select="for $triple-key in ac:value-except(map:keys($triples-original), map:keys($triples-local)) return map:get($triples-original, $triple-key)" as="element()*"/>
         <xsl:if test="exists($properties-original)">
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf
index 37167f175..8665be76e 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf
@@ -529,4 +529,20 @@
         <rdfs:label xml:lang="en-US">View the current version</rdfs:label>
         <rdfs:label xml:lang="es-ES">Ver la versión actual</rdfs:label>
     </rdf:Description>
+    <rdf:Description rdf:nodeID="from">
+        <rdfs:label xml:lang="en-US">From</rdfs:label>
+        <rdfs:label xml:lang="es-ES">Desde</rdfs:label>
+    </rdf:Description>
+    <rdf:Description rdf:nodeID="to">
+        <rdfs:label xml:lang="en-US">To</rdfs:label>
+        <rdfs:label xml:lang="es-ES">Hasta</rdfs:label>
+    </rdf:Description>
+    <rdf:Description rdf:nodeID="compare">
+        <rdfs:label xml:lang="en-US">Compare</rdfs:label>
+        <rdfs:label xml:lang="es-ES">Comparar</rdfs:label>
+    </rdf:Description>
+    <rdf:Description rdf:nodeID="no-changes">
+        <rdfs:label xml:lang="en-US">No changes between the selected versions</rdfs:label>
+        <rdfs:label xml:lang="es-ES">No hay cambios entre las versiones seleccionadas</rdfs:label>
+    </rdf:Description>
 </rdf:RDF>
\ No newline at end of file

From f86266c41a0c543ecada1c8d1d2bec49254d6e8f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Wed, 19 Aug 2026 10:42:42 +0200
Subject: [PATCH 2/2] Render version diffs on the document page instead of
 Turtle text

Compare in the history modal now navigates to ?version=<to>&diff=<from> -
the diff is display state like ?mode=, read from the URL at render time and
never sent to the server, so back/forward re-render it and a plain reload
degrades to the ?version= snapshot.

ldh:RDFDocumentLoad fetches the compared version through a self-guarding
promise step; ldh:rdf-document-response renders the union of both versions
(ldh:merge-metadata reused, plus a prune pass so a changed typed block keeps
only its current rdf:value) with the one-sided triple-key sets tunneled down
the shared template chain. Blocks get diff-added/diff-removed/diff-changed
borders via ldh:diff-class() in the bs2:Row emitters, individual property
values get marked <dd>s, and a changed XHTML block stacks its old content
(red) above the new (green). A legend alert next to the historical-version
notice explains the colors.

ldh:triple-key() is extracted from ldh:triples-map() so the dd/block
decorators and the map builder share one triple identity. The Turtle-hunk
rendering from the previous commit is removed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../atomgraph/linkeddatahub/css/bootstrap.css |   5 +
 .../xsl/bootstrap/2.3.2/client/memento.xsl    | 117 +++++++++---------
 .../xsl/bootstrap/2.3.2/document.xsl          |  21 ++++
 .../xsl/bootstrap/2.3.2/imports/default.xsl   |  76 +++++++++++-
 .../xsl/bootstrap/2.3.2/imports/memento.xsl   |  55 --------
 .../xsl/bootstrap/2.3.2/resource.xsl          |  45 +++++--
 .../xsl/bootstrap/2.3.2/translations.rdf      |  14 ++-
 .../atomgraph/linkeddatahub/xsl/client.xsl    |  35 ++++--
 8 files changed, 227 insertions(+), 141 deletions(-)

diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
index 4321cd554..0f7583dda 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
@@ -126,6 +126,11 @@ li button.btn-edit-constructors, li button.btn-add-data, li button.btn-add-ontol
 .content-body > [about].row-fluid.block { overflow-x: auto; margin-bottom: 20px; }
 .content-body > [about].row-fluid.block, .constructor-triple.row-fluid { border-bottom: 2px solid rgb(223, 223, 223); }
 .content-body > [about].row-fluid.block.drag-over { border-bottom: 4px dotted #0f82f5; }
+.content-body > [about].row-fluid.block.diff-added { border: 2px solid #3fb618; }
+.content-body > [about].row-fluid.block.diff-removed { border: 2px solid #ff0039; }
+.content-body > [about].row-fluid.block.diff-changed { border: 2px solid #ff7518; }
+dd.diff-added, .main > div.diff-added { border-left: 4px solid #3fb618; padding-left: 8px; }
+dd.diff-removed, .main > div.diff-removed { border-left: 4px solid #ff0039; padding-left: 8px; }
 .row-fluid.block { max-height: 80em; }
 .row-fluid.block .drag-handle { display: none; width: 30px; background-color: #149bdf; background-image: radial-gradient(circle at 3px 3px, #0480be 1px, transparent 1.5px); background-size: 6px 6px; border-radius: 2px; cursor: move; }
 .list-mode.active { background-image: url('../icons/ic_navigate_before_black_24px.svg'); }
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/memento.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/memento.xsl
index 0c42d0162..2eb973e2a 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/memento.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/memento.xsl
@@ -5,6 +5,7 @@
     <!ENTITY ac      "https://w3id.org/atomgraph/client#">
     <!ENTITY rdf     "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
     <!ENTITY memento "http://mementoweb.org/ns#">
+    <!ENTITY sp      "http://spinrdf.org/sp#">
 ]>
 <xsl:stylesheet
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
@@ -16,6 +17,7 @@ xmlns:lapp="&lapp;"
 xmlns:ac="&ac;"
 xmlns:rdf="&rdf;"
 xmlns:memento="&memento;"
+xmlns:sp="&sp;"
 xmlns:bs2="http://graphity.org/xsl/bootstrap/2.3.2"
 xmlns:xhtml="http://www.w3.org/1999/xhtml"
 exclude-result-prefixes="#all"
@@ -23,7 +25,7 @@ extension-element-prefixes="ixsl"
 version="3.0"
 >
 
-    <!-- Memento (RFC 7089) version history modal -->
+    <!-- Memento (RFC 7089) version history modal and version diff loading -->
 
     <!-- open the version history modal instead of navigating to the TimeMap URL -->
     <xsl:template match="a[contains-token(@class, 'document-history')]" mode="ixsl:onclick" priority="1">
@@ -98,7 +100,7 @@ version="3.0"
                                                             <xsl:apply-templates select="key('resources', 'agent', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
                                                         </xsl:value-of>
                                                     </th>
-                                                    <!-- header colors match the diff line colors: - lines come from the From version, + lines from the To version -->
+                                                    <!-- header colors match the diff colors: removed content comes from the From version, added content from the To version -->
                                                     <th class="text-error">
                                                         <xsl:value-of>
                                                             <xsl:apply-templates select="key('resources', 'from', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
@@ -133,7 +135,6 @@ version="3.0"
                                             </button>
                                         </div>
                                     </form>
-                                    <div id="version-diff"/>
                                 </xsl:when>
                                 <xsl:otherwise>
                                     <div class="alert alert-error">
@@ -148,75 +149,75 @@ version="3.0"
         </xsl:for-each>
     </xsl:function>
 
-    <!-- runs the version diff instead of submitting the form -->
+    <!-- navigates to the version diff view instead of submitting the form -->
     <xsl:template match="form[@id = 'form-version-diff']" mode="ixsl:onsubmit">
         <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])"/>
         <xsl:variable name="from-uri" select=".//input[@name = 'from'][ixsl:get(., 'checked')] ! xs:anyURI(ixsl:get(., 'value'))" as="xs:anyURI?"/>
         <xsl:variable name="to-uri" select=".//input[@name = 'to'][ixsl:get(., 'checked')] ! xs:anyURI(ixsl:get(., 'value'))" as="xs:anyURI?"/>
 
         <xsl:if test="exists($from-uri) and exists($to-uri)">
-            <ixsl:set-style name="cursor" select="'progress'" object="ixsl:page()//body"/>
+            <!-- the memento URI is <doc>?version=<sha>; the diff view URL appends the compared version's SHA as display state -->
+            <xsl:variable name="href" select="xs:anyURI($to-uri || '&amp;diff=' || substring-after($from-uri, '?version='))" as="xs:anyURI"/>
+            <xsl:variable name="parsed" select="ldh:parse-href($href)" as="map(xs:string, item()?)"/>
 
-            <xsl:variable name="context" select="map{ 'from-uri': $from-uri, 'to-uri': $to-uri }" as="map(*)"/>
-            <!-- seed a resolved promise so the fan-out's ixsl:http-request calls run in an active promise context -->
-            <ixsl:promise select="ixsl:resolve($context) => ixsl:then(ldh:version-diff-fanout#1)" on-failure="ldh:promise-failure#1"/>
+            <xsl:for-each select="ancestor::div[contains-token(@class, 'modal')]">
+                <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:for-each>
+
+            <xsl:call-template name="ldh:DocumentNavigate">
+                <xsl:with-param name="doc-uri" select="map:get($parsed, 'doc-uri')"/>
+                <xsl:with-param name="fragment" select="map:get($parsed, 'fragment')"/>
+                <xsl:with-param name="query-params" select="map:get($parsed, 'query-params')"/>
+            </xsl:call-template>
         </xsl:if>
     </xsl:template>
 
-    <!-- fan-out driver: runs as a promise callback (so ixsl:http-request is called in an active promise context), fetches both versions and joins them with ixsl:all -->
-    <xsl:function name="ldh:version-diff-fanout" as="item()*" ixsl:updating="yes">
+    <!-- fetches the ?diff= comparison version when the context carries a diff request; passes the context through otherwise -->
+    <xsl:function name="ldh:load-diff-version" as="item()*" ixsl:updating="yes">
         <xsl:param name="context" as="map(*)"/>
 
-        <xsl:variable name="promises" as="array(*)" select="
-          array {
-            for $uri in ($context('from-uri'), $context('to-uri')) return
-              let $request := map{ 'method': 'GET', 'href': $uri, 'headers': map{ 'Accept': 'application/rdf+xml' } } return
-                ixsl:http-request($request)
-                  => ixsl:then(ldh:rethread-response(map{ 'request': $request }, ?))
-                  => ixsl:then(ldh:handle-response#1)
-          }"/>
-        <xsl:sequence select="ixsl:all($promises) => ixsl:then(ldh:version-diff-response#1)"/>
+        <xsl:choose>
+            <xsl:when test="map:contains($context, 'diff-request')">
+                <xsl:sequence select="
+                  ixsl:http-request($context('diff-request'))
+                    => ixsl:then(ldh:rethread-response($context, ?, 'diff-response'))
+                    => ixsl:then(ldh:handle-response(?, 'diff-response'))
+                "/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:sequence select="$context"/>
+            </xsl:otherwise>
+        </xsl:choose>
     </xsl:function>
 
-    <!-- renders the triple diff between the two selected versions into the history modal -->
-    <xsl:function name="ldh:version-diff-response" as="item()?" ixsl:updating="yes">
-        <xsl:param name="results" as="array(*)"/>
-
-        <xsl:variable name="from-response" select="$results?1?response" as="map(*)"/>
-        <xsl:variable name="to-response" select="$results?2?response" as="map(*)"/>
-
-        <ixsl:set-style name="cursor" select="'default'" object="ixsl:page()//body"/>
-
-        <xsl:for-each select="id('version-diff', ixsl:page())">
-            <xsl:result-document href="?." method="ixsl:replace-content">
-                <xsl:choose>
-                    <xsl:when test="every $response in ($from-response, $to-response) satisfies ($response?status = 200 and $response?media-type = 'application/rdf+xml')">
-                        <xsl:variable name="from-triples" select="ldh:triples-map($from-response?body, false())" as="map(xs:string, element())"/>
-                        <xsl:variable name="to-triples" select="ldh:triples-map($to-response?body, false())" as="map(xs:string, element())"/>
-                        <xsl:variable name="removed" select="for $triple-key in ac:value-except(map:keys($from-triples), map:keys($to-triples)) return map:get($from-triples, $triple-key)" as="element()*"/>
-                        <xsl:variable name="added" select="for $triple-key in ac:value-except(map:keys($to-triples), map:keys($from-triples)) return map:get($to-triples, $triple-key)" as="element()*"/>
-
-                        <xsl:choose>
-                            <xsl:when test="exists(($removed, $added))">
-                                <xsl:sequence select="ldh:version-diff($removed, $added)"/>
-                            </xsl:when>
-                            <xsl:otherwise>
-                                <p class="text-info">
-                                    <xsl:value-of>
-                                        <xsl:apply-templates select="key('resources', 'no-changes', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
-                                    </xsl:value-of>
-                                </p>
-                            </xsl:otherwise>
-                        </xsl:choose>
-                    </xsl:when>
-                    <xsl:otherwise>
-                        <div class="alert alert-error">
-                            <xsl:text>Could not load the versions</xsl:text>
-                        </div>
-                    </xsl:otherwise>
-                </xsl:choose>
-            </xsl:result-document>
-        </xsl:for-each>
+    <!-- union of the two versions' descriptions for the diff view, merged via ldh:MergeRDF; a changed typed block keeps only its current rdf:value because its render factory cannot handle two -->
+    <xsl:function name="ldh:diff-union" as="document-node()">
+        <xsl:param name="to-doc" as="document-node()"/>
+        <xsl:param name="from-doc" as="document-node()"/>
+        <xsl:param name="removed-keys" as="xs:string*"/>
+
+        <xsl:variable name="merged" select="ldh:merge-metadata($to-doc, $from-doc)" as="document-node()"/>
+        <xsl:document>
+            <xsl:apply-templates select="$merged" mode="ldh:DiffPruneValues">
+                <xsl:with-param name="removed-keys" select="$removed-keys" tunnel="yes"/>
+            </xsl:apply-templates>
+        </xsl:document>
     </xsl:function>
 
+    <!-- identity transform for ldh:DiffPruneValues mode -->
+    <xsl:template match="@* | node()" mode="ldh:DiffPruneValues">
+        <xsl:copy>
+            <xsl:apply-templates select="@* | node()" mode="#current"/>
+        </xsl:copy>
+    </xsl:template>
+
+    <!-- drop a typed block's removed rdf:value, but only when the block survives in the To version (has triples outside the removed set) -->
+    <xsl:template match="*[rdf:type/@rdf:resource = ('&ldh;Object', '&ldh;View', '&ldh;GraphChart', '&ldh;ResultSetChart', '&sp;Describe', '&sp;Construct', '&sp;Ask', '&sp;Select')]/rdf:value" mode="ldh:DiffPruneValues">
+        <xsl:param name="removed-keys" as="xs:string*" tunnel="yes"/>
+
+        <xsl:if test="not(ldh:triple-key(., false()) = $removed-keys and ../*[not(ldh:triple-key(., false()) = $removed-keys)])">
+            <xsl:next-match/>
+        </xsl:if>
+    </xsl:template>
+
 </xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/document.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/document.xsl
index da463780d..330ce65b9 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/document.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/document.xsl
@@ -543,6 +543,27 @@ extension-element-prefixes="ixsl"
                 </div>
             </xsl:if>
 
+            <!-- legend shown when a version diff is displayed (?diff= query parameter): removed content comes from the compared version, added content from the viewed one -->
+            <xsl:if test="map:contains(ldh:query-params(), 'diff')">
+                <div class="alert alert-info">
+                    <xsl:value-of>
+                        <xsl:apply-templates select="key('resources', 'comparing-versions', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                    </xsl:value-of>
+                    <xsl:text>: </xsl:text>
+                    <span class="text-error">
+                        <xsl:value-of>
+                            <xsl:apply-templates select="key('resources', 'removed', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                        </xsl:value-of>
+                    </span>
+                    <xsl:text> / </xsl:text>
+                    <span class="text-success">
+                        <xsl:value-of>
+                            <xsl:apply-templates select="key('resources', 'added', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', $lapp:origin)))" mode="ac:label"/>
+                        </xsl:value-of>
+                    </span>
+                </div>
+            </xsl:if>
+
             <!-- host for the RDFa editor toolbar (appended by rdfae:init-editing); empty until an editable region initializes -->
             <div class="navbar-inner editor-bar">
                 <div class="container-fluid"></div>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/default.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/default.xsl
index 29207f21f..0a9e1d230 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/default.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/default.xsl
@@ -478,22 +478,55 @@ exclude-result-prefixes="#all"
         <xsl:sequence select="distinct-values($arg1[not(.=$arg2)])"/>
     </xsl:function>
 
-    <!-- one map entry per triple of a flat RDF/XML document, keyed on subject | predicate | object identity.
+    <!-- identity of one triple given its RDF/XML property element, as subject | predicate | object.
          With $normalize-numerics, numeric literals are normalized so lexically different but equal values (1 vs 1.0) compare
          equal across serializations; without it, comparison is exactly lexical (canonical same-writer output makes that safe).
          XMLLiterals are keyed on their serialized content. Blank node labels are serializer-generated, so bnode-involving
          triples never compare equal across two documents -->
+    <xsl:function name="ldh:triple-key" as="xs:string">
+        <xsl:param name="property" as="element()"/>
+        <xsl:param name="normalize-numerics" as="xs:boolean"/>
+
+        <xsl:for-each select="$property">
+            <xsl:sequence select="concat(../@rdf:about, '|', ../@rdf:nodeID, '|', namespace-uri(), local-name(), '|', @rdf:resource, @rdf:nodeID, if (@rdf:parseType = 'Literal') then serialize(node()) else if ($normalize-numerics and text() castable as xs:float) then xs:float(text()) else text(), '|', @rdf:datatype, @xml:lang)"/>
+        </xsl:for-each>
+    </xsl:function>
+
+    <!-- one map entry per triple of a flat RDF/XML document, keyed with ldh:triple-key() -->
     <xsl:function name="ldh:triples-map" as="map(xs:string, element())">
         <xsl:param name="doc" as="document-node()"/>
         <xsl:param name="normalize-numerics" as="xs:boolean"/>
 
         <xsl:map>
             <xsl:for-each select="$doc/rdf:RDF/rdf:Description/*">
-                <xsl:map-entry key="concat(../@rdf:about, '|', ../@rdf:nodeID, '|', namespace-uri(), local-name(), '|', @rdf:resource, @rdf:nodeID, if (@rdf:parseType = 'Literal') then serialize(node()) else if ($normalize-numerics and text() castable as xs:float) then xs:float(text()) else text(), '|', @rdf:datatype, @xml:lang)" select="."/>
+                <xsl:map-entry key="ldh:triple-key(., $normalize-numerics)" select="."/>
             </xsl:for-each>
         </xsl:map>
     </xsl:function>
 
+    <!-- version-diff status of a whole resource description: added/removed when every one of its triples is one-sided, changed when only some are -->
+    <xsl:function name="ldh:diff-class" as="xs:string?">
+        <xsl:param name="resource" as="element()"/>
+        <xsl:param name="added-keys" as="xs:string*"/>
+        <xsl:param name="removed-keys" as="xs:string*"/>
+
+        <xsl:variable name="triple-keys" select="$resource/* ! ldh:triple-key(., false())" as="xs:string*"/>
+        <xsl:choose>
+            <xsl:when test="exists($triple-keys) and (every $triple-key in $triple-keys satisfies $triple-key = $added-keys)">
+                <xsl:sequence select="'diff-added'"/>
+            </xsl:when>
+            <xsl:when test="exists($triple-keys) and (every $triple-key in $triple-keys satisfies $triple-key = $removed-keys)">
+                <xsl:sequence select="'diff-removed'"/>
+            </xsl:when>
+            <xsl:when test="$triple-keys = ($added-keys, $removed-keys)">
+                <xsl:sequence select="'diff-changed'"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:sequence select="()"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
     <xsl:function name="ldh:url-decode" as="xs:string" use-when="system-property('xsl:product-name') eq 'SaxonJS'">
         <xsl:param name="encoded-string" as="xs:string"/>
         
@@ -652,17 +685,31 @@ exclude-result-prefixes="#all"
     <!-- RDFa overrides -->
 
     <xsl:template match="@rdf:resource" mode="xhtml:DefinitionDescription">
+        <xsl:param name="diff-added-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:param name="diff-removed-keys" as="xs:string*" tunnel="yes"/>
         <xsl:variable name="property-uri" select="../concat(namespace-uri(), local-name())" as="xs:string"/>
-        
+        <xsl:variable name="diff-class" select="ldh:value-diff-class(.., $diff-added-keys, $diff-removed-keys)" as="xs:string?"/>
+
         <dd property="{$property-uri}" resource="{.}">
+            <xsl:if test="$diff-class">
+                <xsl:attribute name="class" select="$diff-class"/>
+            </xsl:if>
+
             <xsl:apply-templates select="."/>
         </dd>
     </xsl:template>
-    
+
     <xsl:template match="text()[../@xml:lang]" mode="xhtml:DefinitionDescription">
+        <xsl:param name="diff-added-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:param name="diff-removed-keys" as="xs:string*" tunnel="yes"/>
         <xsl:variable name="property-uri" select="../concat(namespace-uri(), local-name())" as="xs:string"/>
+        <xsl:variable name="diff-class" select="ldh:value-diff-class(.., $diff-added-keys, $diff-removed-keys)" as="xs:string?"/>
 
         <dd property="{$property-uri}">
+            <xsl:if test="$diff-class">
+                <xsl:attribute name="class" select="$diff-class"/>
+            </xsl:if>
+
             <span class="label label-info pull-right">
                 <xsl:value-of select="../@xml:lang"/>
             </span>
@@ -670,14 +717,31 @@ exclude-result-prefixes="#all"
             <xsl:apply-templates select="."/>
         </dd>
     </xsl:template>
-    
+
     <xsl:template match="node()" mode="xhtml:DefinitionDescription">
+        <xsl:param name="diff-added-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:param name="diff-removed-keys" as="xs:string*" tunnel="yes"/>
         <xsl:variable name="property-uri" select="../concat(namespace-uri(), local-name())" as="xs:string"/>
-        
+        <xsl:variable name="diff-class" select="ldh:value-diff-class(.., $diff-added-keys, $diff-removed-keys)" as="xs:string?"/>
+
         <dd property="{$property-uri}">
+            <xsl:if test="$diff-class">
+                <xsl:attribute name="class" select="$diff-class"/>
+            </xsl:if>
+
             <xsl:apply-templates select="."/>
         </dd>
     </xsl:template>
+
+    <!-- version-diff status of a single property value -->
+    <xsl:function name="ldh:value-diff-class" as="xs:string?">
+        <xsl:param name="property" as="element()"/>
+        <xsl:param name="added-keys" as="xs:string*"/>
+        <xsl:param name="removed-keys" as="xs:string*"/>
+
+        <xsl:variable name="triple-key" select="ldh:triple-key($property, false())" as="xs:string"/>
+        <xsl:sequence select="if ($triple-key = $added-keys) then 'diff-added' else if ($triple-key = $removed-keys) then 'diff-removed' else ()"/>
+    </xsl:function>
     
     <!-- DEFAULT -->
     
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/memento.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/memento.xsl
index 661c25c45..8bd9fd6da 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/memento.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/imports/memento.xsl
@@ -63,59 +63,4 @@ exclude-result-prefixes="#all"
         </tr>
     </xsl:template>
 
-    <!-- Turtle display form of an RDF/XML property element's subject (read from the parent rdf:Description) -->
-    <xsl:function name="ldh:format-subject" as="xs:string">
-        <xsl:param name="property" as="element()"/>
-
-        <xsl:sequence select="if ($property/../@rdf:about) then '&lt;' || $property/../@rdf:about || '&gt;' else '_:' || $property/../@rdf:nodeID"/>
-    </xsl:function>
-
-    <!-- Turtle display form of an RDF/XML property element's predicate and object -->
-    <xsl:function name="ldh:format-predicate-object" as="xs:string">
-        <xsl:param name="property" as="element()"/>
-
-        <xsl:variable name="predicate" select="'&lt;' || namespace-uri($property) || local-name($property) || '&gt;'" as="xs:string"/>
-        <xsl:variable name="object" select="if ($property/@rdf:resource) then '&lt;' || $property/@rdf:resource || '&gt;' else if ($property/@rdf:nodeID) then '_:' || $property/@rdf:nodeID else if ($property/@rdf:parseType = 'Literal') then '&quot;' || serialize($property/node()) || '&quot;^^&lt;&rdf;XMLLiteral&gt;' else if ($property/@rdf:datatype) then '&quot;' || string($property) || '&quot;^^&lt;' || $property/@rdf:datatype || '&gt;' else if ($property/@xml:lang) then '&quot;' || string($property) || '&quot;@' || $property/@xml:lang else '&quot;' || string($property) || '&quot;'" as="xs:string"/>
-
-        <xsl:sequence select="$predicate || ' ' || $object || ' ;'"/>
-    </xsl:function>
-
-    <!-- triple diff rendered as Turtle-style hunks: subject header, then one -/+ predicate-object line per removed/added triple, sorted so changed values of the same property pair up -->
-    <xsl:function name="ldh:version-diff" as="element()">
-        <xsl:param name="removed" as="element()*"/>
-        <xsl:param name="added" as="element()*"/>
-
-        <pre class="pre-scrollable">
-            <xsl:for-each-group select="$removed, $added" group-by="ldh:format-subject(.)">
-                <xsl:sort select="current-grouping-key()"/>
-
-                <xsl:value-of select="current-grouping-key()"/>
-                <xsl:text>&#10;</xsl:text>
-
-                <xsl:for-each select="current-group()">
-                    <xsl:sort select="ldh:format-predicate-object(.)"/>
-                    <xsl:sort select="if (exists(. intersect $removed)) then 0 else 1"/>
-
-                    <xsl:choose>
-                        <xsl:when test="exists(. intersect $removed)">
-                            <span class="text-error">
-                                <xsl:value-of select="'-   ' || ldh:format-predicate-object(.)"/>
-                            </span>
-                        </xsl:when>
-                        <xsl:otherwise>
-                            <span class="text-success">
-                                <xsl:value-of select="'+   ' || ldh:format-predicate-object(.)"/>
-                            </span>
-                        </xsl:otherwise>
-                    </xsl:choose>
-                    <xsl:text>&#10;</xsl:text>
-                </xsl:for-each>
-
-                <xsl:if test="position() != last()">
-                    <xsl:text>&#10;</xsl:text>
-                </xsl:if>
-            </xsl:for-each-group>
-        </pre>
-    </xsl:function>
-
 </xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/resource.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/resource.xsl
index 2c62181da..73f43c774 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/resource.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/resource.xsl
@@ -468,6 +468,9 @@ extension-element-prefixes="ixsl"
         <xsl:param name="typeof" select="rdf:type/@rdf:resource/xs:anyURI(.)" as="xs:anyURI*"/>
         <xsl:param name="draggable" select="false()" as="xs:boolean?"/>
         <xsl:param name="show-row-block-controls" select="true()" as="xs:boolean"/>
+        <xsl:param name="diff-added-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:param name="diff-removed-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:variable name="diff-class" select="ldh:diff-class(., $diff-added-keys, $diff-removed-keys)" as="xs:string?"/>
 
         <xsl:apply-templates select="key('resources', .)" mode="bs2:RowContentHeader"/>
 
@@ -475,8 +478,8 @@ extension-element-prefixes="ixsl"
             <xsl:if test="$id">
                 <xsl:attribute name="id" select="$id"/>
             </xsl:if>
-            <xsl:if test="$class">
-                <xsl:attribute name="class" select="$class"/>
+            <xsl:if test="$class or $diff-class">
+                <xsl:attribute name="class" select="string-join(($class, $diff-class), ' ')"/>
             </xsl:if>
             <xsl:if test="$about">
                 <xsl:attribute name="about" select="$about"/>
@@ -529,6 +532,9 @@ extension-element-prefixes="ixsl"
         <xsl:param name="typeof" select="rdf:type/@rdf:resource/xs:anyURI(.)" as="xs:anyURI*"/>
         <xsl:param name="main-class" select="'main span7'" as="xs:string?"/>
         <xsl:param name="draggable" select="false()" as="xs:boolean?"/>
+        <xsl:param name="diff-added-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:param name="diff-removed-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:variable name="diff-class" select="ldh:diff-class(., $diff-added-keys, $diff-removed-keys)" as="xs:string?"/>
 
         <xsl:apply-templates select="." mode="bs2:RowContentHeader"/>
 
@@ -536,8 +542,8 @@ extension-element-prefixes="ixsl"
             <xsl:if test="$id">
                 <xsl:attribute name="id" select="$id"/>
             </xsl:if>
-            <xsl:if test="$class">
-                <xsl:attribute name="class" select="$class"/>
+            <xsl:if test="$class or $diff-class">
+                <xsl:attribute name="class" select="string-join(($class, $diff-class), ' ')"/>
             </xsl:if>
             <xsl:if test="$about">
                 <xsl:attribute name="about" select="$about"/>
@@ -580,7 +586,22 @@ extension-element-prefixes="ixsl"
                             <xsl:attribute name="class" select="$main-class"/>
                         </xsl:if>
 
-                        <xsl:apply-templates select="rdf:value[@rdf:parseType = 'Literal']/xhtml:div" mode="ldh:XHTMLContent"/>
+                        <!-- the diff union can carry two values (removed and added); mark each and show the removed one first -->
+                        <xsl:for-each select="rdf:value[@rdf:parseType = 'Literal']">
+                            <xsl:sort select="if (ldh:value-diff-class(., $diff-added-keys, $diff-removed-keys) = 'diff-removed') then 0 else 1"/>
+
+                            <xsl:variable name="value-diff-class" select="ldh:value-diff-class(., $diff-added-keys, $diff-removed-keys)" as="xs:string?"/>
+                            <xsl:choose>
+                                <xsl:when test="$value-diff-class">
+                                    <div class="{$value-diff-class}">
+                                        <xsl:apply-templates select="xhtml:div" mode="ldh:XHTMLContent"/>
+                                    </div>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <xsl:apply-templates select="xhtml:div" mode="ldh:XHTMLContent"/>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                        </xsl:for-each>
                     </div>
 
                     <xsl:apply-templates select="." mode="bs2:Right"/>
@@ -610,13 +631,16 @@ extension-element-prefixes="ixsl"
         <xsl:param name="typeof" select="rdf:type/@rdf:resource/xs:anyURI(.)" as="xs:anyURI*"/>
         <xsl:param name="mode" as="xs:anyURI?"/>
         <xsl:param name="style" as="xs:string?"/>
+        <xsl:param name="diff-added-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:param name="diff-removed-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:variable name="diff-class" select="ldh:diff-class(., $diff-added-keys, $diff-removed-keys)" as="xs:string?"/>
 
         <div>
             <xsl:if test="$id">
                 <xsl:attribute name="id" select="$id"/>
             </xsl:if>
-            <xsl:if test="$class">
-                <xsl:attribute name="class" select="$class"/>
+            <xsl:if test="$class or $diff-class">
+                <xsl:attribute name="class" select="string-join(($class, $diff-class), ' ')"/>
             </xsl:if>
             <xsl:if test="$about">
                 <xsl:attribute name="about" select="$about"/>
@@ -644,13 +668,16 @@ extension-element-prefixes="ixsl"
         <xsl:param name="mode" as="xs:anyURI?"/>
         <xsl:param name="style" as="xs:string?"/>
         <xsl:param name="main-class" select="'main span7'" as="xs:string?"/>
+        <xsl:param name="diff-added-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:param name="diff-removed-keys" as="xs:string*" tunnel="yes"/>
+        <xsl:variable name="diff-class" select="ldh:diff-class(., $diff-added-keys, $diff-removed-keys)" as="xs:string?"/>
 
         <div>
             <xsl:if test="$id">
                 <xsl:attribute name="id" select="$id"/>
             </xsl:if>
-            <xsl:if test="$class">
-                <xsl:attribute name="class" select="$class"/>
+            <xsl:if test="$class or $diff-class">
+                <xsl:attribute name="class" select="string-join(($class, $diff-class), ' ')"/>
             </xsl:if>
             <xsl:if test="$about">
                 <xsl:attribute name="about" select="$about"/>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf
index 8665be76e..9df0d2129 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf
@@ -541,8 +541,16 @@
         <rdfs:label xml:lang="en-US">Compare</rdfs:label>
         <rdfs:label xml:lang="es-ES">Comparar</rdfs:label>
     </rdf:Description>
-    <rdf:Description rdf:nodeID="no-changes">
-        <rdfs:label xml:lang="en-US">No changes between the selected versions</rdfs:label>
-        <rdfs:label xml:lang="es-ES">No hay cambios entre las versiones seleccionadas</rdfs:label>
+    <rdf:Description rdf:nodeID="comparing-versions">
+        <rdfs:label xml:lang="en-US">You are comparing two versions of this document</rdfs:label>
+        <rdfs:label xml:lang="es-ES">Está comparando dos versiones de este documento</rdfs:label>
+    </rdf:Description>
+    <rdf:Description rdf:nodeID="removed">
+        <rdfs:label xml:lang="en-US">removed</rdfs:label>
+        <rdfs:label xml:lang="es-ES">eliminado</rdfs:label>
+    </rdf:Description>
+    <rdf:Description rdf:nodeID="added">
+        <rdfs:label xml:lang="en-US">added</rdfs:label>
+        <rdfs:label xml:lang="es-ES">añadido</rdfs:label>
     </rdf:Description>
 </rdf:RDF>
\ No newline at end of file
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/client.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/client.xsl
index af5fcd11c..4e7a15496 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/client.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/client.xsl
@@ -449,6 +449,11 @@ WHERE
                     <ixsl:set-property name="timemap" select="($timemap, '')[1]" object="ixsl:get(ixsl:window(), 'LinkedDataHub')"/>
                     <xsl:for-each select="?body">
                         <xsl:variable name="results" select="." as="document-node()"/>
+                        <!-- ?diff= view: render the union of both versions' descriptions, with the one-sided triple keys classifying added/removed content -->
+                        <xsl:variable name="diff-results" select="if ($context('diff-response')?status = 200 and $context('diff-response')?media-type = 'application/rdf+xml') then $context('diff-response')?body else ()" as="document-node()?"/>
+                        <xsl:variable name="diff-added-keys" select="if (exists($diff-results)) then ac:value-except(map:keys(ldh:triples-map($results, false())), map:keys(ldh:triples-map($diff-results, false()))) else ()" as="xs:string*"/>
+                        <xsl:variable name="diff-removed-keys" select="if (exists($diff-results)) then ac:value-except(map:keys(ldh:triples-map($diff-results, false())), map:keys(ldh:triples-map($results, false()))) else ()" as="xs:string*"/>
+                        <xsl:variable name="render-results" select="if (exists($diff-results)) then ldh:diff-union($results, $diff-results, $diff-removed-keys) else $results" as="document-node()"/>
                         <ixsl:set-property name="{'`' || $doc-uri || '`'}" select="ldh:new-object()" object="ixsl:get(ixsl:window(), 'LinkedDataHub.contents')"/>
                         <!-- store document under window.LinkedDataHub.contents[$doc-uri].results -->
                         <!-- should be possible to cache the document using SaxonJS when this issue is resolved: https://saxonica.plan.io/issues/6355 -->
@@ -498,11 +503,13 @@ WHERE
 
                                 <xsl:for-each select="$reuse-pane/div[contains-token(@class, 'document-body')]">
                                     <xsl:result-document href="?." method="ixsl:replace-element">
-                                        <xsl:apply-templates select="$results/rdf:RDF" mode="bs2:DocumentBody">
+                                        <xsl:apply-templates select="$render-results/rdf:RDF" mode="bs2:DocumentBody">
                                             <xsl:with-param name="mode" select="$mode"/>
                                             <xsl:with-param name="about" select="$doc-uri"/>
                                             <xsl:with-param name="object-metadata" select="$context('object-metadata')" tunnel="yes"/>
                                             <xsl:with-param name="property-metadata" select="$context('property-metadata')" tunnel="yes"/>
+                                            <xsl:with-param name="diff-added-keys" select="$diff-added-keys" tunnel="yes"/>
+                                            <xsl:with-param name="diff-removed-keys" select="$diff-removed-keys" tunnel="yes"/>
                                         </xsl:apply-templates>
                                     </xsl:result-document>
                                 </xsl:for-each>
@@ -530,7 +537,7 @@ WHERE
                             <xsl:otherwise>
                                 <xsl:variable name="tab-body" as="element()">
                                     <!-- inert class: ldh:ActivateTab (called from ldh:RenderTab below) is the single source of truth for the 'active' token. Defaulting to 'tab-pane active' here would briefly leave two panes active (this one + the currently-active local one) and crash ldt:base()/sd:endpoint() in any code that runs between append and ActivateTab (e.g. ldh:LeftSidebar). -->
-                                    <xsl:apply-templates select="$results/rdf:RDF" mode="bs2:TabBody">
+                                    <xsl:apply-templates select="$render-results/rdf:RDF" mode="bs2:TabBody">
                                         <xsl:with-param name="id" select="$tab-body-id"/>
                                         <xsl:with-param name="class" select="'tab-pane'"/>
                                         <xsl:with-param name="mode" select="$mode"/>
@@ -541,6 +548,8 @@ WHERE
                                         <xsl:with-param name="about" select="$doc-uri"/>
                                         <xsl:with-param name="object-metadata" select="$context('object-metadata')" tunnel="yes"/>
                                         <xsl:with-param name="property-metadata" select="$context('property-metadata')" tunnel="yes"/>
+                                        <xsl:with-param name="diff-added-keys" select="$diff-added-keys" tunnel="yes"/>
+                                        <xsl:with-param name="diff-removed-keys" select="$diff-removed-keys" tunnel="yes"/>
                                     </xsl:apply-templates>
                                 </xsl:variable>
 
@@ -1011,22 +1020,28 @@ WHERE
         <xsl:param name="controller" select="ixsl:get(ixsl:get(ixsl:window(), 'LinkedDataHub'), 'saxonController')"/>
         <!-- representation-selecting params (?version=, ?timemap) ride along on the RDF request; display params do not -->
         <xsl:variable name="snapshot-params" select="ldh:snapshot-params($query-params)" as="map(xs:string, xs:string*)"/>
+        <!-- ?diff= is display state (like ?mode=): the compared version is fetched client-side, the param never reaches the server but must survive into ldh:PushState -->
+        <xsl:variable name="diff-version" select="if (map:contains($query-params, 'diff')) then $query-params('diff')[1] else ()" as="xs:string?"/>
         <!-- if the URI is external, dereference it through the proxy -->
         <!-- HTTP requests carry no fragment (protocol-level) -->
         <xsl:variable name="request-uri" select="ldh:href($doc-uri, $snapshot-params, ())" as="xs:anyURI"/>
         <xsl:variable name="request" select="map{ 'method': 'GET', 'href': $request-uri, 'headers': map{ 'Accept': 'application/rdf+xml' } }" as="map(*)"/>
         <xsl:variable name="context" as="map(*)" select="
-          map{
-            'request': $request,
-            'doc-uri': $doc-uri,
-            'fragment': $fragment,
-            'query-params': $snapshot-params,
-            'refresh-content': $refresh-content,
-            'endpoint': sd:endpoint()
-          }"/>
+          map:merge((
+            map{
+              'request': $request,
+              'doc-uri': $doc-uri,
+              'fragment': $fragment,
+              'query-params': map:merge(($snapshot-params, if (exists($diff-version)) then map{ 'diff': $diff-version } else map{})),
+              'refresh-content': $refresh-content,
+              'endpoint': sd:endpoint()
+            },
+            if (exists($diff-version)) then map{ 'diff-request': map{ 'method': 'GET', 'href': ldh:href($doc-uri, map{ 'version': $diff-version }, ()), 'headers': map{ 'Accept': 'application/rdf+xml' } } } else map{}
+          ))"/>
         <ixsl:promise select="ixsl:http-request($context('request'), $controller) =>
             ixsl:then(ldh:rethread-response($context, ?)) =>
             ixsl:then(ldh:handle-response#1) =>
+            ixsl:then(ldh:load-diff-version#1) =>
             ixsl:then(ldh:load-object-metadata#1) =>
             ixsl:then(ldh:http-request-threaded(?, 'metadata-request', 'metadata-response')) =>
             ixsl:then(ldh:handle-response(?, 'metadata-response')) =>