diff --git a/CLAUDE.md b/CLAUDE.md
index e0b6da5..6546a31 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -13,7 +13,7 @@ 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 (nested blocks included — every `%block` drags, drops land wherever the content model admits it), 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).
 
 ## Architecture
 
@@ -28,8 +28,8 @@ Modules under `src/`:
 - **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**.
-- **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.
+- **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 covers **every draggable block** (`local:draggable-block`: a real `%block` — never a run wrapper, `hr` or ephemera — whose parent is a region, a `cm:flow` container or a `blockquote`): nested blocks carry their own handles, stacked per nesting level, each hover-revealed at its block's own gutter indent (the editing view indents `blockquote` content so quote-child handles don't coincide with the quote's); `local:ensure-chrome` in `local:after-mutation` converges handles after every gesture, so mutation sites never thread their own injection. 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) and extended to **nested blocks with a content-model-validated drop resolver**: the target is the innermost draggable block under the pointer whose container accepts the dragged kind (`local:deepest-block-at` + `local:legal-drop-level` climbing to the nearest legal level — the region accepts any block, so the climb terminates and an illegal drop is *clamped*, never created); gutter/gap drops fall back to the nearest top-level block, so dropping in the left gutter lifts a nested block all the way out; **cells take "into" drops** (nothing can legally drop before/after a `td`/`th`, so a cell's pixels away from any block it holds mean *into it* — the text host becomes a container per the `local:insert-block-at-caret` flow doctrine, marked by an inset `drop-into` box; a list item deliberately stays a clamp to around-the-list, since its pixels compete with reordering); the vacated origin is repaired at commit (`local:prune-husks` for emptied structural containers — the B7 doctrine — then `local:collapse-container` for a flow container that lost its last block); transient drag state (`dragging`/`draggable`/empty `class` leftovers — `local:tidy-class`) is stripped before the undo snapshot; drops stay region-scoped (blocks never move between regions). 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**.
+- **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 a (possibly nested) `<table>` is foster-parented out by the HTML fragment parser on `innerHTML` restore, so `local:restore-snapshot` strips every handle and re-converges via `local:ensure-chrome` (deterministic first-child prepend) 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.
 - **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.
@@ -63,11 +63,11 @@ Run `make sef` after any XSLT change; run the tests after any extractor change.
 - Vocabularies are plain ontology RDF/XML files in `vocabs/` — no custom manifest format. Adding a vocabulary = drop the file in `vocabs/` and add its href to `$vocab-hrefs`.
 - `src/index.xsl` (and other editor modules) may use DOCTYPE entities; the SaxonJS compiler does not expand them, hence the `xmlstarlet c14n` step in `generate-sef.sh`. The extractor is entity-free so the test suite runs against `src/` directly.
 - Tests: expected files are authored as readable, grouped RDF/XML; `tests/normalize.xsl` canonicalizes both sides into sorted triple lists, so prefixes/grouping/order don't matter. Blank-node labels are deterministic sibling-position paths (e.g. `b1.1.2`), not `generate-id()`. Canonical-XHTML fixtures live in `tests/fixtures/canonical/` and compare via `tests/normalize-xhtml.xsl` (whitespace-only text dropped only in element-only containers — `pre` stays exact).
-- **Editable region convention**: the host page provides `<div id="content" about="" typeof="…">` with blocks as direct children and **no hardcoded `contenteditable`** — init sets editability recursively per the content model and injects chrome (top-level only). Everything carrying `@data-role` (chrome, rendering) is ephemeral: skipped by the extractor, stripped by canonicalization (LDH v6 contract).
+- **Editable region convention**: the host page provides `<div id="content" about="" typeof="…">` with blocks as direct children and **no hardcoded `contenteditable`** — init sets editability recursively per the content model and injects chrome (on every draggable block, nested ones included — `local:draggable-block`). Everything carrying `@data-role` (chrome, rendering) is ephemeral: skipped by the extractor, stripped by canonicalization (LDH v6 contract).
 - **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.
 - **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 only on draggable blocks, run wrappers editable, zero lint issues, undo restores the exact baseline) and `dragnest.mjs` (nested drag-and-drop with real mouse gestures: nested handles at init, lift-out of a list item — incl. the RDFa object-div case — drop-into a container and INTO a text-only cell, before/after precision on a cell's blocks, legality clamp, region clamp, origin collapse, split convergence, canonical cleanliness — against `tests/fixture-dragnest.html`), all others 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`).
 - **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/README.md b/README.md
index ba5f14e..c52c93d 100644
--- a/README.md
+++ b/README.md
@@ -7,9 +7,10 @@ RDFa extraction and the document canonicalization are all XSLT.
 
 - **Structured-block editing** of any number of `.rdfa-editor-content` regions (p, h1–h3, lists, blockquote,
   pre, figure): Enter splits, Backspace merges, toolbar for block types / inline
-  formatting / links / figures, drag-handle and Alt+Arrow reordering, HTML paste through
-  a sanitizing canonicalization pipeline, unified snapshot undo/redo with caret
-  restoration.
+  formatting / links / figures, drag-handle and Alt+Arrow reordering — nested blocks
+  carry their own handles and drop wherever the XHTML content model admits them (out of
+  a list item or quote, into a table cell) — HTML paste through a sanitizing
+  canonicalization pipeline, unified snapshot undo/redo with caret restoration.
 - **RDFa annotation**: right-click a selection to assert a statement (S/P/O framing,
   vocabulary dropdowns fed by plain ontology RDF/XML files); right-click an annotation
   to edit or remove it.
diff --git a/index.html b/index.html
index b6dd22a..1de806e 100644
--- a/index.html
+++ b/index.html
@@ -244,7 +244,10 @@ <h2>Try it yourself</h2>
                 <li>Type a sentence, then press <strong>Enter</strong> to start a new block.</li>
                 <li>Select a few words, then <strong>right-click</strong> to tag them with meaning.</li>
                 <li>Use the toolbar to add a heading, list, image or table.</li>
-                <li>Hover a block and drag the <strong>⠿</strong> handle to reorder it.</li>
+                <li>Hover a block and drag the <strong>⠿</strong> handle to reorder it —
+                    even into a table cell.</li>
+                <li>Hover the quote above: the paragraph <em>inside</em> it has its own
+                    handle, so you can drag it out of the quote.</li>
             </ol>
 
             <h2>Learn more</h2>
@@ -314,7 +317,11 @@ <h4>Adding meaning (RDFa)</h4>
 
                 <h4>Reordering</h4>
                 <p>Hover over a block and drag the <strong>⠿</strong> handle that appears in
-                    the left margin to move it.</p>
+                    the left margin to move it. Blocks nested inside a list item, a quote or
+                    a table cell have handles of their own, at their own indent — a drop
+                    lands wherever the document structure allows it: next to another block,
+                    <strong>into a table cell</strong>, or — dropped in the page's left
+                    gutter — out at the top level.</p>
 
                 <h4>Seeing the result</h4>
                 <p><strong>Source</strong> (in the toolbar) shows the clean, canonical
diff --git a/rdfa-editor.css b/rdfa-editor.css
index eb3a05f..cd4a9b1 100644
--- a/rdfa-editor.css
+++ b/rdfa-editor.css
@@ -74,6 +74,12 @@
                 position: relative;
             }
 
+/* nested draggable blocks position their own handle (chrome is their first
+   child); handles stack per nesting level, each at its block's own indent */
+            .rdfa-editor-content *:has(> [data-role="chrome"]) {
+                position: relative;
+            }
+
 /* invisible gutter strip: keeps the block hovered while the pointer
                travels to the drag handle, which sits outside the block box */
             .rdfa-editor-content > *::before {
@@ -85,6 +91,27 @@
                 width: 2.25em;
             }
 
+/* nested blocks get a narrower gutter, inside the parent's indentation */
+            .rdfa-editor-content > * *:has(> [data-role="chrome"])::before {
+                content: '';
+                position: absolute;
+                left: -1.5em;
+                top: 0;
+                bottom: 0;
+                width: 1.5em;
+            }
+
+/* a blockquote has no intrinsic child indentation, so its handle and its first
+   block's handle would coincide; the editing view indents quote content to give
+   each nesting level its own gutter column (lists and cells indent natively).
+   The quote bar (Markdown/Bootstrap convention) makes the container visible -
+   a normalized blockquote > p would otherwise read as a plain paragraph */
+            .rdfa-editor-content blockquote {
+                padding-left: 2em;
+                border-left: 4px solid #e0e0e0;
+                color: #616161;
+            }
+
 /* the editing-DOM run wrapper (mixed flow content, e.g. <li>text<ul>...) renders
    like the bare inline run it stands for; unwrapped again at canonicalization */
             .rdfa-editor-content p.rdfa-editor-run {
@@ -156,23 +183,28 @@
                 border: none;
             }
 
-.rdfa-editor-content > *:hover > [data-role="chrome"] {
+.rdfa-editor-content *:hover > [data-role="chrome"] {
                 visibility: visible;
             }
 
-/* Drag-and-drop feedback (v6 conventions) */
-            .rdfa-editor-content > .dragging {
+/* Drag-and-drop feedback (v6 conventions) - any nesting depth */
+            .rdfa-editor-content .dragging {
                 opacity: 0.4;
             }
 
-.rdfa-editor-content > .drop-before {
+.rdfa-editor-content .drop-before {
                 box-shadow: 0 -3px 0 0 #2196f3;
             }
 
-.rdfa-editor-content > .drop-after {
+.rdfa-editor-content .drop-after {
                 box-shadow: 0 3px 0 0 #2196f3;
             }
 
+/* dropping INTO a cell highlights the cell itself, not an edge */
+            .rdfa-editor-content .drop-into {
+                box-shadow: inset 0 0 0 2px #2196f3;
+            }
+
 /* Editor toolbar (injected into the navbar) */
             #edit-toolbar {
                 order: -1;
diff --git a/src/edit.xsl b/src/edit.xsl
index 9b7e1ea..883c937 100644
--- a/src/edit.xsl
+++ b/src/edit.xsl
@@ -55,6 +55,60 @@ version="3.0">
         <xsl:sequence select="$node/ancestor-or-self::*[parent::*[contains-token(@class, 'rdfa-editor-content')]][1]"/>
     </xsl:function>
 
+    <!-- a block the drag layer picks up: a real %block element - never the
+         ephemeral run wrapper, never ephemera or anything inside it, never hr
+         (a void element cannot serialize the chrome span) - sitting where the
+         model places blocks: a region, a mixed flow container (li, dd, td, th,
+         div, figure, figcaption) or a blockquote. Top-level blocks satisfy this
+         by construction; every chrome and drag decision routes through here -->
+    <xsl:function name="local:draggable-block" as="xs:boolean">
+        <xsl:param name="element" as="element()?"/>
+        <xsl:sequence select="exists($element
+            [cm:block(local-name(.))][not(self::hr)]
+            [not(contains-token(@class, 'rdfa-editor-run'))]
+            [empty(ancestor-or-self::*[@data-role])]
+            [exists(local:root-of(.))]
+            [parent::*[contains-token(@class, 'rdfa-editor-content')
+                or cm:flow(local-name(.)) or self::blockquote]])"/>
+    </xsl:function>
+
+    <!-- the drag handle's owning block: chrome is its first child -->
+    <xsl:function name="local:handle-block" as="element()?">
+        <xsl:param name="handle" as="element()"/>
+        <xsl:sequence select="$handle/parent::*[local:draggable-block(.)]"/>
+    </xsl:function>
+
+    <!-- a container admits the dragged kind: the region takes any block (the
+         editor contract, deliberately outside content-model.xsl), everything
+         else per the DTD -->
+    <xsl:function name="local:container-accepts" as="xs:boolean">
+        <xsl:param name="container" as="element()"/>
+        <xsl:param name="block" as="element()"/>
+        <xsl:sequence select="contains-token($container/@class, 'rdfa-editor-content')
+            or cm:allows-child(local-name($container), local-name($block))"/>
+    </xsl:function>
+
+    <!-- the innermost draggable block under a pointer hit - never the dragged
+         block itself or anything inside it (its ancestors are fair targets:
+         dropping before/after an ancestor lifts the block out) -->
+    <xsl:function name="local:deepest-block-at" as="element()?">
+        <xsl:param name="hit"/>
+        <xsl:param name="dragged" as="element()?"/>
+        <xsl:sequence select="$hit/ancestor-or-self::*[local:draggable-block(.)]
+            [empty(ancestor-or-self::* intersect $dragged)][1]"/>
+    </xsl:function>
+
+    <!-- the drop level: the innermost block at or above the candidate whose
+         container legally accepts the dragged kind - an illegal drop clamps to
+         the nearest legal ancestor level instead of being created. The region
+         accepts any block, so the climb always terminates -->
+    <xsl:function name="local:legal-drop-level" as="element()?">
+        <xsl:param name="candidate" as="element()"/>
+        <xsl:param name="dragged" as="element()"/>
+        <xsl:sequence select="$candidate/ancestor-or-self::*[local:draggable-block(.)]
+            [local:container-accepts(parent::*, $dragged)][1]"/>
+    </xsl:function>
+
     <!-- the editable host containing a node (block, li or figcaption) -->
     <xsl:function name="local:host-of" as="element()?">
         <xsl:param name="node"/>
@@ -312,8 +366,9 @@ version="3.0">
     <!-- editability per the content model, recursively: an element is a text host
          while it allows text and holds no block children; mixed flow containers
          (li, td, dd, ... with blocks) and structural containers (blockquote, lists,
-         figure, table) lock their own markup and recurse into their parts. Chrome
-         and drag stay top-level affordances -->
+         figure, table) lock their own markup and recurse into their parts. Every
+         draggable block - nested ones included - carries its own chrome handle -->
+
     <xsl:template name="local:init-block">
         <xsl:param name="block" as="element()"/>
         <xsl:variable name="name" as="xs:string" select="local-name($block)"/>
@@ -354,7 +409,7 @@ version="3.0">
         <xsl:for-each select="$block/descendant-or-self::img[empty(ancestor::*[@contenteditable = 'true'])]">
             <ixsl:set-attribute name="tabindex" select="'-1'"/>
         </xsl:for-each>
-        <xsl:if test="$block/parent::*[contains-token(@class, 'rdfa-editor-content')]">
+        <xsl:if test="local:draggable-block($block)">
             <xsl:call-template name="local:inject-chrome">
                 <xsl:with-param name="block" select="$block"/>
             </xsl:call-template>
@@ -436,6 +491,29 @@ version="3.0">
         </xsl:for-each>
     </xsl:template>
 
+    <!-- classList.remove leaves an empty @class behind, which would survive into
+         undo snapshots and canonical-comparison baselines as class="" noise -->
+    <xsl:template name="local:tidy-class">
+        <xsl:param name="element" as="element()"/>
+        <xsl:for-each select="$element[@class = '']">
+            <ixsl:remove-attribute name="class"/>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- chrome convergence: every draggable block carries its handle. Init seeds
+         the loaded content; gestures that build nested blocks (split, indent,
+         paste, list insert) converge here via local:after-mutation instead of
+         each threading its own injection -->
+    <xsl:template name="local:ensure-chrome">
+        <xsl:param name="scope" as="element()*" select="local:roots()"/>
+        <xsl:for-each select="$scope/descendant::*[local:draggable-block(.)]
+                [empty(*[@data-role = 'chrome'])]">
+            <xsl:call-template name="local:inject-chrome">
+                <xsl:with-param name="block" select="."/>
+            </xsl:call-template>
+        </xsl:for-each>
+    </xsl:template>
+
     <xsl:template name="local:render-toolbar">
         <div id="edit-toolbar" class="rdfa-editor-ui" role="toolbar" aria-label="Editing toolbar">
             <div class="tb-group" role="group" aria-label="Block">
@@ -2160,19 +2238,19 @@ version="3.0">
          permanently draggable contenteditable block breaks text selection -->
 
     <xsl:template match="span[contains-token(@class, 'drag-handle')]" mode="ixsl:onmousedown">
-        <xsl:for-each select="local:block-of(.)">
+        <xsl:for-each select="local:handle-block(.)">
             <ixsl:set-attribute name="draggable" select="'true'"/>
         </xsl:for-each>
     </xsl:template>
 
     <xsl:template match="span[contains-token(@class, 'drag-handle')]" mode="ixsl:onmouseup">
-        <xsl:for-each select="local:block-of(.)">
+        <xsl:for-each select="local:handle-block(.)">
             <ixsl:remove-attribute name="draggable"/>
         </xsl:for-each>
         <xsl:call-template name="local:disarm-sweep"/>
     </xsl:template>
 
-    <xsl:template match="*[parent::*[contains-token(@class, 'rdfa-editor-content')]][@draggable = 'true']" mode="ixsl:ondragstart">
+    <xsl:template match="*[@draggable = 'true'][local:draggable-block(.)]" mode="ixsl:ondragstart">
         <xsl:variable name="transfer" select="ixsl:get(ixsl:event(), 'dataTransfer')"/>
         <!-- a block drag must never race an armed sweep -->
         <xsl:call-template name="local:disarm-sweep"/>
@@ -2196,11 +2274,12 @@ version="3.0">
     </xsl:template>
 
     <!-- images are natively draggable, so a drag starting on one would otherwise
-         carry no block identity and snap back; treat it as dragging its block -->
+         carry no block identity and snap back; treat it as dragging its innermost
+         draggable block (the figure, wherever it nests) -->
     <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//img" mode="ixsl:ondragstart">
         <xsl:variable name="transfer" select="ixsl:get(ixsl:event(), 'dataTransfer')"/>
         <xsl:call-template name="local:disarm-sweep"/>
-        <xsl:for-each select="local:block-of(.)">
+        <xsl:for-each select="ancestor-or-self::*[local:draggable-block(.)][1]">
             <ixsl:set-property name="draggedBlock" select="." object="local:editor-state()"/>
             <ixsl:set-property name="effectAllowed" select="'move'" object="$transfer"/>
             <xsl:sequence select="ixsl:call($transfer, 'setData', [ 'application/x-rdfa-editor-block', '' ])[current-date() lt xs:date('2000-01-01')]"/>
@@ -2218,8 +2297,12 @@ version="3.0">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
             <ixsl:set-property name="dropEffect" select="'move'" object="ixsl:get($event, 'dataTransfer')"/>
             <xsl:call-template name="local:clear-drop-marks"/>
+            <!-- a block target takes a before/after line; a cell target is entered
+                 whole, so it highlights as a box -->
             <xsl:sequence select="ixsl:call(ixsl:get($target, 'classList'), 'add',
-                [ if (local:drop-before($event, $target)) then 'drop-before' else 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
+                [ if (not(local:draggable-block($target))) then 'drop-into'
+                    else if (local:drop-before($event, $target)) then 'drop-before'
+                    else 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
     </xsl:template>
 
@@ -2231,18 +2314,69 @@ version="3.0">
                 and local:has-transfer-type($event, 'application/x-rdfa-editor-block')">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:call-template name="local:clear-drop-marks"/>
+            <!-- transient drag state must not reach the undo snapshot -->
+            <xsl:for-each select="$dragged">
+                <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
+                <ixsl:remove-attribute name="draggable"/>
+                <xsl:call-template name="local:tidy-class">
+                    <xsl:with-param name="element" select="."/>
+                </xsl:call-template>
+            </xsl:for-each>
             <xsl:call-template name="local:push-undo"/>
-            <xsl:sequence select="ixsl:call($target,
-                if (local:drop-before($event, $target)) then 'before' else 'after',
-                [ $dragged ])[current-date() lt xs:date('2000-01-01')]"/>
+            <!-- the vacated origin, captured before the move: the top-level block
+                 (husk-prune scope) and the nearest flow container (collapse
+                 candidate) - both empty for a top-level drag -->
+            <xsl:variable name="origin-block" as="element()?"
+                select="$dragged/parent::*[not(contains-token(@class, 'rdfa-editor-content'))]
+                    ! local:block-of(.)"/>
+            <xsl:variable name="origin-flow" as="element()?"
+                select="$dragged/ancestor::*[cm:flow(local-name(.))]
+                    [not(contains-token(@class, 'rdfa-editor-content'))]
+                    [exists(local:block-of(.))][1]"/>
+            <xsl:choose>
+                <xsl:when test="local:draggable-block($target)">
+                    <xsl:sequence select="ixsl:call($target,
+                        if (local:drop-before($event, $target)) then 'before' else 'after',
+                        [ $dragged ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:when>
+                <!-- into a cell: the text host becomes a container (its runs wrapped,
+                     the insert-block-at-caret flow doctrine) and the block appends -->
+                <xsl:otherwise>
+                    <xsl:for-each select="$target[@contenteditable = 'true']">
+                        <ixsl:remove-attribute name="contenteditable"/>
+                    </xsl:for-each>
+                    <xsl:call-template name="local:wrap-stray-runs">
+                        <xsl:with-param name="container" select="$target"/>
+                    </xsl:call-template>
+                    <xsl:sequence select="ixsl:call($target, 'appendChild', [ $dragged ])[current-date() lt xs:date('2000-01-01')]"/>
+                </xsl:otherwise>
+            </xsl:choose>
+            <!-- repair the origin: structural containers emptied by the lift-out go
+                 (a quote whose only block left - B7 doctrine), then a flow container
+                 that lost its last block reverts to a text host (both self-guard) -->
+            <xsl:for-each select="$origin-block[exists(local:root-of(.))]">
+                <xsl:call-template name="local:prune-husks">
+                    <xsl:with-param name="scope" select="."/>
+                </xsl:call-template>
+            </xsl:for-each>
+            <xsl:for-each select="$origin-flow[exists(local:root-of(.))]">
+                <xsl:call-template name="local:collapse-container">
+                    <xsl:with-param name="container" select="."/>
+                </xsl:call-template>
+            </xsl:for-each>
             <xsl:call-template name="local:after-mutation"/>
         </xsl:if>
     </xsl:template>
 
     <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')] | *[contains-token(@class, 'rdfa-editor-content')]//*" mode="ixsl:ondragend">
-        <xsl:for-each select="local:block-of(.)">
+        <!-- clean the actually-dragged block (the event target of a nested drag
+             may be a descendant, so re-deriving from it would miss) -->
+        <xsl:for-each select="ixsl:get(local:editor-state(), 'draggedBlock')">
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
             <ixsl:remove-attribute name="draggable"/>
+            <xsl:call-template name="local:tidy-class">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
         </xsl:for-each>
         <xsl:call-template name="local:clear-drop-marks"/>
         <ixsl:set-property name="draggedBlock" select="()" object="local:editor-state()"/>
@@ -2256,10 +2390,14 @@ version="3.0">
         <xsl:sequence select="(if ($types instance of array(*)) then $types?* else $types) = $type"/>
     </xsl:function>
 
-    <!-- the block to drop relative to: the hit-tested block when there is one,
-         else the geometrically nearest block by vertical midpoint - so gaps between
-         blocks, the container padding and the (tall) dragged block itself are all
-         valid drop zones instead of snapping the drag back -->
+    <!-- the block to drop relative to: the innermost content-model-legal block
+         under the pointer (a nested drop lands where the model admits the dragged
+         kind, clamped upward to the nearest legal level otherwise - the resolver
+         never produces invalid nesting), else the geometrically nearest top-level
+         block by vertical midpoint - so gaps between blocks, the container padding
+         and the (tall) dragged block itself are all valid drop zones instead of
+         snapping the drag back. The gutter and gaps resolve top-level: dropping
+         there lifts a nested block all the way out -->
     <xsl:function name="local:drop-target-of" as="element()?">
         <xsl:param name="hit"/>
         <xsl:param name="event"/>
@@ -2267,11 +2405,25 @@ version="3.0">
         <!-- blocks never move between editable regions -->
         <xsl:variable name="root" as="element()?"
             select="($dragged ! local:root-of(.), local:root-of($hit))[1]"/>
-        <xsl:variable name="block" as="element()?"
-            select="local:block-of($hit)[local:root-of(.) is $root]"/>
+        <xsl:variable name="deepest" as="element()?"
+            select="local:deepest-block-at($hit, $dragged)[local:root-of(.) is $root]"/>
+        <!-- a cell's pixels are unambiguous - nothing can legally drop before or
+             after a td/th, so pointing into a cell (away from any block it holds)
+             drops INTO it. A list item stays a clamp to around-the-list instead:
+             its pixels compete with reordering next to the list, and Tab/indent
+             already move content into items -->
+        <xsl:variable name="cell" as="element()?"
+            select="$hit/ancestor-or-self::*[self::td or self::th]
+                [empty(ancestor-or-self::* intersect $dragged)]
+                [local:root-of(.) is $root][1]"/>
         <xsl:choose>
-            <xsl:when test="exists($block) and not(exists($dragged) and $block is $dragged)">
-                <xsl:sequence select="$block"/>
+            <xsl:when test="exists($cell) and exists($dragged)
+                    and cm:allows-child(local-name($cell), local-name($dragged))
+                    and empty($deepest/ancestor::* intersect $cell)">
+                <xsl:sequence select="$cell"/>
+            </xsl:when>
+            <xsl:when test="exists($deepest) and exists($dragged)">
+                <xsl:sequence select="local:legal-drop-level($deepest, $dragged)"/>
             </xsl:when>
             <!-- geometric fallback only within the dragged block's own region:
                  a pointer over another region is not a drop zone at all -->
@@ -2299,11 +2451,15 @@ version="3.0">
     </xsl:function>
 
     <xsl:template name="local:clear-drop-marks">
-        <xsl:param name="scope" as="element()*" select="local:roots()/*"/>
+        <xsl:param name="scope" as="element()*" select="local:roots()/descendant::*"/>
         <xsl:for-each select="$scope[contains-token(@class, 'drop-before')
-                or contains-token(@class, 'drop-after')]">
+                or contains-token(@class, 'drop-after') or contains-token(@class, 'drop-into')]">
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'drop-before' ])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'drop-into' ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:tidy-class">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
         </xsl:for-each>
     </xsl:template>
 
diff --git a/src/undo.xsl b/src/undo.xsl
index 257d689..62b33e4 100644
--- a/src/undo.xsl
+++ b/src/undo.xsl
@@ -164,17 +164,16 @@ version="3.0">
         <xsl:for-each select="$root">
             <ixsl:set-property name="innerHTML" select="$snapshot" object="."/>
             <!-- the HTML fragment parser foster-parents non-table content out of a
-                 <table>, so a chrome span serialized inside a table lands as a bogus
-                 region child on restore. Drop the strays and re-inject (idempotent);
-                 must precede caret resolution, which indexes $root/* -->
-            <xsl:for-each select="*[@data-role = 'chrome']">
+                 <table>, so a chrome span serialized inside a (possibly nested)
+                 table lands astray on restore. Strip every handle and re-converge
+                 (deterministic: first-child prepend on each draggable block); must
+                 precede caret resolution, which indexes $root/* -->
+            <xsl:for-each select="descendant::*[@data-role = 'chrome']">
                 <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:for-each>
-            <xsl:for-each select="*">
-                <xsl:call-template name="local:inject-chrome">
-                    <xsl:with-param name="block" select="."/>
-                </xsl:call-template>
-            </xsl:for-each>
+            <xsl:call-template name="local:ensure-chrome">
+                <xsl:with-param name="scope" select="."/>
+            </xsl:call-template>
         </xsl:for-each>
         <!-- every stored node reference is stale now -->
         <xsl:call-template name="local:hide-overlay"/>
@@ -187,9 +186,12 @@ version="3.0">
         <ixsl:set-property name="lastUndoTime" select="0" object="local:editor-state()"/>
         <!-- snapshots taken mid-drag may carry transient drag state -->
         <xsl:call-template name="local:clear-drop-marks"/>
-        <xsl:for-each select="$root/*[@draggable]">
+        <xsl:for-each select="$root/descendant::*[@draggable]">
             <ixsl:remove-attribute name="draggable"/>
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:call-template name="local:tidy-class">
+                <xsl:with-param name="element" select="."/>
+            </xsl:call-template>
         </xsl:for-each>
         <!-- the caret stored with a snapshot is the caret of that state: restore it -->
         <xsl:variable name="block-index" as="xs:integer?" select="$caret[1]"/>
@@ -256,8 +258,10 @@ version="3.0">
         </xsl:if>
     </xsl:template>
 
-    <!-- the single post-mutation refresh hook: lint markers, live ToC, breadcrumb -->
+    <!-- the single post-mutation refresh hook: chrome convergence (a gesture may
+         have built nested draggable blocks), lint markers, live ToC, breadcrumb -->
     <xsl:template name="local:after-mutation">
+        <xsl:call-template name="local:ensure-chrome"/>
         <xsl:call-template name="local:run-lint"/>
         <xsl:if test="id('toc-drawer', ixsl:page()) ! (ixsl:get(., 'style.display') ne 'none')">
             <xsl:call-template name="local:render-toc"/>
diff --git a/tests/browser/authoring.mjs b/tests/browser/authoring.mjs
index 6207dd3..8c267ba 100644
--- a/tests/browser/authoring.mjs
+++ b/tests/browser/authoring.mjs
@@ -72,7 +72,7 @@ results.quoteOn = await page.evaluate(() => {
     return {
         wrapped: !!bq && bq.querySelector(':scope > p')?.getAttribute('contenteditable') === 'true',
         chromeOnQuote: !!bq?.querySelector(':scope > [data-role=chrome]'),
-        noChromeOnP: !bq?.querySelector(':scope > p > [data-role=chrome]'),
+        chromeOnInnerP: !!bq?.querySelector(':scope > p > [data-role=chrome]'),
         notEditableItself: bq?.getAttribute('contenteditable') !== 'true',
     };
 });
@@ -309,7 +309,7 @@ results.insertListInCell = await page.evaluate(() => {
         cellIsContainer: td.getAttribute('contenteditable') !== 'true',
         textKeptAsRun: td.querySelector(':scope > p.rdfa-editor-run')?.textContent === 'Plain cell',
         runEditable: td.querySelector(':scope > p.rdfa-editor-run')?.getAttribute('contenteditable') === 'true',
-        noChromeInCell: !td.querySelector('[data-role=chrome]'),
+        chromeOnCellList: !!td.querySelector(':scope > ol > [data-role=chrome]'),
         notAfterTable: !document.querySelector('#content > table + ol'),
         caretInNewItem: td.querySelector(':scope > ol > li').contains(window.getSelection().anchorNode)
             || td.querySelector(':scope > ol > li') === window.getSelection().anchorNode,
diff --git a/tests/browser/dragnest.mjs b/tests/browser/dragnest.mjs
new file mode 100644
index 0000000..944d9e5
--- /dev/null
+++ b/tests/browser/dragnest.mjs
@@ -0,0 +1,303 @@
+// Nested drag-and-drop: every %block carries its own handle wherever the content
+// model places blocks, and drops resolve to the innermost legal level - lifting a
+// nested block (incl. an RDFa object div) out of a list item, dropping a top-level
+// block into a container or INTO a table cell (a cell's pixels are unambiguous:
+// nothing drops before/after a td), clamping over illegal spots, staying
+// region-scoped. Real mouse gestures throughout (Playwright synthesizes HTML5
+// drag events from mouse.down + moves). Runs against fixture-dragnest.html.
+import { chromium } from 'playwright';
+
+const BASE = process.env.BASE_URL ?? 'http://localhost:8080';
+
+const errors = [];
+const results = {};
+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 undoKey = 'Control+z';
+const load = async () => {
+    await page.goto(BASE + '/tests/fixture-dragnest.html');
+    // nested chrome proves the recursive init reached the quote inside the li
+    await page.waitForSelector('#content li > blockquote > [data-role=chrome]',
+        { state: 'attached', timeout: 15000 })
+        .catch(() => errors.push('nested chrome never injected'));
+};
+const baselineOf = () => page.evaluate(() => document.getElementById('content').innerHTML);
+
+// viewport center of a block's drag handle (hover the block first so the
+// handle's visibility and geometry are settled)
+const handleAt = async selector => {
+    const block = await page.evaluate(sel => {
+        const r = document.querySelector(sel).getBoundingClientRect();
+        return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+    }, selector);
+    await page.mouse.move(block.x, block.y);
+    return page.evaluate(sel => {
+        const r = document.querySelector(sel + ' > [data-role=chrome]').getBoundingClientRect();
+        return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+    }, selector);
+};
+
+// viewport point within a block: fraction of its height picks before (< .5)
+// or after (> .5) per the midpoint rule
+const pointIn = (selector, fraction) => page.evaluate(([sel, f]) => {
+    const r = document.querySelector(sel).getBoundingClientRect();
+    return { x: r.x + Math.min(r.width / 2, 200), y: r.y + r.height * f };
+}, [selector, fraction]);
+
+const dragReal = async (from, to) => {
+    await page.mouse.move(from.x, from.y);
+    await page.mouse.down();
+    for (let i = 1; i <= 8; i++)
+        await page.mouse.move(from.x + (to.x - from.x) * i / 8, from.y + (to.y - from.y) * i / 8);
+    await page.mouse.up();
+};
+
+// the invariants net, with the nested-chrome contract: chrome only as a child
+// of a draggable block (a real %block in a region / flow container / blockquote)
+const invariants = () => page.evaluate(() => {
+    const v = [];
+    const region = document.getElementById('content');
+    const BLOCK = new Set(['P', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'DIV', 'UL', 'OL', 'DL',
+        'PRE', 'BLOCKQUOTE', 'ADDRESS', 'FIELDSET', 'TABLE', 'FIGURE']);
+    const FLOW = new Set(['LI', 'DD', 'TD', 'TH', 'DIV', 'FIGURE', 'FIGCAPTION']);
+    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('[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 c of region.querySelectorAll('[data-role=chrome]')) {
+        const b = c.parentElement;
+        const ok = BLOCK.has(b.tagName) && !b.classList.contains('rdfa-editor-run')
+            && (b.parentElement === region || FLOW.has(b.parentElement.tagName)
+                || b.parentElement.tagName === 'BLOCKQUOTE');
+        if (!ok) v.push('stray chrome in: ' + b.tagName.toLowerCase());
+    }
+    if (document.getElementById('lint-badge').style.display !== 'none')
+        v.push('lint: ' + document.getElementById('lint-badge').textContent);
+    return v;
+});
+
+// act, check invariants, undo once, compare against the pre-gesture baseline
+const settle = async baseline => {
+    const v = await invariants();
+    await page.evaluate(() => document.querySelector('#content [contenteditable=true]')?.focus());
+    await page.keyboard.press(undoKey);
+    const restored = await baselineOf() === baseline;
+    return { invariantsOk: v.length === 0, ...(v.length ? { violations: v } : {}), undoRestores: restored };
+};
+
+// ==== init: handles on nested blocks, none on non-blocks =========================
+await load();
+results.init = await page.evaluate(() => {
+    const li = [...document.querySelectorAll('#content > ul > li')];
+    const objectDiv = document.querySelector('#content li > div[about="#note"]');
+    return {
+        nestedPChrome: !!document.querySelector('#content li > p > [data-role=chrome]'),
+        nestedQuoteChrome: !!document.querySelector('#content li > blockquote > [data-role=chrome]'),
+        quoteInnerPChrome: !!document.querySelector('#content li > blockquote > p > [data-role=chrome]'),
+        objectDivChrome: !!objectDiv?.querySelector(':scope > [data-role=chrome]'),
+        objectDivEditable: objectDiv?.getAttribute('contenteditable') === 'true',
+        noChromeOnLi: li.every(l => ![...l.children].some(c => c.getAttribute('data-role') === 'chrome')),
+        noChromeOnRun: !document.querySelector('#content p.rdfa-editor-run > [data-role=chrome]'),
+    };
+});
+{
+    const v = await invariants();
+    results.initInvariantsOk = v.length === 0;
+    if (v.length) results.initViolations = v;
+}
+
+// ==== S1: lift the nested blockquote out of its list item ========================
+await load();
+{
+    const baseline = await baselineOf();
+    await dragReal(await handleAt('#content li > blockquote'), await pointIn('#content > p + ul + p', 0.8));
+    results.liftOut = await page.evaluate(() => {
+        const bq = [...document.querySelectorAll('#content > blockquote')]
+            .find(b => b.textContent.includes('Quote in item'));
+        const li = [...document.querySelectorAll('#content > ul > li')]
+            .find(l => l.textContent.includes('Block item'));
+        return {
+            atTopLevel: !!bq && !!bq.previousElementSibling
+                && bq.previousElementSibling.textContent.includes('Tail paragraph'),
+            chromeKept: !!bq?.querySelector(':scope > [data-role=chrome]'),
+            liKeepsBlock: !!li?.querySelector(':scope > p') && !li.querySelector(':scope > blockquote'),
+        };
+    });
+    Object.assign(results.liftOut, await settle(baseline));
+}
+
+// ==== S2: the motivating case - the RDFa object div leaves its list item =========
+await load();
+{
+    const baseline = await baselineOf();
+    await dragReal(await handleAt('#content li > div[about="#note"]'), await pointIn('#content > p + ul + p', 0.8));
+    results.objectOut = await page.evaluate(() => {
+        const div = document.querySelector('#content > div[about="#note"]');
+        const li = [...document.querySelectorAll('#content > ul > li')]
+            .find(l => l.textContent.includes('Object holder'));
+        return {
+            atTopLevel: !!div,
+            rdfaIntact: div?.querySelector(':scope > span[property]')?.textContent === 'Note body',
+            liCollapsed: li?.getAttribute('contenteditable') === 'true'
+                && !li.querySelector('.rdfa-editor-run'),
+        };
+    });
+    Object.assign(results.objectOut, await settle(baseline));
+}
+
+// ==== S3: a top-level paragraph drops INTO the list item =========================
+await load();
+{
+    const baseline = await baselineOf();
+    await dragReal(await handleAt('#content > h1 + p'), await pointIn('#content li > p:not(.rdfa-editor-run)', 0.8));
+    results.dropInto = await page.evaluate(() => {
+        const li = [...document.querySelectorAll('#content > ul > li')]
+            .find(l => l.textContent.includes('Block item'));
+        const kids = li ? [...li.children].filter(c => !c.hasAttribute('data-role')) : [];
+        return {
+            nested: kids.length === 3 && kids[1].tagName === 'P'
+                && kids[1].textContent.includes('Intro paragraph'),
+            leftTopLevel: ![...document.querySelectorAll('#content > p')]
+                .some(p => p.textContent.includes('Intro paragraph')),
+        };
+    });
+    Object.assign(results.dropInto, await settle(baseline));
+}
+
+// ==== S4: over a plain item the legal level is the whole list ====================
+// (li is not a drop target; the deepest draggable block there is the ul itself,
+// so the paragraph lands before/after the list - never as an invalid ul child)
+await load();
+{
+    const baseline = await baselineOf();
+    await dragReal(await handleAt('#content > h1 + p'), await pointIn('#content > ul > li', 0.4));
+    results.legalClamp = await page.evaluate(() => ({
+        noPInUl: !document.querySelector('#content ul > p'),
+        beforeList: !!document.querySelector('#content > p + ul')
+            && document.querySelector('#content > ul').previousElementSibling
+                .textContent.includes('Intro paragraph'),
+    }));
+    Object.assign(results.legalClamp, await settle(baseline));
+}
+
+// ==== S5: a drag never crosses regions ===========================================
+await load();
+{
+    const baseline = await baselineOf();
+    const embeddedBefore = await page.evaluate(() => document.getElementById('embedded').innerHTML);
+    await dragReal(await handleAt('#content li > blockquote'), await pointIn('#embedded > p', 0.5));
+    results.crossRegion = {
+        contentIntact: await baselineOf() === baseline,
+        embeddedIntact: await page.evaluate(() => document.getElementById('embedded').innerHTML) === embeddedBefore,
+    };
+}
+
+// ==== S6: a nested handle press never arms a selection sweep =====================
+await load();
+{
+    const from = await handleAt('#content li > blockquote > p');
+    await page.mouse.move(from.x, from.y);
+    await page.mouse.down();
+    const to = await pointIn('#content > p + ul + p', 0.5);
+    for (let i = 1; i <= 4; i++)
+        await page.mouse.move(from.x + (to.x - from.x) * i / 4, from.y + (to.y - from.y) * i / 4);
+    results.nestedHandleNotHijacked = {
+        neverArmed: await page.evaluate(() => window.rdfaEditor.sweepAnchorNode == null),
+    };
+    await page.mouse.up();
+}
+
+// ==== S7: gesture-built nested blocks converge on a handle =======================
+// (Enter splits the paragraph inside the quote; the new sibling paragraph gets
+// its chrome from the after-mutation sweep, not from the split site)
+await load();
+{
+    const baseline = await baselineOf();
+    await page.evaluate(() => {
+        const p = document.querySelector('#content li > blockquote > p');
+        p.focus();
+        const t = [...p.childNodes].find(n => n.nodeType === 3);
+        window.getSelection().collapse(t, 5);
+    });
+    await page.keyboard.press('Enter');
+    results.splitConverges = await page.evaluate(() => {
+        const ps = document.querySelectorAll('#content li > blockquote > p');
+        return {
+            split: ps.length === 2,
+            bothHaveChrome: [...ps].every(p => !!p.querySelector(':scope > [data-role=chrome]')),
+        };
+    });
+    Object.assign(results.splitConverges, await settle(baseline));
+}
+
+// ==== S8: a paragraph drops INTO a text-only cell ================================
+// (nothing can legally drop before/after a td, so a cell's pixels mean "into":
+// the text host becomes a container - its text wrapped as a run - and the block
+// appends; hovering a block INSIDE a cell still places before/after that block)
+await load();
+{
+    const baseline = await baselineOf();
+    const cellPoint = await page.evaluate(() => {
+        const td = [...document.querySelectorAll('#content td')]
+            .find(t => t.textContent.includes('Plain cell'));
+        const r = td.getBoundingClientRect();
+        return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+    });
+    await dragReal(await handleAt('#content > h1 + p'), cellPoint);
+    results.dropIntoCell = await page.evaluate(() => {
+        const td = [...document.querySelectorAll('#content td')]
+            .find(t => t.textContent.includes('Plain cell'));
+        return {
+            nested: !!td.querySelector(':scope > p:not(.rdfa-editor-run)')
+                && td.querySelector(':scope > p:not(.rdfa-editor-run)').textContent.includes('Intro paragraph'),
+            cellIsContainer: td.getAttribute('contenteditable') !== 'true',
+            textKeptAsRun: td.querySelector(':scope > p.rdfa-editor-run')?.textContent === 'Plain cell',
+            markCleared: !td.classList.contains('drop-into'),
+        };
+    });
+    Object.assign(results.dropIntoCell, await settle(baseline));
+}
+
+// ==== S9: a block inside a cell still takes precise before/after drops ===========
+await load();
+{
+    const baseline = await baselineOf();
+    await dragReal(await handleAt('#content > h1 + p'), await pointIn('#content td > p', 0.2));
+    results.dropBeforeCellBlock = await page.evaluate(() => {
+        const td = [...document.querySelectorAll('#content td')]
+            .find(t => t.textContent.includes('Cell para'));
+        const kids = [...td.children].filter(c => !c.hasAttribute('data-role'));
+        return {
+            placedBefore: kids.length === 2 && kids[0].textContent.includes('Intro paragraph')
+                && kids[1].textContent.includes('Cell para'),
+        };
+    });
+    Object.assign(results.dropBeforeCellBlock, await settle(baseline));
+}
+
+// ==== S10: canonical serialization stays clean of nested chrome ==================
+await load();
+{
+    await page.click('#view-source');
+    results.canonicalClean = await page.evaluate(() => {
+        const src = document.getElementById('output-content').textContent;
+        return {
+            noChrome: !src.includes('data-role') && !src.includes('⠿'),
+            objectDivKept: src.includes('about="#note"'),
+        };
+    });
+}
+
+console.log(JSON.stringify({ results, errors: errors.slice(0, 5) }, null, 2));
+await browser.close();
+const flat = JSON.stringify(results);
+process.exit(errors.length || flat.includes('false') ? 1 : 0);
diff --git a/tests/browser/invariants.mjs b/tests/browser/invariants.mjs
index d1d1765..2f954c9 100644
--- a/tests/browser/invariants.mjs
+++ b/tests/browser/invariants.mjs
@@ -4,7 +4,8 @@
 // must satisfy properties that hold regardless of what the gesture did:
 //   I1 every non-ws text node sits inside an editable host (nothing uneditable)
 //   I2 hosts never nest (contenteditable inside contenteditable)
-//   I3 chrome only as a direct child of top-level blocks
+//   I3 chrome only as a child of a draggable block (a real %block - never a run
+//      wrapper - in a region, a flow container or a blockquote)
 //   I4 run wrappers are editable, marker-classed paragraphs inside containers
 //   I5 the lint badge stays hidden (editor gestures never produce invalid nesting)
 // and after the battery, undo unwinds back to the exact post-init baseline.
@@ -61,10 +62,18 @@ const invariants = () => page.evaluate(() => {
     // I2: no nested hosts
     for (const h of region.querySelectorAll('[contenteditable=true] [contenteditable=true]'))
         v.push('nested host: ' + h.tagName.toLowerCase());
-    // I3: chrome only on top-level blocks
-    for (const c of region.querySelectorAll('[data-role=chrome]'))
-        if (c.parentElement.parentElement !== region)
-            v.push('nested chrome in: ' + c.parentElement.tagName.toLowerCase());
+    // I3: chrome only on draggable blocks (a real %block, never a run wrapper,
+    // sitting in the region, a flow container or a blockquote)
+    const BLOCK = new Set(['P', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'DIV', 'UL', 'OL', 'DL',
+        'PRE', 'BLOCKQUOTE', 'ADDRESS', 'FIELDSET', 'TABLE', 'FIGURE']);
+    const FLOW = new Set(['LI', 'DD', 'TD', 'TH', 'DIV', 'FIGURE', 'FIGCAPTION']);
+    for (const c of region.querySelectorAll('[data-role=chrome]')) {
+        const b = c.parentElement;
+        const ok = BLOCK.has(b.tagName) && !b.classList.contains('rdfa-editor-run')
+            && (b.parentElement === region || FLOW.has(b.parentElement.tagName)
+                || b.parentElement.tagName === 'BLOCKQUOTE');
+        if (!ok) v.push('stray chrome in: ' + b.tagName.toLowerCase());
+    }
     // I4: run wrappers are editable p's inside containers
     for (const r of region.querySelectorAll('.rdfa-editor-run')) {
         if (r.tagName !== 'P') v.push('run wrapper is ' + r.tagName.toLowerCase());
diff --git a/tests/browser/nesting.mjs b/tests/browser/nesting.mjs
index 397fe90..4d88d12 100644
--- a/tests/browser/nesting.mjs
+++ b/tests/browser/nesting.mjs
@@ -53,9 +53,14 @@ results.init = await page.evaluate(() => {
         blockItemIsContainer: blockItem && !editable(blockItem),
         blockItemPEditable: editable(blockItem?.querySelector(':scope > p')),
         nestedQuotePEditable: editable(blockItem?.querySelector(':scope > blockquote > p')),
-        // drag handles are direct children of top-level blocks only, never nested deeper
-        noChromeBelowTopLevel: [...document.querySelectorAll('#content [data-role=chrome]')]
-            .every(c => c.parentElement.parentElement === document.getElementById('content')),
+        // drag handles on every draggable block - nested ones included - but
+        // never on list items, cells or run wrappers (they are not %block units)
+        chromeOnNestedBlocks: !!blockItem?.querySelector(':scope > p > [data-role=chrome]')
+            && !!blockItem?.querySelector(':scope > blockquote > [data-role=chrome]')
+            && !!mixed?.querySelector(':scope > ul > [data-role=chrome]'),
+        noChromeOnNonBlocks: ![...document.querySelectorAll('#content li, #content td')]
+            .some(el => [...el.children].some(c => c.getAttribute('data-role') === 'chrome'))
+            && !document.querySelector('#content p.rdfa-editor-run > [data-role=chrome]'),
         chromeOnTopLevel: !!document.querySelector('#content > ul > [data-role=chrome]'),
         cellIsContainer: cell && !editable(cell),
         cellPEditable: editable(cell?.querySelector(':scope > p')),
@@ -99,7 +104,8 @@ results.quoteEnter = await page.evaluate(() => {
     const bq = document.querySelector('#content > blockquote');
     return {
         splitIntoTwo: bq.querySelectorAll(':scope > p').length === 2,
-        noChromeInside: !bq.querySelector('p [data-role=chrome], :scope > p > [data-role=chrome]'),
+        chromeOnBothPs: [...bq.querySelectorAll(':scope > p')]
+            .every(p => !!p.querySelector(':scope > [data-role=chrome]')),
         caretInSecond: bq.querySelectorAll(':scope > p')[1].contains(window.getSelection().anchorNode),
     };
 });
diff --git a/tests/browser/notion.mjs b/tests/browser/notion.mjs
index 9dd8f7f..d256084 100644
--- a/tests/browser/notion.mjs
+++ b/tests/browser/notion.mjs
@@ -69,9 +69,16 @@ const invariants = () => page.evaluate(() => {
     }
     for (const h of region.querySelectorAll('[contenteditable=true] [contenteditable=true]'))
         v.push('nested host: ' + 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());
+    const BLOCK = new Set(['P', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'DIV', 'UL', 'OL', 'DL',
+        'PRE', 'BLOCKQUOTE', 'ADDRESS', 'FIELDSET', 'TABLE', 'FIGURE']);
+    const FLOW = new Set(['LI', 'DD', 'TD', 'TH', 'DIV', 'FIGURE', 'FIGCAPTION']);
+    for (const c of region.querySelectorAll('[data-role=chrome]')) {
+        const b = c.parentElement;
+        const ok = BLOCK.has(b.tagName) && !b.classList.contains('rdfa-editor-run')
+            && (b.parentElement === region || FLOW.has(b.parentElement.tagName)
+                || b.parentElement.tagName === 'BLOCKQUOTE');
+        if (!ok) v.push('stray chrome in: ' + b.tagName.toLowerCase());
+    }
     if (document.getElementById('lint-badge').style.display !== 'none')
         v.push('lint: ' + document.getElementById('lint-badge').textContent);
     return v;
@@ -187,7 +194,7 @@ assert('slash.figureInsideCell', await page.evaluate(() => {
     const td = document.querySelector('#content > table tr > td:nth-child(2)');
     const fig = td?.querySelector(':scope > figure');
     return !!fig && td.getAttribute('contenteditable') !== 'true'   // cell became a container
-        && !fig.querySelector('[data-role=chrome]')                  // nested: no drag handle
+        && !!fig.querySelector(':scope > [data-role=chrome]')        // nested blocks drag too
         && document.querySelectorAll('#content > figure').length === 1; // only the fixture's own
 }));
 await clean('slash.figure');
@@ -208,7 +215,7 @@ assert('slash.tableInsideLi', await page.evaluate(() => {
     const li = document.querySelector('#content > ul > li');
     const table = li?.querySelector(':scope > table');
     return !!table && li.getAttribute('contenteditable') !== 'true'
-        && !table.querySelector('[data-role=chrome]')
+        && !!table.querySelector(':scope > [data-role=chrome]')        // nested blocks drag too
         && document.querySelectorAll('#content > table').length === 1  // the fixture's own only
         && table.contains(window.getSelection().anchorNode);           // caret in the first cell
 }));
@@ -262,9 +269,10 @@ await page.waitForTimeout(80);
 assert('md.quoteWraps', await page.evaluate(() => {
     const q = [...document.querySelectorAll('#content > blockquote')].find(b => !b.textContent.includes('Bare quote'));
     const p = q?.querySelector(':scope > p');
+    const chrome = p?.querySelector(':scope > [data-role=chrome]');
     return !!p && p.getAttribute('contenteditable') === 'true'
-        && p.textContent === '' && !!q.querySelector(':scope > [data-role=chrome]')
-        && !p.querySelector('[data-role=chrome]');
+        && !!q.querySelector(':scope > [data-role=chrome]') && !!chrome
+        && p.textContent === chrome.textContent; // empty host bar its own handle
 }));
 await clean('md.quoteWraps');
 
diff --git a/tests/browser/run.mjs b/tests/browser/run.mjs
index a38d873..7ed5a66 100644
--- a/tests/browser/run.mjs
+++ b/tests/browser/run.mjs
@@ -25,7 +25,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', 'dragnest']) {
     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/browser/select.mjs b/tests/browser/select.mjs
index 9cd50f7..ee8bd47 100644
--- a/tests/browser/select.mjs
+++ b/tests/browser/select.mjs
@@ -67,9 +67,16 @@ const invariants = () => page.evaluate(() => {
     }
     for (const h of region.querySelectorAll('[contenteditable=true] [contenteditable=true]'))
         v.push('nested host: ' + 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());
+    const BLOCK = new Set(['P', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'DIV', 'UL', 'OL', 'DL',
+        'PRE', 'BLOCKQUOTE', 'ADDRESS', 'FIELDSET', 'TABLE', 'FIGURE']);
+    const FLOW = new Set(['LI', 'DD', 'TD', 'TH', 'DIV', 'FIGURE', 'FIGCAPTION']);
+    for (const c of region.querySelectorAll('[data-role=chrome]')) {
+        const b = c.parentElement;
+        const ok = BLOCK.has(b.tagName) && !b.classList.contains('rdfa-editor-run')
+            && (b.parentElement === region || FLOW.has(b.parentElement.tagName)
+                || b.parentElement.tagName === 'BLOCKQUOTE');
+        if (!ok) v.push('stray chrome in: ' + b.tagName.toLowerCase());
+    }
     for (const r of region.querySelectorAll('.rdfa-editor-run')) {
         if (r.tagName !== 'P') v.push('run wrapper is ' + r.tagName.toLowerCase());
         if (r.getAttribute('contenteditable') !== 'true') v.push('uneditable run wrapper');
diff --git a/tests/expected/canonical/23-nested-chrome-strip.xhtml b/tests/expected/canonical/23-nested-chrome-strip.xhtml
new file mode 100644
index 0000000..0814158
--- /dev/null
+++ b/tests/expected/canonical/23-nested-chrome-strip.xhtml
@@ -0,0 +1,20 @@
+<div xmlns="http://www.w3.org/1999/xhtml" about=""
+     typeof="https://www.w3.org/ns/ldt/document-hierarchy#Container">
+    <p>Intro paragraph.</p>
+    <ul>
+        <li>Object holder<div about="#note"
+                typeof="https://example.org/ns#Note"><span property="https://example.org/ns#value">Note body</span></div></li>
+        <li><p>Block item</p><blockquote>
+                <p>Quote in item</p>
+            </blockquote></li>
+    </ul>
+    <table>
+        <tbody>
+            <tr>
+                <td>Cell text<ul>
+                        <li>cell item</li>
+                    </ul></td>
+            </tr>
+        </tbody>
+    </table>
+</div>
diff --git a/tests/expected/lint/13-nested-object-div-clean.txt b/tests/expected/lint/13-nested-object-div-clean.txt
new file mode 100644
index 0000000..e69de29
diff --git a/tests/fixture-dragnest.html b/tests/fixture-dragnest.html
new file mode 100644
index 0000000..d235aa7
--- /dev/null
+++ b/tests/fixture-dragnest.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 - nested drag-and-drop 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/index.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">Drag nesting demo</h1>
+            <p>Intro paragraph.</p>
+            <ul>
+                <li>Plain item</li>
+                <li>Object holder<div about="#note" typeof="https://example.org/ns#Note"><span property="https://example.org/ns#value">Note body</span></div></li>
+                <li><p>Block item</p><blockquote><p>Quote in item</p></blockquote></li>
+            </ul>
+            <p>Tail paragraph.</p>
+            <table>
+                <tbody>
+                    <tr>
+                        <td><p>Cell para</p></td>
+                        <td>Plain cell</td>
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+
+        <!-- a second region: blocks never move between regions -->
+        <div id="embedded" class="rdfa-editor-content" about="#embedded">
+            <p>Embedded paragraph.</p>
+        </div>
+    </body>
+</html>
diff --git a/tests/fixtures/canonical/23-nested-chrome-strip.xhtml b/tests/fixtures/canonical/23-nested-chrome-strip.xhtml
new file mode 100644
index 0000000..a26e628
--- /dev/null
+++ b/tests/fixtures/canonical/23-nested-chrome-strip.xhtml
@@ -0,0 +1,29 @@
+<div xmlns="http://www.w3.org/1999/xhtml" id="content" about=""
+     typeof="https://www.w3.org/ns/ldt/document-hierarchy#Container">
+    <p contenteditable="true"><span data-role="chrome" class="drag-handle"
+        contenteditable="false">&#x28FF;</span>Intro paragraph.</p>
+    <ul>
+        <span data-role="chrome" class="drag-handle" contenteditable="false">&#x28FF;</span>
+        <li><p class="rdfa-editor-run" contenteditable="true">Object holder</p><div
+                about="#note" typeof="https://example.org/ns#Note" contenteditable="true"
+                draggable="true" class="dragging"><span data-role="chrome" class="drag-handle"
+                contenteditable="false">&#x28FF;</span><span property="https://example.org/ns#value">Note body</span></div></li>
+        <li><p contenteditable="true" class="drop-after"><span data-role="chrome"
+                class="drag-handle" contenteditable="false">&#x28FF;</span>Block item</p><blockquote>
+                <span data-role="chrome" class="drag-handle" contenteditable="false">&#x28FF;</span>
+                <p contenteditable="true"><span data-role="chrome" class="drag-handle"
+                    contenteditable="false">&#x28FF;</span>Quote in item</p>
+            </blockquote></li>
+    </ul>
+    <table>
+        <span data-role="chrome" class="drag-handle" contenteditable="false">&#x28FF;</span>
+        <tbody>
+            <tr>
+                <td><p class="rdfa-editor-run" contenteditable="true">Cell text</p><ul>
+                        <span data-role="chrome" class="drag-handle" contenteditable="false">&#x28FF;</span>
+                        <li contenteditable="true">cell item</li>
+                    </ul></td>
+            </tr>
+        </tbody>
+    </table>
+</div>
diff --git a/tests/fixtures/lint/13-nested-object-div-clean.xhtml b/tests/fixtures/lint/13-nested-object-div-clean.xhtml
new file mode 100644
index 0000000..8b783cd
--- /dev/null
+++ b/tests/fixtures/lint/13-nested-object-div-clean.xhtml
@@ -0,0 +1,10 @@
+<div xmlns="http://www.w3.org/1999/xhtml" about="">
+    <p>Intro paragraph.</p>
+    <ul>
+        <li>Object holder<div about="#note" typeof="https://example.org/ns#Note"><span property="https://example.org/ns#value">Note body</span></div></li>
+        <li><div about="#solo" typeof="https://example.org/ns#Note"><span property="https://example.org/ns#value">Sole block</span></div></li>
+    </ul>
+    <div about="#lifted" typeof="https://example.org/ns#Note"><span property="https://example.org/ns#value">Lifted out</span></div>
+    <blockquote><div about="#quoted" typeof="https://example.org/ns#Note"><span property="https://example.org/ns#value">In a quote</span></div></blockquote>
+    <table><tr><td>Cell text<div about="#celled" typeof="https://example.org/ns#Note"><span property="https://example.org/ns#value">In a cell</span></div></td></tr></table>
+</div>