From 0496acfbb86a8f80dfbaad61783918e8f2bf72c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Mon, 13 Jul 2026 11:24:23 +0300
Subject: [PATCH 1/2] Embed LDH's RDF-defined blocks as atomic RDFa islands

Blocks defined purely in RDF (ldh:View, ldh:ResultSetChart, ldh:Object)
can now live wherever the content model admits a div, per the LDH v6
document format: a div[@about][@typeof] block element with its
definition triples as span[@property] children (objects via @resource,
literals as span text) - no wrappers, no rdf:_N sequences, no
document-to-block containment edges. The editor treats such a div as an
atomic island: never a text host, focusable/navigable/deletable like a
block image (shared local:select-island doctrine, undo/redo chords
included), a hard boundary for merges (merge-host-in gains a
tail-island guard - islands hold no hosts, the lookup would leapfrog
them) and for the delete machine (clamped-range moves boundaries out of
islands, so they join selections whole and are only ever removed
whole), and byte-identical on round-trip: the visual rendering is
injected into an ephemeral div[data-role=rendering] child by the
overridable mode="local:render-island" hook and stripped at
canonicalization.

The core (new src/blocks.xsl: $object-block-types param, the
local:island predicate, the render hook + neutral card, extension
stubs) knows no LDH vocabulary. The LDH extension (src/ldh-blocks.xsl,
layered by the src/ldh-editor.xsl entry via xsl:import) supplies the
class list, async renderers - ixsl:promise/ixsl:http-request chains
fetching the referenced documents by content negotiation on clean
trailing-slash URIs (no file extensions anywhere; serve.mjs replaces
python http.server and negotiates rdf+xml / sparql-results+xml
representations) - and the Block... insert dialog wired into the slash
menu and toolbar through the new hook points. In production
LinkedDataHub, client.xsl plays the extension's role, bridging the hook
into its block rendering (MIGRATION.md par. 12).

Two build flavors: the core SEF (dist/index.xsl.sef.json) is what
GitHub Pages deploys - Pages cannot content-negotiate, so the
LDH-extended SEF (dist/ldh-editor.xsl.sef.json) and the demo/ showcase
page stay local-only. New coverage: extractor/canonical/lint fixtures
for the storage form, tests/browser/blocks.mjs against
tests/fixture-blocks.html (hydration, round-trip, navigation,
boundaries, dialog insertion top-level and nested, stage-2/sweep
atomicity, canonical copy, undo); fixture-nesting.html runs the
extended SEF so every core suite doubles as proof the extension layers
non-invasively.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .github/workflows/deploy-pages.yml            |   4 +
 CLAUDE.md                                     |  26 +-
 LDH-BLOCKS-PLAN.md                            | 181 +++++++
 Makefile                                      |   4 +-
 README.md                                     |  20 +-
 demo/index.html                               | 121 +++++
 demo/queries/population/index.rdf             |  19 +
 demo/queries/population/results.xml           |  29 +
 demo/resources/ada/index.rdf                  |  14 +
 docs/ldh/MIGRATION.md                         |  78 +++
 generate-sef.sh                               |  17 +-
 rdfa-editor.css                               |  28 +
 serve.mjs                                     |  53 ++
 src/blocks.xsl                                | 103 ++++
 src/edit.xsl                                  | 174 ++++--
 src/index.xsl                                 |   2 +
 src/input.xsl                                 |  12 +-
 src/ldh-blocks.xsl                            | 504 ++++++++++++++++++
 src/ldh-editor.xsl                            |  20 +
 src/select.xsl                                |  35 +-
 src/undo.xsl                                  |   6 +
 tests/browser/blocks.mjs                      | 311 +++++++++++
 tests/browser/notion.mjs                      |   8 +-
 tests/browser/run.mjs                         |  32 +-
 tests/expected/14-ldh-block-island.rdf        |  21 +
 .../canonical/23-ldh-block-placeholder.xhtml  |  16 +
 tests/expected/lint/09-ldh-block-clean.txt    |   0
 tests/fixture-blocks.html                     |  62 +++
 tests/fixture-nesting.html                    |   2 +-
 tests/fixtures/14-ldh-block-island.xhtml      |  20 +
 .../canonical/23-ldh-block-placeholder.xhtml  |  24 +
 tests/fixtures/lint/09-ldh-block-clean.xhtml  |  18 +
 32 files changed, 1878 insertions(+), 86 deletions(-)
 create mode 100644 LDH-BLOCKS-PLAN.md
 create mode 100644 demo/index.html
 create mode 100644 demo/queries/population/index.rdf
 create mode 100644 demo/queries/population/results.xml
 create mode 100644 demo/resources/ada/index.rdf
 create mode 100644 serve.mjs
 create mode 100644 src/blocks.xsl
 create mode 100644 src/ldh-blocks.xsl
 create mode 100644 src/ldh-editor.xsl
 create mode 100644 tests/browser/blocks.mjs
 create mode 100644 tests/expected/14-ldh-block-island.rdf
 create mode 100644 tests/expected/canonical/23-ldh-block-placeholder.xhtml
 create mode 100644 tests/expected/lint/09-ldh-block-clean.txt
 create mode 100644 tests/fixture-blocks.html
 create mode 100644 tests/fixtures/14-ldh-block-island.xhtml
 create mode 100644 tests/fixtures/canonical/23-ldh-block-placeholder.xhtml
 create mode 100644 tests/fixtures/lint/09-ldh-block-clean.xhtml

diff --git a/.github/workflows/deploy-pages.yml b/.github/workflows/deploy-pages.yml
index 37a0f5d..0ec0a48 100644
--- a/.github/workflows/deploy-pages.yml
+++ b/.github/workflows/deploy-pages.yml
@@ -27,6 +27,10 @@ jobs:
                   mkdir -p _site
                   cp index.html rdfa-editor.css _site/
                   cp -r lib dist vocabs _site/
+                  # core editor only: the LinkedDataHub-extended flavor (demo/ +
+                  # its SEF) needs the content-negotiating dev server (serve.mjs)
+                  # and is never deployed to Pages
+                  rm -f _site/dist/ldh-editor.xsl.sef.json
             - name: Publish to gh-pages branch
               uses: peaceiris/actions-gh-pages@v4
               with:
diff --git a/CLAUDE.md b/CLAUDE.md
index c064720..859f7d3 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -13,25 +13,29 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Overview
 
-RDFa-Editor is a prototype XHTML+RDFa authoring tool using client-side XSLT. Content lives in a `#content` container of structured blocks (p, h1–h3, ul/ol, blockquote, pre, figure, table), always editable Notion-style: typing within blocks, Enter splits, Backspace-at-start merges, toolbar for block types / inline formatting / lists / figures / tables / links, drag-handle reordering, a `/` slash menu (in an empty block) and markdown shortcuts (`# `, `- `, `1. `, `> `, ` ``` `) that insert/convert blocks per the content model. Nesting follows the **XHTML Strict content model** (see content-model.xsl below): `blockquote` is a block *container* (`blockquote > p+` — bare text inside it is invalid and gets normalized; the toolbar quote toggle wraps/unwraps), `li`/`td`/`th`/`dd`/`figcaption` are `%Flow;` (mixed text AND nested blocks — Tab/Shift+Tab indent/outdent nested lists), `p`/`h1–h6`/`caption`/`dt` are inline-only. Tables are composite blocks (structure locked; `td`/`th`/`caption` editable) inserted via a rows×cols dialog with an optional header row and caption; row/column toolbar controls, Tab/Shift+Tab cell traversal and Enter (step down a column) all grow the grid at its bottom edge. Right-click a text selection to annotate it with RDFa; right-click an existing annotation to edit or remove it. "Extract RDF" shows the page's triples; "Source" shows the canonical XHTML+RDFa serialization (all editing ephemera stripped).
+RDFa-Editor is a prototype XHTML+RDFa authoring tool using client-side XSLT. Content lives in a `#content` container of structured blocks (p, h1–h3, ul/ol, blockquote, pre, figure, table), always editable Notion-style: typing within blocks, Enter splits, Backspace-at-start merges, toolbar for block types / inline formatting / lists / figures / tables / links, drag-handle reordering, a `/` slash menu (in an empty block) and markdown shortcuts (`# `, `- `, `1. `, `> `, ` ``` `) that insert/convert blocks per the content model. **Object blocks** (blocks.xsl) embed RDF-defined blocks per the LDH v6 document format (`XHTML-RDFa-as-LDH-v6-Document-Format` wiki) — a `div[@about][@typeof]` whose `@typeof` matches the `$object-block-types` param, its defining triples inline as `span[@property]` children — treated as **atomic islands** (never editable inside, focusable/navigable/deletable like block images, hard merge/delete boundaries) and rendered client-side into an ephemeral `div[@data-role='rendering']` child via the overridable `mode="local:render-island"` hook; the LinkedDataHub extension (ldh-blocks.xsl, layered by the ldh-editor.xsl entry via `xsl:import`) supplies `ldh:Object`/`ldh:View`/`ldh:ResultSetChart` renderers, an insert dialog and slash/toolbar contributions. Nesting follows the **XHTML Strict content model** (see content-model.xsl below): `blockquote` is a block *container* (`blockquote > p+` — bare text inside it is invalid and gets normalized; the toolbar quote toggle wraps/unwraps), `li`/`td`/`th`/`dd`/`figcaption` are `%Flow;` (mixed text AND nested blocks — Tab/Shift+Tab indent/outdent nested lists), `p`/`h1–h6`/`caption`/`dt` are inline-only. Tables are composite blocks (structure locked; `td`/`th`/`caption` editable) inserted via a rows×cols dialog with an optional header row and caption; row/column toolbar controls, Tab/Shift+Tab cell traversal and Enter (step down a column) all grow the grid at its bottom edge. Right-click a text selection to annotate it with RDFa; right-click an existing annotation to edit or remove it. "Extract RDF" shows the page's triples; "Source" shows the canonical XHTML+RDFa serialization (all editing ephemera stripped).
 
 ## Architecture
 
-XSLT 3.0 running on **SaxonJS 3** with its interactive extensions (`ixsl:` namespace). `index.html` loads `lib/SaxonJS3.js` and executes `dist/index.xsl.sef.json` (initial template `main`). The editor UI is fully generated by the stylesheet — the overlay is rendered once at startup (hidden) and only populated/shown/hidden afterwards, so the stylesheet is self-contained and embeddable on any host page.
+XSLT 3.0 running on **SaxonJS 3** with its interactive extensions (`ixsl:` namespace). `index.html` loads `lib/SaxonJS3.js` and executes `dist/index.xsl.sef.json` (initial template `main`); async work uses the **SaxonJS 3 promise API** (`ixsl:promise` + `ixsl:http-request` `=> ixsl:then`, `on-failure`; DOM-mutating callbacks are `ixsl:updating="yes"` functions) — **never the legacy `ixsl:schedule-action`**. The editor UI is fully generated by the stylesheet — the overlay is rendered once at startup (hidden) and only populated/shown/hidden afterwards, so the stylesheet is self-contained and embeddable on any host page.
+
+Two build flavors: **core** (`src/index.xsl` → `dist/index.xsl.sef.json`, deployed to GitHub Pages — `deploy-pages.yml` excludes the LDH artifacts) and **LDH-extended** (`src/ldh-editor.xsl` → `dist/ldh-editor.xsl.sef.json`, used by `demo/index.html` and the browser fixtures — local only, its object blocks need the content-negotiating dev server).
 
 Modules under `src/`:
 
-- **index.xsl** — entry point: `$vocab-hrefs` param, `main` template (async vocabulary prefetch via `ixsl:schedule-action/@document`, then overlay init), `local:document-uri()`.
+- **index.xsl** — the core entry point: `main` template (fully synchronous — the host page preloads the vocabularies into the SaxonJS `documentPool` keyed by page-relative URI, see index.html), editor-state container init, `local:editor-state()`; the module include list.
 - **RDFa2RDFXML-v3.xsl** — RDFa 1.1 → RDF/XML extraction. **Pure XSLT, no `ixsl:`** — it runs headless via `xslt3` for the test suite. Strictly W3C-conformant (RDFa 1.1 processing rules, section 7.5, including chaining via typed resources and `rdfa:usesVocabulary`). Covers `@about`/`@typeof`/`@property`/`@content`/`@datatype`/`@resource`/`@href`/`@src`/`@prefix` (and `xmlns:*`)/`@vocab` with bare terms, `@lang`+`@xml:lang` inheritance, base-URI resolution (`about=""` = the document, `<base href>` honored), and exclusion of `head`/`script`/`style`/`[data-role='rendering']` subtrees. Out of scope (documented future work): `@rel`/`@rev`, `@inlist`, safe CURIEs, `@datetime`/`<time>`, `xml:base`.
 - **content-model.xsl** — the XHTML content model as data. **Pure XSLT, include-free** (no dependencies; `index.xsl` includes it once, before its consumers): a 1:1 transcription of the XHTML 1.0 Strict DTD (Second Edition, Appendix A.1 entities + element declarations) and the Appendix B prohibitions, extended with HTML5 `figure`/`figcaption`. `$cm:model` (element → allowed children + `#PCDATA` flag), `$cm:prohibitions`, predicates `cm:known`/`cm:block`/`cm:inline`/`cm:allows-child`/`cm:allows-text`/`cm:inline-only`/`cm:flow`/`cm:structural`/`cm:valid-nesting`. The **single source of truth** for nesting: editability init and keyboard machines (edit.xsl), boundary normalization (canonical-xhtml.xsl) and nesting lint (lint-xhtml.xsl) all consult it, so verdicts can't drift. `$cm:model` is built with `map:merge`+`map:entry` — the SaxonJS compiler fails an internal assertion on large nested map literals. The editor contract "region children are blocks" is deliberately NOT in this module.
 - **vocab.xsl** — generic ontology RDF/XML → dropdown options. Handles typed elements (`<owl:Class rdf:about>`) and `rdf:Description`+`rdf:type` shapes (including striped one-triple-per-description files like DCMI terms); labels as attributes or child elements; terms outside the ontology namespace filtered out.
 - **overlay.xsl** — the annotation form (single copy), form reading (`local:form-values` map), pre-filling (`local:populate-form`), show/hide with viewport clamping (`local:show-at`, shared with the edit dialogs).
 - **annotate.xsl** — the unified right-click dispatcher (edit vs create), `local:apply-annotation` (single write path for RDFa attributes), shared `local:wrap-range`/`local:unwrap-element` (used by annotations AND inline formatting), invalid-selection flash, the shared output modal (`local:show-output`).
-- **edit.xsl** — the XHTML editor. **Recursive editability init** (`local:init-block`): an element is a *text host* (contenteditable) while its content model allows text and it 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 (`figure` is always composite: image island + caption host); `img` never editable but given `tabindex="-1"` so a block image is a focusable **navigation island**. **Run wrappers**: the stray inline runs of a mixed flow container (`<li>text<ul>…</ul></li>`) get an ephemeral `p.rdfa-editor-run` host (`local:wrap-stray-runs`) so they stay editable — unwrapped again at canonicalization (C11), so mixed content round-trips byte-identical; structural gestures promote a wrapper to a real paragraph. **Load-init normalization**: each region is probed for invalid nesting (`cm:valid-nesting`, stray text in structural containers, stray region-level inline) and rebuilt through `mode="cm-normalize"` only when invalid (the valid case is zero-churn; host-page node references into a rewritten region go stale, same as undo restore). First-child chrome injection is a **top-level-only** affordance (`span[@data-role='chrome']`, hover-revealed via CSS) — nested hosts never carry drag handles. The Enter/Backspace state machine (split/merge primitives with explicit caret placement): splitting a run wrapper *promotes* it (marker class off); E4a — Enter on the empty last item of a *nested* list outdents one level (progressive), E4b — top-level exits to a paragraph; B2 merges text blocks, B2b descends into a preceding non-composite container's (blockquote/list) last host — bare text in the container itself would be invalid — while tables/figures stay hard boundaries (B3); B4 merges an `li` into the *visually preceding line* (`local:merge-host-in` — the last host of the previous item, unless it sits inside a nested table/figure: composites are hard boundaries at any depth, the gesture stays inert), B4b outdents the first item of a nested list, B4c merges the first item of a container-nested list (cell, quote, dd) into the preceding line inside the container — dissolving the emptied list and collapsing the container back to a text host — B7 exits the first block of a blockquote upward (emptied quote removed); E4b anchors the list-exit paragraph *before* removal, so it lands where the list was (inside the cell/quote for nested lists); E6 anchors the caption-exit paragraph after the figure/table itself (which may be nested). **Ancestor walks clamp at the region root** (`[exists(local:block-of(.))]` on `local:item-of`, the Tab cell lookup and the quote-toggle's blockquote lookup) — a host-page li/td/blockquote wrapping an embedded region is never touched. A focused image island deletes its *figure* when it has one, else just the image — never the whole containing list/table. **Tab/Shift+Tab** indent/outdent list items (`local:list-indent`/`local:list-outdent`: indent moves the item into a trailing-or-fresh nested list *inside the previous item* per `ul → (li)+`; outdent moves it after the container item, demoting followers into a nested list inside it; `local:collapse-container` reverts an emptied container to a text host; extremes flash) — the innermost context wins over table-cell traversal (li-in-td indents, a table nested in an item traverses). The **quote toggle** (`format-quote`) wraps the current host block in a `blockquote` where the parent admits one / unwraps all children out (refused with a flash when the quote carries RDFa — triples would drop); the block-type select is **host-based** (`local:current-host`): a paragraph inside a quote converts alone, non-convertible hosts disable it. The **insert buttons** (+¶, lists) place the new block per the content model (`local:insert-block-at-caret`): after the caret's host when its parent admits the kind, *inside* a leaf flow host otherwise (a list inserted in a cell nests in the cell; in a list item it becomes a sublist), after the top-level block as a last resort. **Paste** is cm-driven: clipboard HTML runs `mode="canonical"` + `mode="cm-normalize"`, then blocks land *inside* a mixed flow host (`local:paste-into-flow-host` — head/tail runs wrapped, host re-inited as container), or as siblings of an inline-only host via split-and-thread (when `cm:allows-child` permits), or flatten to text (caption, dt). Drag-and-drop ported from LinkedDataHub's `client/block.xsl` (handle-gated `draggable`, midpoint before/after marks). Arrow-key block crossing walks `local:nav-targets` (editable hosts **plus** block images, in document order): a host gets a caret, an image is *selected* (`local:select-image` focuses it, clearing the caret) — so images are never skipped; on a selected image, arrows step to the adjacent target and Backspace/Delete removes the whole figure (no confirm, undo-covered). Table cell keys (Tab/Enter) and the table dialog live in **tables.xsl**.
+- **edit.xsl** — the XHTML editor. **Recursive editability init** (`local:init-block`): an element is a *text host* (contenteditable) while its content model allows text and it 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 (`figure` is always composite: image island + caption host); `img` never editable but given `tabindex="-1"` so a block image is a focusable **navigation island**; an **object block** (`local:island`, FIRST branch of the choose — a flow div with span children would otherwise become a text host / get its spans run-wrapped) is locked whole, given `tabindex="-1"` + the `rdfa-editor-island` marker class and rendered via the hook when it has no rendering div. **Run wrappers**: the stray inline runs of a mixed flow container (`<li>text<ul>…</ul></li>`) get an ephemeral `p.rdfa-editor-run` host (`local:wrap-stray-runs`) so they stay editable — unwrapped again at canonicalization (C11), so mixed content round-trips byte-identical; structural gestures promote a wrapper to a real paragraph. **Load-init normalization**: each region is probed for invalid nesting (`cm:valid-nesting`, stray text in structural containers, stray region-level inline) and rebuilt through `mode="cm-normalize"` only when invalid (the valid case is zero-churn; host-page node references into a rewritten region go stale, same as undo restore). First-child chrome injection is a **top-level-only** affordance (`span[@data-role='chrome']`, hover-revealed via CSS) — nested hosts never carry drag handles. The Enter/Backspace state machine (split/merge primitives with explicit caret placement): splitting a run wrapper *promotes* it (marker class off); E4a — Enter on the empty last item of a *nested* list outdents one level (progressive), E4b — top-level exits to a paragraph; B2 merges text blocks, B2b descends into a preceding non-composite container's (blockquote/list) last host — bare text in the container itself would be invalid — while tables/figures/islands stay hard boundaries (B3; an empty host removed before an island *selects* the island — no host to land in); B4 merges an `li` into the *visually preceding line* (`local:merge-host-in` — the last host of the previous item, unless it sits inside a nested table/figure/island OR an island follows it at the container's tail (islands hold no hosts, the lookup would leapfrog them): composites are hard boundaries at any depth, the gesture stays inert), B4b outdents the first item of a nested list, B4c merges the first item of a container-nested list (cell, quote, dd) into the preceding line inside the container — dissolving the emptied list and collapsing the container back to a text host — B7 exits the first block of a blockquote upward (emptied quote removed); E4b anchors the list-exit paragraph *before* removal, so it lands where the list was (inside the cell/quote for nested lists); E6 anchors the caption-exit paragraph after the figure/table itself (which may be nested). **Ancestor walks clamp at the region root** (`[exists(local:block-of(.))]` on `local:item-of`, the Tab cell lookup and the quote-toggle's blockquote lookup) — a host-page li/td/blockquote wrapping an embedded region is never touched. A focused image island deletes its *figure* when it has one, else just the image — never the whole containing list/table. **Tab/Shift+Tab** indent/outdent list items (`local:list-indent`/`local:list-outdent`: indent moves the item into a trailing-or-fresh nested list *inside the previous item* per `ul → (li)+`; outdent moves it after the container item, demoting followers into a nested list inside it; `local:collapse-container` reverts an emptied container to a text host; extremes flash) — the innermost context wins over table-cell traversal (li-in-td indents, a table nested in an item traverses). The **quote toggle** (`format-quote`) wraps the current host block in a `blockquote` where the parent admits one / unwraps all children out (refused with a flash when the quote carries RDFa — triples would drop); the block-type select is **host-based** (`local:current-host`): a paragraph inside a quote converts alone, non-convertible hosts disable it. The **insert buttons** (+¶, lists) place the new block per the content model (`local:insert-block-at-caret`): after the caret's host when its parent admits the kind, *inside* a leaf flow host otherwise (a list inserted in a cell nests in the cell; in a list item it becomes a sublist), after the top-level block as a last resort. **Paste** is cm-driven: clipboard HTML runs `mode="canonical"` + `mode="cm-normalize"`, then blocks land *inside* a mixed flow host (`local:paste-into-flow-host` — head/tail runs wrapped, host re-inited as container), or as siblings of an inline-only host via split-and-thread (when `cm:allows-child` permits), or flatten to text (caption, dt). Drag-and-drop ported from LinkedDataHub's `client/block.xsl` (handle-gated `draggable`, midpoint before/after marks). Arrow-key block crossing walks `local:nav-targets` (editable hosts **plus** block images **plus** object-block islands, in document order; nothing inside an island or ephemeral subtree is a stop): a host gets a caret, an image/island is *selected* (`local:select-island` focuses it, clearing the caret) — so islands are never skipped; on a selected island, arrows step to the adjacent target, Backspace/Delete removes the unit whole (an image goes with its figure, an object block deletes itself; no confirm, undo-covered) and **undo/redo chords work too** (the island keydown template intercepts them — host/body templates don't fire with focus on an island). Table cell keys (Tab/Enter) and the table dialog live in **tables.xsl**.
+- **blocks.xsl** — the generic **object-block (island) machinery**, zero LDH knowledge: `$object-block-types` (absolute class IRIs, default EMPTY — re-declared at higher import precedence by an extension entry; a same-precedence duplicate is XTSE0630), THE island predicate `local:island($e)` (`div` whose `tokenize(@typeof)` hits the param — every island decision in init/nav/boundaries/delete-machine/undo routes through it), the render hook `mode="local:render-island"` (context item = the island div; contract: inject exactly ONE `div[@data-role='rendering']` as last child via `local:replace-rendering` — async renderers only in the completion callback, loading state = ephemeral `rdfa-editor-loading` class, so "no rendering div" always means "render needed" and the undo-restore re-render pass keys on that; never touch the spans; never push undo; idempotent), the neutral default card, and the empty extension hook stubs `local:render-extra-dialogs`/`-insert-buttons`/`-slash-items`, `local:run-extra-slash-command` (called from edit.xsl's init/toolbar and input.xsl's slash menu). All modules share `xmlns:local="urn:rdfa-editor:functions"`, so import precedence overrides `local:*` declarations across stylesheets.
+- **ldh-blocks.xsl** + **ldh-editor.xsl** — the LinkedDataHub extension and its entry (`<xsl:import href="index.xsl"/>` + `<xsl:include href="ldh-blocks.xsl"/>` — core at lower precedence; the same layering shape LDH's client.xsl uses, MIGRATION.md §10/§12). The extension re-declares `$object-block-types` (`ldh:Object`/`ldh:View`/`ldh:ResultSetChart`), provides per-type `mode="local:render-island"` renderers — promise chains fetching the referenced document by **content negotiation on the clean trailing-slash URI** (`Accept: application/rdf+xml` for the description; as a demo stand-in for live SPARQL, `Accept: application/sparql-results+xml` on a query document returns canned results; serve.mjs / tests/browser/run.mjs negotiate; **no file extensions in any URL**) — plus the `#ldh-block-dialog` insert dialog (opts into teardown via the `edit-dialog` class), the ▦ toolbar button and the "Block…" slash item. In production LDH, client.xsl plays this module's role, bridging `local:render-island` into its block rendering (v6 mode `ldh:Block`; the v5 `ldh:RenderRow` bridge is worked through in MIGRATION.md §12).
 - **tables.xsl** — table blocks as a composite kind: the insert dialog (rows×cols + header-row + caption, modeled on the figure dialog), positional row/column operations (`local:op-insert-row`/`-column`, `-delete-row`/`-column`) gated behind `local:has-spans` (disabled on pasted `colspan`/`rowspan` grids — positional edits would corrupt a spanned table) and toolbar-synced via `local:sync-table-toolbar` riding `local:update-breadcrumb`, plus `local:table-tab`/`local:table-enter` cell traversal that appends a body row at the bottom edge. Cells are `%Flow;` containers: every caret landing resolves through `local:first-host-in`/`local:last-host-in`, so a cell holding blocks lands the caret in its first/last editable host; the Tab dispatcher (edit.xsl) passes the *cell* as the traversal host even when the caret sits in a nested block. Deleting the last body row/column is a no-op — the confirm-guarded delete-block button removes the whole table. **Undo hazard:** a chrome `span` serialized as a direct child of `<table>` is foster-parented out by the HTML fragment parser on `innerHTML` restore, so `local:restore-snapshot` drops stray region-child chrome and re-injects (idempotent) before caret resolution.
-- **select.xsl** — the Docs-style selection gesture layer, region-scoped select-all and cross-host selection delete (keyboard dispatch lives in edit.xsl's keydown/body/paste templates, mirroring the tables.xsl split; the mouse gesture templates live here). **The browser confines a native drag-selection to the host it starts in** (even background-origin drags clamp on the first host entered), so cross-block selection is **synthesized**: mousedown in a region arms a sweep anchor (`local:caret-at-point` — `caretRangeFromPoint`, `caretPositionFromPoint` fallback; chrome positions escape to just after the chrome); once the pointer leaves the anchor host, each `body|html` mousemove rebuilds the selection anchor→pointer via `setBaseAndExtent` — the only Selection API that can express a **backward selection** (upward drags keep the anchor fixed) — with the focus clamped into the anchor's region (`local:clamp-focus-to-region`, `comparePoint`-based) and a viewport nudge near its edges (native autoscroll dies with the takeover); in-host moves stay native. Mouseup disarms (innermost-match dispatch: the host/drag-handle mouseup templates disarm on their paths, `body|html` catches background ends) and `ondragstart` disarms defensively; a press on the drag handle never reaches the arm template. **Shift+Click** extends from the standing selection anchor to the clicked point (preventDefault keeps the anchor; re-arms so Shift+drag keeps extending; repeated Shift+Clicks share the anchor). **Shift+Up/Down** extend block-granularly past host edges (`local:shift-arrow-extends` gates: cross-host selection, or focus at the host edge facing the arrow — probed from the *focus*, not the range end; `local:extend-selection-block-wise` steps the focus between region-level child positions, whole blocks and composites as units, flipping direction across the anchor); within the host they stay native, Shift+Left/Right stay native throughout. Sweep state (`sweepAnchorNode/-Offset/-Host`, `sweepRegion`) lives on the editor-state container and is cleared on undo restore. **Two-stage Ctrl/Cmd+A** (Docs-style): stage 1 stays native — the browser scopes select-all to the focused host; stage 2 (host already fully selected per the chrome-aware `local:at-*` probes, or empty, or the selection already spans hosts) selects all blocks of the region as a **document-level range** (`local:select-region`) — it paints natively across host boundaries and never reaches the host page. Ctrl+A away from a caret also selects editor content, never the page: from the body it targets the swept region, else `local:active-root()` (selection anchor → last focused host → first region), and a focused image island is its own fully-selected unit (stage 2 directly, with Backspace/Delete then running the delete machine instead of the island's figure-delete); native page select-all happens only when no region exists. One **delete machine** (`local:delete-cross-host-selection`) serves stage-2 selections and every synthetic gesture alike (`local:selection-crosses-hosts()` gates it), fired by Backspace/Delete from host *or* body focus — a sweep from the page background leaves focus on body. Deletion is **block-granular**, never one raw `deleteContents` across the range: fully covered blocks are removed whole; partial edge hosts get sub-range deletes scoped *inside* the host; composites holding a range boundary never lose structure — their covered cells are cleared and flow cells collapse back to text hosts (`local:clear-host`; B3/B4 doctrine at partial coverage) while a *fully* covered composite is removed whole; non-composite edge remnants merge Docs-style via `local:merge-into-previous` with the caret at the seam (never with `pre` — B6); emptied structural containers are pruned (`local:prune-husks`), chrome is re-injected (idempotent), and an emptied region is reseeded with a fresh `p` host (`local:seed-region`). The range is **clamped to a single region** (the start's, else the first swept; `local:clamped-range` also moves boundaries out of chrome) — one gesture, one region-keyed undo entry; other regions stay byte-identical. A **printable character replaces** the selection (the delete machine places the caret, `local:insert-text-at-caret` lands the character — same undo entry); Enter/Tab/paste are suppressed; plain arrows stay native. **Canonical copy/cut** (`ixsl:oncopy`/`oncut` on hosts and body): a cross-host selection is copied in its storage form — `cloneContents` into a carrier div, `mode="canonical"` + `cm:normalize` (the paste pipeline in reverse), so the clipboard's HTML flavor has no chrome/`contenteditable`/marker classes but keeps RDFa attributes; cut adds the delete machine (one undo entry); within-host copy stays native.
+- **select.xsl** — the Docs-style selection gesture layer, region-scoped select-all and cross-host selection delete (keyboard dispatch lives in edit.xsl's keydown/body/paste templates, mirroring the tables.xsl split; the mouse gesture templates live here). **The browser confines a native drag-selection to the host it starts in** (even background-origin drags clamp on the first host entered), so cross-block selection is **synthesized**: mousedown in a region arms a sweep anchor (`local:caret-at-point` — `caretRangeFromPoint`, `caretPositionFromPoint` fallback; chrome positions escape to just after the chrome); once the pointer leaves the anchor host, each `body|html` mousemove rebuilds the selection anchor→pointer via `setBaseAndExtent` — the only Selection API that can express a **backward selection** (upward drags keep the anchor fixed) — with the focus clamped into the anchor's region (`local:clamp-focus-to-region`, `comparePoint`-based) and a viewport nudge near its edges (native autoscroll dies with the takeover); in-host moves stay native. Mouseup disarms (innermost-match dispatch: the host/drag-handle mouseup templates disarm on their paths, `body|html` catches background ends) and `ondragstart` disarms defensively; a press on the drag handle never reaches the arm template. **Shift+Click** extends from the standing selection anchor to the clicked point (preventDefault keeps the anchor; re-arms so Shift+drag keeps extending; repeated Shift+Clicks share the anchor). **Shift+Up/Down** extend block-granularly past host edges (`local:shift-arrow-extends` gates: cross-host selection, or focus at the host edge facing the arrow — probed from the *focus*, not the range end; `local:extend-selection-block-wise` steps the focus between region-level child positions, whole blocks and composites as units, flipping direction across the anchor); within the host they stay native, Shift+Left/Right stay native throughout. Sweep state (`sweepAnchorNode/-Offset/-Host`, `sweepRegion`) lives on the editor-state container and is cleared on undo restore. **Two-stage Ctrl/Cmd+A** (Docs-style): stage 1 stays native — the browser scopes select-all to the focused host; stage 2 (host already fully selected per the chrome-aware `local:at-*` probes, or empty, or the selection already spans hosts) selects all blocks of the region as a **document-level range** (`local:select-region`) — it paints natively across host boundaries and never reaches the host page. Ctrl+A away from a caret also selects editor content, never the page: from the body it targets the swept region, else `local:active-root()` (selection anchor → last focused host → first region), and a focused image island is its own fully-selected unit (stage 2 directly, with Backspace/Delete then running the delete machine instead of the island's figure-delete); native page select-all happens only when no region exists. One **delete machine** (`local:delete-cross-host-selection`) serves stage-2 selections and every synthetic gesture alike (`local:selection-crosses-hosts()` gates it), fired by Backspace/Delete from host *or* body focus — a sweep from the page background leaves focus on body. Deletion is **block-granular**, never one raw `deleteContents` across the range: fully covered blocks are removed whole; partial edge hosts get sub-range deletes scoped *inside* the host; composites holding a range boundary never lose structure — their covered cells are cleared and flow cells collapse back to text hosts (`local:clear-host`; B3/B4 doctrine at partial coverage) while a *fully* covered composite is removed whole; non-composite edge remnants merge Docs-style via `local:merge-into-previous` with the caret at the seam (never with `pre` — B6); emptied structural containers are pruned (`local:prune-husks`), chrome is re-injected (idempotent), and an emptied region is reseeded with a fresh `p` host (`local:seed-region`). The range is **clamped to a single region** (the start's, else the first swept; `local:clamped-range` also moves boundaries out of chrome, and out of object-block islands — `setStartBefore`/`setEndAfter`, so islands join a selection whole and the machine never sees a boundary inside one; fully covered islands are removed whole by the existing rules, and `local:caret-at-point` likewise escapes island interiors so sweep anchors never land in them) — one gesture, one region-keyed undo entry; other regions stay byte-identical. A **printable character replaces** the selection (the delete machine places the caret, `local:insert-text-at-caret` lands the character — same undo entry); Enter/Tab/paste are suppressed; plain arrows stay native. **Canonical copy/cut** (`ixsl:oncopy`/`oncut` on hosts and body): a cross-host selection is copied in its storage form — `cloneContents` into a carrier div, `mode="canonical"` + `cm:normalize` (the paste pipeline in reverse), so the clipboard's HTML flavor has no chrome/`contenteditable`/marker classes but keeps RDFa attributes; cut adds the delete machine (one undo entry); within-host copy stays native.
 - **input.xsl** — Notion-style input affordances (ported from PR #10 onto the content-model era; dispatch additions in edit.xsl): one **priority-raised `ixsl:onbeforeinput` dispatcher** intercepts printable-char triggers and `next-match`es into undo's typing coalescer, so plain typing still snapshots. Triggers act on the **host** the caret sits in and are content-model-gated (`local:trigger-kind` — a shorthand whose result the model rejects stays literal). The **slash menu** (`/` in an empty host): filterable, keyboard-navigable, showing only the commands the context admits (conversions for `p|h1–h3|pre` hosts, Quote where the wrap is legal, lists where the model places one, Figure…/Table… always — routed to the existing dialogs via `insertHost`, whose saves place per the content model through `local:insert-block-at-caret`: an empty list item or cell grows the composite *inside* itself); state on `slashHost`, torn down by `local:hide-dialogs`. **Markdown shorthands** in a paragraph host: `#`/`##`/`###`+space, `-`/`*`+space, `1.`+space, ``` ``` ``` convert in place (`local:convert-block` with the pre-strip snapshot — one undo entry restores the literal marker); `> ` **wraps** via `local:wrap-in-blockquote` (`blockquote > p`; converting the `p` itself would be invalid). Caret popups position via `local:show-at-caret`/`-element` over overlay.xsl's `local:show-at-point` split.
-- **undo.xsl** — unified snapshot undo/redo over `#content` innerHTML: every mutating handler calls `local:push-undo` first and `local:after-mutation` last; plain typing coalesces into ~1s bursts via `ixsl:onbeforeinput`. Ctrl/Cmd+Z / Shift+Z / Ctrl+Y are intercepted (native undo is replaced). Stacks live in a hidden DOM stash (`#undo-storage`, `data-role="storage"`) — JS arrays don't survive the IXSL boundary and sequence-valued window properties keep only their first item. Caret restoration after undo is approximate (first host) by design.
+- **undo.xsl** — unified snapshot undo/redo over `#content` innerHTML: every mutating handler calls `local:push-undo` first and `local:after-mutation` last; plain typing coalesces into ~1s bursts via `ixsl:onbeforeinput`. Ctrl/Cmd+Z / Shift+Z / Ctrl+Y are intercepted (native undo is replaced). Stacks live in a hidden DOM stash (`#undo-storage`, `data-role="storage"`) — JS arrays don't survive the IXSL boundary and sequence-valued window properties keep only their first item. Caret restoration after undo is approximate (first host) by design. `local:restore-snapshot` re-fires `local:render-island` only for islands *without* a rendering div — snapshots carry rendering markup, so restores are render-stable; only mid-render captures re-hydrate.
 - **navigate.xsl** — FontoXML-inspired navigation: ToC drawer (recursive `for-each-group group-starting-with` outline, click-to-jump, section drag-reorder via `local:section-of`), breadcrumb bar (element path + `rdfa:in-scope-subject` at the caret), lint surfacing (markers + badge + issues modal), find & replace (single-text-node matches, `nodeValue`-rewrite replace-all — annotation-safe by construction).
 - **lint-rdfa.xsl** — RDFa lint logic. **Pure XSLT**, tested headless via `tests/lint-driver.xsl` (`xsl:import` resolves the output-method conflict). Reuses the extractor's resolution functions so lint verdicts can't drift from extraction semantics. Checks: term-unresolvable, empty-href, content-resource-conflict, empty-literal, about-relative.
 - **lint-xhtml.xsl** — nesting lint (`lint:nesting-issues`, concatenated with `lint:element-issues` at every surfacing site). **Pure XSLT**, consults content-model.xsl only, so verdicts can't drift from normalization. Checks: invalid-nesting (known child not allowed by known parent), stray-text (non-ws text in an element-only container), prohibited-nesting (Appendix B), unknown-element (outside the model — preserved, unvalidated).
@@ -42,12 +46,12 @@ The editor **emits absolute IRIs** in RDFa attributes (LinkedDataHub v6 conventi
 ## Commands
 
 ```bash
-make up                     # build the SEF, then serve on http://localhost:8000 (override: make up PORT=9000)
-make sef                    # compile src/*.xsl → dist/index.xsl.sef.json + copy vocabs
+make up                     # build the SEFs, then serve on http://localhost:8000 (override: make up PORT=9000)
+make sef                    # compile src → dist/index.xsl.sef.json (core) + dist/ldh-editor.xsl.sef.json (LDH)
 make test                   # headless suites (extractor, canonical, lint); make test-browser for the Playwright suites
 ```
 
-The targets wrap the underlying scripts (`bash generate-sef.sh`, `bash tests/run-tests.sh`, `python3 -m http.server 8000`). `dist/` is a **generated** build artifact (compiled SEF + copied vocabs) and is gitignored — the SEF also bakes in a `buildDateTime`, so it is never byte-stable; `make sef` reproduces it. Serving directly with `python3 -m http.server` needs a prior `make sef`.
+The targets wrap the underlying scripts (`bash generate-sef.sh`, `bash tests/run-tests.sh`, `node serve.mjs`). **serve.mjs content-negotiates trailing-slash document URIs** (`Accept: application/rdf+xml` → the directory's `index.rdf`, `application/sparql-results+xml` → `results.xml`, `text/html` → `index.html`) — required for the object-block demo at `/demo/`; `demo/queries/*/` and `demo/resources/*/` hold the negotiated representations. `dist/` is a **generated** build artifact (compiled SEFs + copied vocabs) and is gitignored — the SEF also bakes in a `buildDateTime`, so it is never byte-stable; `make sef` reproduces it.
 
 Run `make sef` after any XSLT change; run the tests after any extractor change.
 
@@ -66,7 +70,9 @@ Run `make sef` after any XSLT change; run the tests after any extractor change.
 - **Run-wrapper contract**: `p.rdfa-editor-run` is an editing-DOM-only marker for the stray inline runs of mixed flow containers — created by init/paste, unwrapped by canonicalization (C11), promoted to a real `p` by structural gestures, never by plain typing. It renders margin-free via `rdfa-editor.css`.
 - **Undo contract**: every mutating handler pushes a snapshot first (`local:push-undo`, optionally with a pre-captured `$snapshot` when the operation can fail) and calls `local:after-mutation` last — never push from shared primitives. Undo/redo restore invalidates all node-valued window properties (cleared in `local:restore-snapshot`) and closes overlay/dialogs. The caret rides along on stash entries as (block, text-node, offset) data attributes and is restored on undo/redo.
 - **Content markers**: anything written into `#content` for UI purposes must be `@class` (or `aria-*`) only — both are canonicalization-stripped. `@title` is NOT stripped and is forbidden as a marker.
+- **Object-block contract** (= the v6 document format, see the `XHTML-RDFa-as-LDH-v6-Document-Format` wiki): the stored form is the block element ONLY — `div[@about][@typeof]` (`@about` a fragment URI: the block is a document part) with `span[@property]` definition children (objects via `@resource`, **literals as span text content**, hidden by `rdfa-editor.css`); **no document→block containment edge** — `ldh:content` is v6's document→body XMLLiteral property, never a per-block edge, and block order is document order (no `rdf:_N`). Extraction yields the complete block definition. Everything else (`tabindex`, marker classes, the rendering div) is editing ephemera. Island detection keys on `@typeof` only, so `local:block-text()` of a chart island is non-empty (its var-name spans) — the toolbar delete-block button confirms, the keyboard island delete stays confirm-free. **URLs are clean Linked Data URIs**: document URIs end with a trailing slash, representations come from content negotiation — file extensions never appear in storage, fetch code or fixtures. Async rendering runs outside push-undo (a rendering-only undo step is possible and harmless — canonical content is identical).
+- **GitHub Pages deploys the CORE editor only** (`deploy-pages.yml` removes `dist/ldh-editor.xsl.sef.json` and never copies `demo/`) — Pages is a static host with no conneg, so the LDH flavor is local-only by construction.
 - **SaxonJS gotchas**: computed numeric predicates (`[xs:integer(...)]`) are evaluated as booleans in some contexts — bind to a variable and use the bare `[$index]` form. JS arrays returned by `ixsl:call` marshal to XDM sequences (empty array = empty sequence). Large nested map literals fail the compiler with an internal assertion — build them with `map:merge` over `map:entry` (see `$cm:model`).
-- Browser tests live in `tests/browser/` (`npm run test:browser` self-serves the repo): `editor.mjs`, `features.mjs`, `fixes.mjs`, `hardening.mjs`, `multiinstance.mjs`, `tables.mjs`, `datatype.mjs`, `inspector.mjs`, `nesting.mjs` (content-model foundation), `authoring.mjs` (nesting gestures), `select.mjs` (two-stage Ctrl+A, cross-host sweep delete, type-to-replace, canonical copy/cut, composite/clamp semantics, plus the real gestures: drag takeover with real mouse events, Shift+Click, Shift+Up/Down, gutter/backward/cross-region drags, drag-handle non-hijack), `notion.mjs` (slash menu, markdown input rules, context filtering) and `invariants.mjs` (the cross-product net: a uniform gesture battery in every caret context asserting properties that must always hold — no orphan text outside an editable host, no nested hosts, chrome top-level only, run wrappers editable, zero lint issues, undo restores the exact baseline), all against `tests/fixture-nesting.html`. Scenario tests assert *semantics* (where things land); the invariant suite catches *validity/editability/undo* regressions in combinations nobody enumerated. CI runs both headless loops and the browser suites (`.github/workflows/ci.yml`).
+- Browser tests live in `tests/browser/` (`npm run test:browser` self-serves the repo): `editor.mjs`, `features.mjs`, `fixes.mjs`, `hardening.mjs`, `multiinstance.mjs`, `tables.mjs`, `datatype.mjs`, `inspector.mjs`, `nesting.mjs` (content-model foundation), `authoring.mjs` (nesting gestures), `select.mjs` (two-stage Ctrl+A, cross-host sweep delete, type-to-replace, canonical copy/cut, composite/clamp semantics, plus the real gestures: drag takeover with real mouse events, Shift+Click, Shift+Up/Down, gutter/backward/cross-region drags, drag-handle non-hijack), `notion.mjs` (slash menu, markdown input rules, context filtering), `invariants.mjs` (the cross-product net: a uniform gesture battery in every caret context asserting properties that must always hold — no orphan text outside an editable host, no nested hosts, chrome top-level only, run wrappers editable, zero lint issues, undo restores the exact baseline) and `blocks.mjs` (object blocks: init/locking, storage-form round-trip, island navigation/deletion/boundaries, dialog insertion top-level and nested, stage-2/sweep atomicity, canonical copy, undo — against `tests/fixture-blocks.html`, which hydrates two islands over conneg before baselining). All other suites run against `tests/fixture-nesting.html`, which loads the **ldh-editor SEF** — proving the extension layers without disturbing core behavior (notion.mjs counts the extension's 11th slash item). Scenario tests assert *semantics* (where things land); the invariant suite catches *validity/editability/undo* regressions in combinations nobody enumerated. CI runs both headless loops and the browser suites (`.github/workflows/ci.yml`).
 - **Sanitization**: `canonical-xhtml.xsl` is the storage boundary — it drops script/style/iframe/object/embed/applet/form controls/link/meta/base subtrees, comments/PIs, all `on*` attributes, and `javascript:`/`vbscript:`/`data:` URLs (`data:image/*` allowed in `@src`). HTML paste goes through this same mode. Lint mirrors these as `unsafe-attribute`/`unsafe-url`.
 - Editor-contract CSS lives in `rdfa-editor.css` (host pages include it; the container needs ~2.5em left padding for the gutter handles); `index.html` keeps only demo styles.
diff --git a/LDH-BLOCKS-PLAN.md b/LDH-BLOCKS-PLAN.md
new file mode 100644
index 0000000..fadcafa
--- /dev/null
+++ b/LDH-BLOCKS-PLAN.md
@@ -0,0 +1,181 @@
+# Embed LDH's RDF-defined blocks as atomic RDFa islands (core + extension)
+
+## Context
+
+LinkedDataHub's content blocks (`ldh:Object`, `ldh:View`, `ldh:ResultSetChart`, queries) are RDF resources rendered client-side by LDH's SaxonJS XSLT (`ldh:RenderRow`-mode templates on `div[@typeof]`, async promise chains → SPARQL → Google Charts). In LDH they form a **flat top-level `rdf:_N` sequence** — a chart inside a list item is impossible. We want them embeddable in RDFa-Editor regions **wherever an XHTML block element can go** (region top level, `li`, `td`, `blockquote`, `dd`), treated as **atomic island blocks**: never editable inside, navigable/selectable/deletable like image islands, hard boundaries for merges and cross-host deletes, byte-identical round-trip.
+
+**Decisions made with the user:**
+1. **Storage = self-describing RDFa**: a `div` placeholder using the conformant containment idiom, defining triples inline as RDFa spans; extracting the document yields the full block definition.
+2. **Rendering = overridable hook + async fixture demo**: rendering lands in an injected `div[@data-role='rendering']` (extractor skips it, canonicalization drops it — the LDH v6 contract already in place); the default demo renderer does real async hydration from local fixture RDF files via the **SaxonJS 3 promise API** (`ixsl:promise` + `ixsl:http-request` → `ixsl:then` chains, exactly LDH's `ldh:*-thunk` idiom — see LDH block.xsl:582-596). **Never `ixsl:schedule-action`** — legacy, banned in this project.
+3. **Insertion = dialog + slash menu**, placed via the existing `local:insert-block-at-caret`.
+4. **Packaging = optional extension stylesheet layered via `xsl:import`**: the core gains only a *generic* island mechanism with zero LDH knowledge; all LDH specifics live in an extension module whose contract doubles as the real LDH integration contract (LDH's client.xsl already composes with the editor — docs/ldh/MIGRATION.md §10).
+
+Full design rationale with every anchor verified: `/Users/martynas/.claude/plans/we-need-to-make-flickering-mountain-agent-ac9d0adb33f0ef66a.md`. Key claims independently re-verified: all 11 src modules share `xmlns:local="urn:rdfa-editor:functions"` (so import-precedence override of `local:*` works); `local:init-block`'s text-host branch would make an island div contenteditable (edit.xsl:325-330); `local:merge-host-in` (edit.xsl:88-93) would leapfrog a tail island (islands contain no hosts to trip the composite intersect); `local:clamped-range` (select.xsl:117-135) already escapes `@data-role` — islands mirror it; generate-sef.sh c14n-flattens `src/*.xsl` (maxdepth 1) into `build/` and compiles one entry.
+
+## 1. Storage contract
+
+Placeholder (stored/canonical/clipboard form; real output uses absolute IRIs):
+
+```html
+<div property="https://w3id.org/atomgraph/linkeddatahub#content" resource="#chart1"
+     typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart">
+  <span property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span>
+  <span property="https://w3id.org/atomgraph/linkeddatahub#chartType" resource="https://w3id.org/atomgraph/client#BarChart"></span>
+  <span property="https://w3id.org/atomgraph/linkeddatahub#categoryVarName" content="country"></span>
+  <span property="https://w3id.org/atomgraph/linkeddatahub#seriesVarName" content="population"></span>
+</div>
+```
+
+Extracts (base B, region `about=""`): `<B> ldh:content <B#chart1> . <B#chart1> a ldh:ResultSetChart; spin:query <resolve(queries/population/#this, B)>; ldh:chartType ac:BarChart; ldh:categoryVarName "country"; ldh:seriesVarName "population"` — verified against the extractor's `@resource` branch (RDFa2RDFXML-v3.xsl:118-127) and typed-resource chaining (:175-182). Canonicalization verified safe: C1 drops the rendering div (canonical-xhtml.xsl:119), C7a/C7b exclude RDFa-bearing divs (:170-183), C6/C8 keep RDFa-bearing empty spans, C2 strips `tabindex`, N1 only touches inline-only names (div is flow), `cm:wrap-inline-runs` passes divs bare. Lint: zero issues (empty-literal has a `not(@resource)` guard, lint-rdfa.xsl:90). Editing DOM adds only ephemera: `tabindex="-1"`, marker class `rdfa-editor-island`, the rendering div, top-level chrome.
+
+Note: `ldh:content` is not (yet) declared in ldh.ttl 1.1.6 — it's the agreed v6 containment convention; only extension markup templates would change if LDH names it differently.
+
+## 2. Core: new module `src/blocks.xsl` (generic, zero LDH knowledge)
+
+ixsl-bearing (like tables.xsl), `xsl:include`d from src/index.xsl. Contents:
+
+- `<xsl:param name="object-block-types" as="xs:string*" select="()"/>` — absolute class IRIs; default empty.
+- **The single island predicate** — every island decision routes through it:
+  `local:island($e)` = `exists($e[self::div][tokenize(@typeof) = $object-block-types])`.
+- **Render hook**: `<xsl:mode name="local:render-island" on-no-match="deep-skip"/>` — context item = the island div. Contract: inject exactly ONE `div[@data-role='rendering']` as last child via `local:replace-rendering`; async renderers inject it **only in the completion callback** (loading state = ephemeral class `rdfa-editor-loading`), so "no rendering div" always means "re-render needed" (undo-restore keys on that); never touch the RDFa spans; never push undo; idempotent. Core ships a neutral synchronous default (`match="*"`, low precedence): a static card showing type + resource.
+- `local:replace-rendering($island, $content)` — the ONLY writer of the rendering div: remove existing, create div via `local:element('div')` + `ixsl:set-attribute data-role='rendering'`, innerHTML via `serialize($content, map{'method':'html'})` (never xml — self-closing tags swallow siblings), appendChild.
+- **Empty extension hook stubs** (overridden by extensions at higher import precedence): `local:render-extra-dialogs`, `local:render-extra-insert-buttons`, `local:render-extra-slash-items`, `local:run-extra-slash-command($command, $host)`.
+
+CSS (`rdfa-editor.css`): `.rdfa-editor-island` card affordance, `:focus` outline (selected state, mirrors image islands), `.rdfa-editor-loading` dimming. Class markers only (canonicalization-stripped).
+
+## 3. Core: edit.xsl wiring (verified anchors)
+
+- **`local:init-block` (:317-362)** — new FIRST `xsl:when test="local:island($block)"`: remove `contenteditable` (defensive), set `tabindex="-1"`, add class `rdfa-editor-island`, fire `mode="local:render-island"` when `empty($block/*[@data-role='rendering'])`; no recursion, no wrap-stray-runs. The img-tabindex loop (:354-356) gains `[empty(ancestor::*[@data-role])]` (imgs inside rendering never focusable). Chrome injection (:357-361) already runs after the choose — top-level islands get drag handles free; nested islands get none (nested-table doctrine).
+- **`local:nav-targets` (:99-103)** — add `or local:island(.)` plus trailing filters `[empty(ancestor::*[@data-role])][empty(ancestor::*[local:island(.)])]`.
+- **`local:select-image` (:222-228)** → rename **`local:select-island`** (body unchanged: removeAllRanges + focus); update call sites :236, :255. `local:land-forward/-backward` (:232-270): branch test becomes `$target/self::img or local:island($target)`.
+- **Generalize the two img event templates** (:810 onkeydown, :902 onfocusin) to match `*[contains-token(@class, 'rdfa-editor-content')]//*[self::img or local:island(.)]`. Delete victim (:861-862) generalizes to `($target/ancestor-or-self::figure[exists(local:block-of(.))][1], $target)[1]` — an island deletes itself; the existing `local:collapse-container` call (:873-877) handles islands-in-li/td. Ctrl+A stage-2 and arrow nav generalize unchanged.
+- **`local:merge-host-in` (:88-93)** — bind `$host := local:last-host-in($element)`, add island to the composite intersect test AND the tail-island guard (islands contain no hosts, so without it the merge leapfrogs a tail island):
+  `[empty(ancestor-or-self::*[self::table or self::figure or local:island(.)] intersect $element/descendant-or-self::*)][empty($element/descendant-or-self::*[local:island(.)][. >> $host])]`
+- **B3 caret landing (:1203-1216)** — when the removed empty host's `$prev` is an island, `local:select-island($prev)` (the contenteditable descendant lookup is empty). Backspace at start of a non-empty host after an island stays inert (falls through) — same doctrine as tables.
+- **Hook call sites**: `local:init-editing` (:280-287) calls `local:render-extra-dialogs`; toolbar Insert group (:461-464) calls `local:render-extra-insert-buttons`.
+- **Dialog teardown generalization**: Escape match (:2064-2069) and `local:hide-dialogs` (:2072-2090) keyed on class `edit-dialog` (all four existing dialogs carry it — verified edit.xsl:1977, 2111, tables.xsl:121, navigate.xsl:518) + the slash menu, instead of hardcoded ids. Extension dialogs opt in via the class.
+- **No changes needed** (verified): `delete-block` button (island's `local:block-text()` = '' ⇒ deletes without confirm, image-island doctrine); Alt+Arrow, Tab/Enter machines (host-only); block-type select/quote toggle disable via `local:sync-format-toolbar`; paste (canonical strips rendering, re-init re-renders); drag (chrome-gated); breadcrumb already labels `div[<typeof>]` (navigate.xsl:262-264).
+
+## 4. Core: select.xsl, undo.xsl, input.xsl
+
+- **`local:clamped-range` (select.xsl:117-135)**: after the `@data-role` escapes (:128-133), mirror for islands — start container inside an island → `setStartBefore` it; end container → `setEndAfter`. Establishes the invariant "a range boundary never sits inside an island" for the delete machine AND canonical copy (both call it). With that, the delete machine's removals doctrine needs **no island branch** — covered islands are removed whole via the existing rules (:520-527).
+- **`local:caret-at-point` (select.xsl:144-176)**: mirror the chrome escape — a point resolving inside an island moves to just after it (sweep anchors never inside islands).
+- **Guards**: `$collapse-candidates` (select.xsl:536-539) gains `[not(local:island(.))]`; `local:collapse-container` (edit.xsl:367-388) guard gains `not(local:island($container))` — otherwise a span-only island would be collapsed into a contenteditable text host.
+- **Canonical copy**: no change (mode canonical strips rendering/tabindex, keeps the placeholder).
+- **`local:restore-snapshot` (undo.xsl:159-221)**: after chrome re-injection (:170-177), re-render only unrendered islands: `for-each $root//*[local:island(.)][empty(*[@data-role='rendering'])]` → apply `local:render-island`. Snapshots carry rendering markup, so restores are byte-deterministic; only mid-flight captures re-fire (guaranteed by the inject-in-callback contract).
+- **input.xsl**: `local:render-slash-menu` (:224-240) calls `local:render-extra-slash-items` inside `ul.slash-items`; `local:run-slash-command`'s empty `xsl:otherwise` (:361) calls `local:run-extra-slash-command($command, $host)`. `local:open-slash` unchanged — unknown commands hit the `else true()` availability arm (:268), correct since a div is placeable wherever blocks are.
+
+## 5. Extension: `src/ldh-blocks.xsl` + entry `src/ldh-editor.xsl`
+
+Both at src/ **top level** (generate-sef.sh's `find -maxdepth 1` c14n; sibling hrefs survive the build/ flattening).
+
+**src/ldh-editor.xsl** (demo/dist entry):
+```xml
+<xsl:import href="index.xsl"/>      <!-- core at lower import precedence -->
+<xsl:include href="ldh-blocks.xsl"/> <!-- extension at the entry's precedence -->
+```
+Legal by import-precedence rules: `$object-block-types` re-declaration (XTSE0630 forbids duplicates only at the SAME precedence), named-template overrides of the hook stubs, same-mode template rules beating the imported catch-all. `main` stays invocable from the imported module; ixsl event templates register across imports (the MIGRATION.md §10 compile-proof covers this shape). `make sef` after step 1 proves it immediately.
+
+**src/ldh-blocks.xsl**:
+1. `$object-block-types` = the three absolute IRIs (`…#Object`, `…#View`, `…#ResultSetChart`).
+2. **Fixture renderers** — three `mode="local:render-island"` templates matching per typeof + required definition span (mirroring LDH's `ldh:RenderRow` guards). Flow: resolve the query/value IRI against `local:document-uri()` (NOT dist-relative — the span's `@resource` resolves against the page base per RDFa, so `-relocate:on` is moot and no fixture copying is needed); `$query-doc = substring-before($query-uri || '#', '#')`; fetch URLs map the clean IRI to files: `$query-doc || '.rdf'` and `$query-doc || '-results.xml'` (demo-only shim, extensions never in storage); add loading class; then the **SaxonJS 3 promise chain** (LDH's exact idiom, block.xsl:582-596 — NEVER `ixsl:schedule-action`):
+   ```xml
+   <ixsl:promise select="
+       ixsl:http-request(map{ 'method': 'GET', 'href': $query-doc,
+                              'headers': map{ 'Accept': 'application/rdf+xml' } }) =>
+           ixsl:then(local:block-query-response($island, $query-uri, $results-doc, ?))"
+       on-failure="local:block-render-failure($island, ?)"/>
+   ```
+   `local:block-query-response` (partial application closes over `$island`/`$query-uri`/`$results-doc`; `ixsl:updating="yes"`): check `$response?status = 200` and XML `?media-type`, pull `sp:text` for `$query-uri` from `$response?body` (a `document-node()`), then issue the second promise (`ixsl:http-request` for `$results-doc`) whose callback `local:block-results-response` builds the content — `<pre>` with the query text + an HTML `<table>` of the SRX rows (+ chart caption read from the island's own spans) — hands it to `local:replace-rendering` and clears the loading class. `local:block-render-failure` (`on-failure`, both promises): error card via `local:replace-rendering`, loading class cleared — a failed fetch must never wedge the loading state. Object block: same shape, one fetch of the resource description, rendered as a property/value table. Note: this introduces the repo's **first** `ixsl:promise` — there is no async instruction in src/ today.
+3. **Insert dialog** `div#ldh-block-dialog.rdfa-editor-ui.edit-dialog` (class opt-in ⇒ Escape/teardown free): block-type select (Object/View/Result set chart, values = class IRIs), fragment-id input, per-type fieldsets toggled via ixsl:onchange (`ixsl:set-style`): Object → resource URI (`rdf:value`) + optional `ac:mode`; View → query URI (`spin:query`) + optional `ac:mode`; Chart → query URI, chart-type select (ac Table/Bar/Line/Scatter → `ldh:chartType`), category/series var names (`@content` spans). Save (modeled on `table-save`, tables.xsl:159-217): validate → `local:push-undo` → build div+spans via `local:element` + `ixsl:set-attribute` (RDFa must be real attributes; DOM-built, no serialization) → `local:insert-block-at-caret` with `insertHost` → render → `local:select-island` → `local:after-mutation` → `local:hide-dialogs`.
+4. **Slash + toolbar contributions**: `local:render-extra-slash-items` emits `<li class="slash-item" data-command="ldh-block">Block…</li>` (generic filter/arrow/Enter machinery applies); `local:run-extra-slash-command` handles `'ldh-block'` (re-arm `insertHost`, show dialog via `local:show-at-element` — mirroring the table branch, input.xsl:340-360); `local:render-extra-insert-buttons` emits a toolbar button mirroring `insert-table` (tables.xsl:137-157).
+
+**LDH integration contract** (document in MIGRATION.md): in real LDH, client.xsl plays the ldh-blocks.xsl role — sets `$object-block-types`, and its `mode="local:render-island"` templates bridge into the existing `ldh:RenderRow` machinery with the rendering div as container. The editor never learns LDH types; LDH never learns editor internals beyond the mode + `local:replace-rendering` + the hook stubs.
+
+## 6. Build + demo
+
+- **generate-sef.sh**: compile line becomes `-xsl:./build/ldh-editor.xsl` (same output `dist/index.xsl.sef.json` — single SEF, zero-setup demo; core-only consumers compile src/index.xsl themselves — one Makefile comment). Vocabs copy unchanged; **no fixture copy** (document-URI resolution).
+- **Demo fixtures** (new, served from repo root): `demo/queries/population.rdf` (`sp:Select` description with `sp:text`), `demo/queries/population-results.xml` (SRX rows), `demo/resources/ada.rdf` (Object target).
+- **index.html**: add a ResultSetChart block to `#content` (`resource="#population-chart"`, spin:query `resource="queries/population/#this" (on demo/index.html)`); Help-modal sentence.
+- **tests/browser/run.mjs**: add `'.xml': 'application/xml'` and `'.rdf': 'application/rdf+xml'` to the mime map; add `'blocks'` to the suite list. (`ixsl:http-request` parses the response body to a `document-node()` based on the media-type, so the fixtures must be served as XML types; python http.server on macOS maps both via Apache mime.types — the `on-failure`/media-type guard shows the error card if a host maps them wrong.)
+
+## 7. Tests
+
+Headless (run against src/ — island storage-form behavior is all core/pure-XSLT):
+- `tests/fixtures/14-ldh-block-island.xhtml` + expected RDF (the §1 triples; include a nested island inside an `li`).
+- `tests/fixtures/canonical/23-ldh-block-placeholder.xhtml` + expected: island laden with ephemera (tabindex, marker classes, chrome, populated rendering div, run-wrapped sibling) ⇒ clean placeholder, byte-identical spans; plus an attributeless-div control pinning C7a/C7b.
+- `tests/fixtures/lint/10-ldh-block-clean.xhtml` + empty expected.
+
+Browser (`tests/browser/blocks.mjs` against tests/fixture-nesting.html, which gains a top-level ResultSetChart island — `resource="../demo/queries/population/#this"`, page-relative — and a nested View island in an li):
+1. init/render: uneditable, tabindex, spans un-wrapped, rendering table appears (awaited), chrome top-level only;
+2. canonical round-trip via view-source;
+3. nav battery: arrows select/leave, Backspace deletes, undo restores + re-render leaves placeholder intact;
+4. slash "Block…" → dialog → insert in region and in an empty li;
+5. stage-2 Ctrl+A + Delete → reseed; sweep across the island → removed whole, no span residue;
+6. Backspace boundary doctrine;
+7. canonical copy over an island (clipboard text/html);
+8. breadcrumb label + disabled block-type select.
+- invariants.mjs: one render-settle wait before baseline capture (rendering populated); battery unchanged.
+
+## 8. Risks / gotchas
+
+- `serialize(…, map{'method':'html'})` on every innerHTML write (self-closing div/span swallows siblings).
+- `local:island()` in match patterns reads a global param — legal XSLT 3.0; if the SaxonJS compiler balks, inline `self::div[tokenize(@typeof) = $object-block-types]` (variable refs in pattern predicates are safe). De-risk: `make sef` right after step 1.
+- **`ixsl:schedule-action` is banned** (legacy pre-SaxonJS-3) — all async goes through `ixsl:promise`/`ixsl:http-request`/`ixsl:then` with `on-failure`. DOM-mutating promise callbacks must be declared `ixsl:updating="yes"` (LDH precedent, e.g. `ldh:ontology-view-render-thunk`); the failure handler must clear the loading state and render an error card. Verify SaxonJS 3's exact `on-failure` arity against the LDH usage (`ldh:promise-failure#1`) when writing the handlers.
+- Async rendering mutates the region outside push-undo ⇒ a visually-idle undo step is possible; harmless (canonical content identical), documented.
+- `$object-block-types` re-declaration ONLY at higher import precedence, never in a second core include.
+- Always `tokenize(@typeof) = $object-block-types`, never string equality (multi-token typeof).
+- Keep core entity-free where headless suites run src/ directly; extension entities are fine (c14n expands for the SEF).
+
+## 9. Implementation order + verification
+
+1. src/blocks.xsl + index.xsl include + CSS → `make sef` (proves pattern legality).
+2. edit.xsl wiring (§3) → `make sef`, browser spot-check.
+3. select.xsl + undo.xsl + input.xsl (§4).
+4. ldh-blocks.xsl + ldh-editor.xsl + generate-sef.sh + demo/ + index.html.
+5. Headless fixtures → `make test`.
+6. fixture-nesting.html + blocks.mjs + run.mjs + invariants wait → `make test-browser`.
+7. Docs: CLAUDE.md module list (blocks.xsl, ldh-blocks.xsl, ldh-editor.xsl entry, build note), README, MIGRATION.md `local:render-island` integration surface.
+
+Final manual check: `make up` → the population chart hydrates async on index.html; view-source shows the clean placeholder; Extract RDF shows the §1 triples; drag/slash-insert/delete/undo/copy-paste behave per §8 of the agent plan.
+
+## Amendments during implementation
+
+1. **`ixsl:schedule-action` is banned** — all async uses the SaxonJS 3 promise API
+   (`ixsl:promise` + `ixsl:http-request` `=> ixsl:then`, `on-failure`, callbacks as
+   `ixsl:updating="yes"` functions with partial application), exactly LDH's
+   `ldh:*-thunk` idiom.
+2. **Clean Linked Data URLs throughout** — document URIs end with a trailing slash
+   (`demo/queries/population/#this`), representations come from **content
+   negotiation** on the clean URI (`Accept: application/rdf+xml` → the description;
+   `Accept: application/sparql-results+xml` on a query document → canned results, a
+   demo stand-in for live SPARQL execution). File extensions appear nowhere: not in
+   storage, not in fetch code, not in fixtures (`demo/queries/population/index.rdf` +
+   `results.xml` are server-private file names). `make up` therefore serves via
+   `node serve.mjs` (conneg-aware) instead of python http.server; tests/browser/run.mjs
+   negotiates the same way.
+3. **Core/LDH split with core-only GitHub Pages** — two SEFs: `dist/index.xsl.sef.json`
+   (core, from src/index.xsl — what deploy-pages.yml publishes, minus the LDH
+   artifacts) and `dist/ldh-editor.xsl.sef.json` (core + extension — used by the new
+   `demo/index.html` showcase page and the browser fixtures; local-only, needs
+   conneg). index.html carries no LDH markup.
+4. **Islands got their own browser fixture** (`tests/fixture-blocks.html` +
+   `tests/browser/blocks.mjs`) instead of extending fixture-nesting.html — keeps the 13
+   existing suites' block enumeration byte-stable. fixture-nesting.html still loads the
+   ldh-editor SEF, proving the extension layers without disturbing core behavior
+   (notion.mjs counts its 11th slash item).
+5. **Undo/redo chords on a focused island** — the host/body keydown templates don't
+   fire with focus on an island (a pre-existing gap for image islands too), so the
+   generalized island keydown template intercepts Ctrl/Cmd+Z / Shift+Z / Ctrl+Y itself.
+6. **Block markup follows the v6 document format** (the
+   [XHTML-RDFa-as-LDH-v6-Document-Format](https://github.com/AtomGraph/LinkedDataHub/wiki/XHTML-RDFa-as-LDH-v6-Document-Format)
+   wiki, which supersedes the plan's §1 storage contract): blocks carry
+   `@about="#fragment"` + `@typeof` directly — NOT the `property="ldh:content"
+   resource=` containment idiom (in v6 `ldh:content` is the document→body XMLLiteral
+   property, never a per-block edge; there is no document→block triple and no
+   `rdf:_N` — order is document order). Literal definition values are span TEXT
+   content (`<span property="ldh:categoryVarName">country</span>`), not `@content` —
+   which also matches LDH's renderer selectors verbatim. Island detection was already
+   `@typeof`-keyed, so the mechanism was unaffected; the dialog emission, demo pages,
+   fixtures and expected files were updated. v6's render mode is `ldh:Block`
+   (`ldh:RenderRow` is the v5 name the §12 bridge example targets).
diff --git a/Makefile b/Makefile
index b4a2350..7b6850a 100644
--- a/Makefile
+++ b/Makefile
@@ -4,9 +4,9 @@
 PORT ?= 8000
 
 # Bring up the editor locally: build the SEF, then serve on http://localhost:$(PORT)
+# (serve.mjs content-negotiates document URIs — required for the object-block demo)
 up: sef
-	@echo "Serving http://localhost:$(PORT)/index.html — Ctrl-C to stop"
-	python3 -m http.server $(PORT)
+	node serve.mjs $(PORT)
 
 # Compile src/*.xsl to the SaxonJS SEF (dist/index.xsl.sef.json) and copy vocabs
 sef:
diff --git a/README.md b/README.md
index ba5f14e..0f56d28 100644
--- a/README.md
+++ b/README.md
@@ -19,17 +19,27 @@ RDFa extraction and the document canonicalization are all XSLT.
   wavy underlines + a breadcrumb badge.
 - **Navigation**: ToC drawer (outline with section drag-reorder), breadcrumb bar with
   the RDFa subject in scope at the caret, find & replace.
+- **Object blocks** (optional LinkedDataHub extension): blocks defined purely in RDF —
+  queries, charts, referenced resources — embedded as self-describing RDFa placeholders
+  wherever the content model admits a block, edited as atomic islands, and hydrated
+  client-side from clean, content-negotiated Linked Data URIs. Only the RDFa
+  description is stored; the rendering is ephemeral.
 
 ## Run
 
 ```bash
-make up                         # build the SEF, then serve on http://localhost:8000
-# open http://localhost:8000/index.html — override the port with: make up PORT=9000
+make up                         # build the SEFs, then serve on http://localhost:8000
+# open http://localhost:8000/ — override the port with: make up PORT=9000
+# open http://localhost:8000/demo/ for the LinkedDataHub object-blocks demo
 ```
 
-`make up` runs `make sef` first (compile `src/*.xsl` → `dist/index.xsl.sef.json`, needs
-xmlstarlet + npx), then serves the repo with `python3 -m http.server`. Run `make sef`
-alone to rebuild the SEF without serving.
+`make up` runs `make sef` first (compile the core `src/index.xsl` →
+`dist/index.xsl.sef.json` and the LDH-extended `src/ldh-editor.xsl` →
+`dist/ldh-editor.xsl.sef.json`; needs xmlstarlet + npx), then serves the repo with
+`node serve.mjs` — a static server that **content-negotiates** trailing-slash document
+URIs (the object-block demo fetches its RDF and canned SPARQL results that way). Run
+`make sef` alone to rebuild the SEFs without serving. GitHub Pages deploys the core
+editor only.
 
 ## Test
 
diff --git a/demo/index.html b/demo/index.html
new file mode 100644
index 0000000..40d6218
--- /dev/null
+++ b/demo/index.html
@@ -0,0 +1,121 @@
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+        <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700" type="text/css">
+        <title>RDFa Editor — LinkedDataHub blocks demo</title>
+        <script type="text/javascript" src="../lib/SaxonJS3.js"></script>
+        <script type="text/javascript">
+            window.onload = function() {
+                // preload the vocabulary documents into the SaxonJS document pool,
+                // keyed by the page-relative URI the stylesheet resolves - the pool
+                // satisfies doc() before any fetch (fixture-nesting.html precedent)
+                const vocabs = ["vocabs/foaf.rdf", "vocabs/dcterms.rdf"];
+                Promise.all(vocabs.map(href =>
+                        SaxonJS.getResource({ location: "../" + href, type: "xml" })))
+                    .then(resources => {
+                        const pool = {};
+                        vocabs.forEach((href, i) =>
+                            pool[new URL(href, document.baseURI).href] = resources[i]);
+                        return SaxonJS.transform({
+                            documentPool: pool,
+                            stylesheetLocation: "../dist/ldh-editor.xsl.sef.json",
+                            initialTemplate: "main",
+                            logLevel: 10
+                        }, "async");
+                    })
+                    .catch(err => console.log("Transformation failed: " + err));
+            }
+        </script>
+        <link rel="stylesheet" href="../rdfa-editor.css" type="text/css"/>
+        <style type="text/css">
+            html, body { margin: 0; }
+            body {
+                font-family: "Roboto", sans-serif;
+                padding-top: 70px;    /* account for the fixed navbar */
+                padding-bottom: 56px; /* account for the fixed breadcrumb bar */
+            }
+            nav {
+                position: fixed;
+                top: 0;
+                left: 0;
+                right: 0;
+                background: white;
+                box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+                padding: 12px 20px;
+                display: flex;
+                justify-content: flex-end;
+                align-items: center;
+                gap: 8px;
+                z-index: 1000;
+                border-bottom: 1px solid #e0e0e0;
+            }
+            .nav-btn {
+                padding: 10px 20px;
+                border: none;
+                border-radius: 4px;
+                cursor: pointer;
+                font-size: 14px;
+                font-weight: 500;
+                font-family: "Roboto", sans-serif;
+                background-color: #2196f3;
+                color: white;
+            }
+            .nav-btn:hover { background-color: #1976d2; }
+            .rdfa-editor-content {
+                margin: 0;
+                min-height: calc(100vh - 70px - 56px);
+                padding: 32px 48px 48px 48px; /* left >= 2.5em keeps the drag-handle gutter */
+                border: none;
+                background: white;
+                box-sizing: border-box;
+            }
+        </style>
+    </head>
+    <body>
+        <nav>
+            <button id="parse-rdf" class="nav-btn">Extract RDF</button>
+        </nav>
+
+        <div id="content" class="rdfa-editor-content" about="" typeof="http://schema.org/Article">
+            <h1 property="http://purl.org/dc/terms/title">LinkedDataHub blocks in the editor</h1>
+
+            <p>This page runs the editor with the <strong>LinkedDataHub blocks
+                extension</strong>: blocks defined purely in RDF — queries, charts, referenced
+                resources — embedded wherever an ordinary XHTML block can go. Each one is
+                stored as a few RDFa attributes; the rendering below is fetched and drawn on
+                the fly (content-negotiated from this server) and is never saved with the
+                page. Check <strong>Source</strong> in the toolbar to see the storage form,
+                or <strong>Extract RDF</strong> for the triples.</p>
+
+            <h2>A chart block</h2>
+            <p>A <code>ldh:ResultSetChart</code> pointing at a SPARQL query document:</p>
+
+            <div about="#population-chart"
+                    typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart">
+                <span property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span>
+                <span property="https://w3id.org/atomgraph/linkeddatahub#chartType" resource="https://w3id.org/atomgraph/client#BarChart"></span>
+                <span property="https://w3id.org/atomgraph/linkeddatahub#categoryVarName">country</span>
+                <span property="https://w3id.org/atomgraph/linkeddatahub#seriesVarName">population</span>
+            </div>
+
+            <h2>Blocks nest per the content model</h2>
+            <p>Anywhere a block element is allowed, an object block is allowed — here an
+                <code>ldh:Object</code> embedding a resource inside a list item:</p>
+            <ul>
+                <li>Author of the analytical engine notes:
+                    <div about="#ada-object"
+                            typeof="https://w3id.org/atomgraph/linkeddatahub#Object">
+                        <span property="http://www.w3.org/1999/02/22-rdf-syntax-ns#value" resource="resources/ada/#this"></span>
+                    </div>
+                </li>
+                <li>Ordinary list items edit as usual around it.</li>
+            </ul>
+
+            <p>Try it: press <strong>/</strong> in an empty paragraph and pick "Block…", or
+                use the ▦ toolbar button. Select a block with the arrow keys, delete it with
+                Backspace, undo with Ctrl/Cmd+Z — it behaves as one atomic unit.</p>
+        </div>
+    </body>
+</html>
diff --git a/demo/queries/population/index.rdf b/demo/queries/population/index.rdf
new file mode 100644
index 0000000..457fd8e
--- /dev/null
+++ b/demo/queries/population/index.rdf
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
+         xmlns:sp="http://spinrdf.org/sp#">
+    <!-- served by content negotiation at the document URI .../queries/population/
+         so "#this" resolves to .../queries/population/#this -->
+    <sp:Select rdf:about="#this">
+        <rdfs:label>Population by country</rdfs:label>
+        <sp:text>PREFIX dbo: &lt;http://dbpedia.org/ontology/&gt;
+
+SELECT  ?country ?population
+WHERE
+  { ?country  a                     dbo:Country ;
+              dbo:populationTotal   ?population
+  }
+ORDER BY DESC(?population)
+LIMIT   5</sp:text>
+    </sp:Select>
+</rdf:RDF>
diff --git a/demo/queries/population/results.xml b/demo/queries/population/results.xml
new file mode 100644
index 0000000..30aacc9
--- /dev/null
+++ b/demo/queries/population/results.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<sparql xmlns="http://www.w3.org/2005/sparql-results#">
+    <head>
+        <variable name="country"/>
+        <variable name="population"/>
+    </head>
+    <results>
+        <result>
+            <binding name="country"><literal>India</literal></binding>
+            <binding name="population"><literal datatype="http://www.w3.org/2001/XMLSchema#integer">1428627663</literal></binding>
+        </result>
+        <result>
+            <binding name="country"><literal>China</literal></binding>
+            <binding name="population"><literal datatype="http://www.w3.org/2001/XMLSchema#integer">1425671352</literal></binding>
+        </result>
+        <result>
+            <binding name="country"><literal>United States</literal></binding>
+            <binding name="population"><literal datatype="http://www.w3.org/2001/XMLSchema#integer">339996563</literal></binding>
+        </result>
+        <result>
+            <binding name="country"><literal>Indonesia</literal></binding>
+            <binding name="population"><literal datatype="http://www.w3.org/2001/XMLSchema#integer">277534122</literal></binding>
+        </result>
+        <result>
+            <binding name="country"><literal>Pakistan</literal></binding>
+            <binding name="population"><literal datatype="http://www.w3.org/2001/XMLSchema#integer">240485658</literal></binding>
+        </result>
+    </results>
+</sparql>
diff --git a/demo/resources/ada/index.rdf b/demo/resources/ada/index.rdf
new file mode 100644
index 0000000..ed1c6f5
--- /dev/null
+++ b/demo/resources/ada/index.rdf
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
+         xmlns:foaf="http://xmlns.com/foaf/0.1/">
+    <!-- served by content negotiation at the document URI .../resources/ada/
+         so "#this" resolves to .../resources/ada/#this -->
+    <foaf:Person rdf:about="#this">
+        <rdfs:label>Ada Lovelace</rdfs:label>
+        <foaf:name>Ada Lovelace</foaf:name>
+        <foaf:birthday>1815-12-10</foaf:birthday>
+        <foaf:interest rdf:resource="http://dbpedia.org/resource/Analytical_Engine"/>
+        <foaf:knows rdf:resource="http://dbpedia.org/resource/Charles_Babbage"/>
+    </foaf:Person>
+</rdf:RDF>
diff --git a/docs/ldh/MIGRATION.md b/docs/ldh/MIGRATION.md
index 9902982..ad3bda6 100644
--- a/docs/ldh/MIGRATION.md
+++ b/docs/ldh/MIGRATION.md
@@ -161,3 +161,81 @@ wrappers): view markup is edited in place and the canonical document is PUT, wit
 extracted server-side. This form-control integration is the stepping stone: the same
 canonicalization/sanitization boundary and the same editing surface carry over; the
 XMLLiteral round-trip (steps 1/3) is what falls away.
+
+### 12. Object blocks — the v6 block idiom and the render-hook bridge
+
+The editor's object blocks (src/blocks.xsl) implement the **v6 document format**
+([XHTML+RDFa as LDH v6 Document Format](https://github.com/AtomGraph/LinkedDataHub/wiki/XHTML-RDFa-as-LDH-v6-Document-Format)):
+blocks are XHTML elements carrying `@about` (a fragment URI — the block is a document
+part) and `@typeof` directly, with definition triples as `span[@property]` children
+(objects via `@resource`, literals as span *text content*), arbitrarily nestable per
+the content model. There are **no wrappers, no `rdf:_N` sequences, no
+document→block containment edges** — the document owns its blocks implicitly through
+its content, and `ldh:content` remains the document→body XMLLiteral property, never a
+per-block edge. The v5 block model (`ldh:XHTML`, `ldh:Object` indirection, flat
+sequences, row scaffolding, per-block CRUD SPARQL) is obsolete by the format itself;
+what the editor adds on top is the *editing* semantics (atomic islands) and the
+*rendering* seam.
+
+That stored shape is **the same shape LDH's renderers already match**: e.g. the v5
+chart entry (`client/block/chart.xsl:259`) matches
+`*[@typeof = ('&ldh;ResultSetChart', …)][descendant::*[@property = '&spin;query'][@resource]]…`
+and reads `spin:query`/`ldh:chartType`/`ldh:categoryVarName` off descendant
+`@property` elements — and the v6 rendering mode `ldh:Block` is defined exactly as
+"match `@typeof`, read properties from `@property` descendants". So the bridge is
+thin: client.xsl plays the extension role that src/ldh-blocks.xsl plays in the
+standalone demo — it re-declares the island class list and, per type, hands the
+island to its block-rendering machinery (`ldh:Block` in v6; the v5 `ldh:RenderRow`
+example below works the same way) with the ephemeral rendering div as the container:
+
+```xml
+<!-- client.xsl (imports the editor modules, higher import precedence) -->
+<xsl:param name="object-block-types" as="xs:string*"
+    select="('&ldh;Object', '&ldh;View', '&ldh;ResultSetChart', '&ldh;GraphChart')"/>
+
+<xsl:template match="div[tokenize(@typeof) = ('&ldh;ResultSetChart', '&ldh;GraphChart')]"
+        mode="local:render-island">
+    <xsl:variable name="island" as="element()" select="."/>
+    <!-- the container ldh:RenderRow renders into: the ephemeral rendering div
+         (canonicalization-stripped, extractor-skipped). Seed it with the LDH
+         progress-bar markup; the thunk chain replaces it with the chart -->
+    <xsl:call-template name="local:replace-rendering">
+        <xsl:with-param name="island" select="$island"/>
+        <xsl:with-param name="content">
+            <div class="progress progress-striped active">
+                <div class="bar" style="width: 0%;"></div>
+            </div>
+        </xsl:with-param>
+    </xsl:call-template>
+    <xsl:variable name="container" as="element()" select="$island/*[@data-role = 'rendering']"/>
+    <xsl:for-each select="$container">
+        <!-- RenderRow addresses its container by id (canonicalization-stripped) -->
+        <ixsl:set-attribute name="id" select="generate-id($island) || '-rendering'"/>
+    </xsl:for-each>
+    <xsl:apply-templates select="$island" mode="ldh:RenderRow">
+        <!-- the island IS the block: no .row-fluid.block scaffolding, the subject
+             is the island's own @about (a fragment URI per the v6 format) -->
+        <xsl:with-param name="block" select="$island"/>
+        <xsl:with-param name="about"
+            select="xs:anyURI(resolve-uri($island/@about, ldh:base-uri(ixsl:page())))"/>
+        <xsl:with-param name="container" select="$container"/>
+    </xsl:apply-templates>
+</xsl:template>
+```
+
+The existing async pipelines (`ldh:chart-self-thunk` → `ldh:chart-query-thunk` →
+`ldh:chart-results-thunk` → Google Charts `draw()`) run unchanged — they are already
+container-plus-context-map based, and literal definition values are span text
+content per the v6 format, exactly what their selectors read. One caveat: chart
+canvases don't survive an `innerHTML` undo restore; the editor re-fires
+`local:render-island` only for islands *without* a rendering div, so a
+canvas-bearing bridge should also re-draw from the `LinkedDataHub.contents` cache
+when its canvas is dead (LDH already does this on mode switches).
+
+What the seam exposes to client.xsl is exactly what v6's `ldh:Block` mode needs: the
+per-type match shapes (`@typeof` + `@property` descendants, already RDFa-driven) and
+the thunk pipelines behind them; everything the v6 format removed (`rdf:_N`
+ordering/renumbering SPARQL, `ldh:XHTML`/`ldh:Object` wrappers, row scaffolding,
+per-block CRUD chrome) is likewise absent from the editor's side of the contract —
+ordering is document order, reorder/delete/undo are editor gestures, persistence is
+the one document PATCH.
diff --git a/generate-sef.sh b/generate-sef.sh
index ae3e181..769e659 100644
--- a/generate-sef.sh
+++ b/generate-sef.sh
@@ -3,8 +3,12 @@
 mkdir -p build
 find src -maxdepth 1 -type f -name "*.xsl" -exec sh -c 'xmlstarlet c14n "$1" > "build/$(basename "$1")"' x {} \;
 
-# compile the client stylesheet to SEF. -relocate:on means relative document() hrefs
+# compile the client stylesheets to SEF. -relocate:on means relative document() hrefs
 # resolve against the SEF load location, i.e. dist/ — hence the vocabs/ copy below.
+# Two flavors: the CORE editor (index.xsl → dist/index.xsl.sef.json, deployed to
+# GitHub Pages) and the LinkedDataHub-extended editor (ldh-editor.xsl →
+# dist/ldh-editor.xsl.sef.json, used by demo/ and the browser tests — local only,
+# its object blocks need the content-negotiating dev server).
 
 echo "Generating SEF file from src/index.xsl..."
 
@@ -18,6 +22,17 @@ else
     exit 1
 fi
 
+echo "Generating SEF file from src/ldh-editor.xsl..."
+
+npx xslt3-he -t -xsl:./build/ldh-editor.xsl -export:./dist/ldh-editor.xsl.sef.json -nogo -ns:##html5 -relocate:on
+
+if [ $? -eq 0 ]; then
+    echo "✓ SEF file generated successfully: dist/ldh-editor.xsl.sef.json"
+else
+    echo "✗ Error generating SEF file"
+    exit 1
+fi
+
 mkdir -p dist/vocabs
 cp vocabs/*.rdf dist/vocabs/
 echo "✓ Vocabularies copied to dist/vocabs/"
diff --git a/rdfa-editor.css b/rdfa-editor.css
index 1dac6b1..070d661 100644
--- a/rdfa-editor.css
+++ b/rdfa-editor.css
@@ -143,6 +143,34 @@
                 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;
diff --git a/serve.mjs b/serve.mjs
new file mode 100644
index 0000000..0a69190
--- /dev/null
+++ b/serve.mjs
@@ -0,0 +1,53 @@
+// Static dev server with Linked Data content negotiation (LDH-style):
+// a trailing-slash URL is a *document URI* whose representation is chosen by
+// the Accept header — application/rdf+xml serves the directory's index.rdf,
+// application/sparql-results+xml its results.xml, text/html its index.html.
+// URLs never carry file extensions; the file layout stays server-private.
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { extname, join, normalize } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = fileURLToPath(new URL('.', import.meta.url));
+const port = Number(process.argv[2] ?? process.env.PORT ?? 8000);
+
+const mime = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.mjs': 'text/javascript',
+    '.json': 'application/json', '.css': 'text/css', '.rdf': 'application/rdf+xml',
+    '.xml': 'application/xml', '.xsl': 'application/xslt+xml', '.png': 'image/png' };
+
+// negotiable representations of a document URI, matched against Accept in order
+const representations = [
+    { type: 'application/rdf+xml', file: 'index.rdf' },
+    { type: 'application/sparql-results+xml', file: 'results.xml' },
+    { type: 'text/html; charset=utf-8', match: 'text/html', file: 'index.html' },
+];
+
+const server = createServer(async (req, res) => {
+    try {
+        const pathname = decodeURIComponent(new URL(req.url, 'http://x').pathname);
+        const path = normalize(pathname).replace(/^([/\\])+/, '');
+        if (pathname.endsWith('/')) {
+            const accept = req.headers.accept ?? '';
+            const candidates = representations.filter(rep => accept.includes(rep.match ?? rep.type));
+            for (const rep of candidates.length ? candidates
+                    : representations.filter(rep => rep.file === 'index.html')) {
+                try {
+                    const body = await readFile(join(root, path, rep.file));
+                    res.writeHead(200, { 'Content-Type': rep.type });
+                    res.end(body);
+                    return;
+                } catch { /* try the next representation */ }
+            }
+            res.writeHead(406);
+            res.end();
+            return;
+        }
+        const body = await readFile(join(root, path));
+        res.writeHead(200, { 'Content-Type': mime[extname(path)] ?? 'application/octet-stream' });
+        res.end(body);
+    } catch {
+        res.writeHead(404);
+        res.end();
+    }
+});
+server.listen(port, () => console.log(`Serving ${root} at http://localhost:${server.address().port}/ — Ctrl-C to stop`));
diff --git a/src/blocks.xsl b/src/blocks.xsl
new file mode 100644
index 0000000..ab565a9
--- /dev/null
+++ b/src/blocks.xsl
@@ -0,0 +1,103 @@
+<?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 (LinkedDataHub queries, charts, views, ...)
+    embedded in content as self-describing RDFa placeholders - a div whose @typeof
+    matches $object-block-types, carrying its defining triples as property spans.
+    The editor treats such a div as an atomic island: 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 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="()"/>
+
+    <!-- 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])"/>
+    </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 and resource.
+         Extension templates matching per @typeof 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))[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/edit.xsl b/src/edit.xsl
index 9b7e1ea..6b997ff 100644
--- a/src/edit.xsl
+++ b/src/edit.xsl
@@ -83,23 +83,30 @@ version="3.0">
 
     <!-- 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 - composites are hard boundaries (B3/B6), so an empty result
-         leaves the gesture inert -->
+         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:sequence select="local:last-host-in($element)
-            [empty(ancestor-or-self::*[self::table or self::figure]
-                intersect $element/descendant-or-self::*)]"/>
+        <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. An image can't hold a caret, so it
-         is a navigation island in its own right - focused (selected) rather than
-         given a caret - see local:land-forward/-backward -->
+         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 (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
@@ -215,15 +222,16 @@ version="3.0">
         <xsl:sequence select="ixsl:call($element, 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
     </xsl:template>
 
-    <!-- a block image is 'selected' by focusing it (it carries tabindex=-1, set at
-         init); the text caret is cleared so only the image reads as the current
-         target. Its onfocusin records it as the active block, so toolbar/drag act
-         on its figure just as for a focused editable host -->
-    <xsl:template name="local:select-image">
-        <xsl:param name="image" as="element()"/>
+    <!-- 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="$image"/>
+            <xsl:with-param name="element" select="$element"/>
         </xsl:call-template>
     </xsl:template>
 
@@ -232,9 +240,9 @@ version="3.0">
     <xsl:template name="local:land-forward">
         <xsl:param name="target" as="element()"/>
         <xsl:choose>
-            <xsl:when test="$target/self::img">
-                <xsl:call-template name="local:select-image">
-                    <xsl:with-param name="image" select="$target"/>
+            <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>
@@ -251,9 +259,9 @@ version="3.0">
     <xsl:template name="local:land-backward">
         <xsl:param name="target" as="element()"/>
         <xsl:choose>
-            <xsl:when test="$target/self::img">
-                <xsl:call-template name="local:select-image">
-                    <xsl:with-param name="image" select="$target"/>
+            <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>
@@ -283,6 +291,8 @@ version="3.0">
                 <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()">
@@ -319,6 +329,21 @@ version="3.0">
         <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) -->
@@ -350,8 +375,10 @@ version="3.0">
             </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) -->
-        <xsl:for-each select="$block/descendant-or-self::img[empty(ancestor::*[@contenteditable = 'true'])]">
+             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="$block/parent::*[contains-token(@class, 'rdfa-editor-content')]">
@@ -366,7 +393,7 @@ version="3.0">
          the container becomes a plain text host again -->
     <xsl:template name="local:collapse-container">
         <xsl:param name="container" as="element()"/>
-        <xsl:if test="cm:flow(local-name($container))
+        <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))])">
@@ -461,6 +488,7 @@ version="3.0">
             <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>
@@ -803,14 +831,15 @@ version="3.0">
         </xsl:if>
     </xsl:template>
 
-    <!-- a focused block image is a navigation island: plain arrow keys move to the
-         adjacent target (image <-> caret), matching text-block crossing, and
-         Backspace/Delete removes its figure. Since the image 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')]//img" mode="ixsl:onkeydown">
+    <!-- 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 image selects its whole region: the image is
+        <!-- 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'))
@@ -823,14 +852,32 @@ version="3.0">
                 </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="image" as="element()" select="."/>
+            <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; $image])[1]">
+                    <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="."/>
@@ -838,19 +885,20 @@ version="3.0">
                     </xsl:for-each>
                 </xsl:when>
                 <xsl:when test="$key = ('ArrowUp', 'ArrowLeft')">
-                    <xsl:for-each select="($targets[. &lt;&lt; $image])[last()]">
+                    <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
-                     (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 image), the
+                <!-- 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')]"/>
@@ -859,7 +907,7 @@ version="3.0">
                 <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="($image/ancestor-or-self::figure[exists(local:block-of(.))][1], $image)[1]"/>
+                        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::*)]"/>
@@ -896,10 +944,10 @@ version="3.0">
         </xsl:if>
     </xsl:template>
 
-    <!-- a focused block image becomes the active block, so toolbar/breadcrumb resolve
-         to 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')]//img" mode="ixsl:onfocusin">
+    <!-- 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"/>
@@ -1199,19 +1247,29 @@ version="3.0">
                             </xsl:call-template>
                             <xsl:call-template name="local:after-mutation"/>
                         </xsl:when>
-                        <!-- B3: never merge across composite blocks; an empty block is removed -->
+                        <!-- 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: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: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/>
@@ -2061,17 +2119,17 @@ version="3.0">
         <xsl:call-template name="local:hide-dialogs"/>
     </xsl:template>
 
-    <xsl:template match="div[@id = ('link-dialog', 'figure-dialog', 'table-dialog', 'find-dialog', 'slash-menu')]" mode="ixsl:onkeydown">
+    <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 -->
+    <!-- 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="id('link-dialog', ixsl:page()), id('figure-dialog', ixsl:page()),
-                id('table-dialog', ixsl:page()), id('find-dialog', ixsl:page()),
+        <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>
diff --git a/src/index.xsl b/src/index.xsl
index d6314f5..bf17b0b 100644
--- a/src/index.xsl
+++ b/src/index.xsl
@@ -22,6 +22,7 @@ version="3.0">
     - overlay.xsl          annotation form: rendering, reading, populating, visibility
     - 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
@@ -37,6 +38,7 @@ version="3.0">
     <xsl:include href="overlay.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"/>
diff --git a/src/input.xsl b/src/input.xsl
index 9d2bbcf..eff247a 100644
--- a/src/input.xsl
+++ b/src/input.xsl
@@ -235,6 +235,9 @@ version="3.0">
                 <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>
@@ -358,7 +361,14 @@ version="3.0">
                         <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
                     </xsl:for-each>
                 </xsl:when>
-                <xsl:otherwise/>
+                <!-- 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>
diff --git a/src/ldh-blocks.xsl b/src/ldh-blocks.xsl
new file mode 100644
index 0000000..91db8ba
--- /dev/null
+++ b/src/ldh-blocks.xsl
@@ -0,0 +1,504 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE xsl:stylesheet [
+    <!ENTITY ldh    "https://w3id.org/atomgraph/linkeddatahub#">
+    <!ENTITY ac     "https://w3id.org/atomgraph/client#">
+    <!ENTITY rdf    "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+    <!ENTITY spin   "http://spinrdf.org/spin#">
+]>
+<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:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
+xmlns:sp="http://spinrdf.org/sp#"
+xmlns:srx="http://www.w3.org/2005/sparql-results#"
+extension-element-prefixes="ixsl"
+xpath-default-namespace="http://www.w3.org/1999/xhtml"
+version="3.0">
+
+<!--
+    LinkedDataHub blocks extension: makes ldh:Object / ldh:View /
+    ldh:ResultSetChart placeholders first-class island blocks. Included by the
+    ldh-editor.xsl entry at HIGHER import precedence than the core (which it
+    xsl:imports), so the declarations here override the core's:
+
+    - $object-block-types is re-declared with the LDH class IRIs;
+    - per-type mode="local:render-island" templates replace the neutral card
+      with real async hydration via the SaxonJS 3 promise API (ixsl:promise +
+      ixsl:http-request => ixsl:then, LDH's ldh:*-thunk idiom). Document URIs
+      follow the Linked Data convention: trailing slash, no file extensions,
+      representations chosen by CONTENT NEGOTIATION on the clean URI -
+      Accept: application/rdf+xml for the description, and (demo stand-in for
+      live SPARQL execution) Accept: application/sparql-results+xml for canned
+      results of a query document (serve.mjs / tests/browser/run.mjs negotiate).
+      In production, LinkedDataHub's client.xsl plays this module's role,
+      bridging into its block rendering - v6 mode ldh:Block, v5 ldh:RenderRow
+      (docs/ldh/MIGRATION.md par. 12);
+    - the "Block..." insert dialog plugs into the core's extension hooks
+      (local:render-extra-dialogs / -insert-buttons / -slash-items /
+      local:run-extra-slash-command).
+
+    Relative @resource IRIs resolve against the page base (local:document-uri),
+    matching the RDFa extractor's resolution - never against the SEF location.
+-->
+
+    <xsl:param name="object-block-types" as="xs:string*" select="(
+        '&ldh;Object',
+        '&ldh;View',
+        '&ldh;ResultSetChart')"/>
+
+    <!-- ................................ renderers ................................ -->
+
+    <!-- ldh:View / ldh:ResultSetChart: fetch the spin:query resource, then the
+         canned results; a chart also captions itself from its own definition
+         spans. Placeholders missing the spin:query span fall through to the
+         core's neutral card (deep-skip backstop) -->
+    <xsl:template match="div[tokenize(@typeof) = ('&ldh;View', '&ldh;ResultSetChart')]
+            [descendant::*[@property = '&spin;query'][@resource]]" mode="local:render-island">
+        <xsl:variable name="chart-type" as="xs:string?"
+            select="(descendant::*[@property = '&ldh;chartType']/@resource)[1] ! string(.)"/>
+        <xsl:variable name="category" as="xs:string?"
+            select="(descendant::*[@property = '&ldh;categoryVarName']/(@content, text())[1])[1] ! string(.)"/>
+        <xsl:variable name="series" as="xs:string*"
+            select="descendant::*[@property = '&ldh;seriesVarName']/(@content, text())[1] ! string(.)"/>
+        <xsl:variable name="heading" as="xs:string" select="string-join((
+            $chart-type ! replace(., '^.*[#/]', ''),
+            string-join(($category[. ne ''], string-join($series[. ne ''], ', ')[. ne '']), ' &#xD7; ')[. ne '']
+            ), ' &#xB7; ')"/>
+        <xsl:call-template name="local:load-query-block">
+            <xsl:with-param name="island" select="."/>
+            <xsl:with-param name="heading" select="$heading"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- ldh:Object: fetch the referenced resource's document and render its
+         description as a property table -->
+    <xsl:template match="div[tokenize(@typeof) = '&ldh;Object']
+            [descendant::*[@property = '&rdf;value'][@resource]]" mode="local:render-island">
+        <xsl:variable name="island" as="element()" select="."/>
+        <xsl:variable name="value-uri" as="xs:string" select="string(resolve-uri(
+            string((descendant::*[@property = '&rdf;value']/@resource)[1]), local:document-uri()))"/>
+        <xsl:variable name="value-doc" as="xs:string" select="substring-before($value-uri || '#', '#')"/>
+        <xsl:sequence select="ixsl:call(ixsl:get($island, 'classList'), 'add', [ 'rdfa-editor-loading' ])[current-date() lt xs:date('2000-01-01')]"/>
+        <ixsl:promise select="
+            ixsl:http-request(map{ 'method': 'GET', 'href': $value-doc,
+                'headers': map{ 'Accept': 'application/rdf+xml' } }) =>
+                ixsl:then(local:block-object-response($island, $value-uri, $value-doc, ?))"
+            on-failure="local:block-render-failure($island, ?)"/>
+    </xsl:template>
+
+    <!-- shared query-block flow: promise chain fetching the query document,
+         then (in its callback) the results document. The rendering div is
+         injected only in the final callback, per the render-hook contract -->
+    <xsl:template name="local:load-query-block">
+        <xsl:param name="island" as="element()"/>
+        <xsl:param name="heading" as="xs:string?"/>
+        <xsl:variable name="query-uri" as="xs:string" select="string(resolve-uri(
+            string(($island/descendant::*[@property = '&spin;query']/@resource)[1]), local:document-uri()))"/>
+        <xsl:variable name="query-doc" as="xs:string" select="substring-before($query-uri || '#', '#')"/>
+        <xsl:sequence select="ixsl:call(ixsl:get($island, 'classList'), 'add', [ 'rdfa-editor-loading' ])[current-date() lt xs:date('2000-01-01')]"/>
+        <ixsl:promise select="
+            ixsl:http-request(map{ 'method': 'GET', 'href': $query-doc,
+                'headers': map{ 'Accept': 'application/rdf+xml' } }) =>
+                ixsl:then(local:block-query-response($island, $query-uri, $heading, ?))"
+            on-failure="local:block-render-failure($island, ?)"/>
+    </xsl:template>
+
+    <!-- first hop: the query document (Accept: application/rdf+xml). Pulls
+         sp:text (and rdfs:label as the fallback heading), then fires the
+         results fetch - the SAME clean URI, negotiated for SPARQL results -->
+    <xsl:function name="local:block-query-response" as="item()*" ixsl:updating="yes">
+        <xsl:param name="island" as="element()"/>
+        <xsl:param name="query-uri" as="xs:string"/>
+        <xsl:param name="heading" as="xs:string?"/>
+        <xsl:param name="response" as="map(*)"/>
+        <xsl:variable name="body" as="document-node()?" select="$response?body[. instance of document-node()]"/>
+        <xsl:variable name="query-doc" as="xs:string" select="substring-before($query-uri || '#', '#')"/>
+        <xsl:choose>
+            <xsl:when test="$response?status = 200 and exists($body)">
+                <!-- relative rdf:about values resolve against the document URI
+                     (the request URI), per RDF/XML base semantics -->
+                <xsl:variable name="query" as="element()?"
+                    select="($body//*[@rdf:about][string(resolve-uri(@rdf:about, $query-doc)) = $query-uri],
+                        $body//*[sp:text])[1]"/>
+                <xsl:variable name="query-text" as="xs:string?" select="($query/sp:text)[1] ! string(.)"/>
+                <xsl:variable name="final-heading" as="xs:string?"
+                    select="($heading[. ne ''], ($query/rdfs:label)[1] ! string(.))[1]"/>
+                <ixsl:promise select="
+                    ixsl:http-request(map{ 'method': 'GET', 'href': $query-doc,
+                        'headers': map{ 'Accept': 'application/sparql-results+xml' } }) =>
+                        ixsl:then(local:block-results-response($island, $final-heading, $query-text, ?))"
+                    on-failure="local:block-render-failure($island, ?)"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:block-render-error">
+                    <xsl:with-param name="island" select="$island"/>
+                    <xsl:with-param name="message" select="'Failed to load the query (' || $query-uri || ')'
+                        || local:conneg-hint($response)"/>
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- a 200 with the wrong representation means the server ignored the Accept
+         header: the demo needs the content-negotiating dev server (make up) -->
+    <xsl:function name="local:conneg-hint" as="xs:string">
+        <xsl:param name="response" as="map(*)"/>
+        <xsl:sequence select="(' - the server did not content-negotiate the representation; serve with ''make up'' (serve.mjs)'[$response?status = 200], '')[1]"/>
+    </xsl:function>
+
+    <!-- second hop: the SPARQL Results XML document, rendered as a real table -->
+    <xsl:function name="local:block-results-response" as="item()*" ixsl:updating="yes">
+        <xsl:param name="island" as="element()"/>
+        <xsl:param name="heading" as="xs:string?"/>
+        <xsl:param name="query-text" as="xs:string?"/>
+        <xsl:param name="response" as="map(*)"/>
+        <xsl:variable name="results" as="document-node()?" select="$response?body[. instance of document-node()]"/>
+        <xsl:choose>
+            <xsl:when test="$response?status = 200 and exists($results/srx:sparql)">
+                <xsl:variable name="vars" as="xs:string*" select="$results/srx:sparql/srx:head/srx:variable/@name ! string(.)"/>
+                <xsl:sequence select="ixsl:call(ixsl:get($island, 'classList'), 'remove', [ 'rdfa-editor-loading' ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:call-template name="local:replace-rendering">
+                    <xsl:with-param name="island" select="$island"/>
+                    <xsl:with-param name="content">
+                        <div class="rdfa-editor-island-card">
+                            <xsl:for-each select="$heading[. ne '']">
+                                <strong><xsl:value-of select="."/></strong>
+                            </xsl:for-each>
+                            <xsl:for-each select="$query-text[. ne '']">
+                                <pre class="rdfa-editor-island-query"><xsl:value-of select="."/></pre>
+                            </xsl:for-each>
+                            <table>
+                                <thead>
+                                    <tr>
+                                        <xsl:for-each select="$vars">
+                                            <th><xsl:value-of select="."/></th>
+                                        </xsl:for-each>
+                                    </tr>
+                                </thead>
+                                <tbody>
+                                    <xsl:for-each select="$results/srx:sparql/srx:results/srx:result">
+                                        <xsl:variable name="result" as="element()" select="."/>
+                                        <tr>
+                                            <xsl:for-each select="$vars">
+                                                <xsl:variable name="var" as="xs:string" select="."/>
+                                                <td><xsl:value-of select="$result/srx:binding[@name = $var]/(srx:uri, srx:literal, srx:bnode)[1]"/></td>
+                                            </xsl:for-each>
+                                        </tr>
+                                    </xsl:for-each>
+                                </tbody>
+                            </table>
+                        </div>
+                    </xsl:with-param>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:block-render-error">
+                    <xsl:with-param name="island" select="$island"/>
+                    <xsl:with-param name="message" select="'Failed to load results (' || string($response?status) || ')'
+                        || local:conneg-hint($response)"/>
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- ldh:Object hop: the referenced resource's description as a property table -->
+    <xsl:function name="local:block-object-response" as="item()*" ixsl:updating="yes">
+        <xsl:param name="island" as="element()"/>
+        <xsl:param name="value-uri" as="xs:string"/>
+        <xsl:param name="value-doc" as="xs:string"/>
+        <xsl:param name="response" as="map(*)"/>
+        <xsl:variable name="body" as="document-node()?" select="$response?body[. instance of document-node()]"/>
+        <xsl:variable name="description" as="element()?"
+            select="($body//*[@rdf:about][string(resolve-uri(@rdf:about, $value-doc)) = $value-uri],
+                $body/rdf:RDF/*)[1]"/>
+        <xsl:choose>
+            <xsl:when test="$response?status = 200 and exists($description)">
+                <xsl:sequence select="ixsl:call(ixsl:get($island, 'classList'), 'remove', [ 'rdfa-editor-loading' ])[current-date() lt xs:date('2000-01-01')]"/>
+                <xsl:call-template name="local:replace-rendering">
+                    <xsl:with-param name="island" select="$island"/>
+                    <xsl:with-param name="content">
+                        <div class="rdfa-editor-island-card">
+                            <strong><xsl:value-of select="(($description/rdfs:label)[1] ! string(.), $value-uri)[1]"/></strong>
+                            <table>
+                                <tbody>
+                                    <xsl:for-each select="$description/*">
+                                        <tr>
+                                            <th><xsl:value-of select="local-name()"/></th>
+                                            <td><xsl:value-of select="(string(@rdf:resource)[. ne ''], string(.))[1]"/></td>
+                                        </tr>
+                                    </xsl:for-each>
+                                </tbody>
+                            </table>
+                        </div>
+                    </xsl:with-param>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="local:block-render-error">
+                    <xsl:with-param name="island" select="$island"/>
+                    <xsl:with-param name="message" select="'Failed to load the resource (' || $value-uri || ')'
+                        || local:conneg-hint($response)"/>
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- a failed fetch must never wedge the loading state -->
+    <xsl:template name="local:block-render-error">
+        <xsl:param name="island" as="element()"/>
+        <xsl:param name="message" as="xs:string"/>
+        <xsl:sequence select="ixsl:call(ixsl:get($island, 'classList'), 'remove', [ 'rdfa-editor-loading' ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="local:replace-rendering">
+            <xsl:with-param name="island" select="$island"/>
+            <xsl:with-param name="content">
+                <div class="rdfa-editor-island-error"><xsl:value-of select="$message"/></div>
+            </xsl:with-param>
+        </xsl:call-template>
+    </xsl:template>
+
+    <xsl:function name="local:block-render-failure" as="item()*" ixsl:updating="yes">
+        <xsl:param name="island" as="element()"/>
+        <xsl:param name="error" as="item()?"/>
+        <xsl:call-template name="local:block-render-error">
+            <xsl:with-param name="island" select="$island"/>
+            <xsl:with-param name="message" select="'Failed to load block data'"/>
+        </xsl:call-template>
+    </xsl:function>
+
+    <!-- ................................ insert dialog ................................ -->
+
+    <xsl:template name="local:render-extra-dialogs">
+        <div id="ldh-block-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
+                aria-label="Insert block" style="display: none;">
+            <label>Block type</label>
+            <select name="block-type-iri">
+                <option value="&ldh;Object">Object</option>
+                <option value="&ldh;View">View</option>
+                <option value="&ldh;ResultSetChart">Result set chart</option>
+            </select>
+            <label>Fragment id</label>
+            <input type="text" name="about" placeholder="#chart-1"/>
+            <div class="ldh-fields ldh-fields-object">
+                <label>Resource URI</label>
+                <input type="text" name="object-value"/>
+                <label>Mode URI (optional)</label>
+                <input type="text" name="object-mode"/>
+            </div>
+            <div class="ldh-fields ldh-fields-view" style="display: none;">
+                <label>Query URI</label>
+                <input type="text" name="view-query"/>
+                <label>Mode URI (optional)</label>
+                <input type="text" name="view-mode"/>
+            </div>
+            <div class="ldh-fields ldh-fields-chart" style="display: none;">
+                <label>Query URI</label>
+                <input type="text" name="chart-query"/>
+                <label>Chart type</label>
+                <select name="chart-type">
+                    <option value="&ac;Table">Table</option>
+                    <option value="&ac;BarChart">Bar chart</option>
+                    <option value="&ac;LineChart">Line chart</option>
+                    <option value="&ac;ScatterChart">Scatter chart</option>
+                </select>
+                <label>Category variable</label>
+                <input type="text" name="chart-category"/>
+                <label>Series variable</label>
+                <input type="text" name="chart-series"/>
+            </div>
+            <div class="action-buttons">
+                <button type="button" class="btn-primary ldh-block-save">Insert</button>
+                <button type="button" class="btn-secondary ldh-block-cancel">Cancel</button>
+            </div>
+        </div>
+    </xsl:template>
+
+    <xsl:template name="local:render-extra-insert-buttons">
+        <button type="button" class="insert-ldh-block" title="Insert block" aria-label="Insert LinkedDataHub block">&#x25A6;</button>
+    </xsl:template>
+
+    <xsl:template name="local:render-extra-slash-items">
+        <li class="slash-item" data-command="ldh-block" role="option">Block&#x2026;</li>
+    </xsl:template>
+
+    <!-- reset to the Object defaults (mirrors the figure/table openers) -->
+    <xsl:template name="local:reset-ldh-block-dialog">
+        <xsl:variable name="dialog" as="element()" select="id('ldh-block-dialog', ixsl:page())"/>
+        <xsl:for-each select="$dialog//input">
+            <ixsl:set-property name="value" select="''" object="."/>
+        </xsl:for-each>
+        <xsl:for-each select="($dialog//select[@name = 'block-type-iri'])[1]">
+            <ixsl:set-property name="value" select="'&ldh;Object'" object="."/>
+        </xsl:for-each>
+        <xsl:call-template name="local:toggle-ldh-block-fields">
+            <xsl:with-param name="dialog" select="$dialog"/>
+            <xsl:with-param name="type" select="'&ldh;Object'"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <xsl:template name="local:toggle-ldh-block-fields">
+        <xsl:param name="dialog" as="element()"/>
+        <xsl:param name="type" as="xs:string"/>
+        <xsl:for-each select="$dialog//div[contains-token(@class, 'ldh-fields-object')]">
+            <ixsl:set-style name="display" select="if ($type = '&ldh;Object') then 'block' else 'none'"/>
+        </xsl:for-each>
+        <xsl:for-each select="$dialog//div[contains-token(@class, 'ldh-fields-view')]">
+            <ixsl:set-style name="display" select="if ($type = '&ldh;View') then 'block' else 'none'"/>
+        </xsl:for-each>
+        <xsl:for-each select="$dialog//div[contains-token(@class, 'ldh-fields-chart')]">
+            <ixsl:set-style name="display" select="if ($type = '&ldh;ResultSetChart') then 'block' else 'none'"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template match="div[@id = 'ldh-block-dialog']//select[@name = 'block-type-iri']" mode="ixsl:onchange">
+        <xsl:call-template name="local:toggle-ldh-block-fields">
+            <xsl:with-param name="dialog" select="ancestor::div[@id = 'ldh-block-dialog']"/>
+            <xsl:with-param name="type" select="string(ixsl:get(., 'value'))"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'insert-ldh-block')]" mode="ixsl:onclick">
+        <ixsl:set-property name="insertHost"
+            select="local:current-host()[exists(local:block-of(.))]" object="local:editor-state()"/>
+        <xsl:call-template name="local:reset-ldh-block-dialog"/>
+        <xsl:call-template name="local:show-at">
+            <xsl:with-param name="element" select="id('ldh-block-dialog', ixsl:page())"/>
+            <xsl:with-param name="event" select="ixsl:event()"/>
+        </xsl:call-template>
+        <xsl:for-each select="(id('ldh-block-dialog', ixsl:page())//input[@name = 'about'])[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-extra-slash-command">
+        <xsl:param name="command" as="xs:string"/>
+        <xsl:param name="host" as="element()?"/>
+        <xsl:if test="$command = 'ldh-block'">
+            <ixsl:set-property name="insertHost" select="$host" object="local:editor-state()"/>
+            <xsl:variable name="dialog" as="element()" select="id('ldh-block-dialog', ixsl:page())"/>
+            <xsl:call-template name="local:reset-ldh-block-dialog"/>
+            <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 = 'about'])[1]">
+                <xsl:sequence select="ixsl:call(., 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:for-each>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- a definition span: RDFa as real DOM attributes (they must serialize);
+         literal values go in TEXT CONTENT per the v6 document format (the spans
+         render display:none via rdfa-editor.css) -->
+    <xsl:template name="local:make-definition-span">
+        <xsl:param name="property" as="xs:string"/>
+        <xsl:param name="resource" as="xs:string?" select="()"/>
+        <xsl:param name="text" as="xs:string?" select="()"/>
+        <xsl:variable name="span" as="element()" select="local:element('span')"/>
+        <ixsl:set-attribute name="property" select="$property" object="$span"/>
+        <xsl:for-each select="$resource[. ne '']">
+            <ixsl:set-attribute name="resource" select="." object="$span"/>
+        </xsl:for-each>
+        <xsl:for-each select="$text[. ne '']">
+            <ixsl:set-property name="textContent" select="." object="$span"/>
+        </xsl:for-each>
+        <xsl:sequence select="$span"/>
+    </xsl:template>
+
+    <xsl:template match="button[contains-token(@class, 'ldh-block-save')]" mode="ixsl:onclick">
+        <xsl:variable name="dialog" as="element()" select="ancestor::div[@id = 'ldh-block-dialog']"/>
+        <xsl:variable name="type" as="xs:string" select="string(ixsl:get(($dialog//select[@name = 'block-type-iri'])[1], 'value'))"/>
+        <xsl:variable name="about" as="xs:string" select="normalize-space(string(ixsl:get(($dialog//input[@name = 'about'])[1], 'value')))"/>
+        <xsl:variable name="object-value" as="xs:string" select="normalize-space(string(ixsl:get(($dialog//input[@name = 'object-value'])[1], 'value')))"/>
+        <xsl:variable name="object-mode" as="xs:string" select="normalize-space(string(ixsl:get(($dialog//input[@name = 'object-mode'])[1], 'value')))"/>
+        <xsl:variable name="view-query" as="xs:string" select="normalize-space(string(ixsl:get(($dialog//input[@name = 'view-query'])[1], 'value')))"/>
+        <xsl:variable name="view-mode" as="xs:string" select="normalize-space(string(ixsl:get(($dialog//input[@name = 'view-mode'])[1], 'value')))"/>
+        <xsl:variable name="chart-query" as="xs:string" select="normalize-space(string(ixsl:get(($dialog//input[@name = 'chart-query'])[1], 'value')))"/>
+        <xsl:variable name="chart-type" as="xs:string" select="string(ixsl:get(($dialog//select[@name = 'chart-type'])[1], 'value'))"/>
+        <xsl:variable name="chart-category" as="xs:string" select="normalize-space(string(ixsl:get(($dialog//input[@name = 'chart-category'])[1], 'value')))"/>
+        <xsl:variable name="chart-series" as="xs:string" select="normalize-space(string(ixsl:get(($dialog//input[@name = 'chart-series'])[1], 'value')))"/>
+        <xsl:variable name="valid" as="xs:boolean" select="$about ne '' and (
+            if ($type = '&ldh;Object') then $object-value ne ''
+            else if ($type = '&ldh;View') then $view-query ne ''
+            else $chart-query ne '')"/>
+        <xsl:if test="$valid">
+            <xsl:call-template name="local:push-undo"/>
+            <!-- the v6 block idiom: @about (fragment URI - the block is a document
+                 part) + @typeof directly on the element, definition triples as
+                 property spans; NO containment edge - the document owns its blocks
+                 implicitly through its content (XHTML-RDFa-as-LDH-v6-Document-Format) -->
+            <xsl:variable name="island" as="element()" select="local:element('div')"/>
+            <ixsl:set-attribute name="about" select="$about" object="$island"/>
+            <ixsl:set-attribute name="typeof" select="$type" object="$island"/>
+            <xsl:variable name="spans" as="element()*">
+                <xsl:choose>
+                    <xsl:when test="$type = '&ldh;Object'">
+                        <xsl:call-template name="local:make-definition-span">
+                            <xsl:with-param name="property" select="'&rdf;value'"/>
+                            <xsl:with-param name="resource" select="$object-value"/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:make-definition-span">
+                            <xsl:with-param name="property" select="'&ac;mode'"/>
+                            <xsl:with-param name="resource" select="$object-mode[. ne '']"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:when test="$type = '&ldh;View'">
+                        <xsl:call-template name="local:make-definition-span">
+                            <xsl:with-param name="property" select="'&spin;query'"/>
+                            <xsl:with-param name="resource" select="$view-query"/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:make-definition-span">
+                            <xsl:with-param name="property" select="'&ac;mode'"/>
+                            <xsl:with-param name="resource" select="$view-mode[. ne '']"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:call-template name="local:make-definition-span">
+                            <xsl:with-param name="property" select="'&spin;query'"/>
+                            <xsl:with-param name="resource" select="$chart-query"/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:make-definition-span">
+                            <xsl:with-param name="property" select="'&ldh;chartType'"/>
+                            <xsl:with-param name="resource" select="$chart-type"/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:make-definition-span">
+                            <xsl:with-param name="property" select="'&ldh;categoryVarName'"/>
+                            <xsl:with-param name="text" select="$chart-category[. ne '']"/>
+                        </xsl:call-template>
+                        <xsl:call-template name="local:make-definition-span">
+                            <xsl:with-param name="property" select="'&ldh;seriesVarName'"/>
+                            <xsl:with-param name="text" select="$chart-series[. ne '']"/>
+                        </xsl:call-template>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:variable>
+            <!-- spans with neither a resource nor a content value are dropped -->
+            <xsl:for-each select="$spans[@resource or @content]">
+                <xsl:sequence select="ixsl:call($island, 'appendChild', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
+            </xsl:for-each>
+            <!-- placed per the content model relative to the host the dialog was
+                 opened from (same path as figures/tables); init locks it, sets
+                 tabindex and fires the renderer -->
+            <xsl:call-template name="local:insert-block-at-caret">
+                <xsl:with-param name="node" select="$island"/>
+                <xsl:with-param name="host" select="ixsl:get(local:editor-state(), 'insertHost')[exists(local:block-of(.))]"/>
+            </xsl:call-template>
+            <xsl:call-template name="local:init-block">
+                <xsl:with-param name="block" select="$island"/>
+            </xsl:call-template>
+            <xsl:call-template name="local:select-island">
+                <xsl:with-param name="element" select="$island"/>
+            </xsl:call-template>
+            <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, 'ldh-block-cancel')]" mode="ixsl:onclick">
+        <xsl:call-template name="local:hide-dialogs"/>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/src/ldh-editor.xsl b/src/ldh-editor.xsl
new file mode 100644
index 0000000..9f87fbe
--- /dev/null
+++ b/src/ldh-editor.xsl
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet
+xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+version="3.0">
+
+<!--
+    The demo/dist entry: the core editor layered with the LinkedDataHub blocks
+    extension. xsl:import puts the core at LOWER import precedence, so the
+    included extension's declarations override it - $object-block-types, the
+    per-type mode="local:render-island" templates and the local:render-extra-*
+    hook stubs. This is exactly the shape LinkedDataHub's client.xsl uses to
+    integrate the editor (docs/ldh/MIGRATION.md par. 10/12): in production,
+    client.xsl plays the ldh-blocks.xsl role with its real ldh:RenderRow
+    renderers. Core-only consumers compile src/index.xsl instead.
+-->
+
+    <xsl:import href="index.xsl"/>
+    <xsl:include href="ldh-blocks.xsl"/>
+
+</xsl:stylesheet>
diff --git a/src/select.xsl b/src/select.xsl
index 930e7aa..84c7ac5 100644
--- a/src/select.xsl
+++ b/src/select.xsl
@@ -131,6 +131,16 @@ version="3.0">
         <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>
 
@@ -162,8 +172,18 @@ version="3.0">
                 </xsl:otherwise>
             </xsl:choose>
         </xsl:variable>
+        <xsl:variable name="island" as="element()?" select="($raw?node/ancestor-or-self::*[local:island(.)])[1]"/>
         <xsl:variable name="chrome" as="element()?" select="($raw?node/ancestor-or-self::*[@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(),
@@ -532,9 +552,11 @@ version="3.0">
                             [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 -->
+                         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
@@ -648,6 +670,17 @@ version="3.0">
                                 </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">
diff --git a/src/undo.xsl b/src/undo.xsl
index 257d689..866bc6a 100644
--- a/src/undo.xsl
+++ b/src/undo.xsl
@@ -175,6 +175,12 @@ version="3.0">
                     <xsl:with-param name="block" select="."/>
                 </xsl:call-template>
             </xsl:for-each>
+            <!-- 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"/>
diff --git a/tests/browser/blocks.mjs b/tests/browser/blocks.mjs
new file mode 100644
index 0000000..832b2bc
--- /dev/null
+++ b/tests/browser/blocks.mjs
@@ -0,0 +1,311 @@
+// Object blocks (LDH extension): RDF-defined blocks embedded as atomic RDFa
+// islands wherever the content model admits a div. Runs against
+// fixture-blocks.html (the ldh-editor SEF): a top-level ResultSetChart and a
+// View nested in a list item, hydrated by conneg fetches (run.mjs negotiates).
+// Asserts init/locking, the storage-form round-trip, island navigation and
+// deletion, hard boundaries, dialog insertion (top-level and nested), the
+// stage-2/sweep delete machine, canonical copy, and the invariants after every
+// mutation.
+import { chromium } from 'playwright';
+
+const BASE = process.env.BASE_URL ?? 'http://localhost:8080';
+const selectAllKey = process.platform === 'darwin' ? 'Meta+a' : 'Control+a';
+const undoKey = process.platform === 'darwin' ? 'Meta+z' : 'Control+z';
+
+const errors = [];
+const results = {};
+const assert = (name, cond) => { results[name] = cond; if (!cond) errors.push('ASSERT FAILED: ' + name); };
+
+const browser = await chromium.launch();
+const page = await browser.newPage();
+page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
+page.on('pageerror', err => errors.push(String(err)));
+page.on('dialog', d => d.accept());
+
+const CHART = '#content > div.rdfa-editor-island';
+const NESTED = '#content li div.rdfa-editor-island';
+
+// load and let both islands hydrate, so undo baselines are render-stable
+const load = async () => {
+    await page.goto(BASE + '/tests/fixture-blocks.html');
+    await page.waitForSelector('#content > * > [data-role=chrome]', { state: 'attached', timeout: 15000 });
+    await page.waitForSelector(`${CHART} [data-role=rendering] table tbody tr`, { state: 'attached', timeout: 15000 });
+    await page.waitForSelector(`${NESTED} [data-role=rendering] table`, { state: 'attached', timeout: 15000 });
+};
+const caretIn = (needle, offset = 2) => page.evaluate(([txt, off]) => {
+    const host = [...document.querySelectorAll('#content [contenteditable=true]')]
+        .find(el => [...el.childNodes].some(n => n.nodeType === 3 && n.textContent.includes(txt)));
+    if (!host) return false;
+    host.focus();
+    const t = [...host.childNodes].find(n => n.nodeType === 3 && n.textContent.includes(txt));
+    window.getSelection().collapse(t, off === -1 ? t.textContent.length : off);
+    return true;
+}, [needle, offset]);
+const sweep = (fromNeedle, fromOffset, toNeedle, toOffset) => page.evaluate(([fn, fo, tn, to]) => {
+    const textIn = needle => {
+        const host = [...document.querySelectorAll('[contenteditable=true]')]
+            .find(el => [...el.childNodes].some(n => n.nodeType === 3 && n.textContent.includes(needle)));
+        return [...host.childNodes].find(n => n.nodeType === 3 && n.textContent.includes(needle));
+    };
+    const r = document.createRange();
+    r.setStart(textIn(fn), fo);
+    r.setEnd(textIn(tn), to);
+    const sel = window.getSelection();
+    sel.removeAllRanges();
+    sel.addRange(r);
+    return sel.toString().length > 0;
+}, [fromNeedle, fromOffset, toNeedle, toOffset]);
+const invariants = () => page.evaluate(() => {
+    const v = [];
+    const region = document.getElementById('content');
+    const walker = document.createTreeWalker(region, NodeFilter.SHOW_TEXT);
+    for (let n; (n = walker.nextNode());) {
+        if (!n.textContent.trim()) continue;
+        if (n.parentElement.closest('[data-role]')) continue;
+        if (n.parentElement.closest('.rdfa-editor-island')) continue; // island definition spans are locked, not hosted
+        if (!n.parentElement.closest('[contenteditable=true]'))
+            v.push('orphan text: "' + n.textContent.trim().slice(0, 30) + '"');
+    }
+    for (const h of region.querySelectorAll('[contenteditable=true] [contenteditable=true]'))
+        v.push('nested host: ' + h.tagName.toLowerCase());
+    for (const h of region.querySelectorAll('.rdfa-editor-island [contenteditable=true]'))
+        v.push('editable inside island: ' + h.tagName.toLowerCase());
+    for (const c of region.querySelectorAll('[data-role=chrome]'))
+        if (c.parentElement.parentElement !== region)
+            v.push('nested chrome in: ' + c.parentElement.tagName.toLowerCase());
+    if (document.getElementById('lint-badge').style.display !== 'none')
+        v.push('lint: ' + document.getElementById('lint-badge').textContent);
+    return v;
+});
+const clean = async name => {
+    const v = await invariants();
+    assert(name + '.invariants', v.length === 0);
+    if (v.length) errors.push(`${name}: ${v.join('; ')}`);
+};
+const islandState = sel => page.evaluate(s => {
+    const isl = document.querySelector(s);
+    if (!isl) return null;
+    return {
+        editable: isl.getAttribute('contenteditable'),
+        tabindex: isl.getAttribute('tabindex'),
+        spans: isl.querySelectorAll(':scope > span[property]').length,
+        renderings: isl.querySelectorAll(':scope > div[data-role=rendering]').length,
+        rows: isl.querySelectorAll('[data-role=rendering] tbody tr').length,
+        chrome: isl.querySelectorAll(':scope > span[data-role=chrome]').length,
+        loading: isl.classList.contains('rdfa-editor-loading'),
+        focused: document.activeElement === isl,
+    };
+}, sel);
+
+// ==== A. init: islands locked, rendered, chrome top-level only ====================
+await load();
+const chartInit = await islandState(CHART);
+assert('init.chart.locked', chartInit.editable === null && chartInit.tabindex === '-1');
+assert('init.chart.spansIntact', chartInit.spans === 4);
+assert('init.chart.rendered', chartInit.renderings === 1 && chartInit.rows === 5 && !chartInit.loading);
+assert('init.chart.chrome', chartInit.chrome === 1);
+assert('init.chart.heading', await page.evaluate(s =>
+    document.querySelector(s + ' [data-role=rendering] strong')?.textContent === 'BarChart · country × population', CHART));
+const nestedInit = await islandState(NESTED);
+assert('init.nested.locked', nestedInit.editable === null && nestedInit.tabindex === '-1');
+assert('init.nested.rendered', nestedInit.renderings === 1 && !nestedInit.loading);
+assert('init.nested.noChrome', nestedInit.chrome === 0);
+assert('init.nested.liContainer', await page.evaluate(() => {
+    const li = document.querySelector('#content li div.rdfa-editor-island').closest('li');
+    return li.getAttribute('contenteditable') !== 'true'
+        && !!li.querySelector(':scope > p.rdfa-editor-run[contenteditable=true]');
+}));
+await clean('init');
+
+// ==== B. round-trip: view-source shows the clean placeholder =====================
+await page.click('#view-source');
+await page.waitForTimeout(200);
+const source = await page.evaluate(() => document.getElementById('output-content').textContent);
+assert('roundtrip.placeholderKept', source.includes('about="#chart"')
+    && source.includes('typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart"')
+    && source.includes('property="http://spinrdf.org/spin#query"')
+    && source.includes('about="#nested-view"')
+    && source.includes('>country</span>'));
+assert('roundtrip.ephemeraGone', !source.includes('data-role') && !source.includes('tabindex')
+    && !source.includes('rdfa-editor-island') && !source.includes('contenteditable'));
+
+// ==== C. navigation: arrows select the island, Backspace deletes it, undo ========
+await load();
+await caretIn('Before chart', -1);
+await page.keyboard.press('ArrowDown');
+await page.waitForTimeout(80);
+assert('nav.arrowSelects', (await islandState(CHART)).focused);
+await page.keyboard.press('ArrowDown');
+await page.waitForTimeout(80);
+assert('nav.arrowLeaves', await page.evaluate(() =>
+    document.activeElement.textContent.includes('After chart.')));
+await page.keyboard.press('ArrowUp');
+await page.waitForTimeout(80);
+assert('nav.arrowBack', (await islandState(CHART)).focused);
+await page.keyboard.press('Backspace');
+await page.waitForTimeout(120);
+assert('nav.deleteRemovesWhole', await page.evaluate(() =>
+    !document.querySelector('#content div[typeof*="ResultSetChart"]')
+    && !document.querySelector('#content > span[property]')));
+await clean('nav.delete');
+await page.keyboard.press(undoKey);
+await page.waitForTimeout(150);
+const afterUndo = await islandState(CHART);
+assert('nav.undoRestores', !!afterUndo && afterUndo.spans === 4 && afterUndo.renderings === 1
+    && afterUndo.editable === null && afterUndo.tabindex === '-1');
+await clean('nav.undo');
+
+// ==== D. hard boundary: Backspace-at-start after an island =======================
+await load();
+await caretIn('After chart', 0);
+await page.keyboard.press('Backspace');
+await page.waitForTimeout(100);
+assert('boundary.inert', await page.evaluate(() =>
+    [...document.querySelectorAll('#content > p')].some(p => p.textContent.includes('After chart.'))
+    && !!document.querySelector('#content div[typeof*="ResultSetChart"]')));
+// emptied host: Backspace removes it and SELECTS the island (B3)
+await page.evaluate(() => {
+    const host = [...document.querySelectorAll('#content > p')].find(p => p.textContent.includes('After chart.'));
+    host.focus();
+    const t = [...host.childNodes].find(n => n.nodeType === 3);
+    const r = document.createRange();
+    r.setStart(t, 0); r.setEnd(t, t.textContent.length);
+    const sel = window.getSelection(); sel.removeAllRanges(); sel.addRange(r);
+});
+await page.keyboard.press('Backspace');
+await page.waitForTimeout(100);
+await page.keyboard.press('Backspace');
+await page.waitForTimeout(120);
+assert('boundary.emptyHostRemovedIslandSelected', await page.evaluate(() =>
+    ![...document.querySelectorAll('#content > p')].some(p => p.textContent.includes('After chart.'))
+    && document.activeElement === document.querySelector('#content div[typeof*="ResultSetChart"]')));
+await clean('boundary');
+
+// ==== E. slash-menu insert (top level) ============================================
+await load();
+await caretIn('Tail paragraph', -1);
+await page.keyboard.press('Enter');
+await page.waitForTimeout(80);
+await page.keyboard.type('/');
+await page.waitForTimeout(150);
+assert('slash.itemOffered', await page.evaluate(() => {
+    const li = document.querySelector('#slash-menu li[data-command="ldh-block"]');
+    return !!li && getComputedStyle(li).display !== 'none';
+}));
+await page.click('#slash-menu li[data-command="ldh-block"]');
+await page.waitForTimeout(120);
+assert('slash.dialogOpens', await page.evaluate(() =>
+    getComputedStyle(document.getElementById('ldh-block-dialog')).display !== 'none'));
+await page.selectOption('#ldh-block-dialog select[name="block-type-iri"]', 'https://w3id.org/atomgraph/linkeddatahub#View');
+await page.fill('#ldh-block-dialog input[name="about"]', '#t-view');
+await page.fill('#ldh-block-dialog input[name="view-query"]', '../demo/queries/population/#this');
+await page.click('#ldh-block-dialog button.ldh-block-save');
+await page.waitForTimeout(150);
+assert('slash.inserted', await page.evaluate(() => {
+    const isl = document.querySelector('#content > div[about="#t-view"]');
+    return !!isl && isl.classList.contains('rdfa-editor-island')
+        && isl.getAttribute('contenteditable') === null
+        && document.activeElement === isl
+        && !!isl.querySelector(':scope > span[data-role=chrome]');
+}));
+await page.waitForSelector('#content > div[about="#t-view"] [data-role=rendering] table', { state: 'attached', timeout: 15000 });
+assert('slash.hydrates', true);
+await clean('slash.insert');
+await page.keyboard.press(undoKey);
+await page.waitForTimeout(150);
+assert('slash.undo', await page.evaluate(() => !document.querySelector('#content div[about="#t-view"]')));
+
+// ==== F. toolbar insert inside a list item (nested placement) =====================
+await load();
+await caretIn('Item before', -1);
+await page.click('#edit-toolbar button.insert-ldh-block');
+await page.waitForTimeout(120);
+await page.fill('#ldh-block-dialog input[name="about"]', '#t-obj');
+await page.fill('#ldh-block-dialog input[name="object-value"]', '../demo/resources/ada/#this');
+await page.click('#ldh-block-dialog button.ldh-block-save');
+await page.waitForTimeout(150);
+assert('toolbar.nestedInsert', await page.evaluate(() => {
+    const isl = document.querySelector('#content div[about="#t-obj"]');
+    if (!isl) return false;
+    const li = isl.closest('li');
+    return !!li && li.getAttribute('contenteditable') !== 'true'
+        && !!li.querySelector(':scope > p.rdfa-editor-run')
+        && !isl.querySelector('[data-role=chrome]');
+}));
+await page.waitForSelector('#content div[about="#t-obj"] [data-role=rendering] table', { state: 'attached', timeout: 15000 });
+assert('toolbar.nestedHydrates', await page.evaluate(() =>
+    document.querySelector('#content div[about="#t-obj"] [data-role=rendering] strong')?.textContent === 'Ada Lovelace'));
+await clean('toolbar.insert');
+await page.keyboard.press(undoKey);
+await page.waitForTimeout(150);
+assert('toolbar.undo', await page.evaluate(() => !document.querySelector('#content div[about="#t-obj"]')
+    && [...document.querySelectorAll('#content li')].some(li => li.getAttribute('contenteditable') === 'true'
+        && li.textContent.includes('Item before'))));
+
+// ==== G. delete machine: stage-2 select-all and sweeps ============================
+await load();
+await caretIn('Before chart', 2);
+await page.keyboard.press(selectAllKey);
+await page.keyboard.press(selectAllKey);
+await page.keyboard.press('Delete');
+await page.waitForTimeout(150);
+assert('stage2.reseeded', await page.evaluate(() => {
+    const blocks = [...document.getElementById('content').children].filter(el => !el.dataset.role);
+    return blocks.length === 1 && blocks[0].tagName === 'P'
+        && !document.querySelector('#content .rdfa-editor-island')
+        && !document.querySelector('#content span[property]');
+}));
+await clean('stage2.delete');
+await page.keyboard.press(undoKey);
+await page.waitForTimeout(150);
+assert('stage2.undo', await page.evaluate(() =>
+    document.querySelectorAll('#content .rdfa-editor-island').length === 2
+    && !!document.querySelector('#content .rdfa-editor-island [data-role=rendering] table')));
+await clean('stage2.undo');
+
+await load();
+await sweep('Before chart', 3, 'After chart', 5);
+await page.keyboard.press('Backspace');
+await page.waitForTimeout(150);
+assert('sweep.coveredIslandRemovedWhole', await page.evaluate(() =>
+    !document.querySelector('#content div[typeof*="ResultSetChart"]')
+    && !document.querySelector('#content > span[property]')
+    && [...document.querySelectorAll('#content > p')].some(p => p.textContent.replace(/⠿/g, '') === 'Bef chart.')
+    && !!document.querySelector('#content li div[typeof*="View"]')));
+await clean('sweep.delete');
+await page.keyboard.press(undoKey);
+await page.waitForTimeout(150);
+assert('sweep.undo', await page.evaluate(() =>
+    document.querySelectorAll('#content .rdfa-editor-island').length === 2));
+
+// ==== H. canonical copy carries the storage form ==================================
+await load();
+await caretIn('Before chart', 2);
+await page.keyboard.press(selectAllKey);
+await page.keyboard.press(selectAllKey);
+const copied = await page.evaluate(() => {
+    const dt = new DataTransfer();
+    document.activeElement.dispatchEvent(
+        new ClipboardEvent('copy', { clipboardData: dt, bubbles: true, cancelable: true }));
+    return dt.getData('text/html');
+});
+assert('copy.placeholderKept', copied.includes('typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart"')
+    && copied.includes('property="http://spinrdf.org/spin#query"'));
+assert('copy.ephemeraGone', !copied.includes('data-role') && !copied.includes('tabindex')
+    && !copied.includes('rdfa-editor-island') && !copied.includes('contenteditable'));
+
+// ==== I. breadcrumb + toolbar state on a selected island ==========================
+await load();
+await caretIn('Before chart', -1);
+await page.keyboard.press('ArrowDown');
+await page.waitForTimeout(150);
+assert('toolbarState.breadcrumb', await page.evaluate(() => {
+    const crumbs = [...document.querySelectorAll('.crumb')];
+    return crumbs.length > 0 && crumbs[crumbs.length - 1].textContent.startsWith('div[');
+}));
+assert('toolbarState.blockTypeDisabled', await page.evaluate(() =>
+    document.querySelector('#edit-toolbar select[name="block-type"]').disabled === true));
+
+console.log(JSON.stringify({ results, errors: errors.slice(0, 8) }, null, 2));
+await browser.close();
+process.exit(errors.length ? 1 : 0);
diff --git a/tests/browser/notion.mjs b/tests/browser/notion.mjs
index 9dd8f7f..bb4b5e7 100644
--- a/tests/browser/notion.mjs
+++ b/tests/browser/notion.mjs
@@ -91,7 +91,9 @@ await page.waitForTimeout(150);
 assert('slash.opens', await visible('slash-menu'));
 assert('slash.filterFocused', await page.evaluate(() =>
     document.activeElement.classList.contains('slash-filter')));
-assert('slash.allCommandsAtTopLevel', (await shownCommands()).length === 10);
+// 10 core commands + the LDH extension's "Block…" (fixture-nesting runs the
+// ldh-editor SEF, proving the extension layers without disturbing core behavior)
+assert('slash.allCommandsAtTopLevel', (await shownCommands()).length === 11);
 
 // filter narrows to a single command
 await page.fill('#slash-menu input.slash-filter', 'quote');
@@ -157,7 +159,7 @@ await load();
 await emptyHost('Plain item');
 await page.keyboard.type('/');
 await page.waitForTimeout(120);
-assert('slash.liContext', JSON.stringify(await shownCommands()) === '["figure","table"]');
+assert('slash.liContext', JSON.stringify(await shownCommands()) === '["figure","table","ldh-block"]');
 await page.keyboard.press('Escape');
 await page.waitForTimeout(80);
 assert('slash.escapeCloses', !(await visible('slash-menu'))
@@ -168,7 +170,7 @@ await load();
 await emptyHost('Cell para');
 await page.keyboard.type('/');
 await page.waitForTimeout(120);
-assert('slash.cellContext', (await shownCommands()).length === 10);
+assert('slash.cellContext', (await shownCommands()).length === 11);
 await page.keyboard.press('Escape');
 
 // figure command routes to the existing dialog; placement follows the content
diff --git a/tests/browser/run.mjs b/tests/browser/run.mjs
index d14fd5d..8ed1432 100644
--- a/tests/browser/run.mjs
+++ b/tests/browser/run.mjs
@@ -8,12 +8,36 @@ import { fileURLToPath } from 'node:url';
 const root = fileURLToPath(new URL('../..', import.meta.url));
 const mime = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.mjs': 'text/javascript',
     '.json': 'application/json', '.css': 'text/css', '.rdf': 'application/rdf+xml',
-    '.xsl': 'application/xslt+xml', '.png': 'image/png' };
+    '.xml': 'application/xml', '.xsl': 'application/xslt+xml', '.png': 'image/png' };
+
+// Linked Data conneg for document (trailing-slash) URIs — mirrors serve.mjs:
+// object-block fixtures are fetched extension-free with an Accept header
+const representations = [
+    { type: 'application/rdf+xml', file: 'index.rdf' },
+    { type: 'application/sparql-results+xml', file: 'results.xml' },
+    { type: 'text/html; charset=utf-8', match: 'text/html', file: 'index.html' },
+];
 
 const server = createServer(async (req, res) => {
     try {
-        const path = normalize(decodeURIComponent(new URL(req.url, 'http://x').pathname)).replace(/^([/\\])+/, '');
-        const body = await readFile(join(root, path === '' ? 'index.html' : path));
+        const pathname = decodeURIComponent(new URL(req.url, 'http://x').pathname);
+        const path = normalize(pathname).replace(/^([/\\])+/, '');
+        if (pathname.endsWith('/')) {
+            const accept = req.headers.accept ?? '';
+            const candidates = representations.filter(rep => accept.includes(rep.match ?? rep.type));
+            for (const rep of candidates.length ? candidates
+                    : representations.filter(rep => rep.file === 'index.html')) {
+                try {
+                    const body = await readFile(join(root, path, rep.file));
+                    res.writeHead(200, { 'Content-Type': rep.type });
+                    res.end(body);
+                    return;
+                } catch { /* try the next representation */ }
+            }
+            res.writeHead(406); res.end();
+            return;
+        }
+        const body = await readFile(join(root, path));
         res.writeHead(200, { 'Content-Type': mime[extname(path)] ?? 'application/octet-stream' });
         res.end(body);
     } catch {
@@ -25,7 +49,7 @@ const base = `http://localhost:${server.address().port}`;
 console.log(`serving ${root} at ${base}`);
 
 let failed = 0;
-for (const suite of ['editor', 'features', 'fixes', 'hardening', 'multiinstance', 'tables', 'datatype', 'inspector', 'nesting', 'authoring', 'invariants', 'select', 'notion']) {
+for (const suite of ['editor', 'features', 'fixes', 'hardening', 'multiinstance', 'tables', 'datatype', 'inspector', 'nesting', 'authoring', 'invariants', 'select', 'notion', 'blocks']) {
     console.log(`\n=== ${suite} ===`);
     const code = await new Promise(resolve => {
         const child = spawn(process.execPath, [fileURLToPath(new URL(`${suite}.mjs`, import.meta.url))],
diff --git a/tests/expected/14-ldh-block-island.rdf b/tests/expected/14-ldh-block-island.rdf
new file mode 100644
index 0000000..abbe8a0
--- /dev/null
+++ b/tests/expected/14-ldh-block-island.rdf
@@ -0,0 +1,21 @@
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:dct="http://purl.org/dc/terms/"
+         xmlns:ldh="https://w3id.org/atomgraph/linkeddatahub#"
+         xmlns:spin="http://spinrdf.org/spin#">
+    <!-- no document->block containment edges: per the v6 document format the
+         document owns its blocks implicitly through its content -->
+    <rdf:Description rdf:about="http://example.org/dir/doc">
+        <dct:title>Object blocks</dct:title>
+    </rdf:Description>
+    <rdf:Description rdf:about="http://example.org/dir/doc#chart1">
+        <rdf:type rdf:resource="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart"/>
+        <spin:query rdf:resource="http://example.org/dir/queries/population/#this"/>
+        <ldh:chartType rdf:resource="https://w3id.org/atomgraph/client#BarChart"/>
+        <ldh:categoryVarName>country</ldh:categoryVarName>
+        <ldh:seriesVarName>population</ldh:seriesVarName>
+    </rdf:Description>
+    <rdf:Description rdf:about="http://example.org/dir/doc#nested-view">
+        <rdf:type rdf:resource="https://w3id.org/atomgraph/linkeddatahub#View"/>
+        <spin:query rdf:resource="http://example.org/dir/queries/population/#this"/>
+    </rdf:Description>
+</rdf:RDF>
diff --git a/tests/expected/canonical/23-ldh-block-placeholder.xhtml b/tests/expected/canonical/23-ldh-block-placeholder.xhtml
new file mode 100644
index 0000000..7b3fba9
--- /dev/null
+++ b/tests/expected/canonical/23-ldh-block-placeholder.xhtml
@@ -0,0 +1,16 @@
+<div xmlns="http://www.w3.org/1999/xhtml" about="">
+    <div about="#chart1"
+            typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart">
+        <span property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span>
+        <span property="https://w3id.org/atomgraph/linkeddatahub#chartType" resource="https://w3id.org/atomgraph/client#BarChart"></span>
+        <span property="https://w3id.org/atomgraph/linkeddatahub#categoryVarName">country</span>
+        <span property="https://w3id.org/atomgraph/linkeddatahub#seriesVarName">population</span>
+    </div>
+    <ul>
+        <li>A nested view: <div
+                about="#nested-view"
+                typeof="https://w3id.org/atomgraph/linkeddatahub#View"><span
+                    property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span></div></li>
+    </ul>
+    <p>just an <em>inline</em> run</p>
+</div>
diff --git a/tests/expected/lint/09-ldh-block-clean.txt b/tests/expected/lint/09-ldh-block-clean.txt
new file mode 100644
index 0000000..e69de29
diff --git a/tests/fixture-blocks.html b/tests/fixture-blocks.html
new file mode 100644
index 0000000..8f2d1ca
--- /dev/null
+++ b/tests/fixture-blocks.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+        <title>RDFa Editor - object blocks fixture</title>
+        <script type="text/javascript" src="../lib/SaxonJS3.js"></script>
+        <script type="text/javascript">
+            window.onload = function() {
+                const vocabs = ["vocabs/foaf.rdf", "vocabs/dcterms.rdf"];
+                Promise.all(vocabs.map(href =>
+                        SaxonJS.getResource({ location: "../" + href, type: "xml" })))
+                    .then(resources => {
+                        const pool = {};
+                        vocabs.forEach((href, i) =>
+                            pool[new URL(href, document.baseURI).href] = resources[i]);
+                        return SaxonJS.transform({
+                            documentPool: pool,
+                            stylesheetLocation: "../dist/ldh-editor.xsl.sef.json",
+                            initialTemplate: "main",
+                            logLevel: 10
+                        }, "async");
+                    })
+                    .catch(err => console.log("Transformation failed: " + err));
+            }
+        </script>
+        <link rel="stylesheet" href="../rdfa-editor.css" type="text/css"/>
+        <style type="text/css">
+            body { padding-top: 70px; padding-bottom: 56px; }
+            .rdfa-editor-content { padding-left: 2.5em; }
+        </style>
+    </head>
+    <body>
+        <nav>
+            <button id="parse-rdf">Extract RDF</button>
+        </nav>
+
+        <div id="content" class="rdfa-editor-content" about="" typeof="https://www.w3.org/ns/ldt/document-hierarchy#Container">
+            <h1 property="http://purl.org/dc/terms/title">Blocks fixture</h1>
+            <p>Before chart.</p>
+            <div about="#chart"
+                    typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart">
+                <span property="http://spinrdf.org/spin#query" resource="../demo/queries/population/#this"></span>
+                <span property="https://w3id.org/atomgraph/linkeddatahub#chartType" resource="https://w3id.org/atomgraph/client#BarChart"></span>
+                <span property="https://w3id.org/atomgraph/linkeddatahub#categoryVarName">country</span>
+                <span property="https://w3id.org/atomgraph/linkeddatahub#seriesVarName">population</span>
+            </div>
+            <p>After chart.</p>
+            <ul>
+                <li>Item before</li>
+                <li>Holds a view:
+                    <div about="#nested-view"
+                            typeof="https://w3id.org/atomgraph/linkeddatahub#View">
+                        <span property="http://spinrdf.org/spin#query" resource="../demo/queries/population/#this"></span>
+                    </div>
+                </li>
+                <li>Item after</li>
+            </ul>
+            <p>Tail paragraph.</p>
+        </div>
+    </body>
+</html>
diff --git a/tests/fixture-nesting.html b/tests/fixture-nesting.html
index 140dc67..ba496a8 100644
--- a/tests/fixture-nesting.html
+++ b/tests/fixture-nesting.html
@@ -16,7 +16,7 @@
                             pool[new URL(href, document.baseURI).href] = resources[i]);
                         return SaxonJS.transform({
                             documentPool: pool,
-                            stylesheetLocation: "../dist/index.xsl.sef.json",
+                            stylesheetLocation: "../dist/ldh-editor.xsl.sef.json",
                             initialTemplate: "main",
                             logLevel: 10
                         }, "async");
diff --git a/tests/fixtures/14-ldh-block-island.xhtml b/tests/fixtures/14-ldh-block-island.xhtml
new file mode 100644
index 0000000..d5d8224
--- /dev/null
+++ b/tests/fixtures/14-ldh-block-island.xhtml
@@ -0,0 +1,20 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+    <body about="">
+        <h1 property="http://purl.org/dc/terms/title">Object blocks</h1>
+        <div about="#chart1"
+                typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart">
+            <span property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span>
+            <span property="https://w3id.org/atomgraph/linkeddatahub#chartType" resource="https://w3id.org/atomgraph/client#BarChart"></span>
+            <span property="https://w3id.org/atomgraph/linkeddatahub#categoryVarName">country</span>
+            <span property="https://w3id.org/atomgraph/linkeddatahub#seriesVarName">population</span>
+        </div>
+        <ul>
+            <li>A view embedded in a list item:
+                <div about="#nested-view"
+                        typeof="https://w3id.org/atomgraph/linkeddatahub#View">
+                    <span property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span>
+                </div>
+            </li>
+        </ul>
+    </body>
+</html>
diff --git a/tests/fixtures/canonical/23-ldh-block-placeholder.xhtml b/tests/fixtures/canonical/23-ldh-block-placeholder.xhtml
new file mode 100644
index 0000000..f98c8bb
--- /dev/null
+++ b/tests/fixtures/canonical/23-ldh-block-placeholder.xhtml
@@ -0,0 +1,24 @@
+<div xmlns="http://www.w3.org/1999/xhtml" id="content" about="">
+    <div about="#chart1"
+            typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart"
+            class="rdfa-editor-island rdfa-editor-loading" tabindex="-1">
+        <span data-role="chrome" class="drag-handle" contenteditable="false">&#x28FF;</span>
+        <span property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span>
+        <span property="https://w3id.org/atomgraph/linkeddatahub#chartType" resource="https://w3id.org/atomgraph/client#BarChart"></span>
+        <span property="https://w3id.org/atomgraph/linkeddatahub#categoryVarName">country</span>
+        <span property="https://w3id.org/atomgraph/linkeddatahub#seriesVarName">population</span>
+        <div data-role="rendering">
+            <strong>BarChart &#xB7; country &#xD7; population</strong>
+            <table><tbody><tr><td>India</td><td>1428627663</td></tr></tbody></table>
+        </div>
+    </div>
+    <ul>
+        <li><p class="rdfa-editor-run" contenteditable="true">A nested view: </p><div
+                about="#nested-view"
+                typeof="https://w3id.org/atomgraph/linkeddatahub#View"
+                class="rdfa-editor-island" tabindex="-1"><span
+                    property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span><div
+                    data-role="rendering">rendered noise</div></div></li>
+    </ul>
+    <div>just an <em>inline</em> run</div>
+</div>
diff --git a/tests/fixtures/lint/09-ldh-block-clean.xhtml b/tests/fixtures/lint/09-ldh-block-clean.xhtml
new file mode 100644
index 0000000..3f1c3e1
--- /dev/null
+++ b/tests/fixtures/lint/09-ldh-block-clean.xhtml
@@ -0,0 +1,18 @@
+<div xmlns="http://www.w3.org/1999/xhtml" about="">
+    <p>Object blocks in storage form produce no issues.</p>
+    <div about="#chart1"
+            typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart">
+        <span property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span>
+        <span property="https://w3id.org/atomgraph/linkeddatahub#chartType" resource="https://w3id.org/atomgraph/client#BarChart"></span>
+        <span property="https://w3id.org/atomgraph/linkeddatahub#categoryVarName">country</span>
+        <span property="https://w3id.org/atomgraph/linkeddatahub#seriesVarName">population</span>
+    </div>
+    <ul>
+        <li>Nested:
+            <div about="#nested-view"
+                    typeof="https://w3id.org/atomgraph/linkeddatahub#View">
+                <span property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span>
+            </div>
+        </li>
+    </ul>
+</div>

From 45ad373f2e32e9857092dd17923fd0e0efa10c00 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martynas=20Jusevi=C4=8Dius?= <martynas@atomgraph.com>
Date: Mon, 13 Jul 2026 11:36:14 +0300
Subject: [PATCH 2/2] Remove implemented LDH object-blocks plan

The plan shipped in 0496acf (src/blocks.xsl, src/ldh-blocks.xsl,
src/ldh-editor.xsl, demo/, tests, CLAUDE.md docs); the file is no
longer needed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 LDH-BLOCKS-PLAN.md | 181 ---------------------------------------------
 1 file changed, 181 deletions(-)
 delete mode 100644 LDH-BLOCKS-PLAN.md

diff --git a/LDH-BLOCKS-PLAN.md b/LDH-BLOCKS-PLAN.md
deleted file mode 100644
index fadcafa..0000000
--- a/LDH-BLOCKS-PLAN.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# Embed LDH's RDF-defined blocks as atomic RDFa islands (core + extension)
-
-## Context
-
-LinkedDataHub's content blocks (`ldh:Object`, `ldh:View`, `ldh:ResultSetChart`, queries) are RDF resources rendered client-side by LDH's SaxonJS XSLT (`ldh:RenderRow`-mode templates on `div[@typeof]`, async promise chains → SPARQL → Google Charts). In LDH they form a **flat top-level `rdf:_N` sequence** — a chart inside a list item is impossible. We want them embeddable in RDFa-Editor regions **wherever an XHTML block element can go** (region top level, `li`, `td`, `blockquote`, `dd`), treated as **atomic island blocks**: never editable inside, navigable/selectable/deletable like image islands, hard boundaries for merges and cross-host deletes, byte-identical round-trip.
-
-**Decisions made with the user:**
-1. **Storage = self-describing RDFa**: a `div` placeholder using the conformant containment idiom, defining triples inline as RDFa spans; extracting the document yields the full block definition.
-2. **Rendering = overridable hook + async fixture demo**: rendering lands in an injected `div[@data-role='rendering']` (extractor skips it, canonicalization drops it — the LDH v6 contract already in place); the default demo renderer does real async hydration from local fixture RDF files via the **SaxonJS 3 promise API** (`ixsl:promise` + `ixsl:http-request` → `ixsl:then` chains, exactly LDH's `ldh:*-thunk` idiom — see LDH block.xsl:582-596). **Never `ixsl:schedule-action`** — legacy, banned in this project.
-3. **Insertion = dialog + slash menu**, placed via the existing `local:insert-block-at-caret`.
-4. **Packaging = optional extension stylesheet layered via `xsl:import`**: the core gains only a *generic* island mechanism with zero LDH knowledge; all LDH specifics live in an extension module whose contract doubles as the real LDH integration contract (LDH's client.xsl already composes with the editor — docs/ldh/MIGRATION.md §10).
-
-Full design rationale with every anchor verified: `/Users/martynas/.claude/plans/we-need-to-make-flickering-mountain-agent-ac9d0adb33f0ef66a.md`. Key claims independently re-verified: all 11 src modules share `xmlns:local="urn:rdfa-editor:functions"` (so import-precedence override of `local:*` works); `local:init-block`'s text-host branch would make an island div contenteditable (edit.xsl:325-330); `local:merge-host-in` (edit.xsl:88-93) would leapfrog a tail island (islands contain no hosts to trip the composite intersect); `local:clamped-range` (select.xsl:117-135) already escapes `@data-role` — islands mirror it; generate-sef.sh c14n-flattens `src/*.xsl` (maxdepth 1) into `build/` and compiles one entry.
-
-## 1. Storage contract
-
-Placeholder (stored/canonical/clipboard form; real output uses absolute IRIs):
-
-```html
-<div property="https://w3id.org/atomgraph/linkeddatahub#content" resource="#chart1"
-     typeof="https://w3id.org/atomgraph/linkeddatahub#ResultSetChart">
-  <span property="http://spinrdf.org/spin#query" resource="queries/population/#this"></span>
-  <span property="https://w3id.org/atomgraph/linkeddatahub#chartType" resource="https://w3id.org/atomgraph/client#BarChart"></span>
-  <span property="https://w3id.org/atomgraph/linkeddatahub#categoryVarName" content="country"></span>
-  <span property="https://w3id.org/atomgraph/linkeddatahub#seriesVarName" content="population"></span>
-</div>
-```
-
-Extracts (base B, region `about=""`): `<B> ldh:content <B#chart1> . <B#chart1> a ldh:ResultSetChart; spin:query <resolve(queries/population/#this, B)>; ldh:chartType ac:BarChart; ldh:categoryVarName "country"; ldh:seriesVarName "population"` — verified against the extractor's `@resource` branch (RDFa2RDFXML-v3.xsl:118-127) and typed-resource chaining (:175-182). Canonicalization verified safe: C1 drops the rendering div (canonical-xhtml.xsl:119), C7a/C7b exclude RDFa-bearing divs (:170-183), C6/C8 keep RDFa-bearing empty spans, C2 strips `tabindex`, N1 only touches inline-only names (div is flow), `cm:wrap-inline-runs` passes divs bare. Lint: zero issues (empty-literal has a `not(@resource)` guard, lint-rdfa.xsl:90). Editing DOM adds only ephemera: `tabindex="-1"`, marker class `rdfa-editor-island`, the rendering div, top-level chrome.
-
-Note: `ldh:content` is not (yet) declared in ldh.ttl 1.1.6 — it's the agreed v6 containment convention; only extension markup templates would change if LDH names it differently.
-
-## 2. Core: new module `src/blocks.xsl` (generic, zero LDH knowledge)
-
-ixsl-bearing (like tables.xsl), `xsl:include`d from src/index.xsl. Contents:
-
-- `<xsl:param name="object-block-types" as="xs:string*" select="()"/>` — absolute class IRIs; default empty.
-- **The single island predicate** — every island decision routes through it:
-  `local:island($e)` = `exists($e[self::div][tokenize(@typeof) = $object-block-types])`.
-- **Render hook**: `<xsl:mode name="local:render-island" on-no-match="deep-skip"/>` — context item = the island div. Contract: inject exactly ONE `div[@data-role='rendering']` as last child via `local:replace-rendering`; async renderers inject it **only in the completion callback** (loading state = ephemeral class `rdfa-editor-loading`), so "no rendering div" always means "re-render needed" (undo-restore keys on that); never touch the RDFa spans; never push undo; idempotent. Core ships a neutral synchronous default (`match="*"`, low precedence): a static card showing type + resource.
-- `local:replace-rendering($island, $content)` — the ONLY writer of the rendering div: remove existing, create div via `local:element('div')` + `ixsl:set-attribute data-role='rendering'`, innerHTML via `serialize($content, map{'method':'html'})` (never xml — self-closing tags swallow siblings), appendChild.
-- **Empty extension hook stubs** (overridden by extensions at higher import precedence): `local:render-extra-dialogs`, `local:render-extra-insert-buttons`, `local:render-extra-slash-items`, `local:run-extra-slash-command($command, $host)`.
-
-CSS (`rdfa-editor.css`): `.rdfa-editor-island` card affordance, `:focus` outline (selected state, mirrors image islands), `.rdfa-editor-loading` dimming. Class markers only (canonicalization-stripped).
-
-## 3. Core: edit.xsl wiring (verified anchors)
-
-- **`local:init-block` (:317-362)** — new FIRST `xsl:when test="local:island($block)"`: remove `contenteditable` (defensive), set `tabindex="-1"`, add class `rdfa-editor-island`, fire `mode="local:render-island"` when `empty($block/*[@data-role='rendering'])`; no recursion, no wrap-stray-runs. The img-tabindex loop (:354-356) gains `[empty(ancestor::*[@data-role])]` (imgs inside rendering never focusable). Chrome injection (:357-361) already runs after the choose — top-level islands get drag handles free; nested islands get none (nested-table doctrine).
-- **`local:nav-targets` (:99-103)** — add `or local:island(.)` plus trailing filters `[empty(ancestor::*[@data-role])][empty(ancestor::*[local:island(.)])]`.
-- **`local:select-image` (:222-228)** → rename **`local:select-island`** (body unchanged: removeAllRanges + focus); update call sites :236, :255. `local:land-forward/-backward` (:232-270): branch test becomes `$target/self::img or local:island($target)`.
-- **Generalize the two img event templates** (:810 onkeydown, :902 onfocusin) to match `*[contains-token(@class, 'rdfa-editor-content')]//*[self::img or local:island(.)]`. Delete victim (:861-862) generalizes to `($target/ancestor-or-self::figure[exists(local:block-of(.))][1], $target)[1]` — an island deletes itself; the existing `local:collapse-container` call (:873-877) handles islands-in-li/td. Ctrl+A stage-2 and arrow nav generalize unchanged.
-- **`local:merge-host-in` (:88-93)** — bind `$host := local:last-host-in($element)`, add island to the composite intersect test AND the tail-island guard (islands contain no hosts, so without it the merge leapfrogs a tail island):
-  `[empty(ancestor-or-self::*[self::table or self::figure or local:island(.)] intersect $element/descendant-or-self::*)][empty($element/descendant-or-self::*[local:island(.)][. >> $host])]`
-- **B3 caret landing (:1203-1216)** — when the removed empty host's `$prev` is an island, `local:select-island($prev)` (the contenteditable descendant lookup is empty). Backspace at start of a non-empty host after an island stays inert (falls through) — same doctrine as tables.
-- **Hook call sites**: `local:init-editing` (:280-287) calls `local:render-extra-dialogs`; toolbar Insert group (:461-464) calls `local:render-extra-insert-buttons`.
-- **Dialog teardown generalization**: Escape match (:2064-2069) and `local:hide-dialogs` (:2072-2090) keyed on class `edit-dialog` (all four existing dialogs carry it — verified edit.xsl:1977, 2111, tables.xsl:121, navigate.xsl:518) + the slash menu, instead of hardcoded ids. Extension dialogs opt in via the class.
-- **No changes needed** (verified): `delete-block` button (island's `local:block-text()` = '' ⇒ deletes without confirm, image-island doctrine); Alt+Arrow, Tab/Enter machines (host-only); block-type select/quote toggle disable via `local:sync-format-toolbar`; paste (canonical strips rendering, re-init re-renders); drag (chrome-gated); breadcrumb already labels `div[<typeof>]` (navigate.xsl:262-264).
-
-## 4. Core: select.xsl, undo.xsl, input.xsl
-
-- **`local:clamped-range` (select.xsl:117-135)**: after the `@data-role` escapes (:128-133), mirror for islands — start container inside an island → `setStartBefore` it; end container → `setEndAfter`. Establishes the invariant "a range boundary never sits inside an island" for the delete machine AND canonical copy (both call it). With that, the delete machine's removals doctrine needs **no island branch** — covered islands are removed whole via the existing rules (:520-527).
-- **`local:caret-at-point` (select.xsl:144-176)**: mirror the chrome escape — a point resolving inside an island moves to just after it (sweep anchors never inside islands).
-- **Guards**: `$collapse-candidates` (select.xsl:536-539) gains `[not(local:island(.))]`; `local:collapse-container` (edit.xsl:367-388) guard gains `not(local:island($container))` — otherwise a span-only island would be collapsed into a contenteditable text host.
-- **Canonical copy**: no change (mode canonical strips rendering/tabindex, keeps the placeholder).
-- **`local:restore-snapshot` (undo.xsl:159-221)**: after chrome re-injection (:170-177), re-render only unrendered islands: `for-each $root//*[local:island(.)][empty(*[@data-role='rendering'])]` → apply `local:render-island`. Snapshots carry rendering markup, so restores are byte-deterministic; only mid-flight captures re-fire (guaranteed by the inject-in-callback contract).
-- **input.xsl**: `local:render-slash-menu` (:224-240) calls `local:render-extra-slash-items` inside `ul.slash-items`; `local:run-slash-command`'s empty `xsl:otherwise` (:361) calls `local:run-extra-slash-command($command, $host)`. `local:open-slash` unchanged — unknown commands hit the `else true()` availability arm (:268), correct since a div is placeable wherever blocks are.
-
-## 5. Extension: `src/ldh-blocks.xsl` + entry `src/ldh-editor.xsl`
-
-Both at src/ **top level** (generate-sef.sh's `find -maxdepth 1` c14n; sibling hrefs survive the build/ flattening).
-
-**src/ldh-editor.xsl** (demo/dist entry):
-```xml
-<xsl:import href="index.xsl"/>      <!-- core at lower import precedence -->
-<xsl:include href="ldh-blocks.xsl"/> <!-- extension at the entry's precedence -->
-```
-Legal by import-precedence rules: `$object-block-types` re-declaration (XTSE0630 forbids duplicates only at the SAME precedence), named-template overrides of the hook stubs, same-mode template rules beating the imported catch-all. `main` stays invocable from the imported module; ixsl event templates register across imports (the MIGRATION.md §10 compile-proof covers this shape). `make sef` after step 1 proves it immediately.
-
-**src/ldh-blocks.xsl**:
-1. `$object-block-types` = the three absolute IRIs (`…#Object`, `…#View`, `…#ResultSetChart`).
-2. **Fixture renderers** — three `mode="local:render-island"` templates matching per typeof + required definition span (mirroring LDH's `ldh:RenderRow` guards). Flow: resolve the query/value IRI against `local:document-uri()` (NOT dist-relative — the span's `@resource` resolves against the page base per RDFa, so `-relocate:on` is moot and no fixture copying is needed); `$query-doc = substring-before($query-uri || '#', '#')`; fetch URLs map the clean IRI to files: `$query-doc || '.rdf'` and `$query-doc || '-results.xml'` (demo-only shim, extensions never in storage); add loading class; then the **SaxonJS 3 promise chain** (LDH's exact idiom, block.xsl:582-596 — NEVER `ixsl:schedule-action`):
-   ```xml
-   <ixsl:promise select="
-       ixsl:http-request(map{ 'method': 'GET', 'href': $query-doc,
-                              'headers': map{ 'Accept': 'application/rdf+xml' } }) =>
-           ixsl:then(local:block-query-response($island, $query-uri, $results-doc, ?))"
-       on-failure="local:block-render-failure($island, ?)"/>
-   ```
-   `local:block-query-response` (partial application closes over `$island`/`$query-uri`/`$results-doc`; `ixsl:updating="yes"`): check `$response?status = 200` and XML `?media-type`, pull `sp:text` for `$query-uri` from `$response?body` (a `document-node()`), then issue the second promise (`ixsl:http-request` for `$results-doc`) whose callback `local:block-results-response` builds the content — `<pre>` with the query text + an HTML `<table>` of the SRX rows (+ chart caption read from the island's own spans) — hands it to `local:replace-rendering` and clears the loading class. `local:block-render-failure` (`on-failure`, both promises): error card via `local:replace-rendering`, loading class cleared — a failed fetch must never wedge the loading state. Object block: same shape, one fetch of the resource description, rendered as a property/value table. Note: this introduces the repo's **first** `ixsl:promise` — there is no async instruction in src/ today.
-3. **Insert dialog** `div#ldh-block-dialog.rdfa-editor-ui.edit-dialog` (class opt-in ⇒ Escape/teardown free): block-type select (Object/View/Result set chart, values = class IRIs), fragment-id input, per-type fieldsets toggled via ixsl:onchange (`ixsl:set-style`): Object → resource URI (`rdf:value`) + optional `ac:mode`; View → query URI (`spin:query`) + optional `ac:mode`; Chart → query URI, chart-type select (ac Table/Bar/Line/Scatter → `ldh:chartType`), category/series var names (`@content` spans). Save (modeled on `table-save`, tables.xsl:159-217): validate → `local:push-undo` → build div+spans via `local:element` + `ixsl:set-attribute` (RDFa must be real attributes; DOM-built, no serialization) → `local:insert-block-at-caret` with `insertHost` → render → `local:select-island` → `local:after-mutation` → `local:hide-dialogs`.
-4. **Slash + toolbar contributions**: `local:render-extra-slash-items` emits `<li class="slash-item" data-command="ldh-block">Block…</li>` (generic filter/arrow/Enter machinery applies); `local:run-extra-slash-command` handles `'ldh-block'` (re-arm `insertHost`, show dialog via `local:show-at-element` — mirroring the table branch, input.xsl:340-360); `local:render-extra-insert-buttons` emits a toolbar button mirroring `insert-table` (tables.xsl:137-157).
-
-**LDH integration contract** (document in MIGRATION.md): in real LDH, client.xsl plays the ldh-blocks.xsl role — sets `$object-block-types`, and its `mode="local:render-island"` templates bridge into the existing `ldh:RenderRow` machinery with the rendering div as container. The editor never learns LDH types; LDH never learns editor internals beyond the mode + `local:replace-rendering` + the hook stubs.
-
-## 6. Build + demo
-
-- **generate-sef.sh**: compile line becomes `-xsl:./build/ldh-editor.xsl` (same output `dist/index.xsl.sef.json` — single SEF, zero-setup demo; core-only consumers compile src/index.xsl themselves — one Makefile comment). Vocabs copy unchanged; **no fixture copy** (document-URI resolution).
-- **Demo fixtures** (new, served from repo root): `demo/queries/population.rdf` (`sp:Select` description with `sp:text`), `demo/queries/population-results.xml` (SRX rows), `demo/resources/ada.rdf` (Object target).
-- **index.html**: add a ResultSetChart block to `#content` (`resource="#population-chart"`, spin:query `resource="queries/population/#this" (on demo/index.html)`); Help-modal sentence.
-- **tests/browser/run.mjs**: add `'.xml': 'application/xml'` and `'.rdf': 'application/rdf+xml'` to the mime map; add `'blocks'` to the suite list. (`ixsl:http-request` parses the response body to a `document-node()` based on the media-type, so the fixtures must be served as XML types; python http.server on macOS maps both via Apache mime.types — the `on-failure`/media-type guard shows the error card if a host maps them wrong.)
-
-## 7. Tests
-
-Headless (run against src/ — island storage-form behavior is all core/pure-XSLT):
-- `tests/fixtures/14-ldh-block-island.xhtml` + expected RDF (the §1 triples; include a nested island inside an `li`).
-- `tests/fixtures/canonical/23-ldh-block-placeholder.xhtml` + expected: island laden with ephemera (tabindex, marker classes, chrome, populated rendering div, run-wrapped sibling) ⇒ clean placeholder, byte-identical spans; plus an attributeless-div control pinning C7a/C7b.
-- `tests/fixtures/lint/10-ldh-block-clean.xhtml` + empty expected.
-
-Browser (`tests/browser/blocks.mjs` against tests/fixture-nesting.html, which gains a top-level ResultSetChart island — `resource="../demo/queries/population/#this"`, page-relative — and a nested View island in an li):
-1. init/render: uneditable, tabindex, spans un-wrapped, rendering table appears (awaited), chrome top-level only;
-2. canonical round-trip via view-source;
-3. nav battery: arrows select/leave, Backspace deletes, undo restores + re-render leaves placeholder intact;
-4. slash "Block…" → dialog → insert in region and in an empty li;
-5. stage-2 Ctrl+A + Delete → reseed; sweep across the island → removed whole, no span residue;
-6. Backspace boundary doctrine;
-7. canonical copy over an island (clipboard text/html);
-8. breadcrumb label + disabled block-type select.
-- invariants.mjs: one render-settle wait before baseline capture (rendering populated); battery unchanged.
-
-## 8. Risks / gotchas
-
-- `serialize(…, map{'method':'html'})` on every innerHTML write (self-closing div/span swallows siblings).
-- `local:island()` in match patterns reads a global param — legal XSLT 3.0; if the SaxonJS compiler balks, inline `self::div[tokenize(@typeof) = $object-block-types]` (variable refs in pattern predicates are safe). De-risk: `make sef` right after step 1.
-- **`ixsl:schedule-action` is banned** (legacy pre-SaxonJS-3) — all async goes through `ixsl:promise`/`ixsl:http-request`/`ixsl:then` with `on-failure`. DOM-mutating promise callbacks must be declared `ixsl:updating="yes"` (LDH precedent, e.g. `ldh:ontology-view-render-thunk`); the failure handler must clear the loading state and render an error card. Verify SaxonJS 3's exact `on-failure` arity against the LDH usage (`ldh:promise-failure#1`) when writing the handlers.
-- Async rendering mutates the region outside push-undo ⇒ a visually-idle undo step is possible; harmless (canonical content identical), documented.
-- `$object-block-types` re-declaration ONLY at higher import precedence, never in a second core include.
-- Always `tokenize(@typeof) = $object-block-types`, never string equality (multi-token typeof).
-- Keep core entity-free where headless suites run src/ directly; extension entities are fine (c14n expands for the SEF).
-
-## 9. Implementation order + verification
-
-1. src/blocks.xsl + index.xsl include + CSS → `make sef` (proves pattern legality).
-2. edit.xsl wiring (§3) → `make sef`, browser spot-check.
-3. select.xsl + undo.xsl + input.xsl (§4).
-4. ldh-blocks.xsl + ldh-editor.xsl + generate-sef.sh + demo/ + index.html.
-5. Headless fixtures → `make test`.
-6. fixture-nesting.html + blocks.mjs + run.mjs + invariants wait → `make test-browser`.
-7. Docs: CLAUDE.md module list (blocks.xsl, ldh-blocks.xsl, ldh-editor.xsl entry, build note), README, MIGRATION.md `local:render-island` integration surface.
-
-Final manual check: `make up` → the population chart hydrates async on index.html; view-source shows the clean placeholder; Extract RDF shows the §1 triples; drag/slash-insert/delete/undo/copy-paste behave per §8 of the agent plan.
-
-## Amendments during implementation
-
-1. **`ixsl:schedule-action` is banned** — all async uses the SaxonJS 3 promise API
-   (`ixsl:promise` + `ixsl:http-request` `=> ixsl:then`, `on-failure`, callbacks as
-   `ixsl:updating="yes"` functions with partial application), exactly LDH's
-   `ldh:*-thunk` idiom.
-2. **Clean Linked Data URLs throughout** — document URIs end with a trailing slash
-   (`demo/queries/population/#this`), representations come from **content
-   negotiation** on the clean URI (`Accept: application/rdf+xml` → the description;
-   `Accept: application/sparql-results+xml` on a query document → canned results, a
-   demo stand-in for live SPARQL execution). File extensions appear nowhere: not in
-   storage, not in fetch code, not in fixtures (`demo/queries/population/index.rdf` +
-   `results.xml` are server-private file names). `make up` therefore serves via
-   `node serve.mjs` (conneg-aware) instead of python http.server; tests/browser/run.mjs
-   negotiates the same way.
-3. **Core/LDH split with core-only GitHub Pages** — two SEFs: `dist/index.xsl.sef.json`
-   (core, from src/index.xsl — what deploy-pages.yml publishes, minus the LDH
-   artifacts) and `dist/ldh-editor.xsl.sef.json` (core + extension — used by the new
-   `demo/index.html` showcase page and the browser fixtures; local-only, needs
-   conneg). index.html carries no LDH markup.
-4. **Islands got their own browser fixture** (`tests/fixture-blocks.html` +
-   `tests/browser/blocks.mjs`) instead of extending fixture-nesting.html — keeps the 13
-   existing suites' block enumeration byte-stable. fixture-nesting.html still loads the
-   ldh-editor SEF, proving the extension layers without disturbing core behavior
-   (notion.mjs counts its 11th slash item).
-5. **Undo/redo chords on a focused island** — the host/body keydown templates don't
-   fire with focus on an island (a pre-existing gap for image islands too), so the
-   generalized island keydown template intercepts Ctrl/Cmd+Z / Shift+Z / Ctrl+Y itself.
-6. **Block markup follows the v6 document format** (the
-   [XHTML-RDFa-as-LDH-v6-Document-Format](https://github.com/AtomGraph/LinkedDataHub/wiki/XHTML-RDFa-as-LDH-v6-Document-Format)
-   wiki, which supersedes the plan's §1 storage contract): blocks carry
-   `@about="#fragment"` + `@typeof` directly — NOT the `property="ldh:content"
-   resource=` containment idiom (in v6 `ldh:content` is the document→body XMLLiteral
-   property, never a per-block edge; there is no document→block triple and no
-   `rdf:_N` — order is document order). Literal definition values are span TEXT
-   content (`<span property="ldh:categoryVarName">country</span>`), not `@content` —
-   which also matches LDH's renderer selectors verbatim. Island detection was already
-   `@typeof`-keyed, so the mechanism was unaffected; the dialog emission, demo pages,
-   fixtures and expected files were updated. v6's render mode is `ldh:Block`
-   (`ldh:RenderRow` is the v5 name the §12 bridge example targets).