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 e0b6da5..13305cf 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -13,26 +13,30 @@ 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 → term maps (`local:vocab-terms` → `{uri, label}`, consumed by the typeahead). 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). The property/type fields are typeaheads (typeahead.xsl); the datatype field stays a `<select>` (short XSD list) with a `urn:rdfa-editor:custom` sentinel + free-text `custom-datatype` input and the datatype↔lang mutual-exclusion handler.
 - **typeahead.xsl** — autocomplete lookups for the **property** and **type** fields (replacing the long dropdowns; LDH's typeahead interaction ported with local synchronous filtering — no SPARQL/debounce, since vocabularies are already pooled). A stable wrapper `span[@data-field]` holds one of two states, swapped via `result-document` literal result elements: typing (`input.typeahead-input` + `ul.typeahead-menu`) or committed (`button.typeahead-value` + hidden input carrying the IRI, LDH-style). Filtering re-renders per keystroke from `local:vocab-terms` (prefix-ranked, capped, bold-highlighted match); keyboard nav mirrors the slash menu (Arrow/Enter/Escape, first option pre-selected); options commit on `ixsl:onmousedown` (before the input's `focusout`, children `pointer-events:none` so the `<li>` is the target). `local:typeahead-value` reads the committed hidden IRI, else a free-typed absolute IRI (`local:is-absolute-iri`), else the untouched button→edit value parked on `@data-editing-iri` (cleared on the first keystroke — the stale-selection guard). Escape closes the menu else the overlay (the innermost template fully owns the input's keys).
 - **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).
@@ -43,12 +47,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.
 
@@ -67,7 +71,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), `typeahead.mjs` (property/type autocomplete: filter, keyboard/mouse select, free-IRI entry, non-IRI rejection, edit-prefill button, stale-selection invalidation — via `typeahead-helper.mjs`) 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), `typeahead.mjs` (property/type autocomplete: filter, keyboard/mouse select, free-IRI entry, non-IRI rejection, edit-prefill button, stale-selection invalidation — via `typeahead-helper.mjs`), `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/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 eb3a05f..d17879d 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 63a4322..cbfdfd2 100644
--- a/src/index.xsl
+++ b/src/index.xsl
@@ -23,6 +23,7 @@ version="3.0">
     - typeahead.xsl        autocomplete lookups for the property and type fields
     - annotate.xsl         right-click dispatch, apply/remove annotation, extraction modal
     - edit.xsl             XHTML editing: blocks, keyboard, toolbar, dialogs, drag-and-drop
+    - blocks.xsl           object blocks: island predicate, render hook, extension points
     - tables.xsl           table blocks: insert dialog, row/column operations, cell traversal
     - select.xsl           region-scoped select-all and cross-host selection delete
     - input.xsl            input triggers: slash menu and markdown shorthands
@@ -39,6 +40,7 @@ version="3.0">
     <xsl:include href="typeahead.xsl"/>
     <xsl:include href="annotate.xsl"/>
     <xsl:include href="edit.xsl"/>
+    <xsl:include href="blocks.xsl"/>
     <xsl:include href="tables.xsl"/>
     <xsl:include href="select.xsl"/>
     <xsl:include href="input.xsl"/>
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 a38d873..747d2af 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', 'typeahead']) {
+for (const suite of ['editor', 'features', 'fixes', 'hardening', 'multiinstance', 'tables', 'datatype', 'inspector', 'nesting', 'authoring', 'invariants', 'select', 'notion', 'typeahead', '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>