From 44c5009e6b82ab7474fda03e18a8f7add1297f34 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Mon, 27 Jul 2026 02:14:06 +0300
Subject: [PATCH 1/6] Replace WYMEditor with the RDFa editor for XMLLiteral
 editing

- vendor the RDFa editor XSLT modules under xsl/rdfa-editor/ (synced
  from the RDFa-Editor repo) and import them from client.xsl
- render XMLLiteral form controls as editable div.rdfa-editor-content
  regions with hidden ol/lt inputs (imports/default.xsl)
- create the editor state container in the client main template;
  full chrome bring-up on the first region, per-region init afterwards
  via the upstream local:init-editor/local:init-region seams (form.xsl)
- serialize canonicalized editor content into the ol input in
  ldh:FormPreSubmit
- run the ldh:FormPreSubmit pass before ldh:parse-rdf-post in the block
  POST and generic row-form submit handlers (previously the param
  defaults parsed the inputs before the pass could sync them, dropping
  the empty ol and tripping the ldh:XHTML MissingValue constraint) and
  canonicalize XMLLiterals in the request body (block.xsl, form.xsl)
- chain body onmousemove to the editor's sweep-selection tracker
  which it shadowed by import precedence (navigation.xsl)
- host the singleton toolbar in a per-document editor-bar below the
  action bar (document.xsl slot + local:toolbar-host override); sticky,
  matching action-bar chrome, hidden while no editable region is open
  along with the editor breadcrumb footer (bootstrap.css)
- drop the WYMEditor assets from layout.xsl; load rdfa-editor.css
  under the same conditions instead

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../atomgraph/linkeddatahub/css/bootstrap.css |    5 +-
 .../linkeddatahub/css/rdfa-editor.css         |  981 +++++++
 .../xsl/bootstrap/2.3.2/client/block.xsl      |    8 +-
 .../xsl/bootstrap/2.3.2/client/form.xsl       |   73 +-
 .../xsl/bootstrap/2.3.2/client/navigation.xsl |    3 +
 .../xsl/bootstrap/2.3.2/document.xsl          |    5 +
 .../xsl/bootstrap/2.3.2/imports/default.xsl   |   16 +-
 .../xsl/bootstrap/2.3.2/layout.xsl            |   10 +-
 .../atomgraph/linkeddatahub/xsl/client.xsl    |    6 +-
 .../xsl/rdfa-editor/RDFa2RDFXML-v3.xsl        |  355 +++
 .../xsl/rdfa-editor/annotate.xsl              |  359 +++
 .../linkeddatahub/xsl/rdfa-editor/blocks.xsl  |  132 +
 .../xsl/rdfa-editor/canonical-xhtml.xsl       |  411 +++
 .../xsl/rdfa-editor/content-model.xsl         |  192 ++
 .../linkeddatahub/xsl/rdfa-editor/edit.xsl    | 2579 +++++++++++++++++
 .../xsl/rdfa-editor/group-sort-triples.xsl    |   57 +
 .../linkeddatahub/xsl/rdfa-editor/index.xsl   |   93 +
 .../linkeddatahub/xsl/rdfa-editor/input.xsl   |  434 +++
 .../xsl/rdfa-editor/lint-rdfa.xsl             |  121 +
 .../xsl/rdfa-editor/lint-xhtml.xsl            |   60 +
 .../xsl/rdfa-editor/navigate.xsl              |  711 +++++
 .../linkeddatahub/xsl/rdfa-editor/overlay.xsl |  345 +++
 .../linkeddatahub/xsl/rdfa-editor/select.xsl  |  777 +++++
 .../linkeddatahub/xsl/rdfa-editor/tables.xsl  |  488 ++++
 .../xsl/rdfa-editor/typeahead.xsl             |  382 +++
 .../linkeddatahub/xsl/rdfa-editor/undo.xsl    |  278 ++
 .../linkeddatahub/xsl/rdfa-editor/vocab.xsl   |   78 +
 27 files changed, 8915 insertions(+), 44 deletions(-)
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/css/rdfa-editor.css
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/RDFa2RDFXML-v3.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/annotate.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/blocks.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/canonical-xhtml.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/content-model.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/edit.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/group-sort-triples.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/index.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/input.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/lint-rdfa.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/lint-xhtml.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/navigate.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/overlay.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/select.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/tables.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/typeahead.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/undo.xsl
 create mode 100644 src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/vocab.xsl

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 0e19e5ebd..e1b9592d6 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
@@ -210,4 +210,7 @@ object { display: block; margin: auto; max-height: 400px; overflow: hidden; widt
 .ol-overlay-container { width: 60%; max-height: 75%; background-color: white; overflow: auto; }
 .ol-overlay-container img { max-width: 100%; }
 /* SVG graph specific */
-circle { cursor: move; }
\ No newline at end of file
+circle { cursor: move; }
+/* RDFa editor specific */
+.editor-bar { position: sticky; top: calc(var(--action-bar-top, 51px) + 50px); z-index: 998; background: #dfdfdf; padding: 0; box-shadow: none; border-top: 1px solid #aaa; }
+.editor-bar:not(:has(#edit-toolbar)), body:not(:has(.rdfa-editor-content)) .editor-bar, body:not(:has(.rdfa-editor-content)) #rdfa-editor-breadcrumb { display: none; }
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/rdfa-editor.css b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/rdfa-editor.css
new file mode 100644
index 000000000..60aa7c40e
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/rdfa-editor.css
@@ -0,0 +1,981 @@
+/*
+ * rdfa-editor.css - the RDFa editor's UI contract: annotation overlay, edit
+ * dialogs, toolbar, block chrome and drag-and-drop marks, ToC drawer,
+ * breadcrumb bar, lint markers, RDFa highlighting and the output modal.
+ *
+ * Host page requirements: include this stylesheet and give the editable
+ * container (.rdfa-editor-content) enough left padding (>= 2.5em) for the block drag
+ * handles, which render in the gutter outside each block's box.
+ */
+
+/* RDFa Visual Styling - Subtle dashed borders */
+            .rdfa-editor-content *[property] {
+                border: 1px dashed #4caf50;
+                padding: 1px 2px;
+                cursor: pointer;
+                transition: background-color 0.2s, border-color 0.2s;
+            }
+
+.rdfa-editor-content *[property]:hover {
+                background-color: rgba(76, 175, 80, 0.1);
+                border-color: #2e7d32;
+            }
+
+.rdfa-editor-content *[typeof] {
+                border: 1px dashed #9c27b0;
+                padding: 1px 2px;
+                cursor: pointer;
+                transition: background-color 0.2s, border-color 0.2s;
+            }
+
+.rdfa-editor-content *[typeof]:hover {
+                background-color: rgba(156, 39, 176, 0.1);
+                border-color: #7b1fa2;
+            }
+
+.rdfa-editor-content *[about] {
+                border: 1px dashed #2196f3;
+                padding: 1px 2px;
+                cursor: pointer;
+                transition: background-color 0.2s, border-color 0.2s;
+            }
+
+.rdfa-editor-content *[about]:hover {
+                background-color: rgba(33, 150, 243, 0.1);
+                border-color: #1976d2;
+            }
+
+.rdfa-editor-content *[resource] {
+                border: 1px dashed #ff9800;
+                padding: 1px 2px;
+                cursor: pointer;
+                transition: background-color 0.2s, border-color 0.2s;
+            }
+
+.rdfa-editor-content *[resource]:hover {
+                background-color: rgba(255, 152, 0, 0.1);
+                border-color: #f57c00;
+            }
+
+/* Invalid selection flash animation */
+            @keyframes selection-flash {
+                0% { background-color: transparent; }
+                25% { background-color: rgba(244, 67, 54, 0.4); }
+                50% { background-color: rgba(244, 67, 54, 0.6); }
+                75% { background-color: rgba(244, 67, 54, 0.4); }
+                100% { background-color: transparent; }
+            }
+
+.invalid-selection-flash {
+                animation: selection-flash 0.6s ease-in-out 2;
+            }
+
+.rdfa-editor-content > * {
+                position: relative;
+            }
+
+/* nested draggable blocks position their own handle (chrome is their first
+   child); handles stack per nesting level, each at its block's own indent */
+            .rdfa-editor-content *:has(> [data-role="chrome"]) {
+                position: relative;
+            }
+
+/* invisible gutter strip: keeps the block hovered while the pointer
+               travels to the drag handle, which sits outside the block box */
+            .rdfa-editor-content > *::before {
+                content: '';
+                position: absolute;
+                left: -2.25em;
+                top: 0;
+                bottom: 0;
+                width: 2.25em;
+            }
+
+/* nested blocks get a narrower gutter, inside the parent's indentation */
+            .rdfa-editor-content > * *:has(> [data-role="chrome"])::before {
+                content: '';
+                position: absolute;
+                left: -1.5em;
+                top: 0;
+                bottom: 0;
+                width: 1.5em;
+            }
+
+/* a blockquote has no intrinsic child indentation, so its handle and its first
+   block's handle would coincide; the editing view indents quote content to give
+   each nesting level its own gutter column (lists and cells indent natively).
+   The quote bar (Markdown/Bootstrap convention) makes the container visible -
+   a normalized blockquote > p would otherwise read as a plain paragraph */
+            .rdfa-editor-content blockquote {
+                padding-left: 2em;
+                border-left: 4px solid #e0e0e0;
+                color: #616161;
+            }
+
+/* the editing-DOM run wrapper (mixed flow content, e.g. <li>text<ul>...) renders
+   like the bare inline run it stands for; unwrapped again at canonicalization */
+            .rdfa-editor-content p.rdfa-editor-run {
+                margin: 0;
+            }
+
+.rdfa-editor-content figure {
+                margin: 16px 0;
+            }
+
+.rdfa-editor-content figure img {
+                display: block;
+                max-width: 400px;
+            }
+
+/* Table blocks: cell borders make empty cells clickable while editing.
+   Class-free, so canonical output (stored content) keeps host-page styling */
+            .rdfa-editor-content table {
+                border-collapse: collapse;
+                margin: 16px 0;
+            }
+
+.rdfa-editor-content th,
+            .rdfa-editor-content td {
+                border: 1px solid #e0e0e0;
+                padding: 4px 8px;
+                min-width: 2em;
+                vertical-align: top;
+            }
+
+.rdfa-editor-content th {
+                background: #fafafa;
+            }
+
+.rdfa-editor-content caption {
+                caption-side: top;
+                text-align: left;
+                padding: 4px 0;
+                color: #757575;
+            }
+
+#edit-toolbar button:disabled {
+                opacity: 0.4;
+                cursor: default;
+            }
+
+.rdfa-editor-content [contenteditable="true"]:focus {
+                outline: 2px solid rgba(33, 150, 243, 0.35);
+                outline-offset: 2px;
+            }
+
+/* A block image can't hold a caret; when focused it is the selected navigation
+   target, so it gets a stronger outline than the (caret-bearing) editable hosts */
+            .rdfa-editor-content img:focus {
+                outline: 2px solid rgba(33, 150, 243, 0.7);
+                outline-offset: 2px;
+            }
+
+/* Object blocks (RDF-defined islands): the placeholder div renders as a card;
+   its RDFa definition spans are invisible - only the injected rendering shows.
+   Focused = selected navigation target, mirroring the image island */
+            .rdfa-editor-content .rdfa-editor-island {
+                border: 1px solid #e0e0e0;
+                border-radius: 4px;
+                background: #fafafa;
+                padding: 8px 12px;
+                margin: 16px 0;
+            }
+
+.rdfa-editor-content .rdfa-editor-island > span[property] {
+                display: none;
+            }
+
+.rdfa-editor-content .rdfa-editor-island:focus {
+                outline: 2px solid rgba(33, 150, 243, 0.7);
+                outline-offset: 2px;
+            }
+
+.rdfa-editor-content .rdfa-editor-island.rdfa-editor-loading {
+                opacity: 0.5;
+            }
+
+.rdfa-editor-content .rdfa-editor-island [data-role="rendering"] table {
+                margin: 8px 0;
+            }
+
+/* Block chrome (drag handle) - ephemeral, data-role stripped on serialization */
+            [data-role="chrome"] {
+                visibility: hidden;
+                position: absolute;
+                top: 2px;
+                left: -1.5em;
+                color: #9e9e9e;
+                font-size: 14px;
+                cursor: grab;
+                user-select: none;
+                border: none;
+            }
+
+.rdfa-editor-content *:hover > [data-role="chrome"] {
+                visibility: visible;
+            }
+
+/* Drag-and-drop feedback (v6 conventions) - any nesting depth */
+            .rdfa-editor-content .dragging {
+                opacity: 0.4;
+            }
+
+.rdfa-editor-content .drop-before {
+                box-shadow: 0 -3px 0 0 #2196f3;
+            }
+
+.rdfa-editor-content .drop-after {
+                box-shadow: 0 3px 0 0 #2196f3;
+            }
+
+/* dropping INTO a cell highlights the cell itself, not an edge */
+            .rdfa-editor-content .drop-into {
+                box-shadow: inset 0 0 0 2px #2196f3;
+            }
+
+/* Editor toolbar (injected into the navbar) */
+            #edit-toolbar {
+                order: -1;
+                margin-right: auto;
+                display: flex;
+                gap: 6px;
+                align-items: center;
+            }
+
+#edit-toolbar select,
+            #edit-toolbar button {
+                padding: 6px 10px;
+                border: 1px solid #e0e0e0;
+                border-radius: 4px;
+                background: white;
+                font-size: 13px;
+                font-family: "Roboto", sans-serif;
+                cursor: pointer;
+            }
+
+#edit-toolbar button:hover {
+                background: #f5f5f5;
+            }
+
+/* Caret-contextual toggle state (aria-pressed toggle buttons) */
+            #edit-toolbar button[aria-pressed="true"] {
+                background: #e3f0ff;
+                border-color: #6aa3e0;
+                color: #1a5fb4;
+            }
+
+/* Functional groups: thin dividers between clusters, no labels */
+            #edit-toolbar .tb-group {
+                display: flex;
+                gap: 6px;
+                align-items: center;
+            }
+
+#edit-toolbar .tb-group + .tb-group {
+                border-left: 1px solid #e0e0e0;
+                padding-left: 6px;
+            }
+
+/* Table-ops cluster switches on when the caret is in a table */
+            #edit-toolbar .tb-group.table-ops.active {
+                background: #e3f0ff;
+                border-radius: 4px;
+            }
+
+/* Link / figure dialogs */
+            .edit-dialog {
+                background: white;
+                border: 2px solid #2196f3;
+                border-radius: 8px;
+                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+                padding: 16px;
+                min-width: 320px;
+                z-index: 10000;
+            }
+
+.edit-dialog label {
+                display: block;
+                font-size: 13px;
+                font-weight: 500;
+                color: #424242;
+                margin: 8px 0 4px 0;
+            }
+
+.edit-dialog input[type="text"] {
+                width: 100%;
+                padding: 8px 10px;
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                font-size: 14px;
+                box-sizing: border-box;
+            }
+
+.edit-dialog .rdfa-editor-ui .action-buttons {
+                margin-top: 14px;
+            }
+
+/* Slash menu (/ to insert a block) */
+            #slash-menu {
+                background: white;
+                border: 1px solid #e0e0e0;
+                border-radius: 8px;
+                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+                padding: 6px;
+                min-width: 220px;
+                max-height: 320px;
+                overflow-y: auto;
+                z-index: 10000;
+            }
+
+.rdfa-editor-ui .slash-filter {
+                width: 100%;
+                padding: 7px 9px;
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                font-size: 14px;
+                box-sizing: border-box;
+                margin-bottom: 6px;
+            }
+
+.rdfa-editor-ui .slash-items {
+                list-style: none;
+                margin: 0;
+                padding: 0;
+            }
+
+.rdfa-editor-ui .slash-item {
+                padding: 7px 10px;
+                border-radius: 4px;
+                font-size: 14px;
+                color: #212121;
+                cursor: pointer;
+            }
+
+.rdfa-editor-ui .slash-item:hover,
+            .rdfa-editor-ui .slash-item[aria-selected="true"] {
+                background: #e3f2fd;
+                color: #0d47a1;
+            }
+
+/* ToC jumps land below the fixed navbar */
+            .rdfa-editor-content > * {
+                scroll-margin-top: 76px;
+                scroll-margin-bottom: 48px;
+            }
+
+/* ToC drawer (Fonto-style outline view) */
+            #toc-drawer {
+                position: fixed;
+                top: 64px;
+                left: 0;
+                bottom: 44px;
+                width: 260px;
+                overflow-y: auto;
+                background: white;
+                border-right: 1px solid #e0e0e0;
+                box-shadow: 2px 0 4px rgba(0, 0, 0, 0.05);
+                padding: 12px 16px;
+                z-index: 900;
+            }
+
+#toc-drawer h2 {
+                font-size: 14px;
+                color: #555;
+                margin: 0 0 8px 0;
+                padding-right: 20px;
+            }
+
+#toc-drawer .toc-close {
+                position: absolute;
+                right: 8px;
+                top: 6px;
+                background: none;
+                border: none;
+                padding: 0 4px;
+                font-size: 22px;
+                line-height: 1;
+                color: #999;
+                cursor: pointer;
+            }
+
+#toc-drawer .toc-close:hover {
+                color: #333;
+            }
+
+#toc-drawer ul {
+                list-style: none;
+                padding-left: 0;
+                margin: 4px 0;
+            }
+
+#toc-drawer ul ul {
+                padding-left: 14px;
+            }
+
+.rdfa-editor-ui .toc-item {
+                padding: 2px 0;
+            }
+
+.rdfa-editor-ui .toc-label {
+                cursor: pointer;
+                display: block;
+                padding: 2px 6px;
+                border-radius: 4px;
+                font-size: 13px;
+            }
+
+.rdfa-editor-ui .toc-label:hover {
+                background: #e3f2fd;
+            }
+
+#toc-drawer .drop-before {
+                box-shadow: 0 -3px 0 0 #2196f3;
+            }
+
+#toc-drawer .drop-after {
+                box-shadow: 0 3px 0 0 #2196f3;
+            }
+
+#toc-drawer .dragging {
+                opacity: 0.4;
+            }
+
+/* Subject inspector drawer (read-only RDFa property sheet) */
+            #inspector-drawer {
+                position: fixed;
+                top: 64px;
+                right: 0;
+                bottom: 44px;
+                width: 300px;
+                overflow-y: auto;
+                background: white;
+                border-left: 1px solid #e0e0e0;
+                box-shadow: -2px 0 4px rgba(0, 0, 0, 0.05);
+                padding: 12px 16px;
+                z-index: 900;
+            }
+
+#inspector-drawer h2 {
+                font-size: 14px;
+                color: #555;
+                margin: 0 0 8px 0;
+                padding-right: 20px;
+            }
+
+#inspector-drawer .inspector-close {
+                position: absolute;
+                right: 8px;
+                top: 6px;
+                background: none;
+                border: none;
+                padding: 0 4px;
+                font-size: 22px;
+                line-height: 1;
+                color: #999;
+                cursor: pointer;
+            }
+
+#inspector-drawer .inspector-close:hover {
+                color: #333;
+            }
+
+#inspector-subject {
+                margin-bottom: 12px;
+                padding-bottom: 8px;
+                border-bottom: 1px solid #e0e0e0;
+            }
+
+.rdfa-editor-ui .inspector-subject-iri {
+                display: block;
+                font-family: 'Courier New', monospace;
+                font-size: 13px;
+                color: #1565c0;
+                word-break: break-all;
+                margin-bottom: 6px;
+            }
+
+.rdfa-editor-ui .inspector-type {
+                display: inline-block;
+                background: #f3e5f5;
+                color: #7b1fa2;
+                border-radius: 10px;
+                padding: 1px 8px;
+                font-size: 11px;
+                margin-right: 4px;
+            }
+
+.rdfa-editor-ui .inspector-row {
+                padding: 5px 0;
+                border-bottom: 1px solid #f0f0f0;
+                font-size: 13px;
+            }
+
+.rdfa-editor-ui .inspector-pred {
+                display: block;
+                font-family: 'Courier New', monospace;
+                color: #2e7d32;
+            }
+
+.rdfa-editor-ui .inspector-obj {
+                display: block;
+                color: #333;
+                margin-top: 2px;
+                word-break: break-word;
+            }
+
+.rdfa-editor-ui .inspector-obj-iri {
+                font-family: 'Courier New', monospace;
+                color: #1976d2;
+            }
+
+.rdfa-editor-ui .inspector-obj-dt,
+            .rdfa-editor-ui .inspector-obj-lang {
+                color: #9e9e9e;
+                font-size: 11px;
+                margin-left: 6px;
+            }
+
+/* Breadcrumb bar (Fonto-style element path + RDFa subject) */
+            #rdfa-editor-breadcrumb {
+                position: fixed;
+                left: 0;
+                right: 0;
+                bottom: 0;
+                background: white;
+                border-top: 1px solid #e0e0e0;
+                padding: 8px 20px;
+                display: flex;
+                justify-content: space-between;
+                align-items: center;
+                font-size: 13px;
+                z-index: 1000;
+            }
+
+.rdfa-editor-ui .crumb {
+                cursor: pointer;
+                color: #1976d2;
+            }
+
+.rdfa-editor-ui .crumb:hover {
+                text-decoration: underline;
+            }
+
+.rdfa-editor-ui .crumb-sep {
+                color: #9e9e9e;
+                margin: 0 4px;
+            }
+
+#rdfa-editor-breadcrumb-subject {
+                font-family: 'Courier New', monospace;
+                font-size: 12px;
+                color: #1565c0;
+            }
+
+.lint-badge {
+                border: none;
+                font-family: "Roboto", sans-serif;
+                background: #f44336;
+                color: white;
+                border-radius: 10px;
+                padding: 2px 10px;
+                font-size: 12px;
+                cursor: pointer;
+                margin-left: 12px;
+            }
+
+/* RDFa validation markers (class only - stripped by canonicalization) */
+            .rdfa-editor-content .rdfa-invalid {
+                text-decoration: underline wavy #f44336;
+                text-decoration-skip-ink: none;
+            }
+
+.edit-dialog .rdfa-editor-ui .checkbox-label {
+                display: inline-flex;
+                gap: 6px;
+                align-items: center;
+                font-weight: 400;
+                margin-top: 8px;
+            }
+
+/* Modern Overlay Styling */
+            #overlay {
+                background: linear-gradient(to bottom, #f8f9fa, #ffffff);
+                border: 2px solid #2196f3;
+                border-radius: 8px;
+                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+                font-family: "Roboto", sans-serif;
+                min-width: 450px;
+                max-width: 500px;
+                z-index: 10000;
+            }
+
+.rdfa-editor-ui .overlay-header {
+                background: linear-gradient(135deg, #2196f3, #1976d2);
+                color: white;
+                padding: 16px 20px;
+                border-radius: 6px 6px 0 0;
+                box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+            }
+
+.rdfa-editor-ui .overlay-header h3 {
+                margin: 0 0 8px 0;
+                font-size: 18px;
+                font-weight: 500;
+            }
+
+#overlay form {
+                padding: 20px;
+            }
+
+/* Statement (S / P / O) framing */
+            .rdfa-editor-ui .statement {
+                display: grid;
+                grid-template-columns: 26px 1fr;
+                gap: 10px 12px;
+                align-items: center;
+                background: #e3f2fd;
+                border-radius: 6px;
+                padding: 14px 16px;
+                margin-bottom: 16px;
+            }
+
+.rdfa-editor-ui .stmt-role {
+                font-family: 'Courier New', monospace;
+                font-weight: bold;
+                font-size: 12px;
+                color: white;
+                background: #2196f3;
+                border-radius: 50%;
+                width: 24px;
+                height: 24px;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+            }
+
+#stmt-subject {
+                font-family: 'Courier New', monospace;
+                font-size: 12px;
+                color: #1565c0;
+                word-break: break-all;
+            }
+
+/* Advanced fields disclosure */
+            #overlay details {
+                border: 1px solid #e0e0e0;
+                border-radius: 6px;
+                padding: 8px 16px;
+                margin-bottom: 16px;
+                background: white;
+            }
+
+#overlay summary {
+                cursor: pointer;
+                font-size: 13px;
+                font-weight: 500;
+                color: #757575;
+                padding: 4px 0;
+            }
+
+#overlay details fieldset {
+                margin-top: 12px;
+            }
+
+/* Fieldsets */
+            #overlay fieldset {
+                border: 1px solid #e0e0e0;
+                border-radius: 6px;
+                padding: 12px 16px;
+                margin-bottom: 16px;
+                background: white;
+            }
+
+#overlay label {
+                display: block;
+                font-weight: 500;
+                color: #424242;
+                margin-bottom: 8px;
+                font-size: 14px;
+            }
+
+#overlay input[type="text"],
+            #overlay select {
+                width: 100%;
+                padding: 10px 12px;
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                font-size: 14px;
+                font-family: "Roboto", sans-serif;
+                transition: border-color 0.2s;
+                box-sizing: border-box;
+            }
+
+#overlay input[type="text"]:focus,
+            #overlay select:focus {
+                outline: none;
+                border-color: #2196f3;
+                box-shadow: 0 0 0 3px rgba(33, 150, 243, 0.1);
+            }
+
+#overlay input[type="text"]:disabled {
+                background-color: #f5f5f5;
+                color: #999;
+            }
+
+.rdfa-editor-ui .helper-text {
+                display: block;
+                font-size: 12px;
+                color: #757575;
+                margin-top: 6px;
+                font-style: italic;
+            }
+
+/* Action Buttons */
+            .rdfa-editor-ui .action-buttons {
+                display: flex;
+                gap: 12px;
+                margin-top: 20px;
+                justify-content: flex-end;
+            }
+
+.rdfa-editor-ui .btn-primary,
+            .rdfa-editor-ui .btn-secondary,
+            .rdfa-editor-ui .btn-danger {
+                padding: 10px 24px;
+                border: none;
+                border-radius: 4px;
+                font-size: 14px;
+                font-weight: 500;
+                cursor: pointer;
+                transition: all 0.2s;
+                font-family: "Roboto", sans-serif;
+            }
+
+.rdfa-editor-ui .btn-primary {
+                background: #4caf50;
+                color: white;
+            }
+
+.rdfa-editor-ui .btn-primary:hover {
+                background: #45a049;
+                box-shadow: 0 2px 8px rgba(76, 175, 80, 0.3);
+            }
+
+.rdfa-editor-ui .btn-secondary {
+                background: #f5f5f5;
+                color: #424242;
+                border: 1px solid #e0e0e0;
+            }
+
+.rdfa-editor-ui .btn-secondary:hover {
+                background: #e0e0e0;
+            }
+
+.rdfa-editor-ui .btn-danger {
+                background: #f44336;
+                color: white;
+                margin-right: auto;
+            }
+
+.rdfa-editor-ui .btn-danger:hover {
+                background: #d32f2f;
+                box-shadow: 0 2px 8px rgba(244, 67, 54, 0.3);
+            }
+
+#overlay input[name="custom-datatype"] {
+                margin-top: 8px;
+            }
+
+/* Typeahead lookups (property / type) */
+            .rdfa-editor-ui .typeahead-field {
+                position: relative;
+                display: block;
+            }
+
+.rdfa-editor-ui .typeahead-menu {
+                position: absolute;
+                top: 100%;
+                left: 0;
+                right: 0;
+                z-index: 10002;
+                margin: 2px 0 0 0;
+                padding: 4px;
+                list-style: none;
+                background: white;
+                border: 1px solid #e0e0e0;
+                border-radius: 6px;
+                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+                max-height: 260px;
+                overflow-y: auto;
+            }
+
+.rdfa-editor-ui .typeahead-option {
+                display: flex;
+                align-items: baseline;
+                justify-content: space-between;
+                gap: 10px;
+                padding: 7px 10px;
+                border-radius: 4px;
+                font-size: 14px;
+                color: #212121;
+                cursor: pointer;
+            }
+
+/* children never intercept the mousedown, so the <li> is always the event target */
+            .rdfa-editor-ui .typeahead-option * {
+                pointer-events: none;
+            }
+
+.rdfa-editor-ui .typeahead-option:hover,
+            .rdfa-editor-ui .typeahead-option[aria-selected="true"] {
+                background: #e3f2fd;
+                color: #0d47a1;
+            }
+
+.rdfa-editor-ui .typeahead-option-label strong {
+                font-weight: 700;
+            }
+
+.rdfa-editor-ui .typeahead-option-uri {
+                flex: 0 1 auto;
+                min-width: 0;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                white-space: nowrap;
+                font-size: 11px;
+                color: #9e9e9e;
+            }
+
+.rdfa-editor-ui .typeahead-value {
+                display: flex;
+                align-items: center;
+                gap: 8px;
+                width: 100%;
+                padding: 10px 12px;
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                background: white;
+                font-size: 14px;
+                font-family: "Roboto", sans-serif;
+                text-align: left;
+                cursor: pointer;
+            }
+
+.rdfa-editor-ui .typeahead-value:hover {
+                border-color: #2196f3;
+            }
+
+.rdfa-editor-ui .typeahead-label {
+                flex: 1 1 auto;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                white-space: nowrap;
+            }
+
+.rdfa-editor-ui .typeahead-clear {
+                flex: 0 0 auto;
+                color: #9e9e9e;
+                font-size: 16px;
+                line-height: 1;
+                padding: 0 2px;
+            }
+
+.rdfa-editor-ui .typeahead-clear:hover {
+                color: #f44336;
+            }
+
+/* Modal Dialog */
+#output-modal {
+                position: fixed;
+                z-index: 10001;
+                left: 0;
+                top: 0;
+                width: 100%;
+                height: 100%;
+                background-color: rgba(0, 0, 0, 0.5);
+                display: flex;
+                align-items: center;
+                justify-content: center;
+            }
+
+.rdfa-editor-ui .modal-content {
+                background-color: white;
+                padding: 30px;
+                border-radius: 8px;
+                width: 90%;
+                max-width: 900px;
+                max-height: 80vh;
+                overflow-y: auto;
+                position: relative;
+                box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+            }
+
+.rdfa-editor-ui .modal-close {
+                position: absolute;
+                right: 20px;
+                top: 15px;
+                font-size: 32px;
+                font-weight: bold;
+                color: #999;
+                cursor: pointer;
+                line-height: 1;
+                transition: color 0.2s;
+            }
+
+.rdfa-editor-ui .modal-close:hover {
+                color: #333;
+            }
+
+.rdfa-editor-ui #output-download {
+                position: absolute;
+                right: 60px;
+                top: 22px;
+                padding: 5px 14px;
+                border: 1px solid #2196f3;
+                border-radius: 4px;
+                background: white;
+                color: #2196f3;
+                font-size: 13px;
+                font-weight: 500;
+                font-family: inherit;
+                cursor: pointer;
+                transition: background-color 0.2s, color 0.2s;
+            }
+
+.rdfa-editor-ui #output-download:hover {
+                background: #2196f3;
+                color: white;
+            }
+
+.rdfa-editor-ui .modal-content h3 {
+                margin-top: 0;
+                color: #333;
+                padding-right: 40px;
+            }
+
+.rdfa-editor-ui .modal-content pre {
+                margin: 15px 0 0 0;
+                padding: 15px;
+                background-color: #f5f5f5;
+                border: 1px solid #e0e0e0;
+                border-radius: 4px;
+                font-family: 'Courier New', monospace;
+                font-size: 12px;
+                white-space: pre-wrap;
+                word-wrap: break-word;
+                overflow-x: auto;
+            }
+
+/* links are editable text: a plain click places the caret (I-beam, not a pointer that
+   would falsely promise navigation); Ctrl/Cmd+Click opens the href */
+.rdfa-editor-content a[href] {
+    cursor: text;
+}
+
+/* the annotated selection stays visible while the overlay form has focus */
+.rdfa-editor-selection-hint {
+    position: absolute;
+    background: rgba(11, 87, 208, 0.22);
+    pointer-events: none;
+    z-index: 999;
+}
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl
index 96fa08abf..8c037fac1 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl
@@ -325,8 +325,14 @@ exclude-result-prefixes="#all"
     
     <xsl:template match="div[@typeof = ('&ldh;XHTML', '&ldh;Object')]//form[contains-token(@class, 'form-horizontal')][upper-case(@method) = 'POST']" mode="ixsl:onsubmit" priority="2"> <!-- prioritize over form.xsl -->
         <xsl:param name="elements" select=".//input | .//textarea | .//select" as="element()*"/>
-        <xsl:param name="triples" select="ldh:parse-rdf-post($elements)" as="element()*"/>
         <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])"/>
+        <!-- pre-process form before submitting it: syncs input values, so it must precede ldh:parse-rdf-post -->
+        <xsl:apply-templates select="." mode="ldh:FormPreSubmit"/>
+        <xsl:variable name="triples" select="ldh:parse-rdf-post($elements)" as="element()*"/>
+        <!-- canonicalize XML in rdf:XMLLiterals -->
+        <xsl:variable name="triples" as="element()*">
+            <xsl:apply-templates select="$triples" mode="ldh:CanonicalizeXML"/>
+        </xsl:variable>
         <xsl:variable name="container" select="ancestor::div[@typeof][1]" as="element()"/>
         <xsl:variable name="block" select="ancestor::div[contains-token(@class, 'block')][1]" as="element()"/>
         <xsl:variable name="block-uri" select="xs:anyURI(.//input[@name = 'su'] => ixsl:get('value'))" as="xs:anyURI"/>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl
index 70324486f..f6429148b 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl
@@ -47,6 +47,7 @@ xmlns:sh="&sh;"
 xmlns:sioc="&sioc;"
 xmlns:spin="&spin;"
 xmlns:bs2="http://graphity.org/xsl/bootstrap/2.3.2"
+xmlns:local="urn:rdfa-editor:functions"
 extension-element-prefixes="ixsl"
 exclude-result-prefixes="#all"
 >
@@ -141,22 +142,25 @@ WHERE
         <xsl:sequence select="ixsl:call(., 'addEventListener', [ 'change', ixsl:get(ixsl:window(), 'onSubjectTypeChange') ])[current-date() lt xs:date('2000-01-01')]"/>
     </xsl:template>
     
-    <xsl:template match="textarea[contains-token(@class, 'wymeditor')]" mode="ldh:RenderRowForm" priority="1">
-        <!-- call .wymeditor() on textarea to show WYMEditor with current origin's iframe path -->
-        <xsl:variable name="iframe-base-path" select="resolve-uri('static/com/atomgraph/linkeddatahub/js/wymeditor/iframe/default/', ldt:base())" as="xs:anyURI"/>
-        <xsl:variable name="wymeditor-config" select="ldh:new-object()"/>
-        <ixsl:set-property name="iframeBasePath" select="$iframe-base-path" object="$wymeditor-config"/>
-        <xsl:sequence select="ixsl:call(ixsl:call(ixsl:window(), 'jQuery', [ . ]), 'wymeditor', [ $wymeditor-config ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:variable name="wymeditor" select="ixsl:call(ixsl:get(ixsl:window(), 'jQuery'), 'getWymeditorByTextarea', [ . ])" as="item()"/>
-        <xsl:variable name="char-count" select="sum(.//text()/string-length())" as="xs:integer"/>
-        <xsl:variable name="iframe" select="ixsl:get($wymeditor, '_iframe')" as="element()"/>
-        
-        <!-- attempt to infer WYMEditor height from the length of textarea's content (though min 30em and max 100em) -->
-        <xsl:for-each select="$iframe">
-            <xsl:variable name="height-in-em" select="$char-count idiv 16" as="xs:integer"/>
-            <xsl:variable name="height-in-em" select="if ($height-in-em &lt; 30) then 30 else if ($height-in-em &gt; 100) then 100 else $height-in-em" as="xs:integer"/>
-            <ixsl:set-style name="height" select="string($height-in-em) || 'em'" object="."/>
+    <!-- the RDFa editor toolbar mounts in the active document's editor-bar, below the action bar (LDH pages have no nav element) -->
+    <xsl:function name="local:toolbar-host" as="element()*">
+        <xsl:sequence select="(id('tab-content', ixsl:page())/div[contains-token(@class, 'tab-pane')][contains-token(@class, 'active')]//div[contains-token(@class, 'editor-bar')]/div[contains-token(@class, 'container-fluid')])[1]"/>
+    </xsl:function>
+
+    <!-- first editable region on the page: full editor bring-up (chrome, dialogs, drawers, all regions) -->
+    <xsl:template match="div[contains-token(@class, 'rdfa-editor-content')][empty(id('edit-toolbar', ixsl:page()))]" mode="ldh:RenderRowForm" priority="2">
+        <xsl:call-template name="local:init-editor"/>
+    </xsl:template>
+
+    <!-- additional region: editor chrome already in the DOM; init only this region's blocks -->
+    <xsl:template match="div[contains-token(@class, 'rdfa-editor-content')]" mode="ldh:RenderRowForm" priority="1">
+        <!-- adopt the singleton toolbar into this document's editor-bar (it may have initialized in another tab) -->
+        <xsl:for-each select="local:toolbar-host()[not(descendant::*[@id = 'edit-toolbar'])]">
+            <xsl:sequence select="ixsl:call(., 'appendChild', [ id('edit-toolbar', ixsl:page()) ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
+        <xsl:call-template name="local:init-region">
+            <xsl:with-param name="region" select="."/>
+        </xsl:call-template>
     </xsl:template>
 
     <!-- TO-DO: phase out as regular ixsl: event templates -->
@@ -181,6 +185,17 @@ WHERE
     
     <xsl:template match="text()" mode="ldh:FormPreSubmit"/>
     
+    <!-- serialize canonicalized editor content into the hidden ol input before form submission -->
+    <xsl:template match="div[contains-token(@class, 'rdfa-editor-content')]" mode="ldh:FormPreSubmit" priority="1">
+        <xsl:variable name="canonical" as="node()*">
+            <xsl:apply-templates select="node()" mode="canonical"/>
+        </xsl:variable>
+        <xsl:variable name="value" select="serialize($canonical, map{ 'method': 'xml' })" as="xs:string"/>
+        <xsl:for-each select="following-sibling::input[@name = 'ol'][1]">
+            <ixsl:set-property name="value" select="$value" object="."/>
+        </xsl:for-each>
+    </xsl:template>
+
     <!-- trim whitespace in bnode/URI values -->
     <xsl:template match="input[@name = ('ob', 'ou')][ixsl:get(., 'value')]" mode="ldh:FormPreSubmit" priority="1">
         <ixsl:set-attribute name="value" select="normalize-space(ixsl:get(., 'value'))"/>
@@ -702,15 +717,7 @@ WHERE
         <xsl:param name="method" select="upper-case(@method)" as="xs:string"/>
         <xsl:param name="callback" select="ldh:row-form-response#1" as="function(map(*)) as item()*"/>
         <xsl:param name="elements" select=".//input | .//textarea | .//select" as="element()*"/>
-        <xsl:param name="triples" select="ldh:parse-rdf-post($elements)" as="element()*"/>
-        <xsl:param name="resources" as="document-node()">
-            <xsl:document>
-                <rdf:RDF>
-                    <xsl:sequence select="ldh:triples-to-descriptions($triples)"/>
-                </rdf:RDF>
-            </xsl:document>
-        </xsl:param>
-        <xsl:param name="request-body" select="$resources" as="document-node()"/>
+        <xsl:param name="request-body" as="document-node()?"/> <!-- no default: built below from the parsed triples, which must follow the ldh:FormPreSubmit pass -->
         <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])"/>
         <xsl:variable name="id" select="ixsl:get($form, 'id')" as="xs:string"/>
         <xsl:variable name="action" select="ixsl:get($form, 'action')" as="xs:anyURI"/>
@@ -720,16 +727,28 @@ WHERE
 
         <ixsl:set-style name="cursor" select="'progress'" object="ixsl:page()//body"/>
 
+        <!-- pre-process form before submitting it: syncs input values, so it must precede ldh:parse-rdf-post.
+             A wrapping handler that supplied $request-body has already run the pass -->
+        <xsl:if test="empty($request-body)">
+            <xsl:apply-templates select="." mode="ldh:FormPreSubmit"/>
+        </xsl:if>
+
+        <xsl:variable name="triples" select="ldh:parse-rdf-post($elements)" as="element()*"/>
         <!-- canonicalize XML in rdf:XMLLiterals -->
         <xsl:variable name="triples" as="element()*">
             <xsl:apply-templates select="$triples" mode="ldh:CanonicalizeXML"/>
         </xsl:variable>
+        <xsl:variable name="resources" as="document-node()">
+            <xsl:document>
+                <rdf:RDF>
+                    <xsl:sequence select="ldh:triples-to-descriptions($triples)"/>
+                </rdf:RDF>
+            </xsl:document>
+        </xsl:variable>
+        <xsl:variable name="request-body" select="($request-body, $resources)[1]" as="document-node()"/>
         <xsl:variable name="doc-uri" select="ac:absolute-path(ldh:base-uri(.))" as="xs:anyURI"/>
         <xsl:variable name="request-uri" select="ldh:href($action, map{})" as="xs:anyURI"/>
 
-        <!-- pre-process form before submitting it -->
-        <xsl:apply-templates select="." mode="ldh:FormPreSubmit"/>
-            
         <xsl:choose>
             <!-- we need to handle multipart requests specially because of Saxon-JS 2 limitations: https://saxonica.plan.io/issues/4732 -->
             <xsl:when test="$enctype = 'multipart/form-data'">
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/navigation.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/navigation.xsl
index f401f975e..dac62a605 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/navigation.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/navigation.xsl
@@ -306,6 +306,9 @@ ORDER BY DESC(?created)
                 <ixsl:set-style name="display" select="'block'" object="$active-sidebar"/>
             </xsl:if>
         </xsl:if>
+
+        <!-- chain to the RDFa editor's sweep-selection tracker (lower import precedence) -->
+        <xsl:next-match/>
     </xsl:template>
 
     <!-- hide the document tree container if its position is fixed (i.e. the layout is not responsive) -->
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 e79f8a0b4..27fa88922 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
@@ -511,6 +511,11 @@ extension-element-prefixes="ixsl"
                 <xsl:with-param name="active-mode" select="$mode"/>
             </xsl:apply-templates>
 
+            <!-- host for the RDFa editor toolbar (appended by local:init-editing); empty until an editable region initializes -->
+            <div class="navbar-inner editor-bar">
+                <div class="container-fluid"></div>
+            </div>
+
             <xsl:apply-templates select="." mode="bs2:ContentBody">
                 <xsl:with-param name="mode" select="$mode"/>
             </xsl:apply-templates>
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 b0a90db79..2739db5a2 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
@@ -1234,19 +1234,21 @@ exclude-result-prefixes="#all"
         </xsl:if>
     </xsl:template>
     
-    <!-- WYSIWYG editor for XMLLiteral objects -->
+    <!-- RDFa editor for XMLLiteral objects -->
 
     <xsl:template match="*[@rdf:parseType = 'Literal']/xhtml:*" mode="bs2:FormControl">
         <xsl:param name="id" select="generate-id()" as="xs:string"/>
         <xsl:param name="type" select="'textarea'" as="xs:string?"/> <!-- 'textarea' is not a valid <input> type -->
         <xsl:param name="type-label" select="true()" as="xs:boolean"/>
 
-        <textarea name="ol" id="{$id}" class="wymeditor">
-            <xsl:variable name="xhtml" as="element()*">
-                <xsl:copy-of select="xhtml:*" copy-namespaces="no"/>
-            </xsl:variable>
-            <xsl:value-of select="serialize($xhtml)"/>
-        </textarea>
+        <div class="rdfa-editor-content">
+            <xsl:copy-of select="node()" copy-namespaces="no"/>
+        </div>
+        <xsl:call-template name="xhtml:Input">
+            <xsl:with-param name="type" select="'hidden'"/>
+            <xsl:with-param name="name" select="'ol'"/>
+            <xsl:with-param name="id" select="$id"/>
+        </xsl:call-template>
         <xsl:call-template name="xhtml:Input">
             <xsl:with-param name="type" select="'hidden'"/>
             <xsl:with-param name="name" select="'lt'"/>
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 e6ce4ed4f..748b1880e 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
@@ -332,15 +332,15 @@ exclude-result-prefixes="#all">
     <!-- STYLE -->
     
     <xsl:template match="rdf:RDF[lapp:origin()] | srx:sparql[lapp:origin()]" mode="xhtml:Style">
-        <xsl:param name="load-wymeditor" select="exists($foaf:Agent//@rdf:about)" as="xs:boolean"/>
+        <xsl:param name="load-rdfa-editor" select="exists($foaf:Agent//@rdf:about)" as="xs:boolean"/>
         <xsl:param name="load-yasqe" select="true()" as="xs:boolean"/>
 
         <link href="{resolve-uri('static/css/bootstrap.css', lapp:origin())}" rel="stylesheet" type="text/css"/>
         <link href="{resolve-uri('static/css/bootstrap-responsive.css', lapp:origin())}" rel="stylesheet" type="text/css"/>
         <link href="{resolve-uri('static/com/atomgraph/client/css/bootstrap.css', lapp:origin())}" rel="stylesheet" type="text/css"/>
         <link href="{resolve-uri('static/com/atomgraph/linkeddatahub/css/bootstrap.css', lapp:origin())}" rel="stylesheet" type="text/css"/>
-        <xsl:if test="$load-wymeditor">
-            <link href="{resolve-uri('static/com/atomgraph/linkeddatahub/js/wymeditor/skins/default/skin.css', lapp:origin())}" rel="stylesheet" type="text/css"/>
+        <xsl:if test="$load-rdfa-editor">
+            <link href="{resolve-uri('static/com/atomgraph/linkeddatahub/css/rdfa-editor.css', lapp:origin())}" rel="stylesheet" type="text/css"/>
         </xsl:if>
         <xsl:if test="$load-yasqe">
             <link href="{resolve-uri('static/css/yasqe.css', lapp:origin())}" rel="stylesheet" type="text/css"/>
@@ -352,7 +352,6 @@ exclude-result-prefixes="#all">
     <xsl:template match="rdf:RDF[lapp:origin()] | srx:sparql[lapp:origin()]" mode="xhtml:Script">
         <xsl:param name="client-stylesheet" select="resolve-uri('static/com/atomgraph/linkeddatahub/xsl/client.xsl.sef.json', lapp:origin())" as="xs:anyURI"/>
         <xsl:param name="saxon-js-log-level" select="10" as="xs:integer"/>
-        <xsl:param name="load-wymeditor" select="not(ac:mode(root()) = ('&ac;ModalMode', '&ldht;InfoWindowMode'))" as="xs:boolean"/>
         <xsl:param name="load-yasqe" select="not(ac:mode(root()) = ('&ac;ModalMode', '&ldht;InfoWindowMode'))" as="xs:boolean"/>
         <xsl:param name="load-saxon-js" select="$ldh:ajaxRendering and not(ac:mode(root()) = ('&ac;ModalMode', '&ldht;InfoWindowMode'))" as="xs:boolean"/>
         <xsl:param name="load-sparql-builder" select="not(ac:mode(root()) = ('&ac;ModalMode', '&ldht;InfoWindowMode'))" as="xs:boolean"/>
@@ -381,9 +380,6 @@ exclude-result-prefixes="#all">
               //]]&gt;
             </xsl:text>
         </script>
-        <xsl:if test="$load-wymeditor">
-            <script type="text/javascript" src="{resolve-uri('static/com/atomgraph/linkeddatahub/js/wymeditor/jquery.wymeditor.js', lapp:origin())}" defer="defer"></script>
-        </xsl:if>
         <xsl:if test="$load-yasqe">
             <script src="{resolve-uri('static/js/yasqe.js', lapp:origin())}" type="text/javascript"></script>
         </xsl:if>
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 62c043dec..d0595ff75 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/client.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/client.xsl
@@ -68,6 +68,7 @@ xmlns:schema1="&schema1;"
 xmlns:schema2="&schema2;"
 xmlns:dbpo="&dbpo;"
 xmlns:bs2="http://graphity.org/xsl/bootstrap/2.3.2"
+xmlns:local="urn:rdfa-editor:functions"
 exclude-result-prefixes="#all"
 extension-element-prefixes="ixsl"
 >
@@ -106,7 +107,8 @@ extension-element-prefixes="ixsl"
     <xsl:import href="converters/RDFXML2DataTable.xsl"/>
     <xsl:import href="converters/SPARQLXMLResults2DataTable.xsl"/>
     <xsl:import href="converters/RDFXML2GeoJSON.xsl"/>
-    
+    <xsl:import href="rdfa-editor/index.xsl"/>
+
     <xsl:include href="bootstrap/2.3.2/client/admin/signup.xsl"/>
     <xsl:include href="bootstrap/2.3.2/client/query-transforms.xsl"/>
     <xsl:include href="bootstrap/2.3.2/client/typeahead.xsl"/>
@@ -259,6 +261,8 @@ WHERE
         <ixsl:set-property name="typeahead" select="ldh:new-object()" object="ixsl:get(ixsl:window(), 'LinkedDataHub')"/> <!-- used by typeahead.xsl -->
         <ixsl:set-property name="graphs" select="ldh:new-object()" object="ixsl:get(ixsl:window(), 'LinkedDataHub')"/> <!-- used by graph3d.xsl -->
         <ixsl:set-property name="yasqe" select="ldh:new-object()" object="ixsl:get(ixsl:window(), 'LinkedDataHub')"/>
+        <!-- create the RDFa editor state container (editor chrome initializes lazily, on the first editable region) -->
+        <xsl:call-template name="local:init-state"/>
 
         <!-- handle OAuth ID token from URL fragment -->
         <xsl:variable name="location-hash" select="ixsl:get(ixsl:get(ixsl:window(), 'location'), 'hash')" as="xs:string?"/>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/RDFa2RDFXML-v3.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/RDFa2RDFXML-v3.xsl
new file mode 100644
index 000000000..2cc9af4a8
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/RDFa2RDFXML-v3.xsl
@@ -0,0 +1,355 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    xmlns:map="http://www.w3.org/2005/xpath-functions/map"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns:rdfa="urn:rdfa:functions"
+    xpath-default-namespace="http://www.w3.org/1999/xhtml"
+    exclude-result-prefixes="xs map rdfa"
+    version="3.0">
+
+<!--
+    RDFa 1.1 (Lite) to RDF/XML extraction. Pure XSLT 3.0 - no ixsl: dependencies,
+    so it runs headless via xslt3 for testing (see tests/run-tests.sh).
+
+    Supported: @about, @typeof, @property, @content, @datatype, @resource, @href,
+    @src, @prefix (and xmlns:*), @vocab with bare-term resolution, @lang/@xml:lang
+    inheritance, base-URI resolution (about="" = the document).
+
+    Semantics follow the RDFa 1.1 processing rules strictly - no profile deviations.
+    Note for LinkedDataHub v6 alignment: the conformant containment idiom is
+    <article property="https://schema.org/hasPart" resource="#part" typeof="...">
+    (object chaining via @resource); @about + @property without @content/@resource
+    is, per spec, a text literal on the @about subject.
+
+    Subtrees carrying any @data-role (LDH v6 convention: hydrated 'rendering' output,
+    injected editor 'chrome') plus head, script and style are excluded - both from
+    traversal and from literal values.
+
+    Future work (out of scope): @rel/@rev, @inlist, safe CURIEs, @datetime/<time>,
+    xml:base.
+-->
+
+    <xsl:mode name="rdfa:extract" on-no-match="deep-skip"/>
+
+    <xsl:output method="xml" indent="yes" encoding="UTF-8"/>
+
+    <!-- overrides base-uri($doc): required when the input's static base URI is meaningless (CLI fixtures) -->
+    <xsl:param name="base-uri" as="xs:string?" select="()"/>
+
+    <!-- RDFa 1.1 initial context (subset) -->
+    <xsl:variable name="rdfa:default-prefixes" as="map(xs:string, xs:string)" select="map{
+        'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+        'rdfs': 'http://www.w3.org/2000/01/rdf-schema#',
+        'xsd': 'http://www.w3.org/2001/XMLSchema#',
+        'schema': 'http://schema.org/',
+        'foaf': 'http://xmlns.com/foaf/0.1/',
+        'dc': 'http://purl.org/dc/terms/',
+        'dct': 'http://purl.org/dc/terms/'
+    }"/>
+
+    <xsl:template match="/" name="extract-rdfa">
+        <xsl:param name="doc" as="document-node()" select="."/>
+        <xsl:param name="base" as="xs:string" select="($base-uri, string(base-uri($doc)))[1]"/>
+        <xsl:variable name="effective-base" as="xs:string"
+            select="if ($doc//base/@href) then string(resolve-uri(($doc//base/@href)[1], $base)) else $base"/>
+
+        <rdf:RDF>
+            <xsl:apply-templates select="$doc/*" mode="rdfa:extract">
+                <!-- RDFa initializes the parent object to the base URI -->
+                <xsl:with-param name="subject" select="$effective-base"/>
+                <xsl:with-param name="base" select="$effective-base" tunnel="yes"/>
+            </xsl:apply-templates>
+        </rdf:RDF>
+    </xsl:template>
+
+    <xsl:template match="head | script | style | *[@data-role]" mode="rdfa:extract"/>
+
+    <xsl:template match="*" mode="rdfa:extract">
+        <xsl:param name="subject" as="xs:string?" select="()"/>
+        <xsl:param name="prefixes" as="map(xs:string, xs:string)" select="$rdfa:default-prefixes"/>
+        <xsl:param name="vocab" as="xs:string?" select="()"/>
+        <xsl:param name="lang" as="xs:string?" select="()"/>
+        <xsl:param name="base" as="xs:string" tunnel="yes"/>
+
+        <!-- evaluation context updates. Empty @vocab/@lang reset; @xml:lang wins over @lang -->
+        <xsl:variable name="prefixes" as="map(xs:string, xs:string)"
+            select="map:merge(($prefixes, rdfa:in-scope-namespaces(.), rdfa:parse-prefix-attr(@prefix)), map{ 'duplicates': 'use-last' })"/>
+        <xsl:variable name="vocab" as="xs:string?"
+            select="if (exists(@vocab)) then @vocab[. ne ''] else $vocab"/>
+        <xsl:variable name="lang" as="xs:string?"
+            select="if (exists((@xml:lang, @lang))) then string((@xml:lang, @lang)[1])[. ne ''] else $lang"/>
+
+        <xsl:variable name="new-subject" as="xs:string?" select="rdfa:new-subject(., $prefixes, $base)"/>
+
+        <!-- section 7.5 step 2: @vocab asserts (base, rdfa:usesVocabulary, vocab IRI) -->
+        <xsl:for-each select="@vocab[. ne '']">
+            <rdf:Description rdf:about="{$base}">
+                <xsl:element name="usesVocabulary" namespace="http://www.w3.org/ns/rdfa#">
+                    <xsl:attribute name="rdf:resource" select="resolve-uri(., $base)"/>
+                </xsl:element>
+            </rdf:Description>
+        </xsl:for-each>
+
+        <!-- @typeof: one rdf:type triple per token; the typed node is the new subject -->
+        <xsl:for-each select="@typeof ! tokenize(.) ! rdfa:resolve-term-or-curie(., $prefixes, $vocab)">
+            <rdf:Description>
+                <xsl:sequence select="rdfa:subject-attribute($new-subject)"/>
+                <rdf:type rdf:resource="{.}"/>
+            </rdf:Description>
+        </xsl:for-each>
+
+        <!-- @property: determine subject/object once, emit one triple per token -->
+        <xsl:variable name="statement" as="map(*)?">
+            <xsl:choose>
+                <xsl:when test="not(@property)"/>
+                <!-- literal object: @content overrides text content; @datatype forces a literal reading.
+                     Subject establishment follows rule 5.2, so @resource/@href/@src set it (via new-subject) -->
+                <xsl:when test="@content or @datatype">
+                    <xsl:sequence select="map{
+                        'subject': ($new-subject, $subject)[1],
+                        'literal': string((@content, rdfa:literal-value(.))[1]),
+                        'datatype': @datatype ! rdfa:resolve-term-or-curie(., $prefixes, $vocab),
+                        'lang': $lang
+                    }"/>
+                </xsl:when>
+                <!-- IRI object from @resource/@href/@src (rule 5.1 + step 11) -->
+                <xsl:when test="@resource or @href or @src">
+                    <xsl:sequence select="map{
+                        'subject': (@about ! $new-subject, $subject)[1],
+                        'object': rdfa:resolve-iri((@resource, @href, @src)[1], $prefixes, $base)
+                    }"/>
+                </xsl:when>
+                <!-- @typeof without @about: the typed node becomes the object (RDFa 1.1 chaining) -->
+                <xsl:when test="@typeof and not(@about)">
+                    <xsl:sequence select="map{ 'subject': $subject, 'object': $new-subject }"/>
+                </xsl:when>
+                <!-- plain literal from text content -->
+                <xsl:otherwise>
+                    <xsl:sequence select="map{
+                        'subject': (@about ! $new-subject, $subject)[1],
+                        'literal': rdfa:literal-value(.),
+                        'lang': $lang
+                    }"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:variable>
+
+        <xsl:if test="exists($statement) and exists($statement?subject)">
+            <xsl:for-each select="tokenize(@property) ! rdfa:resolve-term-or-curie(., $prefixes, $vocab)">
+                <xsl:variable name="property-parts" as="map(xs:string, xs:string)" select="rdfa:split-uri(.)"/>
+                <xsl:choose>
+                    <xsl:when test="matches($property-parts?local, '^[\i-[:]][\c-[:]]*$') and $property-parts?namespace ne ''">
+                        <rdf:Description>
+                            <xsl:sequence select="rdfa:subject-attribute($statement?subject)"/>
+                            <xsl:element name="{rdfa:prefixed-name($property-parts, $prefixes)}" namespace="{$property-parts?namespace}">
+                                <xsl:choose>
+                                    <xsl:when test="exists($statement?object)">
+                                        <xsl:sequence select="rdfa:object-attribute($statement?object)"/>
+                                    </xsl:when>
+                                    <xsl:otherwise>
+                                        <xsl:choose>
+                                            <xsl:when test="exists($statement?datatype)">
+                                                <xsl:attribute name="rdf:datatype" select="$statement?datatype"/>
+                                            </xsl:when>
+                                            <xsl:when test="exists($statement?lang)">
+                                                <xsl:attribute name="xml:lang" select="$statement?lang"/>
+                                            </xsl:when>
+                                        </xsl:choose>
+                                        <xsl:value-of select="$statement?literal"/>
+                                    </xsl:otherwise>
+                                </xsl:choose>
+                            </xsl:element>
+                        </rdf:Description>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:message select="'[RDFa] Skipping property IRI not splittable into namespace/local name: ' || ."/>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:for-each>
+        </xsl:if>
+
+        <!-- descendants inherit the current object resource - set only by a typed resource
+             (@typeof without @about, rule 5.1) - else the new subject, else the current one -->
+        <xsl:variable name="chains" as="xs:boolean"
+            select="exists(@property) and not(@content) and not(@datatype) and exists(@typeof) and not(@about)"/>
+        <xsl:apply-templates select="*" mode="rdfa:extract">
+            <xsl:with-param name="subject" select="if ($chains) then $statement?object else ($new-subject, $subject)[1]"/>
+            <xsl:with-param name="prefixes" select="$prefixes"/>
+            <xsl:with-param name="vocab" select="$vocab"/>
+            <xsl:with-param name="lang" select="$lang"/>
+        </xsl:apply-templates>
+    </xsl:template>
+
+    <!--
+        New subject / typed resource of an element per RDFa 1.1 section 7.5:
+        @about always wins; under rule 5.2 (no @property, or @content/@datatype
+        present) @resource/@href/@src establish the subject; @typeof mints a node
+        identified by @resource/@href/@src or a fresh blank node; else none (inherit).
+    -->
+    <xsl:function name="rdfa:new-subject" as="xs:string?">
+        <xsl:param name="element" as="element()"/>
+        <xsl:param name="prefixes" as="map(xs:string, xs:string)"/>
+        <xsl:param name="base" as="xs:string"/>
+
+        <xsl:choose>
+            <xsl:when test="$element/@about">
+                <xsl:sequence select="rdfa:resolve-iri($element/@about, $prefixes, $base)"/>
+            </xsl:when>
+            <xsl:when test="$element/(@resource, @href, @src)
+                    and (not($element/@property) or $element/@content or $element/@datatype)">
+                <xsl:sequence select="rdfa:resolve-iri(($element/@resource, $element/@href, $element/@src)[1], $prefixes, $base)"/>
+            </xsl:when>
+            <xsl:when test="$element/@typeof">
+                <xsl:sequence select="if ($element/(@resource, @href, @src))
+                    then rdfa:resolve-iri(($element/@resource, $element/@href, $element/@src)[1], $prefixes, $base)
+                    else '_:' || rdfa:bnode-label($element)"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:sequence select="()"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- the subject in scope at an element, for UI display: fold new-subject over the ancestor axis -->
+    <xsl:function name="rdfa:in-scope-subject" as="xs:string?">
+        <xsl:param name="element" as="element()"/>
+        <xsl:param name="base" as="xs:string"/>
+
+        <xsl:sequence select="fold-left($element/ancestor-or-self::*, $base,
+            function($subject, $e) { (rdfa:new-subject($e, $rdfa:default-prefixes, $base), $subject)[1] })"/>
+    </xsl:function>
+
+    <!-- IRI attribute values (@about/@resource/@href/@src): blank node, CURIE, or (relative) IRI -->
+    <xsl:function name="rdfa:resolve-iri" as="xs:string">
+        <xsl:param name="value" as="xs:string"/>
+        <xsl:param name="prefixes" as="map(xs:string, xs:string)"/>
+        <xsl:param name="base" as="xs:string"/>
+
+        <xsl:variable name="value" as="xs:string" select="normalize-space($value)"/>
+        <xsl:choose>
+            <xsl:when test="starts-with($value, '_:')">
+                <xsl:sequence select="$value"/>
+            </xsl:when>
+            <xsl:when test="map:contains($prefixes, substring-before($value, ':')) and not(starts-with(substring-after($value, ':'), '//'))">
+                <xsl:sequence select="$prefixes(substring-before($value, ':')) || substring-after($value, ':')"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:sequence select="string(resolve-uri($value, $base))"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- @property/@typeof/@datatype values: absolute IRI, CURIE, or bare term against @vocab -->
+    <xsl:function name="rdfa:resolve-term-or-curie" as="xs:string?">
+        <xsl:param name="value" as="xs:string"/>
+        <xsl:param name="prefixes" as="map(xs:string, xs:string)"/>
+        <xsl:param name="vocab" as="xs:string?"/>
+
+        <xsl:variable name="value" as="xs:string" select="normalize-space($value)"/>
+        <xsl:choose>
+            <xsl:when test="map:contains($prefixes, substring-before($value, ':')) and not(starts-with(substring-after($value, ':'), '//'))">
+                <xsl:sequence select="$prefixes(substring-before($value, ':')) || substring-after($value, ':')"/>
+            </xsl:when>
+            <xsl:when test="matches($value, '^[a-zA-Z][a-zA-Z0-9+.-]*:')">
+                <xsl:sequence select="$value"/>
+            </xsl:when>
+            <xsl:when test="exists($vocab) and matches($value, '^[\i-[:]][\c-[:]]*$')">
+                <xsl:sequence select="$vocab || $value"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:message select="'[RDFa] Dropping unresolvable term ''' || $value || ''' (no in-scope vocab or prefix)'"/>
+                <xsl:sequence select="()"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- @prefix attribute: 'prefix: IRI prefix: IRI ...' -->
+    <xsl:function name="rdfa:parse-prefix-attr" as="map(xs:string, xs:string)">
+        <xsl:param name="attr" as="xs:string?"/>
+
+        <xsl:variable name="entries" as="map(xs:string, xs:string)*">
+            <xsl:analyze-string select="string($attr)" regex="([^\s:]+):\s+(\S+)">
+                <xsl:matching-substring>
+                    <xsl:sequence select="map{ regex-group(1): regex-group(2) }"/>
+                </xsl:matching-substring>
+            </xsl:analyze-string>
+        </xsl:variable>
+        <xsl:sequence select="map:merge($entries, map{ 'duplicates': 'use-last' })"/>
+    </xsl:function>
+
+    <!-- legacy xmlns:* declarations, via the namespace axis (XDM) and attribute names (HTML DOM) -->
+    <xsl:function name="rdfa:in-scope-namespaces" as="map(xs:string, xs:string)">
+        <xsl:param name="element" as="element()"/>
+
+        <xsl:variable name="entries" as="map(xs:string, xs:string)*" select="
+            in-scope-prefixes($element)[not(. = ('', 'xml'))] ! map{ . : string(namespace-uri-for-prefix(., $element)) },
+            $element/@*[starts-with(name(), 'xmlns:')] ! map{ substring-after(name(), 'xmlns:'): string(.) }"/>
+        <xsl:sequence select="map:merge($entries, map{ 'duplicates': 'use-last' })"/>
+    </xsl:function>
+
+    <!-- literal value of an element: its text content minus rendering/script/style subtrees -->
+    <xsl:function name="rdfa:literal-value" as="xs:string">
+        <xsl:param name="element" as="element()"/>
+
+        <xsl:sequence select="normalize-space(string-join(
+            $element//text()[not(ancestor::*[@data-role] | ancestor::script | ancestor::style)]))"/>
+    </xsl:function>
+
+    <!-- stable across processors and runs, unlike generate-id(): position path of the element -->
+    <xsl:function name="rdfa:bnode-label" as="xs:string">
+        <xsl:param name="element" as="element()"/>
+
+        <xsl:sequence select="'b' || string-join($element/ancestor-or-self::* ! string(count(preceding-sibling::*) + 1), '.')"/>
+    </xsl:function>
+
+    <xsl:function name="rdfa:subject-attribute" as="attribute()">
+        <xsl:param name="subject" as="xs:string"/>
+
+        <xsl:choose>
+            <xsl:when test="starts-with($subject, '_:')">
+                <xsl:attribute name="rdf:nodeID" select="substring-after($subject, '_:')"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:attribute name="rdf:about" select="$subject"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <xsl:function name="rdfa:object-attribute" as="attribute()">
+        <xsl:param name="object" as="xs:string"/>
+
+        <xsl:choose>
+            <xsl:when test="starts-with($object, '_:')">
+                <xsl:attribute name="rdf:nodeID" select="substring-after($object, '_:')"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:attribute name="rdf:resource" select="$object"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- namespace/local split on the last '#' or '/' for RDF/XML property element names -->
+    <xsl:function name="rdfa:split-uri" as="map(xs:string, xs:string)">
+        <xsl:param name="uri" as="xs:string"/>
+
+        <xsl:variable name="namespace" as="xs:string"
+            select="(replace($uri, '^(.*[#/])[^#/]*$', '$1')[. ne $uri], '')[1]"/>
+        <xsl:sequence select="map{
+            'namespace': $namespace,
+            'local': substring($uri, string-length($namespace) + 1)
+        }"/>
+    </xsl:function>
+
+    <!-- prefer a declared prefix for readable RDF/XML output -->
+    <xsl:function name="rdfa:prefixed-name" as="xs:string">
+        <xsl:param name="parts" as="map(xs:string, xs:string)"/>
+        <xsl:param name="prefixes" as="map(xs:string, xs:string)"/>
+
+        <xsl:variable name="prefix" as="xs:string?"
+            select="map:for-each($prefixes, function($prefix, $namespace) { $prefix[$namespace eq $parts?namespace] })[1]"/>
+        <xsl:sequence select="if (exists($prefix)) then $prefix || ':' || $parts?local else $parts?local"/>
+    </xsl:function>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/annotate.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/annotate.xsl
new file mode 100644
index 000000000..3c72614bd
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/annotate.xsl
@@ -0,0 +1,359 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfa="urn:rdfa:functions"
+xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    Event handling. One interaction model: right-click inside editable content.
+    On an existing annotation it opens the editor pre-filled (with a Remove action);
+    on a plain selection it validates the range and opens the create form.
+    Plain clicks never open the overlay, so the caret stays usable while editing text.
+-->
+
+    <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:oncontextmenu">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="target" select="ixsl:get($event, 'target')"/>
+        <!-- innermost annotated element inside this editable root, plus the block
+             itself when it carries its own @property (e.g. h1[property=dct:title]) -
+             a genuine block-level annotation. A block that only declares a subject
+             (@about/@typeof/@resource) stays structural and is left to create mode. -->
+        <xsl:variable name="annotation" as="element()?"
+            select="($target/ancestor-or-self::*[@property or @typeof or @about or @resource]
+                intersect (descendant::* | self::*[@property]))[last()]"/>
+        <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+
+        <xsl:choose>
+            <!-- edit mode -->
+            <xsl:when test="exists($annotation)">
+                <ixsl:set-property name="editingSpan" select="$annotation" object="local:editor-state()"/>
+                <xsl:call-template name="local:populate-form">
+                    <xsl:with-param name="span" select="$annotation"/>
+                    <!-- rdfa:literal-value, not string(): a block annotation contains a
+                         chrome span whose ⠿ text would otherwise leak into the value -->
+                    <xsl:with-param name="value" select="if (exists($annotation/@content))
+                        then string($annotation/@content) else rdfa:literal-value($annotation)"/>
+                </xsl:call-template>
+                <xsl:call-template name="local:show-overlay">
+                    <xsl:with-param name="event" select="$event"/>
+                    <xsl:with-param name="in-scope-subject"
+                        select="($annotation/@about ! string(.),
+                            $annotation/parent::* ! rdfa:in-scope-subject(., local:document-uri()))[1]"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- create mode -->
+            <xsl:otherwise>
+                <xsl:variable name="selection" select="local:selection()"/>
+                <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1 and not(ixsl:get($selection, 'isCollapsed'))">
+                    <xsl:variable name="range" select="local:caret-range()"/>
+                    <xsl:choose>
+                        <xsl:when test="local:selection-valid($range)">
+                            <ixsl:set-property name="range" select="$range" object="local:editor-state()"/>
+                            <ixsl:set-property name="editingSpan" select="()" object="local:editor-state()"/>
+                            <xsl:call-template name="local:show-selection-hint">
+                                <xsl:with-param name="range" select="$range"/>
+                            </xsl:call-template>
+                            <xsl:call-template name="local:populate-form">
+                                <xsl:with-param name="value" select="string(ixsl:call($selection, 'toString', []))"/>
+                            </xsl:call-template>
+                            <xsl:call-template name="local:show-overlay">
+                                <xsl:with-param name="event" select="$event"/>
+                                <xsl:with-param name="in-scope-subject" select="rdfa:in-scope-subject(., local:document-uri())"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <xsl:otherwise>
+                            <xsl:call-template name="local:show-flash">
+                                <xsl:with-param name="range" select="$range"/>
+                            </xsl:call-template>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:if>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- surroundContents() succeeds when the range starts and ends in the same
+         container, or in sibling text nodes; xsl:try in the Annotate handler backstops
+         the partial-selection cases this misses -->
+    <xsl:function name="local:selection-valid" as="xs:boolean">
+        <xsl:param name="range"/>
+
+        <xsl:variable name="start" select="ixsl:get($range, 'startContainer')"/>
+        <xsl:variable name="end" select="ixsl:get($range, 'endContainer')"/>
+        <xsl:sequence select="ixsl:call($start, 'isSameNode', [ $end ])
+            or (ixsl:get($start, 'nodeType') = 3 and ixsl:get($end, 'nodeType') = 3
+                and ixsl:call(ixsl:get($start, 'parentNode'), 'isSameNode', [ ixsl:get($end, 'parentNode') ]))"/>
+    </xsl:function>
+
+    <!-- the single write path for RDFa attributes, shared by create and edit. No modes:
+         the attributes follow from the filled fields. A value differing from the display
+         text becomes @content - unless @resource is the object (RDFa step 11: @content
+         would take precedence and orphan the resource) -->
+    <xsl:template name="local:apply-annotation">
+        <xsl:param name="target" as="element()"/>
+        <xsl:param name="values" as="map(xs:string, xs:string?)"/>
+        <xsl:param name="reference-text" as="xs:string"/>
+
+        <xsl:for-each select="$target">
+            <xsl:variable name="element" select="."/>
+            <xsl:for-each select="'about', 'typeof', 'property', 'resource', 'content', 'datatype', 'lang', 'xml:lang'">
+                <ixsl:remove-attribute name="{.}" object="$element"/>
+            </xsl:for-each>
+
+            <xsl:if test="exists($values?subject)">
+                <ixsl:set-attribute name="about" select="$values?subject"/>
+            </xsl:if>
+            <xsl:if test="exists($values?typeof)">
+                <ixsl:set-attribute name="typeof" select="$values?typeof"/>
+            </xsl:if>
+            <xsl:if test="exists($values?property)">
+                <ixsl:set-attribute name="property" select="$values?property"/>
+            </xsl:if>
+            <xsl:if test="exists($values?object)">
+                <ixsl:set-attribute name="resource" select="$values?object"/>
+            </xsl:if>
+            <xsl:if test="exists($values?value[. ne $reference-text]) and empty($values?object)">
+                <ixsl:set-attribute name="content" select="$values?value"/>
+            </xsl:if>
+            <!-- literal-type markup only when the object is a literal; @datatype wins over
+                 @lang (RDFa: a datatype forces a typed literal and language is ignored) -->
+            <xsl:if test="empty($values?object)">
+                <xsl:choose>
+                    <xsl:when test="exists($values?datatype)">
+                        <ixsl:set-attribute name="datatype" select="$values?datatype"/>
+                    </xsl:when>
+                    <xsl:when test="exists($values?lang)">
+                        <ixsl:set-attribute name="lang" select="$values?lang"/>
+                    </xsl:when>
+                </xsl:choose>
+            </xsl:if>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="button[tokenize(@class) = 'spo-action']" mode="ixsl:onclick">
+        <xsl:variable name="values" as="map(xs:string, xs:string?)" select="local:form-values(ancestor::form)"/>
+        <xsl:variable name="editing" select="ixsl:get(local:editor-state(), 'editingSpan')"/>
+
+        <xsl:choose>
+            <xsl:when test="exists($editing)">
+                <xsl:call-template name="local:push-undo"/>
+                <xsl:call-template name="local:apply-annotation">
+                    <xsl:with-param name="target" select="$editing"/>
+                    <xsl:with-param name="values" select="$values"/>
+                    <!-- chrome-excluded, so an unchanged block value doesn't spuriously emit @content -->
+                    <xsl:with-param name="reference-text" select="rdfa:literal-value($editing)"/>
+                </xsl:call-template>
+                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="local:hide-overlay"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="range" select="ixsl:get(local:editor-state(), 'range')"/>
+                <xsl:variable name="reference-text" as="xs:string" select="string(ixsl:call($range, 'toString', []))"/>
+                <!-- capture pre-wrap state; push only when the wrap succeeded -->
+                <xsl:variable name="snapshot-root" as="element()?" select="local:active-root()"/>
+                <xsl:variable name="snapshot" as="xs:string?"
+                    select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
+                <xsl:variable name="span" as="element()?">
+                    <xsl:call-template name="local:wrap-range">
+                        <xsl:with-param name="range" select="$range"/>
+                        <xsl:with-param name="name" select="'span'"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:for-each select="$span">
+                    <xsl:call-template name="local:push-undo">
+                        <xsl:with-param name="root" select="$snapshot-root"/>
+                        <xsl:with-param name="snapshot" select="$snapshot"/>
+                    </xsl:call-template>
+                    <xsl:call-template name="local:apply-annotation">
+                        <xsl:with-param name="target" select="."/>
+                        <xsl:with-param name="values" select="$values"/>
+                        <xsl:with-param name="reference-text" select="$reference-text"/>
+                    </xsl:call-template>
+                    <xsl:call-template name="local:after-mutation"/>
+                </xsl:for-each>
+                <xsl:call-template name="local:hide-overlay"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- unwrap an element: move its children up, drop it, merge text nodes -->
+    <xsl:template name="local:unwrap-element">
+        <xsl:param name="element" as="element()"/>
+
+        <xsl:variable name="parent" select="ixsl:get($element, 'parentNode')"/>
+        <xsl:for-each select="1 to xs:integer(ixsl:get($element, 'childNodes.length'))">
+            <xsl:sequence select="ixsl:call($parent, 'insertBefore', [ ixsl:get($element, 'firstChild'), $element ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:sequence select="ixsl:call($parent, 'removeChild', [ $element ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:sequence select="ixsl:call($parent, 'normalize', [])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <!-- wrap a range in a fresh element; on boundary-crossing selections flash and return nothing -->
+    <xsl:template name="local:wrap-range" as="element()?">
+        <xsl:param name="range"/>
+        <xsl:param name="name" as="xs:string"/>
+
+        <xsl:variable name="element" as="element()" select="ixsl:call(ixsl:page(), 'createElement', [ $name ])"/>
+        <xsl:try>
+            <xsl:sequence select="ixsl:call($range, 'surroundContents', [ $element ])[current-date() lt xs:date('2000-01-01')]"/>
+            <!-- surroundContents leaves the selection undefined; re-select the wrapped
+                 contents so subsequent toggles resolve their target -->
+            <xsl:sequence select="ixsl:call(local:selection(), 'selectAllChildren',
+                [ $element ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="$element"/>
+            <xsl:catch errors="*">
+                <xsl:call-template name="local:show-flash">
+                    <xsl:with-param name="range" select="$range"/>
+                </xsl:call-template>
+            </xsl:catch>
+        </xsl:try>
+    </xsl:template>
+
+    <xsl:template match="button[tokenize(@class) = 'remove-action']" mode="ixsl:onclick">
+        <xsl:for-each select="ixsl:get(local:editor-state(), 'editingSpan')">
+            <xsl:call-template name="local:push-undo"/>
+            <xsl:choose>
+                <!-- a block carries its annotation on itself: strip the RDFa attributes
+                     but keep the block (unwrapping would dissolve the heading/paragraph) -->
+                <xsl:when test="local:block-of(.) is .">
+                    <xsl:variable name="element" select="."/>
+                    <xsl:for-each select="'about', 'typeof', 'property', 'resource', 'content', 'datatype', 'lang', 'xml:lang'">
+                        <ixsl:remove-attribute name="{.}" object="$element"/>
+                    </xsl:for-each>
+                </xsl:when>
+                <!-- an inline annotation is a wrapper element: unwrap it -->
+                <xsl:otherwise>
+                    <xsl:call-template name="local:unwrap-element">
+                        <xsl:with-param name="element" select="."/>
+                    </xsl:call-template>
+                </xsl:otherwise>
+            </xsl:choose>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:for-each>
+        <xsl:call-template name="local:hide-overlay"/>
+    </xsl:template>
+
+    <xsl:template match="button[tokenize(@class) = 'cancel-action']" mode="ixsl:onclick">
+        <xsl:call-template name="local:hide-overlay"/>
+    </xsl:template>
+
+    <!-- brief red flash over an invalid selection, in page coordinates so it scrolls with the text -->
+    <xsl:template name="local:show-flash">
+        <xsl:param name="range"/>
+
+        <xsl:variable name="rect" select="ixsl:call($range, 'getBoundingClientRect', [])"/>
+        <xsl:variable name="scroll-x" as="xs:double" select="ixsl:get(ixsl:window(), 'scrollX')"/>
+        <xsl:variable name="scroll-y" as="xs:double" select="ixsl:get(ixsl:window(), 'scrollY')"/>
+        <xsl:for-each select="ixsl:page()//body">
+            <xsl:result-document href="?." method="ixsl:append-content">
+                <div id="selection-flash" class="invalid-selection-flash"
+                    style="position: absolute; pointer-events: none; z-index: 9999; left: {ixsl:get($rect, 'left') + $scroll-x}px; top: {ixsl:get($rect, 'top') + $scroll-y}px; width: {ixsl:get($rect, 'width')}px; height: {ixsl:get($rect, 'height')}px;"/>
+            </xsl:result-document>
+        </xsl:for-each>
+        <ixsl:promise select="ixsl:sleep(1200) => ixsl:then(local:hide-flash#1)"/>
+    </xsl:template>
+
+    <xsl:function name="local:hide-flash" as="empty-sequence()" ixsl:updating="yes">
+        <xsl:param name="ignored" as="item()?"/>
+
+        <xsl:for-each select="id('selection-flash', ixsl:page())">
+            <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:function>
+
+    <!-- the editor renders its own output modal (host pages provide only content regions) -->
+    <xsl:template name="local:init-annotate">
+        <xsl:for-each select="ixsl:page()//body">
+            <xsl:result-document href="?." method="ixsl:append-content">
+                <div id="output-modal" class="rdfa-editor-ui" style="display: none;">
+                    <div class="modal-content">
+                        <span class="modal-close">&#215;</span>
+                        <h3 id="output-title">Output</h3>
+                        <button id="output-download" type="button" style="display: none;">Download</button>
+                        <pre id="output-content"/>
+                    </div>
+                </div>
+            </xsl:result-document>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- shared output modal (Extract RDF / View source / lint issues); callers
+         passing $filename get a Download button (hidden otherwise) -->
+    <xsl:template name="local:show-output">
+        <xsl:param name="title" as="xs:string"/>
+        <xsl:param name="text" as="xs:string"/>
+        <xsl:param name="filename" as="xs:string?"/>
+        <xsl:param name="media-type" as="xs:string?"/>
+
+        <xsl:for-each select="id('output-title', ixsl:page())">
+            <ixsl:set-property name="textContent" select="$title" object="."/>
+        </xsl:for-each>
+        <xsl:for-each select="id('output-content', ixsl:page())">
+            <ixsl:set-property name="textContent" select="$text" object="."/>
+        </xsl:for-each>
+        <xsl:for-each select="id('output-download', ixsl:page())">
+            <xsl:choose>
+                <xsl:when test="exists($filename)">
+                    <ixsl:set-attribute name="data-filename" select="$filename"/>
+                    <ixsl:set-attribute name="data-media-type" select="($media-type, 'text/plain')[1]"/>
+                    <ixsl:set-style name="display" select="'inline-block'"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <ixsl:set-style name="display" select="'none'"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:for-each>
+        <xsl:for-each select="id('output-modal', ixsl:page())">
+            <ixsl:set-style name="display" select="'flex'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- client-side file download: the shown text becomes a Blob clicked through
+         an ephemeral object-URL anchor - no server involved, so it works on any
+         static hosting (gh-pages included) -->
+    <xsl:template match="button[@id = 'output-download']" mode="ixsl:onclick">
+        <xsl:variable name="js-function" select="ixsl:eval('(function (text, type, filename) { var url = URL.createObjectURL(new Blob([ text ], { type: type })); var a = document.createElement(''a''); a.href = url; a.download = filename; document.body.appendChild(a); a.click(); a.remove(); setTimeout(function () { URL.revokeObjectURL(url); }, 1000); })')"/>
+        <xsl:sequence select="ixsl:call($js-function, 'call',
+            [ (), ixsl:get(id('output-content', ixsl:page()), 'textContent'), string(@data-media-type), string(@data-filename) ])
+            [current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <!-- extract RDF/XML from the page and display it in the modal, grouped one
+         rdf:Description per subject (via local:group-triples) for readability -->
+    <xsl:template match="button[@id = 'parse-rdf']" mode="ixsl:onclick">
+        <xsl:variable name="rdf" as="element(rdf:RDF)">
+            <xsl:call-template name="extract-rdfa">
+                <xsl:with-param name="doc" select="ixsl:page()"/>
+                <xsl:with-param name="base" select="local:document-uri()"/>
+            </xsl:call-template>
+        </xsl:variable>
+
+        <xsl:call-template name="local:show-output">
+            <xsl:with-param name="title" select="'Extracted RDF/XML'"/>
+            <xsl:with-param name="text" select="serialize(local:group-triples($rdf), map{ 'method': 'xml', 'indent': true() })"/>
+            <xsl:with-param name="filename" select="'content.rdf'"/>
+            <xsl:with-param name="media-type" select="'application/rdf+xml'"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <xsl:template match="span[tokenize(@class) = 'modal-close']" mode="ixsl:onclick">
+        <xsl:for-each select="id('output-modal', ixsl:page())">
+            <ixsl:set-style name="display" select="'none'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- clicking the backdrop (not the content) closes the modal -->
+    <xsl:template match="div[@id = 'output-modal']" mode="ixsl:onclick">
+        <xsl:if test="ixsl:call(ixsl:get(ixsl:event(), 'target'), 'isSameNode', [ . ])">
+            <ixsl:set-style name="display" select="'none'"/>
+        </xsl:if>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/blocks.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/blocks.xsl
new file mode 100644
index 000000000..556733f1f
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/blocks.xsl
@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    Object blocks: RDF-defined blocks embedded in content as self-describing
+    RDFa placeholders, in two kinds:
+
+    - a DEFINED block - a div whose @typeof matches $object-block-types,
+      carrying its defining triples as property spans (LinkedDataHub queries,
+      charts, views, ...);
+    - a REFERENCE block - an empty div whose @about names a resource OUTSIDE
+      this document by an absolute URI. No wrapper node, no rdf:value
+      indirection (the v5 ldh:Object idiom is obsolete per the v6 document
+      format): naming the resource IS the reference, placement is carried by
+      the XHTML structure, and the RDFa extraction of an empty div[@about] is
+      zero triples. Blocks defined in the document keep fragment @about values
+      (they are document parts); an absolute non-document @about therefore
+      unambiguously reads as "dereference and render".
+
+    The editor treats both as atomic islands: never a text host, focusable
+    like a block image, a hard boundary for merges and cross-host deletes. The
+    visual rendering is injected into an ephemeral div[@data-role='rendering']
+    child (canonicalization-stripped, extractor-skipped), so the placeholder
+    round-trips byte-identically wherever the content model admits a div.
+
+    The core knows no block vocabulary: $object-block-types is empty and the
+    local:render-island mode ships a neutral placeholder card. An extension
+    stylesheet (src/ldh-blocks.xsl here; LinkedDataHub's client.xsl in
+    production) imports the editor, re-declares the param and overrides the mode
+    per @typeof - and for reference blocks by dereferencing the @about URI -
+    with real (async) renderers - see the render-hook contract below.
+-->
+
+    <!-- island classes: absolute class IRIs matched against tokenize(@typeof).
+         Empty in core - re-declared at higher import precedence by an extension
+         entry (a same-precedence duplicate would be static error XTSE0630) -->
+    <xsl:param name="object-block-types" as="xs:string*" select="()"/>
+
+    <!-- a reference block: an effectively-empty div (ephemeral children and
+         whitespace only) whose @about is an absolute URI naming a different
+         document than the page. String tests only - no resolve-uri, so a
+         malformed @about can never error out of a predicate that runs on every
+         gesture; relative/fragment @about values (document parts, or the
+         about-relative lint case) are never islands -->
+    <xsl:function name="local:reference-block" as="xs:boolean">
+        <xsl:param name="element" as="element()?"/>
+        <xsl:sequence select="exists($element[self::div]
+            [matches(normalize-space(@about), '^[A-Za-z][A-Za-z0-9+.\-]*:')]
+            [substring-before(normalize-space(@about) || '#', '#') ne local:document-uri()]
+            [empty((node() except *[@data-role])[not(self::text()[not(normalize-space())])])])"/>
+    </xsl:function>
+
+    <!-- THE island predicate: every island decision (init, navigation, merge
+         boundaries, the delete machine, undo re-render) routes through here -->
+    <xsl:function name="local:island" as="xs:boolean">
+        <xsl:param name="element" as="element()?"/>
+        <xsl:sequence select="exists($element[self::div][tokenize(@typeof) = $object-block-types])
+            or local:reference-block($element)"/>
+    </xsl:function>
+
+    <!-- the render hook. Context item = the island div. Contract: inject exactly
+         one div[@data-role='rendering'] as the island's last child via
+         local:replace-rendering - async renderers only in the completion callback
+         (loading state = the ephemeral rdfa-editor-loading class), so an island
+         without a rendering div always reads as "render needed" (the undo-restore
+         re-render pass keys on that); never touch the RDFa spans; never push undo
+         (rendering is ephemeral by construction); idempotent (replace, not append) -->
+    <xsl:mode name="local:render-island" on-no-match="deep-skip"/>
+
+    <!-- neutral default: a static card naming the block's type (a reference
+         block has none - it reads as 'Resource') and resource. Extension
+         templates matching per @typeof / reference win on import precedence -->
+    <xsl:template match="*" mode="local:render-island">
+        <xsl:variable name="type" as="xs:string?"
+            select="(tokenize(@typeof)[. = $object-block-types], tokenize(@typeof), 'Resource')[1]"/>
+        <xsl:call-template name="local:replace-rendering">
+            <xsl:with-param name="island" select="."/>
+            <xsl:with-param name="content">
+                <div class="rdfa-editor-island-card">
+                    <strong><xsl:value-of select="replace($type, '^.*[#/]', '')"/></strong>
+                    <xsl:for-each select="(@resource, @about)[1]">
+                        <xsl:text> </xsl:text>
+                        <code><xsl:value-of select="."/></code>
+                    </xsl:for-each>
+                </div>
+            </xsl:with-param>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- idempotent rendering-container swap: the only writer of the rendering div -->
+    <xsl:template name="local:replace-rendering">
+        <xsl:param name="island" as="element()"/>
+        <xsl:param name="content" as="node()*"/>
+        <xsl:for-each select="$island/*[@data-role = 'rendering']">
+            <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:variable name="rendering" as="element()" select="local:element('div')"/>
+        <xsl:for-each select="$rendering">
+            <ixsl:set-attribute name="data-role" select="'rendering'"/>
+        </xsl:for-each>
+        <!-- html method: XML's self-closing tags read as OPEN tags to the HTML
+             fragment parser and swallow following siblings -->
+        <ixsl:set-property name="innerHTML"
+            select="serialize($content, map{ 'method': 'html' })" object="$rendering"/>
+        <xsl:sequence select="ixsl:call($island, 'appendChild', [ $rendering ])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <!-- ............................ extension hooks ............................ -->
+
+    <!-- no-op extension points, overridden at higher import precedence: dialogs
+         appended to body at init, toolbar Insert-group buttons, slash-menu items,
+         and slash-command dispatch for those items -->
+    <xsl:template name="local:render-extra-dialogs"/>
+
+    <xsl:template name="local:render-extra-insert-buttons"/>
+
+    <xsl:template name="local:render-extra-slash-items"/>
+
+    <xsl:template name="local:run-extra-slash-command">
+        <xsl:param name="command" as="xs:string"/>
+        <xsl:param name="host" as="element()?"/>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/canonical-xhtml.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/canonical-xhtml.xsl
new file mode 100644
index 000000000..50cb11395
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/canonical-xhtml.xsl
@@ -0,0 +1,411 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:cm="urn:rdfa-editor:content-model"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+exclude-result-prefixes="#all"
+version="3.0">
+
+<!--
+    Canonical XHTML+RDFa serialization form. Pure XSLT 3.0 - no ixsl: dependencies,
+    so it runs headless for testing (see tests/run-tests.sh), but NOT standalone-
+    compilable: it consults content-model.xsl (cm:*) - include/import both together
+    (index.xsl does; the test driver is tests/canonical-driver.xsl).
+
+    Two passes in a fixed order:
+    1. mode="canonical"     strips editing ephemera per the LDH v6 convention
+                            (everything carrying @data-role is removable by
+                            construction), sanitizes, and normalizes browser mess.
+                            Nesting analysis must never see chrome, so this runs first.
+    2. mode="cm-normalize"  coerces the result to the XHTML Strict content model
+                            (blockquote is block-only, p is inline-only, ul holds
+                            only li, ...), always RDFa-preserving. The load-init
+                            path (edit.xsl) runs this pass ALONE on host content.
+
+    The entry template finally applies the editor contract - region children are
+    blocks - which is deliberately not part of the DTD transcription.
+    RDFa attributes and pre whitespace are never touched; text is never reflowed.
+-->
+
+    <!-- serialization is the caller's job (view-source runs exclusive XML c14n via
+         local:canonicalize-xml in edit.xsl, tests use -o output); no xsl:output
+         here - it would conflict with the including stylesheet's -->
+    <xsl:mode name="canonical" on-no-match="shallow-copy"/>
+    <xsl:mode name="cm-normalize" on-no-match="shallow-copy"/>
+
+    <xsl:template name="canonical-xhtml">
+        <xsl:param name="content" as="element()" select="/*"/>
+        <xsl:variable name="pass1" as="node()*">
+            <xsl:apply-templates select="$content" mode="canonical"/>
+        </xsl:variable>
+        <xsl:for-each select="$pass1/self::*">
+            <xsl:copy>
+                <xsl:copy-of select="@*"/>
+                <!-- editor contract (not the DTD's rule): region children are blocks -->
+                <xsl:sequence select="cm:wrap-inline-runs(cm:normalize(node()), 'p')"/>
+            </xsl:copy>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- -im:canonical entry for CLI fallback -->
+    <xsl:template match="/" mode="canonical">
+        <xsl:call-template name="canonical-xhtml"/>
+    </xsl:template>
+
+    <!-- ................ shared coercion primitives ................ -->
+
+    <xsl:function name="cm:normalize" as="node()*">
+        <xsl:param name="nodes" as="node()*"/>
+        <xsl:apply-templates select="$nodes" mode="cm-normalize"/>
+    </xsl:function>
+
+    <!-- the wrapper is inline-only, so only text and KNOWN-INLINE elements may be
+         pulled into it; everything else passes through bare - blocks and ephemera
+         by design, and both unknown elements (an RDFa-bearing article) and known
+         non-inline strays (an li outside any list) stay put for lint to report
+         rather than being wrapped into fresh invalid nesting. Adjacent runs with
+         substance (an element or non-whitespace text) get wrapped; whitespace-only
+         runs between blocks stay bare. The one grouping axis shared by the entry
+         coercion, N2 and the paste handler (edit.xsl) -->
+    <xsl:function name="cm:wrap-inline-runs" as="node()*">
+        <xsl:param name="kids" as="node()*"/>
+        <xsl:param name="wrapper" as="xs:string"/>
+        <xsl:for-each-group select="$kids"
+                group-adjacent="boolean(self::*[not(cm:inline(local-name(.))) or @data-role])">
+            <xsl:choose>
+                <xsl:when test="current-grouping-key()">
+                    <xsl:sequence select="current-group()"/>
+                </xsl:when>
+                <xsl:when test="exists(current-group()[self::* or self::text()[normalize-space()]])">
+                    <xsl:element name="{$wrapper}">
+                        <xsl:sequence select="current-group()"/>
+                    </xsl:element>
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:sequence select="current-group()"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:for-each-group>
+    </xsl:function>
+
+    <!-- element-only containers (ul, dl, tr): allowed/@data-role children pass,
+         adjacent runs of anything else get wrapped in the container's item kind -->
+    <xsl:function name="cm:coerce-children" as="node()*">
+        <xsl:param name="kids" as="node()*"/>
+        <xsl:param name="allowed" as="xs:string*"/>
+        <xsl:param name="wrapper" as="xs:string"/>
+        <xsl:for-each-group select="$kids"
+                group-adjacent="boolean(self::*[local-name() = $allowed or @data-role])">
+            <xsl:choose>
+                <xsl:when test="current-grouping-key()">
+                    <xsl:sequence select="current-group()"/>
+                </xsl:when>
+                <xsl:when test="exists(current-group()[self::* or self::text()[normalize-space()]])">
+                    <xsl:element name="{$wrapper}">
+                        <xsl:sequence select="current-group()"/>
+                    </xsl:element>
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:sequence select="current-group()"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:for-each-group>
+    </xsl:function>
+
+    <!-- ................ pass 1: mode="canonical" ................ -->
+
+    <!-- C1: everything carrying @data-role is ephemeral (chrome, rendering) -->
+    <xsl:template match="*[@data-role]" mode="canonical" priority="2"/>
+
+    <!-- S1: active/embedding elements never survive into stored content (the
+         canonical form is the sanitization boundary for multi-user content) -->
+    <xsl:template match="script | style | iframe | object | embed | applet
+        | form | input | button | select | textarea | link | meta | base" mode="canonical" priority="3"/>
+
+    <!-- S1b: comments and processing instructions are noise (Word/HTML paste junk) -->
+    <xsl:template match="comment() | processing-instruction()" mode="canonical"/>
+
+    <!-- S2: event-handler attributes are always stripped -->
+    <xsl:template match="@*[matches(local-name(), '^on', 'i')]" mode="canonical"/>
+
+    <!-- S3: scripting/data URL schemes are dropped from link and media targets
+         (the attribute, not the element); data:image/* remains valid in @src -->
+    <xsl:template match="@href[matches(normalize-space(.), '^(javascript|vbscript|data):', 'i')]
+        | @src[matches(normalize-space(.), '^(javascript|vbscript):', 'i')]
+        | @src[matches(normalize-space(.), '^data:', 'i')][not(matches(normalize-space(.), '^data:image/', 'i'))]"
+        mode="canonical"/>
+
+    <!-- C2: editing-state and styling-hook attributes never serialize (tabindex is
+         injected to make block images focusable navigation islands) -->
+    <xsl:template match="@contenteditable | @draggable | @class | @id | @style | @tabindex
+        | @*[starts-with(name(), 'aria-')] | @*[starts-with(name(), 'data-')]" mode="canonical"/>
+
+    <!-- C3/C4: presentational aliases to their semantic elements -->
+    <xsl:template match="b" mode="canonical">
+        <strong>
+            <xsl:apply-templates select="@* | node()" mode="#current"/>
+        </strong>
+    </xsl:template>
+
+    <xsl:template match="i" mode="canonical">
+        <em>
+            <xsl:apply-templates select="@* | node()" mode="#current"/>
+        </em>
+    </xsl:template>
+
+    <!-- C5: legacy presentational wrappers are dropped, content kept -->
+    <xsl:template match="font | u" mode="canonical">
+        <xsl:apply-templates select="node()" mode="#current"/>
+    </xsl:template>
+
+    <!-- C6: a span left without RDFa or language attributes carries no meaning -->
+    <xsl:template match="span[not(@property or @about or @typeof or @resource or @content
+            or @datatype or @lang or @xml:lang)]" mode="canonical">
+        <xsl:apply-templates select="node()" mode="#current"/>
+    </xsl:template>
+
+    <!-- C7a: browser-generated attributeless div with inline content becomes a
+         paragraph; RDFa-bearing divs pass -->
+    <xsl:template match="div[not(@property or @about or @typeof or @resource)]
+            [empty(*[cm:block(local-name(.))])]" mode="canonical">
+        <p>
+            <xsl:apply-templates select="@* | node()" mode="#current"/>
+        </p>
+    </xsl:template>
+
+    <!-- C7b: an attributeless div holding blocks is a semantics-free grouping
+         wrapper (p may not contain blocks) - unwrap to its children; stray inline
+         residue is re-coerced by pass 2 in the parent's context -->
+    <xsl:template match="div[not(@property or @about or @typeof or @resource)]
+            [exists(*[cm:block(local-name(.))])]" mode="canonical">
+        <xsl:apply-templates select="node()" mode="#current"/>
+    </xsl:template>
+
+    <!-- C11: the editing-DOM run wrapper (edit.xsl wraps stray inline runs of mixed
+         flow containers in p.rdfa-editor-run so they stay editable) unwraps, so
+         <li>text<ul>...</ul></li> round-trips byte-identical. An annotated wrapper
+         has become real content and stays a p -->
+    <xsl:template match="p[contains-token(@class, 'rdfa-editor-run')]
+            [not(@property or @about or @typeof or @resource or @content or @datatype)]"
+        mode="canonical" priority="1">
+        <xsl:apply-templates select="node()" mode="#current"/>
+    </xsl:template>
+
+    <!-- C12: HTML5 sectioning wrappers have no XHTML Strict equivalent - unwrap
+         clipboard/host wrappers, keep RDFa-bearing ones (dropping them would lose
+         triples; lint reports them as unknown-element) -->
+    <xsl:template match="(section | article | main | aside | header | footer | nav | hgroup)
+            [not(@property or @about or @typeof or @resource)]" mode="canonical">
+        <xsl:apply-templates select="node()" mode="#current"/>
+    </xsl:template>
+
+    <!-- C8: empty non-RDFa inline elements are junk; RDFa-bearing empties
+         (hidden <span property resource/> definitions) are kept by C6's predicates -->
+    <xsl:template match="(strong | em | a | code)[not(normalize-space(.))][not(.//img)]
+            [not(@property or @about or @typeof or @resource or @content)]" mode="canonical" priority="1"/>
+
+    <!-- C10: line structure inside pre is text, not markup -->
+    <xsl:template match="br[ancestor::pre]" mode="canonical" priority="1">
+        <xsl:text>&#10;</xsl:text>
+    </xsl:template>
+
+    <!-- C9: a trailing <br> is a caret placeholder, not content -->
+    <xsl:template match="br[not(following-sibling::node()[self::* or self::text()[normalize-space()]])]"
+        mode="canonical"/>
+
+    <!-- ................ pass 2: mode="cm-normalize" ................ -->
+
+    <!-- N0: ephemera are placed by the editor, not judged by the DTD (the load-init
+         path runs this pass alone, where chrome and rendering subtrees still exist) -->
+    <xsl:template match="*[@data-role]" mode="cm-normalize" priority="2">
+        <xsl:copy-of select="."/>
+    </xsl:template>
+
+    <!-- N1: blocks inside an inline-only element (p, h1-h6, dt, caption, pre, inlines).
+         Matches EVERY inline-only element and decides on the PROCESSED children, so
+         blocks surfaced by inner splits are handled in the same bottom-up pass (one
+         invocation reaches the fixed point). An RDFa-bearing parent stays whole -
+         its block children demote to inline via mode="cm-demote" (recursive, all
+         attributes kept), so the extracted literal and triples are unchanged. A
+         plain parent splits around its block children; inline runs keep a shell
+         copying ALL attributes (safe: this branch is non-RDFa by construction, so
+         nothing duplicates a triple - an <a href> split by a block keeps its target
+         on both halves); whitespace-only residue between blocks drops -->
+    <xsl:template match="*[cm:inline-only(local-name(.))]" mode="cm-normalize">
+        <xsl:variable name="name" as="xs:string" select="local-name(.)"/>
+        <xsl:variable name="kids" as="node()*">
+            <xsl:apply-templates select="node()" mode="#current"/>
+        </xsl:variable>
+        <xsl:choose>
+            <xsl:when test="empty($kids/self::*[cm:block(local-name(.))])">
+                <xsl:copy>
+                    <xsl:copy-of select="@*"/>
+                    <xsl:sequence select="$kids"/>
+                </xsl:copy>
+            </xsl:when>
+            <xsl:when test="@property or @about or @typeof or @resource or @content or @datatype">
+                <xsl:copy>
+                    <xsl:copy-of select="@*"/>
+                    <xsl:apply-templates select="$kids" mode="cm-demote"/>
+                </xsl:copy>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="attributes" as="attribute()*" select="@*"/>
+                <xsl:for-each-group select="$kids"
+                        group-adjacent="boolean(self::*[cm:block(local-name(.))])">
+                    <xsl:choose>
+                        <xsl:when test="current-grouping-key()">
+                            <xsl:sequence select="current-group()"/>
+                        </xsl:when>
+                        <xsl:when test="exists(current-group()[self::* or self::text()[normalize-space()]])">
+                            <xsl:element name="{$name}">
+                                <xsl:copy-of select="$attributes"/>
+                                <xsl:sequence select="current-group()"/>
+                            </xsl:element>
+                        </xsl:when>
+                        <xsl:otherwise/>
+                    </xsl:choose>
+                </xsl:for-each-group>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- inline demotion for content preserved inside an RDFa-bearing inline-only
+         element: every known non-inline element renames to span (all attributes
+         kept), recursively - a demoted list becomes nested spans, never a bare li
+         inside a span. Text, inline and unknown elements pass through with their
+         children demoted likewise -->
+    <xsl:mode name="cm-demote" on-no-match="shallow-copy"/>
+
+    <xsl:template match="*[cm:known(local-name(.))][not(cm:inline(local-name(.)))]" mode="cm-demote">
+        <span>
+            <xsl:copy-of select="@*"/>
+            <xsl:apply-templates select="node()" mode="#current"/>
+        </span>
+    </xsl:template>
+
+    <!-- N2: blockquote (and noscript) is block-only per Strict - stray text/inline
+         runs become paragraphs; RDFa attributes on the container are untouched -->
+    <xsl:template match="blockquote | noscript" mode="cm-normalize">
+        <xsl:variable name="kids" as="node()*">
+            <xsl:apply-templates select="node()" mode="#current"/>
+        </xsl:variable>
+        <xsl:copy>
+            <xsl:copy-of select="@*"/>
+            <xsl:sequence select="cm:wrap-inline-runs($kids, 'p')"/>
+        </xsl:copy>
+    </xsl:template>
+
+    <!-- N3: ul/ol hold only li - stray children become item content (li is flow) -->
+    <xsl:template match="ul | ol" mode="cm-normalize">
+        <xsl:variable name="kids" as="node()*">
+            <xsl:apply-templates select="node()" mode="#current"/>
+        </xsl:variable>
+        <xsl:copy>
+            <xsl:copy-of select="@*"/>
+            <xsl:sequence select="cm:coerce-children($kids, 'li', 'li')"/>
+        </xsl:copy>
+    </xsl:template>
+
+    <!-- N4: dl holds only dt/dd - strays become dd content (dd is flow, dt is not) -->
+    <xsl:template match="dl" mode="cm-normalize">
+        <xsl:variable name="kids" as="node()*">
+            <xsl:apply-templates select="node()" mode="#current"/>
+        </xsl:variable>
+        <xsl:copy>
+            <xsl:copy-of select="@*"/>
+            <xsl:sequence select="cm:coerce-children($kids, ('dt', 'dd'), 'dd')"/>
+        </xsl:copy>
+    </xsl:template>
+
+    <!-- N5: tr holds only th/td - strays become cell content (td is flow) -->
+    <xsl:template match="tr" mode="cm-normalize">
+        <xsl:variable name="kids" as="node()*">
+            <xsl:apply-templates select="node()" mode="#current"/>
+        </xsl:variable>
+        <xsl:copy>
+            <xsl:copy-of select="@*"/>
+            <xsl:sequence select="cm:coerce-children($kids, ('th', 'td'), 'td')"/>
+        </xsl:copy>
+    </xsl:template>
+
+    <!-- N5b: table sections hold only tr - a stray cell run keeps its cells in a
+         fresh row; anything else becomes a one-cell row -->
+    <xsl:template match="thead | tbody | tfoot" mode="cm-normalize">
+        <xsl:variable name="kids" as="node()*">
+            <xsl:apply-templates select="node()" mode="#current"/>
+        </xsl:variable>
+        <xsl:copy>
+            <xsl:copy-of select="@*"/>
+            <xsl:for-each-group select="$kids"
+                    group-adjacent="boolean(self::*[local-name() = 'tr' or @data-role])">
+                <xsl:choose>
+                    <xsl:when test="current-grouping-key()">
+                        <xsl:sequence select="current-group()"/>
+                    </xsl:when>
+                    <xsl:when test="exists(current-group()[self::* or self::text()[normalize-space()]])">
+                        <tr>
+                            <xsl:choose>
+                                <xsl:when test="every $n in current-group()[self::*]
+                                        satisfies local-name($n) = ('th', 'td')">
+                                    <xsl:sequence select="current-group()"/>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <td>
+                                        <xsl:sequence select="current-group()"/>
+                                    </td>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                        </tr>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:sequence select="current-group()"/>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:for-each-group>
+        </xsl:copy>
+    </xsl:template>
+
+    <!-- N6: children a table cannot hold are hoisted before it (mirrors browser
+         foster parenting); whitespace and ephemera stay put -->
+    <xsl:template match="table" mode="cm-normalize">
+        <xsl:variable name="kids" as="node()*">
+            <xsl:apply-templates select="node()" mode="#current"/>
+        </xsl:variable>
+        <xsl:variable name="valid" as="xs:string*"
+            select="'caption', 'col', 'colgroup', 'thead', 'tfoot', 'tbody', 'tr'"/>
+        <xsl:sequence select="$kids[(self::*[not(local-name() = $valid)][not(@data-role)])
+            or self::text()[normalize-space()]]"/>
+        <xsl:copy>
+            <xsl:copy-of select="@*"/>
+            <xsl:sequence select="$kids[self::*[local-name() = $valid or @data-role]
+                or self::text()[not(normalize-space())]]"/>
+        </xsl:copy>
+    </xsl:template>
+
+    <!-- N7: Appendix B pre exclusions, text-preserving: size/position markup
+         unwraps, replaced objects fall back to their alternative text -->
+    <xsl:template match="(big | small | sub | sup)[ancestor::pre]" mode="cm-normalize" priority="1">
+        <xsl:apply-templates select="node()" mode="#current"/>
+    </xsl:template>
+
+    <xsl:template match="(img | object)[ancestor::pre]" mode="cm-normalize" priority="1">
+        <xsl:value-of select="@alt"/>
+    </xsl:template>
+
+    <!-- N8: Appendix B nesting prohibitions - the inner element keeps all its
+         attributes (RDFa preserved; a dead @href is harmless) under a valid name -->
+    <xsl:template match="a[ancestor::a]" mode="cm-normalize" priority="1">
+        <span>
+            <xsl:copy-of select="@*"/>
+            <xsl:apply-templates select="node()" mode="#current"/>
+        </span>
+    </xsl:template>
+
+    <xsl:template match="label[ancestor::label]" mode="cm-normalize" priority="1">
+        <xsl:apply-templates select="node()" mode="#current"/>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/content-model.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/content-model.xsl
new file mode 100644
index 000000000..6f8b3ae3f
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/content-model.xsl
@@ -0,0 +1,192 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:map="http://www.w3.org/2005/xpath-functions/map"
+xmlns:cm="urn:rdfa-editor:content-model"
+exclude-result-prefixes="#all"
+version="3.0">
+
+<!--
+    XHTML content model as data: a 1:1 transcription of the XHTML 1.0 Strict DTD
+    (Second Edition, REC-xhtml1-20020801, Appendix A.1) parameter entities and
+    element declarations, plus the Appendix B element prohibitions, extended with
+    HTML5 figure/figcaption (WHATWG HTML 4.4.12-4.4.13) - the one editor block
+    kind XHTML 1.0 lacks.
+
+    Pure XSLT 3.0, include-free, namespace-agnostic (all predicates take element
+    names, callers pass local-name()). The single source of truth for nesting
+    decisions across the editor: editability init and the keyboard state machines
+    (edit.xsl), boundary normalization (canonical-xhtml.xsl) and nesting lint
+    (lint-xhtml.xsl) all consult these predicates, so their verdicts cannot drift
+    apart. The editor contract "region children are blocks" is deliberately NOT
+    encoded here - it is not the DTD's rule.
+-->
+
+    <!-- ................. Appendix A.1 parameter entities ................. -->
+
+    <xsl:variable name="cm:special.pre"  as="xs:string*" select="'br', 'span', 'bdo', 'map'"/>
+    <xsl:variable name="cm:special"      as="xs:string*" select="$cm:special.pre, 'object', 'img'"/>
+    <xsl:variable name="cm:fontstyle"    as="xs:string*" select="'tt', 'i', 'b', 'big', 'small'"/>
+    <xsl:variable name="cm:phrase"       as="xs:string*" select="'em', 'strong', 'dfn', 'code', 'q',
+        'samp', 'kbd', 'var', 'cite', 'abbr', 'acronym', 'sub', 'sup'"/>
+    <xsl:variable name="cm:inline.forms" as="xs:string*" select="'input', 'select', 'textarea', 'label', 'button'"/>
+    <xsl:variable name="cm:misc.inline"  as="xs:string*" select="'ins', 'del', 'script'"/>
+    <xsl:variable name="cm:misc"         as="xs:string*" select="'noscript', $cm:misc.inline"/>
+    <xsl:variable name="cm:inline"       as="xs:string*" select="'a', $cm:special, $cm:fontstyle,
+        $cm:phrase, $cm:inline.forms"/>
+    <xsl:variable name="cm:heading"      as="xs:string*" select="'h1', 'h2', 'h3', 'h4', 'h5', 'h6'"/>
+    <xsl:variable name="cm:lists"        as="xs:string*" select="'ul', 'ol', 'dl'"/>
+    <xsl:variable name="cm:blocktext"    as="xs:string*" select="'pre', 'hr', 'blockquote', 'address'"/>
+    <!-- %block; plus the figure extension (figure is flow/block content in HTML5,
+         so it participates wherever %block; appears: regions, blockquote, li, td) -->
+    <xsl:variable name="cm:block-set"    as="xs:string*" select="'p', $cm:heading, 'div', $cm:lists,
+        $cm:blocktext, 'fieldset', 'table', 'figure'"/>
+
+    <!-- content-model child sets: %Inline;, %Block;, %Flow;, %a.content;, %pre.content; -->
+    <xsl:variable name="cm:Inline-children" as="xs:string*" select="$cm:inline, $cm:misc.inline"/>
+    <xsl:variable name="cm:Block-children"  as="xs:string*" select="$cm:block-set, 'form', $cm:misc"/>
+    <xsl:variable name="cm:Flow-children"   as="xs:string*" select="$cm:block-set, 'form', $cm:inline, $cm:misc"/>
+    <xsl:variable name="cm:a-children"      as="xs:string*" select="$cm:special, $cm:fontstyle,
+        $cm:phrase, $cm:inline.forms, $cm:misc.inline"/>
+    <xsl:variable name="cm:pre-children"    as="xs:string*" select="'a', $cm:fontstyle, $cm:phrase,
+        $cm:special.pre, $cm:misc.inline, $cm:inline.forms"/>
+
+    <!-- ................. per-element content models ................. -->
+
+    <!-- one entry per element declaration: allowed child element names ('children')
+         and whether #PCDATA is allowed ('text'). Empty 'children' + false 'text'
+         = EMPTY. Appendix B prohibitions are NOT folded in here (the DTD cannot
+         express them either) - see $cm:prohibitions.
+         map:merge over map:entry rather than one map literal: the SaxonJS 3
+         compiler fails an internal assertion on large nested map literals -->
+    <xsl:variable name="cm:model" as="map(xs:string, map(*))" select="map:merge((
+        (: %Inline; elements :)
+        ('p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'address', 'dt', 'caption', 'legend',
+            'label', 'span', 'bdo', $cm:fontstyle, $cm:phrase)
+            ! map:entry(., map{ 'children': $cm:Inline-children, 'text': true() }),
+        (: %Flow; elements :)
+        ('div', 'li', 'dd', 'td', 'th', 'ins', 'del')
+            ! map:entry(., map{ 'children': $cm:Flow-children, 'text': true() }),
+        (: restricted-inline and element-only content models :)
+        map:entry('pre',        map{ 'children': $cm:pre-children, 'text': true() }),
+        map:entry('a',          map{ 'children': $cm:a-children, 'text': true() }),
+        map:entry('blockquote', map{ 'children': $cm:Block-children, 'text': false() }),
+        map:entry('noscript',   map{ 'children': $cm:Block-children, 'text': false() }),
+        (: %form.content; = (%block; | %misc;)* - unlike %Block;, it excludes form
+           (forms must not be nested) :)
+        map:entry('form',       map{ 'children': ($cm:block-set, $cm:misc), 'text': false() }),
+        map:entry('fieldset',   map{ 'children': ('legend', $cm:Flow-children), 'text': true() }),
+        map:entry('button',     map{ 'children': ('p', $cm:heading, 'div', $cm:lists, $cm:blocktext,
+                                    'table', $cm:special, $cm:fontstyle, $cm:phrase, $cm:misc), 'text': true() }),
+        map:entry('object',     map{ 'children': ('param', $cm:Flow-children), 'text': true() }),
+        map:entry('map',        map{ 'children': ($cm:block-set, 'form', $cm:misc, 'area'), 'text': false() }),
+        map:entry('ul',         map{ 'children': 'li', 'text': false() }),
+        map:entry('ol',         map{ 'children': 'li', 'text': false() }),
+        map:entry('dl',         map{ 'children': ('dt', 'dd'), 'text': false() }),
+        map:entry('select',     map{ 'children': ('optgroup', 'option'), 'text': false() }),
+        map:entry('optgroup',   map{ 'children': 'option', 'text': false() }),
+        ('option', 'textarea', 'script')
+            ! map:entry(., map{ 'children': (), 'text': true() }),
+        (: table structure :)
+        map:entry('table',      map{ 'children': ('caption', 'col', 'colgroup', 'thead', 'tfoot', 'tbody', 'tr'), 'text': false() }),
+        ('thead', 'tfoot', 'tbody')
+            ! map:entry(., map{ 'children': 'tr', 'text': false() }),
+        map:entry('tr',         map{ 'children': ('th', 'td'), 'text': false() }),
+        map:entry('colgroup',   map{ 'children': 'col', 'text': false() }),
+        (: EMPTY elements :)
+        ('hr', 'br', 'img', 'param', 'area', 'col', 'input')
+            ! map:entry(., map{ 'children': (), 'text': false() }),
+        (: HTML5 figure extension :)
+        map:entry('figure',     map{ 'children': ($cm:Flow-children, 'figcaption'), 'text': true() }),
+        map:entry('figcaption', map{ 'children': $cm:Flow-children, 'text': true() })
+    ))"/>
+
+    <!-- Appendix B element prohibitions: element name -> ancestor element names
+         under which it must not appear, at any depth -->
+    <xsl:variable name="cm:prohibitions" as="map(xs:string, xs:string*)" select="map{
+        'a':        'a',
+        'img':      'pre',
+        'object':   'pre',
+        'big':      'pre',
+        'small':    'pre',
+        'sub':      'pre',
+        'sup':      'pre',
+        'input':    'button',
+        'select':   'button',
+        'textarea': 'button',
+        'label':    ('button', 'label'),
+        'button':   'button',
+        'form':     ('button', 'form'),
+        'fieldset': 'button',
+        'iframe':   'button',
+        'isindex':  'button'
+    }"/>
+
+    <!-- ................. predicates ................. -->
+
+    <xsl:function name="cm:known" as="xs:boolean">
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="map:contains($cm:model, $name)"/>
+    </xsl:function>
+
+    <!-- block-level per %block; (+ figure): the grouping axis for run wrapping -->
+    <xsl:function name="cm:block" as="xs:boolean">
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="$name = $cm:block-set"/>
+    </xsl:function>
+
+    <xsl:function name="cm:inline" as="xs:boolean">
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="$name = $cm:Inline-children"/>
+    </xsl:function>
+
+    <xsl:function name="cm:allows-child" as="xs:boolean">
+        <xsl:param name="parent" as="xs:string"/>
+        <xsl:param name="child" as="xs:string"/>
+        <xsl:sequence select="$child = $cm:model($parent)?children"/>
+    </xsl:function>
+
+    <xsl:function name="cm:allows-text" as="xs:boolean">
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="($cm:model($name)?text, false())[1]"/>
+    </xsl:function>
+
+    <!-- text-bearing element that admits no block children: p, h1-h6, dt, caption, pre, inlines -->
+    <xsl:function name="cm:inline-only" as="xs:boolean">
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="cm:allows-text($name) and not($cm:model($name)?children = $cm:block-set)"/>
+    </xsl:function>
+
+    <!-- mixed-content element admitting text AND blocks: li, dd, td, th, div, figure, figcaption -->
+    <xsl:function name="cm:flow" as="xs:boolean">
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="cm:allows-text($name) and $cm:model($name)?children = $cm:block-set"/>
+    </xsl:function>
+
+    <!-- element-only container: ul, ol, dl, blockquote, table structure - never a text host -->
+    <xsl:function name="cm:structural" as="xs:boolean">
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="cm:known($name) and not(cm:allows-text($name))
+            and exists($cm:model($name)?children)"/>
+    </xsl:function>
+
+    <xsl:function name="cm:prohibited-ancestors" as="xs:string*">
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="if (map:contains($cm:prohibitions, $name)) then $cm:prohibitions($name) else ()"/>
+    </xsl:function>
+
+    <!-- an element sits validly under its parent: child of a known parent must be
+         declared, and no Appendix B ancestor prohibition may apply. Unknown child
+         or parent names are not judged (lint reports them as unknown-element) -->
+    <xsl:function name="cm:valid-nesting" as="xs:boolean">
+        <xsl:param name="element" as="element()"/>
+        <xsl:variable name="name" as="xs:string" select="local-name($element)"/>
+        <xsl:sequence select="(empty($element/parent::*)
+                or not(cm:known(local-name($element/parent::*)))
+                or not(cm:known($name))
+                or cm:allows-child(local-name($element/parent::*), $name))
+            and empty($element/ancestor::*[local-name() = cm:prohibited-ancestors($name)])"/>
+    </xsl:function>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/edit.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/edit.xsl
new file mode 100644
index 000000000..9ad298734
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/edit.xsl
@@ -0,0 +1,2579 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:cm="urn:rdfa-editor:content-model"
+xmlns:local="urn:rdfa-editor:functions"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    Built-in XHTML editor: structured blocks under the #content container, each
+    individually contenteditable - block structure is never browser-editable.
+    Enter splits, Backspace at block start merges, the toolbar changes block types
+    and wraps inline strong/em/a (reusing the annotation machinery), blocks reorder
+    via the drag handle. Injected chrome carries data-role="chrome" and is stripped
+    by canonical-xhtml.xsl and skipped by the RDFa extractor.
+
+    Undo: native per-block typing undo works (Ctrl/Cmd+Z is never intercepted);
+    structural operations (split/merge/convert/move/delete) are not undoable in v1.
+-->
+
+    <!-- ................................ helpers ................................ -->
+
+    <!-- the page URI without its fragment: the base for RDFa resolution in the browser -->
+    <xsl:function name="local:document-uri" as="xs:string">
+        <xsl:sequence select="substring-before(ixsl:location() || '#', '#')"/>
+    </xsl:function>
+
+    <!-- editable regions are marked by convention with the rdfa-editor-content class
+         (host-page chrome: never serialized - the canonical form strips @class) -->
+    <xsl:function name="local:roots" as="element()*">
+        <xsl:sequence select="ixsl:page()//*[contains-token(@class, 'rdfa-editor-content')]"/>
+    </xsl:function>
+
+    <!-- where local:init-editing appends the toolbar; hosts without a nav element
+         override this to point at their own chrome -->
+    <xsl:function name="local:toolbar-host" as="element()*">
+        <xsl:sequence select="ixsl:page()//nav"/>
+    </xsl:function>
+
+    <xsl:function name="local:root-of" as="element()?">
+        <xsl:param name="node"/>
+        <xsl:sequence select="$node/ancestor-or-self::*[contains-token(@class, 'rdfa-editor-content')][1]"/>
+    </xsl:function>
+
+    <!-- the region the user is working in: selection first, then the last focused host -->
+    <xsl:function name="local:active-root" as="element()?">
+        <xsl:sequence select="(local:anchor-node() ! local:root-of(.),
+            ixsl:get(local:editor-state(), 'activeBlock') ! local:root-of(.), local:roots()[1])[1]"/>
+    </xsl:function>
+
+    <!-- the top-level block containing a node -->
+    <xsl:function name="local:block-of" as="element()?">
+        <xsl:param name="node"/>
+        <xsl:sequence select="$node/ancestor-or-self::*[parent::*[contains-token(@class, 'rdfa-editor-content')]][1]"/>
+    </xsl:function>
+
+    <!-- a block the drag layer picks up: a real %block element - never the
+         ephemeral run wrapper, never ephemera or anything inside it, never hr
+         (a void element cannot serialize the chrome span) - sitting where the
+         model places blocks: a region, a mixed flow container (li, dd, td, th,
+         div, figure, figcaption) or a blockquote. Top-level blocks satisfy this
+         by construction; every chrome and drag decision routes through here -->
+    <xsl:function name="local:draggable-block" as="xs:boolean">
+        <xsl:param name="element" as="element()?"/>
+        <xsl:sequence select="exists($element
+            [cm:block(local-name(.))][not(self::hr)]
+            [not(contains-token(@class, 'rdfa-editor-run'))]
+            [empty(ancestor-or-self::*[@data-role])]
+            [exists(local:root-of(.))]
+            [parent::*[contains-token(@class, 'rdfa-editor-content')
+                or cm:flow(local-name(.)) or self::blockquote]])"/>
+    </xsl:function>
+
+    <!-- the drag handle's owning block: chrome is its first child -->
+    <xsl:function name="local:handle-block" as="element()?">
+        <xsl:param name="handle" as="element()"/>
+        <xsl:sequence select="$handle/parent::*[local:draggable-block(.)]"/>
+    </xsl:function>
+
+    <!-- a container admits the dragged kind: the region takes any block (the
+         editor contract, deliberately outside content-model.xsl), everything
+         else per the DTD -->
+    <xsl:function name="local:container-accepts" as="xs:boolean">
+        <xsl:param name="container" as="element()"/>
+        <xsl:param name="block" as="element()"/>
+        <xsl:sequence select="contains-token($container/@class, 'rdfa-editor-content')
+            or cm:allows-child(local-name($container), local-name($block))"/>
+    </xsl:function>
+
+    <!-- the innermost draggable block under a pointer hit - never the dragged
+         block itself or anything inside it (its ancestors are fair targets:
+         dropping before/after an ancestor lifts the block out) -->
+    <xsl:function name="local:deepest-block-at" as="element()?">
+        <xsl:param name="hit"/>
+        <xsl:param name="dragged" as="element()?"/>
+        <xsl:sequence select="$hit/ancestor-or-self::*[local:draggable-block(.)]
+            [empty(ancestor-or-self::* intersect $dragged)][1]"/>
+    </xsl:function>
+
+    <!-- the drop level: the innermost block at or above the candidate whose
+         container legally accepts the dragged kind - an illegal drop clamps to
+         the nearest legal ancestor level instead of being created. The region
+         accepts any block, so the climb always terminates -->
+    <xsl:function name="local:legal-drop-level" as="element()?">
+        <xsl:param name="candidate" as="element()"/>
+        <xsl:param name="dragged" as="element()"/>
+        <xsl:sequence select="$candidate/ancestor-or-self::*[local:draggable-block(.)]
+            [local:container-accepts(parent::*, $dragged)][1]"/>
+    </xsl:function>
+
+    <!-- the editable host containing a node (block, li or figcaption) -->
+    <xsl:function name="local:host-of" as="element()?">
+        <xsl:param name="node"/>
+        <xsl:sequence select="$node/ancestor-or-self::*[@contenteditable = 'true'][1]"/>
+    </xsl:function>
+
+    <!-- the list item a node sits in (the host may be a nested block inside a
+         container item): the unit Tab indent/outdent acts on. Clamped at the
+         region root - a host-page li wrapping an embedded region is not ours -->
+    <xsl:function name="local:item-of" as="element()?">
+        <xsl:param name="node"/>
+        <xsl:sequence select="$node/ancestor-or-self::li[exists(local:block-of(.))][1]"/>
+    </xsl:function>
+
+    <!-- the first/last editable host within an element (the element itself when it
+         is a host): where the caret lands entering a container from either side -->
+    <xsl:function name="local:first-host-in" as="element()?">
+        <xsl:param name="element" as="element()?"/>
+        <xsl:sequence select="($element/descendant-or-self::*[@contenteditable = 'true'])[1]"/>
+    </xsl:function>
+
+    <xsl:function name="local:last-host-in" as="element()?">
+        <xsl:param name="element" as="element()?"/>
+        <xsl:sequence select="($element/descendant-or-self::*[@contenteditable = 'true'])[last()]"/>
+    </xsl:function>
+
+    <!-- the merge target for Backspace joins: the last editable host within an
+         element, unless it sits inside a composite (table, figure) at or below
+         the element, or an object-block island follows it at the element's tail
+         (islands hold no hosts, so the lookup would leapfrog them) - composites
+         and islands are hard boundaries (B3/B6), so an empty result leaves the
+         gesture inert -->
+    <xsl:function name="local:merge-host-in" as="element()?">
+        <xsl:param name="element" as="element()?"/>
+        <xsl:variable name="host" as="element()?" select="local:last-host-in($element)"/>
+        <xsl:sequence select="$host
+            [empty(ancestor-or-self::*[self::table or self::figure or local:island(.)]
+                intersect $element/descendant-or-self::*)]
+            [empty($element/descendant-or-self::*[local:island(.)][. &gt;&gt; $host])]"/>
+    </xsl:function>
+
+    <!-- keyboard-navigation stops within a region, in document order: the editable
+         hosts plus block-level (figure) images plus object-block islands. Neither
+         can hold a caret, so each is a navigation island in its own right -
+         focused (selected) rather than given a caret - see local:land-forward/
+         -backward. Nothing inside an island or an ephemeral subtree is a stop -->
+    <xsl:function name="local:nav-targets" as="element()*">
+        <xsl:param name="node"/>
+        <xsl:sequence select="local:root-of($node)//*[@contenteditable = 'true'
+            or (self::img and empty(ancestor::*[@contenteditable = 'true']))
+            or local:island(.)]
+            [empty(ancestor::*[@data-role])][empty(ancestor::*[local:island(.)])]"/>
+    </xsl:function>
+
+    <!-- toolbar actions resolve the block from the selection, falling back to the
+         last focused host (the block-type select steals focus - see ixsl:onfocusin) -->
+    <xsl:function name="local:current-block" as="element()?">
+        <xsl:sequence select="(local:anchor-node() ! local:block-of(.),
+            ixsl:get(local:editor-state(), 'activeBlock') ! local:block-of(.))[1]"/>
+    </xsl:function>
+
+    <!-- host-based resolution for actions that act on the leaf block the caret
+         sits in (block-type convert, quote toggle) rather than the top-level block -->
+    <xsl:function name="local:current-host" as="element()?">
+        <xsl:sequence select="(local:anchor-node() ! local:host-of(.),
+            ixsl:get(local:editor-state(), 'activeBlock') ! local:host-of(.))[1]"/>
+    </xsl:function>
+
+    <xsl:function name="local:chrome-count" as="xs:integer">
+        <xsl:param name="block" as="element()"/>
+        <xsl:sequence select="count($block/*[@data-role = 'chrome'])"/>
+    </xsl:function>
+
+    <!-- block text excluding chrome, for emptiness checks -->
+    <xsl:function name="local:block-text" as="xs:string">
+        <xsl:param name="block" as="element()"/>
+        <xsl:sequence select="normalize-space(string-join($block//text()[not(ancestor::*[@data-role])]))"/>
+    </xsl:function>
+
+    <!-- true when nothing but chrome precedes the caret inside the host -->
+    <xsl:function name="local:at-start" as="xs:boolean">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="range"/>
+        <xsl:variable name="probe" select="ixsl:call(ixsl:page(), 'createRange', [])"/>
+        <xsl:sequence select="ixsl:call($probe, 'setStart', [ $host, local:chrome-count($host) ])[current-date() lt xs:date('2000-01-01')],
+            ixsl:call($probe, 'setEnd', [ ixsl:get($range, 'startContainer'), xs:integer(ixsl:get($range, 'startOffset')) ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:sequence select="string(ixsl:call($probe, 'toString', [])) = ''"/>
+    </xsl:function>
+
+    <!-- true when nothing but a trailing placeholder follows the caret inside the host -->
+    <xsl:function name="local:at-end" as="xs:boolean">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="range"/>
+        <xsl:variable name="probe" select="ixsl:call(ixsl:page(), 'createRange', [])"/>
+        <xsl:sequence select="ixsl:call($probe, 'setEnd', [ $host, xs:integer(ixsl:get($host, 'childNodes.length')) ])[current-date() lt xs:date('2000-01-01')],
+            ixsl:call($probe, 'setStart', [ ixsl:get($range, 'endContainer'), xs:integer(ixsl:get($range, 'endOffset')) ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:sequence select="string(ixsl:call($probe, 'toString', [])) = ''"/>
+    </xsl:function>
+
+    <!-- an empty editable host needs a <br> placeholder: without one it has no height
+         and no valid caret position (its only child may be non-editable chrome), so
+         clicks and typing go nowhere. Dropped again by canonical-xhtml.xsl. Never
+         fires on element-only containers (blockquote) - br is inline content -->
+    <xsl:template name="local:ensure-placeholder">
+        <xsl:param name="host" as="element()"/>
+        <xsl:if test="local:block-text($host) = '' and empty($host/br)
+                and cm:allows-child(local-name($host), 'br')">
+            <xsl:sequence select="ixsl:call($host, 'appendChild',
+                [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- outermost RDFa-attributed inline ancestor of a node, strictly below the host -->
+    <xsl:function name="local:enclosing-annotation" as="element()?">
+        <xsl:param name="node"/>
+        <xsl:param name="host" as="element()"/>
+        <xsl:sequence select="($node/ancestor-or-self::*[@property or @about or @typeof or @resource]
+            intersect $host/descendant::*)[1]"/>
+    </xsl:function>
+
+    <xsl:function name="local:selection" as="item()">
+        <xsl:sequence select="ixsl:call(ixsl:window(), 'getSelection', [])"/>
+    </xsl:function>
+
+    <xsl:function name="local:caret-range" as="item()?">
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:sequence select="if (ixsl:get($selection, 'rangeCount') ge 1)
+            then ixsl:call($selection, 'getRangeAt', [ 0 ]) else ()"/>
+    </xsl:function>
+
+    <!-- the selection anchor as a node (empty when no range) and its offset (0 then) -->
+    <xsl:function name="local:anchor-node" as="node()?">
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:sequence select="if (ixsl:get($selection, 'rangeCount') ge 1)
+            then ixsl:get($selection, 'anchorNode') else ()"/>
+    </xsl:function>
+
+    <xsl:function name="local:anchor-offset" as="xs:integer">
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:sequence select="if (ixsl:get($selection, 'rangeCount') ge 1)
+            then xs:integer(ixsl:get($selection, 'anchorOffset')) else 0"/>
+    </xsl:function>
+
+    <xsl:function name="local:element" as="element()">
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="ixsl:call(ixsl:page(), 'createElement', [ $name ])"/>
+    </xsl:function>
+
+    <!-- the live value of the first input named $name under $scope (a dialog or form) -->
+    <xsl:function name="local:input-value" as="xs:string">
+        <xsl:param name="scope" as="element()"/>
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="string(ixsl:get(($scope//input[@name = $name])[1], 'value'))"/>
+    </xsl:function>
+
+    <!-- focus the host of $node, then collapse the caret there -->
+    <xsl:template name="local:focus-caret">
+        <xsl:param name="node"/>
+        <xsl:param name="offset" as="xs:integer"/>
+        <xsl:for-each select="local:host-of($node)">
+            <xsl:call-template name="local:focus">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+        <xsl:call-template name="local:place-caret">
+            <xsl:with-param name="node" select="$node"/>
+            <xsl:with-param name="offset" select="$offset"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <xsl:template name="local:place-caret">
+        <xsl:param name="node"/>
+        <xsl:param name="offset" as="xs:integer"/>
+        <xsl:sequence select="ixsl:call(local:selection(), 'collapse',
+            [ $node, $offset ])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <xsl:template name="local:focus">
+        <xsl:param name="element" as="element()"/>
+        <xsl:sequence select="ixsl:call($element, 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <!-- a block image or object-block island is 'selected' by focusing it (both
+         carry tabindex=-1, set at init); the text caret is cleared so only the
+         island reads as the current target. Its onfocusin records it as the
+         active block, so toolbar/drag act on it (or its figure) just as for a
+         focused editable host -->
+    <xsl:template name="local:select-island">
+        <xsl:param name="element" as="element()"/>
+        <xsl:sequence select="ixsl:call(local:selection(), 'removeAllRanges', [])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:focus">
+            <xsl:with-param name="element" select="$element"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- land at the start of the next target (down/right): caret at a host after any
+         chrome, focus (selection) at an image -->
+    <xsl:template name="local:land-forward">
+        <xsl:param name="target" as="element()"/>
+        <xsl:choose>
+            <xsl:when test="$target/self::img or local:island($target)">
+                <xsl:call-template name="local:select-island">
+                    <xsl:with-param name="element" select="$target"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:focus-caret">
+                    <xsl:with-param name="node" select="$target"/>
+                    <xsl:with-param name="offset" select="local:chrome-count($target)"/>
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- land at the end of the previous target (up/left): caret before any trailing
+         placeholder <br> at a host, focus (selection) at an image -->
+    <xsl:template name="local:land-backward">
+        <xsl:param name="target" as="element()"/>
+        <xsl:choose>
+            <xsl:when test="$target/self::img or local:island($target)">
+                <xsl:call-template name="local:select-island">
+                    <xsl:with-param name="element" select="$target"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:focus">
+                    <xsl:with-param name="element" select="$target"/>
+                </xsl:call-template>
+                <xsl:call-template name="local:place-caret">
+                    <xsl:with-param name="node" select="$target"/>
+                    <xsl:with-param name="offset"
+                        select="count($target/node()) - count($target/node()[last()][self::br])"/>
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- ................................ init ................................ -->
+
+    <xsl:template name="local:init-editing">
+        <xsl:for-each select="local:toolbar-host()">
+            <xsl:result-document href="?." method="ixsl:append-content">
+                <xsl:call-template name="local:render-toolbar"/>
+            </xsl:result-document>
+        </xsl:for-each>
+        <xsl:for-each select="ixsl:page()//body">
+            <xsl:result-document href="?." method="ixsl:append-content">
+                <xsl:call-template name="local:render-link-dialog"/>
+                <xsl:call-template name="local:render-figure-dialog"/>
+                <xsl:call-template name="local:render-table-dialog"/>
+                <xsl:call-template name="local:render-slash-menu"/>
+                <!-- extension dialogs (opt into teardown via the edit-dialog class) -->
+                <xsl:call-template name="local:render-extra-dialogs"/>
+            </xsl:result-document>
+        </xsl:for-each>
+        <xsl:for-each select="local:roots()">
+            <xsl:call-template name="local:init-region">
+                <xsl:with-param name="region" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- per-region bring-up, callable for regions rendered after the initial page
+         (hosts that open editable regions lazily init each one through this) -->
+    <xsl:template name="local:init-region">
+        <xsl:param name="region" as="element()"/>
+
+        <!-- boundary-normalize invalid host markup (bare text in blockquote,
+             blocks inside p, stray inline at region level, ...) before
+             editability init; the probe keeps the valid case zero-churn -->
+        <xsl:variable name="invalid" as="xs:boolean" select="
+            exists($region//*[not(ancestor-or-self::*[@data-role])][not(cm:valid-nesting(.))])
+            or exists($region//*[not(ancestor-or-self::*[@data-role])]
+                [cm:structural(local-name(.))][text()[normalize-space()]])
+            or exists($region/(text()[normalize-space()] | *[cm:inline(local-name(.))]))"/>
+        <xsl:if test="$invalid">
+            <xsl:variable name="fixed" as="node()*"
+                select="cm:wrap-inline-runs(cm:normalize($region/node()), 'p')"/>
+            <ixsl:set-property name="innerHTML"
+                select="serialize($fixed, map{ 'method': 'html' })" object="$region"/>
+        </xsl:if>
+        <!-- an empty region cannot hold a caret: seed a paragraph (the
+             empty-blockquote idiom in local:init-block) -->
+        <xsl:if test="empty($region/*[not(@data-role)])">
+            <xsl:variable name="p" as="element()" select="local:element('p')"/>
+            <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="ixsl:call($region, 'appendChild', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+        <xsl:for-each select="$region/*">
+            <xsl:call-template name="local:init-block">
+                <xsl:with-param name="block" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- editability per the content model, recursively: an element is a text host
+         while it allows text and holds no block children; mixed flow containers
+         (li, td, dd, ... with blocks) and structural containers (blockquote, lists,
+         figure, table) lock their own markup and recurse into their parts. Every
+         draggable block - nested ones included - carries its own chrome handle -->
+
+    <xsl:template name="local:init-block">
+        <xsl:param name="block" as="element()"/>
+        <xsl:variable name="name" as="xs:string" select="local-name($block)"/>
+
+        <xsl:choose>
+            <!-- object-block island: an atomic unit - never editable inside, its
+                 RDFa definition spans locked, focusable (tabindex, like a block
+                 image) and rendered via the local:render-island hook when it has
+                 no rendering div yet (idempotent across re-inits and undo) -->
+            <xsl:when test="local:island($block)">
+                <xsl:for-each select="$block">
+                    <ixsl:remove-attribute name="contenteditable"/>
+                    <ixsl:set-attribute name="tabindex" select="'-1'"/>
+                </xsl:for-each>
+                <xsl:sequence select="ixsl:call(ixsl:get($block, 'classList'), 'add',
+                    [ 'rdfa-editor-island' ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:if test="empty($block/*[@data-role = 'rendering'])">
+                    <xsl:apply-templates select="$block" mode="local:render-island"/>
+                </xsl:if>
+            </xsl:when>
+            <!-- text host: inline-only elements, and flow elements without block
+                 children (figure is always composite structure - its parts are the
+                 image island, the caption host and any wrapped runs) -->
+            <xsl:when test="not($block/self::figure) and (cm:inline-only($name)
+                    or (cm:flow($name) and empty($block/*[cm:block(local-name(.))])))">
+                <xsl:for-each select="$block">
+                    <ixsl:set-attribute name="contenteditable" select="'true'"/>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise>
+                <!-- mixed flow container: stray inline runs get an editable wrapper -->
+                <xsl:if test="cm:flow($name)">
+                    <xsl:call-template name="local:wrap-stray-runs">
+                        <xsl:with-param name="container" select="$block"/>
+                    </xsl:call-template>
+                </xsl:if>
+                <!-- an empty blockquote cannot hold a caret itself: seed a paragraph -->
+                <xsl:if test="$block/self::blockquote and empty($block/*[not(@data-role)])">
+                    <xsl:variable name="p" as="element()" select="local:element('p')"/>
+                    <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:sequence select="ixsl:call($block, 'appendChild', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:if>
+                <xsl:for-each select="$block/*[not(@data-role)][cm:known(local-name(.))]
+                        [not(cm:inline(local-name(.)))]">
+                    <xsl:call-template name="local:init-block">
+                        <xsl:with-param name="block" select="."/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+        <!-- block images can't hold a caret, so they are made focusable to serve as
+             keyboard-navigation islands (tabindex is canonicalization-stripped);
+             imgs inside ephemeral subtrees (island renderings) are never targets -->
+        <xsl:for-each select="$block/descendant-or-self::img[empty(ancestor::*[@contenteditable = 'true'])]
+                [empty(ancestor::*[@data-role])]">
+            <ixsl:set-attribute name="tabindex" select="'-1'"/>
+        </xsl:for-each>
+        <xsl:if test="local:draggable-block($block)">
+            <xsl:call-template name="local:inject-chrome">
+                <xsl:with-param name="block" select="$block"/>
+            </xsl:call-template>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- the inverse of local:wrap-stray-runs: when a flow container loses its last
+         block child, remaining run wrappers unwrap (adjacent runs merge back) and
+         the container becomes a plain text host again -->
+    <xsl:template name="local:collapse-container">
+        <xsl:param name="container" as="element()"/>
+        <xsl:if test="not(local:island($container)) and cm:flow(local-name($container))
+                and empty($container/*[not(@data-role)][cm:block(local-name(.)) or self::figcaption]
+                    [not(contains-token(@class, 'rdfa-editor-run')
+                        and not(@property or @about or @typeof or @resource or @content or @datatype))])">
+            <xsl:for-each select="$container/p[contains-token(@class, 'rdfa-editor-run')]
+                    [not(@property or @about or @typeof or @resource or @content or @datatype)]">
+                <xsl:variable name="wrapper" as="element()" select="."/>
+                <xsl:for-each select="1 to xs:integer(ixsl:get($wrapper, 'childNodes.length'))">
+                    <xsl:sequence select="ixsl:call($wrapper, 'before', [ ixsl:get($wrapper, 'firstChild') ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+                <xsl:sequence select="ixsl:call($wrapper, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:for-each>
+            <xsl:for-each select="$container">
+                <ixsl:set-attribute name="contenteditable" select="'true'"/>
+            </xsl:for-each>
+            <xsl:call-template name="local:ensure-placeholder">
+                <xsl:with-param name="host" select="$container"/>
+            </xsl:call-template>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- editing-DOM run wrapper: the stray inline runs of a mixed flow container
+         are wrapped in p.rdfa-editor-run hosts so they stay editable; the marker
+         class is unwrapped again by canonical-xhtml.xsl (C11), so mixed content
+         like <li>text<ul>...</ul></li> round-trips intact. Blocks, block images,
+         figcaption, ephemera and unknown elements stay put. Structural gestures
+         (Enter-split, block-type convert) promote a wrapper to a real paragraph -->
+    <xsl:template name="local:wrap-stray-runs">
+        <xsl:param name="container" as="element()"/>
+        <!-- snapshot the child sequence: wrapping mutates the live list -->
+        <xsl:variable name="kids" as="node()*" select="$container/node()"/>
+        <xsl:for-each-group select="$kids" group-adjacent="boolean(self::*[cm:block(local-name(.))
+                or self::img or self::figcaption or @data-role or not(cm:known(local-name(.)))])">
+            <xsl:if test="not(current-grouping-key())
+                    and exists(current-group()[self::* or self::text()[normalize-space()]])">
+                <xsl:variable name="wrapper" as="element()" select="local:element('p')"/>
+                <ixsl:set-attribute name="class" select="'rdfa-editor-run'" object="$wrapper"/>
+                <!-- the wrapper IS the run's editable host - callers outside init
+                     (insert, indent, outdent) never re-init the container -->
+                <ixsl:set-attribute name="contenteditable" select="'true'" object="$wrapper"/>
+                <xsl:sequence select="ixsl:call(current-group()[1], 'before', [ $wrapper ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:for-each select="current-group()">
+                    <xsl:sequence select="ixsl:call($wrapper, 'appendChild', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+            </xsl:if>
+        </xsl:for-each-group>
+    </xsl:template>
+
+    <!-- first-child chrome keeps split ranges (caret to end of block) clean of it -->
+    <xsl:template name="local:inject-chrome">
+        <xsl:param name="block" as="element()"/>
+
+        <xsl:if test="empty($block/*[@data-role = 'chrome'])">
+            <xsl:variable name="chrome" as="element()" select="local:element('span')"/>
+            <ixsl:set-attribute name="data-role" select="'chrome'" object="$chrome"/>
+            <ixsl:set-attribute name="class" select="'drag-handle'" object="$chrome"/>
+            <ixsl:set-attribute name="contenteditable" select="'false'" object="$chrome"/>
+            <ixsl:set-attribute name="title" select="'Drag to reorder'" object="$chrome"/>
+            <ixsl:set-property name="textContent" select="'&#x283F;'" object="$chrome"/>
+            <xsl:sequence select="ixsl:call($block, 'prepend', [ $chrome ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="local:remove-chrome">
+        <xsl:param name="block" as="element()"/>
+        <xsl:for-each select="$block/*[@data-role = 'chrome']">
+            <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- classList.remove leaves an empty @class behind, which would survive into
+         undo snapshots and canonical-comparison baselines as class="" noise -->
+    <xsl:template name="local:tidy-class">
+        <xsl:param name="element" as="element()"/>
+        <xsl:for-each select="$element[@class = '']">
+            <ixsl:remove-attribute name="class"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- chrome convergence: every draggable block carries its handle. Init seeds
+         the loaded content; gestures that build nested blocks (split, indent,
+         paste, list insert) converge here via local:after-mutation instead of
+         each threading its own injection -->
+    <xsl:template name="local:ensure-chrome">
+        <xsl:param name="scope" as="element()*" select="local:roots()"/>
+        <xsl:for-each select="$scope/descendant::*[local:draggable-block(.)]
+                [empty(*[@data-role = 'chrome'])]">
+            <xsl:call-template name="local:inject-chrome">
+                <xsl:with-param name="block" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="local:render-toolbar">
+        <div id="edit-toolbar" class="rdfa-editor-ui" role="toolbar" aria-label="Editing toolbar">
+            <div class="tb-group" role="group" aria-label="Block">
+                <select name="block-type" title="Block type" aria-label="Block type">
+                    <option value="p">Paragraph</option>
+                    <option value="h1">Heading 1</option>
+                    <option value="h2">Heading 2</option>
+                    <option value="h3">Heading 3</option>
+                    <option value="pre">Preformatted</option>
+                </select>
+            </div>
+            <div class="tb-group" role="group" aria-label="Text">
+                <button type="button" class="format-inline" data-element="strong" aria-pressed="false" title="Bold" aria-label="Bold"><strong>B</strong></button>
+                <button type="button" class="format-inline" data-element="em" aria-pressed="false" title="Italic" aria-label="Italic"><em>I</em></button>
+                <button type="button" class="format-link" aria-pressed="false" title="Link" aria-label="Link">&#x1F517;</button>
+            </div>
+            <div class="tb-group" role="group" aria-label="Blocks">
+                <button type="button" class="insert-block" title="Add paragraph" aria-label="Add paragraph">+ &#xB6;</button>
+                <button type="button" class="insert-list" data-list="ul" aria-pressed="false" title="Bulleted list" aria-label="Bulleted list">&#x2022; List</button>
+                <button type="button" class="insert-list" data-list="ol" aria-pressed="false" title="Numbered list" aria-label="Numbered list">1. List</button>
+                <button type="button" class="format-quote" aria-pressed="false" title="Quote" aria-label="Quote">&#x201C;&#x201D;</button>
+            </div>
+            <div class="tb-group" role="group" aria-label="Insert">
+                <button type="button" class="insert-figure" title="Insert figure" aria-label="Insert figure">&#x1F5BC;</button>
+                <button type="button" class="insert-table" title="Insert table" aria-label="Insert table">&#x229E;</button>
+                <xsl:call-template name="local:render-extra-insert-buttons"/>
+            </div>
+            <div class="tb-group table-ops" role="group" aria-label="Table operations">
+                <button type="button" class="table-op" data-op="row-above" disabled="disabled" title="Insert row above" aria-label="Insert row above">&#x2191;R</button>
+                <button type="button" class="table-op" data-op="row-below" disabled="disabled" title="Insert row below" aria-label="Insert row below">&#x2193;R</button>
+                <button type="button" class="table-op" data-op="col-left" disabled="disabled" title="Insert column left" aria-label="Insert column left">&#x2190;C</button>
+                <button type="button" class="table-op" data-op="col-right" disabled="disabled" title="Insert column right" aria-label="Insert column right">&#x2192;C</button>
+                <button type="button" class="table-op" data-op="del-row" disabled="disabled" title="Delete row" aria-label="Delete row">&#x2212;R</button>
+                <button type="button" class="table-op" data-op="del-col" disabled="disabled" title="Delete column" aria-label="Delete column">&#x2212;C</button>
+            </div>
+            <div class="tb-group" role="group" aria-label="Block actions">
+                <button type="button" class="delete-block" title="Delete block" aria-label="Delete block">&#x2715;</button>
+            </div>
+            <div class="tb-group" role="group" aria-label="View">
+                <button type="button" id="toc-toggle" title="Table of contents" aria-label="Table of contents">&#x2630;</button>
+                <button type="button" id="inspector-toggle" title="Properties" aria-label="Subject properties">&#x24C5;</button>
+                <button type="button" id="find-open" title="Find and replace" aria-label="Find and replace">&#x1F50D;</button>
+                <button type="button" id="view-source" title="Canonical XHTML+RDFa" aria-label="View canonical source">Source</button>
+            </div>
+        </div>
+    </xsl:template>
+
+    <!-- caret-contextual toolbar state, riding local:update-breadcrumb (the single
+         caret-awareness choke point) alongside local:sync-table-toolbar: the inline
+         toggles reflect the elements the caret sits inside (strong/em/link/list) and
+         the block-type select follows the current convertible block kind -->
+    <xsl:template name="local:sync-format-toolbar">
+        <xsl:variable name="leaf" as="element()?" select="ixsl:get(local:editor-state(), 'breadcrumbLeaf')"/>
+        <xsl:variable name="host" as="element()?" select="$leaf ! local:host-of(.)"/>
+        <!-- inline element toggles: strong / em (mirrors the format-inline click handler) -->
+        <xsl:for-each select="id('edit-toolbar', ixsl:page())//button[@data-element]">
+            <xsl:variable name="name" as="xs:string" select="string(@data-element)"/>
+            <xsl:variable name="on" as="xs:boolean" select="exists($host)
+                and exists($leaf/ancestor-or-self::*[local-name() = $name] intersect $host/descendant::*)"/>
+            <ixsl:set-attribute name="aria-pressed" select="if ($on) then 'true' else 'false'" object="."/>
+        </xsl:for-each>
+        <!-- link toggle -->
+        <xsl:for-each select="id('edit-toolbar', ixsl:page())//button[contains-token(@class, 'format-link')]">
+            <xsl:variable name="on" as="xs:boolean" select="exists($host)
+                and exists($leaf/ancestor-or-self::a intersect $host/descendant::*)"/>
+            <ixsl:set-attribute name="aria-pressed" select="if ($on) then 'true' else 'false'" object="."/>
+        </xsl:for-each>
+        <!-- list toggles: only the innermost enclosing list lights (never both) -->
+        <xsl:variable name="list" as="element()?" select="$leaf/ancestor-or-self::*[self::ul or self::ol][1]"/>
+        <xsl:for-each select="id('edit-toolbar', ixsl:page())//button[@data-list]">
+            <xsl:variable name="on" as="xs:boolean" select="exists($list) and local-name($list) = string(@data-list)"/>
+            <ixsl:set-attribute name="aria-pressed" select="if ($on) then 'true' else 'false'" object="."/>
+        </xsl:for-each>
+        <!-- quote toggle: pressed inside a blockquote (of this region - host-page
+             quotes around an embedded region don't count), disabled where neither
+             pressed nor a valid wrap target exists -->
+        <xsl:variable name="in-quote" as="xs:boolean"
+            select="exists($host) and exists($leaf/ancestor-or-self::blockquote[exists(local:block-of(.))])"/>
+        <xsl:variable name="wrappable" as="xs:boolean" select="exists($host[cm:block(local-name(.))]
+            [parent::*[contains-token(@class, 'rdfa-editor-content')]
+                or cm:allows-child(local-name(parent::*), 'blockquote')])"/>
+        <xsl:for-each select="id('edit-toolbar', ixsl:page())//button[contains-token(@class, 'format-quote')]">
+            <ixsl:set-attribute name="aria-pressed" select="if ($in-quote) then 'true' else 'false'" object="."/>
+            <ixsl:set-property name="disabled" select="not($in-quote or $wrappable)" object="."/>
+        </xsl:for-each>
+        <!-- block-type select follows the convertible HOST (a quote paragraph reads
+             as Paragraph); disabled on non-convertible hosts (li, cells, captions) -->
+        <xsl:variable name="convertible" as="element()?"
+            select="$host[self::p or self::h1 or self::h2 or self::h3 or self::pre]"/>
+        <xsl:for-each select="id('edit-toolbar', ixsl:page())//select[@name = 'block-type']">
+            <ixsl:set-property name="disabled" select="empty($convertible)" object="."/>
+            <xsl:for-each select="$convertible">
+                <xsl:variable name="kind" as="xs:string" select="local-name(.)"/>
+                <xsl:for-each select="id('edit-toolbar', ixsl:page())//select[@name = 'block-type']">
+                    <ixsl:set-property name="value" select="$kind" object="."/>
+                </xsl:for-each>
+            </xsl:for-each>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- ................................ keyboard ................................ -->
+
+    <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onkeydown">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="key" as="xs:string" select="string(ixsl:get($event, 'key'))"/>
+        <xsl:variable name="chord" as="xs:boolean"
+            select="(ixsl:get($event, 'ctrlKey') or ixsl:get($event, 'metaKey')) and not(ixsl:get($event, 'altKey'))"/>
+        <xsl:if test="exists(local:block-of(.)) and not(ixsl:get($event, 'isComposing'))">
+            <xsl:choose>
+                <!-- native undo is replaced by the snapshot history: intercept even on an empty stack -->
+                <xsl:when test="$chord and lower-case($key) = 'z' and not(ixsl:get($event, 'shiftKey'))">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:apply-undo"/>
+                </xsl:when>
+                <xsl:when test="$chord and ((lower-case($key) = 'z' and ixsl:get($event, 'shiftKey'))
+                        or (lower-case($key) = 'y' and not(ixsl:get($event, 'shiftKey'))))">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:apply-redo"/>
+                </xsl:when>
+                <!-- Ctrl/Cmd+A escalates Docs-style: native select-all already scopes
+                     to the host (stage 1); once the host is fully selected (or the
+                     selection already spans hosts) the whole region is selected
+                     instead - never the host page -->
+                <xsl:when test="$chord and lower-case($key) = 'a' and not(ixsl:get($event, 'shiftKey'))">
+                    <xsl:variable name="range" select="local:caret-range()"/>
+                    <xsl:if test="local:selection-crosses-hosts()
+                            or (exists($range) and local:host-fully-selected(., $range))">
+                        <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                        <xsl:for-each select="local:root-of(.)">
+                            <xsl:call-template name="local:select-region">
+                                <xsl:with-param name="region" select="."/>
+                            </xsl:call-template>
+                        </xsl:for-each>
+                    </xsl:if>
+                </xsl:when>
+                <!-- other ctrl/meta chords stay native (copy, paste, browser find) -->
+                <xsl:when test="ixsl:get($event, 'ctrlKey') or ixsl:get($event, 'metaKey')"/>
+                <!-- Escape closes the annotation overlay / dialogs even while focus
+                     remains in the content (their own keydown templates only fire
+                     when focus is inside them) -->
+                <xsl:when test="$key = 'Escape'">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:hide-overlay"/>
+                    <xsl:call-template name="local:hide-dialogs"/>
+                </xsl:when>
+                <!-- Shift+Up/Down extend the selection block-granularly beyond the
+                     host: native extension clamps at host edges, and a cross-host
+                     selection cannot be extended natively at all; within the host
+                     (focus not at the facing edge) they stay native line-wise -->
+                <xsl:when test="ixsl:get($event, 'shiftKey') and not(ixsl:get($event, 'altKey'))
+                        and $key = ('ArrowUp', 'ArrowDown')
+                        and local:shift-arrow-extends(., if ($key = 'ArrowUp') then 'up' else 'down')">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:extend-selection-block-wise">
+                        <xsl:with-param name="direction" select="if ($key = 'ArrowUp') then 'up' else 'down'"/>
+                    </xsl:call-template>
+                </xsl:when>
+                <!-- a selection spanning hosts: Backspace/Delete run the editor's own
+                     delete (the browser refuses to edit across host boundaries), a
+                     printable character replaces the selection (delete, then the
+                     character lands at the machine-placed caret), Enter/Tab are
+                     suppressed so the selection cannot be half-edited; plain arrows
+                     stay native (they collapse it) and the chord cases above keep
+                     copy/cut native (canonical copy intercepts at the event level) -->
+                <xsl:when test="local:selection-crosses-hosts()">
+                    <xsl:choose>
+                        <xsl:when test="$key = ('Backspace', 'Delete')">
+                            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                            <xsl:call-template name="local:delete-cross-host-selection"/>
+                        </xsl:when>
+                        <xsl:when test="string-length($key) = 1">
+                            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                            <xsl:call-template name="local:delete-cross-host-selection"/>
+                            <xsl:call-template name="local:insert-text-at-caret">
+                                <xsl:with-param name="text" select="$key"/>
+                            </xsl:call-template>
+                            <xsl:call-template name="local:after-mutation"/>
+                        </xsl:when>
+                        <xsl:when test="$key = ('Enter', 'Tab')">
+                            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                        </xsl:when>
+                        <xsl:otherwise/>
+                    </xsl:choose>
+                </xsl:when>
+                <!-- Alt+Arrow moves the current block (keyboard alternative to drag-and-drop) -->
+                <xsl:when test="ixsl:get($event, 'altKey') and $key = ('ArrowUp', 'ArrowDown')">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:variable name="host" as="element()" select="."/>
+                    <xsl:variable name="block" as="element()?" select="local:block-of(.)"/>
+                    <xsl:for-each select="if ($key = 'ArrowUp')
+                            then $block/preceding-sibling::*[1] else $block/following-sibling::*[1]">
+                        <xsl:call-template name="local:push-undo"/>
+                        <xsl:sequence select="ixsl:call(., if ($key = 'ArrowUp') then 'before' else 'after',
+                            [ $block ])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:for-each>
+                    <!-- moving the focused block blurs it -->
+                    <xsl:call-template name="local:focus">
+                        <xsl:with-param name="element" select="$host"/>
+                    </xsl:call-template>
+                    <xsl:call-template name="local:after-mutation"/>
+                </xsl:when>
+                <!-- Tab indents/outdents list items and walks table cells; the
+                     innermost context wins (li inside a cell indents, a table
+                     nested in an item traverses); native Tab everywhere else -->
+                <xsl:when test="$key = 'Tab'">
+                    <xsl:variable name="item" as="element()?" select="local:item-of(.)"/>
+                    <!-- clamped at the region root: a host-page cell wrapping an
+                         embedded region must never be traversed or grown -->
+                    <xsl:variable name="cell" as="element()?"
+                        select="ancestor-or-self::*[self::td or self::th or self::caption]
+                            [exists(local:block-of(.))][1]"/>
+                    <xsl:choose>
+                        <xsl:when test="exists($item) and (empty($cell)
+                                or exists($item/ancestor::* intersect $cell))">
+                            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                            <xsl:choose>
+                                <xsl:when test="ixsl:get($event, 'shiftKey')">
+                                    <xsl:call-template name="local:list-outdent">
+                                        <xsl:with-param name="item" select="$item"/>
+                                    </xsl:call-template>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <xsl:call-template name="local:list-indent">
+                                        <xsl:with-param name="item" select="$item"/>
+                                    </xsl:call-template>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                        </xsl:when>
+                        <xsl:when test="exists($cell)">
+                            <xsl:call-template name="local:table-tab">
+                                <xsl:with-param name="host" select="$cell"/>
+                                <xsl:with-param name="event" select="$event"/>
+                                <xsl:with-param name="shift" select="ixsl:get($event, 'shiftKey') = true()"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <xsl:otherwise/>
+                    </xsl:choose>
+                </xsl:when>
+                <!-- arrow keys cross block boundaries: each block is its own
+                     contenteditable island, so the browser stops at its edges.
+                     Block-level (figure) images are non-editable but still navigable -
+                     local:nav-targets includes them and local:land-* selects them
+                     (focus) rather than placing a caret -->
+                <xsl:when test="$key = ('ArrowDown', 'ArrowRight', 'ArrowUp', 'ArrowLeft')
+                        and not(ixsl:get($event, 'shiftKey')) and not(ixsl:get($event, 'altKey'))">
+                    <xsl:variable name="selection" select="local:selection()"/>
+                    <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1 and ixsl:get($selection, 'isCollapsed')">
+                        <xsl:variable name="range" select="local:caret-range()"/>
+                        <xsl:variable name="host" as="element()" select="."/>
+                        <xsl:variable name="targets" as="element()*" select="local:nav-targets(.)"/>
+                        <xsl:choose>
+                            <xsl:when test="$key = ('ArrowDown', 'ArrowRight') and local:at-end($host, $range)">
+                                <xsl:for-each select="($targets[. &gt;&gt; $host])[1]">
+                                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                                    <xsl:call-template name="local:land-forward">
+                                        <xsl:with-param name="target" select="."/>
+                                    </xsl:call-template>
+                                </xsl:for-each>
+                            </xsl:when>
+                            <xsl:when test="$key = ('ArrowUp', 'ArrowLeft') and local:at-start($host, $range)">
+                                <xsl:for-each select="($targets[. &lt;&lt; $host])[last()]">
+                                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                                    <xsl:call-template name="local:land-backward">
+                                        <xsl:with-param name="target" select="."/>
+                                    </xsl:call-template>
+                                </xsl:for-each>
+                            </xsl:when>
+                            <xsl:otherwise/>
+                        </xsl:choose>
+                    </xsl:if>
+                </xsl:when>
+                <xsl:when test="$key = ('Enter', 'Backspace')">
+                    <xsl:variable name="selection" select="local:selection()"/>
+                    <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
+                        <xsl:variable name="range" select="local:caret-range()"/>
+                        <xsl:choose>
+                            <xsl:when test="$key = 'Enter'">
+                                <xsl:call-template name="local:handle-enter">
+                                    <xsl:with-param name="host" select="."/>
+                                    <xsl:with-param name="event" select="$event"/>
+                                    <xsl:with-param name="range" select="$range"/>
+                                </xsl:call-template>
+                            </xsl:when>
+                            <!-- Backspace intercepts only collapsed carets; everything else stays native (B1) -->
+                            <xsl:when test="ixsl:get($selection, 'isCollapsed')">
+                                <xsl:call-template name="local:handle-backspace">
+                                    <xsl:with-param name="host" select="."/>
+                                    <xsl:with-param name="event" select="$event"/>
+                                    <xsl:with-param name="range" select="$range"/>
+                                </xsl:call-template>
+                            </xsl:when>
+                        </xsl:choose>
+                    </xsl:if>
+                </xsl:when>
+                <xsl:otherwise/>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- undo chords also work with focus on the page background, and a mouse sweep
+         from the background leaves focus there: the cross-host gestures must fire
+         from body too. Plain Ctrl+A without a region-engaging selection stays
+         native - whole-page select-all is never hijacked on a host page -->
+    <xsl:template match="body" mode="ixsl:onkeydown">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="key" as="xs:string" select="string(ixsl:get($event, 'key'))"/>
+        <xsl:variable name="chord" as="xs:boolean"
+            select="(ixsl:get($event, 'ctrlKey') or ixsl:get($event, 'metaKey')) and not(ixsl:get($event, 'altKey'))"/>
+        <xsl:if test="ixsl:call(ixsl:get($event, 'target'), 'isSameNode', [ . ])">
+            <xsl:choose>
+                <xsl:when test="$chord and lower-case($key) = 'z' and not(ixsl:get($event, 'shiftKey'))">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:apply-undo"/>
+                </xsl:when>
+                <xsl:when test="$chord and ((lower-case($key) = 'z' and ixsl:get($event, 'shiftKey'))
+                        or (lower-case($key) = 'y' and not(ixsl:get($event, 'shiftKey'))))">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:apply-redo"/>
+                </xsl:when>
+                <!-- Docs-style: select-all from the page background selects editor
+                     content, never the page - the swept region when a cross-host
+                     selection exists, else the active region (selection anchor,
+                     last focused host, first region). Native page select-all only
+                     when no editable region exists at all -->
+                <xsl:when test="$chord and lower-case($key) = 'a' and not(ixsl:get($event, 'shiftKey'))">
+                    <xsl:variable name="range" select="local:caret-range()"/>
+                    <xsl:variable name="region" as="element()?" select="
+                        if (local:selection-crosses-hosts())
+                        then (local:root-of(ixsl:get($range, 'startContainer')),
+                            local:roots()[ixsl:call($range, 'intersectsNode', [ . ])])[1]
+                        else local:active-root()"/>
+                    <xsl:for-each select="$region">
+                        <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                        <xsl:call-template name="local:select-region">
+                            <xsl:with-param name="region" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                </xsl:when>
+                <xsl:when test="not($chord) and $key = ('Backspace', 'Delete')
+                        and local:selection-crosses-hosts()">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:delete-cross-host-selection"/>
+                </xsl:when>
+                <!-- type-to-replace works from the page background too: the delete
+                     machine focuses a host, the character lands at its caret -->
+                <xsl:when test="not($chord) and string-length($key) = 1
+                        and local:selection-crosses-hosts()">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:delete-cross-host-selection"/>
+                    <xsl:call-template name="local:insert-text-at-caret">
+                        <xsl:with-param name="text" select="$key"/>
+                    </xsl:call-template>
+                    <xsl:call-template name="local:after-mutation"/>
+                </xsl:when>
+                <!-- a background-ended sweep leaves focus on body: Shift+Up/Down keep
+                     extending the cross-host selection block-wise from here too -->
+                <xsl:when test="not($chord) and ixsl:get($event, 'shiftKey') and not(ixsl:get($event, 'altKey'))
+                        and $key = ('ArrowUp', 'ArrowDown') and local:selection-crosses-hosts()">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:extend-selection-block-wise">
+                        <xsl:with-param name="direction" select="if ($key = 'ArrowUp') then 'up' else 'down'"/>
+                    </xsl:call-template>
+                </xsl:when>
+                <xsl:otherwise/>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- a focused block image or object-block island is a navigation island: plain
+         arrow keys move to the adjacent target (island <-> caret), matching
+         text-block crossing, and Backspace/Delete removes it (an image goes with
+         its figure). Since an island can't hold a caret, these keys are the only
+         way keyboard editing reaches or leaves it -->
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//*[self::img or local:island(.)]" mode="ixsl:onkeydown">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="key" as="xs:string" select="string(ixsl:get($event, 'key'))"/>
+        <!-- Ctrl/Cmd+A on a selected island selects its whole region: the island is
+             its own fully-selected unit, so this is stage 2 directly -->
+        <xsl:if test="empty(ancestor::*[@contenteditable = 'true'])
+                and (ixsl:get($event, 'ctrlKey') or ixsl:get($event, 'metaKey'))
+                and not(ixsl:get($event, 'altKey')) and not(ixsl:get($event, 'shiftKey'))
+                and lower-case($key) = 'a'">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:for-each select="local:root-of(.)">
+                <xsl:call-template name="local:select-region">
+                    <xsl:with-param name="region" select="."/>
+                </xsl:call-template>
+            </xsl:for-each>
+        </xsl:if>
+        <!-- undo/redo chords work with focus on a selected island too - e.g. right
+             after an insert or B3 selects one (native undo is replaced globally) -->
+        <xsl:if test="empty(ancestor::*[@contenteditable = 'true'])
+                and (ixsl:get($event, 'ctrlKey') or ixsl:get($event, 'metaKey'))
+                and not(ixsl:get($event, 'altKey'))">
+            <xsl:choose>
+                <xsl:when test="lower-case($key) = 'z' and not(ixsl:get($event, 'shiftKey'))">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:apply-undo"/>
+                </xsl:when>
+                <xsl:when test="(lower-case($key) = 'z' and ixsl:get($event, 'shiftKey'))
+                        or (lower-case($key) = 'y' and not(ixsl:get($event, 'shiftKey')))">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:apply-redo"/>
+                </xsl:when>
+                <xsl:otherwise/>
+            </xsl:choose>
+        </xsl:if>
+        <xsl:if test="empty(ancestor::*[@contenteditable = 'true'])
+                and not(ixsl:get($event, 'shiftKey')) and not(ixsl:get($event, 'altKey'))
+                and not(ixsl:get($event, 'ctrlKey')) and not(ixsl:get($event, 'metaKey'))">
+            <xsl:variable name="island" as="element()" select="."/>
+            <xsl:variable name="targets" as="element()*" select="local:nav-targets(.)"/>
+            <xsl:choose>
+                <xsl:when test="$key = ('ArrowDown', 'ArrowRight')">
+                    <xsl:for-each select="($targets[. &gt;&gt; $island])[1]">
+                        <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                        <xsl:call-template name="local:land-forward">
+                            <xsl:with-param name="target" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                </xsl:when>
+                <xsl:when test="$key = ('ArrowUp', 'ArrowLeft')">
+                    <xsl:for-each select="($targets[. &lt;&lt; $island])[last()]">
+                        <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                        <xsl:call-template name="local:land-backward">
+                            <xsl:with-param name="target" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                </xsl:when>
+                <!-- a selected image is deleted whole with its FIGURE when it has one,
+                     an object block deletes itself (no smaller unit, no confirm - it
+                     was explicitly selected and undo covers accidents); a bare island
+                     in a mixed container is deleted alone, never its whole list/table.
+                     The caret lands on the previous target for Backspace, the next
+                     for Delete -->
+                <!-- with a cross-host selection painted (Ctrl+A from the island), the
+                     selection wins over the island: the delete machine runs instead -->
+                <xsl:when test="$key = ('Backspace', 'Delete') and local:selection-crosses-hosts()">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:call-template name="local:delete-cross-host-selection"/>
+                </xsl:when>
+                <xsl:when test="$key = ('Backspace', 'Delete')">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:variable name="victim" as="element()"
+                        select="($island/ancestor-or-self::figure[exists(local:block-of(.))][1], $island)[1]"/>
+                    <xsl:variable name="container" as="element()?" select="$victim/parent::*"/>
+                    <xsl:variable name="outside" as="element()*"
+                        select="$targets[empty(. intersect $victim/descendant-or-self::*)]"/>
+                    <xsl:variable name="prev" as="element()?" select="($outside[. &lt;&lt; $victim])[last()]"/>
+                    <xsl:variable name="next" as="element()?" select="($outside[. &gt;&gt; $victim])[1]"/>
+                    <xsl:call-template name="local:push-undo"/>
+                    <xsl:sequence select="ixsl:call($victim, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                    <!-- a mixed container that just lost its only nested block
+                         becomes a plain text host again -->
+                    <xsl:for-each select="$container[not(contains-token(@class, 'rdfa-editor-content'))]">
+                        <xsl:call-template name="local:collapse-container">
+                            <xsl:with-param name="container" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                    <xsl:for-each select="if ($key = 'Backspace') then ($prev, $next)[1] else ($next, $prev)[1]">
+                        <xsl:choose>
+                            <xsl:when test=". is $prev">
+                                <xsl:call-template name="local:land-backward">
+                                    <xsl:with-param name="target" select="."/>
+                                </xsl:call-template>
+                            </xsl:when>
+                            <xsl:otherwise>
+                                <xsl:call-template name="local:land-forward">
+                                    <xsl:with-param name="target" select="."/>
+                                </xsl:call-template>
+                            </xsl:otherwise>
+                        </xsl:choose>
+                    </xsl:for-each>
+                    <xsl:call-template name="local:after-mutation"/>
+                </xsl:when>
+                <xsl:otherwise/>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- a focused block image or object-block island becomes the active block, so
+         toolbar/breadcrumb resolve to it (or its figure) just as they do for a
+         focused editable host (mirrors the contenteditable onfocusin above) -->
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//*[self::img or local:island(.)]" mode="ixsl:onfocusin">
+        <xsl:if test="empty(ancestor::*[@contenteditable = 'true'])">
+            <ixsl:set-property name="activeBlock" select="." object="local:editor-state()"/>
+            <xsl:call-template name="local:update-breadcrumb"/>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="local:handle-enter">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="event"/>
+        <xsl:param name="range"/>
+
+        <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:push-undo">
+            <xsl:with-param name="host" select="$host"/>
+        </xsl:call-template>
+        <xsl:if test="not(ixsl:get($range, 'collapsed'))">
+            <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+
+        <xsl:choose>
+            <!-- E1: Shift+Enter = line break -->
+            <xsl:when test="ixsl:get($event, 'shiftKey')">
+                <xsl:call-template name="local:insert-at-caret">
+                    <xsl:with-param name="node" select="local:element('br')"/>
+                    <xsl:with-param name="range" select="$range"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- E2: line structure inside pre is text -->
+            <xsl:when test="$host/self::pre">
+                <xsl:call-template name="local:insert-at-caret">
+                    <xsl:with-param name="node" select="ixsl:call(ixsl:page(), 'createTextNode', [ '&#10;' ])"/>
+                    <xsl:with-param name="range" select="$range"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- E2b: Enter in a table cell steps down the column, growing the table -->
+            <xsl:when test="$host/self::td or $host/self::th">
+                <xsl:call-template name="local:table-enter">
+                    <xsl:with-param name="host" select="$host"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- E4a: Enter on the empty last item of a NESTED list outdents one
+                 level (progressive: each press lifts it until it reaches the top) -->
+            <xsl:when test="$host/self::li and local:block-text($host) = ''
+                    and empty($host/following-sibling::li) and exists($host/parent::*/parent::li)">
+                <xsl:call-template name="local:list-outdent">
+                    <xsl:with-param name="item" select="$host"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- E4b: Enter on the empty last item of a list exits it - the paragraph
+                 anchors after the list BEFORE anything is removed (a sole-item list
+                 disappears with it), so the exit lands where the list was: at the
+                 region for top-level lists, inside the cell/quote for nested ones -->
+            <xsl:when test="$host/self::li and local:block-text($host) = '' and empty($host/following-sibling::li)">
+                <xsl:variable name="list" as="element()" select="$host/parent::*"/>
+                <xsl:call-template name="local:insert-empty-paragraph">
+                    <xsl:with-param name="after" select="$list"/>
+                </xsl:call-template>
+                <xsl:sequence select="ixsl:call($host, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:if test="empty($list/li)">
+                    <xsl:sequence select="ixsl:call($list, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:if>
+            </xsl:when>
+            <!-- E6: Enter in a figure/table caption starts a paragraph after the
+                 figure/table itself - which may be nested inside an item or cell -->
+            <xsl:when test="$host/self::figcaption or $host/self::caption">
+                <xsl:call-template name="local:insert-empty-paragraph">
+                    <xsl:with-param name="after" select="$host/parent::*"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- E3/E5/E7/E8: split, never through an annotation (the split point moves
+                 behind the outermost RDFa-attributed ancestor so the graph is unchanged) -->
+            <xsl:otherwise>
+                <xsl:for-each select="local:enclosing-annotation(ixsl:get($range, 'startContainer'), $host)">
+                    <xsl:sequence select="ixsl:call($range, 'setStartAfter', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:sequence select="ixsl:call($range, 'collapse', [ true() ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+                <xsl:call-template name="local:split-block">
+                    <xsl:with-param name="host" select="$host"/>
+                    <xsl:with-param name="range" select="$range"/>
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+        <xsl:call-template name="local:after-mutation"/>
+    </xsl:template>
+
+    <!-- a fresh empty paragraph after a block: the <br> is the browser-standard caret
+         placeholder for empty editable elements (dropped again by canonical-xhtml.xsl) -->
+    <xsl:template name="local:insert-empty-paragraph">
+        <xsl:param name="after" as="element()?"/>
+
+        <xsl:variable name="p" as="element()" select="local:element('p')"/>
+        <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:choose>
+            <xsl:when test="exists($after)">
+                <xsl:sequence select="ixsl:call($after, 'after', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:for-each select="local:active-root()">
+                    <xsl:sequence select="ixsl:call(., 'appendChild', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+        <ixsl:set-attribute name="contenteditable" select="'true'" object="$p"/>
+        <xsl:if test="$p/parent::*[contains-token(@class, 'rdfa-editor-content')]">
+            <xsl:call-template name="local:inject-chrome">
+                <xsl:with-param name="block" select="$p"/>
+            </xsl:call-template>
+        </xsl:if>
+        <xsl:call-template name="local:focus-caret">
+    <xsl:with-param name="node" select="$p"/>
+    <xsl:with-param name="offset" select="local:chrome-count($p)"/>
+</xsl:call-template>
+    </xsl:template>
+
+    <xsl:template name="local:insert-at-caret">
+        <xsl:param name="node"/>
+        <xsl:param name="range"/>
+
+        <xsl:sequence select="ixsl:call($range, 'insertNode', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:place-caret">
+            <xsl:with-param name="node" select="ixsl:get($node, 'parentNode')"/>
+            <xsl:with-param name="offset" select="count($node/preceding-sibling::node()) + 1"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- move everything from the caret to the end of the host into a fresh sibling
+         of the same name; inline elements wholly after the caret move intact.
+         Splitting a run wrapper promotes it: the marker class comes off the first
+         half (the fresh second half never has it) - a structural edit makes both
+         halves real paragraphs -->
+    <xsl:template name="local:split-block">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="range"/>
+
+        <xsl:if test="contains-token($host/@class, 'rdfa-editor-run')">
+            <xsl:sequence select="ixsl:call(ixsl:get($host, 'classList'), 'remove',
+                [ 'rdfa-editor-run' ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+        <xsl:sequence select="ixsl:call($range, 'setEnd', [ $host, xs:integer(ixsl:get($host, 'childNodes.length')) ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:variable name="fragment" select="ixsl:call($range, 'extractContents', [])"/>
+        <xsl:variable name="new" as="element()" select="ixsl:call(ixsl:page(), 'createElement', [ local-name($host) ])"/>
+        <xsl:sequence select="ixsl:call($new, 'appendChild', [ $fragment ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:sequence select="ixsl:call($host, 'after', [ $new ])[current-date() lt xs:date('2000-01-01')]"/>
+        <ixsl:set-attribute name="contenteditable" select="'true'" object="$new"/>
+        <!-- chrome is a top-level affordance: nested hosts (li, quote paragraphs,
+             cell blocks) never carry a drag handle -->
+        <xsl:if test="$host/parent::*[contains-token(@class, 'rdfa-editor-content')]">
+            <xsl:call-template name="local:inject-chrome">
+                <xsl:with-param name="block" select="$new"/>
+            </xsl:call-template>
+        </xsl:if>
+        <!-- a split at either extreme leaves one empty half -->
+        <xsl:call-template name="local:ensure-placeholder">
+            <xsl:with-param name="host" select="$host"/>
+        </xsl:call-template>
+        <xsl:call-template name="local:ensure-placeholder">
+            <xsl:with-param name="host" select="$new"/>
+        </xsl:call-template>
+        <xsl:call-template name="local:focus-caret">
+    <xsl:with-param name="node" select="$new"/>
+    <xsl:with-param name="offset" select="local:chrome-count($new)"/>
+</xsl:call-template>
+    </xsl:template>
+
+    <xsl:template name="local:handle-backspace">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="event"/>
+        <xsl:param name="range"/>
+
+        <!-- B1: anywhere but the block start stays native -->
+        <xsl:if test="local:at-start($host, $range)">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:choose>
+                <!-- B4: a list item merges into the visually preceding line - the
+                     deepest last host of the previous item (which may be a container
+                     holding a nested list); a previous item ending in a composite
+                     is a hard boundary (merge-host-in returns nothing - inert) -->
+                <xsl:when test="$host/self::li and exists($host/preceding-sibling::li)">
+                    <xsl:for-each select="local:merge-host-in($host/preceding-sibling::li[1])">
+                        <xsl:call-template name="local:push-undo">
+                            <xsl:with-param name="host" select="$host"/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:merge-into-previous">
+                            <xsl:with-param name="host" select="$host"/>
+                            <xsl:with-param name="prev" select="."/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:after-mutation"/>
+                    </xsl:for-each>
+                </xsl:when>
+                <!-- B4b: the first item of a NESTED list outdents (mirrors Shift+Tab) -->
+                <xsl:when test="$host/self::li and exists($host/parent::*/parent::li)">
+                    <xsl:call-template name="local:list-outdent">
+                        <xsl:with-param name="item" select="$host"/>
+                    </xsl:call-template>
+                </xsl:when>
+                <!-- B4c: the first item of a list nested in a container (cell,
+                     quote, dd) merges into the preceding line inside it; the
+                     emptied list goes and the container collapses back to a text
+                     host - composites (table, figure) stay hard boundaries -->
+                <xsl:when test="$host/self::li
+                        and $host/parent::*/parent::*[not(contains-token(@class, 'rdfa-editor-content'))]
+                        and exists(local:merge-host-in($host/parent::*/preceding-sibling::*[not(@data-role)][1]))">
+                    <xsl:variable name="list" as="element()" select="$host/parent::*"/>
+                    <xsl:variable name="container" as="element()" select="$list/parent::*"/>
+                    <!-- the caret target must survive the merge AND the collapse
+                         unwrap (text-node references ride through both moves) -->
+                    <xsl:variable name="first-text" select="($host//text()[not(ancestor::*[@data-role])])[1]"/>
+                    <xsl:call-template name="local:push-undo">
+                        <xsl:with-param name="host" select="$host"/>
+                    </xsl:call-template>
+                    <xsl:call-template name="local:merge-into-previous">
+                        <xsl:with-param name="host" select="$host"/>
+                        <xsl:with-param name="prev" select="local:merge-host-in(
+                            $list/preceding-sibling::*[not(@data-role)][1])"/>
+                    </xsl:call-template>
+                    <xsl:if test="empty($list/li)">
+                        <xsl:sequence select="ixsl:call($list, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:if>
+                    <xsl:call-template name="local:collapse-container">
+                        <xsl:with-param name="container" select="$container"/>
+                    </xsl:call-template>
+                    <xsl:choose>
+                        <xsl:when test="exists($first-text)">
+                            <xsl:call-template name="local:focus-caret">
+                                <xsl:with-param name="node" select="$first-text"/>
+                                <xsl:with-param name="offset" select="0"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <xsl:otherwise>
+                            <xsl:for-each select="local:last-host-in($container)">
+                                <xsl:call-template name="local:focus-caret">
+                                    <xsl:with-param name="node" select="."/>
+                                    <xsl:with-param name="offset"
+                                        select="count(node()) - count(node()[last()][self::br])"/>
+                                </xsl:call-template>
+                            </xsl:for-each>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                    <xsl:call-template name="local:after-mutation"/>
+                </xsl:when>
+                <!-- B5: the first item of a top-level list (or of a list with
+                     nothing mergeable before it) is inert -->
+                <xsl:when test="$host/self::li"/>
+                <!-- B6: cells, captions and pre absorb Backspace-at-start (never merge away) -->
+                <xsl:when test="$host/self::figcaption or $host/self::pre
+                        or $host/self::td or $host/self::th or $host/self::caption"/>
+                <xsl:otherwise>
+                    <xsl:variable name="prev" as="element()?" select="$host/preceding-sibling::*[1]"/>
+                    <xsl:choose>
+                        <!-- B2: text blocks merge -->
+                        <xsl:when test="$prev[self::p or self::h1 or self::h2 or self::h3]">
+                            <xsl:call-template name="local:push-undo">
+                                <xsl:with-param name="host" select="$host"/>
+                            </xsl:call-template>
+                            <xsl:call-template name="local:merge-into-previous">
+                                <xsl:with-param name="host" select="$host"/>
+                                <xsl:with-param name="prev" select="$prev"/>
+                            </xsl:call-template>
+                            <xsl:call-template name="local:after-mutation"/>
+                        </xsl:when>
+                        <!-- B2b: a preceding non-composite container (blockquote,
+                             list) merges into its last editable host, never into
+                             the container itself (bare text there would be invalid;
+                             tables and figures stay hard boundaries - B3 - even
+                             nested at the container's tail: merge-host-in) -->
+                        <xsl:when test="$prev[self::blockquote or self::ul or self::ol or self::dl]">
+                            <xsl:for-each select="local:merge-host-in($prev)">
+                                <xsl:call-template name="local:push-undo">
+                                    <xsl:with-param name="host" select="$host"/>
+                                </xsl:call-template>
+                                <xsl:call-template name="local:merge-into-previous">
+                                    <xsl:with-param name="host" select="$host"/>
+                                    <xsl:with-param name="prev" select="."/>
+                                </xsl:call-template>
+                                <xsl:call-template name="local:after-mutation"/>
+                            </xsl:for-each>
+                        </xsl:when>
+                        <!-- B7: the first block of a blockquote exits upward - it
+                             moves before the quote; an emptied quote is removed -->
+                        <xsl:when test="empty($prev[not(@data-role)]) and $host/parent::blockquote">
+                            <xsl:variable name="quote" as="element()" select="$host/parent::blockquote"/>
+                            <xsl:call-template name="local:push-undo">
+                                <xsl:with-param name="host" select="$host"/>
+                            </xsl:call-template>
+                            <xsl:sequence select="ixsl:call($quote, 'before', [ $host ])[current-date() lt xs:date('2000-01-01')]"/>
+                            <xsl:if test="empty($quote/*[not(@data-role)])">
+                                <xsl:sequence select="ixsl:call($quote, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                            </xsl:if>
+                            <xsl:if test="$host/parent::*[contains-token(@class, 'rdfa-editor-content')]">
+                                <xsl:call-template name="local:inject-chrome">
+                                    <xsl:with-param name="block" select="$host"/>
+                                </xsl:call-template>
+                            </xsl:if>
+                            <xsl:call-template name="local:focus-caret">
+                                <xsl:with-param name="node" select="$host"/>
+                                <xsl:with-param name="offset" select="local:chrome-count($host)"/>
+                            </xsl:call-template>
+                            <xsl:call-template name="local:after-mutation"/>
+                        </xsl:when>
+                        <!-- B3: never merge across composite blocks; an empty block is removed
+                             (a preceding island has no host to land in - it is selected) -->
+                        <xsl:when test="exists($prev[not(@data-role)]) and local:block-text($host) = ''">
+                            <xsl:call-template name="local:push-undo"/>
+                            <xsl:sequence select="ixsl:call($host, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                            <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                            <xsl:choose>
+                                <xsl:when test="local:island($prev)">
+                                    <xsl:call-template name="local:select-island">
+                                        <xsl:with-param name="element" select="$prev"/>
+                                    </xsl:call-template>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <xsl:variable name="prev-host" as="element()?"
+                                        select="($prev/descendant-or-self::*[@contenteditable = 'true'])[last()]"/>
+                                    <xsl:for-each select="$prev-host">
+                                        <xsl:call-template name="local:focus-caret">
+                                            <xsl:with-param name="node" select="."/>
+                                            <xsl:with-param name="offset" select="xs:integer(ixsl:get(., 'childNodes.length'))"/>
+                                        </xsl:call-template>
+                                    </xsl:for-each>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                            <xsl:call-template name="local:after-mutation"/>
+                        </xsl:when>
+                        <xsl:otherwise/>
+                    </xsl:choose>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- ................................ list indent/outdent ................................ -->
+
+    <!-- Tab: the item indents under its previous sibling - per ul/ol -> (li)+ the
+         nested list lives INSIDE the previous item, which becomes a container
+         (trailing nested list reused, else a fresh list of the same kind). A first
+         item has nowhere to go - flash -->
+    <xsl:template name="local:list-indent">
+        <xsl:param name="item" as="element()"/>
+
+        <xsl:variable name="prev" as="element()?" select="$item/preceding-sibling::li[1]"/>
+        <xsl:choose>
+            <xsl:when test="exists($prev)">
+                <xsl:call-template name="local:push-undo">
+                    <xsl:with-param name="host" select="$item"/>
+                </xsl:call-template>
+                <!-- text-node caret references survive reparenting -->
+                <xsl:variable name="caret-node" as="node()?" select="local:anchor-node()"/>
+                <xsl:variable name="caret-offset" as="xs:integer" select="local:anchor-offset()"/>
+                <xsl:variable name="target" as="element()?"
+                    select="$prev/*[not(@data-role)][last()][self::ul or self::ol]"/>
+                <xsl:if test="empty($target)">
+                    <xsl:for-each select="$prev[@contenteditable = 'true']">
+                        <ixsl:remove-attribute name="contenteditable"/>
+                        <xsl:call-template name="local:wrap-stray-runs">
+                            <xsl:with-param name="container" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                </xsl:if>
+                <xsl:variable name="list" as="element()" select="if (exists($target)) then $target
+                    else local:element(local-name($item/parent::*))"/>
+                <xsl:if test="empty($target)">
+                    <xsl:sequence select="ixsl:call($prev, 'appendChild', [ $list ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:if>
+                <xsl:sequence select="ixsl:call($list, 'appendChild', [ $item ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:choose>
+                    <xsl:when test="exists($caret-node)">
+                        <xsl:call-template name="local:focus-caret">
+                            <xsl:with-param name="node" select="$caret-node"/>
+                            <xsl:with-param name="offset" select="$caret-offset"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:for-each select="local:first-host-in($item)">
+                            <xsl:call-template name="local:focus-caret">
+                                <xsl:with-param name="node" select="."/>
+                                <xsl:with-param name="offset" select="0"/>
+                            </xsl:call-template>
+                        </xsl:for-each>
+                    </xsl:otherwise>
+                </xsl:choose>
+                <xsl:call-template name="local:after-mutation"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:for-each select="local:caret-range()">
+                    <xsl:call-template name="local:show-flash">
+                        <xsl:with-param name="range" select="."/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Shift+Tab (and progressive Enter/Backspace exits): the item moves after its
+         container item; following siblings demote into a nested list inside the
+         moved item (they were logically below it). The emptied nested list is
+         removed and the container collapses back to a text host when its last
+         block leaves. A top-level item has nowhere to go - flash -->
+    <xsl:template name="local:list-outdent">
+        <xsl:param name="item" as="element()"/>
+
+        <xsl:variable name="list" as="element()" select="$item/parent::*"/>
+        <xsl:variable name="container" as="element()?" select="$list/parent::li"/>
+        <xsl:choose>
+            <xsl:when test="exists($container)">
+                <xsl:call-template name="local:push-undo">
+                    <xsl:with-param name="host" select="$item"/>
+                </xsl:call-template>
+                <xsl:variable name="caret-node" as="node()?" select="local:anchor-node()"/>
+                <xsl:variable name="caret-offset" as="xs:integer" select="local:anchor-offset()"/>
+                <xsl:variable name="followers" as="element()*" select="$item/following-sibling::li"/>
+                <xsl:if test="exists($followers)">
+                    <xsl:variable name="target" as="element()?"
+                        select="$item/*[not(@data-role)][last()][self::ul or self::ol]"/>
+                    <xsl:if test="empty($target)">
+                        <xsl:for-each select="$item[@contenteditable = 'true']">
+                            <ixsl:remove-attribute name="contenteditable"/>
+                            <xsl:call-template name="local:wrap-stray-runs">
+                                <xsl:with-param name="container" select="."/>
+                            </xsl:call-template>
+                        </xsl:for-each>
+                    </xsl:if>
+                    <xsl:variable name="sub" as="element()" select="if (exists($target)) then $target
+                        else local:element(local-name($list))"/>
+                    <xsl:if test="empty($target)">
+                        <xsl:sequence select="ixsl:call($item, 'appendChild', [ $sub ])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:if>
+                    <xsl:for-each select="$followers">
+                        <xsl:sequence select="ixsl:call($sub, 'appendChild', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:for-each>
+                </xsl:if>
+                <xsl:sequence select="ixsl:call($container, 'after', [ $item ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:if test="empty($list/li)">
+                    <xsl:sequence select="ixsl:call($list, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:if>
+                <xsl:call-template name="local:collapse-container">
+                    <xsl:with-param name="container" select="$container"/>
+                </xsl:call-template>
+                <xsl:choose>
+                    <xsl:when test="exists($caret-node)">
+                        <xsl:call-template name="local:focus-caret">
+                            <xsl:with-param name="node" select="$caret-node"/>
+                            <xsl:with-param name="offset" select="$caret-offset"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:for-each select="local:first-host-in($item)">
+                            <xsl:call-template name="local:focus-caret">
+                                <xsl:with-param name="node" select="."/>
+                                <xsl:with-param name="offset" select="0"/>
+                            </xsl:call-template>
+                        </xsl:for-each>
+                    </xsl:otherwise>
+                </xsl:choose>
+                <xsl:call-template name="local:after-mutation"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:for-each select="local:caret-range()">
+                    <xsl:call-template name="local:show-flash">
+                        <xsl:with-param name="range" select="."/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- counted firstChild moves (never iterate a live child list lazily); no
+         normalize() afterwards - the caret index depends on the node count -->
+    <xsl:template name="local:merge-into-previous">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="prev" as="element()"/>
+
+        <xsl:call-template name="local:remove-chrome">
+            <xsl:with-param name="block" select="$host"/>
+        </xsl:call-template>
+        <xsl:variable name="index" as="xs:integer" select="xs:integer(ixsl:get($prev, 'childNodes.length'))"/>
+        <xsl:for-each select="1 to xs:integer(ixsl:get($host, 'childNodes.length'))">
+            <xsl:sequence select="ixsl:call($prev, 'appendChild', [ ixsl:get($host, 'firstChild') ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:sequence select="ixsl:call($host, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+        <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+        <xsl:call-template name="local:focus-caret">
+    <xsl:with-param name="node" select="$prev"/>
+    <xsl:with-param name="offset" select="$index"/>
+</xsl:call-template>
+    </xsl:template>
+
+    <!-- ................................ paste / focus ................................ -->
+
+    <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onpaste">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:if test="exists(local:block-of(.))">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:variable name="html" as="xs:string"
+                select="string(ixsl:call(ixsl:get($event, 'clipboardData'), 'getData', [ 'text/html' ]))"/>
+            <!-- pasting over a cross-host selection is inert this iteration: the
+                 paste machines would raw-deleteContents across hosts -->
+            <xsl:choose>
+                <xsl:when test="local:selection-crosses-hosts()"/>
+                <!-- formatted paste through the canonical (sanitizing) pipeline -->
+                <xsl:when test="$html ne '' and not(self::pre)">
+                    <xsl:call-template name="local:paste-html">
+                        <xsl:with-param name="host" select="."/>
+                        <xsl:with-param name="html" select="$html"/>
+                    </xsl:call-template>
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:call-template name="local:paste-text">
+                        <xsl:with-param name="host" select="."/>
+                        <xsl:with-param name="raw" select="string(ixsl:call(ixsl:get($event, 'clipboardData'),
+                            'getData', [ 'text/plain' ]))"/>
+                    </xsl:call-template>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="local:paste-text">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="raw" as="xs:string"/>
+
+        <xsl:variable name="text" as="xs:string"
+            select="if ($host/self::pre) then $raw else normalize-space($raw)"/>
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:if test="$text ne '' and ixsl:get($selection, 'rangeCount') ge 1">
+            <xsl:variable name="range" select="local:caret-range()"/>
+            <xsl:call-template name="local:push-undo">
+                <xsl:with-param name="host" select="$host"/>
+            </xsl:call-template>
+            <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:variable name="node" select="ixsl:call(ixsl:page(), 'createTextNode', [ $text ])"/>
+            <xsl:sequence select="ixsl:call($range, 'insertNode', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:place-caret">
+                <xsl:with-param name="node" select="$node"/>
+                <xsl:with-param name="offset" select="string-length($text)"/>
+            </xsl:call-template>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- clipboard HTML: browser-parse it on a DETACHED element (scripts inert),
+         sanitize/normalize via mode="canonical" + mode="cm-normalize", then insert
+         where the content model allows - inline fragments at the caret, blocks
+         inside a flow host (li, td, ...) or as new siblings between the split
+         halves of an inline-only host; hosts that can take blocks neither way
+         (caption, dt) flatten to text -->
+    <xsl:template name="local:paste-html">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="html" as="xs:string"/>
+
+        <xsl:variable name="carrier" as="element()" select="local:element('div')"/>
+        <ixsl:set-property name="innerHTML" select="$html" object="$carrier"/>
+        <xsl:variable name="pass1">
+            <xsl:apply-templates select="$carrier/node()" mode="canonical"/>
+        </xsl:variable>
+        <xsl:variable name="clean">
+            <xsl:sequence select="cm:normalize($pass1/node())"/>
+        </xsl:variable>
+        <xsl:variable name="has-blocks" as="xs:boolean"
+            select="exists($clean/*[cm:block(local-name(.))])"/>
+        <xsl:variable name="selection" select="local:selection()"/>
+
+        <xsl:choose>
+            <xsl:when test="empty($clean/node()) or ixsl:get($selection, 'rangeCount') lt 1"/>
+            <!-- a mixed flow host takes the blocks inside itself -->
+            <xsl:when test="$has-blocks and cm:flow(local-name($host))">
+                <xsl:call-template name="local:paste-into-flow-host">
+                    <xsl:with-param name="host" select="$host"/>
+                    <xsl:with-param name="clean" select="$clean/node()"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- an inline-only host splits when its parent takes the blocks as
+                 siblings (the region by contract; blockquote, containers by model) -->
+            <xsl:when test="$has-blocks and (not(cm:known(local-name($host/parent::*)))
+                    or (every $block in $clean/*[cm:block(local-name(.))]
+                        satisfies cm:allows-child(local-name($host/parent::*), local-name($block))))">
+                <!-- stray top-level inline runs become paragraphs -->
+                <xsl:variable name="blocks" as="element()*"
+                    select="cm:wrap-inline-runs($clean/node(), 'p')[self::*]"/>
+                <xsl:variable name="range" select="local:caret-range()"/>
+                <xsl:call-template name="local:push-undo">
+                    <xsl:with-param name="host" select="$host"/>
+                </xsl:call-template>
+                <xsl:if test="not(ixsl:get($range, 'collapsed'))">
+                    <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:if>
+                <!-- split the host, then thread the pasted blocks in after the first half -->
+                <xsl:call-template name="local:split-block">
+                    <xsl:with-param name="host" select="$host"/>
+                    <xsl:with-param name="range" select="$range"/>
+                </xsl:call-template>
+                <!-- method html: XML's self-closing <p/> reads as an OPEN tag to the
+                     HTML fragment parser and swallows following siblings -->
+                <xsl:variable name="stage" as="element()" select="local:element('div')"/>
+                <ixsl:set-property name="innerHTML" select="serialize($blocks, map{ 'method': 'html' })" object="$stage"/>
+                <xsl:variable name="count" as="xs:integer" select="xs:integer(ixsl:get($stage, 'childNodes.length'))"/>
+                <xsl:iterate select="1 to $count">
+                    <xsl:param name="anchor" select="$host"/>
+                    <xsl:variable name="node" select="ixsl:get($stage, 'firstChild')"/>
+                    <xsl:sequence select="ixsl:call($anchor, 'after', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:next-iteration>
+                        <xsl:with-param name="anchor" select="$node"/>
+                    </xsl:next-iteration>
+                </xsl:iterate>
+                <xsl:for-each select="$host/following-sibling::*[position() le $count]">
+                    <xsl:call-template name="local:init-block">
+                        <xsl:with-param name="block" select="."/>
+                    </xsl:call-template>
+                </xsl:for-each>
+                <!-- caret at the end of the last pasted block's last editable host -->
+                <xsl:variable name="last" as="element()?" select="$host/following-sibling::*[$count]"/>
+                <xsl:for-each select="($last/descendant-or-self::*[@contenteditable = 'true'])[last()]">
+                    <xsl:call-template name="local:focus-caret">
+    <xsl:with-param name="node" select="."/>
+    <xsl:with-param name="offset" select="count(node()) - count(node()[last()][self::br])"/>
+</xsl:call-template>
+                </xsl:for-each>
+                <xsl:call-template name="local:after-mutation"/>
+            </xsl:when>
+            <!-- blocks fit neither inside the host nor beside it (caption, dt):
+                 flatten to sanitized text -->
+            <xsl:when test="$has-blocks">
+                <xsl:call-template name="local:paste-text">
+                    <xsl:with-param name="host" select="$host"/>
+                    <xsl:with-param name="raw" select="string($clean)"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- inline-only fragment: insert at the caret -->
+            <xsl:otherwise>
+                <xsl:variable name="range" select="local:caret-range()"/>
+                <xsl:call-template name="local:push-undo">
+                    <xsl:with-param name="host" select="$host"/>
+                </xsl:call-template>
+                <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:variable name="stage" as="element()" select="local:element('div')"/>
+                <ixsl:set-property name="innerHTML" select="serialize($clean/node(), map{ 'method': 'html' })" object="$stage"/>
+                <xsl:variable name="last" select="ixsl:get($stage, 'lastChild')"/>
+                <xsl:variable name="fragment" select="ixsl:call(ixsl:page(), 'createDocumentFragment', [])"/>
+                <xsl:for-each select="1 to xs:integer(ixsl:get($stage, 'childNodes.length'))">
+                    <xsl:sequence select="ixsl:call($fragment, 'appendChild', [ ixsl:get($stage, 'firstChild') ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+                <xsl:sequence select="ixsl:call($range, 'insertNode', [ $fragment ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:for-each select="$last">
+                    <xsl:call-template name="local:place-caret">
+                        <xsl:with-param name="node" select="ixsl:get(., 'parentNode')"/>
+                        <xsl:with-param name="offset" select="count(preceding-sibling::node()) + 1"/>
+                    </xsl:call-template>
+                </xsl:for-each>
+                <xsl:call-template name="local:after-mutation"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- blocks paste INSIDE a mixed flow host (li, td, th, dd, figcaption): the
+         host's content splits around the caret into head and tail runs with the
+         blocks between them, and re-init turns the host into a container (stray
+         runs wrapped as p.rdfa-editor-run, nested blocks inited recursively) -->
+    <xsl:template name="local:paste-into-flow-host">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="clean" as="node()*"/>
+
+        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:call-template name="local:push-undo">
+            <xsl:with-param name="host" select="$host"/>
+        </xsl:call-template>
+        <xsl:if test="not(ixsl:get($range, 'collapsed'))">
+            <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+        <!-- the tail (caret to end of host) rides out as HTML -->
+        <xsl:sequence select="ixsl:call($range, 'setEnd', [ $host, xs:integer(ixsl:get($host, 'childNodes.length')) ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:variable name="tail-stage" as="element()" select="local:element('div')"/>
+        <xsl:sequence select="ixsl:call($tail-stage, 'appendChild',
+            [ ixsl:call($range, 'extractContents', []) ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:remove-chrome">
+            <xsl:with-param name="block" select="$host"/>
+        </xsl:call-template>
+        <ixsl:set-property name="innerHTML" select="string(ixsl:get($host, 'innerHTML'))
+            || serialize($clean, map{ 'method': 'html' })
+            || string(ixsl:get($tail-stage, 'innerHTML'))" object="$host"/>
+        <!-- re-init decides text host vs container afresh -->
+        <xsl:for-each select="$host">
+            <ixsl:remove-attribute name="contenteditable"/>
+        </xsl:for-each>
+        <xsl:call-template name="local:init-block">
+            <xsl:with-param name="block" select="$host"/>
+        </xsl:call-template>
+        <!-- caret at the end of the last editable host in the rebuilt container -->
+        <xsl:for-each select="($host/descendant-or-self::*[@contenteditable = 'true'])[last()]">
+            <xsl:call-template name="local:focus-caret">
+                <xsl:with-param name="node" select="."/>
+                <xsl:with-param name="offset" select="count(node()) - count(node()[last()][self::br])"/>
+            </xsl:call-template>
+        </xsl:for-each>
+        <xsl:call-template name="local:after-mutation"/>
+    </xsl:template>
+
+    <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onfocusin">
+        <xsl:if test="exists(local:block-of(.))">
+            <ixsl:set-property name="activeBlock" select="." object="local:editor-state()"/>
+            <xsl:call-template name="local:update-breadcrumb"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- ................................ toolbar ................................ -->
+
+    <!-- buttons must not steal the selection they act on -->
+    <xsl:template match="div[@id = 'edit-toolbar']//button" mode="ixsl:onmousedown">
+        <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <!-- the select acts on the HOST the caret sits in (a paragraph inside a quote
+         converts alone, leaving the quote intact); quote wrapping lives on the
+         format-quote toggle -->
+    <xsl:template match="select[@name = 'block-type']" mode="ixsl:onchange">
+        <xsl:variable name="name" as="xs:string" select="string(ixsl:get(., 'value'))"/>
+        <xsl:for-each select="local:current-host()[self::p or self::h1 or self::h2 or self::h3
+                or self::pre][exists(local:block-of(.))][local-name() ne $name]">
+            <xsl:call-template name="local:convert-block">
+                <xsl:with-param name="block" select="."/>
+                <xsl:with-param name="name" select="$name"/>
+            </xsl:call-template>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- the quote toggle: wrapping keeps the block's name, editability and caret
+         (text nodes survive reparenting); chrome moves to a new top-level quote.
+         Wrapping a run wrapper promotes it (blockquote > bare run would unwrap to
+         invalid bare text at canonicalization) -->
+    <xsl:template name="local:wrap-in-blockquote">
+        <xsl:param name="block" as="element()"/>
+
+        <xsl:call-template name="local:push-undo">
+            <xsl:with-param name="host" select="$block"/>
+        </xsl:call-template>
+        <xsl:if test="contains-token($block/@class, 'rdfa-editor-run')">
+            <xsl:sequence select="ixsl:call(ixsl:get($block, 'classList'), 'remove',
+                [ 'rdfa-editor-run' ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+        <xsl:variable name="quote" as="element()" select="local:element('blockquote')"/>
+        <xsl:sequence select="ixsl:call($block, 'before', [ $quote ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:remove-chrome">
+            <xsl:with-param name="block" select="$block"/>
+        </xsl:call-template>
+        <xsl:sequence select="ixsl:call($quote, 'appendChild', [ $block ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:if test="$quote/parent::*[contains-token(@class, 'rdfa-editor-content')]">
+            <xsl:call-template name="local:inject-chrome">
+                <xsl:with-param name="block" select="$quote"/>
+            </xsl:call-template>
+        </xsl:if>
+        <ixsl:set-property name="activeBlock" select="$block" object="local:editor-state()"/>
+        <xsl:call-template name="local:focus">
+            <xsl:with-param name="element" select="$block"/>
+        </xsl:call-template>
+        <xsl:call-template name="local:after-mutation"/>
+    </xsl:template>
+
+    <!-- the quote toggle off: all children move out (counted sibling inserts) and
+         re-init (chrome iff now top-level); refused with a flash when the quote
+         carries RDFa attributes - unwrapping would silently drop triples -->
+    <xsl:template name="local:unwrap-blockquote">
+        <xsl:param name="quote" as="element()"/>
+
+        <xsl:choose>
+            <xsl:when test="$quote/@property or $quote/@about or $quote/@typeof
+                    or $quote/@resource or $quote/@content or $quote/@datatype">
+                <xsl:for-each select="local:caret-range()">
+                    <xsl:call-template name="local:show-flash">
+                        <xsl:with-param name="range" select="."/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:push-undo">
+                    <xsl:with-param name="host" select="$quote"/>
+                </xsl:call-template>
+                <xsl:variable name="caret-node" as="node()?" select="local:anchor-node()"/>
+                <xsl:variable name="caret-offset" as="xs:integer" select="local:anchor-offset()"/>
+                <xsl:call-template name="local:remove-chrome">
+                    <xsl:with-param name="block" select="$quote"/>
+                </xsl:call-template>
+                <xsl:variable name="inner" as="element()*" select="$quote/*"/>
+                <xsl:for-each select="1 to xs:integer(ixsl:get($quote, 'childNodes.length'))">
+                    <xsl:sequence select="ixsl:call($quote, 'before', [ ixsl:get($quote, 'firstChild') ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+                <xsl:sequence select="ixsl:call($quote, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:for-each select="$inner">
+                    <xsl:call-template name="local:init-block">
+                        <xsl:with-param name="block" select="."/>
+                    </xsl:call-template>
+                </xsl:for-each>
+                <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                <xsl:choose>
+                    <xsl:when test="exists($caret-node)">
+                        <xsl:call-template name="local:focus-caret">
+                            <xsl:with-param name="node" select="$caret-node"/>
+                            <xsl:with-param name="offset" select="$caret-offset"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:for-each select="local:first-host-in($inner[1])">
+                            <xsl:call-template name="local:focus-caret">
+                                <xsl:with-param name="node" select="."/>
+                                <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+                            </xsl:call-template>
+                        </xsl:for-each>
+                    </xsl:otherwise>
+                </xsl:choose>
+                <xsl:call-template name="local:after-mutation"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'format-quote')]" mode="ixsl:onclick">
+        <xsl:variable name="host" as="element()?" select="local:current-host()[exists(local:block-of(.))]"/>
+        <!-- clamped at the region root: a host-page blockquote wrapping an
+             embedded region is not ours to unwrap -->
+        <xsl:variable name="quote" as="element()?"
+            select="$host/ancestor-or-self::blockquote[exists(local:block-of(.))][1]"/>
+        <xsl:choose>
+            <xsl:when test="exists($quote)">
+                <xsl:call-template name="local:unwrap-blockquote">
+                    <xsl:with-param name="quote" select="$quote"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- wrap the host block where its parent admits a blockquote (the
+                 region by contract; flow containers and blockquote by model) -->
+            <xsl:when test="$host[cm:block(local-name(.))]
+                    [parent::*[contains-token(@class, 'rdfa-editor-content')]
+                        or cm:allows-child(local-name(parent::*), 'blockquote')]">
+                <xsl:call-template name="local:wrap-in-blockquote">
+                    <xsl:with-param name="block" select="$host"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:for-each select="local:caret-range()">
+                    <xsl:call-template name="local:show-flash">
+                        <xsl:with-param name="range" select="."/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- rename by rebuild: copy RDFa/lang attributes, move children (text-node
+         references survive reparenting, so the caret can be restored exactly) -->
+    <xsl:template name="local:convert-block">
+        <xsl:param name="block" as="element()"/>
+        <xsl:param name="name" as="xs:string"/>
+        <!-- optionally pre-captured by the caller (unwrap+rename is one undo entry);
+             the defaults mirror local:push-undo's capture-now behavior -->
+        <xsl:param name="snapshot-root" as="element()?" select="local:active-root()"/>
+        <xsl:param name="snapshot" as="xs:string?"
+            select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
+
+        <xsl:call-template name="local:push-undo">
+            <xsl:with-param name="root" select="$snapshot-root"/>
+            <xsl:with-param name="snapshot" select="$snapshot"/>
+        </xsl:call-template>
+        <!-- host-of, not block-of: $block may be a nested host (a paragraph in a
+             quote or cell) whose top-level block is the container. Restore only a
+             node that MOVES with the children (a descendant); an element-level
+             caret on the block itself dangles after replaceWith, so it falls back
+             to the start of the new block (matters for empty-block conversions) -->
+        <xsl:variable name="caret-node" as="node()?"
+            select="local:anchor-node()[local:host-of(.) is $block][not(. is $block)]"/>
+        <xsl:variable name="caret-offset" as="xs:integer"
+            select="if (exists($caret-node)) then local:anchor-offset() else 0"/>
+
+        <xsl:variable name="new" as="element()" select="ixsl:call(ixsl:page(), 'createElement', [ $name ])"/>
+        <xsl:for-each select="$block/(@about | @property | @typeof | @resource | @content
+                | @datatype | @lang | @xml:lang | @contenteditable)">
+            <ixsl:set-attribute name="{name()}" select="string(.)" object="$new"/>
+        </xsl:for-each>
+        <xsl:for-each select="1 to xs:integer(ixsl:get($block, 'childNodes.length'))">
+            <xsl:sequence select="ixsl:call($new, 'appendChild', [ ixsl:get($block, 'firstChild') ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:sequence select="ixsl:call($block, 'replaceWith', [ $new ])[current-date() lt xs:date('2000-01-01')]"/>
+        <ixsl:set-property name="activeBlock" select="$new" object="local:editor-state()"/>
+        <xsl:call-template name="local:focus">
+            <xsl:with-param name="element" select="$new"/>
+        </xsl:call-template>
+        <xsl:choose>
+            <xsl:when test="exists($caret-node)">
+                <xsl:call-template name="local:place-caret">
+                    <xsl:with-param name="node" select="$caret-node"/>
+                    <xsl:with-param name="offset" select="$caret-offset"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:place-caret">
+                    <xsl:with-param name="node" select="$new"/>
+                    <xsl:with-param name="offset" select="local:chrome-count($new)"/>
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+        <xsl:call-template name="local:after-mutation"/>
+    </xsl:template>
+
+    <!-- inline formatting toggles reuse the annotation wrap/unwrap machinery -->
+    <xsl:template match="button[contains-token(@class, 'format-inline')]" mode="ixsl:onclick">
+        <xsl:variable name="name" as="xs:string" select="string(@data-element)"/>
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
+            <xsl:variable name="range" select="local:caret-range()"/>
+            <xsl:variable name="anchor" select="ixsl:get($selection, 'anchorNode')"/>
+            <xsl:for-each select="local:host-of($anchor)[exists(local:block-of(.))]">
+                <xsl:variable name="existing" as="element()?"
+                    select="($anchor/ancestor-or-self::*[local-name() = $name] intersect descendant::*)[1]"/>
+                <xsl:choose>
+                    <xsl:when test="exists($existing)">
+                        <xsl:call-template name="local:push-undo"/>
+                        <xsl:call-template name="local:unwrap-element">
+                            <xsl:with-param name="element" select="$existing"/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:after-mutation"/>
+                    </xsl:when>
+                    <xsl:when test="not(ixsl:get($selection, 'isCollapsed'))">
+                        <!-- capture pre-wrap state; push only when the wrap succeeded -->
+                        <xsl:variable name="snapshot-root" as="element()?" select="local:active-root()"/>
+                        <xsl:variable name="snapshot" as="xs:string?"
+                            select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
+                        <xsl:variable name="wrapped" as="element()?">
+                            <xsl:call-template name="local:wrap-range">
+                                <xsl:with-param name="range" select="$range"/>
+                                <xsl:with-param name="name" select="$name"/>
+                            </xsl:call-template>
+                        </xsl:variable>
+                        <xsl:for-each select="$wrapped">
+                            <xsl:call-template name="local:push-undo">
+                                <xsl:with-param name="root" select="$snapshot-root"/>
+                                <xsl:with-param name="snapshot" select="$snapshot"/>
+                            </xsl:call-template>
+                            <xsl:call-template name="local:after-mutation"/>
+                        </xsl:for-each>
+                    </xsl:when>
+                    <xsl:otherwise/>
+                </xsl:choose>
+            </xsl:for-each>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- places a freshly created block per the content model: after the caret's
+         host when its parent admits the kind (region children by contract; a
+         paragraph in a cell or quote gets the block as its sibling), INSIDE a leaf
+         flow host otherwise (a cell or list item grows a nested block, becoming a
+         container), after the current top-level block as a last resort (caption,
+         dt). Chrome stays a top-level affordance -->
+    <xsl:template name="local:insert-block-at-caret">
+        <xsl:param name="node" as="element()"/>
+        <!-- dialog saves pass the host their dialog was opened from (the caret
+             sits in the dialog input by then); defaulted for the direct buttons -->
+        <xsl:param name="host" as="element()?" select="local:current-host()[exists(local:block-of(.))]"/>
+
+        <xsl:choose>
+            <!-- not inside a figure: the figure is a locked composite, so a block
+                 inserted at its caption nests INSIDE the figcaption (flow branch)
+                 rather than growing the figure's children -->
+            <xsl:when test="$host[not(parent::figure)][parent::*[contains-token(@class, 'rdfa-editor-content')]
+                    or cm:allows-child(local-name(parent::*), local-name($node))]">
+                <xsl:sequence select="ixsl:call($host, 'after', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:when>
+            <xsl:when test="$host[cm:flow(local-name(.))]">
+                <xsl:for-each select="$host">
+                    <ixsl:remove-attribute name="contenteditable"/>
+                </xsl:for-each>
+                <xsl:call-template name="local:wrap-stray-runs">
+                    <xsl:with-param name="container" select="$host"/>
+                </xsl:call-template>
+                <xsl:sequence select="ixsl:call($host, 'appendChild', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:when>
+            <xsl:when test="exists(local:current-block())">
+                <xsl:sequence select="ixsl:call(local:current-block(), 'after', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:for-each select="local:active-root()">
+                    <xsl:sequence select="ixsl:call(., 'appendChild', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+        <xsl:if test="$node/parent::*[contains-token(@class, 'rdfa-editor-content')]">
+            <xsl:call-template name="local:inject-chrome">
+                <xsl:with-param name="block" select="$node"/>
+            </xsl:call-template>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'insert-block')]" mode="ixsl:onclick">
+        <xsl:call-template name="local:push-undo"/>
+        <xsl:variable name="p" as="element()" select="local:element('p')"/>
+        <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+        <ixsl:set-attribute name="contenteditable" select="'true'" object="$p"/>
+        <xsl:call-template name="local:insert-block-at-caret">
+            <xsl:with-param name="node" select="$p"/>
+        </xsl:call-template>
+        <xsl:call-template name="local:focus-caret">
+            <xsl:with-param name="node" select="$p"/>
+            <xsl:with-param name="offset" select="local:chrome-count($p)"/>
+        </xsl:call-template>
+        <xsl:call-template name="local:after-mutation"/>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'insert-list')]" mode="ixsl:onclick">
+        <xsl:call-template name="local:push-undo"/>
+        <xsl:variable name="list" as="element()" select="ixsl:call(ixsl:page(), 'createElement', [ string(@data-list) ])"/>
+        <xsl:variable name="li" as="element()" select="local:element('li')"/>
+        <ixsl:set-attribute name="contenteditable" select="'true'" object="$li"/>
+        <xsl:sequence select="ixsl:call($list, 'appendChild', [ $li ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:insert-block-at-caret">
+            <xsl:with-param name="node" select="$list"/>
+        </xsl:call-template>
+        <xsl:call-template name="local:focus-caret">
+    <xsl:with-param name="node" select="$li"/>
+    <xsl:with-param name="offset" select="0"/>
+</xsl:call-template>
+        <xsl:call-template name="local:after-mutation"/>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'delete-block')]" mode="ixsl:onclick">
+        <xsl:for-each select="local:current-block()">
+            <xsl:variable name="confirmed" as="xs:boolean" select="local:block-text(.) = ''
+                or ixsl:call(ixsl:window(), 'confirm', [ 'Delete this block?' ])"/>
+            <xsl:if test="$confirmed">
+                <xsl:call-template name="local:push-undo"/>
+                <xsl:variable name="prev" as="element()?" select="preceding-sibling::*[1]"/>
+                <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                <xsl:for-each select="($prev/descendant-or-self::*[@contenteditable = 'true'])[last()]">
+                    <xsl:call-template name="local:focus">
+                        <xsl:with-param name="element" select="."/>
+                    </xsl:call-template>
+                </xsl:for-each>
+                <xsl:call-template name="local:after-mutation"/>
+            </xsl:if>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- ................................ link dialog ................................ -->
+
+    <xsl:template match="button[contains-token(@class, 'format-link')]" mode="ixsl:onclick">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
+            <xsl:variable name="range" select="local:caret-range()"/>
+            <xsl:variable name="anchor" select="ixsl:get($selection, 'anchorNode')"/>
+            <xsl:for-each select="local:host-of($anchor)[exists(local:block-of(.))]">
+                <xsl:variable name="link" as="element()?"
+                    select="($anchor/ancestor-or-self::a intersect descendant::*)[1]"/>
+                <xsl:choose>
+                    <!-- caret inside a link: edit it -->
+                    <xsl:when test="exists($link)">
+                        <ixsl:set-property name="editingLink" select="$link" object="local:editor-state()"/>
+                        <xsl:call-template name="local:open-link-dialog">
+                            <xsl:with-param name="event" select="$event"/>
+                            <xsl:with-param name="href" select="string($link/@href)"/>
+                            <xsl:with-param name="editing" select="true()"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <!-- selection: create one -->
+                    <xsl:when test="not(ixsl:get($selection, 'isCollapsed'))">
+                        <ixsl:set-property name="editRange" select="$range" object="local:editor-state()"/>
+                        <ixsl:set-property name="editingLink" select="()" object="local:editor-state()"/>
+                        <xsl:call-template name="local:open-link-dialog">
+                            <xsl:with-param name="event" select="$event"/>
+                            <xsl:with-param name="href" select="''"/>
+                            <xsl:with-param name="editing" select="false()"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise/>
+                </xsl:choose>
+            </xsl:for-each>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="local:render-link-dialog">
+        <div id="link-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
+                aria-label="Link" style="display: none;">
+            <label>Link target (href)</label>
+            <input type="text" name="href" placeholder="https://..."/>
+            <div class="action-buttons">
+                <button type="button" class="btn-danger link-remove" style="display: none;">Remove link</button>
+                <button type="button" class="btn-primary link-save">Save</button>
+                <button type="button" class="btn-secondary link-cancel">Cancel</button>
+            </div>
+        </div>
+    </xsl:template>
+
+    <xsl:template name="local:open-link-dialog">
+        <xsl:param name="event"/>
+        <xsl:param name="href" as="xs:string"/>
+        <xsl:param name="editing" as="xs:boolean"/>
+
+        <xsl:variable name="dialog" as="element()" select="id('link-dialog', ixsl:page())"/>
+        <xsl:for-each select="($dialog//input[@name = 'href'])[1]">
+            <ixsl:set-property name="value" select="$href" object="."/>
+        </xsl:for-each>
+        <xsl:for-each select="$dialog//button[contains-token(@class, 'link-remove')]">
+            <ixsl:set-style name="display" select="if ($editing) then 'inline-block' else 'none'"/>
+        </xsl:for-each>
+        <xsl:call-template name="local:show-at">
+            <xsl:with-param name="element" select="$dialog"/>
+            <xsl:with-param name="event" select="$event"/>
+        </xsl:call-template>
+        <xsl:for-each select="($dialog//input[@name = 'href'])[1]">
+            <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'link-save')]" mode="ixsl:onclick">
+        <xsl:variable name="href" as="xs:string"
+            select="local:input-value(ancestor::div[@id = 'link-dialog'][1], 'href')"/>
+        <xsl:if test="$href ne ''">
+            <xsl:variable name="editing" select="ixsl:get(local:editor-state(), 'editingLink')"/>
+            <xsl:choose>
+                <xsl:when test="exists($editing)">
+                    <xsl:call-template name="local:push-undo"/>
+                    <xsl:for-each select="$editing">
+                        <ixsl:set-attribute name="href" select="$href"/>
+                    </xsl:for-each>
+                </xsl:when>
+                <xsl:otherwise>
+                    <!-- capture pre-wrap state; push only when the wrap succeeded -->
+                    <xsl:variable name="snapshot-root" as="element()?" select="local:active-root()"/>
+                    <xsl:variable name="snapshot" as="xs:string?"
+                        select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
+                    <xsl:variable name="wrapped" as="element()?">
+                        <xsl:call-template name="local:wrap-range">
+                            <xsl:with-param name="range" select="ixsl:get(local:editor-state(), 'editRange')"/>
+                            <xsl:with-param name="name" select="'a'"/>
+                        </xsl:call-template>
+                    </xsl:variable>
+                    <xsl:for-each select="$wrapped">
+                        <xsl:call-template name="local:push-undo">
+                            <xsl:with-param name="root" select="$snapshot-root"/>
+                            <xsl:with-param name="snapshot" select="$snapshot"/>
+                        </xsl:call-template>
+                        <ixsl:set-attribute name="href" select="$href"/>
+                    </xsl:for-each>
+                </xsl:otherwise>
+            </xsl:choose>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:if>
+        <xsl:call-template name="local:hide-dialogs"/>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'link-remove')]" mode="ixsl:onclick">
+        <xsl:for-each select="ixsl:get(local:editor-state(), 'editingLink')">
+            <xsl:call-template name="local:push-undo"/>
+            <xsl:call-template name="local:unwrap-element">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:for-each>
+        <xsl:call-template name="local:hide-dialogs"/>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'link-cancel')
+            or contains-token(@class, 'figure-cancel')
+            or contains-token(@class, 'table-cancel')]" mode="ixsl:onclick">
+        <xsl:call-template name="local:hide-dialogs"/>
+    </xsl:template>
+
+    <xsl:template match="div[contains-token(@class, 'edit-dialog')] | div[@id = 'slash-menu']" mode="ixsl:onkeydown">
+        <xsl:if test="string(ixsl:get(ixsl:event(), 'key')) = 'Escape'">
+            <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:hide-dialogs"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- single teardown point for all dialogs: everything carrying the edit-dialog
+         class (extension dialogs opt in the same way) plus the slash menu -->
+    <xsl:template name="local:hide-dialogs">
+        <xsl:for-each select="ixsl:page()//div[contains-token(@class, 'edit-dialog')],
+                id('slash-menu', ixsl:page())">
+            <ixsl:set-style name="display" select="'none'"/>
+        </xsl:for-each>
+        <ixsl:set-property name="editRange" select="()" object="local:editor-state()"/>
+        <ixsl:set-property name="editingLink" select="()" object="local:editor-state()"/>
+        <ixsl:set-property name="insertHost" select="()" object="local:editor-state()"/>
+        <ixsl:set-property name="slashHost" select="()" object="local:editor-state()"/>
+        <ixsl:set-property name="findNode" select="()" object="local:editor-state()"/>
+        <ixsl:set-property name="findOffset" select="1" object="local:editor-state()"/>
+        <!-- return focus to the content -->
+        <xsl:for-each select="ixsl:get(local:editor-state(), 'activeBlock')[exists(local:block-of(.))]">
+            <xsl:call-template name="local:focus">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- ................................ figure dialog ................................ -->
+
+    <xsl:template match="button[contains-token(@class, 'insert-figure')]" mode="ixsl:onclick">
+        <ixsl:set-property name="insertHost"
+            select="local:current-host()[exists(local:block-of(.))]" object="local:editor-state()"/>
+        <xsl:variable name="dialog" as="element()" select="id('figure-dialog', ixsl:page())"/>
+        <xsl:for-each select="$dialog//input">
+            <ixsl:set-property name="value" select="''" object="."/>
+        </xsl:for-each>
+        <xsl:call-template name="local:show-at">
+            <xsl:with-param name="element" select="$dialog"/>
+            <xsl:with-param name="event" select="ixsl:event()"/>
+        </xsl:call-template>
+        <xsl:for-each select="($dialog//input[@name = 'src'])[1]">
+            <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="local:render-figure-dialog">
+        <div id="figure-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
+                aria-label="Insert figure" style="display: none;">
+            <label>Image URL (src)</label>
+            <input type="text" name="src" placeholder="https://... or relative path"/>
+            <label>Alternate text (alt)</label>
+            <input type="text" name="alt"/>
+            <label>Caption</label>
+            <input type="text" name="caption"/>
+            <div class="action-buttons">
+                <button type="button" class="btn-primary figure-save">Insert</button>
+                <button type="button" class="btn-secondary figure-cancel">Cancel</button>
+            </div>
+        </div>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'figure-save')]" mode="ixsl:onclick">
+        <xsl:variable name="dialog" as="element()" select="ancestor::div[@id = 'figure-dialog']"/>
+        <xsl:variable name="src" as="xs:string" select="local:input-value($dialog, 'src')"/>
+        <xsl:if test="$src ne ''">
+            <xsl:call-template name="local:push-undo"/>
+            <xsl:variable name="figure" as="element()" select="local:element('figure')"/>
+            <xsl:variable name="img" as="element()" select="local:element('img')"/>
+            <ixsl:set-attribute name="src" select="$src" object="$img"/>
+            <ixsl:set-attribute name="alt" select="local:input-value($dialog, 'alt')" object="$img"/>
+            <!-- focusable so the image is a keyboard-navigation island (see local:nav-targets) -->
+            <ixsl:set-attribute name="tabindex" select="'-1'" object="$img"/>
+            <xsl:variable name="figcaption" as="element()" select="local:element('figcaption')"/>
+            <ixsl:set-property name="textContent" select="local:input-value($dialog, 'caption')" object="$figcaption"/>
+            <ixsl:set-attribute name="contenteditable" select="'true'" object="$figcaption"/>
+            <xsl:sequence select="ixsl:call($figure, 'appendChild', [ $img ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="ixsl:call($figure, 'appendChild', [ $figcaption ])[current-date() lt xs:date('2000-01-01')]"/>
+            <!-- placed per the content model relative to the host the dialog was
+                 opened from: an empty list item or cell grows the figure INSIDE
+                 itself, a sibling where the parent admits it (chrome only when it
+                 lands top-level - the helper guards it) -->
+            <xsl:call-template name="local:insert-block-at-caret">
+                <xsl:with-param name="node" select="$figure"/>
+                <xsl:with-param name="host" select="ixsl:get(local:editor-state(), 'insertHost')[exists(local:block-of(.))]"/>
+            </xsl:call-template>
+            <xsl:call-template name="local:focus">
+                <xsl:with-param name="element" select="$figcaption"/>
+            </xsl:call-template>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:if>
+        <xsl:call-template name="local:hide-dialogs"/>
+    </xsl:template>
+
+    <!-- ................................ drag-and-drop ................................ -->
+    <!-- ported from LinkedDataHub client/block.xsl; handle-gated draggable because a
+         permanently draggable contenteditable block breaks text selection -->
+
+    <xsl:template match="span[contains-token(@class, 'drag-handle')]" mode="ixsl:onmousedown">
+        <xsl:for-each select="local:handle-block(.)">
+            <ixsl:set-attribute name="draggable" select="'true'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="span[contains-token(@class, 'drag-handle')]" mode="ixsl:onmouseup">
+        <xsl:for-each select="local:handle-block(.)">
+            <ixsl:remove-attribute name="draggable"/>
+        </xsl:for-each>
+        <xsl:call-template name="local:disarm-sweep"/>
+    </xsl:template>
+
+    <xsl:template match="*[@draggable = 'true'][local:draggable-block(.)]" mode="ixsl:ondragstart">
+        <xsl:variable name="transfer" select="ixsl:get(ixsl:event(), 'dataTransfer')"/>
+        <!-- a block drag must never race an armed sweep -->
+        <xsl:call-template name="local:disarm-sweep"/>
+        <ixsl:set-property name="draggedBlock" select="." object="local:editor-state()"/>
+        <ixsl:set-property name="effectAllowed" select="'move'" object="$transfer"/>
+        <xsl:sequence select="ixsl:call($transfer, 'setData', [ 'application/x-rdfa-editor-block', '' ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:sequence select="ixsl:call($transfer, 'setDragImage', [ ., 0, 0 ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'add', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <!-- links cannot navigate on plain click inside contenteditable (the click
+         places the caret for editing); the standard editor convention applies:
+         Ctrl/Cmd+Click follows the link -->
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//a[@href]" mode="ixsl:onclick">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:if test="ixsl:get($event, 'ctrlKey') or ixsl:get($event, 'metaKey')">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="ixsl:call(ixsl:window(), 'open',
+                [ string(resolve-uri(@href, local:document-uri())), '_blank' ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- images are natively draggable, so a drag starting on one would otherwise
+         carry no block identity and snap back; treat it as dragging its innermost
+         draggable block (the figure, wherever it nests) -->
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//img" mode="ixsl:ondragstart">
+        <xsl:variable name="transfer" select="ixsl:get(ixsl:event(), 'dataTransfer')"/>
+        <xsl:call-template name="local:disarm-sweep"/>
+        <xsl:for-each select="ancestor-or-self::*[local:draggable-block(.)][1]">
+            <ixsl:set-property name="draggedBlock" select="." object="local:editor-state()"/>
+            <ixsl:set-property name="effectAllowed" select="'move'" object="$transfer"/>
+            <xsl:sequence select="ixsl:call($transfer, 'setData', [ 'application/x-rdfa-editor-block', '' ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="ixsl:call($transfer, 'setDragImage', [ ., 0, 0 ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'add', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')] | *[contains-token(@class, 'rdfa-editor-content')]//*" mode="ixsl:ondragover">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="dragged" select="ixsl:get(local:editor-state(), 'draggedBlock')"/>
+        <xsl:variable name="target" as="element()?" select="local:drop-target-of(., $event)"/>
+        <xsl:if test="exists($dragged) and exists($target)
+                and local:has-transfer-type($event, 'application/x-rdfa-editor-block')">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <ixsl:set-property name="dropEffect" select="'move'" object="ixsl:get($event, 'dataTransfer')"/>
+            <xsl:call-template name="local:clear-drop-marks"/>
+            <!-- a block target takes a before/after line; a cell target is entered
+                 whole, so it highlights as a box -->
+            <xsl:sequence select="ixsl:call(ixsl:get($target, 'classList'), 'add',
+                [ if (not(local:draggable-block($target))) then 'drop-into'
+                    else if (local:drop-before($event, $target)) then 'drop-before'
+                    else 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')] | *[contains-token(@class, 'rdfa-editor-content')]//*" mode="ixsl:ondrop">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="dragged" select="ixsl:get(local:editor-state(), 'draggedBlock')"/>
+        <xsl:variable name="target" as="element()?" select="local:drop-target-of(., $event)"/>
+        <xsl:if test="exists($dragged) and exists($target)
+                and local:has-transfer-type($event, 'application/x-rdfa-editor-block')">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:clear-drop-marks"/>
+            <!-- transient drag state must not reach the undo snapshot -->
+            <xsl:for-each select="$dragged">
+                <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
+                <ixsl:remove-attribute name="draggable"/>
+                <xsl:call-template name="local:tidy-class">
+                    <xsl:with-param name="element" select="."/>
+                </xsl:call-template>
+            </xsl:for-each>
+            <xsl:call-template name="local:push-undo"/>
+            <!-- the vacated origin, captured before the move: the top-level block
+                 (husk-prune scope) and the nearest flow container (collapse
+                 candidate) - both empty for a top-level drag -->
+            <xsl:variable name="origin-block" as="element()?"
+                select="$dragged/parent::*[not(contains-token(@class, 'rdfa-editor-content'))]
+                    ! local:block-of(.)"/>
+            <xsl:variable name="origin-flow" as="element()?"
+                select="$dragged/ancestor::*[cm:flow(local-name(.))]
+                    [not(contains-token(@class, 'rdfa-editor-content'))]
+                    [exists(local:block-of(.))][1]"/>
+            <xsl:choose>
+                <xsl:when test="local:draggable-block($target)">
+                    <xsl:sequence select="ixsl:call($target,
+                        if (local:drop-before($event, $target)) then 'before' else 'after',
+                        [ $dragged ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:when>
+                <!-- into a cell: the text host becomes a container (its runs wrapped,
+                     the insert-block-at-caret flow doctrine) and the block appends -->
+                <xsl:otherwise>
+                    <xsl:for-each select="$target[@contenteditable = 'true']">
+                        <ixsl:remove-attribute name="contenteditable"/>
+                    </xsl:for-each>
+                    <xsl:call-template name="local:wrap-stray-runs">
+                        <xsl:with-param name="container" select="$target"/>
+                    </xsl:call-template>
+                    <xsl:sequence select="ixsl:call($target, 'appendChild', [ $dragged ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:otherwise>
+            </xsl:choose>
+            <!-- repair the origin: structural containers emptied by the lift-out go
+                 (a quote whose only block left - B7 doctrine), then a flow container
+                 that lost its last block reverts to a text host (both self-guard) -->
+            <xsl:for-each select="$origin-block[exists(local:root-of(.))]">
+                <xsl:call-template name="local:prune-husks">
+                    <xsl:with-param name="scope" select="."/>
+                </xsl:call-template>
+            </xsl:for-each>
+            <xsl:for-each select="$origin-flow[exists(local:root-of(.))]">
+                <xsl:call-template name="local:collapse-container">
+                    <xsl:with-param name="container" select="."/>
+                </xsl:call-template>
+            </xsl:for-each>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')] | *[contains-token(@class, 'rdfa-editor-content')]//*" mode="ixsl:ondragend">
+        <!-- clean the actually-dragged block (the event target of a nested drag
+             may be a descendant, so re-deriving from it would miss) -->
+        <xsl:for-each select="ixsl:get(local:editor-state(), 'draggedBlock')">
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
+            <ixsl:remove-attribute name="draggable"/>
+            <xsl:call-template name="local:tidy-class">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+        <xsl:call-template name="local:clear-drop-marks"/>
+        <ixsl:set-property name="draggedBlock" select="()" object="local:editor-state()"/>
+    </xsl:template>
+
+    <!-- dataTransfer.types marshals to an XDM array or sequence of strings -->
+    <xsl:function name="local:has-transfer-type" as="xs:boolean">
+        <xsl:param name="event"/>
+        <xsl:param name="type" as="xs:string"/>
+        <xsl:variable name="types" select="ixsl:get(ixsl:get($event, 'dataTransfer'), 'types')"/>
+        <xsl:sequence select="(if ($types instance of array(*)) then $types?* else $types) = $type"/>
+    </xsl:function>
+
+    <!-- the block to drop relative to: the innermost content-model-legal block
+         under the pointer (a nested drop lands where the model admits the dragged
+         kind, clamped upward to the nearest legal level otherwise - the resolver
+         never produces invalid nesting), else the geometrically nearest top-level
+         block by vertical midpoint - so gaps between blocks, the container padding
+         and the (tall) dragged block itself are all valid drop zones instead of
+         snapping the drag back. The gutter and gaps resolve top-level: dropping
+         there lifts a nested block all the way out -->
+    <xsl:function name="local:drop-target-of" as="element()?">
+        <xsl:param name="hit"/>
+        <xsl:param name="event"/>
+        <xsl:variable name="dragged" select="ixsl:get(local:editor-state(), 'draggedBlock')"/>
+        <!-- blocks never move between editable regions -->
+        <xsl:variable name="root" as="element()?"
+            select="($dragged ! local:root-of(.), local:root-of($hit))[1]"/>
+        <xsl:variable name="deepest" as="element()?"
+            select="local:deepest-block-at($hit, $dragged)[local:root-of(.) is $root]"/>
+        <!-- a cell's pixels are unambiguous - nothing can legally drop before or
+             after a td/th, so pointing into a cell (away from any block it holds)
+             drops INTO it. A list item stays a clamp to around-the-list instead:
+             its pixels compete with reordering next to the list, and Tab/indent
+             already move content into items. Only CONTENT cells qualify: a cell
+             inside ephemera or an island interior (a rendered chart or reference
+             card paints real tables) is external rendering, never a drop zone -
+             the pointer falls through to the island itself (before/after) -->
+        <xsl:variable name="cell" as="element()?"
+            select="$hit/ancestor-or-self::*[self::td or self::th]
+                [empty(ancestor-or-self::*[@data-role])]
+                [empty(ancestor::*[local:island(.)])]
+                [empty(ancestor-or-self::* intersect $dragged)]
+                [local:root-of(.) is $root][1]"/>
+        <xsl:choose>
+            <xsl:when test="exists($cell) and exists($dragged)
+                    and cm:allows-child(local-name($cell), local-name($dragged))
+                    and empty($deepest/ancestor::* intersect $cell)">
+                <xsl:sequence select="$cell"/>
+            </xsl:when>
+            <xsl:when test="exists($deepest) and exists($dragged)">
+                <xsl:sequence select="local:legal-drop-level($deepest, $dragged)"/>
+            </xsl:when>
+            <!-- geometric fallback only within the dragged block's own region:
+                 a pointer over another region is not a drop zone at all -->
+            <xsl:when test="not(local:root-of($hit) is $root)"/>
+            <xsl:otherwise>
+                <xsl:variable name="y" as="xs:double" select="xs:double(ixsl:get($event, 'clientY'))"/>
+                <xsl:variable name="candidates" as="element()*"
+                    select="$root/*[not(exists($dragged) and . is $dragged)]"/>
+                <xsl:variable name="distances" as="xs:double*" select="$candidates
+                    ! (let $rect := ixsl:call(., 'getBoundingClientRect', []) return
+                        abs(xs:double(ixsl:get($rect, 'top')) + xs:double(ixsl:get($rect, 'height')) div 2 - $y))"/>
+                <xsl:variable name="nearest" as="xs:integer?" select="index-of($distances, min($distances))[1]"/>
+                <xsl:sequence select="$candidates[$nearest]"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- above or below the vertical midpoint of the target block -->
+    <xsl:function name="local:drop-before" as="xs:boolean">
+        <xsl:param name="event"/>
+        <xsl:param name="target" as="element()"/>
+        <xsl:variable name="rect" select="ixsl:call($target, 'getBoundingClientRect', [])"/>
+        <xsl:sequence select="xs:double(ixsl:get($event, 'clientY')) - xs:double(ixsl:get($rect, 'top'))
+            lt xs:double(ixsl:get($rect, 'height')) div 2"/>
+    </xsl:function>
+
+    <xsl:template name="local:clear-drop-marks">
+        <xsl:param name="scope" as="element()*" select="local:roots()/descendant::*"/>
+        <xsl:for-each select="$scope[contains-token(@class, 'drop-before')
+                or contains-token(@class, 'drop-after') or contains-token(@class, 'drop-into')]">
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'drop-before' ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'drop-into' ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:tidy-class">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- ................................ view source ................................ -->
+
+    <!-- W3C Exclusive XML Canonicalization (the rdf:XMLLiteral value space) via the
+         xml-c14n lib on the host page - LinkedDataHub's ldh:canonicalize-xml ported.
+         parse-xml() is the XDM->DOM bridge: the lib walks browser DOM nodes, not
+         Saxon's temporary trees -->
+    <xsl:function name="local:canonicalize-xml" as="xs:string">
+        <xsl:param name="doc" as="document-node()"/>
+        <xsl:variable name="js-function" select="ixsl:eval('(function (doc) { return window[''xml-c14n-sync.js'']().createCanonicaliser(''http://www.w3.org/2001/10/xml-exc-c14n#WithComments'').canonicaliseSync(doc.documentElement); })')"/>
+        <xsl:sequence select="ixsl:call($js-function, 'call', [ (), $doc ])"/>
+    </xsl:function>
+
+    <xsl:template match="button[@id = 'view-source']" mode="ixsl:onclick">
+        <xsl:variable name="canonical" as="element()?">
+            <xsl:call-template name="canonical-xhtml">
+                <xsl:with-param name="content" select="local:active-root()"/>
+            </xsl:call-template>
+        </xsl:variable>
+        <xsl:call-template name="local:show-output">
+            <xsl:with-param name="title" select="'Canonical XHTML+RDFa'"/>
+            <xsl:with-param name="text" select="local:canonicalize-xml(parse-xml(serialize($canonical, map{ 'method': 'xml' })))"/>
+            <xsl:with-param name="filename" select="'content.xhtml'"/>
+            <xsl:with-param name="media-type" select="'application/xhtml+xml'"/>
+        </xsl:call-template>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/group-sort-triples.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/group-sort-triples.xsl
new file mode 100644
index 000000000..8a170a61b
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/group-sort-triples.xsl
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+Copyright 2012 Martynas Jusevičius <martynas@atomgraph.com>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+<xsl:stylesheet
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+xmlns:local="urn:rdfa-editor:functions"
+exclude-result-prefixes="xsl xs local"
+version="3.0">
+
+    <!--
+        Groups striped RDF/XML (one rdf:Description per triple, as the extractor in
+        RDFa2RDFXML-v3.xsl emits) into one rdf:Description per subject, with the
+        properties sorted - easing per-entity rendering (the inspector pane in
+        navigate.xsl). Adapted to a pure function from AtomGraph Web-Client's
+        group-sort-triples.xsl (ac:GroupTriples mode): no top-level xsl:output or
+        xsl:strip-space here, since this module is xsl:included into the editor
+        stylesheet and must not impose global serialization or whitespace handling.
+    -->
+    <xsl:function name="local:group-triples" as="element(rdf:RDF)">
+        <xsl:param name="rdf" as="element(rdf:RDF)"/>
+
+        <rdf:RDF>
+            <!-- one rdf:Description per subject; URI resources first ('0 '), then blank nodes ('1 ') -->
+            <xsl:for-each-group select="$rdf/rdf:Description[@rdf:about or @rdf:nodeID]"
+                    group-by="if (@rdf:about) then '0 ' || @rdf:about else '1 ' || @rdf:nodeID">
+                <xsl:sort select="current-grouping-key()" data-type="text" order="ascending"/>
+                <rdf:Description>
+                    <xsl:copy-of select="(@rdf:about, @rdf:nodeID)[1]"/>
+                    <xsl:perform-sort select="current-group()/*">
+                        <xsl:sort select="namespace-uri() || local-name()" data-type="text" order="ascending"/>
+                        <xsl:sort select="@rdf:resource" data-type="text" order="ascending"/>
+                        <xsl:sort select="@rdf:nodeID" data-type="text" order="ascending"/>
+                        <xsl:sort select="@rdf:datatype" data-type="text" order="ascending"/>
+                        <xsl:sort select="@xml:lang" data-type="text" order="ascending"/>
+                        <xsl:sort select="." data-type="text" order="ascending"/>
+                    </xsl:perform-sort>
+                </rdf:Description>
+            </xsl:for-each-group>
+        </rdf:RDF>
+    </xsl:function>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/index.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/index.xsl
new file mode 100644
index 000000000..29fd27863
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/index.xsl
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    RDFa editor entry point. The editor UI is fully generated by this stylesheet:
+    drop it onto any host page with a #content container and author XHTML+RDFa -
+    structured block editing plus right-click RDFa annotation.
+
+    Modules:
+    - RDFa2RDFXML-v3.xsl   RDFa 1.1 to RDF/XML extraction (pure XSLT, tested headless)
+    - content-model.xsl    XHTML Strict content model as data (pure XSLT, include-free)
+    - canonical-xhtml.xsl  canonical serialization form (pure XSLT, tested headless)
+    - vocab.xsl            generic ontology RDF/XML to term maps
+    - overlay.xsl          annotation form: rendering, reading, populating, visibility
+    - typeahead.xsl        autocomplete lookups for the property and type fields
+    - annotate.xsl         right-click dispatch, apply/remove annotation, extraction modal
+    - edit.xsl             XHTML editing: blocks, keyboard, toolbar, dialogs, drag-and-drop
+    - blocks.xsl           object blocks: island predicate, render hook, extension points
+    - tables.xsl           table blocks: insert dialog, row/column operations, cell traversal
+    - select.xsl           region-scoped select-all and cross-host selection delete
+    - input.xsl            input triggers: slash menu and markdown shorthands
+-->
+
+    <xsl:include href="RDFa2RDFXML-v3.xsl"/>
+    <xsl:include href="group-sort-triples.xsl"/>
+    <xsl:include href="content-model.xsl"/>
+    <xsl:include href="canonical-xhtml.xsl"/>
+    <xsl:include href="lint-rdfa.xsl"/>
+    <xsl:include href="lint-xhtml.xsl"/>
+    <xsl:include href="vocab.xsl"/>
+    <xsl:include href="overlay.xsl"/>
+    <xsl:include href="typeahead.xsl"/>
+    <xsl:include href="annotate.xsl"/>
+    <xsl:include href="edit.xsl"/>
+    <xsl:include href="blocks.xsl"/>
+    <xsl:include href="tables.xsl"/>
+    <xsl:include href="select.xsl"/>
+    <xsl:include href="input.xsl"/>
+    <xsl:include href="undo.xsl"/>
+    <xsl:include href="navigate.xsl"/>
+
+    <!-- the initial template (SaxonJS.transform initialTemplate in the host page).
+         Everything here is synchronous: the host page preloads the vocabulary
+         documents into the SaxonJS document pool (SaxonJS.getResource +
+         documentPool), keyed by page-relative URI -->
+    <xsl:template name="main">
+        <xsl:call-template name="local:init-state"/>
+        <xsl:call-template name="local:init-editor"/>
+    </xsl:template>
+
+    <!-- all editor state lives on a single window.rdfaEditor container (mirrors
+         LinkedDataHub's window.LinkedDataHub); reached everywhere via local:editor-state().
+         Hosts with their own initial template call this from there instead of main -->
+    <xsl:template name="local:init-state">
+        <xsl:variable name="state" select="ixsl:call(ixsl:window(), 'Object', [])"/>
+        <ixsl:set-property name="rdfaEditor" select="$state" object="ixsl:window()"/>
+        <xsl:for-each select="('editingSpan', 'range', 'activeBlock', 'draggedBlock',
+                'editRange', 'editingLink', 'insertHost', 'lastUndoHost',
+                'breadcrumbLeaf', 'draggedSectionHeading', 'findNode', 'tocRoot',
+                'slashHost', 'sweepAnchorNode', 'sweepAnchorHost', 'sweepRegion')">
+            <ixsl:set-property name="{.}" select="()" object="$state"/>
+        </xsl:for-each>
+        <ixsl:set-property name="lastUndoTime" select="0" object="$state"/>
+        <ixsl:set-property name="findOffset" select="1" object="$state"/>
+        <ixsl:set-property name="sweepAnchorOffset" select="0" object="$state"/>
+    </xsl:template>
+
+    <!-- the full editor bring-up: page chrome (undo stash, overlay, output modal,
+         toolbar, dialogs, drawers) plus block init of every editable region. Hosts
+         that render regions lazily call this once, when the first region appears -->
+    <xsl:template name="local:init-editor">
+        <xsl:call-template name="local:init-undo"/>
+        <xsl:call-template name="local:init-overlay"/>
+        <xsl:call-template name="local:init-annotate"/>
+        <xsl:call-template name="local:init-editing"/>
+        <xsl:call-template name="local:init-navigate"/>
+    </xsl:template>
+
+    <!-- the single window.rdfaEditor container that holds all mutable editor state;
+         every read/write of that state goes through this accessor -->
+    <xsl:function name="local:editor-state">
+        <xsl:sequence select="ixsl:get(ixsl:window(), 'rdfaEditor')"/>
+    </xsl:function>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/input.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/input.xsl
new file mode 100644
index 000000000..eff247a0f
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/input.xsl
@@ -0,0 +1,434 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+xmlns:cm="urn:rdfa-editor:content-model"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    Notion-style input affordances, ported from the notion-affordances branch
+    (PR #10) onto the content-model era: one priority-raised ixsl:onbeforeinput
+    dispatcher intercepts printable-character triggers - the / slash menu in an
+    empty host and the markdown shorthands in a paragraph host - and next-matches
+    to undo.xsl's typing coalescer for everything else, so plain typing still
+    snapshots for undo.
+
+    All triggers act on the HOST the caret sits in (a paragraph in a quote or
+    cell, a run wrapper, a list item), never blindly on the top-level block, and
+    every conversion is gated on the content model, so a shorthand that would
+    produce invalid nesting stays literal text. Markdown '> ' wraps in a
+    blockquote (blockquote > p - converting the p itself would be invalid).
+    The slash menu is keyboard framing over the existing toolbar actions:
+    convert-block, the quote toggle's wrap, the list builder and the
+    figure/table dialogs.
+-->
+
+    <!-- ................................ caret-anchored popups ................................ -->
+
+    <!-- show a popup below the caret; a collapsed caret in an empty block yields a
+         degenerate (all-zero) client rect, so fall back to the host's own box -->
+    <xsl:template name="local:show-at-caret">
+        <xsl:param name="element" as="element()"/>
+        <xsl:param name="anchor" as="element()?" select="local:current-host()"/>
+        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:variable name="caret" select="$range ! ixsl:call(., 'getBoundingClientRect', [])"/>
+        <xsl:variable name="degenerate" as="xs:boolean" select="empty($caret)
+            or (ixsl:get($caret, 'width') = 0 and ixsl:get($caret, 'height') = 0
+                and ixsl:get($caret, 'left') = 0 and ixsl:get($caret, 'top') = 0)"/>
+        <xsl:variable name="rect" select="if ($degenerate and exists($anchor))
+            then ixsl:call($anchor, 'getBoundingClientRect', []) else $caret"/>
+        <xsl:call-template name="local:show-at-point">
+            <xsl:with-param name="element" select="$element"/>
+            <xsl:with-param name="x" select="ixsl:get($rect, 'left')"/>
+            <xsl:with-param name="y" select="ixsl:get($rect, 'bottom')"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- show a popup below an anchor element's box (no live caret needed) -->
+    <xsl:template name="local:show-at-element">
+        <xsl:param name="element" as="element()"/>
+        <xsl:param name="anchor" as="element()"/>
+        <xsl:variable name="rect" select="ixsl:call($anchor, 'getBoundingClientRect', [])"/>
+        <xsl:call-template name="local:show-at-point">
+            <xsl:with-param name="element" select="$element"/>
+            <xsl:with-param name="x" select="ixsl:get($rect, 'left')"/>
+            <xsl:with-param name="y" select="ixsl:get($rect, 'bottom')"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- ................................ input triggers ................................ -->
+
+    <!-- printable-character triggers run at higher priority than undo.xsl's
+         typing-coalescing onbeforeinput rule; anything that is not a trigger
+         falls through via next-match so plain typing still snapshots for undo -->
+    <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onbeforeinput" priority="1">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="type" as="xs:string" select="string(ixsl:get($event, 'inputType'))"/>
+        <xsl:variable name="data" as="xs:string" select="string((ixsl:get($event, 'data'), '')[1])"/>
+        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:variable name="kind" as="xs:string" select="if ($type = 'insertText'
+                and exists(local:block-of(.)) and exists($range)
+                and not(ixsl:get($event, 'isComposing')))
+            then local:trigger-kind(., $data) else ''"/>
+        <xsl:choose>
+            <xsl:when test="$kind ne ''">
+                <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:choose>
+                    <xsl:when test="$kind = 'slash'">
+                        <xsl:call-template name="local:open-slash">
+                            <xsl:with-param name="host" select="."/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:call-template name="local:apply-markdown">
+                            <xsl:with-param name="host" select="."/>
+                            <xsl:with-param name="kind" select="$kind"/>
+                        </xsl:call-template>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:next-match/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- classify a would-be-inserted character: 'slash' (/ in an empty host), a
+         markdown shorthand 'md:*' completed in a paragraph host, or '' for none.
+         A shorthand whose result the content model would reject stays literal -->
+    <xsl:function name="local:trigger-kind" as="xs:string">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="data" as="xs:string"/>
+
+        <xsl:variable name="text" as="xs:string" select="local:block-text($host)"/>
+        <xsl:variable name="paragraph" as="xs:boolean" select="exists($host/self::p)"/>
+        <xsl:variable name="kind" as="xs:string" select="
+            if ($data = '/' and $text = '') then 'slash'
+            else if ($paragraph and $data = ' ' and $text = '#') then 'md:h1'
+            else if ($paragraph and $data = ' ' and $text = '##') then 'md:h2'
+            else if ($paragraph and $data = ' ' and $text = '###') then 'md:h3'
+            else if ($paragraph and $data = ' ' and ($text = '-' or $text = '*')) then 'md:ul'
+            else if ($paragraph and $data = ' ' and $text = '1.') then 'md:ol'
+            else if ($paragraph and $data = ' ' and $text = '&gt;') then 'md:blockquote'
+            else if ($paragraph and $data = '`' and $text = '``') then 'md:pre'
+            else ''"/>
+        <!-- substring-after over an empty sequence yields the zero-length STRING,
+             which would send '' into the content-model gate - branch explicitly -->
+        <xsl:variable name="target" as="xs:string?"
+            select="if (starts-with($kind, 'md:')) then substring-after($kind, 'md:') else ()"/>
+        <xsl:sequence select="if (exists($target) and not(local:parent-admits($host, $target)))
+            then '' else $kind"/>
+    </xsl:function>
+
+    <!-- the region admits any block by contract; elsewhere the content model rules -->
+    <xsl:function name="local:parent-admits" as="xs:boolean">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="name" as="xs:string"/>
+        <xsl:sequence select="exists($host/parent::*[contains-token(@class, 'rdfa-editor-content')])
+            or cm:allows-child(local-name($host/parent::*), $name)"/>
+    </xsl:function>
+
+    <xsl:template name="local:apply-markdown">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="kind" as="xs:string"/>
+
+        <xsl:choose>
+            <!-- '> ' wraps (blockquote > p; converting the p itself would be
+                 invalid bare text): the wrap pushes the pre-strip state, so undo
+                 restores the literal '>' -->
+            <xsl:when test="$kind = 'md:blockquote'">
+                <xsl:call-template name="local:wrap-in-blockquote">
+                    <xsl:with-param name="block" select="$host"/>
+                </xsl:call-template>
+                <xsl:call-template name="local:strip-marker">
+                    <xsl:with-param name="host" select="$host"/>
+                </xsl:call-template>
+                <xsl:call-template name="local:after-mutation"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <!-- capture the pre-strip state; the conversion pushes it as ONE
+                     undo entry (mirrors the wrap-range capture-then-push pattern) -->
+                <xsl:variable name="snapshot-root" as="element()?" select="local:root-of($host)"/>
+                <xsl:variable name="snapshot" as="xs:string?"
+                    select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
+                <xsl:call-template name="local:strip-marker">
+                    <xsl:with-param name="host" select="$host"/>
+                </xsl:call-template>
+                <xsl:choose>
+                    <xsl:when test="$kind = ('md:ul', 'md:ol')">
+                        <xsl:call-template name="local:push-undo">
+                            <xsl:with-param name="root" select="$snapshot-root"/>
+                            <xsl:with-param name="snapshot" select="$snapshot"/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:replace-with-list">
+                            <xsl:with-param name="block" select="$host"/>
+                            <xsl:with-param name="kind" select="substring-after($kind, 'md:')"/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:after-mutation"/>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:call-template name="local:convert-block">
+                            <xsl:with-param name="block" select="$host"/>
+                            <xsl:with-param name="name" select="substring-after($kind, 'md:')"/>
+                            <xsl:with-param name="snapshot-root" select="$snapshot-root"/>
+                            <xsl:with-param name="snapshot" select="$snapshot"/>
+                        </xsl:call-template>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- drop the typed shorthand marker, keeping chrome and the caret placeholder -->
+    <xsl:template name="local:strip-marker">
+        <xsl:param name="host" as="element()"/>
+        <xsl:for-each select="$host/node()[not(self::*[@data-role])]">
+            <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:call-template name="local:ensure-placeholder">
+            <xsl:with-param name="host" select="$host"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- swap a block for a fresh single-item list of the given kind, caret in the
+         item; a run wrapper swaps like any host (a structural gesture promotes it) -->
+    <xsl:template name="local:replace-with-list">
+        <xsl:param name="block" as="element()"/>
+        <xsl:param name="kind" as="xs:string"/>
+
+        <xsl:variable name="list" as="element()" select="local:element($kind)"/>
+        <xsl:variable name="li" as="element()" select="local:element('li')"/>
+        <ixsl:set-attribute name="contenteditable" select="'true'" object="$li"/>
+        <xsl:sequence select="ixsl:call($li, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')],
+            ixsl:call($list, 'appendChild', [ $li ])[current-date() lt xs:date('2000-01-01')],
+            ixsl:call($block, 'replaceWith', [ $list ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:if test="$list/parent::*[contains-token(@class, 'rdfa-editor-content')]">
+            <xsl:call-template name="local:inject-chrome">
+                <xsl:with-param name="block" select="$list"/>
+            </xsl:call-template>
+        </xsl:if>
+        <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+        <xsl:call-template name="local:focus-caret">
+            <xsl:with-param name="node" select="$li"/>
+            <xsl:with-param name="offset" select="0"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- ................................ slash menu ................................ -->
+
+    <xsl:template name="local:render-slash-menu">
+        <div id="slash-menu" class="rdfa-editor-ui" role="listbox" aria-label="Insert block" style="display: none;">
+            <input type="text" class="slash-filter" placeholder="Filter blocks..." aria-label="Filter blocks"/>
+            <ul class="slash-items">
+                <li class="slash-item" data-command="p" role="option">Paragraph</li>
+                <li class="slash-item" data-command="h1" role="option">Heading 1</li>
+                <li class="slash-item" data-command="h2" role="option">Heading 2</li>
+                <li class="slash-item" data-command="h3" role="option">Heading 3</li>
+                <li class="slash-item" data-command="blockquote" role="option">Quote</li>
+                <li class="slash-item" data-command="pre" role="option">Code</li>
+                <li class="slash-item" data-command="ul" role="option">Bulleted list</li>
+                <li class="slash-item" data-command="ol" role="option">Numbered list</li>
+                <li class="slash-item" data-command="figure" role="option">Figure&#x2026;</li>
+                <li class="slash-item" data-command="table" role="option">Table&#x2026;</li>
+                <!-- extension items (dispatched via local:run-extra-slash-command;
+                     the generic filter/arrow/Enter machinery applies untouched) -->
+                <xsl:call-template name="local:render-extra-slash-items"/>
+            </ul>
+        </div>
+    </xsl:template>
+
+    <!-- open with only the commands the caret context admits: conversions for
+         text-block hosts (per the block-type select), Quote where the wrap is
+         legal and not already inside one, lists where the model places one,
+         figure/table always (they insert after the top-level block) -->
+    <xsl:template name="local:open-slash">
+        <xsl:param name="host" as="element()"/>
+
+        <ixsl:set-property name="slashHost" select="$host" object="local:editor-state()"/>
+        <xsl:variable name="menu" as="element()" select="id('slash-menu', ixsl:page())"/>
+        <xsl:variable name="convertible" as="xs:boolean"
+            select="exists($host/(self::p | self::h1 | self::h2 | self::h3 | self::pre))"/>
+        <xsl:variable name="quotable" as="xs:boolean" select="cm:block(local-name($host))
+            and local:parent-admits($host, 'blockquote')
+            and empty($host/ancestor::blockquote[exists(local:block-of(.))])"/>
+        <xsl:for-each select="$menu//input[contains-token(@class, 'slash-filter')]">
+            <ixsl:set-property name="value" select="''" object="."/>
+        </xsl:for-each>
+        <xsl:variable name="items" as="element()*" select="$menu//li[contains-token(@class, 'slash-item')]"/>
+        <xsl:for-each select="$items">
+            <xsl:variable name="command" as="xs:string" select="string(@data-command)"/>
+            <xsl:variable name="applies" as="xs:boolean" select="
+                if ($command = ('p', 'h1', 'h2', 'h3', 'pre'))
+                    then ($convertible and local:parent-admits($host, $command))
+                else if ($command = 'blockquote') then $quotable
+                else if ($command = ('ul', 'ol'))
+                    then (exists($host/self::p) and local:parent-admits($host, $command))
+                else true()"/>
+            <xsl:choose>
+                <xsl:when test="$applies">
+                    <ixsl:remove-attribute name="data-disabled"/>
+                    <ixsl:set-style name="display" select="'block'"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <ixsl:set-attribute name="data-disabled" select="'true'"/>
+                    <ixsl:set-style name="display" select="'none'"/>
+                </xsl:otherwise>
+            </xsl:choose>
+            <ixsl:remove-attribute name="aria-selected"/>
+        </xsl:for-each>
+        <xsl:for-each select="($items[empty(@data-disabled)])[1]">
+            <ixsl:set-attribute name="aria-selected" select="'true'"/>
+        </xsl:for-each>
+        <xsl:call-template name="local:show-at-caret">
+            <xsl:with-param name="element" select="$menu"/>
+            <xsl:with-param name="anchor" select="$host"/>
+        </xsl:call-template>
+        <xsl:for-each select="($menu//input[contains-token(@class, 'slash-filter')])[1]">
+            <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="local:run-slash-command">
+        <xsl:param name="command" as="xs:string"/>
+        <xsl:variable name="host" as="element()?"
+            select="ixsl:get(local:editor-state(), 'slashHost')[exists(local:block-of(.))]"/>
+        <!-- teardown first: it clears slashHost and insertHost, so the
+             figure/table branches re-arm them after -->
+        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:for-each select="$host">
+            <xsl:choose>
+                <xsl:when test="$command = ('p', 'h1', 'h2', 'h3', 'pre')">
+                    <xsl:for-each select="$host[self::p or self::h1 or self::h2 or self::h3
+                            or self::pre][local-name() ne $command]">
+                        <xsl:call-template name="local:convert-block">
+                            <xsl:with-param name="block" select="."/>
+                            <xsl:with-param name="name" select="$command"/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                </xsl:when>
+                <xsl:when test="$command = 'blockquote'">
+                    <xsl:call-template name="local:wrap-in-blockquote">
+                        <xsl:with-param name="block" select="$host"/>
+                    </xsl:call-template>
+                </xsl:when>
+                <xsl:when test="$command = ('ul', 'ol')">
+                    <xsl:call-template name="local:push-undo">
+                        <xsl:with-param name="host" select="$host"/>
+                    </xsl:call-template>
+                    <xsl:call-template name="local:replace-with-list">
+                        <xsl:with-param name="block" select="$host"/>
+                        <xsl:with-param name="kind" select="$command"/>
+                    </xsl:call-template>
+                    <xsl:call-template name="local:after-mutation"/>
+                </xsl:when>
+                <xsl:when test="$command = 'figure'">
+                    <ixsl:set-property name="insertHost" select="$host" object="local:editor-state()"/>
+                    <xsl:variable name="dialog" as="element()" select="id('figure-dialog', ixsl:page())"/>
+                    <xsl:for-each select="$dialog//input">
+                        <ixsl:set-property name="value" select="''" object="."/>
+                    </xsl:for-each>
+                    <xsl:call-template name="local:show-at-element">
+                        <xsl:with-param name="element" select="$dialog"/>
+                        <xsl:with-param name="anchor" select="$host"/>
+                    </xsl:call-template>
+                    <xsl:for-each select="($dialog//input[@name = 'src'])[1]">
+                        <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:for-each>
+                </xsl:when>
+                <xsl:when test="$command = 'table'">
+                    <ixsl:set-property name="insertHost" select="$host" object="local:editor-state()"/>
+                    <xsl:variable name="dialog" as="element()" select="id('table-dialog', ixsl:page())"/>
+                    <!-- same defaults as the toolbar opener -->
+                    <xsl:for-each select="($dialog//input[@name = 'rows'])[1], ($dialog//input[@name = 'cols'])[1]">
+                        <ixsl:set-property name="value" select="'3'" object="."/>
+                    </xsl:for-each>
+                    <xsl:for-each select="($dialog//input[@name = 'caption'])[1]">
+                        <ixsl:set-property name="value" select="''" object="."/>
+                    </xsl:for-each>
+                    <xsl:for-each select="($dialog//input[@name = 'header-row'])[1]">
+                        <ixsl:set-property name="checked" select="true()" object="."/>
+                    </xsl:for-each>
+                    <xsl:call-template name="local:show-at-element">
+                        <xsl:with-param name="element" select="$dialog"/>
+                        <xsl:with-param name="anchor" select="$host"/>
+                    </xsl:call-template>
+                    <xsl:for-each select="($dialog//input[@name = 'rows'])[1]">
+                        <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:for-each>
+                </xsl:when>
+                <!-- extension commands (mirror the figure/table branches: teardown
+                     already ran, the extension re-arms insertHost itself) -->
+                <xsl:otherwise>
+                    <xsl:call-template name="local:run-extra-slash-command">
+                        <xsl:with-param name="command" select="$command"/>
+                        <xsl:with-param name="host" select="$host"/>
+                    </xsl:call-template>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="input[contains-token(@class, 'slash-filter')]" mode="ixsl:oninput">
+        <xsl:variable name="q" as="xs:string" select="lower-case(normalize-space(string(ixsl:get(., 'value'))))"/>
+        <xsl:variable name="items" as="element()*"
+            select="id('slash-menu', ixsl:page())//li[contains-token(@class, 'slash-item')][empty(@data-disabled)]"/>
+        <xsl:variable name="visible" as="element()*"
+            select="$items[$q = '' or contains(lower-case(string(.)), $q)]"/>
+        <xsl:for-each select="$items">
+            <ixsl:set-style name="display" select="if (. intersect $visible) then 'block' else 'none'"/>
+            <ixsl:remove-attribute name="aria-selected"/>
+        </xsl:for-each>
+        <xsl:for-each select="$visible[1]">
+            <ixsl:set-attribute name="aria-selected" select="'true'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="input[contains-token(@class, 'slash-filter')]" mode="ixsl:onkeydown">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="key" as="xs:string" select="string(ixsl:get($event, 'key'))"/>
+        <xsl:variable name="items" as="element()*"
+            select="id('slash-menu', ixsl:page())//li[contains-token(@class, 'slash-item')]
+                [empty(@data-disabled)][ixsl:get(., 'style.display') ne 'none']"/>
+        <xsl:variable name="current" as="element()?" select="$items[@aria-selected = 'true'][1]"/>
+        <xsl:choose>
+            <xsl:when test="$key = 'Escape'">
+                <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:call-template name="local:hide-dialogs"/>
+            </xsl:when>
+            <xsl:when test="$key = 'Enter'">
+                <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:for-each select="($current, $items[1])[1]">
+                    <xsl:call-template name="local:run-slash-command">
+                        <xsl:with-param name="command" select="string(@data-command)"/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:when test="$key = ('ArrowDown', 'ArrowUp')">
+                <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:variable name="pos" as="xs:integer"
+                    select="if (exists($current)) then count($items[. &lt;&lt; $current]) + 1 else 1"/>
+                <xsl:variable name="next" as="xs:integer" select="if ($key = 'ArrowDown')
+                    then min(($pos + 1, count($items))) else max(($pos - 1, 1))"/>
+                <xsl:for-each select="$items">
+                    <ixsl:remove-attribute name="aria-selected"/>
+                </xsl:for-each>
+                <xsl:for-each select="$items[$next]">
+                    <ixsl:set-attribute name="aria-selected" select="'true'"/>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise/>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="li[contains-token(@class, 'slash-item')]" mode="ixsl:onclick">
+        <xsl:call-template name="local:run-slash-command">
+            <xsl:with-param name="command" select="string(@data-command)"/>
+        </xsl:call-template>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/lint-rdfa.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/lint-rdfa.xsl
new file mode 100644
index 000000000..741f37227
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/lint-rdfa.xsl
@@ -0,0 +1,121 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    xmlns:map="http://www.w3.org/2005/xpath-functions/map"
+    xmlns:rdfa="urn:rdfa:functions"
+    xmlns:lint="urn:rdfa-editor:lint"
+    xpath-default-namespace="http://www.w3.org/1999/xhtml"
+    exclude-result-prefixes="xs map rdfa"
+    version="3.0">
+
+<!--
+    RDFa lint: flags markup that extracts to something almost certainly unintended.
+    Pure XSLT 3.0 - no ixsl: - tested headless via tests/lint-driver.xsl. Reuses the
+    extractor's resolution functions (rdfa:resolve-term-or-curie, rdfa:literal-value,
+    rdfa:bnode-label, $rdfa:default-prefixes), so lint verdicts and extraction
+    semantics cannot drift apart. Not standalone-compilable: include/import it
+    alongside RDFa2RDFXML-v3.xsl.
+
+    Checks:
+    - term-unresolvable        @property/@typeof/@datatype token that neither resolves
+                               as CURIE/term nor is scheme-shaped
+    - empty-href               a[@href] with a whitespace-only target
+    - content-resource-conflict @property + @content + @resource (RDFa step 11:
+                               @content wins, the resource is silently orphaned)
+    - empty-literal            @property whose extracted literal value is ''
+    - about-relative           @about that is neither '', '#...', '_:...', a CURIE,
+                               nor an absolute IRI (the editor emits absolute IRIs)
+-->
+
+    <!-- elements the extractor traverses: everything except head/script/style/@data-role subtrees -->
+    <xsl:function name="lint:lintable" as="element()*">
+        <xsl:param name="root" as="element()"/>
+        <xsl:sequence select="$root/descendant-or-self::*[not(ancestor-or-self::head
+            | ancestor-or-self::script | ancestor-or-self::style | ancestor-or-self::*[@data-role])]"/>
+    </xsl:function>
+
+    <!-- nearest-wins prefix map, mirroring the extractor's top-down merge -->
+    <xsl:function name="lint:in-scope-prefixes" as="map(xs:string, xs:string)">
+        <xsl:param name="element" as="element()"/>
+        <xsl:sequence select="map:merge(($rdfa:default-prefixes,
+            $element/ancestor-or-self::* ! (rdfa:in-scope-namespaces(.), rdfa:parse-prefix-attr(@prefix))),
+            map{ 'duplicates': 'use-last' })"/>
+    </xsl:function>
+
+    <!-- nearest @vocab; an empty value resets, mirroring the extractor -->
+    <xsl:function name="lint:in-scope-vocab" as="xs:string?">
+        <xsl:param name="element" as="element()"/>
+        <xsl:sequence select="$element/ancestor-or-self::*[@vocab][1]/@vocab[. ne ''] ! string(.)"/>
+    </xsl:function>
+
+    <!-- deterministic element path, shared with the extractor's bnode labelling -->
+    <xsl:function name="lint:path" as="xs:string">
+        <xsl:param name="element" as="element()"/>
+        <xsl:sequence select="rdfa:bnode-label($element)"/>
+    </xsl:function>
+
+    <xsl:function name="lint:element-issues" as="element(lint:issue)*">
+        <xsl:param name="element" as="element()"/>
+
+        <xsl:variable name="prefixes" as="map(xs:string, xs:string)" select="lint:in-scope-prefixes($element)"/>
+        <xsl:variable name="vocab" as="xs:string?" select="lint:in-scope-vocab($element)"/>
+
+        <!-- term-unresolvable -->
+        <xsl:for-each select="$element/(@property, @typeof, @datatype)">
+            <xsl:variable name="attribute" as="xs:string" select="name(.)"/>
+            <xsl:for-each select="tokenize(.)[empty(rdfa:resolve-term-or-curie(., $prefixes, $vocab))]">
+                <lint:issue code="term-unresolvable" path="{lint:path($element)}">@<xsl:value-of
+                    select="$attribute"/> term '<xsl:value-of select="."/>' resolves to no IRI (no in-scope vocab or prefix)</lint:issue>
+            </xsl:for-each>
+        </xsl:for-each>
+
+        <!-- empty-href -->
+        <xsl:for-each select="$element[self::a][@href][normalize-space(@href) = '']">
+            <lint:issue code="empty-href" path="{lint:path($element)}">link has an empty @href</lint:issue>
+        </xsl:for-each>
+
+        <!-- content-resource-conflict -->
+        <xsl:for-each select="$element[@property][@content][@resource]">
+            <lint:issue code="content-resource-conflict" path="{lint:path($element)}">@content and @resource
+                on the same @property element: @content wins, the resource is orphaned</lint:issue>
+        </xsl:for-each>
+
+        <!-- empty-literal: the extractor's statement branches, restricted to literal outcomes -->
+        <xsl:for-each select="$element[@property][
+                (: literal via @content/@datatype (rule 5.2 branch) :)
+                ((@content or @datatype) and string((@content, rdfa:literal-value($element))[1]) = '')
+                or
+                (: plain text literal branch: no IRI object, no typeof chaining :)
+                (not(@content) and not(@datatype) and not(@resource) and not(@href) and not(@src)
+                    and not(@typeof and not(@about)) and rdfa:literal-value($element) = '')]">
+            <lint:issue code="empty-literal" path="{lint:path($element)}">@property '<xsl:value-of
+                select="@property"/>' extracts an empty literal</lint:issue>
+        </xsl:for-each>
+
+        <!-- unsafe-attribute: event handlers are stripped by canonicalization; flag them early -->
+        <xsl:for-each select="$element/@*[matches(local-name(), '^on', 'i')]">
+            <lint:issue code="unsafe-attribute" path="{lint:path($element)}">event-handler attribute
+                @<xsl:value-of select="name(.)"/> will be stripped from the canonical document</lint:issue>
+        </xsl:for-each>
+
+        <!-- unsafe-url: scripting/data schemes in link and media targets -->
+        <xsl:for-each select="$element/@href[matches(normalize-space(.), '^(javascript|vbscript|data):', 'i')],
+                $element/@src[matches(normalize-space(.), '^(javascript|vbscript):', 'i')],
+                $element/@src[matches(normalize-space(.), '^data:', 'i')][not(matches(normalize-space(.), '^data:image/', 'i'))]">
+            <lint:issue code="unsafe-url" path="{lint:path($element)}">@<xsl:value-of select="name(.)"/>
+                uses an unsafe URL scheme and will be stripped from the canonical document</lint:issue>
+        </xsl:for-each>
+
+        <!-- about-relative -->
+        <xsl:for-each select="$element/@about[normalize-space(.) ne '']
+                [not(starts-with(normalize-space(.), '#'))]
+                [not(starts-with(normalize-space(.), '_:'))]
+                [not(map:contains($prefixes, substring-before(normalize-space(.), ':')))]
+                [not(matches(normalize-space(.), '^[a-zA-Z][a-zA-Z0-9+.-]*:'))]">
+            <lint:issue code="about-relative" path="{lint:path($element)}">@about '<xsl:value-of
+                select="."/>' is a relative reference - likely a typo for '#...' or an absolute IRI</lint:issue>
+        </xsl:for-each>
+    </xsl:function>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/lint-xhtml.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/lint-xhtml.xsl
new file mode 100644
index 000000000..d80c3af38
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/lint-xhtml.xsl
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    xmlns:cm="urn:rdfa-editor:content-model"
+    xmlns:lint="urn:rdfa-editor:lint"
+    xpath-default-namespace="http://www.w3.org/1999/xhtml"
+    exclude-result-prefixes="xs cm"
+    version="3.0">
+
+<!--
+    XHTML nesting lint: flags markup the content model disallows. Pure XSLT 3.0 -
+    no ixsl: - tested headless via tests/lint-driver.xsl. Consults content-model.xsl
+    (cm:*) - the same single source of truth the boundary normalization
+    (canonical-xhtml.xsl) applies - so lint verdicts and normalization behavior
+    cannot drift apart. Paths come from lint:path (lint-rdfa.xsl). Not standalone-
+    compilable: include/import alongside content-model.xsl and lint-rdfa.xsl.
+
+    Checks:
+    - invalid-nesting     a known element not allowed as a child of its known parent
+                          (e.g. blocks inside p, non-li children of ul)
+    - stray-text          non-whitespace text directly inside an element-only
+                          container (e.g. bare text in blockquote or ul)
+    - prohibited-nesting  XHTML 1.0 Appendix B prohibitions (a in a, img in pre, ...)
+    - unknown-element     an element outside the XHTML Strict (+figure) content
+                          model - preserved, but unvalidated
+-->
+
+    <xsl:function name="lint:nesting-issues" as="element(lint:issue)*">
+        <xsl:param name="element" as="element()"/>
+        <xsl:variable name="name" as="xs:string" select="local-name($element)"/>
+
+        <!-- unknown-element -->
+        <xsl:for-each select="$element[not(cm:known($name))]">
+            <lint:issue code="unknown-element" path="{lint:path($element)}">element '<xsl:value-of
+                select="$name"/>' is outside the XHTML content model - preserved, but its nesting is unvalidated</lint:issue>
+        </xsl:for-each>
+
+        <!-- invalid-nesting -->
+        <xsl:for-each select="$element[cm:known($name)]/parent::*[cm:known(local-name(.))]
+                [not(cm:allows-child(local-name(.), $name))]">
+            <lint:issue code="invalid-nesting" path="{lint:path($element)}">'<xsl:value-of
+                select="$name"/>' is not allowed inside '<xsl:value-of select="local-name(.)"/>'</lint:issue>
+        </xsl:for-each>
+
+        <!-- stray-text -->
+        <xsl:for-each select="$element[cm:structural($name)][text()[normalize-space()]]">
+            <lint:issue code="stray-text" path="{lint:path($element)}">'<xsl:value-of
+                select="$name"/>' allows no text content - stray text will be wrapped by canonicalization</lint:issue>
+        </xsl:for-each>
+
+        <!-- prohibited-nesting -->
+        <xsl:for-each select="$element/ancestor::*[local-name() = cm:prohibited-ancestors($name)][1]">
+            <lint:issue code="prohibited-nesting" path="{lint:path($element)}">'<xsl:value-of
+                select="$name"/>' must not appear inside '<xsl:value-of
+                select="local-name(.)"/>' (XHTML 1.0 Appendix B)</lint:issue>
+        </xsl:for-each>
+    </xsl:function>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/navigate.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/navigate.xsl
new file mode 100644
index 000000000..a655c8b2f
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/navigate.xsl
@@ -0,0 +1,711 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfa="urn:rdfa:functions"
+xmlns:lint="urn:rdfa-editor:lint"
+xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    Document navigation and awareness (FontoXML-inspired): the ToC drawer (outline
+    view with section drag-reorder), the breadcrumb bar (element path + RDFa subject
+    in scope at the caret), lint surfacing (markers + badge; logic in lint-rdfa.xsl),
+    and find & replace. All UI lives outside #content - no data-role needed; the only
+    thing ever written into content is the rdfa-invalid class (canonicalization-
+    stripped, extractor-invisible; @title is forbidden - it would serialize).
+-->
+
+    <xsl:template name="local:init-navigate">
+        <xsl:for-each select="ixsl:page()//body">
+            <xsl:result-document href="?." method="ixsl:append-content">
+                <aside id="toc-drawer" class="rdfa-editor-ui" role="navigation" aria-label="Table of contents" style="display: none;">
+                    <button type="button" id="toc-close" class="toc-close" title="Close" aria-label="Close table of contents">&#215;</button>
+                    <h2>Contents</h2>
+                    <div id="toc-list"/>
+                </aside>
+                <aside id="inspector-drawer" class="rdfa-editor-ui" role="complementary" aria-label="Subject properties" style="display: none;">
+                    <button type="button" id="inspector-close" class="inspector-close" title="Close" aria-label="Close properties">&#215;</button>
+                    <h2>Properties</h2>
+                    <div id="inspector-subject"/>
+                    <div id="inspector-body"/>
+                </aside>
+                <footer id="rdfa-editor-breadcrumb" class="rdfa-editor-ui" role="navigation" aria-label="Document position">
+                    <div id="rdfa-editor-breadcrumb-path"/>
+                    <div id="rdfa-editor-breadcrumb-meta">
+                        <span id="rdfa-editor-breadcrumb-subject"/>
+                        <button type="button" id="lint-badge" class="lint-badge"
+                            aria-label="RDFa validation issues" style="display: none;"/>
+                    </div>
+                </footer>
+                <xsl:call-template name="local:render-find-dialog"/>
+            </xsl:result-document>
+        </xsl:for-each>
+        <xsl:call-template name="local:run-lint"/>
+        <xsl:call-template name="local:update-breadcrumb"/>
+    </xsl:template>
+
+    <!-- ................................ ToC drawer ................................ -->
+
+    <xsl:function name="local:rank" as="xs:integer">
+        <xsl:param name="heading" as="element()"/>
+        <xsl:sequence select="xs:integer(substring(local-name($heading), 2))"/>
+    </xsl:function>
+
+    <xsl:template name="local:render-toc">
+        <xsl:variable name="root" as="element()?" select="local:active-root()"/>
+        <xsl:variable name="headings" as="element()*" select="$root/(h1 | h2 | h3)"/>
+        <!-- remembered for item click/drag resolution (roots are never replaced, only
+             their children, so the reference stays valid across undo restores) -->
+        <ixsl:set-property name="tocRoot" select="$root" object="local:editor-state()"/>
+        <xsl:for-each select="id('toc-list', ixsl:page())">
+            <xsl:result-document href="?." method="ixsl:replace-content">
+                <xsl:choose>
+                    <xsl:when test="exists($headings)">
+                        <xsl:call-template name="local:toc-level">
+                            <xsl:with-param name="headings" select="$headings"/>
+                            <xsl:with-param name="root" select="$root"/>
+                            <xsl:with-param name="rank" select="1"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <p class="helper-text">No headings yet.</p>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:result-document>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- hierarchical outline by heading rank; handles skipped ranks naturally -->
+    <xsl:template name="local:toc-level">
+        <xsl:param name="headings" as="element()*"/>
+        <xsl:param name="root" as="element()"/>
+        <xsl:param name="rank" as="xs:integer"/>
+
+        <ul>
+            <xsl:for-each-group select="$headings" group-starting-with="*[local:rank(.) le $rank]">
+                <li class="toc-item toc-{local-name(current-group()[1])}" draggable="true"
+                    data-index="{count($root/(h1 | h2 | h3)[. &lt;&lt; current-group()[1]]) + 1}">
+                    <span class="toc-label">
+                        <xsl:value-of select="local:block-text(current-group()[1])"/>
+                    </span>
+                    <xsl:if test="exists(current-group()[position() gt 1])">
+                        <xsl:call-template name="local:toc-level">
+                            <xsl:with-param name="headings" select="current-group()[position() gt 1]"/>
+                            <xsl:with-param name="root" select="$root"/>
+                            <xsl:with-param name="rank" select="$rank + 1"/>
+                        </xsl:call-template>
+                    </xsl:if>
+                </li>
+            </xsl:for-each-group>
+        </ul>
+    </xsl:template>
+
+    <xsl:template match="button[@id = 'toc-toggle']" mode="ixsl:onclick">
+        <xsl:for-each select="id('toc-drawer', ixsl:page())">
+            <xsl:choose>
+                <xsl:when test="ixsl:get(., 'style.display') = 'none'">
+                    <xsl:call-template name="local:render-toc"/>
+                    <ixsl:set-style name="display" select="'block'"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <ixsl:set-style name="display" select="'none'"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="button[@id = 'toc-close']" mode="ixsl:onclick">
+        <xsl:for-each select="id('toc-drawer', ixsl:page())">
+            <ixsl:set-style name="display" select="'none'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- ................................ subject inspector ................................ -->
+
+    <xsl:template match="button[@id = 'inspector-toggle']" mode="ixsl:onclick">
+        <xsl:for-each select="id('inspector-drawer', ixsl:page())">
+            <xsl:choose>
+                <xsl:when test="ixsl:get(., 'style.display') = 'none'">
+                    <ixsl:set-style name="display" select="'block'"/>
+                    <xsl:call-template name="local:sync-inspector"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <ixsl:set-style name="display" select="'none'"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="button[@id = 'inspector-close']" mode="ixsl:onclick">
+        <xsl:for-each select="id('inspector-drawer', ixsl:page())">
+            <ixsl:set-style name="display" select="'none'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="span[contains-token(@class, 'toc-label')]" mode="ixsl:onclick">
+        <xsl:variable name="index" as="xs:integer" select="xs:integer(../@data-index)"/>
+        <xsl:for-each select="(ixsl:get(local:editor-state(), 'tocRoot')/(h1 | h2 | h3))[$index]">
+            <xsl:sequence select="ixsl:call(., 'scrollIntoView', [ map{ 'block': 'start' } ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:focus-caret">
+    <xsl:with-param name="node" select="."/>
+    <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+</xsl:call-template>
+            <xsl:call-template name="local:update-breadcrumb"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- ................................ ToC section drag ................................ -->
+
+    <!-- a section = the heading plus everything up to the next same-or-higher heading -->
+    <xsl:function name="local:section-of" as="element()+">
+        <xsl:param name="heading" as="element()"/>
+        <xsl:variable name="stop" as="element()?"
+            select="$heading/following-sibling::*[self::h1 or self::h2 or self::h3]
+                [local:rank(.) le local:rank($heading)][1]"/>
+        <xsl:sequence select="$heading | $heading/following-sibling::*[empty($stop) or . &lt;&lt; $stop]"/>
+    </xsl:function>
+
+    <xsl:template match="li[contains-token(@class, 'toc-item')]" mode="ixsl:ondragstart">
+        <xsl:variable name="transfer" select="ixsl:get(ixsl:event(), 'dataTransfer')"/>
+        <xsl:variable name="index" as="xs:integer" select="xs:integer(@data-index)"/>
+        <ixsl:set-property name="draggedSectionHeading"
+            select="(ixsl:get(local:editor-state(), 'tocRoot')/(h1 | h2 | h3))[$index]" object="local:editor-state()"/>
+        <ixsl:set-property name="effectAllowed" select="'move'" object="$transfer"/>
+        <xsl:sequence select="ixsl:call($transfer, 'setData', [ 'application/x-rdfa-editor-section', '' ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'add', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <xsl:template match="li[contains-token(@class, 'toc-item')]" mode="ixsl:ondragover">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:if test="exists(ixsl:get(local:editor-state(), 'draggedSectionHeading'))
+                and local:has-transfer-type($event, 'application/x-rdfa-editor-section')">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <ixsl:set-property name="dropEffect" select="'move'" object="ixsl:get($event, 'dataTransfer')"/>
+            <xsl:call-template name="local:clear-drop-marks">
+            <xsl:with-param name="scope" select="id('toc-list', ixsl:page())//li"/>
+        </xsl:call-template>
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'add',
+                [ if (local:drop-before($event, .)) then 'drop-before' else 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template match="li[contains-token(@class, 'toc-item')]" mode="ixsl:ondrop">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="item" as="element()" select="."/>
+        <xsl:variable name="source" select="ixsl:get(local:editor-state(), 'draggedSectionHeading')"/>
+        <xsl:variable name="before" as="xs:boolean" select="local:drop-before($event, $item)"/>
+        <xsl:call-template name="local:clear-drop-marks">
+            <xsl:with-param name="scope" select="id('toc-list', ixsl:page())//li"/>
+        </xsl:call-template>
+        <xsl:if test="exists($source) and local:has-transfer-type($event, 'application/x-rdfa-editor-section')">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <!-- bare-variable positional predicate: SaxonJS evaluates computed numeric
+                 predicates as booleans in this context -->
+            <xsl:variable name="index" as="xs:integer" select="xs:integer($item/@data-index)"/>
+            <xsl:variable name="target" as="element()?"
+                select="(ixsl:get(local:editor-state(), 'tocRoot')/(h1 | h2 | h3))[$index]"/>
+            <!-- no-op: dropping onto itself or into its own section (incl. subsections) -->
+            <xsl:if test="exists($target) and not($target is $source)
+                    and empty($target intersect local:section-of($source))">
+                <xsl:call-template name="local:push-undo"/>
+                <xsl:variable name="section" as="element()+" select="local:section-of($source)"/>
+                <xsl:choose>
+                    <xsl:when test="$before">
+                        <xsl:for-each select="$section">
+                            <xsl:sequence select="ixsl:call($target, 'before', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+                        </xsl:for-each>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:iterate select="$section">
+                            <xsl:param name="anchor" as="element()" select="local:section-of($target)[last()]"/>
+                            <xsl:sequence select="ixsl:call($anchor, 'after', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+                            <xsl:next-iteration>
+                                <xsl:with-param name="anchor" select="."/>
+                            </xsl:next-iteration>
+                        </xsl:iterate>
+                    </xsl:otherwise>
+                </xsl:choose>
+                <!-- after-mutation re-renders the (open) ToC -->
+                <xsl:call-template name="local:after-mutation"/>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template match="li[contains-token(@class, 'toc-item')]" mode="ixsl:ondragend">
+        <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:clear-drop-marks">
+            <xsl:with-param name="scope" select="id('toc-list', ixsl:page())//li"/>
+        </xsl:call-template>
+        <ixsl:set-property name="draggedSectionHeading" select="()" object="local:editor-state()"/>
+    </xsl:template>
+
+    <!-- ................................ breadcrumb ................................ -->
+
+    <xsl:function name="local:compact-term" as="xs:string">
+        <xsl:param name="term" as="xs:string"/>
+        <xsl:sequence select="if (matches($term, '^[a-zA-Z][a-zA-Z0-9+.-]*:'))
+            then rdfa:prefixed-name(rdfa:split-uri($term), $rdfa:default-prefixes)
+            else $term"/>
+    </xsl:function>
+
+    <xsl:function name="local:crumb-label" as="xs:string">
+        <xsl:param name="element" as="element()"/>
+        <xsl:choose>
+            <xsl:when test="contains-token($element/@class, 'rdfa-editor-content')">content</xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="term" as="xs:string?"
+                    select="($element/@property, $element/@typeof)[1] ! tokenize(.)[1]"/>
+                <xsl:sequence select="local-name($element) || ($term ! ('[' || local:compact-term(.) || ']'), '')[1]"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <xsl:template name="local:update-breadcrumb">
+        <xsl:variable name="node" select="(local:anchor-node(),
+            ixsl:get(local:editor-state(), 'activeBlock'))[1]"/>
+        <xsl:variable name="leaf" as="element()?" select="$node/ancestor-or-self::*[1]"/>
+        <xsl:choose>
+            <xsl:when test="exists($leaf) and exists(local:block-of($leaf))">
+                <ixsl:set-property name="breadcrumbLeaf" select="$leaf" object="local:editor-state()"/>
+                <xsl:variable name="ancestors" as="element()*"
+                    select="$leaf/ancestor-or-self::* intersect local:root-of($leaf)/descendant-or-self::*"/>
+                <xsl:for-each select="id('rdfa-editor-breadcrumb-path', ixsl:page())">
+                    <xsl:result-document href="?." method="ixsl:replace-content">
+                        <xsl:for-each select="$ancestors">
+                            <xsl:if test="position() gt 1">
+                                <span class="crumb-sep">&#x203A;</span>
+                            </xsl:if>
+                            <span class="crumb" data-index="{position()}">
+                                <xsl:value-of select="local:crumb-label(.)"/>
+                            </span>
+                        </xsl:for-each>
+                    </xsl:result-document>
+                </xsl:for-each>
+                <xsl:for-each select="id('rdfa-editor-breadcrumb-subject', ixsl:page())">
+                    <ixsl:set-property name="textContent"
+                        select="rdfa:in-scope-subject($leaf, local:document-uri())" object="."/>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise>
+                <ixsl:set-property name="breadcrumbLeaf" select="()" object="local:editor-state()"/>
+                <xsl:for-each select="id('rdfa-editor-breadcrumb-path', ixsl:page())">
+                    <ixsl:set-property name="textContent" select="''" object="."/>
+                </xsl:for-each>
+                <xsl:for-each select="id('rdfa-editor-breadcrumb-subject', ixsl:page())">
+                    <ixsl:set-property name="textContent" select="local:document-uri()" object="."/>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+        <xsl:call-template name="local:sync-table-toolbar"/>
+        <xsl:call-template name="local:sync-format-toolbar"/>
+        <xsl:call-template name="local:sync-inspector"/>
+    </xsl:template>
+
+    <!-- the property sheet for the subject in scope at the caret. Read-only: it
+         re-presents the extractor's own output (grouped per subject) so its verdicts
+         can never drift from "Extract RDF"/lint. Only does work while the drawer is
+         open; rides local:update-breadcrumb, so it tracks the caret and refreshes
+         after every mutation (annotate/undo route through local:after-mutation). -->
+    <xsl:template name="local:sync-inspector">
+        <xsl:for-each select="id('inspector-drawer', ixsl:page())[ixsl:get(., 'style.display') ne 'none']">
+            <xsl:variable name="base" as="xs:string" select="local:document-uri()"/>
+            <xsl:variable name="leaf" select="ixsl:get(local:editor-state(), 'breadcrumbLeaf')"/>
+            <xsl:variable name="subject" as="xs:string"
+                select="((if (exists($leaf)) then rdfa:in-scope-subject($leaf, $base) else ())[. ne ''], $base)[1]"/>
+            <xsl:variable name="rdf" as="element(rdf:RDF)">
+                <xsl:call-template name="extract-rdfa">
+                    <xsl:with-param name="doc" select="ixsl:page()"/>
+                    <xsl:with-param name="base" select="$base"/>
+                </xsl:call-template>
+            </xsl:variable>
+            <xsl:variable name="desc" as="element(rdf:Description)?" select="
+                local:group-triples($rdf)/rdf:Description[
+                    (@rdf:about = $subject)
+                    or (starts-with($subject, '_:') and @rdf:nodeID = substring-after($subject, '_:'))
+                ]"/>
+
+            <xsl:for-each select="id('inspector-subject', ixsl:page())">
+                <xsl:result-document href="?." method="ixsl:replace-content">
+                    <span class="inspector-subject-iri">
+                        <xsl:value-of select="local:short-iri($subject, $base)"/>
+                    </span>
+                    <xsl:for-each select="$desc/rdf:type/@rdf:resource">
+                        <span class="inspector-type">
+                            <xsl:value-of select="local:compact-term(.)"/>
+                        </span>
+                    </xsl:for-each>
+                </xsl:result-document>
+            </xsl:for-each>
+
+            <xsl:for-each select="id('inspector-body', ixsl:page())">
+                <xsl:result-document href="?." method="ixsl:replace-content">
+                    <xsl:variable name="props" as="element()*" select="$desc/*[not(self::rdf:type)]"/>
+                    <xsl:choose>
+                        <xsl:when test="exists($props)">
+                            <xsl:for-each select="$props">
+                                <div class="inspector-row">
+                                    <span class="inspector-pred">
+                                        <xsl:value-of select="local:compact-term(namespace-uri() || local-name())"/>
+                                    </span>
+                                    <span class="inspector-obj">
+                                        <xsl:choose>
+                                            <xsl:when test="@rdf:resource">
+                                                <span class="inspector-obj-iri">
+                                                    <xsl:value-of select="local:short-iri(@rdf:resource, $base)"/>
+                                                </span>
+                                            </xsl:when>
+                                            <xsl:when test="@rdf:nodeID">
+                                                <span class="inspector-obj-iri">_:<xsl:value-of select="@rdf:nodeID"/></span>
+                                            </xsl:when>
+                                            <xsl:otherwise>
+                                                <span class="inspector-obj-lit"><xsl:value-of select="."/></span>
+                                                <xsl:if test="@rdf:datatype">
+                                                    <span class="inspector-obj-dt"><xsl:value-of select="local:compact-term(@rdf:datatype)"/></span>
+                                                </xsl:if>
+                                                <xsl:if test="@xml:lang">
+                                                    <span class="inspector-obj-lang">@<xsl:value-of select="@xml:lang"/></span>
+                                                </xsl:if>
+                                            </xsl:otherwise>
+                                        </xsl:choose>
+                                    </span>
+                                </div>
+                            </xsl:for-each>
+                        </xsl:when>
+                        <xsl:otherwise>
+                            <p class="helper-text">No properties on this subject.</p>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:result-document>
+            </xsl:for-each>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- readable object/subject: the document itself, a same-document fragment, or a CURIE -->
+    <xsl:function name="local:short-iri" as="xs:string">
+        <xsl:param name="iri" as="xs:string"/>
+        <xsl:param name="base" as="xs:string"/>
+        <xsl:sequence select="
+            if ($iri eq $base) then 'this document'
+            else if (starts-with($iri, '_:')) then $iri
+            else if (starts-with($iri, $base)) then substring-after($iri, $base)
+            else local:compact-term($iri)"/>
+    </xsl:function>
+
+    <xsl:template match="span[contains-token(@class, 'crumb')]" mode="ixsl:onmousedown">
+        <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <xsl:template match="span[contains-token(@class, 'crumb')]" mode="ixsl:onclick">
+        <xsl:variable name="index" as="xs:integer" select="xs:integer(@data-index)"/>
+        <xsl:for-each select="ixsl:get(local:editor-state(), 'breadcrumbLeaf')[exists(local:block-of(.))]">
+            <xsl:variable name="target" as="element()?"
+                select="(ancestor-or-self::* intersect local:root-of(.)/descendant-or-self::*)[$index]"/>
+            <xsl:for-each select="$target">
+                <xsl:sequence select="ixsl:call(local:selection(),
+                    'selectAllChildren', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:for-each>
+        </xsl:for-each>
+        <xsl:call-template name="local:update-breadcrumb"/>
+    </xsl:template>
+
+    <!-- caret movement awareness: keyup and mouseup on hosts (no document-level
+         selectionchange - unproven in SaxonJS); focusin is handled in edit.xsl -->
+    <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onkeyup">
+        <xsl:if test="exists(local:block-of(.))">
+            <xsl:call-template name="local:update-breadcrumb"/>
+            <xsl:if test="(self::h1 or self::h2 or self::h3)
+                    and id('toc-drawer', ixsl:page()) ! (ixsl:get(., 'style.display') ne 'none')">
+                <xsl:call-template name="local:render-toc"/>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onmouseup">
+        <!-- innermost-match dispatch: a sweep ending over a host lands here, not
+             on the body/html disarm template (select.xsl) -->
+        <xsl:call-template name="local:disarm-sweep"/>
+        <xsl:if test="exists(local:block-of(.))">
+            <xsl:call-template name="local:update-breadcrumb"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- ................................ lint surfacing ................................ -->
+
+    <xsl:template name="local:run-lint">
+        <xsl:for-each select="local:roots()//*[contains-token(@class, 'rdfa-invalid')]">
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'rdfa-invalid' ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <!-- the issue functions run once per element: markers and the badge count
+             both derive from the same evaluation (this fires on every mutation) -->
+        <xsl:variable name="linted" as="map(*)*" select="local:roots() ! lint:lintable(.) ! map{
+            'element': .,
+            'issues': count((lint:element-issues(.), lint:nesting-issues(.))) }"/>
+        <xsl:for-each select="$linted[?issues gt 0]?element">
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'add', [ 'rdfa-invalid' ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:variable name="count" as="xs:integer" select="sum($linted?issues)"/>
+        <xsl:for-each select="id('lint-badge', ixsl:page())">
+            <xsl:choose>
+                <xsl:when test="$count gt 0">
+                    <ixsl:set-property name="textContent"
+                        select="$count || ' issue' || (if ($count gt 1) then 's' else '')" object="."/>
+                    <ixsl:set-style name="display" select="'inline-block'"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <ixsl:set-style name="display" select="'none'"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="button[@id = 'lint-badge']" mode="ixsl:onclick">
+        <xsl:variable name="lines" as="xs:string*"
+            select="local:roots() ! lint:lintable(.) ! (lint:element-issues(.), lint:nesting-issues(.))
+                ! (string(@code) || ' &#x2014; ' || normalize-space(string(.)))"/>
+        <xsl:call-template name="local:show-output">
+            <xsl:with-param name="title" select="'Validation issues'"/>
+            <xsl:with-param name="text" select="string-join($lines, '&#10;')"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- ................................ find &amp; replace ................................ -->
+
+    <xsl:function name="local:norm" as="xs:string">
+        <xsl:param name="s" as="xs:string"/>
+        <xsl:param name="ci" as="xs:boolean"/>
+        <xsl:sequence select="if ($ci) then lower-case($s) else $s"/>
+    </xsl:function>
+
+    <!-- 1-based position of the next occurrence at or after $from, or empty -->
+    <xsl:function name="local:find-in" as="xs:integer?">
+        <xsl:param name="hay" as="xs:string"/>
+        <xsl:param name="from" as="xs:integer"/>
+        <xsl:param name="query" as="xs:string"/>
+        <xsl:param name="ci" as="xs:boolean"/>
+        <xsl:variable name="tail" as="xs:string" select="local:norm(substring($hay, $from), $ci)"/>
+        <xsl:variable name="q" as="xs:string" select="local:norm($query, $ci)"/>
+        <xsl:sequence select="if (contains($tail, $q))
+            then $from + string-length(substring-before($tail, $q)) else ()"/>
+    </xsl:function>
+
+    <!-- all occurrences replaced within one string; returns map{'value','count'} -->
+    <xsl:function name="local:replace-in-string" as="map(*)">
+        <xsl:param name="hay" as="xs:string"/>
+        <xsl:param name="query" as="xs:string"/>
+        <xsl:param name="replacement" as="xs:string"/>
+        <xsl:param name="ci" as="xs:boolean"/>
+        <xsl:variable name="p" as="xs:integer?" select="local:find-in($hay, 1, $query, $ci)"/>
+        <xsl:choose>
+            <xsl:when test="empty($p)">
+                <xsl:sequence select="map{ 'value': $hay, 'count': 0 }"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="rest" as="map(*)" select="local:replace-in-string(
+                    substring($hay, $p + string-length($query)), $query, $replacement, $ci)"/>
+                <xsl:sequence select="map{
+                    'value': substring($hay, 1, $p - 1) || $replacement || $rest?value,
+                    'count': 1 + xs:integer($rest?count) }"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <xsl:template name="local:render-find-dialog">
+        <div id="find-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
+                aria-label="Find and replace" style="display: none;">
+            <label>Find</label>
+            <input type="text" name="find"/>
+            <label>Replace with</label>
+            <input type="text" name="replace"/>
+            <label class="checkbox-label">
+                <input type="checkbox" name="match-case"/> Match case
+            </label>
+            <div class="action-buttons">
+                <button type="button" class="btn-primary find-next">Find next</button>
+                <button type="button" class="btn-secondary replace-current">Replace</button>
+                <button type="button" class="btn-secondary replace-all">Replace all</button>
+                <button type="button" class="btn-secondary find-close">Close</button>
+            </div>
+            <span id="find-status" class="helper-text"/>
+        </div>
+    </xsl:template>
+
+    <xsl:template match="button[@id = 'find-open']" mode="ixsl:onclick">
+        <xsl:variable name="dialog" as="element()" select="id('find-dialog', ixsl:page())"/>
+        <xsl:call-template name="local:show-at">
+            <xsl:with-param name="element" select="$dialog"/>
+            <xsl:with-param name="event" select="ixsl:event()"/>
+        </xsl:call-template>
+        <xsl:for-each select="($dialog//input[@name = 'find'])[1]">
+            <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- keep the content selection (the match highlight) alive across button clicks -->
+    <xsl:template match="div[@id = 'find-dialog']//button" mode="ixsl:onmousedown">
+        <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'find-close')]" mode="ixsl:onclick">
+        <xsl:call-template name="local:hide-dialogs"/>
+    </xsl:template>
+
+    <xsl:template name="local:find-status">
+        <xsl:param name="message" as="xs:string"/>
+        <xsl:for-each select="id('find-status', ixsl:page())">
+            <ixsl:set-property name="textContent" select="$message" object="."/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'find-next')]" mode="ixsl:onclick">
+        <xsl:call-template name="local:find-next"/>
+    </xsl:template>
+
+    <xsl:template name="local:find-next">
+        <xsl:variable name="dialog" as="element()" select="id('find-dialog', ixsl:page())"/>
+        <xsl:variable name="query" as="xs:string"
+            select="string(ixsl:get(($dialog//input[@name = 'find'])[1], 'value'))"/>
+        <xsl:variable name="ci" as="xs:boolean"
+            select="not(ixsl:get(($dialog//input[@name = 'match-case'])[1], 'checked'))"/>
+        <xsl:choose>
+            <xsl:when test="$query = ''">
+                <xsl:call-template name="local:find-status">
+                    <xsl:with-param name="message" select="'Enter a search term.'"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="texts" select="local:roots()//text()[not(ancestor::*[@data-role])]"/>
+                <xsl:variable name="current" select="ixsl:get(local:editor-state(), 'findNode')[exists(local:block-of(.))]"/>
+                <xsl:variable name="offset" as="xs:integer"
+                    select="(ixsl:get(local:editor-state(), 'findOffset') ! xs:integer(.), 1)[1]"/>
+                <!-- wrap-around scan plan: current node from the last match onward,
+                     following nodes, preceding nodes, current node from the top -->
+                <xsl:variable name="plan" as="map(*)*" select="
+                    if (exists($current)) then (
+                        map{ 'n': $current, 'from': $offset },
+                        for $t in $texts[. &gt;&gt; $current] return map{ 'n': $t, 'from': 1 },
+                        for $t in $texts[. &lt;&lt; $current] return map{ 'n': $t, 'from': 1 },
+                        map{ 'n': $current, 'from': 1 })
+                    else for $t in $texts return map{ 'n': $t, 'from': 1 }"/>
+                <xsl:iterate select="$plan">
+                    <xsl:on-completion>
+                        <xsl:call-template name="local:find-status">
+                            <xsl:with-param name="message" select="'No matches.'"/>
+                        </xsl:call-template>
+                        <ixsl:set-property name="findNode" select="()" object="local:editor-state()"/>
+                        <ixsl:set-property name="findOffset" select="1" object="local:editor-state()"/>
+                    </xsl:on-completion>
+                    <xsl:variable name="node" select="?n"/>
+                    <xsl:variable name="position" as="xs:integer?"
+                        select="local:find-in(string($node), ?from, $query, $ci)"/>
+                    <xsl:choose>
+                        <xsl:when test="exists($position)">
+                            <xsl:for-each select="local:host-of($node)">
+                                <xsl:call-template name="local:focus">
+                                    <xsl:with-param name="element" select="."/>
+                                </xsl:call-template>
+                            </xsl:for-each>
+                            <xsl:sequence select="ixsl:call(local:selection(),
+                                'setBaseAndExtent', [ $node, $position - 1, $node,
+                                    $position - 1 + string-length($query) ])[current-date() lt xs:date('2000-01-01')]"/>
+                            <xsl:sequence select="ixsl:call(ixsl:get($node, 'parentElement'), 'scrollIntoView',
+                                [ map{ 'block': 'center' } ])[current-date() lt xs:date('2000-01-01')]"/>
+                            <ixsl:set-property name="findNode" select="$node" object="local:editor-state()"/>
+                            <ixsl:set-property name="findOffset"
+                                select="$position + string-length($query)" object="local:editor-state()"/>
+                            <xsl:call-template name="local:find-status">
+                                <xsl:with-param name="message" select="''"/>
+                            </xsl:call-template>
+                            <xsl:call-template name="local:update-breadcrumb"/>
+                            <xsl:break/>
+                        </xsl:when>
+                        <xsl:otherwise>
+                            <xsl:next-iteration/>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:iterate>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'replace-current')]" mode="ixsl:onclick">
+        <xsl:variable name="dialog" as="element()" select="id('find-dialog', ixsl:page())"/>
+        <xsl:variable name="query" as="xs:string"
+            select="string(ixsl:get(($dialog//input[@name = 'find'])[1], 'value'))"/>
+        <xsl:variable name="replacement" as="xs:string"
+            select="string(ixsl:get(($dialog//input[@name = 'replace'])[1], 'value'))"/>
+        <xsl:variable name="ci" as="xs:boolean"
+            select="not(ixsl:get(($dialog//input[@name = 'match-case'])[1], 'checked'))"/>
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:choose>
+            <!-- the current selection is the match found by find-next -->
+            <xsl:when test="$query ne '' and ixsl:get($selection, 'rangeCount') ge 1
+                    and not(ixsl:get($selection, 'isCollapsed'))
+                    and (ixsl:get($selection, 'anchorNode') ! exists(local:block-of(.)))
+                    and local:norm(string(ixsl:call($selection, 'toString', [])), $ci) eq local:norm($query, $ci)">
+                <xsl:variable name="range" select="local:caret-range()"/>
+                <xsl:call-template name="local:push-undo"/>
+                <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:if test="$replacement ne ''">
+                    <xsl:variable name="node" select="ixsl:call(ixsl:page(), 'createTextNode', [ $replacement ])"/>
+                    <xsl:sequence select="ixsl:call($range, 'insertNode', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+                    <ixsl:set-property name="findNode" select="$node" object="local:editor-state()"/>
+                    <ixsl:set-property name="findOffset" select="string-length($replacement) + 1" object="local:editor-state()"/>
+                </xsl:if>
+                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="local:find-next"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:find-next"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- pure nodeValue rewrites: no structural change, annotation-safe by construction -->
+    <xsl:template match="button[contains-token(@class, 'replace-all')]" mode="ixsl:onclick">
+        <xsl:variable name="dialog" as="element()" select="id('find-dialog', ixsl:page())"/>
+        <xsl:variable name="query" as="xs:string"
+            select="string(ixsl:get(($dialog//input[@name = 'find'])[1], 'value'))"/>
+        <xsl:variable name="replacement" as="xs:string"
+            select="string(ixsl:get(($dialog//input[@name = 'replace'])[1], 'value'))"/>
+        <xsl:variable name="ci" as="xs:boolean"
+            select="not(ixsl:get(($dialog//input[@name = 'match-case'])[1], 'checked'))"/>
+        <xsl:variable name="matched" select="local:roots()//text()[not(ancestor::*[@data-role])]
+            [$query ne ''][contains(local:norm(string(.), $ci), local:norm($query, $ci))]"/>
+        <xsl:choose>
+            <xsl:when test="empty($matched)">
+                <xsl:call-template name="local:find-status">
+                    <xsl:with-param name="message"
+                        select="if ($query = '') then 'Enter a search term.' else 'No matches.'"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:push-undo"/>
+                <xsl:iterate select="$matched">
+                    <xsl:param name="total" as="xs:integer" select="0"/>
+                    <xsl:on-completion>
+                        <xsl:call-template name="local:find-status">
+                            <xsl:with-param name="message" select="$total || ' occurrence'
+                                || (if ($total ne 1) then 's' else '') || ' replaced.'"/>
+                        </xsl:call-template>
+                    </xsl:on-completion>
+                    <xsl:variable name="result" as="map(*)"
+                        select="local:replace-in-string(string(.), $query, $replacement, $ci)"/>
+                    <ixsl:set-property name="nodeValue" select="$result?value" object="."/>
+                    <xsl:next-iteration>
+                        <xsl:with-param name="total" select="$total + xs:integer($result?count)"/>
+                    </xsl:next-iteration>
+                </xsl:iterate>
+                <ixsl:set-property name="findNode" select="()" object="local:editor-state()"/>
+                <ixsl:set-property name="findOffset" select="1" object="local:editor-state()"/>
+                <xsl:call-template name="local:after-mutation"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/overlay.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/overlay.xsl
new file mode 100644
index 000000000..ec4226c7c
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/overlay.xsl
@@ -0,0 +1,345 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+    <!-- select value marking the free-text custom-IRI state ('' means none/unset) -->
+    <xsl:variable name="local:custom" as="xs:string" select="'urn:rdfa-editor:custom'"/>
+
+<!--
+    The annotation overlay: rendered once at startup (hidden), then only populated,
+    shown and hidden. The form is framed as the statement being asserted - subject,
+    predicate, object rows - with type/subject/object overrides in a details
+    disclosure. There is no mode selection: the emitted RDFa attributes follow from
+    which fields are filled. Form state is read and written via live DOM properties
+    (checked/value/disabled/open) - attributes never reflect user input.
+-->
+
+    <xsl:template name="local:init-overlay">
+        <xsl:for-each select="ixsl:page()//body">
+            <xsl:result-document href="?." method="ixsl:append-content">
+                <xsl:call-template name="local:render-overlay"/>
+            </xsl:result-document>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="local:render-overlay">
+        <div id="overlay" class="rdfa-editor-ui" role="dialog" aria-modal="true" aria-label="RDFa annotation" style="display: none;">
+            <div class="overlay-header">
+                <h3>RDFa Annotation</h3>
+            </div>
+            <form id="annotation-form">
+                <div class="statement">
+                    <span class="stmt-role" title="Subject">S</span>
+                    <div id="stmt-subject" class="stmt-value"/>
+                    <span class="stmt-role" title="Predicate">P</span>
+                    <div class="stmt-control">
+                        <xsl:sequence select="local:typeahead-field('property')"/>
+                    </div>
+                    <span class="stmt-role" title="Object">O</span>
+                    <div class="stmt-control">
+                        <input type="text" name="value" placeholder="Literal value"/>
+                        <span class="helper-text">The selected text; change it to emit a machine-readable content value</span>
+                    </div>
+                </div>
+
+                <details id="advanced-fields">
+                    <summary>Type, subject &amp; object</summary>
+                    <fieldset>
+                        <label>Entity type (typeof)</label>
+                        <xsl:sequence select="local:typeahead-field('typeof')"/>
+                        <span class="helper-text">Types the annotated resource; without a subject the typed
+                            resource becomes the object of the property (chaining)</span>
+                    </fieldset>
+                    <fieldset>
+                        <label>Subject (about)</label>
+                        <input type="text" name="subject" placeholder="Overrides the subject in scope"/>
+                        <span class="helper-text">IRI or _:blank-node identifier</span>
+                    </fieldset>
+                    <fieldset>
+                        <label>Object (resource)</label>
+                        <input type="text" name="object" placeholder="Object IRI"/>
+                        <span class="helper-text">Makes the object a resource instead of the literal value</span>
+                    </fieldset>
+                    <fieldset>
+                        <label>Literal type (datatype)</label>
+                        <select name="datatype">
+                            <option value="">(plain literal)</option>
+                            <xsl:variable name="xsd" as="xs:string" select="'http://www.w3.org/2001/XMLSchema#'"/>
+                            <xsl:for-each select="'string', 'date', 'dateTime', 'time', 'integer',
+                                    'decimal', 'double', 'float', 'boolean', 'anyURI'">
+                                <option value="{$xsd || .}">xsd:<xsl:value-of select="."/></option>
+                            </xsl:for-each>
+                            <option value="{$local:custom}">-- Custom datatype --</option>
+                        </select>
+                        <input type="text" name="custom-datatype" placeholder="Datatype IRI" style="display: none;"/>
+                        <span class="helper-text">Types the literal (e.g. xsd:date, xsd:integer);
+                            mutually exclusive with a language tag</span>
+                    </fieldset>
+                    <fieldset>
+                        <label>Language (lang)</label>
+                        <input type="text" name="lang" placeholder="e.g. en, fr-CA"/>
+                        <span class="helper-text">Language tag for the literal; ignored when a datatype is set</span>
+                    </fieldset>
+                </details>
+
+                <div class="action-buttons">
+                    <button type="button" class="btn-danger remove-action" style="display: none;">Remove</button>
+                    <button type="button" class="btn-primary spo-action">Annotate</button>
+                    <button type="button" class="btn-secondary cancel-action">Cancel</button>
+                </div>
+            </form>
+        </div>
+    </xsl:template>
+
+    <!-- all form reads via live properties: the checked/value attributes never change on user input -->
+    <xsl:function name="local:form-values" as="map(xs:string, xs:string?)">
+        <xsl:param name="form" as="element()"/>
+
+        <xsl:map>
+            <xsl:map-entry key="'property'" select="local:typeahead-value($form, 'property')"/>
+            <xsl:map-entry key="'typeof'" select="local:typeahead-value($form, 'typeof')"/>
+            <xsl:map-entry key="'subject'" select="local:input-value($form, 'subject')[. ne '']"/>
+            <xsl:map-entry key="'object'" select="local:input-value($form, 'object')[. ne '']"/>
+            <xsl:map-entry key="'value'" select="local:input-value($form, 'value')[. ne '']"/>
+            <xsl:map-entry key="'datatype'" select="local:select-or-custom($form, 'datatype', 'custom-datatype')"/>
+            <xsl:map-entry key="'lang'" select="local:input-value($form, 'lang')[. ne '']"/>
+        </xsl:map>
+    </xsl:function>
+
+    <!-- a select whose empty value defers to its free-text custom input -->
+    <xsl:function name="local:select-or-custom" as="xs:string?">
+        <xsl:param name="form" as="element()"/>
+        <xsl:param name="select-name" as="xs:string"/>
+        <xsl:param name="custom-name" as="xs:string"/>
+
+        <xsl:variable name="value" as="xs:string"
+            select="string(ixsl:get(($form//select[@name = $select-name])[1], 'value'))"/>
+        <xsl:sequence select="if ($value eq $local:custom)
+            then local:input-value($form, $custom-name)[. ne '']
+            else $value[. ne '']"/>
+    </xsl:function>
+
+    <!-- reset the form; when editing, pre-fill it from the annotated element.
+         $value prefills the object row: the selected text, or @content/text when editing -->
+    <xsl:template name="local:populate-form">
+        <xsl:param name="span" as="element()?" select="()"/>
+        <xsl:param name="value" as="xs:string?" select="()"/>
+
+        <xsl:for-each select="id('annotation-form', ixsl:page())">
+            <xsl:variable name="form" as="element()" select="."/>
+            <xsl:sequence select="ixsl:call(., 'reset', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:for-each select=".//input[@name = 'custom-datatype']">
+                <ixsl:set-style name="display" select="'none'"/>
+            </xsl:for-each>
+            <!-- the typeahead widgets are not native controls, so form.reset() leaves
+                 them as they were: reset both explicitly (empty in create mode, the
+                 committed button in edit mode) -->
+            <xsl:call-template name="local:typeahead-set-value">
+                <xsl:with-param name="form" select="$form"/>
+                <xsl:with-param name="field" select="'property'"/>
+                <xsl:with-param name="iri" select="string($span/@property)"/>
+            </xsl:call-template>
+            <xsl:call-template name="local:typeahead-set-value">
+                <xsl:with-param name="form" select="$form"/>
+                <xsl:with-param name="field" select="'typeof'"/>
+                <xsl:with-param name="iri" select="string($span/@typeof)"/>
+            </xsl:call-template>
+            <xsl:for-each select=".//button[tokenize(@class) = 'remove-action']">
+                <ixsl:set-style name="display" select="if (exists($span)) then 'inline-block' else 'none'"/>
+            </xsl:for-each>
+            <xsl:for-each select=".//input[@name = 'value']">
+                <ixsl:set-property name="value" select="($value, '')[1]" object="."/>
+            </xsl:for-each>
+            <!-- disclose the advanced fields when the annotation carries any of them -->
+            <xsl:for-each select="id('advanced-fields', ixsl:page())">
+                <ixsl:set-property name="open"
+                    select="exists($span/(@about | @resource | @typeof | @datatype | @lang | @xml:lang))" object="."/>
+            </xsl:for-each>
+            <!-- datatype and language are mutually exclusive (datatype wins): a datatype
+                 on the edited annotation disables the language input -->
+            <xsl:for-each select=".//input[@name = 'lang']">
+                <ixsl:set-property name="disabled" select="exists($span/@datatype)" object="."/>
+            </xsl:for-each>
+
+            <xsl:for-each select="$span">
+                <xsl:for-each select="$form//input[@name = 'subject']">
+                    <ixsl:set-property name="value" select="string($span/@about)" object="."/>
+                </xsl:for-each>
+                <xsl:for-each select="$form//input[@name = 'object']">
+                    <ixsl:set-property name="value" select="string($span/@resource)" object="."/>
+                </xsl:for-each>
+                <xsl:for-each select="@datatype">
+                    <xsl:call-template name="local:set-select-or-custom">
+                        <xsl:with-param name="form" select="$form"/>
+                        <xsl:with-param name="select-name" select="'datatype'"/>
+                        <xsl:with-param name="custom-name" select="'custom-datatype'"/>
+                        <xsl:with-param name="value" select="string(.)"/>
+                    </xsl:call-template>
+                </xsl:for-each>
+                <xsl:for-each select="$form//input[@name = 'lang']">
+                    <ixsl:set-property name="value" select="string(($span/@lang, $span/@xml:lang)[1])" object="."/>
+                </xsl:for-each>
+            </xsl:for-each>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- set a select's value via the live property; an IRI absent from the options
+         leaves the select empty, so route it to the custom input instead -->
+    <xsl:template name="local:set-select-or-custom">
+        <xsl:param name="form" as="element()"/>
+        <xsl:param name="select-name" as="xs:string"/>
+        <xsl:param name="custom-name" as="xs:string"/>
+        <xsl:param name="value" as="xs:string"/>
+
+        <xsl:for-each select="($form//select[@name = $select-name])[1]">
+            <ixsl:set-property name="value" select="$value" object="."/>
+            <xsl:if test="string(ixsl:get(., 'value')) ne $value">
+                <ixsl:set-property name="value" select="$local:custom" object="."/>
+                <xsl:for-each select="($form//input[@name = $custom-name])[1]">
+                    <ixsl:set-property name="value" select="$value" object="."/>
+                    <ixsl:set-style name="display" select="'block'"/>
+                </xsl:for-each>
+            </xsl:if>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- show an element at the event position, clamped to the viewport with 10px
+         padding. Positioned absolutely in page coordinates (client + scroll offset)
+         so it scrolls with the content -->
+    <xsl:template name="local:show-at">
+        <xsl:param name="element" as="element()"/>
+        <xsl:param name="event"/>
+
+        <xsl:call-template name="local:show-at-point">
+            <xsl:with-param name="element" select="$element"/>
+            <xsl:with-param name="x" select="ixsl:get($event, 'clientX')"/>
+            <xsl:with-param name="y" select="ixsl:get($event, 'clientY')"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- the positioning core: shared by mouse-driven dialogs (local:show-at) and the
+         caret-anchored popups (slash menu) which have no mouse event -->
+    <xsl:template name="local:show-at-point">
+        <xsl:param name="element" as="element()"/>
+        <xsl:param name="x" as="xs:double"/>
+        <xsl:param name="y" as="xs:double"/>
+
+        <xsl:for-each select="$element">
+            <ixsl:set-style name="display" select="'block'"/>
+            <ixsl:set-style name="position" select="'absolute'"/>
+
+            <xsl:variable name="client-x" as="xs:double" select="$x"/>
+            <xsl:variable name="client-y" as="xs:double" select="$y"/>
+            <xsl:variable name="scroll-x" as="xs:double" select="ixsl:get(ixsl:window(), 'scrollX')"/>
+            <xsl:variable name="scroll-y" as="xs:double" select="ixsl:get(ixsl:window(), 'scrollY')"/>
+            <xsl:variable name="viewport-width" as="xs:double" select="ixsl:get(ixsl:window(), 'innerWidth')"/>
+            <xsl:variable name="viewport-height" as="xs:double" select="ixsl:get(ixsl:window(), 'innerHeight')"/>
+            <xsl:variable name="width" as="xs:double" select="ixsl:get(., 'offsetWidth')"/>
+            <xsl:variable name="height" as="xs:double" select="ixsl:get(., 'offsetHeight')"/>
+
+            <ixsl:set-style name="left" select="((if ($client-x + $width + 10 gt $viewport-width)
+                then max(($viewport-width - $width - 10, 10)) else $client-x) + $scroll-x) || 'px'"/>
+            <ixsl:set-style name="top" select="((if ($client-y + $height + 10 gt $viewport-height)
+                then max(($viewport-height - $height - 10, 10)) else $client-y) + $scroll-y) || 'px'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="local:show-overlay">
+        <xsl:param name="event"/>
+        <xsl:param name="in-scope-subject" as="xs:string?" select="()"/>
+
+        <xsl:call-template name="local:show-at">
+            <xsl:with-param name="element" select="id('overlay', ixsl:page())"/>
+            <xsl:with-param name="event" select="$event"/>
+        </xsl:call-template>
+
+        <xsl:for-each select="id('stmt-subject', ixsl:page())">
+            <ixsl:set-attribute name="data-inherited-subject" select="($in-scope-subject, '')[1]"/>
+            <ixsl:set-property name="textContent" select="($in-scope-subject, '')[1]" object="."/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- the browser drops the visible selection once focus moves into the overlay
+         form: paint the stored range's client rects as pointer-transparent hint
+         boxes (no content mutation), cleared on hide -->
+    <xsl:template name="local:show-selection-hint">
+        <xsl:param name="range"/>
+
+        <xsl:variable name="scroll-x" as="xs:double" select="ixsl:get(ixsl:window(), 'scrollX')"/>
+        <xsl:variable name="scroll-y" as="xs:double" select="ixsl:get(ixsl:window(), 'scrollY')"/>
+        <!-- getClientRects returns a DOMRectList; Array.from marshals it to a sequence -->
+        <xsl:for-each select="ixsl:call(ixsl:get(ixsl:window(), 'Array'), 'from',
+                [ ixsl:call($range, 'getClientRects', []) ])"><!-- -->
+            <xsl:variable name="rect" select="."/>
+            <xsl:for-each select="ixsl:page()//body">
+                <xsl:result-document href="?." method="ixsl:append-content">
+                    <div class="rdfa-editor-selection-hint" style="left: {ixsl:get($rect, 'left') + $scroll-x}px;
+                        top: {ixsl:get($rect, 'top') + $scroll-y}px; width: {ixsl:get($rect, 'width')}px;
+                        height: {ixsl:get($rect, 'height')}px;"/>
+                </xsl:result-document>
+            </xsl:for-each>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="local:hide-selection-hint">
+        <xsl:for-each select="ixsl:page()//body/div[contains-token(@class, 'rdfa-editor-selection-hint')]">
+            <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- single teardown point: hiding the overlay always clears the interaction state -->
+    <xsl:template name="local:hide-overlay">
+        <xsl:call-template name="local:hide-selection-hint"/>
+        <xsl:for-each select="id('overlay', ixsl:page())">
+            <ixsl:set-style name="display" select="'none'"/>
+        </xsl:for-each>
+        <ixsl:set-property name="editingSpan" select="()" object="local:editor-state()"/>
+        <ixsl:set-property name="range" select="()" object="local:editor-state()"/>
+        <!-- return focus to the content -->
+        <xsl:for-each select="ixsl:get(local:editor-state(), 'activeBlock')[exists(local:block-of(.))]">
+            <xsl:call-template name="local:focus">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="div[@id = 'overlay']" mode="ixsl:onkeydown">
+        <xsl:if test="string(ixsl:get(ixsl:event(), 'key')) = 'Escape'">
+            <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:hide-overlay"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- a subject override is reflected in the statement's S row -->
+    <xsl:template match="input[@name = 'subject']" mode="ixsl:onchange">
+        <xsl:variable name="value" as="xs:string" select="string(ixsl:get(., 'value'))"/>
+        <xsl:for-each select="id('stmt-subject', ixsl:page())">
+            <ixsl:set-property name="textContent"
+                select="($value[. ne ''], string(@data-inherited-subject))[1]" object="."/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- the datatype select's 'Custom' option reveals the free-text IRI input;
+         a chosen datatype wins over language, disabling the language input -->
+    <xsl:template match="select[@name = 'datatype']" mode="ixsl:onchange">
+        <xsl:variable name="value" as="xs:string" select="string(ixsl:get(., 'value'))"/>
+        <xsl:variable name="custom" as="xs:boolean" select="$value eq $local:custom"/>
+        <xsl:for-each select="ancestor::form//input[@name = 'custom-datatype']">
+            <ixsl:set-style name="display" select="if ($custom) then 'block' else 'none'"/>
+            <xsl:if test="$custom">
+                <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:if>
+        </xsl:for-each>
+        <xsl:for-each select="ancestor::form//input[@name = 'lang']">
+            <ixsl:set-property name="disabled" select="$value ne ''" object="."/>
+        </xsl:for-each>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/select.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/select.xsl
new file mode 100644
index 000000000..688c63e69
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/select.xsl
@@ -0,0 +1,777 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+xmlns:cm="urn:rdfa-editor:content-model"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    Cross-host selection: the gestures that create selections spanning editable
+    hosts (Google-Docs model), select-all scoped to the editable region and
+    deletion of selections that span editable hosts.
+
+    Each block is its own contenteditable host, so the browser confines a
+    native drag-selection to the host it starts in - it never crosses a host
+    boundary (even a drag from the page background clamps on the first host it
+    enters) and it refuses to edit a document-level selection that spans hosts.
+    Docs-style selection is therefore synthesized: mousedown in a region arms a
+    sweep anchor (caretRangeFromPoint); once the pointer leaves the anchor
+    host, each mousemove rebuilds the selection anchor-to-pointer with
+    setBaseAndExtent - the only Selection API that can express a backward
+    selection, so dragging upward keeps the anchor fixed like Docs; mouseup
+    disarms. Shift+Click extends from the standing anchor to the clicked point
+    and re-arms it, so Shift+drag keeps extending; Shift+Up/Down extend the
+    focus block-granularly past host edges (within a host they stay native).
+    Every gesture clamps to one region. The result is a plain document-level
+    selection: it paints natively across blocks, and one delete machine serves
+    Ctrl/Cmd+A stage 2 and every synthetic gesture alike. Keyboard dispatch
+    lives in edit.xsl (keydown, body keydown, paste gate); the machinery and
+    the mouse gesture templates live here, mirroring the tables.xsl split.
+
+    Deletion is block-granular, never one raw deleteContents across the range:
+    fully covered blocks are removed whole, partial edge hosts get a
+    sub-range delete scoped inside the host, and composites (table, figure)
+    holding a range boundary never lose grid structure - their covered cells
+    are cleared instead (B3/B4 doctrine: composites are hard boundaries).
+    Non-composite edge remnants merge Google-Docs-style (the tail joins the
+    head, caret at the seam). One gesture pushes one region-keyed undo entry.
+-->
+
+    <!-- ................................ predicates ................................ -->
+
+    <!-- the host's content is entirely inside the selection (chrome- and
+         placeholder-insensitive via the local:at-* probes); an empty host counts
+         as fully selected, so Ctrl+A escalates immediately where stage 1 would
+         have nothing to select -->
+    <xsl:function name="local:host-fully-selected" as="xs:boolean">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="range"/>
+        <xsl:sequence select="local:block-text($host) = ''
+            or (not(ixsl:get($range, 'collapsed'))
+                and local:at-start($host, $range) and local:at-end($host, $range))"/>
+    </xsl:function>
+
+    <!-- true for a non-collapsed selection that engages an editable region but is
+         not confined to a single host: the boundary hosts differ, or a boundary
+         sits outside any host (region level, page background). Host-page
+         contenteditables don't count (the local:block-of clamp), and selections
+         that never touch a region stay native -->
+    <xsl:function name="local:selection-crosses-hosts" as="xs:boolean">
+        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:choose>
+            <xsl:when test="empty($range) or ixsl:get($range, 'collapsed')">
+                <xsl:sequence select="false()"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="start-host" as="element()?"
+                    select="local:host-of(ixsl:get($range, 'startContainer'))[exists(local:block-of(.))]"/>
+                <xsl:variable name="end-host" as="element()?"
+                    select="local:host-of(ixsl:get($range, 'endContainer'))[exists(local:block-of(.))]"/>
+                <xsl:sequence select="(empty($start-host) or empty($end-host) or not($start-host is $end-host))
+                    and (some $root in local:roots() satisfies ixsl:call($range, 'intersectsNode', [ $root ]))"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- the node lies entirely inside the range: it intersects it and neither
+         range boundary sits at or below the node (an offset in a parent points
+         between children, so a boundary inside the node means its container is
+         in the node's subtree - pure XDM containment, no compareBoundaryPoints) -->
+    <xsl:function name="local:covered-by" as="xs:boolean">
+        <xsl:param name="node" as="node()"/>
+        <xsl:param name="range"/>
+        <xsl:sequence select="ixsl:call($range, 'intersectsNode', [ $node ])
+            and empty(ixsl:get($range, 'startContainer')/ancestor-or-self::node()
+                intersect $node/descendant-or-self::node())
+            and empty(ixsl:get($range, 'endContainer')/ancestor-or-self::node()
+                intersect $node/descendant-or-self::node())"/>
+    </xsl:function>
+
+    <!-- ................................ region select ................................ -->
+
+    <!-- a document-level range over all of the region's blocks: it paints across
+         host boundaries and never extends beyond the region. Focus stays where it
+         was, so the same keydown template keeps firing -->
+    <xsl:template name="local:select-region">
+        <xsl:param name="region" as="element()"/>
+        <xsl:variable name="blocks" as="element()*" select="$region/*[not(@data-role)]"/>
+        <xsl:if test="exists($blocks)">
+            <xsl:variable name="range" select="ixsl:call(ixsl:page(), 'createRange', [])"/>
+            <xsl:sequence select="ixsl:call($range, 'setStartBefore', [ $blocks[1] ])[current-date() lt xs:date('2000-01-01')],
+                ixsl:call($range, 'setEndAfter', [ $blocks[last()] ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:variable name="selection" select="local:selection()"/>
+            <xsl:sequence select="ixsl:call($selection, 'removeAllRanges', [])[current-date() lt xs:date('2000-01-01')],
+                ixsl:call($selection, 'addRange', [ $range ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- a clone of $range clamped to $region: boundaries outside the region (page
+         content, another region) move to the region's extremes, and a boundary
+         inside chrome moves out of the ephemeral subtree (the handle is not
+         content). Shared by the delete machine and canonical copy -->
+    <xsl:function name="local:clamped-range" as="item()">
+        <xsl:param name="range"/>
+        <xsl:param name="region" as="element()"/>
+        <xsl:variable name="all" as="element()*" select="$region/*[not(@data-role)]"/>
+        <xsl:variable name="work" select="ixsl:call($range, 'cloneRange', [])"/>
+        <xsl:if test="not(local:root-of(ixsl:get($work, 'startContainer')) is $region)">
+            <xsl:sequence select="ixsl:call($work, 'setStartBefore', [ $all[1] ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+        <xsl:if test="not(local:root-of(ixsl:get($work, 'endContainer')) is $region)">
+            <xsl:sequence select="ixsl:call($work, 'setEndAfter', [ $all[last()] ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:if>
+        <xsl:for-each select="(ixsl:get($work, 'startContainer')/ancestor-or-self::*[@data-role])[1]">
+            <xsl:sequence select="ixsl:call($work, 'setStartAfter', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:for-each select="(ixsl:get($work, 'endContainer')/ancestor-or-self::*[@data-role])[1]">
+            <xsl:sequence select="ixsl:call($work, 'setEndBefore', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <!-- a boundary inside an object-block island moves out of it (after the
+             chrome escape - the rendering div is chrome inside the island):
+             islands join a selection whole, so the delete machine and canonical
+             copy never see a boundary inside one -->
+        <xsl:for-each select="(ixsl:get($work, 'startContainer')/ancestor-or-self::*[local:island(.)])[1]">
+            <xsl:sequence select="ixsl:call($work, 'setStartBefore', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:for-each select="(ixsl:get($work, 'endContainer')/ancestor-or-self::*[local:island(.)])[1]">
+            <xsl:sequence select="ixsl:call($work, 'setEndAfter', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:sequence select="$work"/>
+    </xsl:function>
+
+    <!-- ................................ selection gestures ................................ -->
+
+    <!-- the document position under a viewport point, as map{'node','offset'}:
+         caretRangeFromPoint (Chromium, Safari) or caretPositionFromPoint
+         (Firefox). A position inside chrome moves out of the ephemeral subtree
+         to just after it (mirroring local:clamped-range); empty when the point
+         resolves to nothing -->
+    <xsl:function name="local:caret-at-point" as="map(*)?">
+        <xsl:param name="x" as="xs:double"/>
+        <xsl:param name="y" as="xs:double"/>
+        <xsl:variable name="raw" as="map(*)?">
+            <xsl:choose>
+                <xsl:when test="exists(ixsl:get(ixsl:page(), 'caretRangeFromPoint'))">
+                    <xsl:for-each select="ixsl:call(ixsl:page(), 'caretRangeFromPoint', [ $x, $y ])">
+                        <xsl:sequence select="map{
+                            'node': ixsl:get(., 'startContainer'),
+                            'offset': xs:integer(ixsl:get(., 'startOffset')) }"/>
+                    </xsl:for-each>
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:for-each select="ixsl:call(ixsl:page(), 'caretPositionFromPoint', [ $x, $y ])">
+                        <xsl:sequence select="map{
+                            'node': ixsl:get(., 'offsetNode'),
+                            'offset': xs:integer(ixsl:get(., 'offset')) }"/>
+                    </xsl:for-each>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:variable>
+        <!-- one ancestor walk serves both probes: this runs per mousemove during a sweep -->
+        <xsl:variable name="ancestors" as="element()*" select="$raw?node/ancestor-or-self::*"/>
+        <xsl:variable name="island" as="element()?" select="($ancestors[local:island(.)])[1]"/>
+        <xsl:variable name="chrome" as="element()?" select="($ancestors[@data-role])[1]"/>
+        <xsl:choose>
+            <!-- a point inside an object-block island (its rendering or its RDFa
+                 spans) escapes to just after the island: sweep anchors never sit
+                 inside islands - checked first, the rendering div is chrome
+                 inside the island -->
+            <xsl:when test="exists($island)">
+                <xsl:sequence select="map{
+                    'node': $island/parent::node(),
+                    'offset': count($island/preceding-sibling::node()) + 1 }"/>
+            </xsl:when>
+            <xsl:when test="exists($chrome)">
+                <xsl:sequence select="map{
+                    'node': $chrome/parent::node(),
+                    'offset': count($chrome/preceding-sibling::node()) + 1 }"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:sequence select="$raw"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- a selection focus clamped into $region: a position outside it (page
+         content, another region) becomes the region extreme on that side -
+         one gesture, one region -->
+    <xsl:function name="local:clamp-focus-to-region" as="map(*)">
+        <xsl:param name="node"/>
+        <xsl:param name="offset" as="xs:integer"/>
+        <xsl:param name="region" as="element()"/>
+        <xsl:choose>
+            <xsl:when test="local:root-of($node) is $region">
+                <xsl:sequence select="map{ 'node': $node, 'offset': $offset }"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="probe" select="ixsl:call(ixsl:page(), 'createRange', [])"/>
+                <xsl:sequence select="ixsl:call($probe, 'selectNodeContents', [ $region ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:variable name="cmp" as="xs:integer" select="xs:integer(ixsl:call($probe, 'comparePoint', [ $node, $offset ]))"/>
+                <xsl:choose>
+                    <xsl:when test="$cmp lt 0">
+                        <xsl:sequence select="map{ 'node': $region,
+                            'offset': count($region/*[not(@data-role)][1]/preceding-sibling::node()) }"/>
+                    </xsl:when>
+                    <xsl:when test="$cmp gt 0">
+                        <xsl:sequence select="map{ 'node': $region, 'offset': count($region/node()) }"/>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:sequence select="map{ 'node': $node, 'offset': $offset }"/>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- move the selection focus, anchor fixed: setBaseAndExtent is the only
+         Selection API that can express a backward selection (focus before
+         anchor), which an upward drag or Shift+Click produces -->
+    <xsl:template name="local:extend-selection-to">
+        <xsl:param name="anchor-node"/>
+        <xsl:param name="anchor-offset" as="xs:integer"/>
+        <xsl:param name="focus" as="map(*)"/>
+        <xsl:sequence select="ixsl:call(local:selection(), 'setBaseAndExtent',
+            [ $anchor-node, $anchor-offset, $focus?node, $focus?offset ])[current-date() lt xs:date('2000-01-01')]"/>
+    </xsl:template>
+
+    <xsl:template name="local:disarm-sweep">
+        <xsl:for-each select="('sweepAnchorNode', 'sweepAnchorHost', 'sweepRegion')">
+            <ixsl:set-property name="{.}" select="()" object="local:editor-state()"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- mousedown in a region: Shift extends the standing selection to the
+         clicked point (the anchor never moves - preventDefault stops the
+         native caret placement that would collapse it), a plain primary press
+         arms a sweep anchor for the mousemove takeover (no preventDefault:
+         native caret placement and in-host drags proceed untouched). SaxonJS
+         dispatches an event at the innermost matching template only, so a
+         press on the drag handle never reaches this (the handle owns its
+         gesture) and chrome is guarded out explicitly -->
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]" mode="ixsl:onmousedown">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="region" as="element()" select="."/>
+        <xsl:variable name="target" as="node()?" select="ixsl:get($event, 'target')"/>
+        <xsl:variable name="button" as="xs:double" select="number(ixsl:get($event, 'button'))"/>
+        <xsl:if test="$button = 0 and empty($target/ancestor-or-self::*[@data-role])">
+            <xsl:variable name="anchor-node" as="node()?" select="local:anchor-node()"/>
+            <xsl:variable name="point" as="map(*)?" select="local:caret-at-point(
+                xs:double(ixsl:get($event, 'clientX')), xs:double(ixsl:get($event, 'clientY')))"/>
+            <xsl:choose>
+                <!-- an anchor outside any region is the host page's - never hijacked -->
+                <xsl:when test="ixsl:get($event, 'shiftKey') = true()
+                        and exists(local:root-of($anchor-node)) and exists($point)">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:variable name="anchor-offset" as="xs:integer" select="local:anchor-offset()"/>
+                    <xsl:call-template name="local:extend-selection-to">
+                        <xsl:with-param name="anchor-node" select="$anchor-node"/>
+                        <xsl:with-param name="anchor-offset" select="$anchor-offset"/>
+                        <xsl:with-param name="focus" select="local:clamp-focus-to-region(
+                            $point?node, $point?offset, local:root-of($anchor-node))"/>
+                    </xsl:call-template>
+                    <!-- re-arm from the same anchor so Shift+drag keeps extending; the
+                         preventDefault killed the native drag session, so every move
+                         must be synthetic (no anchor host) -->
+                    <ixsl:set-property name="sweepAnchorNode" select="$anchor-node" object="local:editor-state()"/>
+                    <ixsl:set-property name="sweepAnchorOffset" select="$anchor-offset" object="local:editor-state()"/>
+                    <ixsl:set-property name="sweepAnchorHost" select="()" object="local:editor-state()"/>
+                    <ixsl:set-property name="sweepRegion" select="local:root-of($anchor-node)" object="local:editor-state()"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:for-each select="$point">
+                        <ixsl:set-property name="sweepAnchorNode" select="?node" object="local:editor-state()"/>
+                        <ixsl:set-property name="sweepAnchorOffset" select="?offset" object="local:editor-state()"/>
+                        <ixsl:set-property name="sweepAnchorHost"
+                            select="local:host-of(?node)[exists(local:block-of(.))]" object="local:editor-state()"/>
+                        <ixsl:set-property name="sweepRegion" select="$region" object="local:editor-state()"/>
+                    </xsl:for-each>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- the sweep takeover: while a sweep is armed and the primary button is
+         held, a pointer outside the anchor host rebuilds the selection from
+         the stored anchor to the point under the pointer - the native
+         drag-selection cannot cross host boundaries, so beyond them the
+         selection is ours; inside the anchor host the native one is correct
+         and untouched. The codebase's only mousemove template: the armed
+         check comes first, one property read on the idle path. html catches
+         moves over the body's margins -->
+    <xsl:template match="body | html" mode="ixsl:onmousemove">
+        <xsl:variable name="anchor-node" select="ixsl:get(local:editor-state(), 'sweepAnchorNode')"/>
+        <xsl:if test="exists($anchor-node)">
+            <xsl:variable name="event" select="ixsl:event()"/>
+            <xsl:choose>
+                <!-- button released outside the window: the mouseup never fired -->
+                <xsl:when test="number(ixsl:get($event, 'buttons')) ne 1">
+                    <xsl:call-template name="local:disarm-sweep"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:variable name="anchor-host" as="element()?" select="ixsl:get(local:editor-state(), 'sweepAnchorHost')"/>
+                    <xsl:variable name="target" as="node()?" select="ixsl:get($event, 'target')"/>
+                    <xsl:if test="empty($anchor-host) or empty($target/ancestor-or-self::* intersect $anchor-host)">
+                        <xsl:variable name="y" as="xs:double" select="xs:double(ixsl:get($event, 'clientY'))"/>
+                        <xsl:variable name="point" as="map(*)?" select="local:caret-at-point(
+                            xs:double(ixsl:get($event, 'clientX')), $y)"/>
+                        <!-- a point over floating editor UI does not move the focus -->
+                        <xsl:if test="exists($point) and empty($point?node/ancestor-or-self::*[contains-token(@class, 'rdfa-editor-ui')])">
+                            <xsl:for-each select="ixsl:get(local:editor-state(), 'sweepRegion')">
+                                <xsl:call-template name="local:extend-selection-to">
+                                    <xsl:with-param name="anchor-node" select="$anchor-node"/>
+                                    <xsl:with-param name="anchor-offset"
+                                        select="xs:integer(ixsl:get(local:editor-state(), 'sweepAnchorOffset'))"/>
+                                    <xsl:with-param name="focus"
+                                        select="local:clamp-focus-to-region($point?node, $point?offset, .)"/>
+                                </xsl:call-template>
+                            </xsl:for-each>
+                        </xsl:if>
+                        <!-- native autoscroll died with the takeover: nudge the viewport
+                             near its edges (advances only while the pointer moves) -->
+                        <xsl:if test="$y lt 40">
+                            <xsl:sequence select="ixsl:call(ixsl:window(), 'scrollBy', [ 0, -16 ])[current-date() lt xs:date('2000-01-01')]"/>
+                        </xsl:if>
+                        <xsl:if test="$y gt xs:double(ixsl:get(ixsl:window(), 'innerHeight')) - 40">
+                            <xsl:sequence select="ixsl:call(ixsl:window(), 'scrollBy', [ 0, 16 ])[current-date() lt xs:date('2000-01-01')]"/>
+                        </xsl:if>
+                    </xsl:if>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- a sweep ending over the page background (the host and drag-handle
+         mouseup templates disarm on their own paths - innermost-match
+         dispatch means only one of them sees the event) -->
+    <xsl:template match="body | html" mode="ixsl:onmouseup">
+        <xsl:if test="exists(ixsl:get(local:editor-state(), 'sweepAnchorNode'))">
+            <xsl:call-template name="local:disarm-sweep"/>
+            <!-- no host mouseup fires out here: sync the breadcrumb ourselves -->
+            <xsl:if test="local:selection-crosses-hosts()">
+                <xsl:call-template name="local:update-breadcrumb"/>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- Shift+Up/Down handling gate: a cross-host selection cannot be extended
+         natively at all, and a within-host focus at the host's edge facing the
+         arrow is where native extension clamps - both are ours; anywhere else
+         native line-wise extension is right. Probes run from the FOCUS: the
+         range end is not the focus in a backward selection -->
+    <xsl:function name="local:shift-arrow-extends" as="xs:boolean">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="direction" as="xs:string"/>
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:choose>
+            <xsl:when test="local:selection-crosses-hosts()">
+                <xsl:sequence select="true()"/>
+            </xsl:when>
+            <xsl:when test="ixsl:get($selection, 'rangeCount') lt 1">
+                <xsl:sequence select="false()"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="focus-node" select="ixsl:get($selection, 'focusNode')"/>
+                <xsl:variable name="focus-offset" as="xs:integer" select="xs:integer(ixsl:get($selection, 'focusOffset'))"/>
+                <xsl:choose>
+                    <xsl:when test="empty($focus-node/ancestor-or-self::* intersect $host)">
+                        <xsl:sequence select="false()"/>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:variable name="probe" select="ixsl:call(ixsl:page(), 'createRange', [])"/>
+                        <xsl:choose>
+                            <xsl:when test="$direction = 'down'">
+                                <xsl:sequence select="ixsl:call($probe, 'setStart', [ $focus-node, $focus-offset ])[current-date() lt xs:date('2000-01-01')],
+                                    ixsl:call($probe, 'setEnd', [ $host, xs:integer(ixsl:get($host, 'childNodes.length')) ])[current-date() lt xs:date('2000-01-01')]"/>
+                            </xsl:when>
+                            <xsl:otherwise>
+                                <xsl:sequence select="ixsl:call($probe, 'setStart', [ $host, local:chrome-count($host) ])[current-date() lt xs:date('2000-01-01')],
+                                    ixsl:call($probe, 'setEnd', [ $focus-node, $focus-offset ])[current-date() lt xs:date('2000-01-01')]"/>
+                            </xsl:otherwise>
+                        </xsl:choose>
+                        <xsl:sequence select="string(ixsl:call($probe, 'toString', [])) = ''"/>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- block-granular focus stepping for Shift+Up/Down: the anchor stays, the
+         focus moves between region-level positions - whole top-level blocks
+         enter or leave the selection, composites always as one unit. From
+         inside a block the first step lands just past (before) it; stepping
+         across the anchor flips the selection direction; the extremes are
+         no-ops -->
+    <xsl:template name="local:extend-selection-block-wise">
+        <xsl:param name="direction" as="xs:string"/>
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
+            <xsl:variable name="focus-node" select="ixsl:get($selection, 'focusNode')"/>
+            <xsl:variable name="focus-offset" as="xs:integer" select="xs:integer(ixsl:get($selection, 'focusOffset'))"/>
+            <xsl:for-each select="local:root-of($focus-node)">
+                <xsl:variable name="region" as="element()" select="."/>
+                <xsl:variable name="blocks" as="element()*" select="*[not(@data-role)]"/>
+                <xsl:variable name="focus-block" as="element()?" select="local:block-of($focus-node)"/>
+                <!-- the focus as a region-level coordinate: inside a block it
+                     counts as just inside the edge facing the step -->
+                <xsl:variable name="current" as="xs:integer" select="
+                    if (exists($focus-block))
+                    then count($focus-block/preceding-sibling::node()) + (if ($direction = 'up') then 1 else 0)
+                    else $focus-offset"/>
+                <xsl:variable name="target-block" as="element()?" select="
+                    if ($direction = 'down')
+                    then $blocks[count(preceding-sibling::node()) + 1 gt $current][1]
+                    else $blocks[count(preceding-sibling::node()) lt $current][last()]"/>
+                <xsl:for-each select="$target-block">
+                    <xsl:call-template name="local:extend-selection-to">
+                        <xsl:with-param name="anchor-node" select="ixsl:get($selection, 'anchorNode')"/>
+                        <xsl:with-param name="anchor-offset" select="xs:integer(ixsl:get($selection, 'anchorOffset'))"/>
+                        <xsl:with-param name="focus" select="map{ 'node': $region,
+                            'offset': count(preceding-sibling::node()) + (if ($direction = 'down') then 1 else 0) }"/>
+                    </xsl:call-template>
+                    <xsl:sequence select="ixsl:call(., 'scrollIntoView',
+                        [ map{ 'block': 'nearest' } ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+            </xsl:for-each>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- ................................ canonical copy / cut ................................ -->
+
+    <!-- a cross-host selection is copied in its storage form: the editing DOM
+         (chrome, contenteditable, marker classes) would otherwise travel to the
+         clipboard's HTML flavor. The fragment runs the same canonical +
+         cm-normalize pipeline as paste, in reverse; RDFa attributes survive, so
+         annotated content round-trips between documents. Within-host copy stays
+         native. The union match covers both dispatch shapes: the focused host,
+         or body after a background-origin sweep -->
+    <xsl:template match="*[@contenteditable = 'true'] | body" mode="ixsl:oncopy">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:if test="local:selection-crosses-hosts()">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:copy-selection">
+                <xsl:with-param name="event" select="$event"/>
+            </xsl:call-template>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- cut = canonical copy + the delete machine (one region-keyed undo entry) -->
+    <xsl:template match="*[@contenteditable = 'true'] | body" mode="ixsl:oncut">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:if test="local:selection-crosses-hosts()">
+            <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:copy-selection">
+                <xsl:with-param name="event" select="$event"/>
+            </xsl:call-template>
+            <xsl:call-template name="local:delete-cross-host-selection"/>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="local:copy-selection">
+        <xsl:param name="event"/>
+        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:variable name="region" as="element()?"
+            select="(local:root-of(ixsl:get($range, 'startContainer')),
+                local:roots()[ixsl:call($range, 'intersectsNode', [ . ])])[1]"/>
+        <xsl:for-each select="$region[exists(*[not(@data-role)])]">
+            <xsl:variable name="work" select="local:clamped-range($range, .)"/>
+            <!-- cloneContents keeps partially-selected ancestors as shells, so the
+                 fragment stays block-shaped; the carrier div mirrors paste-html -->
+            <xsl:variable name="carrier" as="element()" select="local:element('div')"/>
+            <xsl:sequence select="ixsl:call($carrier, 'appendChild',
+                [ ixsl:call($work, 'cloneContents', []) ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:variable name="pass1">
+                <xsl:apply-templates select="$carrier/node()" mode="canonical"/>
+            </xsl:variable>
+            <xsl:variable name="clean">
+                <xsl:sequence select="cm:normalize($pass1/node())"/>
+            </xsl:variable>
+            <xsl:variable name="data" select="ixsl:get($event, 'clipboardData')"/>
+            <xsl:sequence select="ixsl:call($data, 'setData', [ 'text/html',
+                serialize($clean/node(), map{ 'method': 'html' }) ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="ixsl:call($data, 'setData', [ 'text/plain',
+                string-join($clean/node()[normalize-space()] ! normalize-space(.), '&#10;') ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- ................................ delete machine ................................ -->
+
+    <!-- delete a cross-host selection: reads and classification first, one undo
+         push, then the mutations in fixed order. Reached from the host and body
+         keydown dispatchers (edit.xsl) -->
+    <xsl:template name="local:delete-cross-host-selection">
+        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:if test="exists($range) and not(ixsl:get($range, 'collapsed'))">
+            <!-- the single region this gesture acts on: the start's region, else
+                 the first region the sweep reaches (one gesture = one region-keyed
+                 history entry; blocks never leave their region) -->
+            <xsl:variable name="region" as="element()?"
+                select="(local:root-of(ixsl:get($range, 'startContainer')),
+                    local:roots()[ixsl:call($range, 'intersectsNode', [ . ])])[1]"/>
+            <xsl:variable name="all" as="element()*" select="$region/*[not(@data-role)]"/>
+            <xsl:if test="exists($all)">
+                <xsl:variable name="work" select="local:clamped-range($range, $region)"/>
+                <xsl:variable name="blocks" as="element()*" select="$all[ixsl:call($work, 'intersectsNode', [ . ])]"/>
+                <xsl:if test="exists($blocks) and not(ixsl:get($work, 'collapsed'))">
+                    <!-- boundary hosts (a partial edge is an edge with a boundary
+                         host); clamped boundaries sit at region level - no host -->
+                    <xsl:variable name="start-host" as="element()?"
+                        select="local:host-of(ixsl:get($work, 'startContainer'))[local:root-of(.) is $region]"/>
+                    <xsl:variable name="end-host" as="element()?"
+                        select="local:host-of(ixsl:get($work, 'endContainer'))[local:root-of(.) is $region]"/>
+                    <!-- only the two edge blocks can be partially covered -->
+                    <xsl:variable name="head-block" as="element()?" select="$blocks[1][not(local:covered-by(., $work))]"/>
+                    <xsl:variable name="tail-block" as="element()?" select="$blocks[last()][not(local:covered-by(., $work))]"/>
+                    <xsl:variable name="partial-blocks" as="element()*" select="$head-block | $tail-block"/>
+                    <!-- composites holding a range boundary: their structure is
+                         never ripped (composites are hard boundaries - B3/B4) -->
+                    <xsl:variable name="partial-composites" as="element()*"
+                        select="$partial-blocks/descendant-or-self::*[self::table or self::figure]
+                            [ixsl:call($work, 'intersectsNode', [ . ])][not(local:covered-by(., $work))]"/>
+                    <!-- removals: covered blocks whole, plus the maximal covered
+                         fragments of the edge blocks - except grid parts of a
+                         boundary-holding composite (rows, cells, captions, the
+                         figure image), which survive with their content cleared -->
+                    <xsl:variable name="removals" as="element()*" select="
+                        $blocks[local:covered-by(., $work)]
+                        | $partial-blocks/descendant::*
+                            [not(ancestor-or-self::*[@data-role])]
+                            [not((self::tbody or self::thead or self::tfoot or self::tr
+                                or self::td or self::th or self::caption or self::figcaption or self::img)
+                                and exists(ancestor::*[self::table or self::figure]))]
+                            [local:covered-by(., $work)]
+                            [not(local:covered-by(.., $work))]"/>
+                    <!-- covered cells of a boundary-holding composite: cleared, kept -->
+                    <xsl:variable name="clears" as="element()*" select="
+                        $partial-blocks/descendant::*[self::td or self::th or self::caption or self::figcaption]
+                            [exists(ancestor::*[self::table or self::figure])]
+                            [local:covered-by(., $work)]
+                            [not(local:covered-by((ancestor::*[self::table or self::figure])[last()], $work))]"/>
+                    <!-- flow containers of the edge blocks touched by the range:
+                         after the removals they may have lost their last block
+                         (never an island - a div island must not become a text host) -->
+                    <xsl:variable name="collapse-candidates" as="element()*" select="
+                        $partial-blocks/descendant::*[cm:flow(local-name(.))][not(self::figure)]
+                            [not(local:island(.))]
+                            [not(@contenteditable = 'true')]
+                            [ixsl:call($work, 'intersectsNode', [ . ])]"/>
+                    <!-- caret fallbacks for a fully-covered sweep: the untouched
+                         neighbors of the swept range -->
+                    <xsl:variable name="next-block" as="element()?" select="$blocks[last()]/following-sibling::*[not(@data-role)][1]"/>
+                    <xsl:variable name="prev-block" as="element()?" select="$blocks[1]/preceding-sibling::*[not(@data-role)][1]"/>
+                    <!-- remnants merge (Google Docs) only between plain text hosts:
+                         never across a composite boundary, never with pre (B6) -->
+                    <xsl:variable name="merge" as="xs:boolean" select="exists($start-host) and exists($end-host)
+                        and not($start-host is $end-host)
+                        and empty($start-host/ancestor::* intersect $partial-composites)
+                        and empty($end-host/ancestor::* intersect $partial-composites)
+                        and empty(($start-host, $end-host)/self::pre)"/>
+                    <!-- sub-ranges for the partial edge hosts, cloned before any
+                         mutation (a range scoped to one host cannot escape it) -->
+                    <xsl:variable name="head-sub" select="if (exists($start-host)) then ixsl:call($work, 'cloneRange', []) else ()"/>
+                    <xsl:for-each select="$start-host">
+                        <xsl:sequence select="ixsl:call($head-sub, 'setEnd', [ ., xs:integer(ixsl:get(., 'childNodes.length')) ])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:for-each>
+                    <xsl:variable name="tail-sub" select="if (exists($end-host)) then ixsl:call($work, 'cloneRange', []) else ()"/>
+                    <xsl:for-each select="$end-host">
+                        <xsl:sequence select="ixsl:call($tail-sub, 'setStart', [ ., 0 ])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:for-each>
+
+                    <!-- mutate: one region-keyed history entry, snapshot first -->
+                    <xsl:call-template name="local:push-undo">
+                        <xsl:with-param name="root" select="$region"/>
+                    </xsl:call-template>
+                    <xsl:for-each select="$head-sub, $tail-sub">
+                        <xsl:sequence select="ixsl:call(., 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:for-each>
+                    <xsl:for-each select="$clears">
+                        <xsl:call-template name="local:clear-host">
+                            <xsl:with-param name="host" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                    <xsl:for-each select="$removals">
+                        <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    </xsl:for-each>
+                    <!-- the seam: the first text node of the tail remnant, captured
+                         before the merge moves it (the reference rides through the
+                         move and any container collapse - B4c) -->
+                    <xsl:variable name="seam-text" as="text()?"
+                        select="($end-host//text()[not(ancestor::*[@data-role])])[1]"/>
+                    <xsl:if test="$merge">
+                        <xsl:call-template name="local:merge-into-previous">
+                            <xsl:with-param name="host" select="$end-host"/>
+                            <xsl:with-param name="prev" select="$start-host"/>
+                        </xsl:call-template>
+                    </xsl:if>
+                    <!-- structural containers emptied by the deletion or the merge -->
+                    <xsl:for-each select="($head-block, $tail-block)[exists(local:root-of(.))]">
+                        <xsl:call-template name="local:prune-husks">
+                            <xsl:with-param name="scope" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                    <!-- flow containers that lost their last block revert to text hosts -->
+                    <xsl:for-each select="$collapse-candidates[exists(local:root-of(.))]">
+                        <xsl:call-template name="local:collapse-container">
+                            <xsl:with-param name="container" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                    <xsl:for-each select="($start-host, $end-host)[exists(local:root-of(.))][@contenteditable = 'true']">
+                        <xsl:call-template name="local:ensure-placeholder">
+                            <xsl:with-param name="host" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                    <!-- a boundary at a block's very edge can sweep the handle away:
+                         re-inject (idempotent, top-level only) -->
+                    <xsl:for-each select="$region/*[not(@data-role)]">
+                        <xsl:call-template name="local:inject-chrome">
+                            <xsl:with-param name="block" select="."/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                    <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                    <xsl:choose>
+                        <!-- everything went: reseed so the region can hold a caret -->
+                        <xsl:when test="empty($region/*[not(@data-role)])">
+                            <xsl:call-template name="local:seed-region">
+                                <xsl:with-param name="region" select="$region"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <xsl:when test="$merge and exists($seam-text) and exists(local:host-of($seam-text))">
+                            <xsl:call-template name="local:focus-caret">
+                                <xsl:with-param name="node" select="$seam-text"/>
+                                <xsl:with-param name="offset" select="0"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <xsl:when test="exists(local:last-host-in($head-block[exists(local:root-of(.))]))">
+                            <xsl:for-each select="local:last-host-in($head-block)">
+                                <xsl:call-template name="local:focus-caret">
+                                    <xsl:with-param name="node" select="."/>
+                                    <xsl:with-param name="offset"
+                                        select="count(node()) - count(node()[last()][self::br])"/>
+                                </xsl:call-template>
+                            </xsl:for-each>
+                        </xsl:when>
+                        <xsl:when test="exists(local:first-host-in($tail-block[exists(local:root-of(.))]))">
+                            <xsl:for-each select="local:first-host-in($tail-block)">
+                                <xsl:call-template name="local:focus-caret">
+                                    <xsl:with-param name="node" select="."/>
+                                    <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+                                </xsl:call-template>
+                            </xsl:for-each>
+                        </xsl:when>
+                        <xsl:when test="exists(local:first-host-in($next-block))">
+                            <xsl:for-each select="local:first-host-in($next-block)">
+                                <xsl:call-template name="local:focus-caret">
+                                    <xsl:with-param name="node" select="."/>
+                                    <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+                                </xsl:call-template>
+                            </xsl:for-each>
+                        </xsl:when>
+                        <!-- a neighboring island has no host to land in: select it -->
+                        <xsl:when test="local:island($next-block)">
+                            <xsl:call-template name="local:select-island">
+                                <xsl:with-param name="element" select="$next-block"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <xsl:when test="local:island($prev-block)">
+                            <xsl:call-template name="local:select-island">
+                                <xsl:with-param name="element" select="$prev-block"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <xsl:otherwise>
+                            <xsl:for-each select="local:last-host-in($prev-block)">
+                                <xsl:call-template name="local:focus-caret">
+                                    <xsl:with-param name="node" select="."/>
+                                    <xsl:with-param name="offset"
+                                        select="count(node()) - count(node()[last()][self::br])"/>
+                                </xsl:call-template>
+                            </xsl:for-each>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                    <xsl:call-template name="local:after-mutation"/>
+                </xsl:if>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- type-to-replace: after the delete machine has collapsed the caret into a
+         host, the typed character lands there - one gesture, one undo entry (the
+         machine's push; the insert rides the same snapshot) -->
+    <xsl:template name="local:insert-text-at-caret">
+        <xsl:param name="text" as="xs:string"/>
+        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:for-each select="$range[ixsl:get(., 'collapsed')]">
+            <xsl:for-each select="local:host-of(ixsl:get(., 'startContainer'))[exists(local:block-of(.))]">
+                <xsl:variable name="node" select="ixsl:call(ixsl:page(), 'createTextNode', [ $text ])"/>
+                <xsl:sequence select="ixsl:call($range, 'insertNode', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:call-template name="local:place-caret">
+                    <xsl:with-param name="node" select="$node"/>
+                    <xsl:with-param name="offset" select="string-length($text)"/>
+                </xsl:call-template>
+            </xsl:for-each>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- ................................ cleanup helpers ................................ -->
+
+    <!-- empty a covered cell keeping the grid: content out, then a flow cell
+         reverts to a text host (collapse handles editability and placeholder),
+         an inline-only host (caption) just gets its placeholder back -->
+    <xsl:template name="local:clear-host">
+        <xsl:param name="host" as="element()"/>
+        <xsl:for-each select="1 to xs:integer(ixsl:get($host, 'childNodes.length'))">
+            <xsl:sequence select="ixsl:call($host, 'removeChild', [ ixsl:get($host, 'firstChild') ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:choose>
+            <xsl:when test="cm:flow(local-name($host))">
+                <xsl:call-template name="local:collapse-container">
+                    <xsl:with-param name="container" select="$host"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:ensure-placeholder">
+                    <xsl:with-param name="host" select="$host"/>
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- remove structural containers emptied by a deletion (a list whose items
+         all went, a quote whose blocks all went), innermost first, re-probing
+         after each removal so emptiness cascades upward -->
+    <xsl:template name="local:prune-husks">
+        <xsl:param name="scope" as="element()"/>
+        <xsl:variable name="husk" as="element()?" select="($scope/descendant-or-self::*
+            [self::ul or self::ol or self::dl or self::blockquote]
+            [empty(*[not(@data-role)])][not(text()[normalize-space()])])[last()]"/>
+        <xsl:for-each select="$husk">
+            <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:if test="not(. is $scope)">
+                <xsl:call-template name="local:prune-husks">
+                    <xsl:with-param name="scope" select="$scope"/>
+                </xsl:call-template>
+            </xsl:if>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- an emptied region cannot hold a caret: seed a fresh paragraph host (the
+         empty-blockquote idiom with the region as explicit parent) -->
+    <xsl:template name="local:seed-region">
+        <xsl:param name="region" as="element()"/>
+        <xsl:variable name="p" as="element()" select="local:element('p')"/>
+        <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+        <ixsl:set-attribute name="contenteditable" select="'true'" object="$p"/>
+        <xsl:sequence select="ixsl:call($region, 'appendChild', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:inject-chrome">
+            <xsl:with-param name="block" select="$p"/>
+        </xsl:call-template>
+        <xsl:call-template name="local:focus-caret">
+            <xsl:with-param name="node" select="$p"/>
+            <xsl:with-param name="offset" select="local:chrome-count($p)"/>
+        </xsl:call-template>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/tables.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/tables.xsl
new file mode 100644
index 000000000..0d1063cf7
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/tables.xsl
@@ -0,0 +1,488 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    Tables as composite blocks: the table/thead/tbody/tr structure is locked,
+    td/th/caption are the editable hosts (like li and figcaption). Structure
+    changes go through explicit operations - the insert dialog and the
+    row/column toolbar buttons (enabled while the caret is in a table) - plus
+    Tab/Shift+Tab cell traversal and Enter stepping down a column, both growing
+    the table by a body row at its bottom edge.
+
+    Row/column operations address cells positionally, so they are disabled on
+    tables with colspan/rowspan (pasted content): positional edits would corrupt
+    a spanned grid. Such tables remain editable, draggable and annotatable.
+-->
+
+    <!-- ................................ helpers ................................ -->
+
+    <xsl:function name="local:cell-of" as="element()?">
+        <xsl:param name="node"/>
+        <xsl:sequence select="$node/ancestor-or-self::*[self::td or self::th][1]"/>
+    </xsl:function>
+
+    <!-- the cell the caret is in: selection first, then the last focused host -->
+    <xsl:function name="local:current-cell" as="element()?">
+        <xsl:sequence select="(local:anchor-node() ! local:cell-of(.),
+            ixsl:get(local:editor-state(), 'activeBlock') ! local:cell-of(.))[1][exists(local:block-of(.))]"/>
+    </xsl:function>
+
+    <xsl:function name="local:table-of" as="element()?">
+        <xsl:param name="node"/>
+        <xsl:sequence select="$node/ancestor-or-self::table[1]"/>
+    </xsl:function>
+
+    <!-- rows in visual order; tolerates bare table > tr (XHTML-parsed host pages) -->
+    <xsl:function name="local:table-rows" as="element()*">
+        <xsl:param name="table" as="element()?"/>
+        <xsl:sequence select="$table/(thead | tbody | tfoot)/tr | $table/tr"/>
+    </xsl:function>
+
+    <xsl:function name="local:table-cells" as="element()*">
+        <xsl:param name="table" as="element()?"/>
+        <xsl:sequence select="local:table-rows($table)/(td | th)"/>
+    </xsl:function>
+
+    <xsl:function name="local:column-index" as="xs:integer">
+        <xsl:param name="cell" as="element()"/>
+        <xsl:sequence select="count($cell/preceding-sibling::*[self::td or self::th]) + 1"/>
+    </xsl:function>
+
+    <xsl:function name="local:has-spans" as="xs:boolean">
+        <xsl:param name="table" as="element()?"/>
+        <xsl:sequence select="exists(local:table-cells($table)[@colspan or @rowspan])"/>
+    </xsl:function>
+
+    <!-- ................................ construction ................................ -->
+
+    <!-- a fresh editable cell with the <br> caret placeholder (dropped again by
+         canonical-xhtml.xsl); returned for the caller to place -->
+    <xsl:template name="local:make-cell">
+        <xsl:param name="name" as="xs:string"/>
+
+        <xsl:variable name="cell" as="element()" select="local:element($name)"/>
+        <ixsl:set-attribute name="contenteditable" select="'true'" object="$cell"/>
+        <xsl:sequence select="ixsl:call($cell, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:sequence select="$cell"/>
+    </xsl:template>
+
+    <xsl:template name="local:make-row">
+        <xsl:param name="cols" as="xs:integer"/>
+
+        <xsl:variable name="row" as="element()" select="local:element('tr')"/>
+        <xsl:for-each select="1 to $cols">
+            <xsl:variable name="cell" as="element()">
+                <xsl:call-template name="local:make-cell">
+                    <xsl:with-param name="name" select="'td'"/>
+                </xsl:call-template>
+            </xsl:variable>
+            <xsl:sequence select="ixsl:call($row, 'appendChild', [ $cell ])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+        <xsl:sequence select="$row"/>
+    </xsl:template>
+
+    <!-- a fresh all-td row next to $row, returned for caret placement; () on a
+         no-op. The header row is pinned first: "before" it does nothing,
+         "after" it lands at the top of the body -->
+    <xsl:template name="local:insert-row">
+        <xsl:param name="row" as="element()"/>
+        <xsl:param name="before" as="xs:boolean"/>
+
+        <xsl:variable name="anchor" as="element()?" select="
+            if ($row/parent::thead)
+            then (if ($before) then () else ($row/ancestor::table[1]/tbody)[1])
+            else $row"/>
+        <xsl:for-each select="$anchor">
+            <xsl:variable name="new" as="element()">
+                <xsl:call-template name="local:make-row">
+                    <xsl:with-param name="cols" select="count($row/(td | th))"/>
+                </xsl:call-template>
+            </xsl:variable>
+            <xsl:sequence select="ixsl:call(., if (self::tbody) then 'prepend'
+                else if ($before) then 'before' else 'after', [ $new ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="$new"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- ................................ insert dialog ................................ -->
+
+    <xsl:template name="local:render-table-dialog">
+        <div id="table-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
+                aria-label="Insert table" style="display: none;">
+            <label>Body rows</label>
+            <input type="number" name="rows" value="3" min="1" max="50"/>
+            <label>Columns</label>
+            <input type="number" name="cols" value="3" min="1" max="20"/>
+            <label class="checkbox-label"><input type="checkbox" name="header-row" checked="checked"/> Header row</label>
+            <label>Caption</label>
+            <input type="text" name="caption"/>
+            <div class="action-buttons">
+                <button type="button" class="btn-primary table-save">Insert</button>
+                <button type="button" class="btn-secondary table-cancel">Cancel</button>
+            </div>
+        </div>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'insert-table')]" mode="ixsl:onclick">
+        <ixsl:set-property name="insertHost"
+            select="local:current-host()[exists(local:block-of(.))]" object="local:editor-state()"/>
+        <xsl:variable name="dialog" as="element()" select="id('table-dialog', ixsl:page())"/>
+        <xsl:for-each select="($dialog//input[@name = 'rows'])[1], ($dialog//input[@name = 'cols'])[1]">
+            <ixsl:set-property name="value" select="'3'" object="."/>
+        </xsl:for-each>
+        <xsl:for-each select="($dialog//input[@name = 'caption'])[1]">
+            <ixsl:set-property name="value" select="''" object="."/>
+        </xsl:for-each>
+        <xsl:for-each select="($dialog//input[@name = 'header-row'])[1]">
+            <ixsl:set-property name="checked" select="true()" object="."/>
+        </xsl:for-each>
+        <xsl:call-template name="local:show-at">
+            <xsl:with-param name="element" select="$dialog"/>
+            <xsl:with-param name="event" select="ixsl:event()"/>
+        </xsl:call-template>
+        <xsl:for-each select="($dialog//input[@name = 'rows'])[1]">
+            <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'table-save')]" mode="ixsl:onclick">
+        <xsl:variable name="dialog" as="element()" select="ancestor::div[@id = 'table-dialog']"/>
+        <xsl:variable name="rows-raw" as="xs:string" select="local:input-value($dialog, 'rows')"/>
+        <xsl:variable name="cols-raw" as="xs:string" select="local:input-value($dialog, 'cols')"/>
+        <xsl:if test="$rows-raw castable as xs:integer and $cols-raw castable as xs:integer">
+            <xsl:variable name="rows" as="xs:integer" select="min((max((xs:integer($rows-raw), 1)), 50))"/>
+            <xsl:variable name="cols" as="xs:integer" select="min((max((xs:integer($cols-raw), 1)), 20))"/>
+            <xsl:variable name="header" as="xs:boolean" select="boolean(ixsl:get(($dialog//input[@name = 'header-row'])[1], 'checked'))"/>
+            <xsl:variable name="caption-text" as="xs:string" select="local:input-value($dialog, 'caption')"/>
+            <xsl:call-template name="local:push-undo"/>
+            <xsl:variable name="table" as="element()" select="local:element('table')"/>
+            <xsl:if test="$caption-text ne ''">
+                <xsl:variable name="caption" as="element()" select="local:element('caption')"/>
+                <ixsl:set-attribute name="contenteditable" select="'true'" object="$caption"/>
+                <ixsl:set-property name="textContent" select="$caption-text" object="$caption"/>
+                <xsl:sequence select="ixsl:call($table, 'appendChild', [ $caption ])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:if>
+            <xsl:if test="$header">
+                <xsl:variable name="thead" as="element()" select="local:element('thead')"/>
+                <xsl:variable name="tr" as="element()" select="local:element('tr')"/>
+                <xsl:for-each select="1 to $cols">
+                    <xsl:variable name="th" as="element()">
+                        <xsl:call-template name="local:make-cell">
+                            <xsl:with-param name="name" select="'th'"/>
+                        </xsl:call-template>
+                    </xsl:variable>
+                    <xsl:sequence select="ixsl:call($tr, 'appendChild', [ $th ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+                <xsl:sequence select="ixsl:call($thead, 'appendChild', [ $tr ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:sequence select="ixsl:call($table, 'appendChild', [ $thead ])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:if>
+            <xsl:variable name="tbody" as="element()" select="local:element('tbody')"/>
+            <xsl:for-each select="1 to $rows">
+                <xsl:variable name="tr" as="element()">
+                    <xsl:call-template name="local:make-row">
+                        <xsl:with-param name="cols" select="$cols"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:sequence select="ixsl:call($tbody, 'appendChild', [ $tr ])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:for-each>
+            <xsl:sequence select="ixsl:call($table, 'appendChild', [ $tbody ])[current-date() lt xs:date('2000-01-01')]"/>
+            <!-- placed per the content model relative to the host the dialog was
+                 opened from: an empty list item or cell grows the table INSIDE
+                 itself, a sibling where the parent admits it (chrome only when it
+                 lands top-level - the helper guards it) -->
+            <xsl:call-template name="local:insert-block-at-caret">
+                <xsl:with-param name="node" select="$table"/>
+                <xsl:with-param name="host" select="ixsl:get(local:editor-state(), 'insertHost')[exists(local:block-of(.))]"/>
+            </xsl:call-template>
+            <xsl:for-each select="(local:table-cells($table))[1]">
+                <xsl:call-template name="local:focus-caret">
+                    <xsl:with-param name="node" select="."/>
+                    <xsl:with-param name="offset" select="0"/>
+                </xsl:call-template>
+            </xsl:for-each>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:if>
+        <xsl:call-template name="local:hide-dialogs"/>
+    </xsl:template>
+
+    <!-- ................................ row/column operations ................................ -->
+
+    <xsl:template match="button[contains-token(@class, 'table-op')]" mode="ixsl:onclick">
+        <xsl:variable name="op" as="xs:string" select="string(@data-op)"/>
+        <xsl:for-each select="local:current-cell()[not(local:has-spans(local:table-of(.)))]">
+            <xsl:choose>
+                <xsl:when test="$op = ('row-above', 'row-below')">
+                    <xsl:call-template name="local:op-insert-row">
+                        <xsl:with-param name="cell" select="."/>
+                        <xsl:with-param name="before" select="$op = 'row-above'"/>
+                    </xsl:call-template>
+                </xsl:when>
+                <xsl:when test="$op = ('col-left', 'col-right')">
+                    <xsl:call-template name="local:op-insert-column">
+                        <xsl:with-param name="cell" select="."/>
+                        <xsl:with-param name="before" select="$op = 'col-left'"/>
+                    </xsl:call-template>
+                </xsl:when>
+                <xsl:when test="$op = 'del-row'">
+                    <xsl:call-template name="local:op-delete-row">
+                        <xsl:with-param name="cell" select="."/>
+                    </xsl:call-template>
+                </xsl:when>
+                <xsl:when test="$op = 'del-col'">
+                    <xsl:call-template name="local:op-delete-column">
+                        <xsl:with-param name="cell" select="."/>
+                    </xsl:call-template>
+                </xsl:when>
+                <xsl:otherwise/>
+            </xsl:choose>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- capture pre-insert state; push only when the insert happened (insert-row
+         no-ops above the header row and after a headerless table's thead) -->
+    <xsl:template name="local:op-insert-row">
+        <xsl:param name="cell" as="element()"/>
+        <xsl:param name="before" as="xs:boolean"/>
+
+        <xsl:variable name="i" as="xs:integer" select="local:column-index($cell)"/>
+        <xsl:variable name="snapshot-root" as="element()?" select="local:root-of($cell)"/>
+        <xsl:variable name="snapshot" as="xs:string?" select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
+        <xsl:variable name="new" as="element()?">
+            <xsl:call-template name="local:insert-row">
+                <xsl:with-param name="row" select="$cell/parent::tr"/>
+                <xsl:with-param name="before" select="$before"/>
+            </xsl:call-template>
+        </xsl:variable>
+        <xsl:for-each select="$new">
+            <xsl:call-template name="local:push-undo">
+                <xsl:with-param name="root" select="$snapshot-root"/>
+                <xsl:with-param name="snapshot" select="$snapshot"/>
+            </xsl:call-template>
+            <xsl:for-each select="((td | th)[$i], (td | th)[last()])[1]">
+                <xsl:call-template name="local:focus-caret">
+                    <xsl:with-param name="node" select="."/>
+                    <xsl:with-param name="offset" select="0"/>
+                </xsl:call-template>
+            </xsl:for-each>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="local:op-insert-column">
+        <xsl:param name="cell" as="element()"/>
+        <xsl:param name="before" as="xs:boolean"/>
+
+        <xsl:variable name="i" as="xs:integer" select="local:column-index($cell)"/>
+        <xsl:call-template name="local:push-undo">
+            <xsl:with-param name="host" select="$cell"/>
+        </xsl:call-template>
+        <xsl:for-each select="local:table-rows(local:table-of($cell))">
+            <xsl:variable name="row" as="element()" select="."/>
+            <xsl:variable name="new" as="element()">
+                <xsl:call-template name="local:make-cell">
+                    <xsl:with-param name="name" select="if ($row/parent::thead) then 'th' else 'td'"/>
+                </xsl:call-template>
+            </xsl:variable>
+            <xsl:variable name="ref" as="element()?" select="($row/(td | th))[$i]"/>
+            <xsl:choose>
+                <xsl:when test="exists($ref)">
+                    <xsl:sequence select="ixsl:call($ref, if ($before) then 'before' else 'after', [ $new ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:when>
+                <!-- ragged (pasted) rows shorter than the caret column -->
+                <xsl:otherwise>
+                    <xsl:sequence select="ixsl:call($row, 'appendChild', [ $new ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:for-each>
+        <xsl:variable name="j" as="xs:integer" select="$i + (if ($before) then 0 else 1)"/>
+        <xsl:for-each select="local:first-host-in(($cell/parent::tr/(td | th))[$j])">
+            <xsl:call-template name="local:focus-caret">
+                <xsl:with-param name="node" select="."/>
+                <xsl:with-param name="offset" select="0"/>
+            </xsl:call-template>
+        </xsl:for-each>
+        <xsl:call-template name="local:after-mutation"/>
+    </xsl:template>
+
+    <!-- the last body row stays (delete-block removes the whole table); a header
+         row goes only while body rows remain to hold the caret -->
+    <xsl:template name="local:op-delete-row">
+        <xsl:param name="cell" as="element()"/>
+
+        <xsl:variable name="row" as="element()" select="$cell/parent::tr"/>
+        <xsl:variable name="table" as="element()?" select="local:table-of($cell)"/>
+        <xsl:variable name="body-rows" as="element()*" select="local:table-rows($table)[not(parent::thead)]"/>
+        <xsl:if test="if ($row/parent::thead) then exists($body-rows) else count($body-rows) gt 1">
+            <xsl:variable name="i" as="xs:integer" select="local:column-index($cell)"/>
+            <xsl:variable name="rows" as="element()*" select="local:table-rows($table)"/>
+            <xsl:variable name="target" as="element()?"
+                select="(($rows[. &gt;&gt; $row])[1], ($rows[. &lt;&lt; $row])[last()])[1]"/>
+            <xsl:call-template name="local:push-undo">
+                <xsl:with-param name="host" select="$cell"/>
+            </xsl:call-template>
+            <xsl:variable name="section" as="element()" select="$row/parent::*"/>
+            <xsl:sequence select="ixsl:call($row, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:if test="$section[self::thead or self::tbody or self::tfoot] and empty($section/tr)">
+                <xsl:sequence select="ixsl:call($section, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:if>
+            <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+            <xsl:for-each select="local:first-host-in(
+                    (($target/(td | th))[$i], ($target/(td | th))[last()])[1])">
+                <xsl:call-template name="local:focus-caret">
+                    <xsl:with-param name="node" select="."/>
+                    <xsl:with-param name="offset" select="0"/>
+                </xsl:call-template>
+            </xsl:for-each>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- the last column stays; victims are materialized before the first removal
+         because the positional index shifts as cells go -->
+    <xsl:template name="local:op-delete-column">
+        <xsl:param name="cell" as="element()"/>
+
+        <xsl:variable name="row" as="element()" select="$cell/parent::tr"/>
+        <xsl:if test="count($row/(td | th)) gt 1">
+            <xsl:variable name="i" as="xs:integer" select="local:column-index($cell)"/>
+            <xsl:variable name="victims" as="element()*"
+                select="local:table-rows(local:table-of($cell)) ! (./(td | th))[$i]"/>
+            <xsl:call-template name="local:push-undo">
+                <xsl:with-param name="host" select="$cell"/>
+            </xsl:call-template>
+            <xsl:for-each select="$victims">
+                <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:for-each>
+            <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+            <xsl:for-each select="local:first-host-in(
+                    (($row/(td | th))[$i], ($row/(td | th))[last()])[1])">
+                <xsl:call-template name="local:focus-caret">
+                    <xsl:with-param name="node" select="."/>
+                    <xsl:with-param name="offset" select="0"/>
+                </xsl:call-template>
+            </xsl:for-each>
+            <xsl:call-template name="local:after-mutation"/>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- ................................ cell traversal ................................ -->
+
+    <!-- Tab walks the cells in visual order and grows the table by a body row at
+         the very last cell; the caption Tabs into the first cell. Focus never
+         Tabs out of the grid into the toolbar -->
+    <xsl:template name="local:table-tab">
+        <xsl:param name="host" as="element()"/>
+        <xsl:param name="event"/>
+        <xsl:param name="shift" as="xs:boolean"/>
+
+        <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:variable name="table" as="element()?" select="local:table-of($host)"/>
+        <xsl:variable name="cells" as="element()*" select="local:table-cells($table)"/>
+        <xsl:choose>
+            <xsl:when test="$shift">
+                <xsl:for-each select="local:last-host-in(($cells[. &lt;&lt; $host])[last()])">
+                    <!-- caret at the end, but before a trailing placeholder <br> -->
+                    <xsl:call-template name="local:focus-caret">
+                        <xsl:with-param name="node" select="."/>
+                        <xsl:with-param name="offset" select="count(node()) - count(node()[last()][self::br])"/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:when test="exists(($cells[. &gt;&gt; $host])[1])">
+                <xsl:for-each select="local:first-host-in(($cells[. &gt;&gt; $host])[1])">
+                    <xsl:call-template name="local:focus-caret">
+                        <xsl:with-param name="node" select="."/>
+                        <xsl:with-param name="offset" select="0"/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise>
+                <!-- capture pre-insert state; push only when the row appeared -->
+                <xsl:variable name="snapshot-root" as="element()?" select="local:root-of($host)"/>
+                <xsl:variable name="snapshot" as="xs:string?" select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
+                <xsl:variable name="new" as="element()?">
+                    <xsl:for-each select="(local:table-rows($table))[last()]">
+                        <xsl:call-template name="local:insert-row">
+                            <xsl:with-param name="row" select="."/>
+                            <xsl:with-param name="before" select="false()"/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                </xsl:variable>
+                <xsl:for-each select="$new">
+                    <xsl:call-template name="local:push-undo">
+                        <xsl:with-param name="root" select="$snapshot-root"/>
+                        <xsl:with-param name="snapshot" select="$snapshot"/>
+                    </xsl:call-template>
+                    <xsl:for-each select="(td | th)[1]">
+                        <xsl:call-template name="local:focus-caret">
+                            <xsl:with-param name="node" select="."/>
+                            <xsl:with-param name="offset" select="0"/>
+                        </xsl:call-template>
+                    </xsl:for-each>
+                    <xsl:call-template name="local:after-mutation"/>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Enter steps down the column, growing the table below the last row; the
+         caller (local:handle-enter) has already pushed undo and cut a selection -->
+    <xsl:template name="local:table-enter">
+        <xsl:param name="host" as="element()"/>
+
+        <xsl:variable name="table" as="element()?" select="local:table-of($host)"/>
+        <xsl:variable name="row" as="element()" select="$host/parent::tr"/>
+        <xsl:variable name="i" as="xs:integer" select="local:column-index($host)"/>
+        <xsl:variable name="next" as="element()?" select="(local:table-rows($table)[. &gt;&gt; $row])[1]"/>
+        <xsl:choose>
+            <xsl:when test="exists($next)">
+                <xsl:for-each select="local:first-host-in(
+                        (($next/(td | th))[$i], ($next/(td | th))[last()])[1])">
+                    <xsl:call-template name="local:focus-caret">
+                        <xsl:with-param name="node" select="."/>
+                        <xsl:with-param name="offset" select="0"/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="new" as="element()?">
+                    <xsl:call-template name="local:insert-row">
+                        <xsl:with-param name="row" select="$row"/>
+                        <xsl:with-param name="before" select="false()"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:for-each select="(($new/(td | th))[$i], ($new/(td | th))[last()])[1]">
+                    <xsl:call-template name="local:focus-caret">
+                        <xsl:with-param name="node" select="."/>
+                        <xsl:with-param name="offset" select="0"/>
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- ................................ toolbar state ................................ -->
+
+    <!-- riding local:update-breadcrumb, the single caret-awareness choke point -->
+    <xsl:template name="local:sync-table-toolbar">
+        <xsl:variable name="enabled" as="xs:boolean"
+            select="exists(local:current-cell()[not(local:has-spans(local:table-of(.)))])"/>
+        <xsl:for-each select="id('edit-toolbar', ixsl:page())//button[contains-token(@class, 'table-op')]">
+            <ixsl:set-property name="disabled" select="not($enabled)" object="."/>
+        </xsl:for-each>
+        <!-- the whole cluster switches on when the caret is in a table -->
+        <xsl:for-each select="id('edit-toolbar', ixsl:page())//*[contains-token(@class, 'table-ops')]">
+            <ixsl:set-attribute name="class"
+                select="if ($enabled) then 'tb-group table-ops active' else 'tb-group table-ops'" object="."/>
+        </xsl:for-each>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/typeahead.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/typeahead.xsl
new file mode 100644
index 000000000..d2b8f8fc9
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/typeahead.xsl
@@ -0,0 +1,382 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+exclude-result-prefixes="xs"
+version="3.0">
+
+<!--
+    Typeahead lookups for the annotation form's property and type fields (replacing
+    long <select> dropdowns). LinkedDataHub's typeahead fires debounced SPARQL; here
+    the vocabularies are already in the SaxonJS document pool, so filtering is a
+    synchronous per-keystroke pass over local:vocab-terms - no async, no debounce.
+
+    A field is a stable wrapper span[@data-field] holding one of two states, swapped
+    via result-document (literal result elements, the IXSL-idiomatic DOM build):
+      - typing:    input.typeahead-input + ul.typeahead-menu (the option list)
+      - committed: button.typeahead-value (label + hidden input carrying the IRI)
+    The value is read from the hidden input when committed, else from the visible
+    input's text when it is an absolute IRI (free entry) or, for an untouched
+    button->edit, from @data-editing-iri (cleared on the first keystroke).
+-->
+
+    <!-- an absolute IRI has a scheme; free text lacking one is not a usable value -->
+    <xsl:function name="local:is-absolute-iri" as="xs:boolean">
+        <xsl:param name="s" as="xs:string"/>
+        <xsl:sequence select="matches($s, '^[A-Za-z][A-Za-z0-9+.\-]*:')"/>
+    </xsl:function>
+
+    <xsl:function name="local:typeahead-placeholder" as="xs:string">
+        <xsl:param name="field" as="xs:string"/>
+        <xsl:sequence select="if ($field = 'typeof')
+            then 'Type or paste a class IRI…' else 'Type or paste a property IRI…'"/>
+    </xsl:function>
+
+    <xsl:function name="local:typeahead-kind" as="xs:string">
+        <xsl:param name="field" as="xs:string"/>
+        <xsl:sequence select="if ($field = 'typeof') then 'class' else 'property'"/>
+    </xsl:function>
+
+    <!-- all terms of the field's kind across every vocabulary, resolved the same way
+         local:render-overlay does so doc() hits the preloaded pool -->
+    <xsl:function name="local:typeahead-terms" as="map(xs:string, xs:string)*">
+        <xsl:param name="field" as="xs:string"/>
+
+        <xsl:variable name="kind" as="xs:string" select="local:typeahead-kind($field)"/>
+        <xsl:variable name="vocab-uris" as="xs:string*"
+            select="$vocab-hrefs ! string(resolve-uri(., ixsl:location()))"/>
+        <xsl:for-each select="$vocab-uris">
+            <xsl:sequence select="local:vocab-terms(doc(.), $kind)"/>
+        </xsl:for-each>
+    </xsl:function>
+
+    <!-- the human label for a committed IRI: the vocabulary term's label, else the IRI -->
+    <xsl:function name="local:typeahead-label-for" as="xs:string">
+        <xsl:param name="field" as="xs:string"/>
+        <xsl:param name="iri" as="xs:string"/>
+
+        <xsl:variable name="match" as="map(xs:string, xs:string)?"
+            select="(local:typeahead-terms($field)[?uri = $iri])[1]"/>
+        <xsl:sequence select="(if (exists($match)) then $match?label else (), $iri)[1]"/>
+    </xsl:function>
+
+    <!-- the empty typing-state field, placed by local:render-overlay -->
+    <xsl:function name="local:typeahead-field" as="element()">
+        <xsl:param name="field" as="xs:string"/>
+
+        <span class="typeahead-field rdfa-editor-ui" data-field="{$field}">
+            <input type="text" class="typeahead-input" autocomplete="off"
+                placeholder="{local:typeahead-placeholder($field)}"/>
+            <ul class="typeahead-menu" role="listbox" style="display: none;"/>
+        </span>
+    </xsl:function>
+
+    <!-- the committed IRI, else a free-typed absolute IRI, else the untouched
+         button->edit value, else nothing -->
+    <xsl:function name="local:typeahead-value" as="xs:string?">
+        <xsl:param name="form" as="element()"/>
+        <xsl:param name="field" as="xs:string"/>
+
+        <xsl:variable name="wrapper" as="element()?" select="($form//span[@data-field = $field])[1]"/>
+        <xsl:variable name="hidden" as="element()?" select="$wrapper//input[@type = 'hidden']"/>
+        <xsl:choose>
+            <xsl:when test="exists($hidden)">
+                <xsl:sequence select="string(ixsl:get($hidden, 'value'))[. ne '']"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="input" as="element()?"
+                    select="$wrapper//input[contains-token(@class, 'typeahead-input')]"/>
+                <xsl:variable name="text" as="xs:string"
+                    select="normalize-space(string(ixsl:get($input, 'value')))"/>
+                <xsl:variable name="editing" as="xs:string" select="string($wrapper/@data-editing-iri)"/>
+                <xsl:sequence select="
+                    if ($text eq '') then ()
+                    else if (local:is-absolute-iri($text)) then $text
+                    else if ($editing ne '') then $editing
+                    else ()"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- reset a field to reflect an IRI (empty -> empty input, non-empty -> button);
+         drives form open and edit pre-fill, fully controlling the state (form.reset()
+         leaves these custom widgets untouched) -->
+    <xsl:template name="local:typeahead-set-value">
+        <xsl:param name="form" as="element()"/>
+        <xsl:param name="field" as="xs:string"/>
+        <xsl:param name="iri" as="xs:string"/>
+
+        <xsl:for-each select="($form//span[@data-field = $field])[1]">
+            <ixsl:remove-attribute name="data-editing-iri"/>
+            <xsl:choose>
+                <xsl:when test="$iri ne ''">
+                    <xsl:call-template name="local:typeahead-commit">
+                        <xsl:with-param name="wrapper" select="."/>
+                        <xsl:with-param name="iri" select="$iri"/>
+                        <xsl:with-param name="label" select="local:typeahead-label-for($field, $iri)"/>
+                    </xsl:call-template>
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:call-template name="local:typeahead-to-input">
+                        <xsl:with-param name="wrapper" select="."/>
+                    </xsl:call-template>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- swap the wrapper to the committed button carrying the IRI -->
+    <xsl:template name="local:typeahead-commit">
+        <xsl:param name="wrapper" as="element()"/>
+        <xsl:param name="iri" as="xs:string"/>
+        <xsl:param name="label" as="xs:string"/>
+
+        <xsl:variable name="field" as="xs:string" select="string($wrapper/@data-field)"/>
+        <xsl:for-each select="$wrapper">
+            <ixsl:remove-attribute name="data-editing-iri"/>
+            <xsl:result-document href="?." method="ixsl:replace-content">
+                <button type="button" class="typeahead-value" title="{$iri}">
+                    <span class="typeahead-label"><xsl:value-of select="$label"/></span>
+                    <span class="typeahead-clear" role="button" aria-label="Clear">&#215;</span>
+                    <input type="hidden" name="{$field}" value="{$iri}"/>
+                </button>
+            </xsl:result-document>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- swap the wrapper to the typing state; optionally seed the text, focus the
+         input and open the menu (button->edit) -->
+    <xsl:template name="local:typeahead-to-input">
+        <xsl:param name="wrapper" as="element()"/>
+        <xsl:param name="text" as="xs:string" select="''"/>
+        <xsl:param name="focus" as="xs:boolean" select="false()"/>
+        <xsl:param name="open" as="xs:boolean" select="false()"/>
+
+        <xsl:variable name="field" as="xs:string" select="string($wrapper/@data-field)"/>
+        <xsl:for-each select="$wrapper">
+            <xsl:result-document href="?." method="ixsl:replace-content">
+                <input type="text" class="typeahead-input" autocomplete="off"
+                    placeholder="{local:typeahead-placeholder($field)}" value="{$text}"/>
+                <ul class="typeahead-menu" role="listbox" style="display: {if ($open) then 'block' else 'none'};">
+                    <xsl:if test="$open">
+                        <xsl:call-template name="local:typeahead-options">
+                            <xsl:with-param name="field" select="$field"/>
+                            <xsl:with-param name="query" select="$text"/>
+                        </xsl:call-template>
+                    </xsl:if>
+                </ul>
+            </xsl:result-document>
+        </xsl:for-each>
+        <xsl:if test="$focus">
+            <xsl:for-each select="($wrapper//input[contains-token(@class, 'typeahead-input')])[1]">
+                <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:for-each>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- render the option <li> list for a query (no result-document of its own: the
+         caller places it inside one). Prefix matches rank first, then by label;
+         capped so a large vocabulary stays snappy; the first option is pre-selected -->
+    <xsl:template name="local:typeahead-options">
+        <xsl:param name="field" as="xs:string"/>
+        <xsl:param name="query" as="xs:string"/>
+
+        <xsl:variable name="q" as="xs:string" select="lower-case(normalize-space($query))"/>
+        <xsl:variable name="matches" as="map(xs:string, xs:string)*" select="local:typeahead-terms($field)
+            [$q = '' or contains(lower-case(?label), $q) or contains(lower-case(?uri), $q)]"/>
+        <xsl:variable name="ranked" as="map(xs:string, xs:string)*">
+            <xsl:perform-sort select="$matches">
+                <xsl:sort select="if (starts-with(lower-case(?label), $q)) then 0 else 1"/>
+                <xsl:sort select="lower-case(?label)"/>
+            </xsl:perform-sort>
+        </xsl:variable>
+        <xsl:for-each select="$ranked[position() le 50]">
+            <xsl:variable name="pos" as="xs:integer" select="position()"/>
+            <li class="typeahead-option" role="option" data-uri="{?uri}" data-label="{?label}">
+                <xsl:if test="$pos = 1">
+                    <xsl:attribute name="aria-selected" select="'true'"/>
+                </xsl:if>
+                <span class="typeahead-option-label">
+                    <xsl:call-template name="local:typeahead-highlight">
+                        <xsl:with-param name="text" select="?label"/>
+                        <xsl:with-param name="q" select="$q"/>
+                    </xsl:call-template>
+                </span>
+                <span class="typeahead-option-uri"><xsl:value-of select="?uri"/></span>
+            </li>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- re-render the menu for the current query and show/hide it -->
+    <xsl:template name="local:typeahead-refresh">
+        <xsl:param name="wrapper" as="element()"/>
+        <xsl:param name="query" as="xs:string"/>
+
+        <xsl:variable name="field" as="xs:string" select="string($wrapper/@data-field)"/>
+        <xsl:for-each select="$wrapper//ul[contains-token(@class, 'typeahead-menu')]">
+            <xsl:result-document href="?." method="ixsl:replace-content">
+                <xsl:call-template name="local:typeahead-options">
+                    <xsl:with-param name="field" select="$field"/>
+                    <xsl:with-param name="query" select="$query"/>
+                </xsl:call-template>
+            </xsl:result-document>
+            <ixsl:set-style name="display"
+                select="if (exists(./li)) then 'block' else 'none'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- the matched substring in bold (first occurrence, case-insensitive) -->
+    <xsl:template name="local:typeahead-highlight">
+        <xsl:param name="text" as="xs:string"/>
+        <xsl:param name="q" as="xs:string"/>
+
+        <xsl:choose>
+            <xsl:when test="$q = '' or not(contains(lower-case($text), $q))">
+                <xsl:value-of select="$text"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="i" as="xs:integer"
+                    select="string-length(substring-before(lower-case($text), $q))"/>
+                <xsl:value-of select="substring($text, 1, $i)"/>
+                <strong><xsl:value-of select="substring($text, $i + 1, string-length($q))"/></strong>
+                <xsl:value-of select="substring($text, $i + 1 + string-length($q))"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- ............................ event handlers ............................ -->
+
+    <!-- typing filters the menu and invalidates a stale button->edit selection -->
+    <xsl:template match="input[contains-token(@class, 'typeahead-input')]" mode="ixsl:oninput">
+        <xsl:variable name="wrapper" as="element()"
+            select="ancestor::span[contains-token(@class, 'typeahead-field')][1]"/>
+        <ixsl:remove-attribute name="data-editing-iri" object="$wrapper"/>
+        <xsl:call-template name="local:typeahead-refresh">
+            <xsl:with-param name="wrapper" select="$wrapper"/>
+            <xsl:with-param name="query" select="string(ixsl:get(., 'value'))"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- the innermost template fires, so this fully owns the input's keys: Escape
+         closes the menu (else the overlay, mirroring overlay.xsl's div handler);
+         Enter commits a free IRI or the active option; arrows move the selection -->
+    <xsl:template match="input[contains-token(@class, 'typeahead-input')]" mode="ixsl:onkeydown">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="key" as="xs:string" select="string(ixsl:get($event, 'key'))"/>
+        <xsl:variable name="wrapper" as="element()"
+            select="ancestor::span[contains-token(@class, 'typeahead-field')][1]"/>
+        <xsl:variable name="field" as="xs:string" select="string($wrapper/@data-field)"/>
+        <xsl:variable name="menu" as="element()" select="$wrapper//ul[contains-token(@class, 'typeahead-menu')]"/>
+        <xsl:variable name="open" as="xs:boolean" select="string(ixsl:get($menu, 'style.display')) ne 'none'"/>
+        <xsl:variable name="items" as="element()*" select="$menu//li[contains-token(@class, 'typeahead-option')]"/>
+        <xsl:variable name="current" as="element()?" select="$items[@aria-selected = 'true'][1]"/>
+        <xsl:variable name="text" as="xs:string" select="normalize-space(string(ixsl:get(., 'value')))"/>
+        <xsl:choose>
+            <xsl:when test="$key = 'Escape'">
+                <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:choose>
+                    <xsl:when test="$open">
+                        <ixsl:set-style name="display" select="'none'" object="$menu"/>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:call-template name="local:hide-overlay"/>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:when>
+            <xsl:when test="$key = 'Enter'">
+                <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:choose>
+                    <xsl:when test="local:is-absolute-iri($text)">
+                        <xsl:call-template name="local:typeahead-commit">
+                            <xsl:with-param name="wrapper" select="$wrapper"/>
+                            <xsl:with-param name="iri" select="$text"/>
+                            <xsl:with-param name="label" select="local:typeahead-label-for($field, $text)"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:when test="$open and exists($current)">
+                        <xsl:call-template name="local:typeahead-commit">
+                            <xsl:with-param name="wrapper" select="$wrapper"/>
+                            <xsl:with-param name="iri" select="string($current/@data-uri)"/>
+                            <xsl:with-param name="label" select="string($current/@data-label)"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <ixsl:set-style name="display" select="'none'" object="$menu"/>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:when>
+            <xsl:when test="$key = ('ArrowDown', 'ArrowUp') and $open and exists($items)">
+                <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:variable name="pos" as="xs:integer"
+                    select="if (exists($current)) then count($items[. &lt;&lt; $current]) + 1 else 1"/>
+                <xsl:variable name="next" as="xs:integer" select="if ($key = 'ArrowDown')
+                    then min(($pos + 1, count($items))) else max(($pos - 1, 1))"/>
+                <xsl:for-each select="$items">
+                    <ixsl:remove-attribute name="aria-selected"/>
+                </xsl:for-each>
+                <xsl:for-each select="$items[$next]">
+                    <ixsl:set-attribute name="aria-selected" select="'true'"/>
+                    <xsl:variable name="opts" select="ixsl:call(ixsl:window(), 'Object', [])"/>
+                    <ixsl:set-property name="block" select="'nearest'" object="$opts"/>
+                    <xsl:sequence select="ixsl:call(., 'scrollIntoView', [ $opts ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise/>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- focus leaving the field hides the menu; an option's mousedown preventDefault
+         keeps focus, so mouse selection commits before this runs -->
+    <xsl:template match="input[contains-token(@class, 'typeahead-input')]" mode="ixsl:onfocusout">
+        <xsl:for-each select="ancestor::span[contains-token(@class, 'typeahead-field')][1]
+                //ul[contains-token(@class, 'typeahead-menu')]">
+            <ixsl:set-style name="display" select="'none'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- mousedown (not click): fires before the input's focusout, so the option is
+         still there to read. preventDefault keeps the caret/focus -->
+    <xsl:template match="li[contains-token(@class, 'typeahead-option')]" mode="ixsl:onmousedown">
+        <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:typeahead-commit">
+            <xsl:with-param name="wrapper" select="ancestor::span[contains-token(@class, 'typeahead-field')][1]"/>
+            <xsl:with-param name="iri" select="string(@data-uri)"/>
+            <xsl:with-param name="label" select="string(@data-label)"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- the committed button: the × clears the field, the body re-opens it for
+         editing (prefilled with the label, IRI parked on @data-editing-iri) -->
+    <xsl:template match="button[contains-token(@class, 'typeahead-value')]" mode="ixsl:onclick">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:variable name="target" select="ixsl:get($event, 'target')"/>
+        <xsl:variable name="wrapper" as="element()"
+            select="ancestor-or-self::span[contains-token(@class, 'typeahead-field')][1]"/>
+        <xsl:variable name="iri" as="xs:string" select="string(@title)"/>
+        <xsl:variable name="label" as="xs:string"
+            select="string(.//span[contains-token(@class, 'typeahead-label')])"/>
+        <xsl:choose>
+            <xsl:when test="exists($target/ancestor-or-self::*[contains-token(@class, 'typeahead-clear')])">
+                <xsl:call-template name="local:typeahead-to-input">
+                    <xsl:with-param name="wrapper" select="$wrapper"/>
+                    <xsl:with-param name="focus" select="true()"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <ixsl:set-attribute name="data-editing-iri" select="$iri" object="$wrapper"/>
+                <xsl:call-template name="local:typeahead-to-input">
+                    <xsl:with-param name="wrapper" select="$wrapper"/>
+                    <xsl:with-param name="text" select="$label"/>
+                    <xsl:with-param name="focus" select="true()"/>
+                    <xsl:with-param name="open" select="true()"/>
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/undo.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/undo.xsl
new file mode 100644
index 000000000..3a219396e
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/undo.xsl
@@ -0,0 +1,278 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:local="urn:rdfa-editor:functions"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    Unified snapshot undo/redo: one whole-document history over #content innerHTML.
+    Every mutating handler pushes a snapshot first and calls local:after-mutation last;
+    plain typing is
+    coalesced into ~1s bursts via ixsl:onbeforeinput. Ctrl/Cmd+Z and Shift+Z / Ctrl+Y
+    are intercepted in the keydown dispatcher (edit.xsl) - native undo is replaced.
+
+    Storage: hidden DOM stash divs (one child div per snapshot, textContent = the
+    innerHTML string). JS arrays are unusable across the IXSL boundary (they marshal
+    to XDM sequences; an empty array becomes an empty sequence) and sequence-valued
+    window properties store only their first item - the DOM stash uses only proven
+    primitives and gives O(1) push/pop. It carries data-role="storage", so the
+    extractor skips it; it lives outside #content, so canonicalization never sees it.
+
+    Caret restoration after undo/redo is approximate (first editable host): exact
+    restoration would require serializing Range endpoints into content-polluting
+    markers, which the canonicalization contract forbids.
+-->
+
+    <xsl:variable name="local:max-undo" as="xs:integer" select="100"/>
+
+    <xsl:template name="local:init-undo">
+        <xsl:for-each select="ixsl:page()//body">
+            <xsl:result-document href="?." method="ixsl:append-content">
+                <div id="rdfa-editor-undo-storage" data-role="storage" style="display: none;">
+                    <div id="rdfa-editor-undo-stack"/>
+                    <div id="rdfa-editor-redo-stack"/>
+                </div>
+            </xsl:result-document>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- append a snapshot entry, enforcing the depth cap. The caret position of the
+         state being snapshotted rides along as data attributes (the stash lives
+         outside #content, so data attributes are fine here) -->
+    <xsl:template name="local:stash-push">
+        <xsl:param name="stack" as="element()"/>
+        <xsl:param name="snapshot" as="xs:string"/>
+        <xsl:param name="root" as="element()"/>
+
+        <xsl:variable name="entry" as="element()" select="local:element('div')"/>
+        <ixsl:set-property name="textContent" select="$snapshot" object="$entry"/>
+        <!-- histories are keyed by editable region -->
+        <ixsl:set-attribute name="data-root"
+            select="string(count(local:roots()[. &lt;&lt; $root]) + 1)" object="$entry"/>
+        <xsl:call-template name="local:capture-caret">
+            <xsl:with-param name="entry" select="$entry"/>
+            <xsl:with-param name="root" select="$root"/>
+        </xsl:call-template>
+        <xsl:sequence select="ixsl:call($stack, 'appendChild', [ $entry ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:for-each select="($stack/div)[position() le count($stack/div) - $local:max-undo]">
+            <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- caret as (block index, chrome-free text-node index, character offset);
+         captured only when the selection anchors a text node inside content -->
+    <xsl:template name="local:capture-caret">
+        <xsl:param name="entry" as="element()"/>
+        <xsl:param name="root" as="element()"/>
+
+        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
+            <xsl:variable name="anchor" select="ixsl:get($selection, 'anchorNode')"/>
+            <xsl:if test="ixsl:get($anchor, 'nodeType') = 3 and (local:root-of($anchor) ! (. is $root))">
+                <xsl:for-each select="local:block-of($anchor)">
+                    <xsl:variable name="texts" select=".//text()[not(ancestor::*[@data-role])]"/>
+                    <xsl:if test="exists($texts[. is $anchor])">
+                        <ixsl:set-attribute name="data-block"
+                            select="string(count(preceding-sibling::*) + 1)" object="$entry"/>
+                        <ixsl:set-attribute name="data-node"
+                            select="string(count($texts[. &lt;&lt; $anchor]) + 1)" object="$entry"/>
+                        <ixsl:set-attribute name="data-offset"
+                            select="string(ixsl:get($selection, 'anchorOffset'))" object="$entry"/>
+                    </xsl:if>
+                </xsl:for-each>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- record the pre-mutation state; call FIRST in every mutating handler.
+         $snapshot allows capturing before an operation that may fail (wrap-range)
+         and pushing only on success -->
+    <xsl:template name="local:push-undo">
+        <xsl:param name="host" as="element()?" select="()"/>
+        <xsl:param name="root" as="element()?" select="($host ! local:root-of(.), local:active-root())[1]"/>
+        <xsl:param name="snapshot" as="xs:string?" select="$root ! string(ixsl:get(., 'innerHTML'))"/>
+
+        <xsl:for-each select="$root[exists($snapshot)]">
+            <xsl:variable name="stack" as="element()" select="id('rdfa-editor-undo-stack', ixsl:page())"/>
+            <xsl:variable name="root-index" as="xs:integer" select="count(local:roots()[. &lt;&lt; current()]) + 1"/>
+            <xsl:variable name="top" as="element()?" select="($stack/div)[last()]"/>
+            <!-- dedup guard: the same region's unchanged snapshot is a no-op -->
+            <xsl:if test="not(string($top) eq $snapshot and xs:integer($top/@data-root) eq $root-index)">
+                <xsl:call-template name="local:stash-push">
+                    <xsl:with-param name="stack" select="$stack"/>
+                    <xsl:with-param name="snapshot" select="$snapshot"/>
+                    <xsl:with-param name="root" select="."/>
+                </xsl:call-template>
+                <ixsl:set-property name="textContent" select="''" object="id('rdfa-editor-redo-stack', ixsl:page())"/>
+            </xsl:if>
+        </xsl:for-each>
+        <ixsl:set-property name="lastUndoTime"
+            select="ixsl:call(ixsl:get(ixsl:window(), 'Date'), 'now', [])" object="local:editor-state()"/>
+        <ixsl:set-property name="lastUndoHost" select="$host" object="local:editor-state()"/>
+    </xsl:template>
+
+    <!-- undo and redo are the same move with the stacks swapped: pop $from,
+         push the popped entry's region's current state raw onto $to (raw: never
+         clears the redo stack - only local:push-undo does), restore -->
+    <xsl:template name="local:shift-history">
+        <xsl:param name="from" as="xs:string"/>
+        <xsl:param name="to" as="xs:string"/>
+
+        <xsl:for-each select="(id($from, ixsl:page())/div)[last()]">
+            <xsl:variable name="root-index" as="xs:integer" select="xs:integer(@data-root)"/>
+            <xsl:variable name="root" as="element()?" select="local:roots()[$root-index]"/>
+            <xsl:call-template name="local:stash-push">
+                <xsl:with-param name="stack" select="id($to, ixsl:page())"/>
+                <xsl:with-param name="snapshot" select="$root ! string(ixsl:get(., 'innerHTML'))"/>
+                <xsl:with-param name="root" select="$root"/>
+            </xsl:call-template>
+            <xsl:variable name="snapshot" as="xs:string" select="string(.)"/>
+            <xsl:variable name="caret" as="xs:integer*" select="(@data-block, @data-node, @data-offset) ! xs:integer(.)"/>
+            <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:restore-snapshot">
+                <xsl:with-param name="snapshot" select="$snapshot"/>
+                <xsl:with-param name="caret" select="$caret"/>
+                <xsl:with-param name="root" select="$root"/>
+            </xsl:call-template>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="local:apply-undo">
+        <xsl:call-template name="local:shift-history">
+            <xsl:with-param name="from" select="'rdfa-editor-undo-stack'"/>
+            <xsl:with-param name="to" select="'rdfa-editor-redo-stack'"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <xsl:template name="local:apply-redo">
+        <xsl:call-template name="local:shift-history">
+            <xsl:with-param name="from" select="'rdfa-editor-redo-stack'"/>
+            <xsl:with-param name="to" select="'rdfa-editor-undo-stack'"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <xsl:template name="local:restore-snapshot">
+        <xsl:param name="snapshot" as="xs:string"/>
+        <xsl:param name="caret" as="xs:integer*" select="()"/>
+        <xsl:param name="root" as="element()?"/>
+
+        <xsl:for-each select="$root">
+            <ixsl:set-property name="innerHTML" select="$snapshot" object="."/>
+            <!-- the HTML fragment parser foster-parents non-table content out of a
+                 <table>, so a chrome span serialized inside a (possibly nested)
+                 table lands astray on restore. Strip every handle and re-converge
+                 (deterministic: first-child prepend on each draggable block); must
+                 precede caret resolution, which indexes $root/* -->
+            <xsl:for-each select="descendant::*[@data-role = 'chrome']">
+                <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:for-each>
+            <xsl:call-template name="local:ensure-chrome">
+                <xsl:with-param name="scope" select="."/>
+            </xsl:call-template>
+            <!-- snapshots carry island rendering markup, so restores are normally
+                 render-stable; only islands captured mid-render (no rendering div -
+                 async renderers inject it in the completion callback only) re-fire -->
+            <xsl:for-each select="descendant-or-self::*[local:island(.)][empty(*[@data-role = 'rendering'])]">
+                <xsl:apply-templates select="." mode="local:render-island"/>
+            </xsl:for-each>
+        </xsl:for-each>
+        <!-- every stored node reference is stale now -->
+        <xsl:call-template name="local:hide-overlay"/>
+        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:for-each select="('activeBlock', 'editingSpan', 'draggedBlock', 'editRange', 'editingLink',
+                'insertHost', 'range', 'breadcrumbLeaf', 'findNode', 'lastUndoHost',
+                'draggedSectionHeading', 'slashHost', 'sweepAnchorNode', 'sweepAnchorHost', 'sweepRegion')">
+            <ixsl:set-property name="{.}" select="()" object="local:editor-state()"/>
+        </xsl:for-each>
+        <ixsl:set-property name="lastUndoTime" select="0" object="local:editor-state()"/>
+        <!-- snapshots taken mid-drag may carry transient drag state -->
+        <xsl:call-template name="local:clear-drop-marks"/>
+        <xsl:for-each select="$root/descendant::*[@draggable]">
+            <ixsl:remove-attribute name="draggable"/>
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:tidy-class">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+        <!-- the caret stored with a snapshot is the caret of that state: restore it -->
+        <xsl:variable name="block-index" as="xs:integer?" select="$caret[1]"/>
+        <xsl:variable name="node-index" as="xs:integer?" select="$caret[2]"/>
+        <xsl:variable name="target" as="text()?"
+            select="(($root/*)[$block-index]//text()[not(ancestor::*[@data-role])])[$node-index]"/>
+        <xsl:choose>
+            <xsl:when test="exists($target)">
+                <xsl:for-each select="local:host-of($target)">
+                    <xsl:call-template name="local:focus">
+                        <xsl:with-param name="element" select="."/>
+                    </xsl:call-template>
+                </xsl:for-each>
+                <xsl:call-template name="local:place-caret">
+                    <xsl:with-param name="node" select="$target"/>
+                    <xsl:with-param name="offset" select="min(($caret[3], string-length($target)))"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:for-each select="($root/descendant-or-self::*[@contenteditable = 'true'])[1]">
+                    <xsl:call-template name="local:focus-caret">
+    <xsl:with-param name="node" select="."/>
+    <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+</xsl:call-template>
+                </xsl:for-each>
+            </xsl:otherwise>
+        </xsl:choose>
+        <xsl:call-template name="local:after-mutation"/>
+    </xsl:template>
+
+    <!-- coalesced typing history: beforeinput fires pre-mutation for typing, native
+         deletes and cut, so a burst boundary snapshot captures the state before it -->
+    <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onbeforeinput">
+        <xsl:variable name="event" select="ixsl:event()"/>
+        <xsl:if test="exists(local:block-of(.))">
+            <xsl:variable name="type" as="xs:string" select="string(ixsl:get($event, 'inputType'))"/>
+            <xsl:choose>
+                <!-- menu-driven Edit > Undo/Redo bypasses keydown -->
+                <xsl:when test="starts-with($type, 'history')">
+                    <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:choose>
+                        <xsl:when test="$type = 'historyUndo'">
+                            <xsl:call-template name="local:apply-undo"/>
+                        </xsl:when>
+                        <xsl:otherwise>
+                            <xsl:call-template name="local:apply-redo"/>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:when>
+                <xsl:otherwise>
+                    <!-- Date.now via ixsl:call is a deliberate last resort: current-dateTime()
+                         is stable across event invocations in SaxonJS (probed), so it cannot
+                         detect burst boundaries -->
+                    <xsl:variable name="now" as="xs:double" select="ixsl:call(ixsl:get(ixsl:window(), 'Date'), 'now', [])"/>
+                    <xsl:if test="$now - xs:double((ixsl:get(local:editor-state(), 'lastUndoTime'), 0)[1]) gt 1000
+                            or not(ixsl:get(local:editor-state(), 'lastUndoHost') ! (. is current()))">
+                        <xsl:call-template name="local:push-undo">
+                            <xsl:with-param name="host" select="."/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:after-mutation"/>
+                    </xsl:if>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- the single post-mutation refresh hook: chrome convergence (a gesture may
+         have built nested draggable blocks), lint markers, live ToC, breadcrumb -->
+    <xsl:template name="local:after-mutation">
+        <xsl:call-template name="local:ensure-chrome"/>
+        <xsl:call-template name="local:run-lint"/>
+        <xsl:if test="id('toc-drawer', ixsl:page()) ! (ixsl:get(., 'style.display') ne 'none')">
+            <xsl:call-template name="local:render-toc"/>
+        </xsl:if>
+        <xsl:call-template name="local:update-breadcrumb"/>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/vocab.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/vocab.xsl
new file mode 100644
index 000000000..662e664ac
--- /dev/null
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/vocab.xsl
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns="http://www.w3.org/1999/xhtml"
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+xmlns:xs="http://www.w3.org/2001/XMLSchema"
+xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
+xmlns:owl="http://www.w3.org/2002/07/owl#"
+xmlns:dc11="http://purl.org/dc/elements/1.1/"
+xmlns:dct="http://purl.org/dc/terms/"
+xmlns:local="urn:rdfa-editor:functions"
+exclude-result-prefixes="#all"
+version="3.0">
+
+<!--
+    Generic ontology RDF/XML consumption: populates the type and property dropdowns
+    from plain vocabulary documents (FOAF, DCMI terms, ...) - no custom manifest format.
+
+    Handles both common RDF/XML shapes: typed elements (<owl:Class rdf:about="...">)
+    and rdf:Description with rdf:type children (possibly striped one-triple-per-
+    description, as in the DCMI terms file); labels as attributes or child elements.
+-->
+
+    <!-- ontology documents (RDF/XML) feeding the type and property dropdowns.
+         Relative hrefs resolve against the page URI; the host page preloads them
+         into the SaxonJS document pool (must match its list) -->
+    <xsl:param name="vocab-hrefs" as="xs:string*" select="('vocabs/foaf.rdf', 'vocabs/dcterms.rdf')"/>
+
+    <xsl:variable name="local:class-types" as="xs:string*" select="(
+        'http://www.w3.org/2000/01/rdf-schema#Class',
+        'http://www.w3.org/2002/07/owl#Class'
+    )"/>
+
+    <xsl:variable name="local:property-types" as="xs:string*" select="(
+        'http://www.w3.org/1999/02/22-rdf-syntax-ns#Property',
+        'http://www.w3.org/2002/07/owl#ObjectProperty',
+        'http://www.w3.org/2002/07/owl#DatatypeProperty',
+        'http://www.w3.org/2002/07/owl#AnnotationProperty'
+    )"/>
+
+    <!-- the ontology's own URI: owl:Ontology description, else the first rdfs:isDefinedBy target -->
+    <xsl:function name="local:ontology-uri" as="xs:string?">
+        <xsl:param name="vocab" as="document-node()"/>
+
+        <xsl:sequence select="(
+            $vocab/rdf:RDF/owl:Ontology/@rdf:about,
+            $vocab/rdf:RDF/*[rdf:type/@rdf:resource = 'http://www.w3.org/2002/07/owl#Ontology']/@rdf:about,
+            $vocab/rdf:RDF/*/rdfs:isDefinedBy/@rdf:resource
+        )[1] ! string(.)"/>
+    </xsl:function>
+
+    <!--
+        Terms of the requested kind ('class' | 'property') as maps with 'uri' and 'label'.
+        Descriptions are grouped by @rdf:about so striped vocabularies work; terms outside
+        the ontology namespace (e.g. FOAF's OWL-interop declarations) are dropped.
+    -->
+    <xsl:function name="local:vocab-terms" as="map(xs:string, xs:string)*">
+        <xsl:param name="vocab" as="document-node()"/>
+        <xsl:param name="kind" as="xs:string"/>
+
+        <xsl:variable name="type-uris" as="xs:string*"
+            select="if ($kind = 'class') then $local:class-types else $local:property-types"/>
+        <xsl:variable name="ontology-uri" as="xs:string?" select="local:ontology-uri($vocab)"/>
+        <xsl:for-each-group select="$vocab/rdf:RDF/*[@rdf:about]" group-by="@rdf:about">
+            <xsl:if test="(current-group()/rdf:type/@rdf:resource, current-group() ! (namespace-uri() || local-name())) = $type-uris
+                    and (empty($ontology-uri) or starts-with(current-grouping-key(), $ontology-uri))">
+                <xsl:sequence select="map{
+                    'uri': string(current-grouping-key()),
+                    'label': (current-group()/@rdfs:label, current-group()/rdfs:label,
+                        replace(current-grouping-key(), '^.*[#/]', ''))[1] ! string(.)
+                }"/>
+            </xsl:if>
+        </xsl:for-each-group>
+    </xsl:function>
+
+    <!-- local:vocab-terms feeds the property and type typeaheads (typeahead.xsl) -->
+
+</xsl:stylesheet>

From 21abe5f28f0249ef3689eadedf25c89e9a977872 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Mon, 27 Jul 2026 11:37:46 +0300
Subject: [PATCH 2/6] Fix RDFa editor-bar visual alignment

- Move border to action-bar bottom (border-top on editor-bar was hidden under action-bar's higher z-index)
- Flex-center editor-bar content (Bootstrap navbar-inner has min-height: 50px with no vertical centering)
- Fix select vertical alignment via auto margins (Firefox ignores align-items: center on native select)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../static/com/atomgraph/linkeddatahub/css/bootstrap.css      | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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 e1b9592d6..1aa7c9d2b 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
@@ -44,6 +44,7 @@ ul.dropdown-menu ul { margin: 0; }
 .action-bar #doc-controls { text-align: right; padding-top: 5px; }
 .action-bar #doc-controls .btn-edit { margin-top: -5px; margin-left: 10px; }
 .action-bar p.alert { margin-bottom: 0; }
+body:has(#edit-toolbar) .action-bar { border-bottom: 1px solid #aaa; }
 .nav-header.btn { color: inherit; }
 .btn.btn-primary.create-action { background-image: url('../icons/ic_note_add_white_24px.svg'); background-position: 12px center; background-repeat: no-repeat; padding-left: 40px; /* height: 30px; */ }
 .btn.create-action, a.create-action { background-image: url('../icons/ic_note_add_black_24px.svg'); background-position: 12px center; background-repeat: no-repeat; padding-left: 40px; /* height: 30px; */ }
@@ -212,5 +213,6 @@ object { display: block; margin: auto; max-height: 400px; overflow: hidden; widt
 /* SVG graph specific */
 circle { cursor: move; }
 /* RDFa editor specific */
-.editor-bar { position: sticky; top: calc(var(--action-bar-top, 51px) + 50px); z-index: 998; background: #dfdfdf; padding: 0; box-shadow: none; border-top: 1px solid #aaa; }
+.editor-bar { position: sticky; top: calc(var(--action-bar-top, 51px) + 50px); z-index: 998; background: #dfdfdf; padding: 0; box-shadow: none; display: flex; align-items: center; }
+#edit-toolbar select { margin-top: auto; margin-bottom: auto; }
 .editor-bar:not(:has(#edit-toolbar)), body:not(:has(.rdfa-editor-content)) .editor-bar, body:not(:has(.rdfa-editor-content)) #rdfa-editor-breadcrumb { display: none; }

From f00c823a1b375e553033ca64d6b43428800c56ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Mon, 27 Jul 2026 12:00:28 +0300
Subject: [PATCH 3/6] Add click-to-edit and autosave for XHTML blocks

- Click anywhere on .main content to enter edit mode (skips if text selected)
- Autosave XMLLiteral on focusout unless focus moved to toolbar/editor UI
- Hide .btn-edit on XHTML blocks (entry point is now content click)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../atomgraph/linkeddatahub/css/bootstrap.css |  2 ++
 .../xsl/bootstrap/2.3.2/client/block.xsl      | 27 ++++++++++++++++++-
 2 files changed, 28 insertions(+), 1 deletion(-)

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 1aa7c9d2b..91144217d 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
@@ -181,6 +181,8 @@ button.add-typeahead { width: 219px; }
 .description { display: none; }
 .content .dl-horizontal { max-height: 35em; overflow: auto; }
 div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"] .main { font-size: larger; line-height: 25px; }
+div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"]:not(:has(form)) .main { cursor: pointer; }
+div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"] .btn-edit { display: none; }
 div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"] .form-horizontal .control-label { display: none; }
 div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"] .form-horizontal .controls { margin-left: 0; }
 .span12.progress .row-block-controls { background-color: #e9ecef; }
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl
index 8c037fac1..74708d98d 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl
@@ -309,8 +309,33 @@ exclude-result-prefixes="#all"
         </xsl:if>
     </xsl:template>
 
+    <!-- click anywhere on XHTML content to enter edit mode (skip if text is selected) -->
+
+    <xsl:template match="div[@typeof = '&ldh;XHTML'][not(descendant::form)][acl:mode() = '&acl;Write']//div[contains-token(@class, 'main')]" mode="ixsl:onclick">
+        <xsl:if test="ixsl:call(ixsl:call(ixsl:window(), 'getSelection', []), 'toString', []) = ''">
+            <xsl:variable name="block" select="ancestor::div[contains-token(@class, 'block')][1]" as="element()"/>
+            <xsl:variable name="btn-edit" select="($block//button[contains-token(@class, 'btn-edit')][not(contains-token(@class, 'disabled'))])[1]" as="element()?"/>
+            <xsl:if test="$btn-edit">
+                <xsl:sequence select="ixsl:call($btn-edit, 'click', [])"/>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- autosave XMLLiteral when focus leaves the editor region (but not to the toolbar or other editor UI) -->
+
+    <xsl:template match="div[contains-token(@class, 'rdfa-editor-content')]" mode="ixsl:onfocusout">
+        <xsl:variable name="self" select="." as="element()"/>
+        <xsl:variable name="related" select="ixsl:get(ixsl:event(), 'relatedTarget')" as="item()?"/>
+        <xsl:if test="empty($related) or empty($related/ancestor-or-self::*[. is $self or @id = ('edit-toolbar', 'rdfa-editor-breadcrumb') or contains-token(@class, 'rdfa-editor-ui')])">
+            <xsl:variable name="form" select="ancestor::form[contains-token(@class, 'form-horizontal')][1]" as="element()?"/>
+            <xsl:if test="$form">
+                <xsl:sequence select="ixsl:call($form, 'requestSubmit', [])"/>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
     <!-- override inline editing form for block types (do nothing if the button is disabled) - prioritize over form.xsl -->
-    
+
     <xsl:template match="div[following-sibling::div[@typeof = ('&ldh;XHTML', '&ldh;Object')]]//button[contains-token(@class, 'btn-edit')][not(contains-token(@class, 'disabled'))]" mode="ixsl:onclick" priority="1">
         <xsl:param name="block" select="ancestor::div[contains-token(@class, 'block')][1]" as="element()"/>
         <!-- for block types, button.btn-edit is placed in its own div.row-fluid, therefore the next row is the actual container -->

From f8f1f20f66c03ec80f03ca847fd5509afc2165b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Mon, 27 Jul 2026 13:42:34 +0300
Subject: [PATCH 4/6] Suppress form-actions for XHTML blocks and exit edit mode
 on column click

- bs2:RowForm gains $show-form-actions param (default true); XHTML blocks
  pass false via xsl:next-match, omitting the Save/Reset/Cancel buttons
  since autosave-on-blur already handles submission
- ixsl:onclick on XHTML blocks in edit mode submits the form when the
  click target is outside the editor canvas; interactive elements are
  excluded (they steal focus, triggering focusout + autosave instead)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../xsl/bootstrap/2.3.2/client/block.xsl      | 21 +++++++++
 .../xsl/bootstrap/2.3.2/resource.xsl          | 45 ++++++++++---------
 2 files changed, 45 insertions(+), 21 deletions(-)

diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl
index 74708d98d..28896c48c 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/block.xsl
@@ -203,6 +203,13 @@ exclude-result-prefixes="#all"
 
     <xsl:template match="*[rdf:type/@rdf:resource = '&ldh;XHTML']/rdf:value/xhtml:*" mode="bs2:FormControlTypeLabel" priority="1"/>
 
+    <!-- autosave via ixsl:onfocusout replaces the Save button; suppress form-actions for XHTML blocks -->
+    <xsl:template match="*[rdf:type/@rdf:resource = '&ldh;XHTML']" mode="bs2:RowForm" priority="1">
+        <xsl:next-match>
+            <xsl:with-param name="show-form-actions" select="false()"/>
+        </xsl:next-match>
+    </xsl:template>
+
     <!-- EVENT LISTENERS -->
     
     <!-- show block controls -->
@@ -309,6 +316,20 @@ exclude-result-prefixes="#all"
         </xsl:if>
     </xsl:template>
 
+    <!-- click outside the editor canvas (left/right columns) while in edit mode exits edit mode -->
+
+    <xsl:template match="div[@typeof = '&ldh;XHTML'][descendant::form]" mode="ixsl:onclick">
+        <xsl:variable name="target" select="ixsl:get(ixsl:event(), 'target')" as="element()?"/>
+        <xsl:variable name="canvas" select="(descendant::div[contains-token(@class, 'rdfa-editor-content')])[1]" as="element()?"/>
+        <!-- skip if target is within the canvas or is an interactive element (interactive elements steal focus, triggering focusout + autosave) -->
+        <xsl:if test="exists($target) and empty($target/ancestor-or-self::*[. is $canvas or self::button or self::input or self::select or self::a])">
+            <xsl:variable name="form" select="(descendant::form[contains-token(@class, 'form-horizontal')])[1]" as="element()?"/>
+            <xsl:if test="$form">
+                <xsl:sequence select="ixsl:call($form, 'requestSubmit', [])"/>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
     <!-- click anywhere on XHTML content to enter edit mode (skip if text is selected) -->
 
     <xsl:template match="div[@typeof = '&ldh;XHTML'][not(descendant::form)][acl:mode() = '&acl;Write']//div[contains-token(@class, 'main')]" mode="ixsl:onclick">
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 00b51835a..43a8a1446 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
@@ -1100,6 +1100,7 @@ extension-element-prefixes="ixsl"
         <xsl:param name="button-class" select="'btn btn-primary wymupdate'" as="xs:string?"/>
         <xsl:param name="accept-charset" select="'UTF-8'" as="xs:string?"/>
         <xsl:param name="show-cancel-button" select="true()" as="xs:boolean"/>
+        <xsl:param name="show-form-actions" select="true()" as="xs:boolean"/>
         <xsl:param name="main-class" select="'main span7'" as="xs:string?"/>
 
         <div>
@@ -1148,31 +1149,33 @@ extension-element-prefixes="ixsl"
                         <xsl:with-param name="required" select="rdf:type/@rdf:resource = ('&dh;Container', '&dh;Item')" tunnel="yes"/>
                     </xsl:apply-templates>
 
-                    <div class="form-actions">
-                        <button type="submit" class="btn-primary">
-                            <xsl:apply-templates select="key('resources', 'save', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ldh:logo">
-                                <xsl:with-param name="class" select="$button-class"/>
-                            </xsl:apply-templates>
-
-                            <xsl:apply-templates select="key('resources', 'save', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ac:label"/>
-                        </button>
+                    <xsl:if test="$show-form-actions">
+                        <div class="form-actions">
+                            <button type="submit" class="btn-primary">
+                                <xsl:apply-templates select="key('resources', 'save', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ldh:logo">
+                                    <xsl:with-param name="class" select="$button-class"/>
+                                </xsl:apply-templates>
 
-                        <button type="reset" class="btn">
-                            <xsl:apply-templates select="key('resources', 'reset', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ldh:logo">
-                                <xsl:with-param name="class" select="'btn'"/>
-                            </xsl:apply-templates>
+                                <xsl:apply-templates select="key('resources', 'save', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ac:label"/>
+                            </button>
 
-                            <xsl:apply-templates select="key('resources', 'reset', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ac:label"/>
-                        </button>
+                            <button type="reset" class="btn">
+                                <xsl:apply-templates select="key('resources', 'reset', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ldh:logo">
+                                    <xsl:with-param name="class" select="'btn'"/>
+                                </xsl:apply-templates>
 
-                        <xsl:if test="$show-cancel-button">
-                            <button type="button" class="btn btn-cancel">
-                                <xsl:value-of>
-                                    <xsl:apply-templates select="key('resources', 'cancel', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ac:label"/>
-                                </xsl:value-of>
+                                <xsl:apply-templates select="key('resources', 'reset', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ac:label"/>
                             </button>
-                        </xsl:if>
-                    </div>
+
+                            <xsl:if test="$show-cancel-button">
+                                <button type="button" class="btn btn-cancel">
+                                    <xsl:value-of>
+                                        <xsl:apply-templates select="key('resources', 'cancel', document(resolve-uri('static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/translations.rdf', lapp:origin())))" mode="ac:label"/>
+                                    </xsl:value-of>
+                                </button>
+                            </xsl:if>
+                        </div>
+                    </xsl:if>
                 </form>
             </div>
 

From b73f7a64ee07e5d6f32cab062a4886e25d9519c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Mon, 27 Jul 2026 15:11:24 +0300
Subject: [PATCH 5/6] Override RDFa editor annotation typeahead and dialog with
 LDH's Bootstrap UI

Intercepts local:typeahead-field, local:typeahead-set-value,
local:typeahead-value, and local:render-overlay in form.xsl (which has
higher import precedence than the vendored rdfa-editor/ stylesheets) to
replace the upstream's doc()-on-vocabs typeahead with LDH's /ns-querying
bs2:Lookup widget and to re-style the annotation dialog using Bootstrap
2.3.2 form classes (.well, .form-horizontal, .control-group, .btn).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../atomgraph/linkeddatahub/css/bootstrap.css |   6 +
 .../xsl/bootstrap/2.3.2/client/form.xsl       | 132 ++++++++++++++++++
 2 files changed, 138 insertions(+)

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 91144217d..86a396c21 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
@@ -153,6 +153,12 @@ h2.item-logo { background-image: url('../icons/file.svg'); background-position:
 .modal-footer { position: sticky; bottom: 0; background-color: white; z-index: 1060; }
 .modal-first-time-message { margin-left: 0; width: 80%; left: 10%; }
 .modal-first-time-message .hero-unit { margin-bottom: 0; }
+/* Annotation overlay — reset rdfa-editor.css visual overrides; .well provides base styling */
+#overlay { background: #f5f5f5 !important; background-image: none !important; border: 1px solid #e3e3e3 !important; border-radius: 4px !important; box-shadow: inset 0 1px 1px rgba(0,0,0,.05) !important; font-family: inherit !important; min-width: 360px !important; max-width: 520px !important; }
+#overlay form { padding: 0 !important; }
+#overlay .btn.btn-primary { background-color: #0088cc; background-image: linear-gradient(to bottom, #0088cc, #0044cc); color: #fff; border-color: #0044cc; }
+#overlay .btn.btn-danger { background-color: #da4f49; background-image: linear-gradient(to bottom, #ee5f5b, #bd362f); color: #fff; border-color: #bd362f; }
+#overlay .btn { font-family: inherit; }
 .control-group.endpoint-classes ul { max-height: 20em; overflow: auto; }
 .nav-tabs > li > a, .pager > li > a.active { cursor: pointer; }
 .pager > li.previous > a { text-align: right; font-size: 0; color: transparent; background-image: url('../icons/ic_navigate_before_black_24px.svg'); background-position: center center; background-repeat: no-repeat; width: 64px; height: 24px; }
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl
index f6429148b..ef22e5b57 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl
@@ -163,6 +163,138 @@ WHERE
         </xsl:call-template>
     </xsl:template>
 
+    <!-- override RDFa editor annotation typeahead: use LDH's /ns-querying bs2:Lookup instead of doc()-on-vocabs -->
+    <xsl:function name="local:typeahead-field" as="element()">
+        <xsl:param name="field" as="xs:string"/>
+        <xsl:variable name="for-class" as="xs:anyURI" select="if ($field = 'typeof') then xs:anyURI('&owl;Class') else xs:anyURI('&rdf;Property')"/>
+        <span data-field="{$field}" class="typeahead-field rdfa-editor-ui">
+            <xsl:call-template name="bs2:Lookup">
+                <xsl:with-param name="class" select="'property-typeahead typeahead'"/>
+                <xsl:with-param name="id" select="'annotation-' || $field"/>
+                <xsl:with-param name="list-class" select="'property-typeahead typeahead dropdown-menu'"/>
+                <xsl:with-param name="forClass" select="$for-class"/>
+            </xsl:call-template>
+        </span>
+    </xsl:function>
+
+    <!-- rebuild the typeahead field and pre-populate with IRI; clears any prior committed button state -->
+    <xsl:template name="local:typeahead-set-value">
+        <xsl:param name="form" as="element()"/>
+        <xsl:param name="field" as="xs:string"/>
+        <xsl:param name="iri" as="xs:string"/>
+        <xsl:variable name="for-class" as="xs:anyURI" select="if ($field = 'typeof') then xs:anyURI('&owl;Class') else xs:anyURI('&rdf;Property')"/>
+        <xsl:for-each select="($form//span[@data-field = $field])[1]">
+            <xsl:result-document href="?." method="ixsl:replace-content">
+                <xsl:call-template name="bs2:Lookup">
+                    <xsl:with-param name="class" select="'property-typeahead typeahead'"/>
+                    <xsl:with-param name="id" select="'annotation-' || $field"/>
+                    <xsl:with-param name="list-class" select="'property-typeahead typeahead dropdown-menu'"/>
+                    <xsl:with-param name="forClass" select="$for-class"/>
+                    <xsl:with-param name="value" select="if ($iri ne '') then $iri else ()"/>
+                </xsl:call-template>
+            </xsl:result-document>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- read back the IRI from span[@data-field]: committed (hidden input) or typed (property-typeahead text) -->
+    <xsl:function name="local:typeahead-value" as="xs:string?">
+        <xsl:param name="form" as="element()"/>
+        <xsl:param name="field" as="xs:string"/>
+        <xsl:variable name="wrapper" as="element()?" select="($form//span[@data-field = $field])[1]"/>
+        <xsl:variable name="hidden" as="element()?" select="($wrapper//input[@type = 'hidden'])[1]"/>
+        <xsl:choose>
+            <xsl:when test="exists($hidden)">
+                <xsl:sequence select="string(ixsl:get($hidden, 'value'))[. ne '']"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="input" as="element()?" select="($wrapper//input[contains-token(@class, 'property-typeahead')])[1]"/>
+                <xsl:variable name="text" as="xs:string" select="normalize-space(string(ixsl:get($input, 'value')))"/>
+                <xsl:sequence select="if (local:is-absolute-iri($text)) then $text else ()"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- Bootstrap-styled annotation overlay (replaces rdfa-editor's custom HTML structure) -->
+    <xsl:template name="local:render-overlay">
+        <div id="overlay" class="rdfa-editor-ui well" role="dialog" aria-modal="true" aria-label="RDFa annotation" style="display: none;">
+            <div class="modal-header">
+                <h3>RDFa Annotation</h3>
+            </div>
+            <form id="annotation-form" class="form-horizontal">
+                <div class="control-group">
+                    <label class="control-label">Subject</label>
+                    <div class="controls">
+                        <div id="stmt-subject" class="uneditable-input"/>
+                    </div>
+                </div>
+                <div class="control-group">
+                    <label class="control-label">Property</label>
+                    <div class="controls">
+                        <xsl:sequence select="local:typeahead-field('property')"/>
+                    </div>
+                </div>
+                <div class="control-group">
+                    <label class="control-label">Value</label>
+                    <div class="controls">
+                        <input type="text" name="value" class="input-xlarge" placeholder="Literal value"/>
+                        <span class="help-block">The selected text; change to emit a machine-readable content value</span>
+                    </div>
+                </div>
+                <details id="advanced-fields">
+                    <summary>Type, subject &amp; object</summary>
+                    <div class="control-group">
+                        <label class="control-label">Type (typeof)</label>
+                        <div class="controls">
+                            <xsl:sequence select="local:typeahead-field('typeof')"/>
+                            <span class="help-block">Types the annotated resource; without a subject the typed resource becomes the object of the property (chaining)</span>
+                        </div>
+                    </div>
+                    <div class="control-group">
+                        <label class="control-label">Subject (about)</label>
+                        <div class="controls">
+                            <input type="text" name="subject" class="input-xlarge" placeholder="Overrides the subject in scope"/>
+                            <span class="help-block">IRI or _:blank-node identifier</span>
+                        </div>
+                    </div>
+                    <div class="control-group">
+                        <label class="control-label">Object (resource)</label>
+                        <div class="controls">
+                            <input type="text" name="object" class="input-xlarge" placeholder="Object IRI"/>
+                            <span class="help-block">Makes the object a resource instead of the literal value</span>
+                        </div>
+                    </div>
+                    <div class="control-group">
+                        <label class="control-label">Datatype</label>
+                        <div class="controls">
+                            <select name="datatype">
+                                <option value="">(plain literal)</option>
+                                <xsl:variable name="xsd" as="xs:string" select="'http://www.w3.org/2001/XMLSchema#'"/>
+                                <xsl:for-each select="'string', 'date', 'dateTime', 'time', 'integer', 'decimal', 'double', 'float', 'boolean', 'anyURI'">
+                                    <option value="{$xsd || .}">xsd:<xsl:value-of select="."/></option>
+                                </xsl:for-each>
+                                <option value="{$local:custom}">-- Custom datatype --</option>
+                            </select>
+                            <input type="text" name="custom-datatype" class="input-xlarge" placeholder="Datatype IRI" style="display: none;"/>
+                            <span class="help-block">Types the literal; mutually exclusive with a language tag</span>
+                        </div>
+                    </div>
+                    <div class="control-group">
+                        <label class="control-label">Language</label>
+                        <div class="controls">
+                            <input type="text" name="lang" class="input-small" placeholder="e.g. en, fr-CA"/>
+                            <span class="help-block">Language tag for the literal; ignored when a datatype is set</span>
+                        </div>
+                    </div>
+                </details>
+                <div class="form-actions">
+                    <button type="button" class="btn btn-danger remove-action" style="display: none;">Remove</button>
+                    <button type="button" class="btn btn-primary spo-action">Annotate</button>
+                    <button type="button" class="btn cancel-action">Cancel</button>
+                </div>
+            </form>
+        </div>
+    </xsl:template>
+
     <!-- TO-DO: phase out as regular ixsl: event templates -->
     <xsl:template match="fieldset//input" mode="ldh:RenderRowForm" priority="1">
         <!-- subject value change -->

From 7cbc2f2c3f307c1c0b3ba35ba52ace45b56fe375 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Tue, 28 Jul 2026 11:39:49 +0300
Subject: [PATCH 6/6] Refine RDFa editor LDH integration: CSS split, overlay
 id, modal structure, fieldset fix

- Remove host-UI sections (overlay + toolbar) from vendored rdfa-editor.css; host styles now live only in bootstrap.css
- Replace !important overlay overrides in bootstrap.css with clean rules scoped to #rdfa-editor-overlay; add full #edit-toolbar layout rules
- Parameterize overlay element id via $local:overlay-id in vendored overlay.xsl (matches upstream feature/ldh-integration-seams)
- Restructure RDFa Annotation dialog to follow LDH modal convention: div.modal > div.modal-header + div.modal-body; add label @for attributes
- Suppress fieldset border inside XHTML block edit form to avoid spurious outline around div.main in edit mode
- Mention in-place RDFa editing in README

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .gitignore                                    |   1 +
 README.md                                     |   2 +
 .../atomgraph/linkeddatahub/css/bootstrap.css |  18 +-
 .../linkeddatahub/css/rdfa-editor.css         | 341 ------------------
 .../xsl/bootstrap/2.3.2/client/form.xsl       | 121 ++++---
 .../linkeddatahub/xsl/rdfa-editor/overlay.xsl |  10 +-
 6 files changed, 82 insertions(+), 411 deletions(-)

diff --git a/.gitignore b/.gitignore
index b6d335aca..8c3f0b0e2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,3 +15,4 @@
 /http-tests/out
 /fuseki
 .claude/scheduled_tasks.lock
+/cli/target
diff --git a/README.md b/README.md
index b1f153c76..8198c5915 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,8 @@ We are building LinkedDataHub primarily for:
 
 What makes LinkedDataHub unique is its completely _data-driven architecture_: applications and documents are defined as data, managed using a single generic HTTP API and presented using declarative technologies. The default application structure and user interface are provided, but they can be completely overridden and customized. Unless a custom server-side processing is required, no imperative code such as Java or JavaScript needs to be involved at all.
 
+XHTML documents can be edited in-place using a built-in RDFa-aware rich text editor — annotations link selected text directly to Knowledge Graph terms, embedding machine-readable RDF statements in the markup without leaving the page.
+
 **Follow the [Get started](https://atomgraph.github.io/LinkedDataHub/linkeddatahub/docs/get-started/) guide to LinkedDataHub.** The setup and basic configuration sections are provided below and should get you running.
 
 **LinkedDataHub is also available as a free AWS Marketplace product!** <a href="https://aws.amazon.com/marketplace/pp/prodview-vqbeztc3f2nni" target="_blank"><img src="https://github.com/AtomGraph/LinkedDataHub/raw/master/AWS%20Marketplace.svg" width="160" alt="AWS Marketplace"/></a>  
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 86a396c21..f5464c7f4 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/bootstrap.css
@@ -153,12 +153,8 @@ h2.item-logo { background-image: url('../icons/file.svg'); background-position:
 .modal-footer { position: sticky; bottom: 0; background-color: white; z-index: 1060; }
 .modal-first-time-message { margin-left: 0; width: 80%; left: 10%; }
 .modal-first-time-message .hero-unit { margin-bottom: 0; }
-/* Annotation overlay — reset rdfa-editor.css visual overrides; .well provides base styling */
-#overlay { background: #f5f5f5 !important; background-image: none !important; border: 1px solid #e3e3e3 !important; border-radius: 4px !important; box-shadow: inset 0 1px 1px rgba(0,0,0,.05) !important; font-family: inherit !important; min-width: 360px !important; max-width: 520px !important; }
-#overlay form { padding: 0 !important; }
-#overlay .btn.btn-primary { background-color: #0088cc; background-image: linear-gradient(to bottom, #0088cc, #0044cc); color: #fff; border-color: #0044cc; }
-#overlay .btn.btn-danger { background-color: #da4f49; background-image: linear-gradient(to bottom, #ee5f5b, #bd362f); color: #fff; border-color: #bd362f; }
-#overlay .btn { font-family: inherit; }
+/* Annotation overlay */
+#rdfa-editor-overlay { position: absolute; min-width: 360px; max-width: 520px; z-index: 10001; }
 .control-group.endpoint-classes ul { max-height: 20em; overflow: auto; }
 .nav-tabs > li > a, .pager > li > a.active { cursor: pointer; }
 .pager > li.previous > a { text-align: right; font-size: 0; color: transparent; background-image: url('../icons/ic_navigate_before_black_24px.svg'); background-position: center center; background-repeat: no-repeat; width: 64px; height: 24px; }
@@ -191,6 +187,7 @@ div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"]:not(:has(form)) .ma
 div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"] .btn-edit { display: none; }
 div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"] .form-horizontal .control-label { display: none; }
 div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"] .form-horizontal .controls { margin-left: 0; }
+div[typeof="https://w3id.org/atomgraph/linkeddatahub#XHTML"] form fieldset { border: none; }
 .span12.progress .row-block-controls { background-color: #e9ecef; }
 .span12.progress .bar { height: 20px; }
 /* .content .btn.add-typeahead { margin-top: -10px; } */
@@ -222,5 +219,12 @@ object { display: block; margin: auto; max-height: 400px; overflow: hidden; widt
 circle { cursor: move; }
 /* RDFa editor specific */
 .editor-bar { position: sticky; top: calc(var(--action-bar-top, 51px) + 50px); z-index: 998; background: #dfdfdf; padding: 0; box-shadow: none; display: flex; align-items: center; }
-#edit-toolbar select { margin-top: auto; margin-bottom: auto; }
+#edit-toolbar { order: -1; margin-right: auto; display: flex; gap: 6px; align-items: center; }
+#edit-toolbar button, #edit-toolbar select { padding: 4px 8px; border: 1px solid #ccc; border-radius: 4px; background: white; font-size: 13px; font-family: inherit; cursor: pointer; margin-top: auto; margin-bottom: auto; }
+#edit-toolbar button:disabled { opacity: 0.4; cursor: default; }
+#edit-toolbar button:hover { background: #f5f5f5; }
+#edit-toolbar button[aria-pressed="true"] { background: #e3f0ff; border-color: #6aa3e0; color: #1a5fb4; }
+#edit-toolbar .tb-group { display: flex; gap: 6px; align-items: center; }
+#edit-toolbar .tb-group + .tb-group { border-left: 1px solid #e0e0e0; padding-left: 6px; }
+#edit-toolbar .tb-group.table-ops.active { background: #e3f0ff; border-radius: 4px; }
 .editor-bar:not(:has(#edit-toolbar)), body:not(:has(.rdfa-editor-content)) .editor-bar, body:not(:has(.rdfa-editor-content)) #rdfa-editor-breadcrumb { display: none; }
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/rdfa-editor.css b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/rdfa-editor.css
index 60aa7c40e..3bd7b8e3e 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/css/rdfa-editor.css
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/css/rdfa-editor.css
@@ -153,11 +153,6 @@
                 color: #757575;
             }
 
-#edit-toolbar button:disabled {
-                opacity: 0.4;
-                cursor: default;
-            }
-
 .rdfa-editor-content [contenteditable="true"]:focus {
                 outline: 2px solid rgba(33, 150, 243, 0.35);
                 outline-offset: 2px;
@@ -233,55 +228,6 @@
                 box-shadow: inset 0 0 0 2px #2196f3;
             }
 
-/* Editor toolbar (injected into the navbar) */
-            #edit-toolbar {
-                order: -1;
-                margin-right: auto;
-                display: flex;
-                gap: 6px;
-                align-items: center;
-            }
-
-#edit-toolbar select,
-            #edit-toolbar button {
-                padding: 6px 10px;
-                border: 1px solid #e0e0e0;
-                border-radius: 4px;
-                background: white;
-                font-size: 13px;
-                font-family: "Roboto", sans-serif;
-                cursor: pointer;
-            }
-
-#edit-toolbar button:hover {
-                background: #f5f5f5;
-            }
-
-/* Caret-contextual toggle state (aria-pressed toggle buttons) */
-            #edit-toolbar button[aria-pressed="true"] {
-                background: #e3f0ff;
-                border-color: #6aa3e0;
-                color: #1a5fb4;
-            }
-
-/* Functional groups: thin dividers between clusters, no labels */
-            #edit-toolbar .tb-group {
-                display: flex;
-                gap: 6px;
-                align-items: center;
-            }
-
-#edit-toolbar .tb-group + .tb-group {
-                border-left: 1px solid #e0e0e0;
-                padding-left: 6px;
-            }
-
-/* Table-ops cluster switches on when the caret is in a table */
-            #edit-toolbar .tb-group.table-ops.active {
-                background: #e3f0ff;
-                border-radius: 4px;
-            }
-
 /* Link / figure dialogs */
             .edit-dialog {
                 background: white;
@@ -597,293 +543,6 @@
                 margin-top: 8px;
             }
 
-/* Modern Overlay Styling */
-            #overlay {
-                background: linear-gradient(to bottom, #f8f9fa, #ffffff);
-                border: 2px solid #2196f3;
-                border-radius: 8px;
-                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
-                font-family: "Roboto", sans-serif;
-                min-width: 450px;
-                max-width: 500px;
-                z-index: 10000;
-            }
-
-.rdfa-editor-ui .overlay-header {
-                background: linear-gradient(135deg, #2196f3, #1976d2);
-                color: white;
-                padding: 16px 20px;
-                border-radius: 6px 6px 0 0;
-                box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-            }
-
-.rdfa-editor-ui .overlay-header h3 {
-                margin: 0 0 8px 0;
-                font-size: 18px;
-                font-weight: 500;
-            }
-
-#overlay form {
-                padding: 20px;
-            }
-
-/* Statement (S / P / O) framing */
-            .rdfa-editor-ui .statement {
-                display: grid;
-                grid-template-columns: 26px 1fr;
-                gap: 10px 12px;
-                align-items: center;
-                background: #e3f2fd;
-                border-radius: 6px;
-                padding: 14px 16px;
-                margin-bottom: 16px;
-            }
-
-.rdfa-editor-ui .stmt-role {
-                font-family: 'Courier New', monospace;
-                font-weight: bold;
-                font-size: 12px;
-                color: white;
-                background: #2196f3;
-                border-radius: 50%;
-                width: 24px;
-                height: 24px;
-                display: flex;
-                align-items: center;
-                justify-content: center;
-            }
-
-#stmt-subject {
-                font-family: 'Courier New', monospace;
-                font-size: 12px;
-                color: #1565c0;
-                word-break: break-all;
-            }
-
-/* Advanced fields disclosure */
-            #overlay details {
-                border: 1px solid #e0e0e0;
-                border-radius: 6px;
-                padding: 8px 16px;
-                margin-bottom: 16px;
-                background: white;
-            }
-
-#overlay summary {
-                cursor: pointer;
-                font-size: 13px;
-                font-weight: 500;
-                color: #757575;
-                padding: 4px 0;
-            }
-
-#overlay details fieldset {
-                margin-top: 12px;
-            }
-
-/* Fieldsets */
-            #overlay fieldset {
-                border: 1px solid #e0e0e0;
-                border-radius: 6px;
-                padding: 12px 16px;
-                margin-bottom: 16px;
-                background: white;
-            }
-
-#overlay label {
-                display: block;
-                font-weight: 500;
-                color: #424242;
-                margin-bottom: 8px;
-                font-size: 14px;
-            }
-
-#overlay input[type="text"],
-            #overlay select {
-                width: 100%;
-                padding: 10px 12px;
-                border: 1px solid #ccc;
-                border-radius: 4px;
-                font-size: 14px;
-                font-family: "Roboto", sans-serif;
-                transition: border-color 0.2s;
-                box-sizing: border-box;
-            }
-
-#overlay input[type="text"]:focus,
-            #overlay select:focus {
-                outline: none;
-                border-color: #2196f3;
-                box-shadow: 0 0 0 3px rgba(33, 150, 243, 0.1);
-            }
-
-#overlay input[type="text"]:disabled {
-                background-color: #f5f5f5;
-                color: #999;
-            }
-
-.rdfa-editor-ui .helper-text {
-                display: block;
-                font-size: 12px;
-                color: #757575;
-                margin-top: 6px;
-                font-style: italic;
-            }
-
-/* Action Buttons */
-            .rdfa-editor-ui .action-buttons {
-                display: flex;
-                gap: 12px;
-                margin-top: 20px;
-                justify-content: flex-end;
-            }
-
-.rdfa-editor-ui .btn-primary,
-            .rdfa-editor-ui .btn-secondary,
-            .rdfa-editor-ui .btn-danger {
-                padding: 10px 24px;
-                border: none;
-                border-radius: 4px;
-                font-size: 14px;
-                font-weight: 500;
-                cursor: pointer;
-                transition: all 0.2s;
-                font-family: "Roboto", sans-serif;
-            }
-
-.rdfa-editor-ui .btn-primary {
-                background: #4caf50;
-                color: white;
-            }
-
-.rdfa-editor-ui .btn-primary:hover {
-                background: #45a049;
-                box-shadow: 0 2px 8px rgba(76, 175, 80, 0.3);
-            }
-
-.rdfa-editor-ui .btn-secondary {
-                background: #f5f5f5;
-                color: #424242;
-                border: 1px solid #e0e0e0;
-            }
-
-.rdfa-editor-ui .btn-secondary:hover {
-                background: #e0e0e0;
-            }
-
-.rdfa-editor-ui .btn-danger {
-                background: #f44336;
-                color: white;
-                margin-right: auto;
-            }
-
-.rdfa-editor-ui .btn-danger:hover {
-                background: #d32f2f;
-                box-shadow: 0 2px 8px rgba(244, 67, 54, 0.3);
-            }
-
-#overlay input[name="custom-datatype"] {
-                margin-top: 8px;
-            }
-
-/* Typeahead lookups (property / type) */
-            .rdfa-editor-ui .typeahead-field {
-                position: relative;
-                display: block;
-            }
-
-.rdfa-editor-ui .typeahead-menu {
-                position: absolute;
-                top: 100%;
-                left: 0;
-                right: 0;
-                z-index: 10002;
-                margin: 2px 0 0 0;
-                padding: 4px;
-                list-style: none;
-                background: white;
-                border: 1px solid #e0e0e0;
-                border-radius: 6px;
-                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
-                max-height: 260px;
-                overflow-y: auto;
-            }
-
-.rdfa-editor-ui .typeahead-option {
-                display: flex;
-                align-items: baseline;
-                justify-content: space-between;
-                gap: 10px;
-                padding: 7px 10px;
-                border-radius: 4px;
-                font-size: 14px;
-                color: #212121;
-                cursor: pointer;
-            }
-
-/* children never intercept the mousedown, so the <li> is always the event target */
-            .rdfa-editor-ui .typeahead-option * {
-                pointer-events: none;
-            }
-
-.rdfa-editor-ui .typeahead-option:hover,
-            .rdfa-editor-ui .typeahead-option[aria-selected="true"] {
-                background: #e3f2fd;
-                color: #0d47a1;
-            }
-
-.rdfa-editor-ui .typeahead-option-label strong {
-                font-weight: 700;
-            }
-
-.rdfa-editor-ui .typeahead-option-uri {
-                flex: 0 1 auto;
-                min-width: 0;
-                overflow: hidden;
-                text-overflow: ellipsis;
-                white-space: nowrap;
-                font-size: 11px;
-                color: #9e9e9e;
-            }
-
-.rdfa-editor-ui .typeahead-value {
-                display: flex;
-                align-items: center;
-                gap: 8px;
-                width: 100%;
-                padding: 10px 12px;
-                border: 1px solid #ccc;
-                border-radius: 4px;
-                background: white;
-                font-size: 14px;
-                font-family: "Roboto", sans-serif;
-                text-align: left;
-                cursor: pointer;
-            }
-
-.rdfa-editor-ui .typeahead-value:hover {
-                border-color: #2196f3;
-            }
-
-.rdfa-editor-ui .typeahead-label {
-                flex: 1 1 auto;
-                overflow: hidden;
-                text-overflow: ellipsis;
-                white-space: nowrap;
-            }
-
-.rdfa-editor-ui .typeahead-clear {
-                flex: 0 0 auto;
-                color: #9e9e9e;
-                font-size: 16px;
-                line-height: 1;
-                padding: 0 2px;
-            }
-
-.rdfa-editor-ui .typeahead-clear:hover {
-                color: #f44336;
-            }
-
 /* Modal Dialog */
 #output-modal {
                 position: fixed;
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl
index ef22e5b57..16efb1b74 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/bootstrap/2.3.2/client/form.xsl
@@ -216,82 +216,85 @@ WHERE
 
     <!-- Bootstrap-styled annotation overlay (replaces rdfa-editor's custom HTML structure) -->
     <xsl:template name="local:render-overlay">
-        <div id="overlay" class="rdfa-editor-ui well" role="dialog" aria-modal="true" aria-label="RDFa annotation" style="display: none;">
+        <div id="{$local:overlay-id}" class="modal rdfa-editor-ui" role="dialog" aria-modal="true" aria-label="RDFa annotation" style="display: none;">
             <div class="modal-header">
-                <h3>RDFa Annotation</h3>
+                <button type="button" class="close cancel-action">&#215;</button>
+                <legend>RDFa Annotation</legend>
             </div>
-            <form id="annotation-form" class="form-horizontal">
-                <div class="control-group">
-                    <label class="control-label">Subject</label>
-                    <div class="controls">
-                        <div id="stmt-subject" class="uneditable-input"/>
-                    </div>
-                </div>
-                <div class="control-group">
-                    <label class="control-label">Property</label>
-                    <div class="controls">
-                        <xsl:sequence select="local:typeahead-field('property')"/>
-                    </div>
-                </div>
-                <div class="control-group">
-                    <label class="control-label">Value</label>
-                    <div class="controls">
-                        <input type="text" name="value" class="input-xlarge" placeholder="Literal value"/>
-                        <span class="help-block">The selected text; change to emit a machine-readable content value</span>
-                    </div>
-                </div>
-                <details id="advanced-fields">
-                    <summary>Type, subject &amp; object</summary>
+            <div class="modal-body">
+                <form id="annotation-form" class="form-horizontal">
                     <div class="control-group">
-                        <label class="control-label">Type (typeof)</label>
+                        <label class="control-label" for="stmt-subject">Subject</label>
                         <div class="controls">
-                            <xsl:sequence select="local:typeahead-field('typeof')"/>
-                            <span class="help-block">Types the annotated resource; without a subject the typed resource becomes the object of the property (chaining)</span>
+                            <div id="stmt-subject" class="uneditable-input"/>
                         </div>
                     </div>
                     <div class="control-group">
-                        <label class="control-label">Subject (about)</label>
+                        <label class="control-label" for="annotation-property">Property</label>
                         <div class="controls">
-                            <input type="text" name="subject" class="input-xlarge" placeholder="Overrides the subject in scope"/>
-                            <span class="help-block">IRI or _:blank-node identifier</span>
+                            <xsl:sequence select="local:typeahead-field('property')"/>
                         </div>
                     </div>
                     <div class="control-group">
-                        <label class="control-label">Object (resource)</label>
+                        <label class="control-label" for="annotation-value">Value</label>
                         <div class="controls">
-                            <input type="text" name="object" class="input-xlarge" placeholder="Object IRI"/>
-                            <span class="help-block">Makes the object a resource instead of the literal value</span>
+                            <input type="text" id="annotation-value" name="value" class="input-xlarge" placeholder="Literal value"/>
+                            <span class="help-block">The selected text; change to emit a machine-readable content value</span>
                         </div>
                     </div>
-                    <div class="control-group">
-                        <label class="control-label">Datatype</label>
-                        <div class="controls">
-                            <select name="datatype">
-                                <option value="">(plain literal)</option>
-                                <xsl:variable name="xsd" as="xs:string" select="'http://www.w3.org/2001/XMLSchema#'"/>
-                                <xsl:for-each select="'string', 'date', 'dateTime', 'time', 'integer', 'decimal', 'double', 'float', 'boolean', 'anyURI'">
-                                    <option value="{$xsd || .}">xsd:<xsl:value-of select="."/></option>
-                                </xsl:for-each>
-                                <option value="{$local:custom}">-- Custom datatype --</option>
-                            </select>
-                            <input type="text" name="custom-datatype" class="input-xlarge" placeholder="Datatype IRI" style="display: none;"/>
-                            <span class="help-block">Types the literal; mutually exclusive with a language tag</span>
+                    <details id="advanced-fields">
+                        <summary>Type, subject &amp; object</summary>
+                        <div class="control-group">
+                            <label class="control-label" for="annotation-typeof">Type (typeof)</label>
+                            <div class="controls">
+                                <xsl:sequence select="local:typeahead-field('typeof')"/>
+                                <span class="help-block">Types the annotated resource; without a subject the typed resource becomes the object of the property (chaining)</span>
+                            </div>
                         </div>
-                    </div>
-                    <div class="control-group">
-                        <label class="control-label">Language</label>
-                        <div class="controls">
-                            <input type="text" name="lang" class="input-small" placeholder="e.g. en, fr-CA"/>
-                            <span class="help-block">Language tag for the literal; ignored when a datatype is set</span>
+                        <div class="control-group">
+                            <label class="control-label" for="annotation-subject">Subject (about)</label>
+                            <div class="controls">
+                                <input type="text" id="annotation-subject" name="subject" class="input-xlarge" placeholder="Overrides the subject in scope"/>
+                                <span class="help-block">IRI or _:blank-node identifier</span>
+                            </div>
+                        </div>
+                        <div class="control-group">
+                            <label class="control-label" for="annotation-object">Object (resource)</label>
+                            <div class="controls">
+                                <input type="text" id="annotation-object" name="object" class="input-xlarge" placeholder="Object IRI"/>
+                                <span class="help-block">Makes the object a resource instead of the literal value</span>
+                            </div>
+                        </div>
+                        <div class="control-group">
+                            <label class="control-label" for="annotation-datatype">Datatype</label>
+                            <div class="controls">
+                                <select id="annotation-datatype" name="datatype">
+                                    <option value="">(plain literal)</option>
+                                    <xsl:variable name="xsd" as="xs:string" select="'http://www.w3.org/2001/XMLSchema#'"/>
+                                    <xsl:for-each select="'string', 'date', 'dateTime', 'time', 'integer', 'decimal', 'double', 'float', 'boolean', 'anyURI'">
+                                        <option value="{$xsd || .}">xsd:<xsl:value-of select="."/></option>
+                                    </xsl:for-each>
+                                    <option value="{$local:custom}">-- Custom datatype --</option>
+                                </select>
+                                <input type="text" name="custom-datatype" class="input-xlarge" placeholder="Datatype IRI" style="display: none;"/>
+                                <span class="help-block">Types the literal; mutually exclusive with a language tag</span>
+                            </div>
+                        </div>
+                        <div class="control-group">
+                            <label class="control-label" for="annotation-lang">Language</label>
+                            <div class="controls">
+                                <input type="text" id="annotation-lang" name="lang" class="input-small" placeholder="e.g. en, fr-CA"/>
+                                <span class="help-block">Language tag for the literal; ignored when a datatype is set</span>
+                            </div>
                         </div>
+                    </details>
+                    <div class="form-actions modal-footer">
+                        <button type="button" class="btn btn-danger remove-action" style="display: none;">Remove</button>
+                        <button type="button" class="btn btn-primary spo-action">Annotate</button>
+                        <button type="button" class="btn cancel-action">Cancel</button>
                     </div>
-                </details>
-                <div class="form-actions">
-                    <button type="button" class="btn btn-danger remove-action" style="display: none;">Remove</button>
-                    <button type="button" class="btn btn-primary spo-action">Annotate</button>
-                    <button type="button" class="btn cancel-action">Cancel</button>
-                </div>
-            </form>
+                </form>
+            </div>
         </div>
     </xsl:template>
 
diff --git a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/overlay.xsl b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/overlay.xsl
index ec4226c7c..7917da059 100644
--- a/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/overlay.xsl
+++ b/src/main/webapp/static/com/atomgraph/linkeddatahub/xsl/rdfa-editor/overlay.xsl
@@ -11,6 +11,8 @@ version="3.0">
 
     <!-- select value marking the free-text custom-IRI state ('' means none/unset) -->
     <xsl:variable name="local:custom" as="xs:string" select="'urn:rdfa-editor:custom'"/>
+    <!-- id of the annotation overlay element; host UIs may shadow this variable -->
+    <xsl:variable name="local:overlay-id" as="xs:string" select="'rdfa-editor-overlay'"/>
 
 <!--
     The annotation overlay: rendered once at startup (hidden), then only populated,
@@ -30,7 +32,7 @@ version="3.0">
     </xsl:template>
 
     <xsl:template name="local:render-overlay">
-        <div id="overlay" class="rdfa-editor-ui" role="dialog" aria-modal="true" aria-label="RDFa annotation" style="display: none;">
+        <div id="{$local:overlay-id}" class="rdfa-editor-ui" role="dialog" aria-modal="true" aria-label="RDFa annotation" style="display: none;">
             <div class="overlay-header">
                 <h3>RDFa Annotation</h3>
             </div>
@@ -256,7 +258,7 @@ version="3.0">
         <xsl:param name="in-scope-subject" as="xs:string?" select="()"/>
 
         <xsl:call-template name="local:show-at">
-            <xsl:with-param name="element" select="id('overlay', ixsl:page())"/>
+            <xsl:with-param name="element" select="id($local:overlay-id, ixsl:page())"/>
             <xsl:with-param name="event" select="$event"/>
         </xsl:call-template>
 
@@ -297,7 +299,7 @@ version="3.0">
     <!-- single teardown point: hiding the overlay always clears the interaction state -->
     <xsl:template name="local:hide-overlay">
         <xsl:call-template name="local:hide-selection-hint"/>
-        <xsl:for-each select="id('overlay', ixsl:page())">
+        <xsl:for-each select="id($local:overlay-id, ixsl:page())">
             <ixsl:set-style name="display" select="'none'"/>
         </xsl:for-each>
         <ixsl:set-property name="editingSpan" select="()" object="local:editor-state()"/>
@@ -310,7 +312,7 @@ version="3.0">
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template match="div[@id = 'overlay']" mode="ixsl:onkeydown">
+    <xsl:template match="div[@id = $local:overlay-id]" mode="ixsl:onkeydown">
         <xsl:if test="string(ixsl:get(ixsl:event(), 'key')) = 'Escape'">
             <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:call-template name="local:hide-overlay"/>