diff --git a/CLAUDE.md b/CLAUDE.md
index 0c38f70..4351540 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -4,40 +4,40 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Multi-instance model (M2)
 
-- **Editable regions** are any elements with the `rdfa-editor-content` class token (host-page chrome, canonicalization-stripped). No `id('content')` singletons anywhere: `local:roots()`, `local:root-of()`, `local:active-root()` (selection, then last focused host, then first region) in `edit.xsl`.
+- **Editable regions** are any elements with the `rdfa-editor-content` class token (host-page chrome, canonicalization-stripped). No `id('content')` singletons anywhere: `rdfae:roots()`, `rdfae:root-of()`, `rdfae:active-root()` (selection, then last focused host, then first region) in `edit.xsl`.
 - **Undo is region-keyed**: one global stack, each stash entry carries `data-root` (region index) and restores only its region; caret data is region-relative. Stash ids: `rdfa-editor-undo-storage/-stack/-redo-stack`.
 - Blocks never move between regions (drop-target resolution is scoped to the dragged block's region). ToC and view-source follow the active region (`tocRoot` remembered at render); lint and find work across all regions.
-- **Editor state lives on one window container** `window.rdfaEditor` — a single object created with `Object()` in the `main` template (mirrors LinkedDataHub's `window.LinkedDataHub`), holding all mutable state under bare names (`range`, `activeBlock`, `editingSpan`, …). Every read/write goes through the `local:editor-state()` accessor (`index.xsl`): reads `ixsl:get(local:editor-state(), 'range')`, writes `object="local:editor-state()"`. Browser globals (`scrollX`, `Date`, `location.href`, …) are read straight off `ixsl:window()` and are not editor state. Editor UI containers carry the `rdfa-editor-ui` class and all generic CSS selectors (`.btn-*`, `.modal-*`, `.crumb`, …) are scoped under it — LDH/Bootstrap pages stay unaffected.
+- **Editor state lives on one window container** `window.rdfaEditor` — a single object created with `Object()` in the `main` template (mirrors LinkedDataHub's `window.LinkedDataHub`), holding all mutable state under bare names (`range`, `activeBlock`, `editingSpan`, …). Every read/write goes through the `rdfae:editor-state()` accessor (`index.xsl`): reads `ixsl:get(rdfae:editor-state(), 'range')`, writes `object="rdfae:editor-state()"`. Browser globals (`scrollX`, `Date`, `location.href`, …) are read straight off `ixsl:window()` and are not editor state. Editor UI containers carry the `rdfa-editor-ui` class and all generic CSS selectors (`.btn-*`, `.modal-*`, `.crumb`, …) are scoped under it — LDH/Bootstrap pages stay unaffected.
 - The extractor entry is a **named template only** (`-it:extract-rdfa`; no unnamed-mode `match="/"`) so it composes with host stylesheets' root templates. Integration with LinkedDataHub's client.xsl is compile-proven (see docs/ldh/MIGRATION.md §10).
 - Links in content: plain click places the caret (links render with a text I-beam, not a pointer, so the affordance matches — they are editable text); Ctrl/Cmd+Click opens the href. The annotation overlay paints the stored selection as `.rdfa-editor-selection-hint` boxes (no content mutation), cleared on hide.
 
 ## 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 (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. **Object blocks** (blocks.xsl) embed RDF-defined blocks per the LDH v6 document format (`XHTML-RDFa-as-LDH-v6-Document-Format` wiki) in two kinds: a *defined* block — a `div[@about][@typeof]` whose `@typeof` matches the `$object-block-types` param, fragment `@about` (a document part), its defining triples inline as `span[@property]` children — and a *reference* block — an **empty div whose absolute `@about` names a resource outside the document** (no `ldh:Object` wrapper, no `rdf:value` indirection — naming the resource IS the reference, and the empty div extracts to zero triples). Both are treated as **atomic islands** (never editable inside, focusable/navigable/deletable like block images, hard merge/delete boundaries) and rendered client-side into an ephemeral `div[@data-role='rendering']` child via the overridable `mode="local:render-island"` hook; the LinkedDataHub extension (ldh-blocks.xsl, layered by the ldh-editor.xsl entry via `xsl:import`) supplies `ldh:View`/`ldh:ResultSetChart` renderers plus the reference dereferencer (conneg on the `@about` URI — a DBpedia resource works directly, CORS + 303 to RDF/XML), an insert dialog and slash/toolbar contributions. Nesting follows the **XHTML Strict content model** (see content-model.xsl below): `blockquote` is a block *container* (`blockquote > p+` — bare text inside it is invalid and gets normalized; the toolbar quote toggle wraps/unwraps), `li`/`td`/`th`/`dd`/`figcaption` are `%Flow;` (mixed text AND nested blocks — Tab/Shift+Tab indent/outdent nested lists), `p`/`h1–h6`/`caption`/`dt` are inline-only. Tables are composite blocks (structure locked; `td`/`th`/`caption` editable) inserted via a rows×cols dialog with an optional header row and caption; row/column toolbar controls, Tab/Shift+Tab cell traversal and Enter (step down a column) all grow the grid at its bottom edge. Right-click a text selection to annotate it with RDFa; right-click an existing annotation to edit or remove it. "Extract RDF" shows the page's triples; "Source" shows the canonical XHTML+RDFa serialization (all editing ephemera stripped) in [Exclusive XML Canonicalization](https://www.w3.org/TR/xml-exc-c14n/) form (`<br></br>`, sorted attributes/namespace declarations, no indentation — the `rdf:XMLLiteral` value space).
+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. **Object blocks** (blocks.xsl) embed RDF-defined blocks per the LDH v6 document format (`XHTML-RDFa-as-LDH-v6-Document-Format` wiki) in two kinds: a *defined* block — a `div[@about][@typeof]` whose `@typeof` matches the `$object-block-types` param, fragment `@about` (a document part), its defining triples inline as `span[@property]` children — and a *reference* block — an **empty div whose absolute `@about` names a resource outside the document** (no `ldh:Object` wrapper, no `rdf:value` indirection — naming the resource IS the reference, and the empty div extracts to zero triples). Both are treated as **atomic islands** (never editable inside, focusable/navigable/deletable like block images, hard merge/delete boundaries) and rendered client-side into an ephemeral `div[@data-role='rendering']` child via the overridable `mode="rdfae:render-island"` hook; the LinkedDataHub extension (ldh-blocks.xsl, layered by the ldh-editor.xsl entry via `xsl:import`) supplies `ldh:View`/`ldh:ResultSetChart` renderers plus the reference dereferencer (conneg on the `@about` URI — a DBpedia resource works directly, CORS + 303 to RDF/XML), an insert dialog and slash/toolbar contributions. Nesting follows the **XHTML Strict content model** (see content-model.xsl below): `blockquote` is a block *container* (`blockquote > p+` — bare text inside it is invalid and gets normalized; the toolbar quote toggle wraps/unwraps), `li`/`td`/`th`/`dd`/`figcaption` are `%Flow;` (mixed text AND nested blocks — Tab/Shift+Tab indent/outdent nested lists), `p`/`h1–h6`/`caption`/`dt` are inline-only. Tables are composite blocks (structure locked; `td`/`th`/`caption` editable) inserted via a rows×cols dialog with an optional header row and caption; row/column toolbar controls, Tab/Shift+Tab cell traversal and Enter (step down a column) all grow the grid at its bottom edge. Right-click a text selection to annotate it with RDFa; right-click an existing annotation to edit or remove it. "Extract RDF" shows the page's triples; "Source" shows the canonical XHTML+RDFa serialization (all editing ephemera stripped) in [Exclusive XML Canonicalization](https://www.w3.org/TR/xml-exc-c14n/) form (`<br></br>`, sorted attributes/namespace declarations, no indentation — the `rdf:XMLLiteral` value space).
 
 ## Architecture
 
-XSLT 3.0 running on **SaxonJS 3** with its interactive extensions (`ixsl:` namespace). `index.html` loads `lib/SaxonJS3.js` plus `lib/xml-c14n-sync.js` (the exclusive-c14n serializer LinkedDataHub also ships — the "Source" view calls it through `local:canonicalize-xml` in edit.xsl, a port of LDH's `ldh:canonicalize-xml`: `serialize()` → `parse-xml()` bridges XDM to browser DOM, which the lib walks) and executes `dist/index.xsl.sef.json` (initial template `main`); async work uses the **SaxonJS 3 promise API** (`ixsl:promise` + `ixsl:http-request` `=> ixsl:then`, `on-failure`; DOM-mutating callbacks are `ixsl:updating="yes"` functions) — **never the legacy `ixsl:schedule-action`**. The editor UI is fully generated by the stylesheet — the overlay is rendered once at startup (hidden) and only populated/shown/hidden afterwards, so the stylesheet is self-contained and embeddable on any host page (host pages must include both libs).
+XSLT 3.0 running on **SaxonJS 3** with its interactive extensions (`ixsl:` namespace). `index.html` loads `lib/SaxonJS3.js` plus `lib/xml-c14n-sync.js` (the exclusive-c14n serializer LinkedDataHub also ships — the "Source" view calls it through `rdfae:canonicalize-xml` in edit.xsl, a port of LDH's `ldh:canonicalize-xml`: `serialize()` → `parse-xml()` bridges XDM to browser DOM, which the lib walks) and executes `dist/index.xsl.sef.json` (initial template `main`); async work uses the **SaxonJS 3 promise API** (`ixsl:promise` + `ixsl:http-request` `=> ixsl:then`, `on-failure`; DOM-mutating callbacks are `ixsl:updating="yes"` functions) — **never the legacy `ixsl:schedule-action`**. The editor UI is fully generated by the stylesheet — the overlay is rendered once at startup (hidden) and only populated/shown/hidden afterwards, so the stylesheet is self-contained and embeddable on any host page (host pages must include both libs).
 
 Two build flavors: **core** (`src/index.xsl` → `dist/index.xsl.sef.json`, deployed to GitHub Pages — `deploy-pages.yml` excludes the LDH artifacts) and **LDH-extended** (`src/ldh-editor.xsl` → `dist/ldh-editor.xsl.sef.json`, used by `demo/index.html` and the browser fixtures — local only, its object blocks need the content-negotiating dev server).
 
 Modules under `src/`:
 
-- **index.xsl** — the core entry point: `main` template (fully synchronous — the host page preloads the vocabularies into the SaxonJS `documentPool` keyed by page-relative URI, see index.html), editor-state container init, `local:editor-state()`; the module include list.
+- **index.xsl** — the core entry point: `main` template (fully synchronous — the host page preloads the vocabularies into the SaxonJS `documentPool` keyed by page-relative URI, see index.html), editor-state container init, `rdfae:editor-state()`; the module include list.
 - **RDFa2RDFXML-v3.xsl** — RDFa 1.1 → RDF/XML extraction. **Pure XSLT, no `ixsl:`** — it runs headless via `xslt3` for the test suite. Strictly W3C-conformant (RDFa 1.1 processing rules, section 7.5, including chaining via typed resources and `rdfa:usesVocabulary`). Covers `@about`/`@typeof`/`@property`/`@content`/`@datatype`/`@resource`/`@href`/`@src`/`@prefix` (and `xmlns:*`)/`@vocab` with bare terms, `@lang`+`@xml:lang` inheritance, base-URI resolution (`about=""` = the document, `<base href>` honored), and exclusion of `head`/`script`/`style`/`[data-role='rendering']` subtrees. Out of scope (documented future work): `@rel`/`@rev`, `@inlist`, safe CURIEs, `@datetime`/`<time>`, `xml:base`.
 - **content-model.xsl** — the XHTML content model as data. **Pure XSLT, include-free** (no dependencies; `index.xsl` includes it once, before its consumers): a 1:1 transcription of the XHTML 1.0 Strict DTD (Second Edition, Appendix A.1 entities + element declarations) and the Appendix B prohibitions, extended with HTML5 `figure`/`figcaption`. `$cm:model` (element → allowed children + `#PCDATA` flag), `$cm:prohibitions`, predicates `cm:known`/`cm:block`/`cm:inline`/`cm:allows-child`/`cm:allows-text`/`cm:inline-only`/`cm:flow`/`cm:structural`/`cm:valid-nesting`. The **single source of truth** for nesting: editability init and keyboard machines (edit.xsl), boundary normalization (canonical-xhtml.xsl) and nesting lint (lint-xhtml.xsl) all consult it, so verdicts can't drift. `$cm:model` is built with `map:merge`+`map:entry` — the SaxonJS compiler fails an internal assertion on large nested map literals. The editor contract "region children are blocks" is deliberately NOT in this module.
-- **vocab.xsl** — generic ontology RDF/XML → term maps (`local:vocab-terms` → `{uri, label}`, consumed by the typeahead). Handles typed elements (`<owl:Class rdf:about>`) and `rdf:Description`+`rdf:type` shapes (including striped one-triple-per-description files like DCMI terms); labels as attributes or child elements; terms outside the ontology namespace filtered out.
-- **overlay.xsl** — the annotation form (single copy), form reading (`local:form-values` map), pre-filling (`local:populate-form`), show/hide with viewport clamping (`local:show-at`, shared with the edit dialogs). The property/type fields are typeaheads (typeahead.xsl); the datatype field stays a `<select>` (short XSD list) with a `urn:rdfa-editor:custom` sentinel + free-text `custom-datatype` input and the datatype↔lang mutual-exclusion handler.
-- **typeahead.xsl** — autocomplete lookups for the **property** and **type** fields (replacing the long dropdowns; LDH's typeahead interaction ported with local synchronous filtering — no SPARQL/debounce, since vocabularies are already pooled). A stable wrapper `span[@data-field]` holds one of two states, swapped via `result-document` literal result elements: typing (`input.typeahead-input` + `ul.typeahead-menu`) or committed (`button.typeahead-value` + hidden input carrying the IRI, LDH-style). Filtering re-renders per keystroke from `local:vocab-terms` (prefix-ranked, capped, bold-highlighted match); keyboard nav mirrors the slash menu (Arrow/Enter/Escape, first option pre-selected); options commit on `ixsl:onmousedown` (before the input's `focusout`, children `pointer-events:none` so the `<li>` is the target). `local:typeahead-value` reads the committed hidden IRI, else a free-typed absolute IRI (`local:is-absolute-iri`), else the untouched button→edit value parked on `@data-editing-iri` (cleared on the first keystroke — the stale-selection guard). Escape closes the menu else the overlay (the innermost template fully owns the input's keys).
-- **annotate.xsl** — the unified right-click dispatcher (edit vs create), `local:apply-annotation` (single write path for RDFa attributes), shared `local:wrap-range`/`local:unwrap-element` (used by annotations AND inline formatting), invalid-selection flash, the shared output modal (`local:show-output`; callers passing a filename get a Download button — the shown text becomes a client-side Blob object-URL download, so it works on static hosting like gh-pages; the lint modal passes none and hides it).
-- **edit.xsl** — the XHTML editor. **Recursive editability init** (`local:init-block`): an element is a *text host* (contenteditable) while its content model allows text and it holds no block children; mixed flow containers (`li`/`td`/`dd`/… with blocks) and structural containers (blockquote, lists, figure, table) lock their own markup and recurse into their parts (`figure` is always composite: image island + caption host); `img` never editable but given `tabindex="-1"` so a block image is a focusable **navigation island**; an **object block** (`local:island`, FIRST branch of the choose — a flow div with span children would otherwise become a text host / get its spans run-wrapped) is locked whole, given `tabindex="-1"` + the `rdfa-editor-island` marker class and rendered via the hook when it has no rendering div. **Run wrappers**: the stray inline runs of a mixed flow container (`<li>text<ul>…</ul></li>`) get an ephemeral `p.rdfa-editor-run` host (`local:wrap-stray-runs`) so they stay editable — unwrapped again at canonicalization (C11), so mixed content round-trips byte-identical; structural gestures promote a wrapper to a real paragraph. **Load-init normalization**: each region is probed for invalid nesting (`cm:valid-nesting`, stray text in structural containers, stray region-level inline) and rebuilt through `mode="cm-normalize"` only when invalid (the valid case is zero-churn; host-page node references into a rewritten region go stale, same as undo restore). First-child chrome injection 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` — an object-block island qualifies like any div, nested islands carry handles too, while nothing *inside* one ever does): 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/islands stay hard boundaries (B3; an empty host removed before an island *selects* the island — no host to land in); B4 merges an `li` into the *visually preceding line* (`local:merge-host-in` — the last host of the previous item, unless it sits inside a nested table/figure/island OR an island follows it at the container's tail (islands hold no hosts, the lookup would leapfrog them): composites are hard boundaries at any depth, the gesture stays inert), B4b outdents the first item of a nested list, B4c merges the first item of a container-nested list (cell, quote, dd) into the preceding line inside the container — dissolving the emptied list and collapsing the container back to a text host — B7 exits the first block of a blockquote upward (emptied quote removed); E4b anchors the list-exit paragraph *before* removal, so it lands where the list was (inside the cell/quote for nested lists); E6 anchors the caption-exit paragraph after the figure/table itself (which may be nested). **Ancestor walks clamp at the region root** (`[exists(local:block-of(.))]` on `local:item-of`, the Tab cell lookup and the quote-toggle's blockquote lookup) — a host-page li/td/blockquote wrapping an embedded region is never touched. A focused image island deletes its *figure* when it has one, else just the image — never the whole containing list/table. **Tab/Shift+Tab** indent/outdent list items (`local:list-indent`/`local:list-outdent`: indent moves the item into a trailing-or-fresh nested list *inside the previous item* per `ul → (li)+`; outdent moves it after the container item, demoting followers into a nested list inside it; `local:collapse-container` reverts an emptied container to a text host; extremes flash) — the innermost context wins over table-cell traversal (li-in-td indents, a table nested in an item traverses). The **quote toggle** (`format-quote`) wraps the current host block in a `blockquote` where the parent admits one / unwraps all children out (refused with a flash when the quote carries RDFa — triples would drop); the block-type select is **host-based** (`local:current-host`): a paragraph inside a quote converts alone, non-convertible hosts disable it. The **insert buttons** (+¶, lists) place the new block per the content model (`local:insert-block-at-caret`): after the caret's host when its parent admits the kind, *inside* a leaf flow host otherwise (a list inserted in a cell nests in the cell; in a list item it becomes a sublist), after the top-level block as a last resort. **Paste** is cm-driven: clipboard HTML runs `mode="canonical"` + `mode="cm-normalize"`, then blocks land *inside* a mixed flow host (`local:paste-into-flow-host` — head/tail runs wrapped, host re-inited as container), or as siblings of an inline-only host via split-and-thread (when `cm:allows-child` permits), or flatten to text (caption, dt). Drag-and-drop ported from LinkedDataHub's `client/block.xsl` (handle-gated `draggable`, midpoint before/after marks) 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); an object-block island moves as an atomic unit and is never a drop *receiver* — `local:deepest-block-at` can't resolve inside one (its interior is inline spans plus the ephemeral rendering subtree), and the cell "into" resolver skips cells inside ephemera/island interiors (a rendered chart or reference card paints real `td`s — external rendering, not drop zones): pointing anywhere over an island means before/after the island itself. Arrow-key block crossing walks `local:nav-targets` (editable hosts **plus** block images **plus** object-block islands, in document order; nothing inside an island or ephemeral subtree is a stop): a host gets a caret, an image/island is *selected* (`local:select-island` focuses it, clearing the caret) — so islands are never skipped; on a selected island, arrows step to the adjacent target, Backspace/Delete removes the unit whole (an image goes with its figure, an object block deletes itself; no confirm, undo-covered) and **undo/redo chords work too** (the island keydown template intercepts them — host/body templates don't fire with focus on an island). Table cell keys (Tab/Enter) and the table dialog live in **tables.xsl**.
-- **blocks.xsl** — the generic **object-block (island) machinery**, zero LDH knowledge: `$object-block-types` (absolute class IRIs, default EMPTY — re-declared at higher import precedence by an extension entry; a same-precedence duplicate is XTSE0630), THE island predicate `local:island($e)` (`div` whose `tokenize(@typeof)` hits the param, OR a *reference block* per `local:reference-block($e)`: an effectively-empty div — ephemera and whitespace aside — whose `@about` is an absolute URI naming a different document than the page (string tests only, no `resolve-uri`, so a malformed `@about` can't error out of a hot predicate; relative/fragment `@about` never islands — document parts stay blocks, `about-relative` stays a lint case) — every island decision in init/nav/boundaries/delete-machine/undo routes through it), the render hook `mode="local:render-island"` (context item = the island div; contract: inject exactly ONE `div[@data-role='rendering']` as last child via `local:replace-rendering` — async renderers only in the completion callback, loading state = ephemeral `rdfa-editor-loading` class, so "no rendering div" always means "render needed" and the undo-restore re-render pass keys on that; never touch the spans; never push undo; idempotent), the neutral default card, and the empty extension hook stubs `local:render-extra-dialogs`/`-insert-buttons`/`-slash-items`, `local:run-extra-slash-command` (called from edit.xsl's init/toolbar and input.xsl's slash menu). All modules share `xmlns:local="urn:rdfa-editor:functions"`, so import precedence overrides `local:*` declarations across stylesheets.
-- **ldh-blocks.xsl** + **ldh-editor.xsl** — the LinkedDataHub extension and its entry (`<xsl:import href="index.xsl"/>` + `<xsl:include href="ldh-blocks.xsl"/>` — core at lower precedence; the same layering shape LDH's client.xsl uses, MIGRATION.md §10/§12). The extension re-declares `$object-block-types` (`ldh:View`/`ldh:ResultSetChart`), provides per-type `mode="local:render-island"` renderers plus one matching `local:reference-block` (dereferences the island's own `@about`) — promise chains fetching the referenced document by **content negotiation on the clean trailing-slash URI** (`Accept: application/rdf+xml` for the description; as a demo stand-in for live SPARQL, `Accept: application/sparql-results+xml` on a query document returns canned results; serve.mjs / tests/browser/run.mjs negotiate; **no file extensions in any URL**; a reference block dereferences any absolute URI the same way — the demo embeds `http://dbpedia.org/resource/Ada_Lovelace` directly, DBpedia 303s to the RDF/XML and allows CORS; the description card caps at 10 properties) — plus the `#ldh-block-dialog` insert dialog (opts into teardown via the `edit-dialog` class; kinds: Resource — one absolute URI straight into `@about`, gated by `local:is-absolute-iri` — View and Result set chart with fragment ids), the ▦ toolbar button and the "Block…" slash item. In production LDH, client.xsl plays this module's role, bridging `local:render-island` into its block rendering (v6 mode `ldh:Block`; the v5 `ldh:RenderRow` bridge is worked through in MIGRATION.md §12).
-- **tables.xsl** — table blocks as a composite kind: the insert dialog (rows×cols + header-row + caption, modeled on the figure dialog), positional row/column operations (`local:op-insert-row`/`-column`, `-delete-row`/`-column`) gated behind `local:has-spans` (disabled on pasted `colspan`/`rowspan` grids — positional edits would corrupt a spanned table) and toolbar-synced via `local:sync-table-toolbar` riding `local:update-breadcrumb`, plus `local:table-tab`/`local:table-enter` cell traversal that appends a body row at the bottom edge. Cells are `%Flow;` containers: every caret landing resolves through `local:first-host-in`/`local:last-host-in`, so a cell holding blocks lands the caret in its first/last editable host; the Tab dispatcher (edit.xsl) passes the *cell* as the traversal host even when the caret sits in a nested block. Deleting the last body row/column is a no-op — the confirm-guarded delete-block button removes the whole table. **Undo hazard:** a chrome `span` serialized as a direct child of 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, and out of object-block islands — `setStartBefore`/`setEndAfter`, so islands join a selection whole and the machine never sees a boundary inside one; fully covered islands are removed whole by the existing rules, and `local:caret-at-point` likewise escapes island interiors so sweep anchors never land in them) — one gesture, one region-keyed undo entry; other regions stay byte-identical. A **printable character replaces** the selection (the delete machine places the caret, `local:insert-text-at-caret` lands the character — same undo entry); Enter/Tab/paste are suppressed; plain arrows stay native. **Canonical copy/cut** (`ixsl:oncopy`/`oncut` on hosts and body): a cross-host selection is copied in its storage form — `cloneContents` into a carrier div, `mode="canonical"` + `cm:normalize` (the paste pipeline in reverse), so the clipboard's HTML flavor has no chrome/`contenteditable`/marker classes but keeps RDFa attributes; cut adds the delete machine (one undo entry); within-host copy stays native.
-- **input.xsl** — Notion-style input affordances (ported from PR #10 onto the content-model era; dispatch additions in edit.xsl): one **priority-raised `ixsl:onbeforeinput` dispatcher** intercepts printable-char triggers and `next-match`es into undo's typing coalescer, so plain typing still snapshots. Triggers act on the **host** the caret sits in and are content-model-gated (`local:trigger-kind` — a shorthand whose result the model rejects stays literal). The **slash menu** (`/` in an empty host): filterable, keyboard-navigable, showing only the commands the context admits (conversions for `p|h1–h3|pre` hosts, Quote where the wrap is legal, lists where the model places one, Figure…/Table… always — routed to the existing dialogs via `insertHost`, whose saves place per the content model through `local:insert-block-at-caret`: an empty list item or cell grows the composite *inside* itself); state on `slashHost`, torn down by `local:hide-dialogs`. **Markdown shorthands** in a paragraph host: `#`/`##`/`###`+space, `-`/`*`+space, `1.`+space, ``` ``` ``` convert in place (`local:convert-block` with the pre-strip snapshot — one undo entry restores the literal marker); `> ` **wraps** via `local:wrap-in-blockquote` (`blockquote > p`; converting the `p` itself would be invalid). Caret popups position via `local:show-at-caret`/`-element` over overlay.xsl's `local:show-at-point` split.
-- **undo.xsl** — unified snapshot undo/redo over `#content` innerHTML: every mutating handler calls `local:push-undo` first and `local:after-mutation` last; plain typing coalesces into ~1s bursts via `ixsl:onbeforeinput`. Ctrl/Cmd+Z / Shift+Z / Ctrl+Y are intercepted (native undo is replaced). Stacks live in a hidden DOM stash (`#undo-storage`, `data-role="storage"`) — JS arrays don't survive the IXSL boundary and sequence-valued window properties keep only their first item. Caret restoration after undo is approximate (first host) by design. `local:restore-snapshot` re-fires `local:render-island` only for islands *without* a rendering div — snapshots carry rendering markup, so restores are render-stable; only mid-render captures re-hydrate.
-- **navigate.xsl** — FontoXML-inspired navigation: ToC drawer (recursive `for-each-group group-starting-with` outline, click-to-jump, section drag-reorder via `local:section-of`), breadcrumb bar (element path + `rdfa:in-scope-subject` at the caret), lint surfacing (markers + badge + issues modal), find & replace (single-text-node matches, `nodeValue`-rewrite replace-all — annotation-safe by construction).
+- **vocab.xsl** — generic ontology RDF/XML → term maps (`rdfae:vocab-terms` → `{uri, label}`, consumed by the typeahead). Handles typed elements (`<owl:Class rdf:about>`) and `rdf:Description`+`rdf:type` shapes (including striped one-triple-per-description files like DCMI terms); labels as attributes or child elements; terms outside the ontology namespace filtered out.
+- **overlay.xsl** — the annotation form (single copy), form reading (`rdfae:form-values` map), pre-filling (`rdfae:populate-form`), show/hide with viewport clamping (`rdfae: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 `https://w3id.org/atomgraph/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 `rdfae: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). `rdfae:typeahead-value` reads the committed hidden IRI, else a free-typed absolute IRI (`rdfae: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), `rdfae:apply-annotation` (single write path for RDFa attributes), shared `rdfae:wrap-range`/`rdfae:unwrap-element` (used by annotations AND inline formatting), invalid-selection flash, the shared output modal (`rdfae:show-output`; callers passing a filename get a Download button — the shown text becomes a client-side Blob object-URL download, so it works on static hosting like gh-pages; the lint modal passes none and hides it).
+- **edit.xsl** — the XHTML editor. **Recursive editability init** (`rdfae:init-block`): an element is a *text host* (contenteditable) while its content model allows text and it holds no block children; mixed flow containers (`li`/`td`/`dd`/… with blocks) and structural containers (blockquote, lists, figure, table) lock their own markup and recurse into their parts (`figure` is always composite: image island + caption host); `img` never editable but given `tabindex="-1"` so a block image is a focusable **navigation island**; an **object block** (`rdfae:island`, FIRST branch of the choose — a flow div with span children would otherwise become a text host / get its spans run-wrapped) is locked whole, given `tabindex="-1"` + the `rdfa-editor-island` marker class and rendered via the hook when it has no rendering div. **Run wrappers**: the stray inline runs of a mixed flow container (`<li>text<ul>…</ul></li>`) get an ephemeral `p.rdfa-editor-run` host (`rdfae: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** (`rdfae:draggable-block`: a real `%block` — never a run wrapper, `hr` or ephemera — whose parent is a region, a `cm:flow` container or a `blockquote` — an object-block island qualifies like any div, nested islands carry handles too, while nothing *inside* one ever does): 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); `rdfae:ensure-chrome` in `rdfae: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/islands stay hard boundaries (B3; an empty host removed before an island *selects* the island — no host to land in); B4 merges an `li` into the *visually preceding line* (`rdfae:merge-host-in` — the last host of the previous item, unless it sits inside a nested table/figure/island OR an island follows it at the container's tail (islands hold no hosts, the lookup would leapfrog them): composites are hard boundaries at any depth, the gesture stays inert), B4b outdents the first item of a nested list, B4c merges the first item of a container-nested list (cell, quote, dd) into the preceding line inside the container — dissolving the emptied list and collapsing the container back to a text host — B7 exits the first block of a blockquote upward (emptied quote removed); E4b anchors the list-exit paragraph *before* removal, so it lands where the list was (inside the cell/quote for nested lists); E6 anchors the caption-exit paragraph after the figure/table itself (which may be nested). **Ancestor walks clamp at the region root** (`[exists(rdfae:block-of(.))]` on `rdfae: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 (`rdfae:list-indent`/`rdfae: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; `rdfae: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** (`rdfae: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 (`rdfae: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 (`rdfae: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 (`rdfae:deepest-block-at` + `rdfae: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 `rdfae: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 (`rdfae:prune-husks` for emptied structural containers — the B7 doctrine — then `rdfae:collapse-container` for a flow container that lost its last block); transient drag state (`dragging`/`draggable`/empty `class` leftovers — `rdfae:tidy-class`) is stripped before the undo snapshot; drops stay region-scoped (blocks never move between regions); an object-block island moves as an atomic unit and is never a drop *receiver* — `rdfae:deepest-block-at` can't resolve inside one (its interior is inline spans plus the ephemeral rendering subtree), and the cell "into" resolver skips cells inside ephemera/island interiors (a rendered chart or reference card paints real `td`s — external rendering, not drop zones): pointing anywhere over an island means before/after the island itself. Arrow-key block crossing walks `rdfae:nav-targets` (editable hosts **plus** block images **plus** object-block islands, in document order; nothing inside an island or ephemeral subtree is a stop): a host gets a caret, an image/island is *selected* (`rdfae:select-island` focuses it, clearing the caret) — so islands are never skipped; on a selected island, arrows step to the adjacent target, Backspace/Delete removes the unit whole (an image goes with its figure, an object block deletes itself; no confirm, undo-covered) and **undo/redo chords work too** (the island keydown template intercepts them — host/body templates don't fire with focus on an island). Table cell keys (Tab/Enter) and the table dialog live in **tables.xsl**.
+- **blocks.xsl** — the generic **object-block (island) machinery**, zero LDH knowledge: `$object-block-types` (absolute class IRIs, default EMPTY — re-declared at higher import precedence by an extension entry; a same-precedence duplicate is XTSE0630), THE island predicate `rdfae:island($e)` (`div` whose `tokenize(@typeof)` hits the param, OR a *reference block* per `rdfae:reference-block($e)`: an effectively-empty div — ephemera and whitespace aside — whose `@about` is an absolute URI naming a different document than the page (string tests only, no `resolve-uri`, so a malformed `@about` can't error out of a hot predicate; relative/fragment `@about` never islands — document parts stay blocks, `about-relative` stays a lint case) — every island decision in init/nav/boundaries/delete-machine/undo routes through it), the render hook `mode="rdfae:render-island"` (context item = the island div; contract: inject exactly ONE `div[@data-role='rendering']` as last child via `rdfae:replace-rendering` — async renderers only in the completion callback, loading state = ephemeral `rdfa-editor-loading` class, so "no rendering div" always means "render needed" and the undo-restore re-render pass keys on that; never touch the spans; never push undo; idempotent), the neutral default card, and the empty extension hook stubs `rdfae:render-extra-dialogs`/`-insert-buttons`/`-slash-items`, `rdfae:run-extra-slash-command` (called from edit.xsl's init/toolbar and input.xsl's slash menu). All modules share `xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"`, so import precedence overrides `rdfae:*` declarations across stylesheets.
+- **ldh-blocks.xsl** + **ldh-editor.xsl** — the LinkedDataHub extension and its entry (`<xsl:import href="index.xsl"/>` + `<xsl:include href="ldh-blocks.xsl"/>` — core at lower precedence; the same layering shape LDH's client.xsl uses, MIGRATION.md §10/§12). The extension re-declares `$object-block-types` (`ldh:View`/`ldh:ResultSetChart`), provides per-type `mode="rdfae:render-island"` renderers plus one matching `rdfae:reference-block` (dereferences the island's own `@about`) — promise chains fetching the referenced document by **content negotiation on the clean trailing-slash URI** (`Accept: application/rdf+xml` for the description; as a demo stand-in for live SPARQL, `Accept: application/sparql-results+xml` on a query document returns canned results; serve.mjs / tests/browser/run.mjs negotiate; **no file extensions in any URL**; a reference block dereferences any absolute URI the same way — the demo embeds `http://dbpedia.org/resource/Ada_Lovelace` directly, DBpedia 303s to the RDF/XML and allows CORS; the description card caps at 10 properties) — plus the `#ldh-block-dialog` insert dialog (opts into teardown via the `edit-dialog` class; kinds: Resource — one absolute URI straight into `@about`, gated by `rdfae:is-absolute-iri` — View and Result set chart with fragment ids), the ▦ toolbar button and the "Block…" slash item. In production LDH, client.xsl plays this module's role, bridging `rdfae:render-island` into its block rendering (v6 mode `ldh:Block`; the v5 `ldh:RenderRow` bridge is worked through in MIGRATION.md §12).
+- **tables.xsl** — table blocks as a composite kind: the insert dialog (rows×cols + header-row + caption, modeled on the figure dialog), positional row/column operations (`rdfae:op-insert-row`/`-column`, `-delete-row`/`-column`) gated behind `rdfae:has-spans` (disabled on pasted `colspan`/`rowspan` grids — positional edits would corrupt a spanned table) and toolbar-synced via `rdfae:sync-table-toolbar` riding `rdfae:update-breadcrumb`, plus `rdfae:table-tab`/`rdfae:table-enter` cell traversal that appends a body row at the bottom edge. Cells are `%Flow;` containers: every caret landing resolves through `rdfae:first-host-in`/`rdfae: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 `rdfae:restore-snapshot` strips every handle and re-converges via `rdfae: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 (`rdfae: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 (`rdfae: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 (`rdfae:shift-arrow-extends` gates: cross-host selection, or focus at the host edge facing the arrow — probed from the *focus*, not the range end; `rdfae: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 `rdfae:at-*` probes, or empty, or the selection already spans hosts) selects all blocks of the region as a **document-level range** (`rdfae: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 `rdfae: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** (`rdfae:delete-cross-host-selection`) serves stage-2 selections and every synthetic gesture alike (`rdfae: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 (`rdfae:clear-host`; B3/B4 doctrine at partial coverage) while a *fully* covered composite is removed whole; non-composite edge remnants merge Docs-style via `rdfae:merge-into-previous` with the caret at the seam (never with `pre` — B6); emptied structural containers are pruned (`rdfae:prune-husks`), chrome is re-injected (idempotent), and an emptied region is reseeded with a fresh `p` host (`rdfae:seed-region`). The range is **clamped to a single region** (the start's, else the first swept; `rdfae:clamped-range` also moves boundaries out of chrome, and out of object-block islands — `setStartBefore`/`setEndAfter`, so islands join a selection whole and the machine never sees a boundary inside one; fully covered islands are removed whole by the existing rules, and `rdfae:caret-at-point` likewise escapes island interiors so sweep anchors never land in them) — one gesture, one region-keyed undo entry; other regions stay byte-identical. A **printable character replaces** the selection (the delete machine places the caret, `rdfae: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 (`rdfae: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 `rdfae:insert-block-at-caret`: an empty list item or cell grows the composite *inside* itself); state on `slashHost`, torn down by `rdfae:hide-dialogs`. **Markdown shorthands** in a paragraph host: `#`/`##`/`###`+space, `-`/`*`+space, `1.`+space, ``` ``` ``` convert in place (`rdfae:convert-block` with the pre-strip snapshot — one undo entry restores the literal marker); `> ` **wraps** via `rdfae:wrap-in-blockquote` (`blockquote > p`; converting the `p` itself would be invalid). Caret popups position via `rdfae:show-at-caret`/`-element` over overlay.xsl's `rdfae:show-at-point` split.
+- **undo.xsl** — unified snapshot undo/redo over `#content` innerHTML: every mutating handler calls `rdfae:push-undo` first and `rdfae: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. `rdfae:restore-snapshot` re-fires `rdfae:render-island` only for islands *without* a rendering div — snapshots carry rendering markup, so restores are render-stable; only mid-render captures re-hydrate.
+- **navigate.xsl** — FontoXML-inspired navigation: ToC drawer (recursive `for-each-group group-starting-with` outline, click-to-jump, section drag-reorder via `rdfae:section-of`), breadcrumb bar (element path + `rdfax:in-scope-subject` at the caret), lint surfacing (markers + badge + issues modal), find & replace (single-text-node matches, `nodeValue`-rewrite replace-all — annotation-safe by construction).
 - **lint-rdfa.xsl** — RDFa lint logic. **Pure XSLT**, tested headless via `tests/lint-driver.xsl` (`xsl:import` resolves the output-method conflict). Reuses the extractor's resolution functions so lint verdicts can't drift from extraction semantics. Checks: term-unresolvable, empty-href, content-resource-conflict, empty-literal, about-relative.
 - **lint-xhtml.xsl** — nesting lint (`lint:nesting-issues`, concatenated with `lint:element-issues` at every surfacing site). **Pure XSLT**, consults content-model.xsl only, so verdicts can't drift from normalization. Checks: invalid-nesting (known child not allowed by known parent), stray-text (non-ws text in an element-only container), prohibited-nesting (Appendix B), unknown-element (outside the model — preserved, unvalidated).
 - **canonical-xhtml.xsl** — canonical serialization form. **Pure XSLT**, tested headless via `tests/canonical-driver.xsl` (it consults `cm:*`, so it is no longer standalone-compilable). **Two passes in fixed order**: `mode="canonical"` (drops `*[@data-role]` subtrees — nesting analysis must never see chrome; strips `contenteditable`/`draggable`/`class`/`id`/`style`/`tabindex`/`aria-*`/`data-*`; normalizes browser mess: `b`→`strong`, `i`→`em`, `font`/`u`/meaningless `span` unwrap, empty non-RDFa inline pruning, trailing-`br` drop, `br`-in-`pre`→newline; content-aware `div`: inline-content attributeless div → `p` (C7a), block-holding attributeless div unwraps (C7b); run-wrapper `p.rdfa-editor-run` unwraps (C11) unless RDFa-annotated; non-RDFa HTML5 sectioning wrappers unwrap (C12)), then `mode="cm-normalize"` (N-rules: N1 matches every inline-only element and decides on the PROCESSED children, so inner splits reach the fixed point in one bottom-up pass — an RDFa-bearing parent keeps its blocks as recursively-demoted inline via `mode="cm-demote"` (a list becomes nested spans, never a bare `li` in a `span`), a plain parent splits around them with shells keeping ALL attributes (an `<a href>` split by a block keeps its target on both halves — safe, the branch is non-RDFa by construction); N2 blockquote stray runs → `p`; N3/N4/N5 `ul`/`dl`/`tr` strays wrapped in `li`/`dd`/`td`; N5b section strays → rows; N6 invalid `table` children hoisted before it; N7/N8 Appendix B fixes: `pre` exclusions unwrap/alt-text, `a`-in-`a` → `span` with attributes kept). `cm:wrap-inline-runs` pulls only text and known-inline elements into its inline-only wrapper — blocks, ephemera, unknowns AND known non-inline strays (an `li` outside any list) pass through bare for lint to report, never wrapped into fresh invalid nesting. The entry template finally coerces region children to blocks (the editor contract, not the DTD's). Shared primitives `cm:normalize`, `cm:wrap-inline-runs`, `cm:coerce-children` are reused by edit.xsl's load-init and paste. RDFa attributes and `pre` whitespace are never touched.
@@ -67,11 +67,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 (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).
+- **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 — `rdfae: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.
+- **Undo contract**: every mutating handler pushes a snapshot first (`rdfae:push-undo`, optionally with a pre-captured `$snapshot` when the operation can fail) and calls `rdfae:after-mutation` last — never push from shared primitives. Undo/redo restore invalidates all node-valued window properties (cleared in `rdfae:restore-snapshot`) and closes overlay/dialogs. The caret rides along on stash entries as (block, text-node, offset) data attributes and is restored on undo/redo.
 - **Content markers**: anything written into `#content` for UI purposes must be `@class` (or `aria-*`) only — both are canonicalization-stripped. `@title` is NOT stripped and is forbidden as a marker.
-- **Object-block contract** (= the v6 document format, see the `XHTML-RDFa-as-LDH-v6-Document-Format` wiki): the stored form is the block element ONLY — `div[@about][@typeof]` (`@about` a fragment URI: the block is a document part) with `span[@property]` definition children (objects via `@resource`, **literals as span text content**, hidden by `rdfa-editor.css`); **no document→block containment edge** — `ldh:content` is v6's document→body XMLLiteral property, never a per-block edge, and block order is document order (no `rdf:_N`). Extraction yields the complete block definition. Everything else (`tabindex`, marker classes, the rendering div) is editing ephemera. Island detection keys on `@typeof` only, so `local:block-text()` of a chart island is non-empty (its var-name spans) — the toolbar delete-block button confirms, the keyboard island delete stays confirm-free. **URLs are clean Linked Data URIs**: document URIs end with a trailing slash, representations come from content negotiation — file extensions never appear in storage, fetch code or fixtures. Async rendering runs outside push-undo (a rendering-only undo step is possible and harmless — canonical content is identical).
+- **Object-block contract** (= the v6 document format, see the `XHTML-RDFa-as-LDH-v6-Document-Format` wiki): the stored form is the block element ONLY — `div[@about][@typeof]` (`@about` a fragment URI: the block is a document part) with `span[@property]` definition children (objects via `@resource`, **literals as span text content**, hidden by `rdfa-editor.css`); **no document→block containment edge** — `ldh:content` is v6's document→body XMLLiteral property, never a per-block edge, and block order is document order (no `rdf:_N`). Extraction yields the complete block definition. Everything else (`tabindex`, marker classes, the rendering div) is editing ephemera. Island detection keys on `@typeof` only, so `rdfae:block-text()` of a chart island is non-empty (its var-name spans) — the toolbar delete-block button confirms, the keyboard island delete stays confirm-free. **URLs are clean Linked Data URIs**: document URIs end with a trailing slash, representations come from content negotiation — file extensions never appear in storage, fetch code or fixtures. Async rendering runs outside push-undo (a rendering-only undo step is possible and harmless — canonical content is identical).
 - **GitHub Pages deploys the CORE editor only** (`deploy-pages.yml` removes `dist/ldh-editor.xsl.sef.json` and never copies `demo/`) — Pages is a static host with no conneg, so the LDH flavor is local-only by construction.
 - **SaxonJS gotchas**: computed numeric predicates (`[xs:integer(...)]`) are evaluated as booleans in some contexts — bind to a variable and use the bare `[$index]` form. JS arrays returned by `ixsl:call` marshal to XDM sequences (empty array = empty sequence). Large nested map literals fail the compiler with an internal assertion — build them with `map:merge` over `map:entry` (see `$cm:model`).
 - Browser tests live in `tests/browser/` (`npm run test:browser` self-serves the repo): `editor.mjs`, `features.mjs`, `fixes.mjs`, `hardening.mjs`, `multiinstance.mjs`, `tables.mjs`, `datatype.mjs`, `inspector.mjs`, `nesting.mjs` (content-model foundation), `authoring.mjs` (nesting gestures), `select.mjs` (two-stage Ctrl+A, cross-host sweep delete, type-to-replace, canonical copy/cut, composite/clamp semantics, plus the real gestures: drag takeover with real mouse events, Shift+Click, Shift+Up/Down, gutter/backward/cross-region drags, drag-handle non-hijack), `notion.mjs` (slash menu, markdown input rules, context filtering), `typeahead.mjs` (property/type autocomplete: filter, keyboard/mouse select, free-IRI entry, non-IRI rejection, edit-prefill button, stale-selection invalidation — via `typeahead-helper.mjs`), `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), `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`, which loads the core SEF) and `blocks.mjs` (object blocks: init/locking, storage-form round-trip — incl. the reference block's empty-div form — island navigation/deletion/boundaries, dialog insertion of a defined View top-level and a nested reference block, stage-2/sweep atomicity, canonical copy, undo — against `tests/fixture-blocks.html`, which hydrates three islands over conneg before baselining: a chart, a reference block whose absolute `@about` the fixture script stamps at load, and a nested View). All other suites run against `tests/fixture-nesting.html`, which loads the **ldh-editor SEF** — proving the extension layers without disturbing core behavior (notion.mjs counts the extension's 11th slash item). Scenario tests assert *semantics* (where things land); the invariant suite catches *validity/editability/undo* regressions in combinations nobody enumerated. CI runs both headless loops and the browser suites (`.github/workflows/ci.yml`).
diff --git a/dialogs.css b/dialogs.css
new file mode 100644
index 0000000..9be8ecc
--- /dev/null
+++ b/dialogs.css
@@ -0,0 +1,43 @@
+/* RDFa Editor toolbar dialog styles (insert link, table, figure).
+   Host UIs that provide their own form styling (e.g. Bootstrap)
+   should omit this file and style .edit-dialog themselves. */
+
+/* Link / figure dialogs */
+.edit-dialog {
+    background: white;
+    border: 2px solid #2196f3;
+    border-radius: 8px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+    padding: 16px;
+    min-width: 320px;
+    z-index: 10000;
+}
+
+.edit-dialog label {
+    display: block;
+    font-size: 13px;
+    font-weight: 500;
+    color: #424242;
+    margin: 8px 0 4px 0;
+}
+
+.edit-dialog input[type="text"] {
+    width: 100%;
+    padding: 8px 10px;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+    font-size: 14px;
+    box-sizing: border-box;
+}
+
+.edit-dialog .rdfa-editor-ui .action-buttons {
+    margin-top: 14px;
+}
+
+.edit-dialog .rdfa-editor-ui .checkbox-label {
+    display: inline-flex;
+    gap: 6px;
+    align-items: center;
+    font-weight: 400;
+    margin-top: 8px;
+}
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index b834827..a380ce8 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -19,7 +19,7 @@ The prototype (through commit `b8466cf`) is functionally rich: structured-block
 - Cross-text-node find matches (currently single-text-node only).
 
 ### A3. Robustness / quality
-- **Multiple editable regions per page**: everything assumes a single `id('content')` (`local:content()`, block-of, undo snapshots, lint, ToC). LDH pages have MANY XHTML blocks. Refactor to instance-scoped editing: editable roots resolved by class/typeof convention or param; undo stack per root (or keyed snapshots); ToC/breadcrumb scoped to the active root.
+- **Multiple editable regions per page**: everything assumes a single `id('content')` (`rdfae:content()`, block-of, undo snapshots, lint, ToC). LDH pages have MANY XHTML blocks. Refactor to instance-scoped editing: editable roots resolved by class/typeof convention or param; undo stack per root (or keyed snapshots); ToC/breadcrumb scoped to the active root.
 - Keyboard/a11y: Escape closes dialogs/overlay; focus trap in dialogs; ARIA roles/labels on toolbar, drawer, dialogs, breadcrumb; keyboard block move (Alt+Arrow) as DnD alternative; `prefers-reduced-motion`.
 - i18n: UI strings hardcoded English — externalize following LDH's translations.rdf pattern.
 - Browser matrix: only Chromium is CI-verified; Firefox + Safari manual/automated passes (Playwright Firefox/WebKit installable).
@@ -33,7 +33,7 @@ The prototype (through commit `b8466cf`) is functionally rich: structured-block
 ### A5. Engineering hygiene
 - CI: GitHub Actions running `tests/run-tests.sh` + the Playwright suites (currently scratchpad-only — move smoke scripts into `tests/browser/` in-repo).
 - Packaging: CSS lives in the demo `index.html` — extract `rdfa-editor.css`; demo page vs library separation; README/integration docs; versioning.
-- Namespace: `local:`/`urn:rdfa-editor:*` fine internally; consider a stable public namespace for a distributable component.
+- Namespace: done — `rdfae:` = `https://w3id.org/atomgraph/rdfa-editor#` (with `content-model#` and `lint#` sub-namespaces); register the `rdfa-editor` redirect at perma-id/w3id.org.
 
 ## B. LinkedDataHub embedding contract (WYMEditor replacement) — ships as `docs/ldh/MIGRATION.md` in this repo
 
@@ -54,7 +54,7 @@ Mapped integration surface (all in `LinkedDataHub/src/main/webapp/static/com/ato
 
 - **M1 — Hardening (THIS ROUND, implemented)**: sanitization + HTML paste + a11y/keys + undo caret restoration + in-repo tests/CI + CSS extraction + README; migration plan document in `ldh/`.
 - **M2 — Multi-instance component** (DONE): `.rdfa-editor-content` regions, region-keyed undo, scoped ToC/source, `rdfaEditor*` state prefix, `.rdfa-editor-ui` CSS scoping; LDH integration compile-proven (docs/ldh/MIGRATION.md §10).
-- **Tables** (DONE): composite table blocks — rows×cols insert dialog (optional header row + caption), positional row/column operations gated on `local:has-spans`, Tab/Shift+Tab + Enter cell traversal that grows the grid at its bottom edge (`src/tables.xsl`).
+- **Tables** (DONE): composite table blocks — rows×cols insert dialog (optional header row + caption), positional row/column operations gated on `rdfae:has-spans`, Tab/Shift+Tab + Enter cell traversal that grows the grid at its bottom edge (`src/tables.xsl`).
 - **M3 — LDH swap**: the contract above (LDH-side patches + build wiring + e2e in an LDH dev instance).
 - **M4 — Vocabulary UX**: typeahead over ontology terms from `/ns`, schema.org vocab, domain/range-aware ranking.
 - **M5 — Editing completeness**: nested lists, h4–h6, code/sub/sup, image upload via LDH, cross-node find, i18n strings, Firefox/Safari passes, touch fallback.
@@ -78,20 +78,20 @@ Mapped integration surface (all in `LinkedDataHub/src/main/webapp/static/com/ato
 - Wrap stray top-level inline runs: `for-each-group group-adjacent="boolean(self::p|self::h1|…block…)"` → non-block groups wrapped in `<p>`.
 - Re-materialize XDM → live DOM: `serialize()` the fragment → `$stage := createElement('div')` + `innerHTML` (safe post-sanitization).
 - Insert:
-  - **Inline-only** fragment: `range.deleteContents()`; move `$stage` childNodes into a `createDocumentFragment` (counted `firstChild` loop, order preserved); capture `$last` ref before the move; `range.insertNode($frag)`; caret after `$last` via `local:place-caret(parent, count(preceding-sibling)+1)`.
-  - **Blocks into p/h/blockquote host**: push-undo; `local:split-block` at caret; insert pasted blocks after the first half (`xsl:iterate` anchor pattern from section drop); `local:init-block` each (editable + chrome); `local:ensure-placeholder` on halves; caret at end of last inserted block.
+  - **Inline-only** fragment: `range.deleteContents()`; move `$stage` childNodes into a `createDocumentFragment` (counted `firstChild` loop, order preserved); capture `$last` ref before the move; `range.insertNode($frag)`; caret after `$last` via `rdfae:place-caret(parent, count(preceding-sibling)+1)`.
+  - **Blocks into p/h/blockquote host**: push-undo; `rdfae:split-block` at caret; insert pasted blocks after the first half (`xsl:iterate` anchor pattern from section drop); `rdfae:init-block` each (editable + chrome); `rdfae:ensure-placeholder` on halves; caret at end of last inserted block.
   - **Into li/figcaption**: flatten to `string($stage)` through the plain-text path (documented).
 - Single push-undo before, after-mutation after; one Ctrl+Z reverts the paste.
 
 ### D3. A11y + keyboard
-- **Escape** closes: keydown templates on `#overlay` and the three dialogs (input events bubble to the containers) → preventDefault + `local:hide-overlay`/`local:hide-dialogs`.
+- **Escape** closes: keydown templates on `#overlay` and the three dialogs (input events bubble to the containers) → preventDefault + `rdfae:hide-overlay`/`rdfae:hide-dialogs`.
 - **Alt+ArrowUp/Down moves the current block** (keyboard DnD alternative): new dispatcher branch BEFORE the plain-arrow branch (plain arrows must also gain a `not(altKey)` guard); `before(prev)`/`after(next)` sibling move; push-undo + after-mutation; caret survives (node refs move with the block); no sibling → no-op.
 - **ARIA** in render templates: `role="dialog" aria-modal="true" aria-label` on overlay + dialogs; `aria-label` mirroring `@title` on toolbar buttons + `role="toolbar"` on `#edit-toolbar`; `role="navigation" aria-label` on `#toc-drawer` and `#breadcrumb`; lint badge becomes a real `<button class="lint-badge">`.
 - **Focus return**: hide-overlay/hide-dialogs focus the `activeBlock` host when present. Full focus trap out of scope (documented).
 
 ### D4. Undo caret restoration (`src/undo.xsl`)
-- `local:push-undo` (and both apply-undo/redo current-state pushes) capture the caret when the selection anchor is a TEXT node inside content, as data attrs on the stash entry (stash lives outside #content): `data-block` (index among content children), `data-node` (index among the block's chrome-free descendant text nodes), `data-offset`.
-- `local:restore-snapshot` resolves `content/*[$bi]` → chrome-free `text()[$ni]` → `collapse(min(offset, length))`; bare-`[$index]` predicates; fallback = current first-host behavior. Caret stored with a snapshot = caret when that state existed → symmetric for undo and redo.
+- `rdfae:push-undo` (and both apply-undo/redo current-state pushes) capture the caret when the selection anchor is a TEXT node inside content, as data attrs on the stash entry (stash lives outside #content): `data-block` (index among content children), `data-node` (index among the block's chrome-free descendant text nodes), `data-offset`.
+- `rdfae:restore-snapshot` resolves `content/*[$bi]` → chrome-free `text()[$ni]` → `collapse(min(offset, length))`; bare-`[$index]` predicates; fallback = current first-host behavior. Caret stored with a snapshot = caret when that state existed → symmetric for undo and redo.
 
 ### D5. Tests in-repo, CI, packaging
 - `tests/browser/{editor,features,fixes}.mjs` (ported suites; `PORT`/`BASE_URL` env); `package.json` (private; devDep `playwright`; scripts `test` → run-tests.sh, `test:browser`).
diff --git a/docs/ldh/MIGRATION.md b/docs/ldh/MIGRATION.md
index a5da131..88c5062 100644
--- a/docs/ldh/MIGRATION.md
+++ b/docs/ldh/MIGRATION.md
@@ -43,7 +43,7 @@ Today: `ldh:RenderRowForm` on `textarea.wymeditor` calls the jQuery plugin
 
 Replacement: an `ldh:RenderRowForm` template on `div.rdfa-editor-content` running the
 editor's per-instance init (per-block-kind `contenteditable`, chrome injection) — the
-M2 equivalent of `local:init-editing` scoped to this container. **No JS assets**: the
+M2 equivalent of `rdfae:init-editing` scoped to this container. **No JS assets**: the
 editor is compiled into the client SEF; only `rdfa-editor.css` is needed.
 
 ### 3. Submit sync — `ldh:FormPreSubmit` (form.xsl:178-198)
@@ -134,7 +134,7 @@ single SEF via `xslt3-he -nogo -ns:##html5 -relocate:on` — no errors, no confl
 Audit results:
 - Extractor entry is a **named template only** (`extract-rdfa`; the unnamed-mode
   `match="/"` was removed; headless tests invoke with `-it:extract-rdfa`). All other
-  editor matching lives in named modes (`rdfa:extract`, `canonical`) or `ixsl:*` event
+  editor matching lives in named modes (`rdfax:extract`, `canonical`) or `ixsl:*` event
   modes.
 - Event templates: LDH has no `contenteditable` usage and no `body` keydown template
   (only `body` onmousemove in navigation.xsl — different mode). No pattern overlap.
@@ -186,7 +186,7 @@ Placement is carried by the XHTML structure, the reference by the name itself; t
 RDFa extraction of an empty `div[@about]` is zero triples, so no scaffolding enters
 the content graph. The fragment rule disambiguates for free: fragment `@about` =
 document part (a defined block or annotated content), absolute non-document `@about`
-on an effectively-empty div = dereference and render (`local:reference-block` in
+on an effectively-empty div = dereference and render (`rdfae:reference-block` in
 src/blocks.xsl). What the wrapper used to pay for — per-embedding metadata such as
 `ac:mode` — has no subject in this idiom; if per-embed rendering modes return, they
 need a typed block again.
@@ -206,18 +206,18 @@ example below works the same way) with the ephemeral rendering div as the contai
 <!-- client.xsl (imports the editor modules, higher import precedence) -->
 <xsl:param name="object-block-types" as="xs:string*"
     select="('&ldh;View', '&ldh;ResultSetChart', '&ldh;GraphChart')"/>
-<!-- reference blocks (embed-by-URI) need no param entry: local:reference-block
+<!-- reference blocks (embed-by-URI) need no param entry: rdfae:reference-block
      recognizes them structurally; client.xsl renders them by dereferencing
      @about into its resource-rendering machinery -->
 
 
 <xsl:template match="div[tokenize(@typeof) = ('&ldh;ResultSetChart', '&ldh;GraphChart')]"
-        mode="local:render-island">
+        mode="rdfae:render-island">
     <xsl:variable name="island" as="element()" select="."/>
     <!-- the container ldh:RenderRow renders into: the ephemeral rendering div
          (canonicalization-stripped, extractor-skipped). Seed it with the LDH
          progress-bar markup; the thunk chain replaces it with the chart -->
-    <xsl:call-template name="local:replace-rendering">
+    <xsl:call-template name="rdfae:replace-rendering">
         <xsl:with-param name="island" select="$island"/>
         <xsl:with-param name="content">
             <div class="progress progress-striped active">
@@ -246,7 +246,7 @@ The existing async pipelines (`ldh:chart-self-thunk` → `ldh:chart-query-thunk`
 container-plus-context-map based, and literal definition values are span text
 content per the v6 format, exactly what their selectors read. One caveat: chart
 canvases don't survive an `innerHTML` undo restore; the editor re-fires
-`local:render-island` only for islands *without* a rendering div, so a
+`rdfae:render-island` only for islands *without* a rendering div, so a
 canvas-bearing bridge should also re-draw from the `LinkedDataHub.contents` cache
 when its canvas is dead (LDH already does this on mode switches).
 
diff --git a/index.html b/index.html
index 54e1bfc..6dac44f 100644
--- a/index.html
+++ b/index.html
@@ -29,6 +29,9 @@
 				}
 		 </script>
         <link rel="stylesheet" href="rdfa-editor.css" type="text/css"/>
+        <link rel="stylesheet" href="overlay.css" type="text/css"/>
+        <link rel="stylesheet" href="toolbar.css" type="text/css"/>
+        <link rel="stylesheet" href="dialogs.css" type="text/css"/>
         <style type="text/css">
             html, body { margin: 0; }
 			body {
diff --git a/overlay.css b/overlay.css
new file mode 100644
index 0000000..a1a0a1f
--- /dev/null
+++ b/overlay.css
@@ -0,0 +1,290 @@
+/* RDFa Editor annotation overlay styles.
+   Host UIs that provide their own form styling (e.g. Bootstrap)
+   should omit this file and style #rdfa-editor-overlay themselves. */
+
+/* Modern Overlay Styling */
+            #rdfa-editor-overlay {
+                background: linear-gradient(to bottom, #f8f9fa, #ffffff);
+                border: 2px solid #2196f3;
+                border-radius: 8px;
+                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+                font-family: "Roboto", sans-serif;
+                min-width: 450px;
+                max-width: 500px;
+                z-index: 10000;
+            }
+
+.rdfa-editor-ui .overlay-header {
+                background: linear-gradient(135deg, #2196f3, #1976d2);
+                color: white;
+                padding: 16px 20px;
+                border-radius: 6px 6px 0 0;
+                box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+            }
+
+.rdfa-editor-ui .overlay-header h3 {
+                margin: 0 0 8px 0;
+                font-size: 18px;
+                font-weight: 500;
+            }
+
+#rdfa-editor-overlay form {
+                padding: 20px;
+            }
+
+/* Statement (S / P / O) framing */
+            .rdfa-editor-ui .statement {
+                display: grid;
+                grid-template-columns: 26px 1fr;
+                gap: 10px 12px;
+                align-items: center;
+                background: #e3f2fd;
+                border-radius: 6px;
+                padding: 14px 16px;
+                margin-bottom: 16px;
+            }
+
+.rdfa-editor-ui .stmt-role {
+                font-family: 'Courier New', monospace;
+                font-weight: bold;
+                font-size: 12px;
+                color: white;
+                background: #2196f3;
+                border-radius: 50%;
+                width: 24px;
+                height: 24px;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+            }
+
+#stmt-subject {
+                font-family: 'Courier New', monospace;
+                font-size: 12px;
+                color: #1565c0;
+                word-break: break-all;
+            }
+
+/* Advanced fields disclosure */
+            #rdfa-editor-overlay details {
+                border: 1px solid #e0e0e0;
+                border-radius: 6px;
+                padding: 8px 16px;
+                margin-bottom: 16px;
+                background: white;
+            }
+
+#rdfa-editor-overlay summary {
+                cursor: pointer;
+                font-size: 13px;
+                font-weight: 500;
+                color: #757575;
+                padding: 4px 0;
+            }
+
+#rdfa-editor-overlay details fieldset {
+                margin-top: 12px;
+            }
+
+/* Fieldsets */
+            #rdfa-editor-overlay fieldset {
+                border: 1px solid #e0e0e0;
+                border-radius: 6px;
+                padding: 12px 16px;
+                margin-bottom: 16px;
+                background: white;
+            }
+
+#rdfa-editor-overlay label {
+                display: block;
+                font-weight: 500;
+                color: #424242;
+                margin-bottom: 8px;
+                font-size: 14px;
+            }
+
+#rdfa-editor-overlay input[type="text"],
+            #rdfa-editor-overlay select {
+                width: 100%;
+                padding: 10px 12px;
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                font-size: 14px;
+                font-family: "Roboto", sans-serif;
+                transition: border-color 0.2s;
+                box-sizing: border-box;
+            }
+
+#rdfa-editor-overlay input[type="text"]:focus,
+            #rdfa-editor-overlay select:focus {
+                outline: none;
+                border-color: #2196f3;
+                box-shadow: 0 0 0 3px rgba(33, 150, 243, 0.1);
+            }
+
+#rdfa-editor-overlay input[type="text"]:disabled {
+                background-color: #f5f5f5;
+                color: #999;
+            }
+
+.rdfa-editor-ui .helper-text {
+                display: block;
+                font-size: 12px;
+                color: #757575;
+                margin-top: 6px;
+                font-style: italic;
+            }
+
+/* Action Buttons */
+            .rdfa-editor-ui .action-buttons {
+                display: flex;
+                gap: 12px;
+                margin-top: 20px;
+                justify-content: flex-end;
+            }
+
+.rdfa-editor-ui .btn-primary,
+            .rdfa-editor-ui .btn-secondary,
+            .rdfa-editor-ui .btn-danger {
+                padding: 10px 24px;
+                border: none;
+                border-radius: 4px;
+                font-size: 14px;
+                font-weight: 500;
+                cursor: pointer;
+                transition: all 0.2s;
+                font-family: "Roboto", sans-serif;
+            }
+
+.rdfa-editor-ui .btn-primary {
+                background: #4caf50;
+                color: white;
+            }
+
+.rdfa-editor-ui .btn-primary:hover {
+                background: #45a049;
+                box-shadow: 0 2px 8px rgba(76, 175, 80, 0.3);
+            }
+
+.rdfa-editor-ui .btn-secondary {
+                background: #f5f5f5;
+                color: #424242;
+                border: 1px solid #e0e0e0;
+            }
+
+.rdfa-editor-ui .btn-secondary:hover {
+                background: #e0e0e0;
+            }
+
+.rdfa-editor-ui .btn-danger {
+                background: #f44336;
+                color: white;
+                margin-right: auto;
+            }
+
+.rdfa-editor-ui .btn-danger:hover {
+                background: #d32f2f;
+                box-shadow: 0 2px 8px rgba(244, 67, 54, 0.3);
+            }
+
+#rdfa-editor-overlay input[name="custom-datatype"] {
+                margin-top: 8px;
+            }
+
+/* Typeahead lookups (property / type) */
+            .rdfa-editor-ui .typeahead-field {
+                position: relative;
+                display: block;
+            }
+
+.rdfa-editor-ui .typeahead-menu {
+                position: absolute;
+                top: 100%;
+                left: 0;
+                right: 0;
+                z-index: 10002;
+                margin: 2px 0 0 0;
+                padding: 4px;
+                list-style: none;
+                background: white;
+                border: 1px solid #e0e0e0;
+                border-radius: 6px;
+                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+                max-height: 260px;
+                overflow-y: auto;
+            }
+
+.rdfa-editor-ui .typeahead-option {
+                display: flex;
+                align-items: baseline;
+                justify-content: space-between;
+                gap: 10px;
+                padding: 7px 10px;
+                border-radius: 4px;
+                font-size: 14px;
+                color: #212121;
+                cursor: pointer;
+            }
+
+/* children never intercept the mousedown, so the <li> is always the event target */
+            .rdfa-editor-ui .typeahead-option * {
+                pointer-events: none;
+            }
+
+.rdfa-editor-ui .typeahead-option:hover,
+            .rdfa-editor-ui .typeahead-option[aria-selected="true"] {
+                background: #e3f2fd;
+                color: #0d47a1;
+            }
+
+.rdfa-editor-ui .typeahead-option-label strong {
+                font-weight: 700;
+            }
+
+.rdfa-editor-ui .typeahead-option-uri {
+                flex: 0 1 auto;
+                min-width: 0;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                white-space: nowrap;
+                font-size: 11px;
+                color: #9e9e9e;
+            }
+
+.rdfa-editor-ui .typeahead-value {
+                display: flex;
+                align-items: center;
+                gap: 8px;
+                width: 100%;
+                padding: 10px 12px;
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                background: white;
+                font-size: 14px;
+                font-family: "Roboto", sans-serif;
+                text-align: left;
+                cursor: pointer;
+            }
+
+.rdfa-editor-ui .typeahead-value:hover {
+                border-color: #2196f3;
+            }
+
+.rdfa-editor-ui .typeahead-label {
+                flex: 1 1 auto;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                white-space: nowrap;
+            }
+
+.rdfa-editor-ui .typeahead-clear {
+                flex: 0 0 auto;
+                color: #9e9e9e;
+                font-size: 16px;
+                line-height: 1;
+                padding: 0 2px;
+            }
+
+.rdfa-editor-ui .typeahead-clear:hover {
+                color: #f44336;
+            }
diff --git a/rdfa-editor.css b/rdfa-editor.css
index 60aa7c4..bbae229 100644
--- a/rdfa-editor.css
+++ b/rdfa-editor.css
@@ -153,11 +153,6 @@
                 color: #757575;
             }
 
-#edit-toolbar button:disabled {
-                opacity: 0.4;
-                cursor: default;
-            }
-
 .rdfa-editor-content [contenteditable="true"]:focus {
                 outline: 2px solid rgba(33, 150, 243, 0.35);
                 outline-offset: 2px;
@@ -233,86 +228,6 @@
                 box-shadow: inset 0 0 0 2px #2196f3;
             }
 
-/* Editor toolbar (injected into the navbar) */
-            #edit-toolbar {
-                order: -1;
-                margin-right: auto;
-                display: flex;
-                gap: 6px;
-                align-items: center;
-            }
-
-#edit-toolbar select,
-            #edit-toolbar button {
-                padding: 6px 10px;
-                border: 1px solid #e0e0e0;
-                border-radius: 4px;
-                background: white;
-                font-size: 13px;
-                font-family: "Roboto", sans-serif;
-                cursor: pointer;
-            }
-
-#edit-toolbar button:hover {
-                background: #f5f5f5;
-            }
-
-/* Caret-contextual toggle state (aria-pressed toggle buttons) */
-            #edit-toolbar button[aria-pressed="true"] {
-                background: #e3f0ff;
-                border-color: #6aa3e0;
-                color: #1a5fb4;
-            }
-
-/* Functional groups: thin dividers between clusters, no labels */
-            #edit-toolbar .tb-group {
-                display: flex;
-                gap: 6px;
-                align-items: center;
-            }
-
-#edit-toolbar .tb-group + .tb-group {
-                border-left: 1px solid #e0e0e0;
-                padding-left: 6px;
-            }
-
-/* Table-ops cluster switches on when the caret is in a table */
-            #edit-toolbar .tb-group.table-ops.active {
-                background: #e3f0ff;
-                border-radius: 4px;
-            }
-
-/* Link / figure dialogs */
-            .edit-dialog {
-                background: white;
-                border: 2px solid #2196f3;
-                border-radius: 8px;
-                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
-                padding: 16px;
-                min-width: 320px;
-                z-index: 10000;
-            }
-
-.edit-dialog label {
-                display: block;
-                font-size: 13px;
-                font-weight: 500;
-                color: #424242;
-                margin: 8px 0 4px 0;
-            }
-
-.edit-dialog input[type="text"] {
-                width: 100%;
-                padding: 8px 10px;
-                border: 1px solid #ccc;
-                border-radius: 4px;
-                font-size: 14px;
-                box-sizing: border-box;
-            }
-
-.edit-dialog .rdfa-editor-ui .action-buttons {
-                margin-top: 14px;
-            }
 
 /* Slash menu (/ to insert a block) */
             #slash-menu {
@@ -589,301 +504,6 @@
                 text-decoration-skip-ink: none;
             }
 
-.edit-dialog .rdfa-editor-ui .checkbox-label {
-                display: inline-flex;
-                gap: 6px;
-                align-items: center;
-                font-weight: 400;
-                margin-top: 8px;
-            }
-
-/* Modern Overlay Styling */
-            #overlay {
-                background: linear-gradient(to bottom, #f8f9fa, #ffffff);
-                border: 2px solid #2196f3;
-                border-radius: 8px;
-                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
-                font-family: "Roboto", sans-serif;
-                min-width: 450px;
-                max-width: 500px;
-                z-index: 10000;
-            }
-
-.rdfa-editor-ui .overlay-header {
-                background: linear-gradient(135deg, #2196f3, #1976d2);
-                color: white;
-                padding: 16px 20px;
-                border-radius: 6px 6px 0 0;
-                box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-            }
-
-.rdfa-editor-ui .overlay-header h3 {
-                margin: 0 0 8px 0;
-                font-size: 18px;
-                font-weight: 500;
-            }
-
-#overlay form {
-                padding: 20px;
-            }
-
-/* Statement (S / P / O) framing */
-            .rdfa-editor-ui .statement {
-                display: grid;
-                grid-template-columns: 26px 1fr;
-                gap: 10px 12px;
-                align-items: center;
-                background: #e3f2fd;
-                border-radius: 6px;
-                padding: 14px 16px;
-                margin-bottom: 16px;
-            }
-
-.rdfa-editor-ui .stmt-role {
-                font-family: 'Courier New', monospace;
-                font-weight: bold;
-                font-size: 12px;
-                color: white;
-                background: #2196f3;
-                border-radius: 50%;
-                width: 24px;
-                height: 24px;
-                display: flex;
-                align-items: center;
-                justify-content: center;
-            }
-
-#stmt-subject {
-                font-family: 'Courier New', monospace;
-                font-size: 12px;
-                color: #1565c0;
-                word-break: break-all;
-            }
-
-/* Advanced fields disclosure */
-            #overlay details {
-                border: 1px solid #e0e0e0;
-                border-radius: 6px;
-                padding: 8px 16px;
-                margin-bottom: 16px;
-                background: white;
-            }
-
-#overlay summary {
-                cursor: pointer;
-                font-size: 13px;
-                font-weight: 500;
-                color: #757575;
-                padding: 4px 0;
-            }
-
-#overlay details fieldset {
-                margin-top: 12px;
-            }
-
-/* Fieldsets */
-            #overlay fieldset {
-                border: 1px solid #e0e0e0;
-                border-radius: 6px;
-                padding: 12px 16px;
-                margin-bottom: 16px;
-                background: white;
-            }
-
-#overlay label {
-                display: block;
-                font-weight: 500;
-                color: #424242;
-                margin-bottom: 8px;
-                font-size: 14px;
-            }
-
-#overlay input[type="text"],
-            #overlay select {
-                width: 100%;
-                padding: 10px 12px;
-                border: 1px solid #ccc;
-                border-radius: 4px;
-                font-size: 14px;
-                font-family: "Roboto", sans-serif;
-                transition: border-color 0.2s;
-                box-sizing: border-box;
-            }
-
-#overlay input[type="text"]:focus,
-            #overlay select:focus {
-                outline: none;
-                border-color: #2196f3;
-                box-shadow: 0 0 0 3px rgba(33, 150, 243, 0.1);
-            }
-
-#overlay input[type="text"]:disabled {
-                background-color: #f5f5f5;
-                color: #999;
-            }
-
-.rdfa-editor-ui .helper-text {
-                display: block;
-                font-size: 12px;
-                color: #757575;
-                margin-top: 6px;
-                font-style: italic;
-            }
-
-/* Action Buttons */
-            .rdfa-editor-ui .action-buttons {
-                display: flex;
-                gap: 12px;
-                margin-top: 20px;
-                justify-content: flex-end;
-            }
-
-.rdfa-editor-ui .btn-primary,
-            .rdfa-editor-ui .btn-secondary,
-            .rdfa-editor-ui .btn-danger {
-                padding: 10px 24px;
-                border: none;
-                border-radius: 4px;
-                font-size: 14px;
-                font-weight: 500;
-                cursor: pointer;
-                transition: all 0.2s;
-                font-family: "Roboto", sans-serif;
-            }
-
-.rdfa-editor-ui .btn-primary {
-                background: #4caf50;
-                color: white;
-            }
-
-.rdfa-editor-ui .btn-primary:hover {
-                background: #45a049;
-                box-shadow: 0 2px 8px rgba(76, 175, 80, 0.3);
-            }
-
-.rdfa-editor-ui .btn-secondary {
-                background: #f5f5f5;
-                color: #424242;
-                border: 1px solid #e0e0e0;
-            }
-
-.rdfa-editor-ui .btn-secondary:hover {
-                background: #e0e0e0;
-            }
-
-.rdfa-editor-ui .btn-danger {
-                background: #f44336;
-                color: white;
-                margin-right: auto;
-            }
-
-.rdfa-editor-ui .btn-danger:hover {
-                background: #d32f2f;
-                box-shadow: 0 2px 8px rgba(244, 67, 54, 0.3);
-            }
-
-#overlay input[name="custom-datatype"] {
-                margin-top: 8px;
-            }
-
-/* Typeahead lookups (property / type) */
-            .rdfa-editor-ui .typeahead-field {
-                position: relative;
-                display: block;
-            }
-
-.rdfa-editor-ui .typeahead-menu {
-                position: absolute;
-                top: 100%;
-                left: 0;
-                right: 0;
-                z-index: 10002;
-                margin: 2px 0 0 0;
-                padding: 4px;
-                list-style: none;
-                background: white;
-                border: 1px solid #e0e0e0;
-                border-radius: 6px;
-                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
-                max-height: 260px;
-                overflow-y: auto;
-            }
-
-.rdfa-editor-ui .typeahead-option {
-                display: flex;
-                align-items: baseline;
-                justify-content: space-between;
-                gap: 10px;
-                padding: 7px 10px;
-                border-radius: 4px;
-                font-size: 14px;
-                color: #212121;
-                cursor: pointer;
-            }
-
-/* children never intercept the mousedown, so the <li> is always the event target */
-            .rdfa-editor-ui .typeahead-option * {
-                pointer-events: none;
-            }
-
-.rdfa-editor-ui .typeahead-option:hover,
-            .rdfa-editor-ui .typeahead-option[aria-selected="true"] {
-                background: #e3f2fd;
-                color: #0d47a1;
-            }
-
-.rdfa-editor-ui .typeahead-option-label strong {
-                font-weight: 700;
-            }
-
-.rdfa-editor-ui .typeahead-option-uri {
-                flex: 0 1 auto;
-                min-width: 0;
-                overflow: hidden;
-                text-overflow: ellipsis;
-                white-space: nowrap;
-                font-size: 11px;
-                color: #9e9e9e;
-            }
-
-.rdfa-editor-ui .typeahead-value {
-                display: flex;
-                align-items: center;
-                gap: 8px;
-                width: 100%;
-                padding: 10px 12px;
-                border: 1px solid #ccc;
-                border-radius: 4px;
-                background: white;
-                font-size: 14px;
-                font-family: "Roboto", sans-serif;
-                text-align: left;
-                cursor: pointer;
-            }
-
-.rdfa-editor-ui .typeahead-value:hover {
-                border-color: #2196f3;
-            }
-
-.rdfa-editor-ui .typeahead-label {
-                flex: 1 1 auto;
-                overflow: hidden;
-                text-overflow: ellipsis;
-                white-space: nowrap;
-            }
-
-.rdfa-editor-ui .typeahead-clear {
-                flex: 0 0 auto;
-                color: #9e9e9e;
-                font-size: 16px;
-                line-height: 1;
-                padding: 0 2px;
-            }
-
-.rdfa-editor-ui .typeahead-clear:hover {
-                color: #f44336;
-            }
-
 /* Modal Dialog */
 #output-modal {
                 position: fixed;
diff --git a/src/RDFa2RDFXML-v3.xsl b/src/RDFa2RDFXML-v3.xsl
index 2cc9af4..7ff325d 100644
--- a/src/RDFa2RDFXML-v3.xsl
+++ b/src/RDFa2RDFXML-v3.xsl
@@ -4,9 +4,9 @@
     xmlns:xs="http://www.w3.org/2001/XMLSchema"
     xmlns:map="http://www.w3.org/2005/xpath-functions/map"
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-    xmlns:rdfa="urn:rdfa:functions"
+    xmlns:rdfax="https://w3id.org/atomgraph/rdfa-editor/rdfa#"
     xpath-default-namespace="http://www.w3.org/1999/xhtml"
-    exclude-result-prefixes="xs map rdfa"
+    exclude-result-prefixes="xs map rdfax"
     version="3.0">
 
 <!--
@@ -31,7 +31,7 @@
     xml:base.
 -->
 
-    <xsl:mode name="rdfa:extract" on-no-match="deep-skip"/>
+    <xsl:mode name="rdfax:extract" on-no-match="deep-skip"/>
 
     <xsl:output method="xml" indent="yes" encoding="UTF-8"/>
 
@@ -39,7 +39,7 @@
     <xsl:param name="base-uri" as="xs:string?" select="()"/>
 
     <!-- RDFa 1.1 initial context (subset) -->
-    <xsl:variable name="rdfa:default-prefixes" as="map(xs:string, xs:string)" select="map{
+    <xsl:variable name="rdfax:default-prefixes" as="map(xs:string, xs:string)" select="map{
         'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
         'rdfs': 'http://www.w3.org/2000/01/rdf-schema#',
         'xsd': 'http://www.w3.org/2001/XMLSchema#',
@@ -56,7 +56,7 @@
             select="if ($doc//base/@href) then string(resolve-uri(($doc//base/@href)[1], $base)) else $base"/>
 
         <rdf:RDF>
-            <xsl:apply-templates select="$doc/*" mode="rdfa:extract">
+            <xsl:apply-templates select="$doc/*" mode="rdfax:extract">
                 <!-- RDFa initializes the parent object to the base URI -->
                 <xsl:with-param name="subject" select="$effective-base"/>
                 <xsl:with-param name="base" select="$effective-base" tunnel="yes"/>
@@ -64,24 +64,24 @@
         </rdf:RDF>
     </xsl:template>
 
-    <xsl:template match="head | script | style | *[@data-role]" mode="rdfa:extract"/>
+    <xsl:template match="head | script | style | *[@data-role]" mode="rdfax:extract"/>
 
-    <xsl:template match="*" mode="rdfa:extract">
+    <xsl:template match="*" mode="rdfax:extract">
         <xsl:param name="subject" as="xs:string?" select="()"/>
-        <xsl:param name="prefixes" as="map(xs:string, xs:string)" select="$rdfa:default-prefixes"/>
+        <xsl:param name="prefixes" as="map(xs:string, xs:string)" select="$rdfax:default-prefixes"/>
         <xsl:param name="vocab" as="xs:string?" select="()"/>
         <xsl:param name="lang" as="xs:string?" select="()"/>
         <xsl:param name="base" as="xs:string" tunnel="yes"/>
 
         <!-- evaluation context updates. Empty @vocab/@lang reset; @xml:lang wins over @lang -->
         <xsl:variable name="prefixes" as="map(xs:string, xs:string)"
-            select="map:merge(($prefixes, rdfa:in-scope-namespaces(.), rdfa:parse-prefix-attr(@prefix)), map{ 'duplicates': 'use-last' })"/>
+            select="map:merge(($prefixes, rdfax:in-scope-namespaces(.), rdfax:parse-prefix-attr(@prefix)), map{ 'duplicates': 'use-last' })"/>
         <xsl:variable name="vocab" as="xs:string?"
             select="if (exists(@vocab)) then @vocab[. ne ''] else $vocab"/>
         <xsl:variable name="lang" as="xs:string?"
             select="if (exists((@xml:lang, @lang))) then string((@xml:lang, @lang)[1])[. ne ''] else $lang"/>
 
-        <xsl:variable name="new-subject" as="xs:string?" select="rdfa:new-subject(., $prefixes, $base)"/>
+        <xsl:variable name="new-subject" as="xs:string?" select="rdfax:new-subject(., $prefixes, $base)"/>
 
         <!-- section 7.5 step 2: @vocab asserts (base, rdfa:usesVocabulary, vocab IRI) -->
         <xsl:for-each select="@vocab[. ne '']">
@@ -93,9 +93,9 @@
         </xsl:for-each>
 
         <!-- @typeof: one rdf:type triple per token; the typed node is the new subject -->
-        <xsl:for-each select="@typeof ! tokenize(.) ! rdfa:resolve-term-or-curie(., $prefixes, $vocab)">
+        <xsl:for-each select="@typeof ! tokenize(.) ! rdfax:resolve-term-or-curie(., $prefixes, $vocab)">
             <rdf:Description>
-                <xsl:sequence select="rdfa:subject-attribute($new-subject)"/>
+                <xsl:sequence select="rdfax:subject-attribute($new-subject)"/>
                 <rdf:type rdf:resource="{.}"/>
             </rdf:Description>
         </xsl:for-each>
@@ -109,8 +109,8 @@
                 <xsl:when test="@content or @datatype">
                     <xsl:sequence select="map{
                         'subject': ($new-subject, $subject)[1],
-                        'literal': string((@content, rdfa:literal-value(.))[1]),
-                        'datatype': @datatype ! rdfa:resolve-term-or-curie(., $prefixes, $vocab),
+                        'literal': string((@content, rdfax:literal-value(.))[1]),
+                        'datatype': @datatype ! rdfax:resolve-term-or-curie(., $prefixes, $vocab),
                         'lang': $lang
                     }"/>
                 </xsl:when>
@@ -118,7 +118,7 @@
                 <xsl:when test="@resource or @href or @src">
                     <xsl:sequence select="map{
                         'subject': (@about ! $new-subject, $subject)[1],
-                        'object': rdfa:resolve-iri((@resource, @href, @src)[1], $prefixes, $base)
+                        'object': rdfax:resolve-iri((@resource, @href, @src)[1], $prefixes, $base)
                     }"/>
                 </xsl:when>
                 <!-- @typeof without @about: the typed node becomes the object (RDFa 1.1 chaining) -->
@@ -129,7 +129,7 @@
                 <xsl:otherwise>
                     <xsl:sequence select="map{
                         'subject': (@about ! $new-subject, $subject)[1],
-                        'literal': rdfa:literal-value(.),
+                        'literal': rdfax:literal-value(.),
                         'lang': $lang
                     }"/>
                 </xsl:otherwise>
@@ -137,16 +137,16 @@
         </xsl:variable>
 
         <xsl:if test="exists($statement) and exists($statement?subject)">
-            <xsl:for-each select="tokenize(@property) ! rdfa:resolve-term-or-curie(., $prefixes, $vocab)">
-                <xsl:variable name="property-parts" as="map(xs:string, xs:string)" select="rdfa:split-uri(.)"/>
+            <xsl:for-each select="tokenize(@property) ! rdfax:resolve-term-or-curie(., $prefixes, $vocab)">
+                <xsl:variable name="property-parts" as="map(xs:string, xs:string)" select="rdfax:split-uri(.)"/>
                 <xsl:choose>
                     <xsl:when test="matches($property-parts?local, '^[\i-[:]][\c-[:]]*$') and $property-parts?namespace ne ''">
                         <rdf:Description>
-                            <xsl:sequence select="rdfa:subject-attribute($statement?subject)"/>
-                            <xsl:element name="{rdfa:prefixed-name($property-parts, $prefixes)}" namespace="{$property-parts?namespace}">
+                            <xsl:sequence select="rdfax:subject-attribute($statement?subject)"/>
+                            <xsl:element name="{rdfax:prefixed-name($property-parts, $prefixes)}" namespace="{$property-parts?namespace}">
                                 <xsl:choose>
                                     <xsl:when test="exists($statement?object)">
-                                        <xsl:sequence select="rdfa:object-attribute($statement?object)"/>
+                                        <xsl:sequence select="rdfax:object-attribute($statement?object)"/>
                                     </xsl:when>
                                     <xsl:otherwise>
                                         <xsl:choose>
@@ -174,7 +174,7 @@
              (@typeof without @about, rule 5.1) - else the new subject, else the current one -->
         <xsl:variable name="chains" as="xs:boolean"
             select="exists(@property) and not(@content) and not(@datatype) and exists(@typeof) and not(@about)"/>
-        <xsl:apply-templates select="*" mode="rdfa:extract">
+        <xsl:apply-templates select="*" mode="rdfax:extract">
             <xsl:with-param name="subject" select="if ($chains) then $statement?object else ($new-subject, $subject)[1]"/>
             <xsl:with-param name="prefixes" select="$prefixes"/>
             <xsl:with-param name="vocab" select="$vocab"/>
@@ -188,23 +188,23 @@
         present) @resource/@href/@src establish the subject; @typeof mints a node
         identified by @resource/@href/@src or a fresh blank node; else none (inherit).
     -->
-    <xsl:function name="rdfa:new-subject" as="xs:string?">
+    <xsl:function name="rdfax:new-subject" as="xs:string?">
         <xsl:param name="element" as="element()"/>
         <xsl:param name="prefixes" as="map(xs:string, xs:string)"/>
         <xsl:param name="base" as="xs:string"/>
 
         <xsl:choose>
             <xsl:when test="$element/@about">
-                <xsl:sequence select="rdfa:resolve-iri($element/@about, $prefixes, $base)"/>
+                <xsl:sequence select="rdfax:resolve-iri($element/@about, $prefixes, $base)"/>
             </xsl:when>
             <xsl:when test="$element/(@resource, @href, @src)
                     and (not($element/@property) or $element/@content or $element/@datatype)">
-                <xsl:sequence select="rdfa:resolve-iri(($element/@resource, $element/@href, $element/@src)[1], $prefixes, $base)"/>
+                <xsl:sequence select="rdfax:resolve-iri(($element/@resource, $element/@href, $element/@src)[1], $prefixes, $base)"/>
             </xsl:when>
             <xsl:when test="$element/@typeof">
                 <xsl:sequence select="if ($element/(@resource, @href, @src))
-                    then rdfa:resolve-iri(($element/@resource, $element/@href, $element/@src)[1], $prefixes, $base)
-                    else '_:' || rdfa:bnode-label($element)"/>
+                    then rdfax:resolve-iri(($element/@resource, $element/@href, $element/@src)[1], $prefixes, $base)
+                    else '_:' || rdfax:bnode-label($element)"/>
             </xsl:when>
             <xsl:otherwise>
                 <xsl:sequence select="()"/>
@@ -213,16 +213,16 @@
     </xsl:function>
 
     <!-- the subject in scope at an element, for UI display: fold new-subject over the ancestor axis -->
-    <xsl:function name="rdfa:in-scope-subject" as="xs:string?">
+    <xsl:function name="rdfax:in-scope-subject" as="xs:string?">
         <xsl:param name="element" as="element()"/>
         <xsl:param name="base" as="xs:string"/>
 
         <xsl:sequence select="fold-left($element/ancestor-or-self::*, $base,
-            function($subject, $e) { (rdfa:new-subject($e, $rdfa:default-prefixes, $base), $subject)[1] })"/>
+            function($subject, $e) { (rdfax:new-subject($e, $rdfax:default-prefixes, $base), $subject)[1] })"/>
     </xsl:function>
 
     <!-- IRI attribute values (@about/@resource/@href/@src): blank node, CURIE, or (relative) IRI -->
-    <xsl:function name="rdfa:resolve-iri" as="xs:string">
+    <xsl:function name="rdfax:resolve-iri" as="xs:string">
         <xsl:param name="value" as="xs:string"/>
         <xsl:param name="prefixes" as="map(xs:string, xs:string)"/>
         <xsl:param name="base" as="xs:string"/>
@@ -242,7 +242,7 @@
     </xsl:function>
 
     <!-- @property/@typeof/@datatype values: absolute IRI, CURIE, or bare term against @vocab -->
-    <xsl:function name="rdfa:resolve-term-or-curie" as="xs:string?">
+    <xsl:function name="rdfax:resolve-term-or-curie" as="xs:string?">
         <xsl:param name="value" as="xs:string"/>
         <xsl:param name="prefixes" as="map(xs:string, xs:string)"/>
         <xsl:param name="vocab" as="xs:string?"/>
@@ -266,7 +266,7 @@
     </xsl:function>
 
     <!-- @prefix attribute: 'prefix: IRI prefix: IRI ...' -->
-    <xsl:function name="rdfa:parse-prefix-attr" as="map(xs:string, xs:string)">
+    <xsl:function name="rdfax:parse-prefix-attr" as="map(xs:string, xs:string)">
         <xsl:param name="attr" as="xs:string?"/>
 
         <xsl:variable name="entries" as="map(xs:string, xs:string)*">
@@ -280,7 +280,7 @@
     </xsl:function>
 
     <!-- legacy xmlns:* declarations, via the namespace axis (XDM) and attribute names (HTML DOM) -->
-    <xsl:function name="rdfa:in-scope-namespaces" as="map(xs:string, xs:string)">
+    <xsl:function name="rdfax:in-scope-namespaces" as="map(xs:string, xs:string)">
         <xsl:param name="element" as="element()"/>
 
         <xsl:variable name="entries" as="map(xs:string, xs:string)*" select="
@@ -290,7 +290,7 @@
     </xsl:function>
 
     <!-- literal value of an element: its text content minus rendering/script/style subtrees -->
-    <xsl:function name="rdfa:literal-value" as="xs:string">
+    <xsl:function name="rdfax:literal-value" as="xs:string">
         <xsl:param name="element" as="element()"/>
 
         <xsl:sequence select="normalize-space(string-join(
@@ -298,13 +298,13 @@
     </xsl:function>
 
     <!-- stable across processors and runs, unlike generate-id(): position path of the element -->
-    <xsl:function name="rdfa:bnode-label" as="xs:string">
+    <xsl:function name="rdfax:bnode-label" as="xs:string">
         <xsl:param name="element" as="element()"/>
 
         <xsl:sequence select="'b' || string-join($element/ancestor-or-self::* ! string(count(preceding-sibling::*) + 1), '.')"/>
     </xsl:function>
 
-    <xsl:function name="rdfa:subject-attribute" as="attribute()">
+    <xsl:function name="rdfax:subject-attribute" as="attribute()">
         <xsl:param name="subject" as="xs:string"/>
 
         <xsl:choose>
@@ -317,7 +317,7 @@
         </xsl:choose>
     </xsl:function>
 
-    <xsl:function name="rdfa:object-attribute" as="attribute()">
+    <xsl:function name="rdfax:object-attribute" as="attribute()">
         <xsl:param name="object" as="xs:string"/>
 
         <xsl:choose>
@@ -331,7 +331,7 @@
     </xsl:function>
 
     <!-- namespace/local split on the last '#' or '/' for RDF/XML property element names -->
-    <xsl:function name="rdfa:split-uri" as="map(xs:string, xs:string)">
+    <xsl:function name="rdfax:split-uri" as="map(xs:string, xs:string)">
         <xsl:param name="uri" as="xs:string"/>
 
         <xsl:variable name="namespace" as="xs:string"
@@ -343,7 +343,7 @@
     </xsl:function>
 
     <!-- prefer a declared prefix for readable RDF/XML output -->
-    <xsl:function name="rdfa:prefixed-name" as="xs:string">
+    <xsl:function name="rdfax:prefixed-name" as="xs:string">
         <xsl:param name="parts" as="map(xs:string, xs:string)"/>
         <xsl:param name="prefixes" as="map(xs:string, xs:string)"/>
 
diff --git a/src/annotate.xsl b/src/annotate.xsl
index 3c72614..ca65a32 100644
--- a/src/annotate.xsl
+++ b/src/annotate.xsl
@@ -4,8 +4,8 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
-xmlns:rdfa="urn:rdfa:functions"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
+xmlns:rdfax="https://w3id.org/atomgraph/rdfa-editor/rdfa#"
 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
@@ -33,43 +33,43 @@ version="3.0">
         <xsl:choose>
             <!-- edit mode -->
             <xsl:when test="exists($annotation)">
-                <ixsl:set-property name="editingSpan" select="$annotation" object="local:editor-state()"/>
-                <xsl:call-template name="local:populate-form">
+                <ixsl:set-property name="editingSpan" select="$annotation" object="rdfae:editor-state()"/>
+                <xsl:call-template name="rdfae:populate-form">
                     <xsl:with-param name="span" select="$annotation"/>
-                    <!-- rdfa:literal-value, not string(): a block annotation contains a
+                    <!-- rdfax:literal-value, not string(): a block annotation contains a
                          chrome span whose ⠿ text would otherwise leak into the value -->
                     <xsl:with-param name="value" select="if (exists($annotation/@content))
-                        then string($annotation/@content) else rdfa:literal-value($annotation)"/>
+                        then string($annotation/@content) else rdfax:literal-value($annotation)"/>
                 </xsl:call-template>
-                <xsl:call-template name="local:show-overlay">
+                <xsl:call-template name="rdfae:show-overlay">
                     <xsl:with-param name="event" select="$event"/>
                     <xsl:with-param name="in-scope-subject"
                         select="($annotation/@about ! string(.),
-                            $annotation/parent::* ! rdfa:in-scope-subject(., local:document-uri()))[1]"/>
+                            $annotation/parent::* ! rdfax:in-scope-subject(., rdfae:document-uri()))[1]"/>
                 </xsl:call-template>
             </xsl:when>
             <!-- create mode -->
             <xsl:otherwise>
-                <xsl:variable name="selection" select="local:selection()"/>
+                <xsl:variable name="selection" select="rdfae:selection()"/>
                 <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1 and not(ixsl:get($selection, 'isCollapsed'))">
-                    <xsl:variable name="range" select="local:caret-range()"/>
+                    <xsl:variable name="range" select="rdfae:caret-range()"/>
                     <xsl:choose>
-                        <xsl:when test="local:selection-valid($range)">
-                            <ixsl:set-property name="range" select="$range" object="local:editor-state()"/>
-                            <ixsl:set-property name="editingSpan" select="()" object="local:editor-state()"/>
-                            <xsl:call-template name="local:show-selection-hint">
+                        <xsl:when test="rdfae:selection-valid($range)">
+                            <ixsl:set-property name="range" select="$range" object="rdfae:editor-state()"/>
+                            <ixsl:set-property name="editingSpan" select="()" object="rdfae:editor-state()"/>
+                            <xsl:call-template name="rdfae:show-selection-hint">
                                 <xsl:with-param name="range" select="$range"/>
                             </xsl:call-template>
-                            <xsl:call-template name="local:populate-form">
+                            <xsl:call-template name="rdfae:populate-form">
                                 <xsl:with-param name="value" select="string(ixsl:call($selection, 'toString', []))"/>
                             </xsl:call-template>
-                            <xsl:call-template name="local:show-overlay">
+                            <xsl:call-template name="rdfae:show-overlay">
                                 <xsl:with-param name="event" select="$event"/>
-                                <xsl:with-param name="in-scope-subject" select="rdfa:in-scope-subject(., local:document-uri())"/>
+                                <xsl:with-param name="in-scope-subject" select="rdfax:in-scope-subject(., rdfae:document-uri())"/>
                             </xsl:call-template>
                         </xsl:when>
                         <xsl:otherwise>
-                            <xsl:call-template name="local:show-flash">
+                            <xsl:call-template name="rdfae:show-flash">
                                 <xsl:with-param name="range" select="$range"/>
                             </xsl:call-template>
                         </xsl:otherwise>
@@ -82,7 +82,7 @@ version="3.0">
     <!-- surroundContents() succeeds when the range starts and ends in the same
          container, or in sibling text nodes; xsl:try in the Annotate handler backstops
          the partial-selection cases this misses -->
-    <xsl:function name="local:selection-valid" as="xs:boolean">
+    <xsl:function name="rdfae:selection-valid" as="xs:boolean">
         <xsl:param name="range"/>
 
         <xsl:variable name="start" select="ixsl:get($range, 'startContainer')"/>
@@ -96,7 +96,7 @@ version="3.0">
          the attributes follow from the filled fields. A value differing from the display
          text becomes @content - unless @resource is the object (RDFa step 11: @content
          would take precedence and orphan the resource) -->
-    <xsl:template name="local:apply-annotation">
+    <xsl:template name="rdfae:apply-annotation">
         <xsl:param name="target" as="element()"/>
         <xsl:param name="values" as="map(xs:string, xs:string?)"/>
         <xsl:param name="reference-text" as="xs:string"/>
@@ -138,53 +138,53 @@ version="3.0">
     </xsl:template>
 
     <xsl:template match="button[tokenize(@class) = 'spo-action']" mode="ixsl:onclick">
-        <xsl:variable name="values" as="map(xs:string, xs:string?)" select="local:form-values(ancestor::form)"/>
-        <xsl:variable name="editing" select="ixsl:get(local:editor-state(), 'editingSpan')"/>
+        <xsl:variable name="values" as="map(xs:string, xs:string?)" select="rdfae:form-values(ancestor::form)"/>
+        <xsl:variable name="editing" select="ixsl:get(rdfae:editor-state(), 'editingSpan')"/>
 
         <xsl:choose>
             <xsl:when test="exists($editing)">
-                <xsl:call-template name="local:push-undo"/>
-                <xsl:call-template name="local:apply-annotation">
+                <xsl:call-template name="rdfae:push-undo"/>
+                <xsl:call-template name="rdfae:apply-annotation">
                     <xsl:with-param name="target" select="$editing"/>
                     <xsl:with-param name="values" select="$values"/>
                     <!-- chrome-excluded, so an unchanged block value doesn't spuriously emit @content -->
-                    <xsl:with-param name="reference-text" select="rdfa:literal-value($editing)"/>
+                    <xsl:with-param name="reference-text" select="rdfax:literal-value($editing)"/>
                 </xsl:call-template>
-                <xsl:call-template name="local:after-mutation"/>
-                <xsl:call-template name="local:hide-overlay"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
+                <xsl:call-template name="rdfae:hide-overlay"/>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:variable name="range" select="ixsl:get(local:editor-state(), 'range')"/>
+                <xsl:variable name="range" select="ixsl:get(rdfae:editor-state(), 'range')"/>
                 <xsl:variable name="reference-text" as="xs:string" select="string(ixsl:call($range, 'toString', []))"/>
                 <!-- capture pre-wrap state; push only when the wrap succeeded -->
-                <xsl:variable name="snapshot-root" as="element()?" select="local:active-root()"/>
+                <xsl:variable name="snapshot-root" as="element()?" select="rdfae:active-root()"/>
                 <xsl:variable name="snapshot" as="xs:string?"
                     select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
                 <xsl:variable name="span" as="element()?">
-                    <xsl:call-template name="local:wrap-range">
+                    <xsl:call-template name="rdfae:wrap-range">
                         <xsl:with-param name="range" select="$range"/>
                         <xsl:with-param name="name" select="'span'"/>
                     </xsl:call-template>
                 </xsl:variable>
                 <xsl:for-each select="$span">
-                    <xsl:call-template name="local:push-undo">
+                    <xsl:call-template name="rdfae:push-undo">
                         <xsl:with-param name="root" select="$snapshot-root"/>
                         <xsl:with-param name="snapshot" select="$snapshot"/>
                     </xsl:call-template>
-                    <xsl:call-template name="local:apply-annotation">
+                    <xsl:call-template name="rdfae:apply-annotation">
                         <xsl:with-param name="target" select="."/>
                         <xsl:with-param name="values" select="$values"/>
                         <xsl:with-param name="reference-text" select="$reference-text"/>
                     </xsl:call-template>
-                    <xsl:call-template name="local:after-mutation"/>
+                    <xsl:call-template name="rdfae:after-mutation"/>
                 </xsl:for-each>
-                <xsl:call-template name="local:hide-overlay"/>
+                <xsl:call-template name="rdfae:hide-overlay"/>
             </xsl:otherwise>
         </xsl:choose>
     </xsl:template>
 
     <!-- unwrap an element: move its children up, drop it, merge text nodes -->
-    <xsl:template name="local:unwrap-element">
+    <xsl:template name="rdfae:unwrap-element">
         <xsl:param name="element" as="element()"/>
 
         <xsl:variable name="parent" select="ixsl:get($element, 'parentNode')"/>
@@ -196,7 +196,7 @@ version="3.0">
     </xsl:template>
 
     <!-- wrap a range in a fresh element; on boundary-crossing selections flash and return nothing -->
-    <xsl:template name="local:wrap-range" as="element()?">
+    <xsl:template name="rdfae:wrap-range" as="element()?">
         <xsl:param name="range"/>
         <xsl:param name="name" as="xs:string"/>
 
@@ -205,11 +205,11 @@ version="3.0">
             <xsl:sequence select="ixsl:call($range, 'surroundContents', [ $element ])[current-date() lt xs:date('2000-01-01')]"/>
             <!-- surroundContents leaves the selection undefined; re-select the wrapped
                  contents so subsequent toggles resolve their target -->
-            <xsl:sequence select="ixsl:call(local:selection(), 'selectAllChildren',
+            <xsl:sequence select="ixsl:call(rdfae:selection(), 'selectAllChildren',
                 [ $element ])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:sequence select="$element"/>
             <xsl:catch errors="*">
-                <xsl:call-template name="local:show-flash">
+                <xsl:call-template name="rdfae:show-flash">
                     <xsl:with-param name="range" select="$range"/>
                 </xsl:call-template>
             </xsl:catch>
@@ -217,12 +217,12 @@ version="3.0">
     </xsl:template>
 
     <xsl:template match="button[tokenize(@class) = 'remove-action']" mode="ixsl:onclick">
-        <xsl:for-each select="ixsl:get(local:editor-state(), 'editingSpan')">
-            <xsl:call-template name="local:push-undo"/>
+        <xsl:for-each select="ixsl:get(rdfae:editor-state(), 'editingSpan')">
+            <xsl:call-template name="rdfae:push-undo"/>
             <xsl:choose>
                 <!-- a block carries its annotation on itself: strip the RDFa attributes
                      but keep the block (unwrapping would dissolve the heading/paragraph) -->
-                <xsl:when test="local:block-of(.) is .">
+                <xsl:when test="rdfae:block-of(.) is .">
                     <xsl:variable name="element" select="."/>
                     <xsl:for-each select="'about', 'typeof', 'property', 'resource', 'content', 'datatype', 'lang', 'xml:lang'">
                         <ixsl:remove-attribute name="{.}" object="$element"/>
@@ -230,22 +230,22 @@ version="3.0">
                 </xsl:when>
                 <!-- an inline annotation is a wrapper element: unwrap it -->
                 <xsl:otherwise>
-                    <xsl:call-template name="local:unwrap-element">
+                    <xsl:call-template name="rdfae:unwrap-element">
                         <xsl:with-param name="element" select="."/>
                     </xsl:call-template>
                 </xsl:otherwise>
             </xsl:choose>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:for-each>
-        <xsl:call-template name="local:hide-overlay"/>
+        <xsl:call-template name="rdfae:hide-overlay"/>
     </xsl:template>
 
     <xsl:template match="button[tokenize(@class) = 'cancel-action']" mode="ixsl:onclick">
-        <xsl:call-template name="local:hide-overlay"/>
+        <xsl:call-template name="rdfae:hide-overlay"/>
     </xsl:template>
 
     <!-- brief red flash over an invalid selection, in page coordinates so it scrolls with the text -->
-    <xsl:template name="local:show-flash">
+    <xsl:template name="rdfae:show-flash">
         <xsl:param name="range"/>
 
         <xsl:variable name="rect" select="ixsl:call($range, 'getBoundingClientRect', [])"/>
@@ -257,10 +257,10 @@ version="3.0">
                     style="position: absolute; pointer-events: none; z-index: 9999; left: {ixsl:get($rect, 'left') + $scroll-x}px; top: {ixsl:get($rect, 'top') + $scroll-y}px; width: {ixsl:get($rect, 'width')}px; height: {ixsl:get($rect, 'height')}px;"/>
             </xsl:result-document>
         </xsl:for-each>
-        <ixsl:promise select="ixsl:sleep(1200) => ixsl:then(local:hide-flash#1)"/>
+        <ixsl:promise select="ixsl:sleep(1200) => ixsl:then(rdfae:hide-flash#1)"/>
     </xsl:template>
 
-    <xsl:function name="local:hide-flash" as="empty-sequence()" ixsl:updating="yes">
+    <xsl:function name="rdfae:hide-flash" as="empty-sequence()" ixsl:updating="yes">
         <xsl:param name="ignored" as="item()?"/>
 
         <xsl:for-each select="id('selection-flash', ixsl:page())">
@@ -269,7 +269,7 @@ version="3.0">
     </xsl:function>
 
     <!-- the editor renders its own output modal (host pages provide only content regions) -->
-    <xsl:template name="local:init-annotate">
+    <xsl:template name="rdfae:init-annotate">
         <xsl:for-each select="ixsl:page()//body">
             <xsl:result-document href="?." method="ixsl:append-content">
                 <div id="output-modal" class="rdfa-editor-ui" style="display: none;">
@@ -286,7 +286,7 @@ version="3.0">
 
     <!-- shared output modal (Extract RDF / View source / lint issues); callers
          passing $filename get a Download button (hidden otherwise) -->
-    <xsl:template name="local:show-output">
+    <xsl:template name="rdfae:show-output">
         <xsl:param name="title" as="xs:string"/>
         <xsl:param name="text" as="xs:string"/>
         <xsl:param name="filename" as="xs:string?"/>
@@ -326,18 +326,18 @@ version="3.0">
     </xsl:template>
 
     <!-- extract RDF/XML from the page and display it in the modal, grouped one
-         rdf:Description per subject (via local:group-triples) for readability -->
+         rdf:Description per subject (via rdfae:group-triples) for readability -->
     <xsl:template match="button[@id = 'parse-rdf']" mode="ixsl:onclick">
         <xsl:variable name="rdf" as="element(rdf:RDF)">
             <xsl:call-template name="extract-rdfa">
                 <xsl:with-param name="doc" select="ixsl:page()"/>
-                <xsl:with-param name="base" select="local:document-uri()"/>
+                <xsl:with-param name="base" select="rdfae:document-uri()"/>
             </xsl:call-template>
         </xsl:variable>
 
-        <xsl:call-template name="local:show-output">
+        <xsl:call-template name="rdfae:show-output">
             <xsl:with-param name="title" select="'Extracted RDF/XML'"/>
-            <xsl:with-param name="text" select="serialize(local:group-triples($rdf), map{ 'method': 'xml', 'indent': true() })"/>
+            <xsl:with-param name="text" select="serialize(rdfae:group-triples($rdf), map{ 'method': 'xml', 'indent': true() })"/>
             <xsl:with-param name="filename" select="'content.rdf'"/>
             <xsl:with-param name="media-type" select="'application/rdf+xml'"/>
         </xsl:call-template>
diff --git a/src/blocks.xsl b/src/blocks.xsl
index 556733f..c4f3e16 100644
--- a/src/blocks.xsl
+++ b/src/blocks.xsl
@@ -4,7 +4,7 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 version="3.0">
@@ -32,7 +32,7 @@ version="3.0">
     round-trips byte-identically wherever the content model admits a div.
 
     The core knows no block vocabulary: $object-block-types is empty and the
-    local:render-island mode ships a neutral placeholder card. An extension
+    rdfae:render-island mode ships a neutral placeholder card. An extension
     stylesheet (src/ldh-blocks.xsl here; LinkedDataHub's client.xsl in
     production) imports the editor, re-declares the param and overrides the mode
     per @typeof - and for reference blocks by dereferencing the @about URI -
@@ -50,38 +50,38 @@ version="3.0">
          malformed @about can never error out of a predicate that runs on every
          gesture; relative/fragment @about values (document parts, or the
          about-relative lint case) are never islands -->
-    <xsl:function name="local:reference-block" as="xs:boolean">
+    <xsl:function name="rdfae:reference-block" as="xs:boolean">
         <xsl:param name="element" as="element()?"/>
         <xsl:sequence select="exists($element[self::div]
             [matches(normalize-space(@about), '^[A-Za-z][A-Za-z0-9+.\-]*:')]
-            [substring-before(normalize-space(@about) || '#', '#') ne local:document-uri()]
+            [substring-before(normalize-space(@about) || '#', '#') ne rdfae:document-uri()]
             [empty((node() except *[@data-role])[not(self::text()[not(normalize-space())])])])"/>
     </xsl:function>
 
     <!-- THE island predicate: every island decision (init, navigation, merge
          boundaries, the delete machine, undo re-render) routes through here -->
-    <xsl:function name="local:island" as="xs:boolean">
+    <xsl:function name="rdfae:island" as="xs:boolean">
         <xsl:param name="element" as="element()?"/>
         <xsl:sequence select="exists($element[self::div][tokenize(@typeof) = $object-block-types])
-            or local:reference-block($element)"/>
+            or rdfae:reference-block($element)"/>
     </xsl:function>
 
     <!-- the render hook. Context item = the island div. Contract: inject exactly
          one div[@data-role='rendering'] as the island's last child via
-         local:replace-rendering - async renderers only in the completion callback
+         rdfae:replace-rendering - async renderers only in the completion callback
          (loading state = the ephemeral rdfa-editor-loading class), so an island
          without a rendering div always reads as "render needed" (the undo-restore
          re-render pass keys on that); never touch the RDFa spans; never push undo
          (rendering is ephemeral by construction); idempotent (replace, not append) -->
-    <xsl:mode name="local:render-island" on-no-match="deep-skip"/>
+    <xsl:mode name="rdfae:render-island" on-no-match="deep-skip"/>
 
     <!-- neutral default: a static card naming the block's type (a reference
          block has none - it reads as 'Resource') and resource. Extension
          templates matching per @typeof / reference win on import precedence -->
-    <xsl:template match="*" mode="local:render-island">
+    <xsl:template match="*" mode="rdfae:render-island">
         <xsl:variable name="type" as="xs:string?"
             select="(tokenize(@typeof)[. = $object-block-types], tokenize(@typeof), 'Resource')[1]"/>
-        <xsl:call-template name="local:replace-rendering">
+        <xsl:call-template name="rdfae:replace-rendering">
             <xsl:with-param name="island" select="."/>
             <xsl:with-param name="content">
                 <div class="rdfa-editor-island-card">
@@ -96,13 +96,13 @@ version="3.0">
     </xsl:template>
 
     <!-- idempotent rendering-container swap: the only writer of the rendering div -->
-    <xsl:template name="local:replace-rendering">
+    <xsl:template name="rdfae:replace-rendering">
         <xsl:param name="island" as="element()"/>
         <xsl:param name="content" as="node()*"/>
         <xsl:for-each select="$island/*[@data-role = 'rendering']">
             <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
-        <xsl:variable name="rendering" as="element()" select="local:element('div')"/>
+        <xsl:variable name="rendering" as="element()" select="rdfae:element('div')"/>
         <xsl:for-each select="$rendering">
             <ixsl:set-attribute name="data-role" select="'rendering'"/>
         </xsl:for-each>
@@ -118,13 +118,13 @@ version="3.0">
     <!-- no-op extension points, overridden at higher import precedence: dialogs
          appended to body at init, toolbar Insert-group buttons, slash-menu items,
          and slash-command dispatch for those items -->
-    <xsl:template name="local:render-extra-dialogs"/>
+    <xsl:template name="rdfae:render-extra-dialogs"/>
 
-    <xsl:template name="local:render-extra-insert-buttons"/>
+    <xsl:template name="rdfae:render-extra-insert-buttons"/>
 
-    <xsl:template name="local:render-extra-slash-items"/>
+    <xsl:template name="rdfae:render-extra-slash-items"/>
 
-    <xsl:template name="local:run-extra-slash-command">
+    <xsl:template name="rdfae:run-extra-slash-command">
         <xsl:param name="command" as="xs:string"/>
         <xsl:param name="host" as="element()?"/>
     </xsl:template>
diff --git a/src/canonical-xhtml.xsl b/src/canonical-xhtml.xsl
index 50cb113..0aaac74 100644
--- a/src/canonical-xhtml.xsl
+++ b/src/canonical-xhtml.xsl
@@ -3,7 +3,7 @@
 xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:cm="urn:rdfa-editor:content-model"
+xmlns:cm="https://w3id.org/atomgraph/rdfa-editor/content-model#"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 exclude-result-prefixes="#all"
 version="3.0">
@@ -30,7 +30,7 @@ version="3.0">
 -->
 
     <!-- serialization is the caller's job (view-source runs exclusive XML c14n via
-         local:canonicalize-xml in edit.xsl, tests use -o output); no xsl:output
+         rdfae:canonicalize-xml in edit.xsl, tests use -o output); no xsl:output
          here - it would conflict with the including stylesheet's -->
     <xsl:mode name="canonical" on-no-match="shallow-copy"/>
     <xsl:mode name="cm-normalize" on-no-match="shallow-copy"/>
diff --git a/src/content-model.xsl b/src/content-model.xsl
index 6f8b3ae..6332024 100644
--- a/src/content-model.xsl
+++ b/src/content-model.xsl
@@ -3,7 +3,7 @@
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
 xmlns:map="http://www.w3.org/2005/xpath-functions/map"
-xmlns:cm="urn:rdfa-editor:content-model"
+xmlns:cm="https://w3id.org/atomgraph/rdfa-editor/content-model#"
 exclude-result-prefixes="#all"
 version="3.0">
 
diff --git a/src/edit.xsl b/src/edit.xsl
index 9ad2987..c845890 100644
--- a/src/edit.xsl
+++ b/src/edit.xsl
@@ -4,8 +4,8 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:cm="urn:rdfa-editor:content-model"
-xmlns:local="urn:rdfa-editor:functions"
+xmlns:cm="https://w3id.org/atomgraph/rdfa-editor/content-model#"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 version="3.0">
@@ -25,35 +25,35 @@ version="3.0">
     <!-- ................................ helpers ................................ -->
 
     <!-- the page URI without its fragment: the base for RDFa resolution in the browser -->
-    <xsl:function name="local:document-uri" as="xs:string">
+    <xsl:function name="rdfae:document-uri" as="xs:string">
         <xsl:sequence select="substring-before(ixsl:location() || '#', '#')"/>
     </xsl:function>
 
     <!-- editable regions are marked by convention with the rdfa-editor-content class
          (host-page chrome: never serialized - the canonical form strips @class) -->
-    <xsl:function name="local:roots" as="element()*">
+    <xsl:function name="rdfae:roots" as="element()*">
         <xsl:sequence select="ixsl:page()//*[contains-token(@class, 'rdfa-editor-content')]"/>
     </xsl:function>
 
-    <!-- where local:init-editing appends the toolbar; hosts without a nav element
+    <!-- where rdfae:init-editing appends the toolbar; hosts without a nav element
          override this to point at their own chrome -->
-    <xsl:function name="local:toolbar-host" as="element()*">
+    <xsl:function name="rdfae:toolbar-host" as="element()*">
         <xsl:sequence select="ixsl:page()//nav"/>
     </xsl:function>
 
-    <xsl:function name="local:root-of" as="element()?">
+    <xsl:function name="rdfae:root-of" as="element()?">
         <xsl:param name="node"/>
         <xsl:sequence select="$node/ancestor-or-self::*[contains-token(@class, 'rdfa-editor-content')][1]"/>
     </xsl:function>
 
     <!-- the region the user is working in: selection first, then the last focused host -->
-    <xsl:function name="local:active-root" as="element()?">
-        <xsl:sequence select="(local:anchor-node() ! local:root-of(.),
-            ixsl:get(local:editor-state(), 'activeBlock') ! local:root-of(.), local:roots()[1])[1]"/>
+    <xsl:function name="rdfae:active-root" as="element()?">
+        <xsl:sequence select="(rdfae:anchor-node() ! rdfae:root-of(.),
+            ixsl:get(rdfae:editor-state(), 'activeBlock') ! rdfae:root-of(.), rdfae:roots()[1])[1]"/>
     </xsl:function>
 
     <!-- the top-level block containing a node -->
-    <xsl:function name="local:block-of" as="element()?">
+    <xsl:function name="rdfae:block-of" as="element()?">
         <xsl:param name="node"/>
         <xsl:sequence select="$node/ancestor-or-self::*[parent::*[contains-token(@class, 'rdfa-editor-content')]][1]"/>
     </xsl:function>
@@ -64,27 +64,27 @@ version="3.0">
          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:function name="rdfae: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(.))]
+            [exists(rdfae: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:function name="rdfae:handle-block" as="element()?">
         <xsl:param name="handle" as="element()"/>
-        <xsl:sequence select="$handle/parent::*[local:draggable-block(.)]"/>
+        <xsl:sequence select="$handle/parent::*[rdfae: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:function name="rdfae: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')
@@ -94,10 +94,10 @@ version="3.0">
     <!-- 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:function name="rdfae: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(.)]
+        <xsl:sequence select="$hit/ancestor-or-self::*[rdfae:draggable-block(.)]
             [empty(ancestor-or-self::* intersect $dragged)][1]"/>
     </xsl:function>
 
@@ -105,15 +105,15 @@ version="3.0">
          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:function name="rdfae: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:sequence select="$candidate/ancestor-or-self::*[rdfae:draggable-block(.)]
+            [rdfae: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:function name="rdfae:host-of" as="element()?">
         <xsl:param name="node"/>
         <xsl:sequence select="$node/ancestor-or-self::*[@contenteditable = 'true'][1]"/>
     </xsl:function>
@@ -121,19 +121,19 @@ version="3.0">
     <!-- the list item a node sits in (the host may be a nested block inside a
          container item): the unit Tab indent/outdent acts on. Clamped at the
          region root - a host-page li wrapping an embedded region is not ours -->
-    <xsl:function name="local:item-of" as="element()?">
+    <xsl:function name="rdfae:item-of" as="element()?">
         <xsl:param name="node"/>
-        <xsl:sequence select="$node/ancestor-or-self::li[exists(local:block-of(.))][1]"/>
+        <xsl:sequence select="$node/ancestor-or-self::li[exists(rdfae:block-of(.))][1]"/>
     </xsl:function>
 
     <!-- the first/last editable host within an element (the element itself when it
          is a host): where the caret lands entering a container from either side -->
-    <xsl:function name="local:first-host-in" as="element()?">
+    <xsl:function name="rdfae:first-host-in" as="element()?">
         <xsl:param name="element" as="element()?"/>
         <xsl:sequence select="($element/descendant-or-self::*[@contenteditable = 'true'])[1]"/>
     </xsl:function>
 
-    <xsl:function name="local:last-host-in" as="element()?">
+    <xsl:function name="rdfae:last-host-in" as="element()?">
         <xsl:param name="element" as="element()?"/>
         <xsl:sequence select="($element/descendant-or-self::*[@contenteditable = 'true'])[last()]"/>
     </xsl:function>
@@ -144,65 +144,65 @@ version="3.0">
          (islands hold no hosts, so the lookup would leapfrog them) - composites
          and islands are hard boundaries (B3/B6), so an empty result leaves the
          gesture inert -->
-    <xsl:function name="local:merge-host-in" as="element()?">
+    <xsl:function name="rdfae:merge-host-in" as="element()?">
         <xsl:param name="element" as="element()?"/>
-        <xsl:variable name="host" as="element()?" select="local:last-host-in($element)"/>
+        <xsl:variable name="host" as="element()?" select="rdfae:last-host-in($element)"/>
         <xsl:sequence select="$host
-            [empty(ancestor-or-self::*[self::table or self::figure or local:island(.)]
+            [empty(ancestor-or-self::*[self::table or self::figure or rdfae:island(.)]
                 intersect $element/descendant-or-self::*)]
-            [empty($element/descendant-or-self::*[local:island(.)][. &gt;&gt; $host])]"/>
+            [empty($element/descendant-or-self::*[rdfae:island(.)][. &gt;&gt; $host])]"/>
     </xsl:function>
 
     <!-- keyboard-navigation stops within a region, in document order: the editable
          hosts plus block-level (figure) images plus object-block islands. Neither
          can hold a caret, so each is a navigation island in its own right -
-         focused (selected) rather than given a caret - see local:land-forward/
+         focused (selected) rather than given a caret - see rdfae:land-forward/
          -backward. Nothing inside an island or an ephemeral subtree is a stop -->
-    <xsl:function name="local:nav-targets" as="element()*">
+    <xsl:function name="rdfae:nav-targets" as="element()*">
         <xsl:param name="node"/>
-        <xsl:sequence select="local:root-of($node)//*[@contenteditable = 'true'
+        <xsl:sequence select="rdfae:root-of($node)//*[@contenteditable = 'true'
             or (self::img and empty(ancestor::*[@contenteditable = 'true']))
-            or local:island(.)]
-            [empty(ancestor::*[@data-role])][empty(ancestor::*[local:island(.)])]"/>
+            or rdfae:island(.)]
+            [empty(ancestor::*[@data-role])][empty(ancestor::*[rdfae:island(.)])]"/>
     </xsl:function>
 
     <!-- toolbar actions resolve the block from the selection, falling back to the
          last focused host (the block-type select steals focus - see ixsl:onfocusin) -->
-    <xsl:function name="local:current-block" as="element()?">
-        <xsl:sequence select="(local:anchor-node() ! local:block-of(.),
-            ixsl:get(local:editor-state(), 'activeBlock') ! local:block-of(.))[1]"/>
+    <xsl:function name="rdfae:current-block" as="element()?">
+        <xsl:sequence select="(rdfae:anchor-node() ! rdfae:block-of(.),
+            ixsl:get(rdfae:editor-state(), 'activeBlock') ! rdfae:block-of(.))[1]"/>
     </xsl:function>
 
     <!-- host-based resolution for actions that act on the leaf block the caret
          sits in (block-type convert, quote toggle) rather than the top-level block -->
-    <xsl:function name="local:current-host" as="element()?">
-        <xsl:sequence select="(local:anchor-node() ! local:host-of(.),
-            ixsl:get(local:editor-state(), 'activeBlock') ! local:host-of(.))[1]"/>
+    <xsl:function name="rdfae:current-host" as="element()?">
+        <xsl:sequence select="(rdfae:anchor-node() ! rdfae:host-of(.),
+            ixsl:get(rdfae:editor-state(), 'activeBlock') ! rdfae:host-of(.))[1]"/>
     </xsl:function>
 
-    <xsl:function name="local:chrome-count" as="xs:integer">
+    <xsl:function name="rdfae:chrome-count" as="xs:integer">
         <xsl:param name="block" as="element()"/>
         <xsl:sequence select="count($block/*[@data-role = 'chrome'])"/>
     </xsl:function>
 
     <!-- block text excluding chrome, for emptiness checks -->
-    <xsl:function name="local:block-text" as="xs:string">
+    <xsl:function name="rdfae:block-text" as="xs:string">
         <xsl:param name="block" as="element()"/>
         <xsl:sequence select="normalize-space(string-join($block//text()[not(ancestor::*[@data-role])]))"/>
     </xsl:function>
 
     <!-- true when nothing but chrome precedes the caret inside the host -->
-    <xsl:function name="local:at-start" as="xs:boolean">
+    <xsl:function name="rdfae:at-start" as="xs:boolean">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="range"/>
         <xsl:variable name="probe" select="ixsl:call(ixsl:page(), 'createRange', [])"/>
-        <xsl:sequence select="ixsl:call($probe, 'setStart', [ $host, local:chrome-count($host) ])[current-date() lt xs:date('2000-01-01')],
+        <xsl:sequence select="ixsl:call($probe, 'setStart', [ $host, rdfae:chrome-count($host) ])[current-date() lt xs:date('2000-01-01')],
             ixsl:call($probe, 'setEnd', [ ixsl:get($range, 'startContainer'), xs:integer(ixsl:get($range, 'startOffset')) ])[current-date() lt xs:date('2000-01-01')]"/>
         <xsl:sequence select="string(ixsl:call($probe, 'toString', [])) = ''"/>
     </xsl:function>
 
     <!-- true when nothing but a trailing placeholder follows the caret inside the host -->
-    <xsl:function name="local:at-end" as="xs:boolean">
+    <xsl:function name="rdfae:at-end" as="xs:boolean">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="range"/>
         <xsl:variable name="probe" select="ixsl:call(ixsl:page(), 'createRange', [])"/>
@@ -215,81 +215,81 @@ version="3.0">
          and no valid caret position (its only child may be non-editable chrome), so
          clicks and typing go nowhere. Dropped again by canonical-xhtml.xsl. Never
          fires on element-only containers (blockquote) - br is inline content -->
-    <xsl:template name="local:ensure-placeholder">
+    <xsl:template name="rdfae:ensure-placeholder">
         <xsl:param name="host" as="element()"/>
-        <xsl:if test="local:block-text($host) = '' and empty($host/br)
+        <xsl:if test="rdfae:block-text($host) = '' and empty($host/br)
                 and cm:allows-child(local-name($host), 'br')">
             <xsl:sequence select="ixsl:call($host, 'appendChild',
-                [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+                [ rdfae:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
     </xsl:template>
 
     <!-- outermost RDFa-attributed inline ancestor of a node, strictly below the host -->
-    <xsl:function name="local:enclosing-annotation" as="element()?">
+    <xsl:function name="rdfae:enclosing-annotation" as="element()?">
         <xsl:param name="node"/>
         <xsl:param name="host" as="element()"/>
         <xsl:sequence select="($node/ancestor-or-self::*[@property or @about or @typeof or @resource]
             intersect $host/descendant::*)[1]"/>
     </xsl:function>
 
-    <xsl:function name="local:selection" as="item()">
+    <xsl:function name="rdfae:selection" as="item()">
         <xsl:sequence select="ixsl:call(ixsl:window(), 'getSelection', [])"/>
     </xsl:function>
 
-    <xsl:function name="local:caret-range" as="item()?">
-        <xsl:variable name="selection" select="local:selection()"/>
+    <xsl:function name="rdfae:caret-range" as="item()?">
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:sequence select="if (ixsl:get($selection, 'rangeCount') ge 1)
             then ixsl:call($selection, 'getRangeAt', [ 0 ]) else ()"/>
     </xsl:function>
 
     <!-- the selection anchor as a node (empty when no range) and its offset (0 then) -->
-    <xsl:function name="local:anchor-node" as="node()?">
-        <xsl:variable name="selection" select="local:selection()"/>
+    <xsl:function name="rdfae:anchor-node" as="node()?">
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:sequence select="if (ixsl:get($selection, 'rangeCount') ge 1)
             then ixsl:get($selection, 'anchorNode') else ()"/>
     </xsl:function>
 
-    <xsl:function name="local:anchor-offset" as="xs:integer">
-        <xsl:variable name="selection" select="local:selection()"/>
+    <xsl:function name="rdfae:anchor-offset" as="xs:integer">
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:sequence select="if (ixsl:get($selection, 'rangeCount') ge 1)
             then xs:integer(ixsl:get($selection, 'anchorOffset')) else 0"/>
     </xsl:function>
 
-    <xsl:function name="local:element" as="element()">
+    <xsl:function name="rdfae:element" as="element()">
         <xsl:param name="name" as="xs:string"/>
         <xsl:sequence select="ixsl:call(ixsl:page(), 'createElement', [ $name ])"/>
     </xsl:function>
 
     <!-- the live value of the first input named $name under $scope (a dialog or form) -->
-    <xsl:function name="local:input-value" as="xs:string">
+    <xsl:function name="rdfae:input-value" as="xs:string">
         <xsl:param name="scope" as="element()"/>
         <xsl:param name="name" as="xs:string"/>
         <xsl:sequence select="string(ixsl:get(($scope//input[@name = $name])[1], 'value'))"/>
     </xsl:function>
 
     <!-- focus the host of $node, then collapse the caret there -->
-    <xsl:template name="local:focus-caret">
+    <xsl:template name="rdfae:focus-caret">
         <xsl:param name="node"/>
         <xsl:param name="offset" as="xs:integer"/>
-        <xsl:for-each select="local:host-of($node)">
-            <xsl:call-template name="local:focus">
+        <xsl:for-each select="rdfae:host-of($node)">
+            <xsl:call-template name="rdfae:focus">
                 <xsl:with-param name="element" select="."/>
             </xsl:call-template>
         </xsl:for-each>
-        <xsl:call-template name="local:place-caret">
+        <xsl:call-template name="rdfae:place-caret">
             <xsl:with-param name="node" select="$node"/>
             <xsl:with-param name="offset" select="$offset"/>
         </xsl:call-template>
     </xsl:template>
 
-    <xsl:template name="local:place-caret">
+    <xsl:template name="rdfae:place-caret">
         <xsl:param name="node"/>
         <xsl:param name="offset" as="xs:integer"/>
-        <xsl:sequence select="ixsl:call(local:selection(), 'collapse',
+        <xsl:sequence select="ixsl:call(rdfae:selection(), 'collapse',
             [ $node, $offset ])[current-date() lt xs:date('2000-01-01')]"/>
     </xsl:template>
 
-    <xsl:template name="local:focus">
+    <xsl:template name="rdfae:focus">
         <xsl:param name="element" as="element()"/>
         <xsl:sequence select="ixsl:call($element, 'focus', [])[current-date() lt xs:date('2000-01-01')]"/>
     </xsl:template>
@@ -299,28 +299,28 @@ version="3.0">
          island reads as the current target. Its onfocusin records it as the
          active block, so toolbar/drag act on it (or its figure) just as for a
          focused editable host -->
-    <xsl:template name="local:select-island">
+    <xsl:template name="rdfae:select-island">
         <xsl:param name="element" as="element()"/>
-        <xsl:sequence select="ixsl:call(local:selection(), 'removeAllRanges', [])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:focus">
+        <xsl:sequence select="ixsl:call(rdfae:selection(), 'removeAllRanges', [])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="rdfae:focus">
             <xsl:with-param name="element" select="$element"/>
         </xsl:call-template>
     </xsl:template>
 
     <!-- land at the start of the next target (down/right): caret at a host after any
          chrome, focus (selection) at an image -->
-    <xsl:template name="local:land-forward">
+    <xsl:template name="rdfae:land-forward">
         <xsl:param name="target" as="element()"/>
         <xsl:choose>
-            <xsl:when test="$target/self::img or local:island($target)">
-                <xsl:call-template name="local:select-island">
+            <xsl:when test="$target/self::img or rdfae:island($target)">
+                <xsl:call-template name="rdfae:select-island">
                     <xsl:with-param name="element" select="$target"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:focus-caret">
+                <xsl:call-template name="rdfae:focus-caret">
                     <xsl:with-param name="node" select="$target"/>
-                    <xsl:with-param name="offset" select="local:chrome-count($target)"/>
+                    <xsl:with-param name="offset" select="rdfae:chrome-count($target)"/>
                 </xsl:call-template>
             </xsl:otherwise>
         </xsl:choose>
@@ -328,19 +328,19 @@ version="3.0">
 
     <!-- land at the end of the previous target (up/left): caret before any trailing
          placeholder <br> at a host, focus (selection) at an image -->
-    <xsl:template name="local:land-backward">
+    <xsl:template name="rdfae:land-backward">
         <xsl:param name="target" as="element()"/>
         <xsl:choose>
-            <xsl:when test="$target/self::img or local:island($target)">
-                <xsl:call-template name="local:select-island">
+            <xsl:when test="$target/self::img or rdfae:island($target)">
+                <xsl:call-template name="rdfae:select-island">
                     <xsl:with-param name="element" select="$target"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:focus">
+                <xsl:call-template name="rdfae:focus">
                     <xsl:with-param name="element" select="$target"/>
                 </xsl:call-template>
-                <xsl:call-template name="local:place-caret">
+                <xsl:call-template name="rdfae:place-caret">
                     <xsl:with-param name="node" select="$target"/>
                     <xsl:with-param name="offset"
                         select="count($target/node()) - count($target/node()[last()][self::br])"/>
@@ -351,24 +351,24 @@ version="3.0">
 
     <!-- ................................ init ................................ -->
 
-    <xsl:template name="local:init-editing">
-        <xsl:for-each select="local:toolbar-host()">
+    <xsl:template name="rdfae:init-editing">
+        <xsl:for-each select="rdfae:toolbar-host()">
             <xsl:result-document href="?." method="ixsl:append-content">
-                <xsl:call-template name="local:render-toolbar"/>
+                <xsl:call-template name="rdfae:render-toolbar"/>
             </xsl:result-document>
         </xsl:for-each>
         <xsl:for-each select="ixsl:page()//body">
             <xsl:result-document href="?." method="ixsl:append-content">
-                <xsl:call-template name="local:render-link-dialog"/>
-                <xsl:call-template name="local:render-figure-dialog"/>
-                <xsl:call-template name="local:render-table-dialog"/>
-                <xsl:call-template name="local:render-slash-menu"/>
+                <xsl:call-template name="rdfae:render-link-dialog"/>
+                <xsl:call-template name="rdfae:render-figure-dialog"/>
+                <xsl:call-template name="rdfae:render-table-dialog"/>
+                <xsl:call-template name="rdfae:render-slash-menu"/>
                 <!-- extension dialogs (opt into teardown via the edit-dialog class) -->
-                <xsl:call-template name="local:render-extra-dialogs"/>
+                <xsl:call-template name="rdfae:render-extra-dialogs"/>
             </xsl:result-document>
         </xsl:for-each>
-        <xsl:for-each select="local:roots()">
-            <xsl:call-template name="local:init-region">
+        <xsl:for-each select="rdfae:roots()">
+            <xsl:call-template name="rdfae:init-region">
                 <xsl:with-param name="region" select="."/>
             </xsl:call-template>
         </xsl:for-each>
@@ -376,7 +376,7 @@ version="3.0">
 
     <!-- per-region bring-up, callable for regions rendered after the initial page
          (hosts that open editable regions lazily init each one through this) -->
-    <xsl:template name="local:init-region">
+    <xsl:template name="rdfae:init-region">
         <xsl:param name="region" as="element()"/>
 
         <!-- boundary-normalize invalid host markup (bare text in blockquote,
@@ -394,14 +394,14 @@ version="3.0">
                 select="serialize($fixed, map{ 'method': 'html' })" object="$region"/>
         </xsl:if>
         <!-- an empty region cannot hold a caret: seed a paragraph (the
-             empty-blockquote idiom in local:init-block) -->
+             empty-blockquote idiom in rdfae:init-block) -->
         <xsl:if test="empty($region/*[not(@data-role)])">
-            <xsl:variable name="p" as="element()" select="local:element('p')"/>
-            <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:variable name="p" as="element()" select="rdfae:element('p')"/>
+            <xsl:sequence select="ixsl:call($p, 'appendChild', [ rdfae:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:sequence select="ixsl:call($region, 'appendChild', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
         <xsl:for-each select="$region/*">
-            <xsl:call-template name="local:init-block">
+            <xsl:call-template name="rdfae:init-block">
                 <xsl:with-param name="block" select="."/>
             </xsl:call-template>
         </xsl:for-each>
@@ -413,16 +413,16 @@ version="3.0">
          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:template name="rdfae:init-block">
         <xsl:param name="block" as="element()"/>
         <xsl:variable name="name" as="xs:string" select="local-name($block)"/>
 
         <xsl:choose>
             <!-- object-block island: an atomic unit - never editable inside, its
                  RDFa definition spans locked, focusable (tabindex, like a block
-                 image) and rendered via the local:render-island hook when it has
+                 image) and rendered via the rdfae:render-island hook when it has
                  no rendering div yet (idempotent across re-inits and undo) -->
-            <xsl:when test="local:island($block)">
+            <xsl:when test="rdfae:island($block)">
                 <xsl:for-each select="$block">
                     <ixsl:remove-attribute name="contenteditable"/>
                     <ixsl:set-attribute name="tabindex" select="'-1'"/>
@@ -430,7 +430,7 @@ version="3.0">
                 <xsl:sequence select="ixsl:call(ixsl:get($block, 'classList'), 'add',
                     [ 'rdfa-editor-island' ])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:if test="empty($block/*[@data-role = 'rendering'])">
-                    <xsl:apply-templates select="$block" mode="local:render-island"/>
+                    <xsl:apply-templates select="$block" mode="rdfae:render-island"/>
                 </xsl:if>
             </xsl:when>
             <!-- text host: inline-only elements, and flow elements without block
@@ -445,19 +445,19 @@ version="3.0">
             <xsl:otherwise>
                 <!-- mixed flow container: stray inline runs get an editable wrapper -->
                 <xsl:if test="cm:flow($name)">
-                    <xsl:call-template name="local:wrap-stray-runs">
+                    <xsl:call-template name="rdfae:wrap-stray-runs">
                         <xsl:with-param name="container" select="$block"/>
                     </xsl:call-template>
                 </xsl:if>
                 <!-- an empty blockquote cannot hold a caret itself: seed a paragraph -->
                 <xsl:if test="$block/self::blockquote and empty($block/*[not(@data-role)])">
-                    <xsl:variable name="p" as="element()" select="local:element('p')"/>
-                    <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+                    <xsl:variable name="p" as="element()" select="rdfae:element('p')"/>
+                    <xsl:sequence select="ixsl:call($p, 'appendChild', [ rdfae:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
                     <xsl:sequence select="ixsl:call($block, 'appendChild', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
                 </xsl:if>
                 <xsl:for-each select="$block/*[not(@data-role)][cm:known(local-name(.))]
                         [not(cm:inline(local-name(.)))]">
-                    <xsl:call-template name="local:init-block">
+                    <xsl:call-template name="rdfae:init-block">
                         <xsl:with-param name="block" select="."/>
                     </xsl:call-template>
                 </xsl:for-each>
@@ -470,19 +470,19 @@ version="3.0">
                 [empty(ancestor::*[@data-role])]">
             <ixsl:set-attribute name="tabindex" select="'-1'"/>
         </xsl:for-each>
-        <xsl:if test="local:draggable-block($block)">
-            <xsl:call-template name="local:inject-chrome">
+        <xsl:if test="rdfae:draggable-block($block)">
+            <xsl:call-template name="rdfae:inject-chrome">
                 <xsl:with-param name="block" select="$block"/>
             </xsl:call-template>
         </xsl:if>
     </xsl:template>
 
-    <!-- the inverse of local:wrap-stray-runs: when a flow container loses its last
+    <!-- the inverse of rdfae:wrap-stray-runs: when a flow container loses its last
          block child, remaining run wrappers unwrap (adjacent runs merge back) and
          the container becomes a plain text host again -->
-    <xsl:template name="local:collapse-container">
+    <xsl:template name="rdfae:collapse-container">
         <xsl:param name="container" as="element()"/>
-        <xsl:if test="not(local:island($container)) and cm:flow(local-name($container))
+        <xsl:if test="not(rdfae:island($container)) and cm:flow(local-name($container))
                 and empty($container/*[not(@data-role)][cm:block(local-name(.)) or self::figcaption]
                     [not(contains-token(@class, 'rdfa-editor-run')
                         and not(@property or @about or @typeof or @resource or @content or @datatype))])">
@@ -497,7 +497,7 @@ version="3.0">
             <xsl:for-each select="$container">
                 <ixsl:set-attribute name="contenteditable" select="'true'"/>
             </xsl:for-each>
-            <xsl:call-template name="local:ensure-placeholder">
+            <xsl:call-template name="rdfae:ensure-placeholder">
                 <xsl:with-param name="host" select="$container"/>
             </xsl:call-template>
         </xsl:if>
@@ -509,7 +509,7 @@ version="3.0">
          like <li>text<ul>...</ul></li> round-trips intact. Blocks, block images,
          figcaption, ephemera and unknown elements stay put. Structural gestures
          (Enter-split, block-type convert) promote a wrapper to a real paragraph -->
-    <xsl:template name="local:wrap-stray-runs">
+    <xsl:template name="rdfae:wrap-stray-runs">
         <xsl:param name="container" as="element()"/>
         <!-- snapshot the child sequence: wrapping mutates the live list -->
         <xsl:variable name="kids" as="node()*" select="$container/node()"/>
@@ -517,7 +517,7 @@ version="3.0">
                 or self::img or self::figcaption or @data-role or not(cm:known(local-name(.)))])">
             <xsl:if test="not(current-grouping-key())
                     and exists(current-group()[self::* or self::text()[normalize-space()]])">
-                <xsl:variable name="wrapper" as="element()" select="local:element('p')"/>
+                <xsl:variable name="wrapper" as="element()" select="rdfae:element('p')"/>
                 <ixsl:set-attribute name="class" select="'rdfa-editor-run'" object="$wrapper"/>
                 <!-- the wrapper IS the run's editable host - callers outside init
                      (insert, indent, outdent) never re-init the container -->
@@ -531,11 +531,11 @@ version="3.0">
     </xsl:template>
 
     <!-- first-child chrome keeps split ranges (caret to end of block) clean of it -->
-    <xsl:template name="local:inject-chrome">
+    <xsl:template name="rdfae:inject-chrome">
         <xsl:param name="block" as="element()"/>
 
         <xsl:if test="empty($block/*[@data-role = 'chrome'])">
-            <xsl:variable name="chrome" as="element()" select="local:element('span')"/>
+            <xsl:variable name="chrome" as="element()" select="rdfae:element('span')"/>
             <ixsl:set-attribute name="data-role" select="'chrome'" object="$chrome"/>
             <ixsl:set-attribute name="class" select="'drag-handle'" object="$chrome"/>
             <ixsl:set-attribute name="contenteditable" select="'false'" object="$chrome"/>
@@ -545,7 +545,7 @@ version="3.0">
         </xsl:if>
     </xsl:template>
 
-    <xsl:template name="local:remove-chrome">
+    <xsl:template name="rdfae:remove-chrome">
         <xsl:param name="block" as="element()"/>
         <xsl:for-each select="$block/*[@data-role = 'chrome']">
             <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
@@ -554,7 +554,7 @@ version="3.0">
 
     <!-- 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:template name="rdfae:tidy-class">
         <xsl:param name="element" as="element()"/>
         <xsl:for-each select="$element[@class = '']">
             <ixsl:remove-attribute name="class"/>
@@ -563,19 +563,19 @@ version="3.0">
 
     <!-- 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
+         paste, list insert) converge here via rdfae: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(.)]
+    <xsl:template name="rdfae:ensure-chrome">
+        <xsl:param name="scope" as="element()*" select="rdfae:roots()"/>
+        <xsl:for-each select="$scope/descendant::*[rdfae:draggable-block(.)]
                 [empty(*[@data-role = 'chrome'])]">
-            <xsl:call-template name="local:inject-chrome">
+            <xsl:call-template name="rdfae:inject-chrome">
                 <xsl:with-param name="block" select="."/>
             </xsl:call-template>
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template name="local:render-toolbar">
+    <xsl:template name="rdfae:render-toolbar">
         <div id="edit-toolbar" class="rdfa-editor-ui" role="toolbar" aria-label="Editing toolbar">
             <div class="tb-group" role="group" aria-label="Block">
                 <select name="block-type" title="Block type" aria-label="Block type">
@@ -600,7 +600,7 @@ version="3.0">
             <div class="tb-group" role="group" aria-label="Insert">
                 <button type="button" class="insert-figure" title="Insert figure" aria-label="Insert figure">&#x1F5BC;</button>
                 <button type="button" class="insert-table" title="Insert table" aria-label="Insert table">&#x229E;</button>
-                <xsl:call-template name="local:render-extra-insert-buttons"/>
+                <xsl:call-template name="rdfae:render-extra-insert-buttons"/>
             </div>
             <div class="tb-group table-ops" role="group" aria-label="Table operations">
                 <button type="button" class="table-op" data-op="row-above" disabled="disabled" title="Insert row above" aria-label="Insert row above">&#x2191;R</button>
@@ -622,13 +622,13 @@ version="3.0">
         </div>
     </xsl:template>
 
-    <!-- caret-contextual toolbar state, riding local:update-breadcrumb (the single
-         caret-awareness choke point) alongside local:sync-table-toolbar: the inline
+    <!-- caret-contextual toolbar state, riding rdfae:update-breadcrumb (the single
+         caret-awareness choke point) alongside rdfae:sync-table-toolbar: the inline
          toggles reflect the elements the caret sits inside (strong/em/link/list) and
          the block-type select follows the current convertible block kind -->
-    <xsl:template name="local:sync-format-toolbar">
-        <xsl:variable name="leaf" as="element()?" select="ixsl:get(local:editor-state(), 'breadcrumbLeaf')"/>
-        <xsl:variable name="host" as="element()?" select="$leaf ! local:host-of(.)"/>
+    <xsl:template name="rdfae:sync-format-toolbar">
+        <xsl:variable name="leaf" as="element()?" select="ixsl:get(rdfae:editor-state(), 'breadcrumbLeaf')"/>
+        <xsl:variable name="host" as="element()?" select="$leaf ! rdfae:host-of(.)"/>
         <!-- inline element toggles: strong / em (mirrors the format-inline click handler) -->
         <xsl:for-each select="id('edit-toolbar', ixsl:page())//button[@data-element]">
             <xsl:variable name="name" as="xs:string" select="string(@data-element)"/>
@@ -652,7 +652,7 @@ version="3.0">
              quotes around an embedded region don't count), disabled where neither
              pressed nor a valid wrap target exists -->
         <xsl:variable name="in-quote" as="xs:boolean"
-            select="exists($host) and exists($leaf/ancestor-or-self::blockquote[exists(local:block-of(.))])"/>
+            select="exists($host) and exists($leaf/ancestor-or-self::blockquote[exists(rdfae:block-of(.))])"/>
         <xsl:variable name="wrappable" as="xs:boolean" select="exists($host[cm:block(local-name(.))]
             [parent::*[contains-token(@class, 'rdfa-editor-content')]
                 or cm:allows-child(local-name(parent::*), 'blockquote')])"/>
@@ -682,29 +682,29 @@ version="3.0">
         <xsl:variable name="key" as="xs:string" select="string(ixsl:get($event, 'key'))"/>
         <xsl:variable name="chord" as="xs:boolean"
             select="(ixsl:get($event, 'ctrlKey') or ixsl:get($event, 'metaKey')) and not(ixsl:get($event, 'altKey'))"/>
-        <xsl:if test="exists(local:block-of(.)) and not(ixsl:get($event, 'isComposing'))">
+        <xsl:if test="exists(rdfae:block-of(.)) and not(ixsl:get($event, 'isComposing'))">
             <xsl:choose>
                 <!-- native undo is replaced by the snapshot history: intercept even on an empty stack -->
                 <xsl:when test="$chord and lower-case($key) = 'z' and not(ixsl:get($event, 'shiftKey'))">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:apply-undo"/>
+                    <xsl:call-template name="rdfae:apply-undo"/>
                 </xsl:when>
                 <xsl:when test="$chord and ((lower-case($key) = 'z' and ixsl:get($event, 'shiftKey'))
                         or (lower-case($key) = 'y' and not(ixsl:get($event, 'shiftKey'))))">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:apply-redo"/>
+                    <xsl:call-template name="rdfae:apply-redo"/>
                 </xsl:when>
                 <!-- Ctrl/Cmd+A escalates Docs-style: native select-all already scopes
                      to the host (stage 1); once the host is fully selected (or the
                      selection already spans hosts) the whole region is selected
                      instead - never the host page -->
                 <xsl:when test="$chord and lower-case($key) = 'a' and not(ixsl:get($event, 'shiftKey'))">
-                    <xsl:variable name="range" select="local:caret-range()"/>
-                    <xsl:if test="local:selection-crosses-hosts()
-                            or (exists($range) and local:host-fully-selected(., $range))">
+                    <xsl:variable name="range" select="rdfae:caret-range()"/>
+                    <xsl:if test="rdfae:selection-crosses-hosts()
+                            or (exists($range) and rdfae:host-fully-selected(., $range))">
                         <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                        <xsl:for-each select="local:root-of(.)">
-                            <xsl:call-template name="local:select-region">
+                        <xsl:for-each select="rdfae:root-of(.)">
+                            <xsl:call-template name="rdfae:select-region">
                                 <xsl:with-param name="region" select="."/>
                             </xsl:call-template>
                         </xsl:for-each>
@@ -717,8 +717,8 @@ version="3.0">
                      when focus is inside them) -->
                 <xsl:when test="$key = 'Escape'">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:hide-overlay"/>
-                    <xsl:call-template name="local:hide-dialogs"/>
+                    <xsl:call-template name="rdfae:hide-overlay"/>
+                    <xsl:call-template name="rdfae:hide-dialogs"/>
                 </xsl:when>
                 <!-- Shift+Up/Down extend the selection block-granularly beyond the
                      host: native extension clamps at host edges, and a cross-host
@@ -726,9 +726,9 @@ version="3.0">
                      (focus not at the facing edge) they stay native line-wise -->
                 <xsl:when test="ixsl:get($event, 'shiftKey') and not(ixsl:get($event, 'altKey'))
                         and $key = ('ArrowUp', 'ArrowDown')
-                        and local:shift-arrow-extends(., if ($key = 'ArrowUp') then 'up' else 'down')">
+                        and rdfae:shift-arrow-extends(., if ($key = 'ArrowUp') then 'up' else 'down')">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:extend-selection-block-wise">
+                    <xsl:call-template name="rdfae:extend-selection-block-wise">
                         <xsl:with-param name="direction" select="if ($key = 'ArrowUp') then 'up' else 'down'"/>
                     </xsl:call-template>
                 </xsl:when>
@@ -739,19 +739,19 @@ version="3.0">
                      suppressed so the selection cannot be half-edited; plain arrows
                      stay native (they collapse it) and the chord cases above keep
                      copy/cut native (canonical copy intercepts at the event level) -->
-                <xsl:when test="local:selection-crosses-hosts()">
+                <xsl:when test="rdfae:selection-crosses-hosts()">
                     <xsl:choose>
                         <xsl:when test="$key = ('Backspace', 'Delete')">
                             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                            <xsl:call-template name="local:delete-cross-host-selection"/>
+                            <xsl:call-template name="rdfae:delete-cross-host-selection"/>
                         </xsl:when>
                         <xsl:when test="string-length($key) = 1">
                             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                            <xsl:call-template name="local:delete-cross-host-selection"/>
-                            <xsl:call-template name="local:insert-text-at-caret">
+                            <xsl:call-template name="rdfae:delete-cross-host-selection"/>
+                            <xsl:call-template name="rdfae:insert-text-at-caret">
                                 <xsl:with-param name="text" select="$key"/>
                             </xsl:call-template>
-                            <xsl:call-template name="local:after-mutation"/>
+                            <xsl:call-template name="rdfae:after-mutation"/>
                         </xsl:when>
                         <xsl:when test="$key = ('Enter', 'Tab')">
                             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
@@ -763,48 +763,48 @@ version="3.0">
                 <xsl:when test="ixsl:get($event, 'altKey') and $key = ('ArrowUp', 'ArrowDown')">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
                     <xsl:variable name="host" as="element()" select="."/>
-                    <xsl:variable name="block" as="element()?" select="local:block-of(.)"/>
+                    <xsl:variable name="block" as="element()?" select="rdfae:block-of(.)"/>
                     <xsl:for-each select="if ($key = 'ArrowUp')
                             then $block/preceding-sibling::*[1] else $block/following-sibling::*[1]">
-                        <xsl:call-template name="local:push-undo"/>
+                        <xsl:call-template name="rdfae:push-undo"/>
                         <xsl:sequence select="ixsl:call(., if ($key = 'ArrowUp') then 'before' else 'after',
                             [ $block ])[current-date() lt xs:date('2000-01-01')]"/>
                     </xsl:for-each>
                     <!-- moving the focused block blurs it -->
-                    <xsl:call-template name="local:focus">
+                    <xsl:call-template name="rdfae:focus">
                         <xsl:with-param name="element" select="$host"/>
                     </xsl:call-template>
-                    <xsl:call-template name="local:after-mutation"/>
+                    <xsl:call-template name="rdfae:after-mutation"/>
                 </xsl:when>
                 <!-- Tab indents/outdents list items and walks table cells; the
                      innermost context wins (li inside a cell indents, a table
                      nested in an item traverses); native Tab everywhere else -->
                 <xsl:when test="$key = 'Tab'">
-                    <xsl:variable name="item" as="element()?" select="local:item-of(.)"/>
+                    <xsl:variable name="item" as="element()?" select="rdfae:item-of(.)"/>
                     <!-- clamped at the region root: a host-page cell wrapping an
                          embedded region must never be traversed or grown -->
                     <xsl:variable name="cell" as="element()?"
                         select="ancestor-or-self::*[self::td or self::th or self::caption]
-                            [exists(local:block-of(.))][1]"/>
+                            [exists(rdfae:block-of(.))][1]"/>
                     <xsl:choose>
                         <xsl:when test="exists($item) and (empty($cell)
                                 or exists($item/ancestor::* intersect $cell))">
                             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
                             <xsl:choose>
                                 <xsl:when test="ixsl:get($event, 'shiftKey')">
-                                    <xsl:call-template name="local:list-outdent">
+                                    <xsl:call-template name="rdfae:list-outdent">
                                         <xsl:with-param name="item" select="$item"/>
                                     </xsl:call-template>
                                 </xsl:when>
                                 <xsl:otherwise>
-                                    <xsl:call-template name="local:list-indent">
+                                    <xsl:call-template name="rdfae:list-indent">
                                         <xsl:with-param name="item" select="$item"/>
                                     </xsl:call-template>
                                 </xsl:otherwise>
                             </xsl:choose>
                         </xsl:when>
                         <xsl:when test="exists($cell)">
-                            <xsl:call-template name="local:table-tab">
+                            <xsl:call-template name="rdfae:table-tab">
                                 <xsl:with-param name="host" select="$cell"/>
                                 <xsl:with-param name="event" select="$event"/>
                                 <xsl:with-param name="shift" select="ixsl:get($event, 'shiftKey') = true()"/>
@@ -816,28 +816,28 @@ version="3.0">
                 <!-- arrow keys cross block boundaries: each block is its own
                      contenteditable island, so the browser stops at its edges.
                      Block-level (figure) images are non-editable but still navigable -
-                     local:nav-targets includes them and local:land-* selects them
+                     rdfae:nav-targets includes them and rdfae:land-* selects them
                      (focus) rather than placing a caret -->
                 <xsl:when test="$key = ('ArrowDown', 'ArrowRight', 'ArrowUp', 'ArrowLeft')
                         and not(ixsl:get($event, 'shiftKey')) and not(ixsl:get($event, 'altKey'))">
-                    <xsl:variable name="selection" select="local:selection()"/>
+                    <xsl:variable name="selection" select="rdfae:selection()"/>
                     <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1 and ixsl:get($selection, 'isCollapsed')">
-                        <xsl:variable name="range" select="local:caret-range()"/>
+                        <xsl:variable name="range" select="rdfae:caret-range()"/>
                         <xsl:variable name="host" as="element()" select="."/>
-                        <xsl:variable name="targets" as="element()*" select="local:nav-targets(.)"/>
+                        <xsl:variable name="targets" as="element()*" select="rdfae:nav-targets(.)"/>
                         <xsl:choose>
-                            <xsl:when test="$key = ('ArrowDown', 'ArrowRight') and local:at-end($host, $range)">
+                            <xsl:when test="$key = ('ArrowDown', 'ArrowRight') and rdfae:at-end($host, $range)">
                                 <xsl:for-each select="($targets[. &gt;&gt; $host])[1]">
                                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                                    <xsl:call-template name="local:land-forward">
+                                    <xsl:call-template name="rdfae:land-forward">
                                         <xsl:with-param name="target" select="."/>
                                     </xsl:call-template>
                                 </xsl:for-each>
                             </xsl:when>
-                            <xsl:when test="$key = ('ArrowUp', 'ArrowLeft') and local:at-start($host, $range)">
+                            <xsl:when test="$key = ('ArrowUp', 'ArrowLeft') and rdfae:at-start($host, $range)">
                                 <xsl:for-each select="($targets[. &lt;&lt; $host])[last()]">
                                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                                    <xsl:call-template name="local:land-backward">
+                                    <xsl:call-template name="rdfae:land-backward">
                                         <xsl:with-param name="target" select="."/>
                                     </xsl:call-template>
                                 </xsl:for-each>
@@ -847,12 +847,12 @@ version="3.0">
                     </xsl:if>
                 </xsl:when>
                 <xsl:when test="$key = ('Enter', 'Backspace')">
-                    <xsl:variable name="selection" select="local:selection()"/>
+                    <xsl:variable name="selection" select="rdfae:selection()"/>
                     <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
-                        <xsl:variable name="range" select="local:caret-range()"/>
+                        <xsl:variable name="range" select="rdfae:caret-range()"/>
                         <xsl:choose>
                             <xsl:when test="$key = 'Enter'">
-                                <xsl:call-template name="local:handle-enter">
+                                <xsl:call-template name="rdfae:handle-enter">
                                     <xsl:with-param name="host" select="."/>
                                     <xsl:with-param name="event" select="$event"/>
                                     <xsl:with-param name="range" select="$range"/>
@@ -860,7 +860,7 @@ version="3.0">
                             </xsl:when>
                             <!-- Backspace intercepts only collapsed carets; everything else stays native (B1) -->
                             <xsl:when test="ixsl:get($selection, 'isCollapsed')">
-                                <xsl:call-template name="local:handle-backspace">
+                                <xsl:call-template name="rdfae:handle-backspace">
                                     <xsl:with-param name="host" select="."/>
                                     <xsl:with-param name="event" select="$event"/>
                                     <xsl:with-param name="range" select="$range"/>
@@ -887,12 +887,12 @@ version="3.0">
             <xsl:choose>
                 <xsl:when test="$chord and lower-case($key) = 'z' and not(ixsl:get($event, 'shiftKey'))">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:apply-undo"/>
+                    <xsl:call-template name="rdfae:apply-undo"/>
                 </xsl:when>
                 <xsl:when test="$chord and ((lower-case($key) = 'z' and ixsl:get($event, 'shiftKey'))
                         or (lower-case($key) = 'y' and not(ixsl:get($event, 'shiftKey'))))">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:apply-redo"/>
+                    <xsl:call-template name="rdfae:apply-redo"/>
                 </xsl:when>
                 <!-- Docs-style: select-all from the page background selects editor
                      content, never the page - the swept region when a cross-host
@@ -900,41 +900,41 @@ version="3.0">
                      last focused host, first region). Native page select-all only
                      when no editable region exists at all -->
                 <xsl:when test="$chord and lower-case($key) = 'a' and not(ixsl:get($event, 'shiftKey'))">
-                    <xsl:variable name="range" select="local:caret-range()"/>
+                    <xsl:variable name="range" select="rdfae:caret-range()"/>
                     <xsl:variable name="region" as="element()?" select="
-                        if (local:selection-crosses-hosts())
-                        then (local:root-of(ixsl:get($range, 'startContainer')),
-                            local:roots()[ixsl:call($range, 'intersectsNode', [ . ])])[1]
-                        else local:active-root()"/>
+                        if (rdfae:selection-crosses-hosts())
+                        then (rdfae:root-of(ixsl:get($range, 'startContainer')),
+                            rdfae:roots()[ixsl:call($range, 'intersectsNode', [ . ])])[1]
+                        else rdfae:active-root()"/>
                     <xsl:for-each select="$region">
                         <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                        <xsl:call-template name="local:select-region">
+                        <xsl:call-template name="rdfae:select-region">
                             <xsl:with-param name="region" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
                 </xsl:when>
                 <xsl:when test="not($chord) and $key = ('Backspace', 'Delete')
-                        and local:selection-crosses-hosts()">
+                        and rdfae:selection-crosses-hosts()">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:delete-cross-host-selection"/>
+                    <xsl:call-template name="rdfae:delete-cross-host-selection"/>
                 </xsl:when>
                 <!-- type-to-replace works from the page background too: the delete
                      machine focuses a host, the character lands at its caret -->
                 <xsl:when test="not($chord) and string-length($key) = 1
-                        and local:selection-crosses-hosts()">
+                        and rdfae:selection-crosses-hosts()">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:delete-cross-host-selection"/>
-                    <xsl:call-template name="local:insert-text-at-caret">
+                    <xsl:call-template name="rdfae:delete-cross-host-selection"/>
+                    <xsl:call-template name="rdfae:insert-text-at-caret">
                         <xsl:with-param name="text" select="$key"/>
                     </xsl:call-template>
-                    <xsl:call-template name="local:after-mutation"/>
+                    <xsl:call-template name="rdfae:after-mutation"/>
                 </xsl:when>
                 <!-- a background-ended sweep leaves focus on body: Shift+Up/Down keep
                      extending the cross-host selection block-wise from here too -->
                 <xsl:when test="not($chord) and ixsl:get($event, 'shiftKey') and not(ixsl:get($event, 'altKey'))
-                        and $key = ('ArrowUp', 'ArrowDown') and local:selection-crosses-hosts()">
+                        and $key = ('ArrowUp', 'ArrowDown') and rdfae:selection-crosses-hosts()">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:extend-selection-block-wise">
+                    <xsl:call-template name="rdfae:extend-selection-block-wise">
                         <xsl:with-param name="direction" select="if ($key = 'ArrowUp') then 'up' else 'down'"/>
                     </xsl:call-template>
                 </xsl:when>
@@ -948,7 +948,7 @@ version="3.0">
          text-block crossing, and Backspace/Delete removes it (an image goes with
          its figure). Since an island can't hold a caret, these keys are the only
          way keyboard editing reaches or leaves it -->
-    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//*[self::img or local:island(.)]" mode="ixsl:onkeydown">
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//*[self::img or rdfae:island(.)]" mode="ixsl:onkeydown">
         <xsl:variable name="event" select="ixsl:event()"/>
         <xsl:variable name="key" as="xs:string" select="string(ixsl:get($event, 'key'))"/>
         <!-- Ctrl/Cmd+A on a selected island selects its whole region: the island is
@@ -958,8 +958,8 @@ version="3.0">
                 and not(ixsl:get($event, 'altKey')) and not(ixsl:get($event, 'shiftKey'))
                 and lower-case($key) = 'a'">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:for-each select="local:root-of(.)">
-                <xsl:call-template name="local:select-region">
+            <xsl:for-each select="rdfae:root-of(.)">
+                <xsl:call-template name="rdfae:select-region">
                     <xsl:with-param name="region" select="."/>
                 </xsl:call-template>
             </xsl:for-each>
@@ -972,12 +972,12 @@ version="3.0">
             <xsl:choose>
                 <xsl:when test="lower-case($key) = 'z' and not(ixsl:get($event, 'shiftKey'))">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:apply-undo"/>
+                    <xsl:call-template name="rdfae:apply-undo"/>
                 </xsl:when>
                 <xsl:when test="(lower-case($key) = 'z' and ixsl:get($event, 'shiftKey'))
                         or (lower-case($key) = 'y' and not(ixsl:get($event, 'shiftKey')))">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:apply-redo"/>
+                    <xsl:call-template name="rdfae:apply-redo"/>
                 </xsl:when>
                 <xsl:otherwise/>
             </xsl:choose>
@@ -986,12 +986,12 @@ version="3.0">
                 and not(ixsl:get($event, 'shiftKey')) and not(ixsl:get($event, 'altKey'))
                 and not(ixsl:get($event, 'ctrlKey')) and not(ixsl:get($event, 'metaKey'))">
             <xsl:variable name="island" as="element()" select="."/>
-            <xsl:variable name="targets" as="element()*" select="local:nav-targets(.)"/>
+            <xsl:variable name="targets" as="element()*" select="rdfae:nav-targets(.)"/>
             <xsl:choose>
                 <xsl:when test="$key = ('ArrowDown', 'ArrowRight')">
                     <xsl:for-each select="($targets[. &gt;&gt; $island])[1]">
                         <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                        <xsl:call-template name="local:land-forward">
+                        <xsl:call-template name="rdfae:land-forward">
                             <xsl:with-param name="target" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
@@ -999,7 +999,7 @@ version="3.0">
                 <xsl:when test="$key = ('ArrowUp', 'ArrowLeft')">
                     <xsl:for-each select="($targets[. &lt;&lt; $island])[last()]">
                         <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                        <xsl:call-template name="local:land-backward">
+                        <xsl:call-template name="rdfae:land-backward">
                             <xsl:with-param name="target" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
@@ -1012,44 +1012,44 @@ version="3.0">
                      for Delete -->
                 <!-- with a cross-host selection painted (Ctrl+A from the island), the
                      selection wins over the island: the delete machine runs instead -->
-                <xsl:when test="$key = ('Backspace', 'Delete') and local:selection-crosses-hosts()">
+                <xsl:when test="$key = ('Backspace', 'Delete') and rdfae:selection-crosses-hosts()">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:call-template name="local:delete-cross-host-selection"/>
+                    <xsl:call-template name="rdfae:delete-cross-host-selection"/>
                 </xsl:when>
                 <xsl:when test="$key = ('Backspace', 'Delete')">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
                     <xsl:variable name="victim" as="element()"
-                        select="($island/ancestor-or-self::figure[exists(local:block-of(.))][1], $island)[1]"/>
+                        select="($island/ancestor-or-self::figure[exists(rdfae:block-of(.))][1], $island)[1]"/>
                     <xsl:variable name="container" as="element()?" select="$victim/parent::*"/>
                     <xsl:variable name="outside" as="element()*"
                         select="$targets[empty(. intersect $victim/descendant-or-self::*)]"/>
                     <xsl:variable name="prev" as="element()?" select="($outside[. &lt;&lt; $victim])[last()]"/>
                     <xsl:variable name="next" as="element()?" select="($outside[. &gt;&gt; $victim])[1]"/>
-                    <xsl:call-template name="local:push-undo"/>
+                    <xsl:call-template name="rdfae:push-undo"/>
                     <xsl:sequence select="ixsl:call($victim, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                    <ixsl:set-property name="activeBlock" select="()" object="rdfae:editor-state()"/>
                     <!-- a mixed container that just lost its only nested block
                          becomes a plain text host again -->
                     <xsl:for-each select="$container[not(contains-token(@class, 'rdfa-editor-content'))]">
-                        <xsl:call-template name="local:collapse-container">
+                        <xsl:call-template name="rdfae:collapse-container">
                             <xsl:with-param name="container" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
                     <xsl:for-each select="if ($key = 'Backspace') then ($prev, $next)[1] else ($next, $prev)[1]">
                         <xsl:choose>
                             <xsl:when test=". is $prev">
-                                <xsl:call-template name="local:land-backward">
+                                <xsl:call-template name="rdfae:land-backward">
                                     <xsl:with-param name="target" select="."/>
                                 </xsl:call-template>
                             </xsl:when>
                             <xsl:otherwise>
-                                <xsl:call-template name="local:land-forward">
+                                <xsl:call-template name="rdfae:land-forward">
                                     <xsl:with-param name="target" select="."/>
                                 </xsl:call-template>
                             </xsl:otherwise>
                         </xsl:choose>
                     </xsl:for-each>
-                    <xsl:call-template name="local:after-mutation"/>
+                    <xsl:call-template name="rdfae:after-mutation"/>
                 </xsl:when>
                 <xsl:otherwise/>
             </xsl:choose>
@@ -1059,20 +1059,20 @@ version="3.0">
     <!-- a focused block image or object-block island becomes the active block, so
          toolbar/breadcrumb resolve to it (or its figure) just as they do for a
          focused editable host (mirrors the contenteditable onfocusin above) -->
-    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//*[self::img or local:island(.)]" mode="ixsl:onfocusin">
+    <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//*[self::img or rdfae:island(.)]" mode="ixsl:onfocusin">
         <xsl:if test="empty(ancestor::*[@contenteditable = 'true'])">
-            <ixsl:set-property name="activeBlock" select="." object="local:editor-state()"/>
-            <xsl:call-template name="local:update-breadcrumb"/>
+            <ixsl:set-property name="activeBlock" select="." object="rdfae:editor-state()"/>
+            <xsl:call-template name="rdfae:update-breadcrumb"/>
         </xsl:if>
     </xsl:template>
 
-    <xsl:template name="local:handle-enter">
+    <xsl:template name="rdfae:handle-enter">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="event"/>
         <xsl:param name="range"/>
 
         <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:push-undo">
+        <xsl:call-template name="rdfae:push-undo">
             <xsl:with-param name="host" select="$host"/>
         </xsl:call-template>
         <xsl:if test="not(ixsl:get($range, 'collapsed'))">
@@ -1082,29 +1082,29 @@ version="3.0">
         <xsl:choose>
             <!-- E1: Shift+Enter = line break -->
             <xsl:when test="ixsl:get($event, 'shiftKey')">
-                <xsl:call-template name="local:insert-at-caret">
-                    <xsl:with-param name="node" select="local:element('br')"/>
+                <xsl:call-template name="rdfae:insert-at-caret">
+                    <xsl:with-param name="node" select="rdfae:element('br')"/>
                     <xsl:with-param name="range" select="$range"/>
                 </xsl:call-template>
             </xsl:when>
             <!-- E2: line structure inside pre is text -->
             <xsl:when test="$host/self::pre">
-                <xsl:call-template name="local:insert-at-caret">
+                <xsl:call-template name="rdfae:insert-at-caret">
                     <xsl:with-param name="node" select="ixsl:call(ixsl:page(), 'createTextNode', [ '&#10;' ])"/>
                     <xsl:with-param name="range" select="$range"/>
                 </xsl:call-template>
             </xsl:when>
             <!-- E2b: Enter in a table cell steps down the column, growing the table -->
             <xsl:when test="$host/self::td or $host/self::th">
-                <xsl:call-template name="local:table-enter">
+                <xsl:call-template name="rdfae:table-enter">
                     <xsl:with-param name="host" select="$host"/>
                 </xsl:call-template>
             </xsl:when>
             <!-- E4a: Enter on the empty last item of a NESTED list outdents one
                  level (progressive: each press lifts it until it reaches the top) -->
-            <xsl:when test="$host/self::li and local:block-text($host) = ''
+            <xsl:when test="$host/self::li and rdfae:block-text($host) = ''
                     and empty($host/following-sibling::li) and exists($host/parent::*/parent::li)">
-                <xsl:call-template name="local:list-outdent">
+                <xsl:call-template name="rdfae:list-outdent">
                     <xsl:with-param name="item" select="$host"/>
                 </xsl:call-template>
             </xsl:when>
@@ -1112,9 +1112,9 @@ version="3.0">
                  anchors after the list BEFORE anything is removed (a sole-item list
                  disappears with it), so the exit lands where the list was: at the
                  region for top-level lists, inside the cell/quote for nested ones -->
-            <xsl:when test="$host/self::li and local:block-text($host) = '' and empty($host/following-sibling::li)">
+            <xsl:when test="$host/self::li and rdfae:block-text($host) = '' and empty($host/following-sibling::li)">
                 <xsl:variable name="list" as="element()" select="$host/parent::*"/>
-                <xsl:call-template name="local:insert-empty-paragraph">
+                <xsl:call-template name="rdfae:insert-empty-paragraph">
                     <xsl:with-param name="after" select="$list"/>
                 </xsl:call-template>
                 <xsl:sequence select="ixsl:call($host, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
@@ -1125,61 +1125,61 @@ version="3.0">
             <!-- E6: Enter in a figure/table caption starts a paragraph after the
                  figure/table itself - which may be nested inside an item or cell -->
             <xsl:when test="$host/self::figcaption or $host/self::caption">
-                <xsl:call-template name="local:insert-empty-paragraph">
+                <xsl:call-template name="rdfae:insert-empty-paragraph">
                     <xsl:with-param name="after" select="$host/parent::*"/>
                 </xsl:call-template>
             </xsl:when>
             <!-- E3/E5/E7/E8: split, never through an annotation (the split point moves
                  behind the outermost RDFa-attributed ancestor so the graph is unchanged) -->
             <xsl:otherwise>
-                <xsl:for-each select="local:enclosing-annotation(ixsl:get($range, 'startContainer'), $host)">
+                <xsl:for-each select="rdfae:enclosing-annotation(ixsl:get($range, 'startContainer'), $host)">
                     <xsl:sequence select="ixsl:call($range, 'setStartAfter', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
                     <xsl:sequence select="ixsl:call($range, 'collapse', [ true() ])[current-date() lt xs:date('2000-01-01')]"/>
                 </xsl:for-each>
-                <xsl:call-template name="local:split-block">
+                <xsl:call-template name="rdfae:split-block">
                     <xsl:with-param name="host" select="$host"/>
                     <xsl:with-param name="range" select="$range"/>
                 </xsl:call-template>
             </xsl:otherwise>
         </xsl:choose>
-        <xsl:call-template name="local:after-mutation"/>
+        <xsl:call-template name="rdfae:after-mutation"/>
     </xsl:template>
 
     <!-- a fresh empty paragraph after a block: the <br> is the browser-standard caret
          placeholder for empty editable elements (dropped again by canonical-xhtml.xsl) -->
-    <xsl:template name="local:insert-empty-paragraph">
+    <xsl:template name="rdfae:insert-empty-paragraph">
         <xsl:param name="after" as="element()?"/>
 
-        <xsl:variable name="p" as="element()" select="local:element('p')"/>
-        <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:variable name="p" as="element()" select="rdfae:element('p')"/>
+        <xsl:sequence select="ixsl:call($p, 'appendChild', [ rdfae:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
         <xsl:choose>
             <xsl:when test="exists($after)">
                 <xsl:sequence select="ixsl:call($after, 'after', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:for-each select="local:active-root()">
+                <xsl:for-each select="rdfae:active-root()">
                     <xsl:sequence select="ixsl:call(., 'appendChild', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
                 </xsl:for-each>
             </xsl:otherwise>
         </xsl:choose>
         <ixsl:set-attribute name="contenteditable" select="'true'" object="$p"/>
         <xsl:if test="$p/parent::*[contains-token(@class, 'rdfa-editor-content')]">
-            <xsl:call-template name="local:inject-chrome">
+            <xsl:call-template name="rdfae:inject-chrome">
                 <xsl:with-param name="block" select="$p"/>
             </xsl:call-template>
         </xsl:if>
-        <xsl:call-template name="local:focus-caret">
+        <xsl:call-template name="rdfae:focus-caret">
     <xsl:with-param name="node" select="$p"/>
-    <xsl:with-param name="offset" select="local:chrome-count($p)"/>
+    <xsl:with-param name="offset" select="rdfae:chrome-count($p)"/>
 </xsl:call-template>
     </xsl:template>
 
-    <xsl:template name="local:insert-at-caret">
+    <xsl:template name="rdfae:insert-at-caret">
         <xsl:param name="node"/>
         <xsl:param name="range"/>
 
         <xsl:sequence select="ixsl:call($range, 'insertNode', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:place-caret">
+        <xsl:call-template name="rdfae:place-caret">
             <xsl:with-param name="node" select="ixsl:get($node, 'parentNode')"/>
             <xsl:with-param name="offset" select="count($node/preceding-sibling::node()) + 1"/>
         </xsl:call-template>
@@ -1190,7 +1190,7 @@ version="3.0">
          Splitting a run wrapper promotes it: the marker class comes off the first
          half (the fresh second half never has it) - a structural edit makes both
          halves real paragraphs -->
-    <xsl:template name="local:split-block">
+    <xsl:template name="rdfae:split-block">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="range"/>
 
@@ -1207,30 +1207,30 @@ version="3.0">
         <!-- chrome is a top-level affordance: nested hosts (li, quote paragraphs,
              cell blocks) never carry a drag handle -->
         <xsl:if test="$host/parent::*[contains-token(@class, 'rdfa-editor-content')]">
-            <xsl:call-template name="local:inject-chrome">
+            <xsl:call-template name="rdfae:inject-chrome">
                 <xsl:with-param name="block" select="$new"/>
             </xsl:call-template>
         </xsl:if>
         <!-- a split at either extreme leaves one empty half -->
-        <xsl:call-template name="local:ensure-placeholder">
+        <xsl:call-template name="rdfae:ensure-placeholder">
             <xsl:with-param name="host" select="$host"/>
         </xsl:call-template>
-        <xsl:call-template name="local:ensure-placeholder">
+        <xsl:call-template name="rdfae:ensure-placeholder">
             <xsl:with-param name="host" select="$new"/>
         </xsl:call-template>
-        <xsl:call-template name="local:focus-caret">
+        <xsl:call-template name="rdfae:focus-caret">
     <xsl:with-param name="node" select="$new"/>
-    <xsl:with-param name="offset" select="local:chrome-count($new)"/>
+    <xsl:with-param name="offset" select="rdfae:chrome-count($new)"/>
 </xsl:call-template>
     </xsl:template>
 
-    <xsl:template name="local:handle-backspace">
+    <xsl:template name="rdfae:handle-backspace">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="event"/>
         <xsl:param name="range"/>
 
         <!-- B1: anywhere but the block start stays native -->
-        <xsl:if test="local:at-start($host, $range)">
+        <xsl:if test="rdfae:at-start($host, $range)">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:choose>
                 <!-- B4: a list item merges into the visually preceding line - the
@@ -1238,20 +1238,20 @@ version="3.0">
                      holding a nested list); a previous item ending in a composite
                      is a hard boundary (merge-host-in returns nothing - inert) -->
                 <xsl:when test="$host/self::li and exists($host/preceding-sibling::li)">
-                    <xsl:for-each select="local:merge-host-in($host/preceding-sibling::li[1])">
-                        <xsl:call-template name="local:push-undo">
+                    <xsl:for-each select="rdfae:merge-host-in($host/preceding-sibling::li[1])">
+                        <xsl:call-template name="rdfae:push-undo">
                             <xsl:with-param name="host" select="$host"/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:merge-into-previous">
+                        <xsl:call-template name="rdfae:merge-into-previous">
                             <xsl:with-param name="host" select="$host"/>
                             <xsl:with-param name="prev" select="."/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:after-mutation"/>
+                        <xsl:call-template name="rdfae:after-mutation"/>
                     </xsl:for-each>
                 </xsl:when>
                 <!-- B4b: the first item of a NESTED list outdents (mirrors Shift+Tab) -->
                 <xsl:when test="$host/self::li and exists($host/parent::*/parent::li)">
-                    <xsl:call-template name="local:list-outdent">
+                    <xsl:call-template name="rdfae:list-outdent">
                         <xsl:with-param name="item" select="$host"/>
                     </xsl:call-template>
                 </xsl:when>
@@ -1261,36 +1261,36 @@ version="3.0">
                      host - composites (table, figure) stay hard boundaries -->
                 <xsl:when test="$host/self::li
                         and $host/parent::*/parent::*[not(contains-token(@class, 'rdfa-editor-content'))]
-                        and exists(local:merge-host-in($host/parent::*/preceding-sibling::*[not(@data-role)][1]))">
+                        and exists(rdfae:merge-host-in($host/parent::*/preceding-sibling::*[not(@data-role)][1]))">
                     <xsl:variable name="list" as="element()" select="$host/parent::*"/>
                     <xsl:variable name="container" as="element()" select="$list/parent::*"/>
                     <!-- the caret target must survive the merge AND the collapse
                          unwrap (text-node references ride through both moves) -->
                     <xsl:variable name="first-text" select="($host//text()[not(ancestor::*[@data-role])])[1]"/>
-                    <xsl:call-template name="local:push-undo">
+                    <xsl:call-template name="rdfae:push-undo">
                         <xsl:with-param name="host" select="$host"/>
                     </xsl:call-template>
-                    <xsl:call-template name="local:merge-into-previous">
+                    <xsl:call-template name="rdfae:merge-into-previous">
                         <xsl:with-param name="host" select="$host"/>
-                        <xsl:with-param name="prev" select="local:merge-host-in(
+                        <xsl:with-param name="prev" select="rdfae:merge-host-in(
                             $list/preceding-sibling::*[not(@data-role)][1])"/>
                     </xsl:call-template>
                     <xsl:if test="empty($list/li)">
                         <xsl:sequence select="ixsl:call($list, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
                     </xsl:if>
-                    <xsl:call-template name="local:collapse-container">
+                    <xsl:call-template name="rdfae:collapse-container">
                         <xsl:with-param name="container" select="$container"/>
                     </xsl:call-template>
                     <xsl:choose>
                         <xsl:when test="exists($first-text)">
-                            <xsl:call-template name="local:focus-caret">
+                            <xsl:call-template name="rdfae:focus-caret">
                                 <xsl:with-param name="node" select="$first-text"/>
                                 <xsl:with-param name="offset" select="0"/>
                             </xsl:call-template>
                         </xsl:when>
                         <xsl:otherwise>
-                            <xsl:for-each select="local:last-host-in($container)">
-                                <xsl:call-template name="local:focus-caret">
+                            <xsl:for-each select="rdfae:last-host-in($container)">
+                                <xsl:call-template name="rdfae:focus-caret">
                                     <xsl:with-param name="node" select="."/>
                                     <xsl:with-param name="offset"
                                         select="count(node()) - count(node()[last()][self::br])"/>
@@ -1298,7 +1298,7 @@ version="3.0">
                             </xsl:for-each>
                         </xsl:otherwise>
                     </xsl:choose>
-                    <xsl:call-template name="local:after-mutation"/>
+                    <xsl:call-template name="rdfae:after-mutation"/>
                 </xsl:when>
                 <!-- B5: the first item of a top-level list (or of a list with
                      nothing mergeable before it) is inert -->
@@ -1311,14 +1311,14 @@ version="3.0">
                     <xsl:choose>
                         <!-- B2: text blocks merge -->
                         <xsl:when test="$prev[self::p or self::h1 or self::h2 or self::h3]">
-                            <xsl:call-template name="local:push-undo">
+                            <xsl:call-template name="rdfae:push-undo">
                                 <xsl:with-param name="host" select="$host"/>
                             </xsl:call-template>
-                            <xsl:call-template name="local:merge-into-previous">
+                            <xsl:call-template name="rdfae:merge-into-previous">
                                 <xsl:with-param name="host" select="$host"/>
                                 <xsl:with-param name="prev" select="$prev"/>
                             </xsl:call-template>
-                            <xsl:call-template name="local:after-mutation"/>
+                            <xsl:call-template name="rdfae:after-mutation"/>
                         </xsl:when>
                         <!-- B2b: a preceding non-composite container (blockquote,
                              list) merges into its last editable host, never into
@@ -1326,22 +1326,22 @@ version="3.0">
                              tables and figures stay hard boundaries - B3 - even
                              nested at the container's tail: merge-host-in) -->
                         <xsl:when test="$prev[self::blockquote or self::ul or self::ol or self::dl]">
-                            <xsl:for-each select="local:merge-host-in($prev)">
-                                <xsl:call-template name="local:push-undo">
+                            <xsl:for-each select="rdfae:merge-host-in($prev)">
+                                <xsl:call-template name="rdfae:push-undo">
                                     <xsl:with-param name="host" select="$host"/>
                                 </xsl:call-template>
-                                <xsl:call-template name="local:merge-into-previous">
+                                <xsl:call-template name="rdfae:merge-into-previous">
                                     <xsl:with-param name="host" select="$host"/>
                                     <xsl:with-param name="prev" select="."/>
                                 </xsl:call-template>
-                                <xsl:call-template name="local:after-mutation"/>
+                                <xsl:call-template name="rdfae:after-mutation"/>
                             </xsl:for-each>
                         </xsl:when>
                         <!-- B7: the first block of a blockquote exits upward - it
                              moves before the quote; an emptied quote is removed -->
                         <xsl:when test="empty($prev[not(@data-role)]) and $host/parent::blockquote">
                             <xsl:variable name="quote" as="element()" select="$host/parent::blockquote"/>
-                            <xsl:call-template name="local:push-undo">
+                            <xsl:call-template name="rdfae:push-undo">
                                 <xsl:with-param name="host" select="$host"/>
                             </xsl:call-template>
                             <xsl:sequence select="ixsl:call($quote, 'before', [ $host ])[current-date() lt xs:date('2000-01-01')]"/>
@@ -1349,25 +1349,25 @@ version="3.0">
                                 <xsl:sequence select="ixsl:call($quote, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
                             </xsl:if>
                             <xsl:if test="$host/parent::*[contains-token(@class, 'rdfa-editor-content')]">
-                                <xsl:call-template name="local:inject-chrome">
+                                <xsl:call-template name="rdfae:inject-chrome">
                                     <xsl:with-param name="block" select="$host"/>
                                 </xsl:call-template>
                             </xsl:if>
-                            <xsl:call-template name="local:focus-caret">
+                            <xsl:call-template name="rdfae:focus-caret">
                                 <xsl:with-param name="node" select="$host"/>
-                                <xsl:with-param name="offset" select="local:chrome-count($host)"/>
+                                <xsl:with-param name="offset" select="rdfae:chrome-count($host)"/>
                             </xsl:call-template>
-                            <xsl:call-template name="local:after-mutation"/>
+                            <xsl:call-template name="rdfae:after-mutation"/>
                         </xsl:when>
                         <!-- B3: never merge across composite blocks; an empty block is removed
                              (a preceding island has no host to land in - it is selected) -->
-                        <xsl:when test="exists($prev[not(@data-role)]) and local:block-text($host) = ''">
-                            <xsl:call-template name="local:push-undo"/>
+                        <xsl:when test="exists($prev[not(@data-role)]) and rdfae:block-text($host) = ''">
+                            <xsl:call-template name="rdfae:push-undo"/>
                             <xsl:sequence select="ixsl:call($host, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
-                            <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                            <ixsl:set-property name="activeBlock" select="()" object="rdfae:editor-state()"/>
                             <xsl:choose>
-                                <xsl:when test="local:island($prev)">
-                                    <xsl:call-template name="local:select-island">
+                                <xsl:when test="rdfae:island($prev)">
+                                    <xsl:call-template name="rdfae:select-island">
                                         <xsl:with-param name="element" select="$prev"/>
                                     </xsl:call-template>
                                 </xsl:when>
@@ -1375,14 +1375,14 @@ version="3.0">
                                     <xsl:variable name="prev-host" as="element()?"
                                         select="($prev/descendant-or-self::*[@contenteditable = 'true'])[last()]"/>
                                     <xsl:for-each select="$prev-host">
-                                        <xsl:call-template name="local:focus-caret">
+                                        <xsl:call-template name="rdfae:focus-caret">
                                             <xsl:with-param name="node" select="."/>
                                             <xsl:with-param name="offset" select="xs:integer(ixsl:get(., 'childNodes.length'))"/>
                                         </xsl:call-template>
                                     </xsl:for-each>
                                 </xsl:otherwise>
                             </xsl:choose>
-                            <xsl:call-template name="local:after-mutation"/>
+                            <xsl:call-template name="rdfae:after-mutation"/>
                         </xsl:when>
                         <xsl:otherwise/>
                     </xsl:choose>
@@ -1397,55 +1397,55 @@ version="3.0">
          nested list lives INSIDE the previous item, which becomes a container
          (trailing nested list reused, else a fresh list of the same kind). A first
          item has nowhere to go - flash -->
-    <xsl:template name="local:list-indent">
+    <xsl:template name="rdfae:list-indent">
         <xsl:param name="item" as="element()"/>
 
         <xsl:variable name="prev" as="element()?" select="$item/preceding-sibling::li[1]"/>
         <xsl:choose>
             <xsl:when test="exists($prev)">
-                <xsl:call-template name="local:push-undo">
+                <xsl:call-template name="rdfae:push-undo">
                     <xsl:with-param name="host" select="$item"/>
                 </xsl:call-template>
                 <!-- text-node caret references survive reparenting -->
-                <xsl:variable name="caret-node" as="node()?" select="local:anchor-node()"/>
-                <xsl:variable name="caret-offset" as="xs:integer" select="local:anchor-offset()"/>
+                <xsl:variable name="caret-node" as="node()?" select="rdfae:anchor-node()"/>
+                <xsl:variable name="caret-offset" as="xs:integer" select="rdfae:anchor-offset()"/>
                 <xsl:variable name="target" as="element()?"
                     select="$prev/*[not(@data-role)][last()][self::ul or self::ol]"/>
                 <xsl:if test="empty($target)">
                     <xsl:for-each select="$prev[@contenteditable = 'true']">
                         <ixsl:remove-attribute name="contenteditable"/>
-                        <xsl:call-template name="local:wrap-stray-runs">
+                        <xsl:call-template name="rdfae:wrap-stray-runs">
                             <xsl:with-param name="container" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
                 </xsl:if>
                 <xsl:variable name="list" as="element()" select="if (exists($target)) then $target
-                    else local:element(local-name($item/parent::*))"/>
+                    else rdfae:element(local-name($item/parent::*))"/>
                 <xsl:if test="empty($target)">
                     <xsl:sequence select="ixsl:call($prev, 'appendChild', [ $list ])[current-date() lt xs:date('2000-01-01')]"/>
                 </xsl:if>
                 <xsl:sequence select="ixsl:call($list, 'appendChild', [ $item ])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:choose>
                     <xsl:when test="exists($caret-node)">
-                        <xsl:call-template name="local:focus-caret">
+                        <xsl:call-template name="rdfae:focus-caret">
                             <xsl:with-param name="node" select="$caret-node"/>
                             <xsl:with-param name="offset" select="$caret-offset"/>
                         </xsl:call-template>
                     </xsl:when>
                     <xsl:otherwise>
-                        <xsl:for-each select="local:first-host-in($item)">
-                            <xsl:call-template name="local:focus-caret">
+                        <xsl:for-each select="rdfae:first-host-in($item)">
+                            <xsl:call-template name="rdfae:focus-caret">
                                 <xsl:with-param name="node" select="."/>
                                 <xsl:with-param name="offset" select="0"/>
                             </xsl:call-template>
                         </xsl:for-each>
                     </xsl:otherwise>
                 </xsl:choose>
-                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:for-each select="local:caret-range()">
-                    <xsl:call-template name="local:show-flash">
+                <xsl:for-each select="rdfae:caret-range()">
+                    <xsl:call-template name="rdfae:show-flash">
                         <xsl:with-param name="range" select="."/>
                     </xsl:call-template>
                 </xsl:for-each>
@@ -1458,18 +1458,18 @@ version="3.0">
          moved item (they were logically below it). The emptied nested list is
          removed and the container collapses back to a text host when its last
          block leaves. A top-level item has nowhere to go - flash -->
-    <xsl:template name="local:list-outdent">
+    <xsl:template name="rdfae:list-outdent">
         <xsl:param name="item" as="element()"/>
 
         <xsl:variable name="list" as="element()" select="$item/parent::*"/>
         <xsl:variable name="container" as="element()?" select="$list/parent::li"/>
         <xsl:choose>
             <xsl:when test="exists($container)">
-                <xsl:call-template name="local:push-undo">
+                <xsl:call-template name="rdfae:push-undo">
                     <xsl:with-param name="host" select="$item"/>
                 </xsl:call-template>
-                <xsl:variable name="caret-node" as="node()?" select="local:anchor-node()"/>
-                <xsl:variable name="caret-offset" as="xs:integer" select="local:anchor-offset()"/>
+                <xsl:variable name="caret-node" as="node()?" select="rdfae:anchor-node()"/>
+                <xsl:variable name="caret-offset" as="xs:integer" select="rdfae:anchor-offset()"/>
                 <xsl:variable name="followers" as="element()*" select="$item/following-sibling::li"/>
                 <xsl:if test="exists($followers)">
                     <xsl:variable name="target" as="element()?"
@@ -1477,13 +1477,13 @@ version="3.0">
                     <xsl:if test="empty($target)">
                         <xsl:for-each select="$item[@contenteditable = 'true']">
                             <ixsl:remove-attribute name="contenteditable"/>
-                            <xsl:call-template name="local:wrap-stray-runs">
+                            <xsl:call-template name="rdfae:wrap-stray-runs">
                                 <xsl:with-param name="container" select="."/>
                             </xsl:call-template>
                         </xsl:for-each>
                     </xsl:if>
                     <xsl:variable name="sub" as="element()" select="if (exists($target)) then $target
-                        else local:element(local-name($list))"/>
+                        else rdfae:element(local-name($list))"/>
                     <xsl:if test="empty($target)">
                         <xsl:sequence select="ixsl:call($item, 'appendChild', [ $sub ])[current-date() lt xs:date('2000-01-01')]"/>
                     </xsl:if>
@@ -1495,30 +1495,30 @@ version="3.0">
                 <xsl:if test="empty($list/li)">
                     <xsl:sequence select="ixsl:call($list, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
                 </xsl:if>
-                <xsl:call-template name="local:collapse-container">
+                <xsl:call-template name="rdfae:collapse-container">
                     <xsl:with-param name="container" select="$container"/>
                 </xsl:call-template>
                 <xsl:choose>
                     <xsl:when test="exists($caret-node)">
-                        <xsl:call-template name="local:focus-caret">
+                        <xsl:call-template name="rdfae:focus-caret">
                             <xsl:with-param name="node" select="$caret-node"/>
                             <xsl:with-param name="offset" select="$caret-offset"/>
                         </xsl:call-template>
                     </xsl:when>
                     <xsl:otherwise>
-                        <xsl:for-each select="local:first-host-in($item)">
-                            <xsl:call-template name="local:focus-caret">
+                        <xsl:for-each select="rdfae:first-host-in($item)">
+                            <xsl:call-template name="rdfae:focus-caret">
                                 <xsl:with-param name="node" select="."/>
                                 <xsl:with-param name="offset" select="0"/>
                             </xsl:call-template>
                         </xsl:for-each>
                     </xsl:otherwise>
                 </xsl:choose>
-                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:for-each select="local:caret-range()">
-                    <xsl:call-template name="local:show-flash">
+                <xsl:for-each select="rdfae:caret-range()">
+                    <xsl:call-template name="rdfae:show-flash">
                         <xsl:with-param name="range" select="."/>
                     </xsl:call-template>
                 </xsl:for-each>
@@ -1528,11 +1528,11 @@ version="3.0">
 
     <!-- counted firstChild moves (never iterate a live child list lazily); no
          normalize() afterwards - the caret index depends on the node count -->
-    <xsl:template name="local:merge-into-previous">
+    <xsl:template name="rdfae:merge-into-previous">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="prev" as="element()"/>
 
-        <xsl:call-template name="local:remove-chrome">
+        <xsl:call-template name="rdfae:remove-chrome">
             <xsl:with-param name="block" select="$host"/>
         </xsl:call-template>
         <xsl:variable name="index" as="xs:integer" select="xs:integer(ixsl:get($prev, 'childNodes.length'))"/>
@@ -1540,8 +1540,8 @@ version="3.0">
             <xsl:sequence select="ixsl:call($prev, 'appendChild', [ ixsl:get($host, 'firstChild') ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
         <xsl:sequence select="ixsl:call($host, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
-        <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
-        <xsl:call-template name="local:focus-caret">
+        <ixsl:set-property name="activeBlock" select="()" object="rdfae:editor-state()"/>
+        <xsl:call-template name="rdfae:focus-caret">
     <xsl:with-param name="node" select="$prev"/>
     <xsl:with-param name="offset" select="$index"/>
 </xsl:call-template>
@@ -1551,23 +1551,23 @@ version="3.0">
 
     <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onpaste">
         <xsl:variable name="event" select="ixsl:event()"/>
-        <xsl:if test="exists(local:block-of(.))">
+        <xsl:if test="exists(rdfae:block-of(.))">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:variable name="html" as="xs:string"
                 select="string(ixsl:call(ixsl:get($event, 'clipboardData'), 'getData', [ 'text/html' ]))"/>
             <!-- pasting over a cross-host selection is inert this iteration: the
                  paste machines would raw-deleteContents across hosts -->
             <xsl:choose>
-                <xsl:when test="local:selection-crosses-hosts()"/>
+                <xsl:when test="rdfae:selection-crosses-hosts()"/>
                 <!-- formatted paste through the canonical (sanitizing) pipeline -->
                 <xsl:when test="$html ne '' and not(self::pre)">
-                    <xsl:call-template name="local:paste-html">
+                    <xsl:call-template name="rdfae:paste-html">
                         <xsl:with-param name="host" select="."/>
                         <xsl:with-param name="html" select="$html"/>
                     </xsl:call-template>
                 </xsl:when>
                 <xsl:otherwise>
-                    <xsl:call-template name="local:paste-text">
+                    <xsl:call-template name="rdfae:paste-text">
                         <xsl:with-param name="host" select="."/>
                         <xsl:with-param name="raw" select="string(ixsl:call(ixsl:get($event, 'clipboardData'),
                             'getData', [ 'text/plain' ]))"/>
@@ -1577,26 +1577,26 @@ version="3.0">
         </xsl:if>
     </xsl:template>
 
-    <xsl:template name="local:paste-text">
+    <xsl:template name="rdfae:paste-text">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="raw" as="xs:string"/>
 
         <xsl:variable name="text" as="xs:string"
             select="if ($host/self::pre) then $raw else normalize-space($raw)"/>
-        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:if test="$text ne '' and ixsl:get($selection, 'rangeCount') ge 1">
-            <xsl:variable name="range" select="local:caret-range()"/>
-            <xsl:call-template name="local:push-undo">
+            <xsl:variable name="range" select="rdfae:caret-range()"/>
+            <xsl:call-template name="rdfae:push-undo">
                 <xsl:with-param name="host" select="$host"/>
             </xsl:call-template>
             <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:variable name="node" select="ixsl:call(ixsl:page(), 'createTextNode', [ $text ])"/>
             <xsl:sequence select="ixsl:call($range, 'insertNode', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:call-template name="local:place-caret">
+            <xsl:call-template name="rdfae:place-caret">
                 <xsl:with-param name="node" select="$node"/>
                 <xsl:with-param name="offset" select="string-length($text)"/>
             </xsl:call-template>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:if>
     </xsl:template>
 
@@ -1606,11 +1606,11 @@ version="3.0">
          inside a flow host (li, td, ...) or as new siblings between the split
          halves of an inline-only host; hosts that can take blocks neither way
          (caption, dt) flatten to text -->
-    <xsl:template name="local:paste-html">
+    <xsl:template name="rdfae:paste-html">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="html" as="xs:string"/>
 
-        <xsl:variable name="carrier" as="element()" select="local:element('div')"/>
+        <xsl:variable name="carrier" as="element()" select="rdfae:element('div')"/>
         <ixsl:set-property name="innerHTML" select="$html" object="$carrier"/>
         <xsl:variable name="pass1">
             <xsl:apply-templates select="$carrier/node()" mode="canonical"/>
@@ -1620,13 +1620,13 @@ version="3.0">
         </xsl:variable>
         <xsl:variable name="has-blocks" as="xs:boolean"
             select="exists($clean/*[cm:block(local-name(.))])"/>
-        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:variable name="selection" select="rdfae:selection()"/>
 
         <xsl:choose>
             <xsl:when test="empty($clean/node()) or ixsl:get($selection, 'rangeCount') lt 1"/>
             <!-- a mixed flow host takes the blocks inside itself -->
             <xsl:when test="$has-blocks and cm:flow(local-name($host))">
-                <xsl:call-template name="local:paste-into-flow-host">
+                <xsl:call-template name="rdfae:paste-into-flow-host">
                     <xsl:with-param name="host" select="$host"/>
                     <xsl:with-param name="clean" select="$clean/node()"/>
                 </xsl:call-template>
@@ -1639,21 +1639,21 @@ version="3.0">
                 <!-- stray top-level inline runs become paragraphs -->
                 <xsl:variable name="blocks" as="element()*"
                     select="cm:wrap-inline-runs($clean/node(), 'p')[self::*]"/>
-                <xsl:variable name="range" select="local:caret-range()"/>
-                <xsl:call-template name="local:push-undo">
+                <xsl:variable name="range" select="rdfae:caret-range()"/>
+                <xsl:call-template name="rdfae:push-undo">
                     <xsl:with-param name="host" select="$host"/>
                 </xsl:call-template>
                 <xsl:if test="not(ixsl:get($range, 'collapsed'))">
                     <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
                 </xsl:if>
                 <!-- split the host, then thread the pasted blocks in after the first half -->
-                <xsl:call-template name="local:split-block">
+                <xsl:call-template name="rdfae:split-block">
                     <xsl:with-param name="host" select="$host"/>
                     <xsl:with-param name="range" select="$range"/>
                 </xsl:call-template>
                 <!-- method html: XML's self-closing <p/> reads as an OPEN tag to the
                      HTML fragment parser and swallows following siblings -->
-                <xsl:variable name="stage" as="element()" select="local:element('div')"/>
+                <xsl:variable name="stage" as="element()" select="rdfae:element('div')"/>
                 <ixsl:set-property name="innerHTML" select="serialize($blocks, map{ 'method': 'html' })" object="$stage"/>
                 <xsl:variable name="count" as="xs:integer" select="xs:integer(ixsl:get($stage, 'childNodes.length'))"/>
                 <xsl:iterate select="1 to $count">
@@ -1665,36 +1665,36 @@ version="3.0">
                     </xsl:next-iteration>
                 </xsl:iterate>
                 <xsl:for-each select="$host/following-sibling::*[position() le $count]">
-                    <xsl:call-template name="local:init-block">
+                    <xsl:call-template name="rdfae:init-block">
                         <xsl:with-param name="block" select="."/>
                     </xsl:call-template>
                 </xsl:for-each>
                 <!-- caret at the end of the last pasted block's last editable host -->
                 <xsl:variable name="last" as="element()?" select="$host/following-sibling::*[$count]"/>
                 <xsl:for-each select="($last/descendant-or-self::*[@contenteditable = 'true'])[last()]">
-                    <xsl:call-template name="local:focus-caret">
+                    <xsl:call-template name="rdfae:focus-caret">
     <xsl:with-param name="node" select="."/>
     <xsl:with-param name="offset" select="count(node()) - count(node()[last()][self::br])"/>
 </xsl:call-template>
                 </xsl:for-each>
-                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
             </xsl:when>
             <!-- blocks fit neither inside the host nor beside it (caption, dt):
                  flatten to sanitized text -->
             <xsl:when test="$has-blocks">
-                <xsl:call-template name="local:paste-text">
+                <xsl:call-template name="rdfae:paste-text">
                     <xsl:with-param name="host" select="$host"/>
                     <xsl:with-param name="raw" select="string($clean)"/>
                 </xsl:call-template>
             </xsl:when>
             <!-- inline-only fragment: insert at the caret -->
             <xsl:otherwise>
-                <xsl:variable name="range" select="local:caret-range()"/>
-                <xsl:call-template name="local:push-undo">
+                <xsl:variable name="range" select="rdfae:caret-range()"/>
+                <xsl:call-template name="rdfae:push-undo">
                     <xsl:with-param name="host" select="$host"/>
                 </xsl:call-template>
                 <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
-                <xsl:variable name="stage" as="element()" select="local:element('div')"/>
+                <xsl:variable name="stage" as="element()" select="rdfae:element('div')"/>
                 <ixsl:set-property name="innerHTML" select="serialize($clean/node(), map{ 'method': 'html' })" object="$stage"/>
                 <xsl:variable name="last" select="ixsl:get($stage, 'lastChild')"/>
                 <xsl:variable name="fragment" select="ixsl:call(ixsl:page(), 'createDocumentFragment', [])"/>
@@ -1703,12 +1703,12 @@ version="3.0">
                 </xsl:for-each>
                 <xsl:sequence select="ixsl:call($range, 'insertNode', [ $fragment ])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:for-each select="$last">
-                    <xsl:call-template name="local:place-caret">
+                    <xsl:call-template name="rdfae:place-caret">
                         <xsl:with-param name="node" select="ixsl:get(., 'parentNode')"/>
                         <xsl:with-param name="offset" select="count(preceding-sibling::node()) + 1"/>
                     </xsl:call-template>
                 </xsl:for-each>
-                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
             </xsl:otherwise>
         </xsl:choose>
     </xsl:template>
@@ -1717,12 +1717,12 @@ version="3.0">
          host's content splits around the caret into head and tail runs with the
          blocks between them, and re-init turns the host into a container (stray
          runs wrapped as p.rdfa-editor-run, nested blocks inited recursively) -->
-    <xsl:template name="local:paste-into-flow-host">
+    <xsl:template name="rdfae:paste-into-flow-host">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="clean" as="node()*"/>
 
-        <xsl:variable name="range" select="local:caret-range()"/>
-        <xsl:call-template name="local:push-undo">
+        <xsl:variable name="range" select="rdfae:caret-range()"/>
+        <xsl:call-template name="rdfae:push-undo">
             <xsl:with-param name="host" select="$host"/>
         </xsl:call-template>
         <xsl:if test="not(ixsl:get($range, 'collapsed'))">
@@ -1730,10 +1730,10 @@ version="3.0">
         </xsl:if>
         <!-- the tail (caret to end of host) rides out as HTML -->
         <xsl:sequence select="ixsl:call($range, 'setEnd', [ $host, xs:integer(ixsl:get($host, 'childNodes.length')) ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:variable name="tail-stage" as="element()" select="local:element('div')"/>
+        <xsl:variable name="tail-stage" as="element()" select="rdfae:element('div')"/>
         <xsl:sequence select="ixsl:call($tail-stage, 'appendChild',
             [ ixsl:call($range, 'extractContents', []) ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:remove-chrome">
+        <xsl:call-template name="rdfae:remove-chrome">
             <xsl:with-param name="block" select="$host"/>
         </xsl:call-template>
         <ixsl:set-property name="innerHTML" select="string(ixsl:get($host, 'innerHTML'))
@@ -1743,23 +1743,23 @@ version="3.0">
         <xsl:for-each select="$host">
             <ixsl:remove-attribute name="contenteditable"/>
         </xsl:for-each>
-        <xsl:call-template name="local:init-block">
+        <xsl:call-template name="rdfae:init-block">
             <xsl:with-param name="block" select="$host"/>
         </xsl:call-template>
         <!-- caret at the end of the last editable host in the rebuilt container -->
         <xsl:for-each select="($host/descendant-or-self::*[@contenteditable = 'true'])[last()]">
-            <xsl:call-template name="local:focus-caret">
+            <xsl:call-template name="rdfae:focus-caret">
                 <xsl:with-param name="node" select="."/>
                 <xsl:with-param name="offset" select="count(node()) - count(node()[last()][self::br])"/>
             </xsl:call-template>
         </xsl:for-each>
-        <xsl:call-template name="local:after-mutation"/>
+        <xsl:call-template name="rdfae:after-mutation"/>
     </xsl:template>
 
     <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onfocusin">
-        <xsl:if test="exists(local:block-of(.))">
-            <ixsl:set-property name="activeBlock" select="." object="local:editor-state()"/>
-            <xsl:call-template name="local:update-breadcrumb"/>
+        <xsl:if test="exists(rdfae:block-of(.))">
+            <ixsl:set-property name="activeBlock" select="." object="rdfae:editor-state()"/>
+            <xsl:call-template name="rdfae:update-breadcrumb"/>
         </xsl:if>
     </xsl:template>
 
@@ -1775,9 +1775,9 @@ version="3.0">
          format-quote toggle -->
     <xsl:template match="select[@name = 'block-type']" mode="ixsl:onchange">
         <xsl:variable name="name" as="xs:string" select="string(ixsl:get(., 'value'))"/>
-        <xsl:for-each select="local:current-host()[self::p or self::h1 or self::h2 or self::h3
-                or self::pre][exists(local:block-of(.))][local-name() ne $name]">
-            <xsl:call-template name="local:convert-block">
+        <xsl:for-each select="rdfae:current-host()[self::p or self::h1 or self::h2 or self::h3
+                or self::pre][exists(rdfae:block-of(.))][local-name() ne $name]">
+            <xsl:call-template name="rdfae:convert-block">
                 <xsl:with-param name="block" select="."/>
                 <xsl:with-param name="name" select="$name"/>
             </xsl:call-template>
@@ -1788,56 +1788,56 @@ version="3.0">
          (text nodes survive reparenting); chrome moves to a new top-level quote.
          Wrapping a run wrapper promotes it (blockquote > bare run would unwrap to
          invalid bare text at canonicalization) -->
-    <xsl:template name="local:wrap-in-blockquote">
+    <xsl:template name="rdfae:wrap-in-blockquote">
         <xsl:param name="block" as="element()"/>
 
-        <xsl:call-template name="local:push-undo">
+        <xsl:call-template name="rdfae:push-undo">
             <xsl:with-param name="host" select="$block"/>
         </xsl:call-template>
         <xsl:if test="contains-token($block/@class, 'rdfa-editor-run')">
             <xsl:sequence select="ixsl:call(ixsl:get($block, 'classList'), 'remove',
                 [ 'rdfa-editor-run' ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
-        <xsl:variable name="quote" as="element()" select="local:element('blockquote')"/>
+        <xsl:variable name="quote" as="element()" select="rdfae:element('blockquote')"/>
         <xsl:sequence select="ixsl:call($block, 'before', [ $quote ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:remove-chrome">
+        <xsl:call-template name="rdfae:remove-chrome">
             <xsl:with-param name="block" select="$block"/>
         </xsl:call-template>
         <xsl:sequence select="ixsl:call($quote, 'appendChild', [ $block ])[current-date() lt xs:date('2000-01-01')]"/>
         <xsl:if test="$quote/parent::*[contains-token(@class, 'rdfa-editor-content')]">
-            <xsl:call-template name="local:inject-chrome">
+            <xsl:call-template name="rdfae:inject-chrome">
                 <xsl:with-param name="block" select="$quote"/>
             </xsl:call-template>
         </xsl:if>
-        <ixsl:set-property name="activeBlock" select="$block" object="local:editor-state()"/>
-        <xsl:call-template name="local:focus">
+        <ixsl:set-property name="activeBlock" select="$block" object="rdfae:editor-state()"/>
+        <xsl:call-template name="rdfae:focus">
             <xsl:with-param name="element" select="$block"/>
         </xsl:call-template>
-        <xsl:call-template name="local:after-mutation"/>
+        <xsl:call-template name="rdfae:after-mutation"/>
     </xsl:template>
 
     <!-- the quote toggle off: all children move out (counted sibling inserts) and
          re-init (chrome iff now top-level); refused with a flash when the quote
          carries RDFa attributes - unwrapping would silently drop triples -->
-    <xsl:template name="local:unwrap-blockquote">
+    <xsl:template name="rdfae:unwrap-blockquote">
         <xsl:param name="quote" as="element()"/>
 
         <xsl:choose>
             <xsl:when test="$quote/@property or $quote/@about or $quote/@typeof
                     or $quote/@resource or $quote/@content or $quote/@datatype">
-                <xsl:for-each select="local:caret-range()">
-                    <xsl:call-template name="local:show-flash">
+                <xsl:for-each select="rdfae:caret-range()">
+                    <xsl:call-template name="rdfae:show-flash">
                         <xsl:with-param name="range" select="."/>
                     </xsl:call-template>
                 </xsl:for-each>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:push-undo">
+                <xsl:call-template name="rdfae:push-undo">
                     <xsl:with-param name="host" select="$quote"/>
                 </xsl:call-template>
-                <xsl:variable name="caret-node" as="node()?" select="local:anchor-node()"/>
-                <xsl:variable name="caret-offset" as="xs:integer" select="local:anchor-offset()"/>
-                <xsl:call-template name="local:remove-chrome">
+                <xsl:variable name="caret-node" as="node()?" select="rdfae:anchor-node()"/>
+                <xsl:variable name="caret-offset" as="xs:integer" select="rdfae:anchor-offset()"/>
+                <xsl:call-template name="rdfae:remove-chrome">
                     <xsl:with-param name="block" select="$quote"/>
                 </xsl:call-template>
                 <xsl:variable name="inner" as="element()*" select="$quote/*"/>
@@ -1846,41 +1846,41 @@ version="3.0">
                 </xsl:for-each>
                 <xsl:sequence select="ixsl:call($quote, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:for-each select="$inner">
-                    <xsl:call-template name="local:init-block">
+                    <xsl:call-template name="rdfae:init-block">
                         <xsl:with-param name="block" select="."/>
                     </xsl:call-template>
                 </xsl:for-each>
-                <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                <ixsl:set-property name="activeBlock" select="()" object="rdfae:editor-state()"/>
                 <xsl:choose>
                     <xsl:when test="exists($caret-node)">
-                        <xsl:call-template name="local:focus-caret">
+                        <xsl:call-template name="rdfae:focus-caret">
                             <xsl:with-param name="node" select="$caret-node"/>
                             <xsl:with-param name="offset" select="$caret-offset"/>
                         </xsl:call-template>
                     </xsl:when>
                     <xsl:otherwise>
-                        <xsl:for-each select="local:first-host-in($inner[1])">
-                            <xsl:call-template name="local:focus-caret">
+                        <xsl:for-each select="rdfae:first-host-in($inner[1])">
+                            <xsl:call-template name="rdfae:focus-caret">
                                 <xsl:with-param name="node" select="."/>
-                                <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+                                <xsl:with-param name="offset" select="rdfae:chrome-count(.)"/>
                             </xsl:call-template>
                         </xsl:for-each>
                     </xsl:otherwise>
                 </xsl:choose>
-                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
             </xsl:otherwise>
         </xsl:choose>
     </xsl:template>
 
     <xsl:template match="button[contains-token(@class, 'format-quote')]" mode="ixsl:onclick">
-        <xsl:variable name="host" as="element()?" select="local:current-host()[exists(local:block-of(.))]"/>
+        <xsl:variable name="host" as="element()?" select="rdfae:current-host()[exists(rdfae:block-of(.))]"/>
         <!-- clamped at the region root: a host-page blockquote wrapping an
              embedded region is not ours to unwrap -->
         <xsl:variable name="quote" as="element()?"
-            select="$host/ancestor-or-self::blockquote[exists(local:block-of(.))][1]"/>
+            select="$host/ancestor-or-self::blockquote[exists(rdfae:block-of(.))][1]"/>
         <xsl:choose>
             <xsl:when test="exists($quote)">
-                <xsl:call-template name="local:unwrap-blockquote">
+                <xsl:call-template name="rdfae:unwrap-blockquote">
                     <xsl:with-param name="quote" select="$quote"/>
                 </xsl:call-template>
             </xsl:when>
@@ -1889,13 +1889,13 @@ version="3.0">
             <xsl:when test="$host[cm:block(local-name(.))]
                     [parent::*[contains-token(@class, 'rdfa-editor-content')]
                         or cm:allows-child(local-name(parent::*), 'blockquote')]">
-                <xsl:call-template name="local:wrap-in-blockquote">
+                <xsl:call-template name="rdfae:wrap-in-blockquote">
                     <xsl:with-param name="block" select="$host"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:for-each select="local:caret-range()">
-                    <xsl:call-template name="local:show-flash">
+                <xsl:for-each select="rdfae:caret-range()">
+                    <xsl:call-template name="rdfae:show-flash">
                         <xsl:with-param name="range" select="."/>
                     </xsl:call-template>
                 </xsl:for-each>
@@ -1905,16 +1905,16 @@ version="3.0">
 
     <!-- rename by rebuild: copy RDFa/lang attributes, move children (text-node
          references survive reparenting, so the caret can be restored exactly) -->
-    <xsl:template name="local:convert-block">
+    <xsl:template name="rdfae:convert-block">
         <xsl:param name="block" as="element()"/>
         <xsl:param name="name" as="xs:string"/>
         <!-- optionally pre-captured by the caller (unwrap+rename is one undo entry);
-             the defaults mirror local:push-undo's capture-now behavior -->
-        <xsl:param name="snapshot-root" as="element()?" select="local:active-root()"/>
+             the defaults mirror rdfae:push-undo's capture-now behavior -->
+        <xsl:param name="snapshot-root" as="element()?" select="rdfae:active-root()"/>
         <xsl:param name="snapshot" as="xs:string?"
             select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
 
-        <xsl:call-template name="local:push-undo">
+        <xsl:call-template name="rdfae:push-undo">
             <xsl:with-param name="root" select="$snapshot-root"/>
             <xsl:with-param name="snapshot" select="$snapshot"/>
         </xsl:call-template>
@@ -1924,9 +1924,9 @@ version="3.0">
              caret on the block itself dangles after replaceWith, so it falls back
              to the start of the new block (matters for empty-block conversions) -->
         <xsl:variable name="caret-node" as="node()?"
-            select="local:anchor-node()[local:host-of(.) is $block][not(. is $block)]"/>
+            select="rdfae:anchor-node()[rdfae:host-of(.) is $block][not(. is $block)]"/>
         <xsl:variable name="caret-offset" as="xs:integer"
-            select="if (exists($caret-node)) then local:anchor-offset() else 0"/>
+            select="if (exists($caret-node)) then rdfae:anchor-offset() else 0"/>
 
         <xsl:variable name="new" as="element()" select="ixsl:call(ixsl:page(), 'createElement', [ $name ])"/>
         <xsl:for-each select="$block/(@about | @property | @typeof | @resource | @content
@@ -1937,62 +1937,62 @@ version="3.0">
             <xsl:sequence select="ixsl:call($new, 'appendChild', [ ixsl:get($block, 'firstChild') ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
         <xsl:sequence select="ixsl:call($block, 'replaceWith', [ $new ])[current-date() lt xs:date('2000-01-01')]"/>
-        <ixsl:set-property name="activeBlock" select="$new" object="local:editor-state()"/>
-        <xsl:call-template name="local:focus">
+        <ixsl:set-property name="activeBlock" select="$new" object="rdfae:editor-state()"/>
+        <xsl:call-template name="rdfae:focus">
             <xsl:with-param name="element" select="$new"/>
         </xsl:call-template>
         <xsl:choose>
             <xsl:when test="exists($caret-node)">
-                <xsl:call-template name="local:place-caret">
+                <xsl:call-template name="rdfae:place-caret">
                     <xsl:with-param name="node" select="$caret-node"/>
                     <xsl:with-param name="offset" select="$caret-offset"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:place-caret">
+                <xsl:call-template name="rdfae:place-caret">
                     <xsl:with-param name="node" select="$new"/>
-                    <xsl:with-param name="offset" select="local:chrome-count($new)"/>
+                    <xsl:with-param name="offset" select="rdfae:chrome-count($new)"/>
                 </xsl:call-template>
             </xsl:otherwise>
         </xsl:choose>
-        <xsl:call-template name="local:after-mutation"/>
+        <xsl:call-template name="rdfae:after-mutation"/>
     </xsl:template>
 
     <!-- inline formatting toggles reuse the annotation wrap/unwrap machinery -->
     <xsl:template match="button[contains-token(@class, 'format-inline')]" mode="ixsl:onclick">
         <xsl:variable name="name" as="xs:string" select="string(@data-element)"/>
-        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
-            <xsl:variable name="range" select="local:caret-range()"/>
+            <xsl:variable name="range" select="rdfae:caret-range()"/>
             <xsl:variable name="anchor" select="ixsl:get($selection, 'anchorNode')"/>
-            <xsl:for-each select="local:host-of($anchor)[exists(local:block-of(.))]">
+            <xsl:for-each select="rdfae:host-of($anchor)[exists(rdfae:block-of(.))]">
                 <xsl:variable name="existing" as="element()?"
                     select="($anchor/ancestor-or-self::*[local-name() = $name] intersect descendant::*)[1]"/>
                 <xsl:choose>
                     <xsl:when test="exists($existing)">
-                        <xsl:call-template name="local:push-undo"/>
-                        <xsl:call-template name="local:unwrap-element">
+                        <xsl:call-template name="rdfae:push-undo"/>
+                        <xsl:call-template name="rdfae:unwrap-element">
                             <xsl:with-param name="element" select="$existing"/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:after-mutation"/>
+                        <xsl:call-template name="rdfae:after-mutation"/>
                     </xsl:when>
                     <xsl:when test="not(ixsl:get($selection, 'isCollapsed'))">
                         <!-- capture pre-wrap state; push only when the wrap succeeded -->
-                        <xsl:variable name="snapshot-root" as="element()?" select="local:active-root()"/>
+                        <xsl:variable name="snapshot-root" as="element()?" select="rdfae:active-root()"/>
                         <xsl:variable name="snapshot" as="xs:string?"
                             select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
                         <xsl:variable name="wrapped" as="element()?">
-                            <xsl:call-template name="local:wrap-range">
+                            <xsl:call-template name="rdfae:wrap-range">
                                 <xsl:with-param name="range" select="$range"/>
                                 <xsl:with-param name="name" select="$name"/>
                             </xsl:call-template>
                         </xsl:variable>
                         <xsl:for-each select="$wrapped">
-                            <xsl:call-template name="local:push-undo">
+                            <xsl:call-template name="rdfae:push-undo">
                                 <xsl:with-param name="root" select="$snapshot-root"/>
                                 <xsl:with-param name="snapshot" select="$snapshot"/>
                             </xsl:call-template>
-                            <xsl:call-template name="local:after-mutation"/>
+                            <xsl:call-template name="rdfae:after-mutation"/>
                         </xsl:for-each>
                     </xsl:when>
                     <xsl:otherwise/>
@@ -2007,11 +2007,11 @@ version="3.0">
          flow host otherwise (a cell or list item grows a nested block, becoming a
          container), after the current top-level block as a last resort (caption,
          dt). Chrome stays a top-level affordance -->
-    <xsl:template name="local:insert-block-at-caret">
+    <xsl:template name="rdfae:insert-block-at-caret">
         <xsl:param name="node" as="element()"/>
         <!-- dialog saves pass the host their dialog was opened from (the caret
              sits in the dialog input by then); defaulted for the direct buttons -->
-        <xsl:param name="host" as="element()?" select="local:current-host()[exists(local:block-of(.))]"/>
+        <xsl:param name="host" as="element()?" select="rdfae:current-host()[exists(rdfae:block-of(.))]"/>
 
         <xsl:choose>
             <!-- not inside a figure: the figure is a locked composite, so a block
@@ -2025,73 +2025,73 @@ version="3.0">
                 <xsl:for-each select="$host">
                     <ixsl:remove-attribute name="contenteditable"/>
                 </xsl:for-each>
-                <xsl:call-template name="local:wrap-stray-runs">
+                <xsl:call-template name="rdfae:wrap-stray-runs">
                     <xsl:with-param name="container" select="$host"/>
                 </xsl:call-template>
                 <xsl:sequence select="ixsl:call($host, 'appendChild', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:when>
-            <xsl:when test="exists(local:current-block())">
-                <xsl:sequence select="ixsl:call(local:current-block(), 'after', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
+            <xsl:when test="exists(rdfae:current-block())">
+                <xsl:sequence select="ixsl:call(rdfae:current-block(), 'after', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:for-each select="local:active-root()">
+                <xsl:for-each select="rdfae:active-root()">
                     <xsl:sequence select="ixsl:call(., 'appendChild', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
                 </xsl:for-each>
             </xsl:otherwise>
         </xsl:choose>
         <xsl:if test="$node/parent::*[contains-token(@class, 'rdfa-editor-content')]">
-            <xsl:call-template name="local:inject-chrome">
+            <xsl:call-template name="rdfae:inject-chrome">
                 <xsl:with-param name="block" select="$node"/>
             </xsl:call-template>
         </xsl:if>
     </xsl:template>
 
     <xsl:template match="button[contains-token(@class, 'insert-block')]" mode="ixsl:onclick">
-        <xsl:call-template name="local:push-undo"/>
-        <xsl:variable name="p" as="element()" select="local:element('p')"/>
-        <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:call-template name="rdfae:push-undo"/>
+        <xsl:variable name="p" as="element()" select="rdfae:element('p')"/>
+        <xsl:sequence select="ixsl:call($p, 'appendChild', [ rdfae:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
         <ixsl:set-attribute name="contenteditable" select="'true'" object="$p"/>
-        <xsl:call-template name="local:insert-block-at-caret">
+        <xsl:call-template name="rdfae:insert-block-at-caret">
             <xsl:with-param name="node" select="$p"/>
         </xsl:call-template>
-        <xsl:call-template name="local:focus-caret">
+        <xsl:call-template name="rdfae:focus-caret">
             <xsl:with-param name="node" select="$p"/>
-            <xsl:with-param name="offset" select="local:chrome-count($p)"/>
+            <xsl:with-param name="offset" select="rdfae:chrome-count($p)"/>
         </xsl:call-template>
-        <xsl:call-template name="local:after-mutation"/>
+        <xsl:call-template name="rdfae:after-mutation"/>
     </xsl:template>
 
     <xsl:template match="button[contains-token(@class, 'insert-list')]" mode="ixsl:onclick">
-        <xsl:call-template name="local:push-undo"/>
+        <xsl:call-template name="rdfae:push-undo"/>
         <xsl:variable name="list" as="element()" select="ixsl:call(ixsl:page(), 'createElement', [ string(@data-list) ])"/>
-        <xsl:variable name="li" as="element()" select="local:element('li')"/>
+        <xsl:variable name="li" as="element()" select="rdfae:element('li')"/>
         <ixsl:set-attribute name="contenteditable" select="'true'" object="$li"/>
         <xsl:sequence select="ixsl:call($list, 'appendChild', [ $li ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:insert-block-at-caret">
+        <xsl:call-template name="rdfae:insert-block-at-caret">
             <xsl:with-param name="node" select="$list"/>
         </xsl:call-template>
-        <xsl:call-template name="local:focus-caret">
+        <xsl:call-template name="rdfae:focus-caret">
     <xsl:with-param name="node" select="$li"/>
     <xsl:with-param name="offset" select="0"/>
 </xsl:call-template>
-        <xsl:call-template name="local:after-mutation"/>
+        <xsl:call-template name="rdfae:after-mutation"/>
     </xsl:template>
 
     <xsl:template match="button[contains-token(@class, 'delete-block')]" mode="ixsl:onclick">
-        <xsl:for-each select="local:current-block()">
-            <xsl:variable name="confirmed" as="xs:boolean" select="local:block-text(.) = ''
+        <xsl:for-each select="rdfae:current-block()">
+            <xsl:variable name="confirmed" as="xs:boolean" select="rdfae:block-text(.) = ''
                 or ixsl:call(ixsl:window(), 'confirm', [ 'Delete this block?' ])"/>
             <xsl:if test="$confirmed">
-                <xsl:call-template name="local:push-undo"/>
+                <xsl:call-template name="rdfae:push-undo"/>
                 <xsl:variable name="prev" as="element()?" select="preceding-sibling::*[1]"/>
                 <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
-                <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                <ixsl:set-property name="activeBlock" select="()" object="rdfae:editor-state()"/>
                 <xsl:for-each select="($prev/descendant-or-self::*[@contenteditable = 'true'])[last()]">
-                    <xsl:call-template name="local:focus">
+                    <xsl:call-template name="rdfae:focus">
                         <xsl:with-param name="element" select="."/>
                     </xsl:call-template>
                 </xsl:for-each>
-                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
             </xsl:if>
         </xsl:for-each>
     </xsl:template>
@@ -2100,18 +2100,18 @@ version="3.0">
 
     <xsl:template match="button[contains-token(@class, 'format-link')]" mode="ixsl:onclick">
         <xsl:variable name="event" select="ixsl:event()"/>
-        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
-            <xsl:variable name="range" select="local:caret-range()"/>
+            <xsl:variable name="range" select="rdfae:caret-range()"/>
             <xsl:variable name="anchor" select="ixsl:get($selection, 'anchorNode')"/>
-            <xsl:for-each select="local:host-of($anchor)[exists(local:block-of(.))]">
+            <xsl:for-each select="rdfae:host-of($anchor)[exists(rdfae:block-of(.))]">
                 <xsl:variable name="link" as="element()?"
                     select="($anchor/ancestor-or-self::a intersect descendant::*)[1]"/>
                 <xsl:choose>
                     <!-- caret inside a link: edit it -->
                     <xsl:when test="exists($link)">
-                        <ixsl:set-property name="editingLink" select="$link" object="local:editor-state()"/>
-                        <xsl:call-template name="local:open-link-dialog">
+                        <ixsl:set-property name="editingLink" select="$link" object="rdfae:editor-state()"/>
+                        <xsl:call-template name="rdfae:open-link-dialog">
                             <xsl:with-param name="event" select="$event"/>
                             <xsl:with-param name="href" select="string($link/@href)"/>
                             <xsl:with-param name="editing" select="true()"/>
@@ -2119,9 +2119,9 @@ version="3.0">
                     </xsl:when>
                     <!-- selection: create one -->
                     <xsl:when test="not(ixsl:get($selection, 'isCollapsed'))">
-                        <ixsl:set-property name="editRange" select="$range" object="local:editor-state()"/>
-                        <ixsl:set-property name="editingLink" select="()" object="local:editor-state()"/>
-                        <xsl:call-template name="local:open-link-dialog">
+                        <ixsl:set-property name="editRange" select="$range" object="rdfae:editor-state()"/>
+                        <ixsl:set-property name="editingLink" select="()" object="rdfae:editor-state()"/>
+                        <xsl:call-template name="rdfae:open-link-dialog">
                             <xsl:with-param name="event" select="$event"/>
                             <xsl:with-param name="href" select="''"/>
                             <xsl:with-param name="editing" select="false()"/>
@@ -2133,7 +2133,7 @@ version="3.0">
         </xsl:if>
     </xsl:template>
 
-    <xsl:template name="local:render-link-dialog">
+    <xsl:template name="rdfae:render-link-dialog">
         <div id="link-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
                 aria-label="Link" style="display: none;">
             <label>Link target (href)</label>
@@ -2146,7 +2146,7 @@ version="3.0">
         </div>
     </xsl:template>
 
-    <xsl:template name="local:open-link-dialog">
+    <xsl:template name="rdfae:open-link-dialog">
         <xsl:param name="event"/>
         <xsl:param name="href" as="xs:string"/>
         <xsl:param name="editing" as="xs:boolean"/>
@@ -2158,7 +2158,7 @@ version="3.0">
         <xsl:for-each select="$dialog//button[contains-token(@class, 'link-remove')]">
             <ixsl:set-style name="display" select="if ($editing) then 'inline-block' else 'none'"/>
         </xsl:for-each>
-        <xsl:call-template name="local:show-at">
+        <xsl:call-template name="rdfae:show-at">
             <xsl:with-param name="element" select="$dialog"/>
             <xsl:with-param name="event" select="$event"/>
         </xsl:call-template>
@@ -2169,29 +2169,29 @@ version="3.0">
 
     <xsl:template match="button[contains-token(@class, 'link-save')]" mode="ixsl:onclick">
         <xsl:variable name="href" as="xs:string"
-            select="local:input-value(ancestor::div[@id = 'link-dialog'][1], 'href')"/>
+            select="rdfae:input-value(ancestor::div[@id = 'link-dialog'][1], 'href')"/>
         <xsl:if test="$href ne ''">
-            <xsl:variable name="editing" select="ixsl:get(local:editor-state(), 'editingLink')"/>
+            <xsl:variable name="editing" select="ixsl:get(rdfae:editor-state(), 'editingLink')"/>
             <xsl:choose>
                 <xsl:when test="exists($editing)">
-                    <xsl:call-template name="local:push-undo"/>
+                    <xsl:call-template name="rdfae:push-undo"/>
                     <xsl:for-each select="$editing">
                         <ixsl:set-attribute name="href" select="$href"/>
                     </xsl:for-each>
                 </xsl:when>
                 <xsl:otherwise>
                     <!-- capture pre-wrap state; push only when the wrap succeeded -->
-                    <xsl:variable name="snapshot-root" as="element()?" select="local:active-root()"/>
+                    <xsl:variable name="snapshot-root" as="element()?" select="rdfae:active-root()"/>
                     <xsl:variable name="snapshot" as="xs:string?"
                         select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
                     <xsl:variable name="wrapped" as="element()?">
-                        <xsl:call-template name="local:wrap-range">
-                            <xsl:with-param name="range" select="ixsl:get(local:editor-state(), 'editRange')"/>
+                        <xsl:call-template name="rdfae:wrap-range">
+                            <xsl:with-param name="range" select="ixsl:get(rdfae:editor-state(), 'editRange')"/>
                             <xsl:with-param name="name" select="'a'"/>
                         </xsl:call-template>
                     </xsl:variable>
                     <xsl:for-each select="$wrapped">
-                        <xsl:call-template name="local:push-undo">
+                        <xsl:call-template name="rdfae:push-undo">
                             <xsl:with-param name="root" select="$snapshot-root"/>
                             <xsl:with-param name="snapshot" select="$snapshot"/>
                         </xsl:call-template>
@@ -2199,51 +2199,51 @@ version="3.0">
                     </xsl:for-each>
                 </xsl:otherwise>
             </xsl:choose>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:if>
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
     </xsl:template>
 
     <xsl:template match="button[contains-token(@class, 'link-remove')]" mode="ixsl:onclick">
-        <xsl:for-each select="ixsl:get(local:editor-state(), 'editingLink')">
-            <xsl:call-template name="local:push-undo"/>
-            <xsl:call-template name="local:unwrap-element">
+        <xsl:for-each select="ixsl:get(rdfae:editor-state(), 'editingLink')">
+            <xsl:call-template name="rdfae:push-undo"/>
+            <xsl:call-template name="rdfae:unwrap-element">
                 <xsl:with-param name="element" select="."/>
             </xsl:call-template>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:for-each>
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
     </xsl:template>
 
     <xsl:template match="button[contains-token(@class, 'link-cancel')
             or contains-token(@class, 'figure-cancel')
             or contains-token(@class, 'table-cancel')]" mode="ixsl:onclick">
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
     </xsl:template>
 
     <xsl:template match="div[contains-token(@class, 'edit-dialog')] | div[@id = 'slash-menu']" mode="ixsl:onkeydown">
         <xsl:if test="string(ixsl:get(ixsl:event(), 'key')) = 'Escape'">
             <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:call-template name="local:hide-dialogs"/>
+            <xsl:call-template name="rdfae:hide-dialogs"/>
         </xsl:if>
     </xsl:template>
 
     <!-- single teardown point for all dialogs: everything carrying the edit-dialog
          class (extension dialogs opt in the same way) plus the slash menu -->
-    <xsl:template name="local:hide-dialogs">
+    <xsl:template name="rdfae:hide-dialogs">
         <xsl:for-each select="ixsl:page()//div[contains-token(@class, 'edit-dialog')],
                 id('slash-menu', ixsl:page())">
             <ixsl:set-style name="display" select="'none'"/>
         </xsl:for-each>
-        <ixsl:set-property name="editRange" select="()" object="local:editor-state()"/>
-        <ixsl:set-property name="editingLink" select="()" object="local:editor-state()"/>
-        <ixsl:set-property name="insertHost" select="()" object="local:editor-state()"/>
-        <ixsl:set-property name="slashHost" select="()" object="local:editor-state()"/>
-        <ixsl:set-property name="findNode" select="()" object="local:editor-state()"/>
-        <ixsl:set-property name="findOffset" select="1" object="local:editor-state()"/>
+        <ixsl:set-property name="editRange" select="()" object="rdfae:editor-state()"/>
+        <ixsl:set-property name="editingLink" select="()" object="rdfae:editor-state()"/>
+        <ixsl:set-property name="insertHost" select="()" object="rdfae:editor-state()"/>
+        <ixsl:set-property name="slashHost" select="()" object="rdfae:editor-state()"/>
+        <ixsl:set-property name="findNode" select="()" object="rdfae:editor-state()"/>
+        <ixsl:set-property name="findOffset" select="1" object="rdfae:editor-state()"/>
         <!-- return focus to the content -->
-        <xsl:for-each select="ixsl:get(local:editor-state(), 'activeBlock')[exists(local:block-of(.))]">
-            <xsl:call-template name="local:focus">
+        <xsl:for-each select="ixsl:get(rdfae:editor-state(), 'activeBlock')[exists(rdfae:block-of(.))]">
+            <xsl:call-template name="rdfae:focus">
                 <xsl:with-param name="element" select="."/>
             </xsl:call-template>
         </xsl:for-each>
@@ -2253,12 +2253,12 @@ version="3.0">
 
     <xsl:template match="button[contains-token(@class, 'insert-figure')]" mode="ixsl:onclick">
         <ixsl:set-property name="insertHost"
-            select="local:current-host()[exists(local:block-of(.))]" object="local:editor-state()"/>
+            select="rdfae:current-host()[exists(rdfae:block-of(.))]" object="rdfae:editor-state()"/>
         <xsl:variable name="dialog" as="element()" select="id('figure-dialog', ixsl:page())"/>
         <xsl:for-each select="$dialog//input">
             <ixsl:set-property name="value" select="''" object="."/>
         </xsl:for-each>
-        <xsl:call-template name="local:show-at">
+        <xsl:call-template name="rdfae:show-at">
             <xsl:with-param name="element" select="$dialog"/>
             <xsl:with-param name="event" select="ixsl:event()"/>
         </xsl:call-template>
@@ -2267,7 +2267,7 @@ version="3.0">
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template name="local:render-figure-dialog">
+    <xsl:template name="rdfae:render-figure-dialog">
         <div id="figure-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
                 aria-label="Insert figure" style="display: none;">
             <label>Image URL (src)</label>
@@ -2285,17 +2285,17 @@ version="3.0">
 
     <xsl:template match="button[contains-token(@class, 'figure-save')]" mode="ixsl:onclick">
         <xsl:variable name="dialog" as="element()" select="ancestor::div[@id = 'figure-dialog']"/>
-        <xsl:variable name="src" as="xs:string" select="local:input-value($dialog, 'src')"/>
+        <xsl:variable name="src" as="xs:string" select="rdfae:input-value($dialog, 'src')"/>
         <xsl:if test="$src ne ''">
-            <xsl:call-template name="local:push-undo"/>
-            <xsl:variable name="figure" as="element()" select="local:element('figure')"/>
-            <xsl:variable name="img" as="element()" select="local:element('img')"/>
+            <xsl:call-template name="rdfae:push-undo"/>
+            <xsl:variable name="figure" as="element()" select="rdfae:element('figure')"/>
+            <xsl:variable name="img" as="element()" select="rdfae:element('img')"/>
             <ixsl:set-attribute name="src" select="$src" object="$img"/>
-            <ixsl:set-attribute name="alt" select="local:input-value($dialog, 'alt')" object="$img"/>
-            <!-- focusable so the image is a keyboard-navigation island (see local:nav-targets) -->
+            <ixsl:set-attribute name="alt" select="rdfae:input-value($dialog, 'alt')" object="$img"/>
+            <!-- focusable so the image is a keyboard-navigation island (see rdfae:nav-targets) -->
             <ixsl:set-attribute name="tabindex" select="'-1'" object="$img"/>
-            <xsl:variable name="figcaption" as="element()" select="local:element('figcaption')"/>
-            <ixsl:set-property name="textContent" select="local:input-value($dialog, 'caption')" object="$figcaption"/>
+            <xsl:variable name="figcaption" as="element()" select="rdfae:element('figcaption')"/>
+            <ixsl:set-property name="textContent" select="rdfae:input-value($dialog, 'caption')" object="$figcaption"/>
             <ixsl:set-attribute name="contenteditable" select="'true'" object="$figcaption"/>
             <xsl:sequence select="ixsl:call($figure, 'appendChild', [ $img ])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:sequence select="ixsl:call($figure, 'appendChild', [ $figcaption ])[current-date() lt xs:date('2000-01-01')]"/>
@@ -2303,16 +2303,16 @@ version="3.0">
                  opened from: an empty list item or cell grows the figure INSIDE
                  itself, a sibling where the parent admits it (chrome only when it
                  lands top-level - the helper guards it) -->
-            <xsl:call-template name="local:insert-block-at-caret">
+            <xsl:call-template name="rdfae:insert-block-at-caret">
                 <xsl:with-param name="node" select="$figure"/>
-                <xsl:with-param name="host" select="ixsl:get(local:editor-state(), 'insertHost')[exists(local:block-of(.))]"/>
+                <xsl:with-param name="host" select="ixsl:get(rdfae:editor-state(), 'insertHost')[exists(rdfae:block-of(.))]"/>
             </xsl:call-template>
-            <xsl:call-template name="local:focus">
+            <xsl:call-template name="rdfae:focus">
                 <xsl:with-param name="element" select="$figcaption"/>
             </xsl:call-template>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:if>
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
     </xsl:template>
 
     <!-- ................................ drag-and-drop ................................ -->
@@ -2320,23 +2320,23 @@ 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:handle-block(.)">
+        <xsl:for-each select="rdfae:handle-block(.)">
             <ixsl:set-attribute name="draggable" select="'true'"/>
         </xsl:for-each>
     </xsl:template>
 
     <xsl:template match="span[contains-token(@class, 'drag-handle')]" mode="ixsl:onmouseup">
-        <xsl:for-each select="local:handle-block(.)">
+        <xsl:for-each select="rdfae:handle-block(.)">
             <ixsl:remove-attribute name="draggable"/>
         </xsl:for-each>
-        <xsl:call-template name="local:disarm-sweep"/>
+        <xsl:call-template name="rdfae:disarm-sweep"/>
     </xsl:template>
 
-    <xsl:template match="*[@draggable = 'true'][local:draggable-block(.)]" mode="ixsl:ondragstart">
+    <xsl:template match="*[@draggable = 'true'][rdfae:draggable-block(.)]" mode="ixsl:ondragstart">
         <xsl:variable name="transfer" select="ixsl:get(ixsl:event(), 'dataTransfer')"/>
         <!-- a block drag must never race an armed sweep -->
-        <xsl:call-template name="local:disarm-sweep"/>
-        <ixsl:set-property name="draggedBlock" select="." object="local:editor-state()"/>
+        <xsl:call-template name="rdfae:disarm-sweep"/>
+        <ixsl:set-property name="draggedBlock" select="." object="rdfae:editor-state()"/>
         <ixsl:set-property name="effectAllowed" select="'move'" object="$transfer"/>
         <xsl:sequence select="ixsl:call($transfer, 'setData', [ 'application/x-rdfa-editor-block', '' ])[current-date() lt xs:date('2000-01-01')]"/>
         <xsl:sequence select="ixsl:call($transfer, 'setDragImage', [ ., 0, 0 ])[current-date() lt xs:date('2000-01-01')]"/>
@@ -2351,7 +2351,7 @@ version="3.0">
         <xsl:if test="ixsl:get($event, 'ctrlKey') or ixsl:get($event, 'metaKey')">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:sequence select="ixsl:call(ixsl:window(), 'open',
-                [ string(resolve-uri(@href, local:document-uri())), '_blank' ])[current-date() lt xs:date('2000-01-01')]"/>
+                [ string(resolve-uri(@href, rdfae:document-uri())), '_blank' ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
     </xsl:template>
 
@@ -2360,9 +2360,9 @@ version="3.0">
          draggable block (the figure, wherever it nests) -->
     <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')]//img" mode="ixsl:ondragstart">
         <xsl:variable name="transfer" select="ixsl:get(ixsl:event(), 'dataTransfer')"/>
-        <xsl:call-template name="local:disarm-sweep"/>
-        <xsl:for-each select="ancestor-or-self::*[local:draggable-block(.)][1]">
-            <ixsl:set-property name="draggedBlock" select="." object="local:editor-state()"/>
+        <xsl:call-template name="rdfae:disarm-sweep"/>
+        <xsl:for-each select="ancestor-or-self::*[rdfae:draggable-block(.)][1]">
+            <ixsl:set-property name="draggedBlock" select="." object="rdfae:editor-state()"/>
             <ixsl:set-property name="effectAllowed" select="'move'" object="$transfer"/>
             <xsl:sequence select="ixsl:call($transfer, 'setData', [ 'application/x-rdfa-editor-block', '' ])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:sequence select="ixsl:call($transfer, 'setDragImage', [ ., 0, 0 ])[current-date() lt xs:date('2000-01-01')]"/>
@@ -2372,53 +2372,53 @@ version="3.0">
 
     <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')] | *[contains-token(@class, 'rdfa-editor-content')]//*" mode="ixsl:ondragover">
         <xsl:variable name="event" select="ixsl:event()"/>
-        <xsl:variable name="dragged" select="ixsl:get(local:editor-state(), 'draggedBlock')"/>
-        <xsl:variable name="target" as="element()?" select="local:drop-target-of(., $event)"/>
+        <xsl:variable name="dragged" select="ixsl:get(rdfae:editor-state(), 'draggedBlock')"/>
+        <xsl:variable name="target" as="element()?" select="rdfae:drop-target-of(., $event)"/>
         <xsl:if test="exists($dragged) and exists($target)
-                and local:has-transfer-type($event, 'application/x-rdfa-editor-block')">
+                and rdfae:has-transfer-type($event, 'application/x-rdfa-editor-block')">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
             <ixsl:set-property name="dropEffect" select="'move'" object="ixsl:get($event, 'dataTransfer')"/>
-            <xsl:call-template name="local:clear-drop-marks"/>
+            <xsl:call-template name="rdfae:clear-drop-marks"/>
             <!-- a block target takes a before/after line; a cell target is entered
                  whole, so it highlights as a box -->
             <xsl:sequence select="ixsl:call(ixsl:get($target, 'classList'), 'add',
-                [ if (not(local:draggable-block($target))) then 'drop-into'
-                    else if (local:drop-before($event, $target)) then 'drop-before'
+                [ if (not(rdfae:draggable-block($target))) then 'drop-into'
+                    else if (rdfae:drop-before($event, $target)) then 'drop-before'
                     else 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
     </xsl:template>
 
     <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')] | *[contains-token(@class, 'rdfa-editor-content')]//*" mode="ixsl:ondrop">
         <xsl:variable name="event" select="ixsl:event()"/>
-        <xsl:variable name="dragged" select="ixsl:get(local:editor-state(), 'draggedBlock')"/>
-        <xsl:variable name="target" as="element()?" select="local:drop-target-of(., $event)"/>
+        <xsl:variable name="dragged" select="ixsl:get(rdfae:editor-state(), 'draggedBlock')"/>
+        <xsl:variable name="target" as="element()?" select="rdfae:drop-target-of(., $event)"/>
         <xsl:if test="exists($dragged) and exists($target)
-                and local:has-transfer-type($event, 'application/x-rdfa-editor-block')">
+                and rdfae: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"/>
+            <xsl:call-template name="rdfae: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:call-template name="rdfae:tidy-class">
                     <xsl:with-param name="element" select="."/>
                 </xsl:call-template>
             </xsl:for-each>
-            <xsl:call-template name="local:push-undo"/>
+            <xsl:call-template name="rdfae:push-undo"/>
             <!-- the vacated origin, captured before the move: the top-level block
                  (husk-prune scope) and the nearest flow container (collapse
                  candidate) - both empty for a top-level drag -->
             <xsl:variable name="origin-block" as="element()?"
                 select="$dragged/parent::*[not(contains-token(@class, 'rdfa-editor-content'))]
-                    ! local:block-of(.)"/>
+                    ! rdfae: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]"/>
+                    [exists(rdfae:block-of(.))][1]"/>
             <xsl:choose>
-                <xsl:when test="local:draggable-block($target)">
+                <xsl:when test="rdfae:draggable-block($target)">
                     <xsl:sequence select="ixsl:call($target,
-                        if (local:drop-before($event, $target)) then 'before' else 'after',
+                        if (rdfae: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,
@@ -2427,7 +2427,7 @@ version="3.0">
                     <xsl:for-each select="$target[@contenteditable = 'true']">
                         <ixsl:remove-attribute name="contenteditable"/>
                     </xsl:for-each>
-                    <xsl:call-template name="local:wrap-stray-runs">
+                    <xsl:call-template name="rdfae: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')]"/>
@@ -2436,36 +2436,36 @@ version="3.0">
             <!-- 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:for-each select="$origin-block[exists(rdfae:root-of(.))]">
+                <xsl:call-template name="rdfae: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:for-each select="$origin-flow[exists(rdfae:root-of(.))]">
+                <xsl:call-template name="rdfae:collapse-container">
                     <xsl:with-param name="container" select="."/>
                 </xsl:call-template>
             </xsl:for-each>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:if>
     </xsl:template>
 
     <xsl:template match="*[contains-token(@class, 'rdfa-editor-content')] | *[contains-token(@class, 'rdfa-editor-content')]//*" mode="ixsl:ondragend">
         <!-- clean the actually-dragged block (the event target of a nested drag
              may be a descendant, so re-deriving from it would miss) -->
-        <xsl:for-each select="ixsl:get(local:editor-state(), 'draggedBlock')">
+        <xsl:for-each select="ixsl:get(rdfae: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:call-template name="rdfae:tidy-class">
                 <xsl:with-param name="element" select="."/>
             </xsl:call-template>
         </xsl:for-each>
-        <xsl:call-template name="local:clear-drop-marks"/>
-        <ixsl:set-property name="draggedBlock" select="()" object="local:editor-state()"/>
+        <xsl:call-template name="rdfae:clear-drop-marks"/>
+        <ixsl:set-property name="draggedBlock" select="()" object="rdfae:editor-state()"/>
     </xsl:template>
 
     <!-- dataTransfer.types marshals to an XDM array or sequence of strings -->
-    <xsl:function name="local:has-transfer-type" as="xs:boolean">
+    <xsl:function name="rdfae:has-transfer-type" as="xs:boolean">
         <xsl:param name="event"/>
         <xsl:param name="type" as="xs:string"/>
         <xsl:variable name="types" select="ixsl:get(ixsl:get($event, 'dataTransfer'), 'types')"/>
@@ -2480,15 +2480,15 @@ version="3.0">
          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:function name="rdfae:drop-target-of" as="element()?">
         <xsl:param name="hit"/>
         <xsl:param name="event"/>
-        <xsl:variable name="dragged" select="ixsl:get(local:editor-state(), 'draggedBlock')"/>
+        <xsl:variable name="dragged" select="ixsl:get(rdfae:editor-state(), 'draggedBlock')"/>
         <!-- blocks never move between editable regions -->
         <xsl:variable name="root" as="element()?"
-            select="($dragged ! local:root-of(.), local:root-of($hit))[1]"/>
+            select="($dragged ! rdfae:root-of(.), rdfae:root-of($hit))[1]"/>
         <xsl:variable name="deepest" as="element()?"
-            select="local:deepest-block-at($hit, $dragged)[local:root-of(.) is $root]"/>
+            select="rdfae:deepest-block-at($hit, $dragged)[rdfae: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:
@@ -2500,9 +2500,9 @@ version="3.0">
         <xsl:variable name="cell" as="element()?"
             select="$hit/ancestor-or-self::*[self::td or self::th]
                 [empty(ancestor-or-self::*[@data-role])]
-                [empty(ancestor::*[local:island(.)])]
+                [empty(ancestor::*[rdfae:island(.)])]
                 [empty(ancestor-or-self::* intersect $dragged)]
-                [local:root-of(.) is $root][1]"/>
+                [rdfae:root-of(.) is $root][1]"/>
         <xsl:choose>
             <xsl:when test="exists($cell) and exists($dragged)
                     and cm:allows-child(local-name($cell), local-name($dragged))
@@ -2510,11 +2510,11 @@ version="3.0">
                 <xsl:sequence select="$cell"/>
             </xsl:when>
             <xsl:when test="exists($deepest) and exists($dragged)">
-                <xsl:sequence select="local:legal-drop-level($deepest, $dragged)"/>
+                <xsl:sequence select="rdfae:legal-drop-level($deepest, $dragged)"/>
             </xsl:when>
             <!-- geometric fallback only within the dragged block's own region:
                  a pointer over another region is not a drop zone at all -->
-            <xsl:when test="not(local:root-of($hit) is $root)"/>
+            <xsl:when test="not(rdfae:root-of($hit) is $root)"/>
             <xsl:otherwise>
                 <xsl:variable name="y" as="xs:double" select="xs:double(ixsl:get($event, 'clientY'))"/>
                 <xsl:variable name="candidates" as="element()*"
@@ -2529,7 +2529,7 @@ version="3.0">
     </xsl:function>
 
     <!-- above or below the vertical midpoint of the target block -->
-    <xsl:function name="local:drop-before" as="xs:boolean">
+    <xsl:function name="rdfae:drop-before" as="xs:boolean">
         <xsl:param name="event"/>
         <xsl:param name="target" as="element()"/>
         <xsl:variable name="rect" select="ixsl:call($target, 'getBoundingClientRect', [])"/>
@@ -2537,14 +2537,14 @@ version="3.0">
             lt xs:double(ixsl:get($rect, 'height')) div 2"/>
     </xsl:function>
 
-    <xsl:template name="local:clear-drop-marks">
-        <xsl:param name="scope" as="element()*" select="local:roots()/descendant::*"/>
+    <xsl:template name="rdfae:clear-drop-marks">
+        <xsl:param name="scope" as="element()*" select="rdfae:roots()/descendant::*"/>
         <xsl:for-each select="$scope[contains-token(@class, 'drop-before')
                 or contains-token(@class, 'drop-after') or contains-token(@class, 'drop-into')]">
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'drop-before' ])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'drop-into' ])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:call-template name="local:tidy-class">
+            <xsl:call-template name="rdfae:tidy-class">
                 <xsl:with-param name="element" select="."/>
             </xsl:call-template>
         </xsl:for-each>
@@ -2556,7 +2556,7 @@ version="3.0">
          xml-c14n lib on the host page - LinkedDataHub's ldh:canonicalize-xml ported.
          parse-xml() is the XDM->DOM bridge: the lib walks browser DOM nodes, not
          Saxon's temporary trees -->
-    <xsl:function name="local:canonicalize-xml" as="xs:string">
+    <xsl:function name="rdfae:canonicalize-xml" as="xs:string">
         <xsl:param name="doc" as="document-node()"/>
         <xsl:variable name="js-function" select="ixsl:eval('(function (doc) { return window[''xml-c14n-sync.js'']().createCanonicaliser(''http://www.w3.org/2001/10/xml-exc-c14n#WithComments'').canonicaliseSync(doc.documentElement); })')"/>
         <xsl:sequence select="ixsl:call($js-function, 'call', [ (), $doc ])"/>
@@ -2565,12 +2565,12 @@ version="3.0">
     <xsl:template match="button[@id = 'view-source']" mode="ixsl:onclick">
         <xsl:variable name="canonical" as="element()?">
             <xsl:call-template name="canonical-xhtml">
-                <xsl:with-param name="content" select="local:active-root()"/>
+                <xsl:with-param name="content" select="rdfae:active-root()"/>
             </xsl:call-template>
         </xsl:variable>
-        <xsl:call-template name="local:show-output">
+        <xsl:call-template name="rdfae:show-output">
             <xsl:with-param name="title" select="'Canonical XHTML+RDFa'"/>
-            <xsl:with-param name="text" select="local:canonicalize-xml(parse-xml(serialize($canonical, map{ 'method': 'xml' })))"/>
+            <xsl:with-param name="text" select="rdfae:canonicalize-xml(parse-xml(serialize($canonical, map{ 'method': 'xml' })))"/>
             <xsl:with-param name="filename" select="'content.xhtml'"/>
             <xsl:with-param name="media-type" select="'application/xhtml+xml'"/>
         </xsl:call-template>
diff --git a/src/group-sort-triples.xsl b/src/group-sort-triples.xsl
index 8a170a6..f6593f4 100644
--- a/src/group-sort-triples.xsl
+++ b/src/group-sort-triples.xsl
@@ -18,8 +18,8 @@ limitations under the License.
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-xmlns:local="urn:rdfa-editor:functions"
-exclude-result-prefixes="xsl xs local"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
+exclude-result-prefixes="xsl xs rdfae"
 version="3.0">
 
     <!--
@@ -31,7 +31,7 @@ version="3.0">
         xsl:strip-space here, since this module is xsl:included into the editor
         stylesheet and must not impose global serialization or whitespace handling.
     -->
-    <xsl:function name="local:group-triples" as="element(rdf:RDF)">
+    <xsl:function name="rdfae:group-triples" as="element(rdf:RDF)">
         <xsl:param name="rdf" as="element(rdf:RDF)"/>
 
         <rdf:RDF>
diff --git a/src/index.xsl b/src/index.xsl
index 29fd278..f483afa 100644
--- a/src/index.xsl
+++ b/src/index.xsl
@@ -4,7 +4,7 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 version="3.0">
@@ -52,14 +52,14 @@ version="3.0">
          documents into the SaxonJS document pool (SaxonJS.getResource +
          documentPool), keyed by page-relative URI -->
     <xsl:template name="main">
-        <xsl:call-template name="local:init-state"/>
-        <xsl:call-template name="local:init-editor"/>
+        <xsl:call-template name="rdfae:init-state"/>
+        <xsl:call-template name="rdfae:init-editor"/>
     </xsl:template>
 
     <!-- all editor state lives on a single window.rdfaEditor container (mirrors
-         LinkedDataHub's window.LinkedDataHub); reached everywhere via local:editor-state().
+         LinkedDataHub's window.LinkedDataHub); reached everywhere via rdfae:editor-state().
          Hosts with their own initial template call this from there instead of main -->
-    <xsl:template name="local:init-state">
+    <xsl:template name="rdfae:init-state">
         <xsl:variable name="state" select="ixsl:call(ixsl:window(), 'Object', [])"/>
         <ixsl:set-property name="rdfaEditor" select="$state" object="ixsl:window()"/>
         <xsl:for-each select="('editingSpan', 'range', 'activeBlock', 'draggedBlock',
@@ -76,17 +76,17 @@ version="3.0">
     <!-- the full editor bring-up: page chrome (undo stash, overlay, output modal,
          toolbar, dialogs, drawers) plus block init of every editable region. Hosts
          that render regions lazily call this once, when the first region appears -->
-    <xsl:template name="local:init-editor">
-        <xsl:call-template name="local:init-undo"/>
-        <xsl:call-template name="local:init-overlay"/>
-        <xsl:call-template name="local:init-annotate"/>
-        <xsl:call-template name="local:init-editing"/>
-        <xsl:call-template name="local:init-navigate"/>
+    <xsl:template name="rdfae:init-editor">
+        <xsl:call-template name="rdfae:init-undo"/>
+        <xsl:call-template name="rdfae:init-overlay"/>
+        <xsl:call-template name="rdfae:init-annotate"/>
+        <xsl:call-template name="rdfae:init-editing"/>
+        <xsl:call-template name="rdfae:init-navigate"/>
     </xsl:template>
 
     <!-- the single window.rdfaEditor container that holds all mutable editor state;
          every read/write of that state goes through this accessor -->
-    <xsl:function name="local:editor-state">
+    <xsl:function name="rdfae:editor-state">
         <xsl:sequence select="ixsl:get(ixsl:window(), 'rdfaEditor')"/>
     </xsl:function>
 
diff --git a/src/input.xsl b/src/input.xsl
index eff247a..4f8fd2e 100644
--- a/src/input.xsl
+++ b/src/input.xsl
@@ -4,8 +4,8 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
-xmlns:cm="urn:rdfa-editor:content-model"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
+xmlns:cm="https://w3id.org/atomgraph/rdfa-editor/content-model#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 version="3.0">
@@ -32,17 +32,17 @@ version="3.0">
 
     <!-- show a popup below the caret; a collapsed caret in an empty block yields a
          degenerate (all-zero) client rect, so fall back to the host's own box -->
-    <xsl:template name="local:show-at-caret">
+    <xsl:template name="rdfae:show-at-caret">
         <xsl:param name="element" as="element()"/>
-        <xsl:param name="anchor" as="element()?" select="local:current-host()"/>
-        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:param name="anchor" as="element()?" select="rdfae:current-host()"/>
+        <xsl:variable name="range" select="rdfae:caret-range()"/>
         <xsl:variable name="caret" select="$range ! ixsl:call(., 'getBoundingClientRect', [])"/>
         <xsl:variable name="degenerate" as="xs:boolean" select="empty($caret)
             or (ixsl:get($caret, 'width') = 0 and ixsl:get($caret, 'height') = 0
                 and ixsl:get($caret, 'left') = 0 and ixsl:get($caret, 'top') = 0)"/>
         <xsl:variable name="rect" select="if ($degenerate and exists($anchor))
             then ixsl:call($anchor, 'getBoundingClientRect', []) else $caret"/>
-        <xsl:call-template name="local:show-at-point">
+        <xsl:call-template name="rdfae:show-at-point">
             <xsl:with-param name="element" select="$element"/>
             <xsl:with-param name="x" select="ixsl:get($rect, 'left')"/>
             <xsl:with-param name="y" select="ixsl:get($rect, 'bottom')"/>
@@ -50,11 +50,11 @@ version="3.0">
     </xsl:template>
 
     <!-- show a popup below an anchor element's box (no live caret needed) -->
-    <xsl:template name="local:show-at-element">
+    <xsl:template name="rdfae:show-at-element">
         <xsl:param name="element" as="element()"/>
         <xsl:param name="anchor" as="element()"/>
         <xsl:variable name="rect" select="ixsl:call($anchor, 'getBoundingClientRect', [])"/>
-        <xsl:call-template name="local:show-at-point">
+        <xsl:call-template name="rdfae:show-at-point">
             <xsl:with-param name="element" select="$element"/>
             <xsl:with-param name="x" select="ixsl:get($rect, 'left')"/>
             <xsl:with-param name="y" select="ixsl:get($rect, 'bottom')"/>
@@ -70,22 +70,22 @@ version="3.0">
         <xsl:variable name="event" select="ixsl:event()"/>
         <xsl:variable name="type" as="xs:string" select="string(ixsl:get($event, 'inputType'))"/>
         <xsl:variable name="data" as="xs:string" select="string((ixsl:get($event, 'data'), '')[1])"/>
-        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:variable name="range" select="rdfae:caret-range()"/>
         <xsl:variable name="kind" as="xs:string" select="if ($type = 'insertText'
-                and exists(local:block-of(.)) and exists($range)
+                and exists(rdfae:block-of(.)) and exists($range)
                 and not(ixsl:get($event, 'isComposing')))
-            then local:trigger-kind(., $data) else ''"/>
+            then rdfae:trigger-kind(., $data) else ''"/>
         <xsl:choose>
             <xsl:when test="$kind ne ''">
                 <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:choose>
                     <xsl:when test="$kind = 'slash'">
-                        <xsl:call-template name="local:open-slash">
+                        <xsl:call-template name="rdfae:open-slash">
                             <xsl:with-param name="host" select="."/>
                         </xsl:call-template>
                     </xsl:when>
                     <xsl:otherwise>
-                        <xsl:call-template name="local:apply-markdown">
+                        <xsl:call-template name="rdfae:apply-markdown">
                             <xsl:with-param name="host" select="."/>
                             <xsl:with-param name="kind" select="$kind"/>
                         </xsl:call-template>
@@ -101,11 +101,11 @@ version="3.0">
     <!-- classify a would-be-inserted character: 'slash' (/ in an empty host), a
          markdown shorthand 'md:*' completed in a paragraph host, or '' for none.
          A shorthand whose result the content model would reject stays literal -->
-    <xsl:function name="local:trigger-kind" as="xs:string">
+    <xsl:function name="rdfae:trigger-kind" as="xs:string">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="data" as="xs:string"/>
 
-        <xsl:variable name="text" as="xs:string" select="local:block-text($host)"/>
+        <xsl:variable name="text" as="xs:string" select="rdfae:block-text($host)"/>
         <xsl:variable name="paragraph" as="xs:boolean" select="exists($host/self::p)"/>
         <xsl:variable name="kind" as="xs:string" select="
             if ($data = '/' and $text = '') then 'slash'
@@ -121,19 +121,19 @@ version="3.0">
              which would send '' into the content-model gate - branch explicitly -->
         <xsl:variable name="target" as="xs:string?"
             select="if (starts-with($kind, 'md:')) then substring-after($kind, 'md:') else ()"/>
-        <xsl:sequence select="if (exists($target) and not(local:parent-admits($host, $target)))
+        <xsl:sequence select="if (exists($target) and not(rdfae:parent-admits($host, $target)))
             then '' else $kind"/>
     </xsl:function>
 
     <!-- the region admits any block by contract; elsewhere the content model rules -->
-    <xsl:function name="local:parent-admits" as="xs:boolean">
+    <xsl:function name="rdfae:parent-admits" as="xs:boolean">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="name" as="xs:string"/>
         <xsl:sequence select="exists($host/parent::*[contains-token(@class, 'rdfa-editor-content')])
             or cm:allows-child(local-name($host/parent::*), $name)"/>
     </xsl:function>
 
-    <xsl:template name="local:apply-markdown">
+    <xsl:template name="rdfae:apply-markdown">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="kind" as="xs:string"/>
 
@@ -142,37 +142,37 @@ version="3.0">
                  invalid bare text): the wrap pushes the pre-strip state, so undo
                  restores the literal '>' -->
             <xsl:when test="$kind = 'md:blockquote'">
-                <xsl:call-template name="local:wrap-in-blockquote">
+                <xsl:call-template name="rdfae:wrap-in-blockquote">
                     <xsl:with-param name="block" select="$host"/>
                 </xsl:call-template>
-                <xsl:call-template name="local:strip-marker">
+                <xsl:call-template name="rdfae:strip-marker">
                     <xsl:with-param name="host" select="$host"/>
                 </xsl:call-template>
-                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
             </xsl:when>
             <xsl:otherwise>
                 <!-- capture the pre-strip state; the conversion pushes it as ONE
                      undo entry (mirrors the wrap-range capture-then-push pattern) -->
-                <xsl:variable name="snapshot-root" as="element()?" select="local:root-of($host)"/>
+                <xsl:variable name="snapshot-root" as="element()?" select="rdfae:root-of($host)"/>
                 <xsl:variable name="snapshot" as="xs:string?"
                     select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
-                <xsl:call-template name="local:strip-marker">
+                <xsl:call-template name="rdfae:strip-marker">
                     <xsl:with-param name="host" select="$host"/>
                 </xsl:call-template>
                 <xsl:choose>
                     <xsl:when test="$kind = ('md:ul', 'md:ol')">
-                        <xsl:call-template name="local:push-undo">
+                        <xsl:call-template name="rdfae:push-undo">
                             <xsl:with-param name="root" select="$snapshot-root"/>
                             <xsl:with-param name="snapshot" select="$snapshot"/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:replace-with-list">
+                        <xsl:call-template name="rdfae:replace-with-list">
                             <xsl:with-param name="block" select="$host"/>
                             <xsl:with-param name="kind" select="substring-after($kind, 'md:')"/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:after-mutation"/>
+                        <xsl:call-template name="rdfae:after-mutation"/>
                     </xsl:when>
                     <xsl:otherwise>
-                        <xsl:call-template name="local:convert-block">
+                        <xsl:call-template name="rdfae:convert-block">
                             <xsl:with-param name="block" select="$host"/>
                             <xsl:with-param name="name" select="substring-after($kind, 'md:')"/>
                             <xsl:with-param name="snapshot-root" select="$snapshot-root"/>
@@ -185,35 +185,35 @@ version="3.0">
     </xsl:template>
 
     <!-- drop the typed shorthand marker, keeping chrome and the caret placeholder -->
-    <xsl:template name="local:strip-marker">
+    <xsl:template name="rdfae:strip-marker">
         <xsl:param name="host" as="element()"/>
         <xsl:for-each select="$host/node()[not(self::*[@data-role])]">
             <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
-        <xsl:call-template name="local:ensure-placeholder">
+        <xsl:call-template name="rdfae:ensure-placeholder">
             <xsl:with-param name="host" select="$host"/>
         </xsl:call-template>
     </xsl:template>
 
     <!-- swap a block for a fresh single-item list of the given kind, caret in the
          item; a run wrapper swaps like any host (a structural gesture promotes it) -->
-    <xsl:template name="local:replace-with-list">
+    <xsl:template name="rdfae:replace-with-list">
         <xsl:param name="block" as="element()"/>
         <xsl:param name="kind" as="xs:string"/>
 
-        <xsl:variable name="list" as="element()" select="local:element($kind)"/>
-        <xsl:variable name="li" as="element()" select="local:element('li')"/>
+        <xsl:variable name="list" as="element()" select="rdfae:element($kind)"/>
+        <xsl:variable name="li" as="element()" select="rdfae:element('li')"/>
         <ixsl:set-attribute name="contenteditable" select="'true'" object="$li"/>
-        <xsl:sequence select="ixsl:call($li, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')],
+        <xsl:sequence select="ixsl:call($li, 'appendChild', [ rdfae:element('br') ])[current-date() lt xs:date('2000-01-01')],
             ixsl:call($list, 'appendChild', [ $li ])[current-date() lt xs:date('2000-01-01')],
             ixsl:call($block, 'replaceWith', [ $list ])[current-date() lt xs:date('2000-01-01')]"/>
         <xsl:if test="$list/parent::*[contains-token(@class, 'rdfa-editor-content')]">
-            <xsl:call-template name="local:inject-chrome">
+            <xsl:call-template name="rdfae:inject-chrome">
                 <xsl:with-param name="block" select="$list"/>
             </xsl:call-template>
         </xsl:if>
-        <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
-        <xsl:call-template name="local:focus-caret">
+        <ixsl:set-property name="activeBlock" select="()" object="rdfae:editor-state()"/>
+        <xsl:call-template name="rdfae:focus-caret">
             <xsl:with-param name="node" select="$li"/>
             <xsl:with-param name="offset" select="0"/>
         </xsl:call-template>
@@ -221,7 +221,7 @@ version="3.0">
 
     <!-- ................................ slash menu ................................ -->
 
-    <xsl:template name="local:render-slash-menu">
+    <xsl:template name="rdfae:render-slash-menu">
         <div id="slash-menu" class="rdfa-editor-ui" role="listbox" aria-label="Insert block" style="display: none;">
             <input type="text" class="slash-filter" placeholder="Filter blocks..." aria-label="Filter blocks"/>
             <ul class="slash-items">
@@ -235,9 +235,9 @@ version="3.0">
                 <li class="slash-item" data-command="ol" role="option">Numbered list</li>
                 <li class="slash-item" data-command="figure" role="option">Figure&#x2026;</li>
                 <li class="slash-item" data-command="table" role="option">Table&#x2026;</li>
-                <!-- extension items (dispatched via local:run-extra-slash-command;
+                <!-- extension items (dispatched via rdfae:run-extra-slash-command;
                      the generic filter/arrow/Enter machinery applies untouched) -->
-                <xsl:call-template name="local:render-extra-slash-items"/>
+                <xsl:call-template name="rdfae:render-extra-slash-items"/>
             </ul>
         </div>
     </xsl:template>
@@ -246,16 +246,16 @@ version="3.0">
          text-block hosts (per the block-type select), Quote where the wrap is
          legal and not already inside one, lists where the model places one,
          figure/table always (they insert after the top-level block) -->
-    <xsl:template name="local:open-slash">
+    <xsl:template name="rdfae:open-slash">
         <xsl:param name="host" as="element()"/>
 
-        <ixsl:set-property name="slashHost" select="$host" object="local:editor-state()"/>
+        <ixsl:set-property name="slashHost" select="$host" object="rdfae:editor-state()"/>
         <xsl:variable name="menu" as="element()" select="id('slash-menu', ixsl:page())"/>
         <xsl:variable name="convertible" as="xs:boolean"
             select="exists($host/(self::p | self::h1 | self::h2 | self::h3 | self::pre))"/>
         <xsl:variable name="quotable" as="xs:boolean" select="cm:block(local-name($host))
-            and local:parent-admits($host, 'blockquote')
-            and empty($host/ancestor::blockquote[exists(local:block-of(.))])"/>
+            and rdfae:parent-admits($host, 'blockquote')
+            and empty($host/ancestor::blockquote[exists(rdfae:block-of(.))])"/>
         <xsl:for-each select="$menu//input[contains-token(@class, 'slash-filter')]">
             <ixsl:set-property name="value" select="''" object="."/>
         </xsl:for-each>
@@ -264,10 +264,10 @@ version="3.0">
             <xsl:variable name="command" as="xs:string" select="string(@data-command)"/>
             <xsl:variable name="applies" as="xs:boolean" select="
                 if ($command = ('p', 'h1', 'h2', 'h3', 'pre'))
-                    then ($convertible and local:parent-admits($host, $command))
+                    then ($convertible and rdfae:parent-admits($host, $command))
                 else if ($command = 'blockquote') then $quotable
                 else if ($command = ('ul', 'ol'))
-                    then (exists($host/self::p) and local:parent-admits($host, $command))
+                    then (exists($host/self::p) and rdfae:parent-admits($host, $command))
                 else true()"/>
             <xsl:choose>
                 <xsl:when test="$applies">
@@ -284,7 +284,7 @@ version="3.0">
         <xsl:for-each select="($items[empty(@data-disabled)])[1]">
             <ixsl:set-attribute name="aria-selected" select="'true'"/>
         </xsl:for-each>
-        <xsl:call-template name="local:show-at-caret">
+        <xsl:call-template name="rdfae:show-at-caret">
             <xsl:with-param name="element" select="$menu"/>
             <xsl:with-param name="anchor" select="$host"/>
         </xsl:call-template>
@@ -293,46 +293,46 @@ version="3.0">
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template name="local:run-slash-command">
+    <xsl:template name="rdfae:run-slash-command">
         <xsl:param name="command" as="xs:string"/>
         <xsl:variable name="host" as="element()?"
-            select="ixsl:get(local:editor-state(), 'slashHost')[exists(local:block-of(.))]"/>
+            select="ixsl:get(rdfae:editor-state(), 'slashHost')[exists(rdfae:block-of(.))]"/>
         <!-- teardown first: it clears slashHost and insertHost, so the
              figure/table branches re-arm them after -->
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
         <xsl:for-each select="$host">
             <xsl:choose>
                 <xsl:when test="$command = ('p', 'h1', 'h2', 'h3', 'pre')">
                     <xsl:for-each select="$host[self::p or self::h1 or self::h2 or self::h3
                             or self::pre][local-name() ne $command]">
-                        <xsl:call-template name="local:convert-block">
+                        <xsl:call-template name="rdfae:convert-block">
                             <xsl:with-param name="block" select="."/>
                             <xsl:with-param name="name" select="$command"/>
                         </xsl:call-template>
                     </xsl:for-each>
                 </xsl:when>
                 <xsl:when test="$command = 'blockquote'">
-                    <xsl:call-template name="local:wrap-in-blockquote">
+                    <xsl:call-template name="rdfae:wrap-in-blockquote">
                         <xsl:with-param name="block" select="$host"/>
                     </xsl:call-template>
                 </xsl:when>
                 <xsl:when test="$command = ('ul', 'ol')">
-                    <xsl:call-template name="local:push-undo">
+                    <xsl:call-template name="rdfae:push-undo">
                         <xsl:with-param name="host" select="$host"/>
                     </xsl:call-template>
-                    <xsl:call-template name="local:replace-with-list">
+                    <xsl:call-template name="rdfae:replace-with-list">
                         <xsl:with-param name="block" select="$host"/>
                         <xsl:with-param name="kind" select="$command"/>
                     </xsl:call-template>
-                    <xsl:call-template name="local:after-mutation"/>
+                    <xsl:call-template name="rdfae:after-mutation"/>
                 </xsl:when>
                 <xsl:when test="$command = 'figure'">
-                    <ixsl:set-property name="insertHost" select="$host" object="local:editor-state()"/>
+                    <ixsl:set-property name="insertHost" select="$host" object="rdfae:editor-state()"/>
                     <xsl:variable name="dialog" as="element()" select="id('figure-dialog', ixsl:page())"/>
                     <xsl:for-each select="$dialog//input">
                         <ixsl:set-property name="value" select="''" object="."/>
                     </xsl:for-each>
-                    <xsl:call-template name="local:show-at-element">
+                    <xsl:call-template name="rdfae:show-at-element">
                         <xsl:with-param name="element" select="$dialog"/>
                         <xsl:with-param name="anchor" select="$host"/>
                     </xsl:call-template>
@@ -341,7 +341,7 @@ version="3.0">
                     </xsl:for-each>
                 </xsl:when>
                 <xsl:when test="$command = 'table'">
-                    <ixsl:set-property name="insertHost" select="$host" object="local:editor-state()"/>
+                    <ixsl:set-property name="insertHost" select="$host" object="rdfae:editor-state()"/>
                     <xsl:variable name="dialog" as="element()" select="id('table-dialog', ixsl:page())"/>
                     <!-- same defaults as the toolbar opener -->
                     <xsl:for-each select="($dialog//input[@name = 'rows'])[1], ($dialog//input[@name = 'cols'])[1]">
@@ -353,7 +353,7 @@ version="3.0">
                     <xsl:for-each select="($dialog//input[@name = 'header-row'])[1]">
                         <ixsl:set-property name="checked" select="true()" object="."/>
                     </xsl:for-each>
-                    <xsl:call-template name="local:show-at-element">
+                    <xsl:call-template name="rdfae:show-at-element">
                         <xsl:with-param name="element" select="$dialog"/>
                         <xsl:with-param name="anchor" select="$host"/>
                     </xsl:call-template>
@@ -364,7 +364,7 @@ version="3.0">
                 <!-- extension commands (mirror the figure/table branches: teardown
                      already ran, the extension re-arms insertHost itself) -->
                 <xsl:otherwise>
-                    <xsl:call-template name="local:run-extra-slash-command">
+                    <xsl:call-template name="rdfae:run-extra-slash-command">
                         <xsl:with-param name="command" select="$command"/>
                         <xsl:with-param name="host" select="$host"/>
                     </xsl:call-template>
@@ -398,12 +398,12 @@ version="3.0">
         <xsl:choose>
             <xsl:when test="$key = 'Escape'">
                 <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                <xsl:call-template name="local:hide-dialogs"/>
+                <xsl:call-template name="rdfae:hide-dialogs"/>
             </xsl:when>
             <xsl:when test="$key = 'Enter'">
                 <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:for-each select="($current, $items[1])[1]">
-                    <xsl:call-template name="local:run-slash-command">
+                    <xsl:call-template name="rdfae:run-slash-command">
                         <xsl:with-param name="command" select="string(@data-command)"/>
                     </xsl:call-template>
                 </xsl:for-each>
@@ -426,7 +426,7 @@ version="3.0">
     </xsl:template>
 
     <xsl:template match="li[contains-token(@class, 'slash-item')]" mode="ixsl:onclick">
-        <xsl:call-template name="local:run-slash-command">
+        <xsl:call-template name="rdfae:run-slash-command">
             <xsl:with-param name="command" select="string(@data-command)"/>
         </xsl:call-template>
     </xsl:template>
diff --git a/src/ldh-blocks.xsl b/src/ldh-blocks.xsl
index 3e5419b..4d8636e 100644
--- a/src/ldh-blocks.xsl
+++ b/src/ldh-blocks.xsl
@@ -10,7 +10,7 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
 xmlns:sp="http://spinrdf.org/sp#"
@@ -28,8 +28,8 @@ version="3.0">
     it xsl:imports), so the declarations here override the core's:
 
     - $object-block-types is re-declared with the LDH class IRIs;
-    - per-type mode="local:render-island" templates (plus one matching
-      local:reference-block) replace the neutral card with real async
+    - per-type mode="rdfae:render-island" templates (plus one matching
+      rdfae:reference-block) replace the neutral card with real async
       hydration via the SaxonJS 3 promise API (ixsl:promise +
       ixsl:http-request => ixsl:then, LDH's ldh:*-thunk idiom). Document URIs
       follow the Linked Data convention: trailing slash, no file extensions,
@@ -43,10 +43,10 @@ version="3.0">
       module's role, bridging into its block rendering - v6 mode ldh:Block,
       v5 ldh:RenderRow (docs/ldh/MIGRATION.md par. 12);
     - the "Block..." insert dialog plugs into the core's extension hooks
-      (local:render-extra-dialogs / -insert-buttons / -slash-items /
-      local:run-extra-slash-command).
+      (rdfae:render-extra-dialogs / -insert-buttons / -slash-items /
+      rdfae:run-extra-slash-command).
 
-    Relative @resource IRIs resolve against the page base (local:document-uri),
+    Relative @resource IRIs resolve against the page base (rdfae:document-uri),
     matching the RDFa extractor's resolution - never against the SEF location.
     Reference blocks carry ABSOLUTE @about URIs by construction (the editor
     emits absolute IRIs; a relative @about is the about-relative lint case).
@@ -63,7 +63,7 @@ version="3.0">
          spans. Placeholders missing the spin:query span fall through to the
          core's neutral card (deep-skip backstop) -->
     <xsl:template match="div[tokenize(@typeof) = ('&ldh;View', '&ldh;ResultSetChart')]
-            [descendant::*[@property = '&spin;query'][@resource]]" mode="local:render-island">
+            [descendant::*[@property = '&spin;query'][@resource]]" mode="rdfae:render-island">
         <xsl:variable name="chart-type" as="xs:string?"
             select="(descendant::*[@property = '&ldh;chartType']/@resource)[1] ! string(.)"/>
         <xsl:variable name="category" as="xs:string?"
@@ -74,16 +74,16 @@ version="3.0">
             $chart-type ! replace(., '^.*[#/]', ''),
             string-join(($category[. ne ''], string-join($series[. ne ''], ', ')[. ne '']), ' &#xD7; ')[. ne '']
             ), ' &#xB7; ')"/>
-        <xsl:call-template name="local:load-query-block">
+        <xsl:call-template name="rdfae:load-query-block">
             <xsl:with-param name="island" select="."/>
             <xsl:with-param name="heading" select="$heading"/>
         </xsl:call-template>
     </xsl:template>
 
     <!-- reference block: dereference the @about URI (conneg on the clean URI;
-         absolute by the local:reference-block predicate) and render the
+         absolute by the rdfae:reference-block predicate) and render the
          resource's description as a property table -->
-    <xsl:template match="div[local:reference-block(.)]" mode="local:render-island">
+    <xsl:template match="div[rdfae:reference-block(.)]" mode="rdfae:render-island">
         <xsl:variable name="island" as="element()" select="."/>
         <xsl:variable name="value-uri" as="xs:string" select="normalize-space(@about)"/>
         <xsl:variable name="value-doc" as="xs:string" select="substring-before($value-uri || '#', '#')"/>
@@ -91,31 +91,31 @@ version="3.0">
         <ixsl:promise select="
             ixsl:http-request(map{ 'method': 'GET', 'href': $value-doc,
                 'headers': map{ 'Accept': 'application/rdf+xml' } }) =>
-                ixsl:then(local:block-reference-response($island, $value-uri, $value-doc, ?))"
-            on-failure="local:block-render-failure($island, ?)"/>
+                ixsl:then(rdfae:block-reference-response($island, $value-uri, $value-doc, ?))"
+            on-failure="rdfae:block-render-failure($island, ?)"/>
     </xsl:template>
 
     <!-- shared query-block flow: promise chain fetching the query document,
          then (in its callback) the results document. The rendering div is
          injected only in the final callback, per the render-hook contract -->
-    <xsl:template name="local:load-query-block">
+    <xsl:template name="rdfae:load-query-block">
         <xsl:param name="island" as="element()"/>
         <xsl:param name="heading" as="xs:string?"/>
         <xsl:variable name="query-uri" as="xs:string" select="string(resolve-uri(
-            string(($island/descendant::*[@property = '&spin;query']/@resource)[1]), local:document-uri()))"/>
+            string(($island/descendant::*[@property = '&spin;query']/@resource)[1]), rdfae:document-uri()))"/>
         <xsl:variable name="query-doc" as="xs:string" select="substring-before($query-uri || '#', '#')"/>
         <xsl:sequence select="ixsl:call(ixsl:get($island, 'classList'), 'add', [ 'rdfa-editor-loading' ])[current-date() lt xs:date('2000-01-01')]"/>
         <ixsl:promise select="
             ixsl:http-request(map{ 'method': 'GET', 'href': $query-doc,
                 'headers': map{ 'Accept': 'application/rdf+xml' } }) =>
-                ixsl:then(local:block-query-response($island, $query-uri, $heading, ?))"
-            on-failure="local:block-render-failure($island, ?)"/>
+                ixsl:then(rdfae:block-query-response($island, $query-uri, $heading, ?))"
+            on-failure="rdfae:block-render-failure($island, ?)"/>
     </xsl:template>
 
     <!-- first hop: the query document (Accept: application/rdf+xml). Pulls
          sp:text (and rdfs:label as the fallback heading), then fires the
          results fetch - the SAME clean URI, negotiated for SPARQL results -->
-    <xsl:function name="local:block-query-response" as="item()*" ixsl:updating="yes">
+    <xsl:function name="rdfae:block-query-response" as="item()*" ixsl:updating="yes">
         <xsl:param name="island" as="element()"/>
         <xsl:param name="query-uri" as="xs:string"/>
         <xsl:param name="heading" as="xs:string?"/>
@@ -135,14 +135,14 @@ version="3.0">
                 <ixsl:promise select="
                     ixsl:http-request(map{ 'method': 'GET', 'href': $query-doc,
                         'headers': map{ 'Accept': 'application/sparql-results+xml' } }) =>
-                        ixsl:then(local:block-results-response($island, $final-heading, $query-text, ?))"
-                    on-failure="local:block-render-failure($island, ?)"/>
+                        ixsl:then(rdfae:block-results-response($island, $final-heading, $query-text, ?))"
+                    on-failure="rdfae:block-render-failure($island, ?)"/>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:block-render-error">
+                <xsl:call-template name="rdfae:block-render-error">
                     <xsl:with-param name="island" select="$island"/>
                     <xsl:with-param name="message" select="'Failed to load the query (' || $query-uri || ')'
-                        || local:conneg-hint($response)"/>
+                        || rdfae:conneg-hint($response)"/>
                 </xsl:call-template>
             </xsl:otherwise>
         </xsl:choose>
@@ -150,13 +150,13 @@ version="3.0">
 
     <!-- a 200 with the wrong representation means the server ignored the Accept
          header: the demo needs the content-negotiating dev server (make up) -->
-    <xsl:function name="local:conneg-hint" as="xs:string">
+    <xsl:function name="rdfae:conneg-hint" as="xs:string">
         <xsl:param name="response" as="map(*)"/>
         <xsl:sequence select="(' - the server did not content-negotiate the representation; serve with ''make up'' (serve.mjs)'[$response?status = 200], '')[1]"/>
     </xsl:function>
 
     <!-- second hop: the SPARQL Results XML document, rendered as a real table -->
-    <xsl:function name="local:block-results-response" as="item()*" ixsl:updating="yes">
+    <xsl:function name="rdfae:block-results-response" as="item()*" ixsl:updating="yes">
         <xsl:param name="island" as="element()"/>
         <xsl:param name="heading" as="xs:string?"/>
         <xsl:param name="query-text" as="xs:string?"/>
@@ -166,7 +166,7 @@ version="3.0">
             <xsl:when test="$response?status = 200 and exists($results/srx:sparql)">
                 <xsl:variable name="vars" as="xs:string*" select="$results/srx:sparql/srx:head/srx:variable/@name ! string(.)"/>
                 <xsl:sequence select="ixsl:call(ixsl:get($island, 'classList'), 'remove', [ 'rdfa-editor-loading' ])[current-date() lt xs:date('2000-01-01')]"/>
-                <xsl:call-template name="local:replace-rendering">
+                <xsl:call-template name="rdfae:replace-rendering">
                     <xsl:with-param name="island" select="$island"/>
                     <xsl:with-param name="content">
                         <div class="rdfa-editor-island-card">
@@ -201,10 +201,10 @@ version="3.0">
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:block-render-error">
+                <xsl:call-template name="rdfae:block-render-error">
                     <xsl:with-param name="island" select="$island"/>
                     <xsl:with-param name="message" select="'Failed to load results (' || string($response?status) || ')'
-                        || local:conneg-hint($response)"/>
+                        || rdfae:conneg-hint($response)"/>
                 </xsl:call-template>
             </xsl:otherwise>
         </xsl:choose>
@@ -213,7 +213,7 @@ version="3.0">
     <!-- reference hop: the dereferenced resource's description as a property
          table, capped - a public resource (DBpedia) can carry hundreds of
          properties, the card is a preview, not a browser -->
-    <xsl:function name="local:block-reference-response" as="item()*" ixsl:updating="yes">
+    <xsl:function name="rdfae:block-reference-response" as="item()*" ixsl:updating="yes">
         <xsl:param name="island" as="element()"/>
         <xsl:param name="value-uri" as="xs:string"/>
         <xsl:param name="value-doc" as="xs:string"/>
@@ -227,7 +227,7 @@ version="3.0">
                 <xsl:sequence select="ixsl:call(ixsl:get($island, 'classList'), 'remove', [ 'rdfa-editor-loading' ])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:variable name="label" as="xs:string?"
                     select="(($description/rdfs:label[not(@xml:lang)], $description/rdfs:label[@xml:lang = 'en'], $description/rdfs:label)[1]) ! string(.)"/>
-                <xsl:call-template name="local:replace-rendering">
+                <xsl:call-template name="rdfae:replace-rendering">
                     <xsl:with-param name="island" select="$island"/>
                     <xsl:with-param name="content">
                         <div class="rdfa-editor-island-card">
@@ -250,21 +250,21 @@ version="3.0">
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:block-render-error">
+                <xsl:call-template name="rdfae:block-render-error">
                     <xsl:with-param name="island" select="$island"/>
                     <xsl:with-param name="message" select="'Failed to load the resource (' || $value-uri || ')'
-                        || local:conneg-hint($response)"/>
+                        || rdfae:conneg-hint($response)"/>
                 </xsl:call-template>
             </xsl:otherwise>
         </xsl:choose>
     </xsl:function>
 
     <!-- a failed fetch must never wedge the loading state -->
-    <xsl:template name="local:block-render-error">
+    <xsl:template name="rdfae:block-render-error">
         <xsl:param name="island" as="element()"/>
         <xsl:param name="message" as="xs:string"/>
         <xsl:sequence select="ixsl:call(ixsl:get($island, 'classList'), 'remove', [ 'rdfa-editor-loading' ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:replace-rendering">
+        <xsl:call-template name="rdfae:replace-rendering">
             <xsl:with-param name="island" select="$island"/>
             <xsl:with-param name="content">
                 <div class="rdfa-editor-island-error"><xsl:value-of select="$message"/></div>
@@ -272,10 +272,10 @@ version="3.0">
         </xsl:call-template>
     </xsl:template>
 
-    <xsl:function name="local:block-render-failure" as="item()*" ixsl:updating="yes">
+    <xsl:function name="rdfae:block-render-failure" as="item()*" ixsl:updating="yes">
         <xsl:param name="island" as="element()"/>
         <xsl:param name="error" as="item()?"/>
-        <xsl:call-template name="local:block-render-error">
+        <xsl:call-template name="rdfae:block-render-error">
             <xsl:with-param name="island" select="$island"/>
             <xsl:with-param name="message" select="'Failed to load block data'"/>
         </xsl:call-template>
@@ -283,12 +283,12 @@ version="3.0">
 
     <!-- ................................ insert dialog ................................ -->
 
-    <xsl:template name="local:render-extra-dialogs">
+    <xsl:template name="rdfae:render-extra-dialogs">
         <div id="ldh-block-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
                 aria-label="Insert block" style="display: none;">
             <label>Block type</label>
             <select name="block-type-iri">
-                <option value="urn:rdfa-editor:reference">Resource</option>
+                <option value="https://w3id.org/atomgraph/rdfa-editor#reference">Resource</option>
                 <option value="&ldh;View">View</option>
                 <option value="&ldh;ResultSetChart">Result set chart</option>
             </select>
@@ -331,37 +331,37 @@ version="3.0">
         </div>
     </xsl:template>
 
-    <xsl:template name="local:render-extra-insert-buttons">
+    <xsl:template name="rdfae:render-extra-insert-buttons">
         <button type="button" class="insert-ldh-block" title="Insert block" aria-label="Insert LinkedDataHub block">&#x25A6;</button>
     </xsl:template>
 
-    <xsl:template name="local:render-extra-slash-items">
+    <xsl:template name="rdfae:render-extra-slash-items">
         <li class="slash-item" data-command="ldh-block" role="option">Block&#x2026;</li>
     </xsl:template>
 
     <!-- reset to the reference defaults (mirrors the figure/table openers) -->
-    <xsl:template name="local:reset-ldh-block-dialog">
+    <xsl:template name="rdfae:reset-ldh-block-dialog">
         <xsl:variable name="dialog" as="element()" select="id('ldh-block-dialog', ixsl:page())"/>
         <xsl:for-each select="$dialog//input">
             <ixsl:set-property name="value" select="''" object="."/>
         </xsl:for-each>
         <xsl:for-each select="($dialog//select[@name = 'block-type-iri'])[1]">
-            <ixsl:set-property name="value" select="'urn:rdfa-editor:reference'" object="."/>
+            <ixsl:set-property name="value" select="'https://w3id.org/atomgraph/rdfa-editor#reference'" object="."/>
         </xsl:for-each>
-        <xsl:call-template name="local:toggle-ldh-block-fields">
+        <xsl:call-template name="rdfae:toggle-ldh-block-fields">
             <xsl:with-param name="dialog" select="$dialog"/>
-            <xsl:with-param name="type" select="'urn:rdfa-editor:reference'"/>
+            <xsl:with-param name="type" select="'https://w3id.org/atomgraph/rdfa-editor#reference'"/>
         </xsl:call-template>
     </xsl:template>
 
-    <xsl:template name="local:toggle-ldh-block-fields">
+    <xsl:template name="rdfae:toggle-ldh-block-fields">
         <xsl:param name="dialog" as="element()"/>
         <xsl:param name="type" as="xs:string"/>
         <xsl:for-each select="$dialog//div[contains-token(@class, 'ldh-fields-reference')]">
-            <ixsl:set-style name="display" select="if ($type = 'urn:rdfa-editor:reference') then 'block' else 'none'"/>
+            <ixsl:set-style name="display" select="if ($type = 'https://w3id.org/atomgraph/rdfa-editor#reference') then 'block' else 'none'"/>
         </xsl:for-each>
         <xsl:for-each select="$dialog//div[contains-token(@class, 'ldh-fields-frag')]">
-            <ixsl:set-style name="display" select="if ($type = 'urn:rdfa-editor:reference') then 'none' else 'block'"/>
+            <ixsl:set-style name="display" select="if ($type = 'https://w3id.org/atomgraph/rdfa-editor#reference') then 'none' else 'block'"/>
         </xsl:for-each>
         <xsl:for-each select="$dialog//div[contains-token(@class, 'ldh-fields-view')]">
             <ixsl:set-style name="display" select="if ($type = '&ldh;View') then 'block' else 'none'"/>
@@ -372,7 +372,7 @@ version="3.0">
     </xsl:template>
 
     <xsl:template match="div[@id = 'ldh-block-dialog']//select[@name = 'block-type-iri']" mode="ixsl:onchange">
-        <xsl:call-template name="local:toggle-ldh-block-fields">
+        <xsl:call-template name="rdfae:toggle-ldh-block-fields">
             <xsl:with-param name="dialog" select="ancestor::div[@id = 'ldh-block-dialog']"/>
             <xsl:with-param name="type" select="string(ixsl:get(., 'value'))"/>
         </xsl:call-template>
@@ -380,9 +380,9 @@ version="3.0">
 
     <xsl:template match="button[contains-token(@class, 'insert-ldh-block')]" mode="ixsl:onclick">
         <ixsl:set-property name="insertHost"
-            select="local:current-host()[exists(local:block-of(.))]" object="local:editor-state()"/>
-        <xsl:call-template name="local:reset-ldh-block-dialog"/>
-        <xsl:call-template name="local:show-at">
+            select="rdfae:current-host()[exists(rdfae:block-of(.))]" object="rdfae:editor-state()"/>
+        <xsl:call-template name="rdfae:reset-ldh-block-dialog"/>
+        <xsl:call-template name="rdfae:show-at">
             <xsl:with-param name="element" select="id('ldh-block-dialog', ixsl:page())"/>
             <xsl:with-param name="event" select="ixsl:event()"/>
         </xsl:call-template>
@@ -391,14 +391,14 @@ version="3.0">
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template name="local:run-extra-slash-command">
+    <xsl:template name="rdfae:run-extra-slash-command">
         <xsl:param name="command" as="xs:string"/>
         <xsl:param name="host" as="element()?"/>
         <xsl:if test="$command = 'ldh-block'">
-            <ixsl:set-property name="insertHost" select="$host" object="local:editor-state()"/>
+            <ixsl:set-property name="insertHost" select="$host" object="rdfae:editor-state()"/>
             <xsl:variable name="dialog" as="element()" select="id('ldh-block-dialog', ixsl:page())"/>
-            <xsl:call-template name="local:reset-ldh-block-dialog"/>
-            <xsl:call-template name="local:show-at-element">
+            <xsl:call-template name="rdfae:reset-ldh-block-dialog"/>
+            <xsl:call-template name="rdfae:show-at-element">
                 <xsl:with-param name="element" select="$dialog"/>
                 <xsl:with-param name="anchor" select="$host"/>
             </xsl:call-template>
@@ -411,11 +411,11 @@ version="3.0">
     <!-- a definition span: RDFa as real DOM attributes (they must serialize);
          literal values go in TEXT CONTENT per the v6 document format (the spans
          render display:none via rdfa-editor.css) -->
-    <xsl:template name="local:make-definition-span">
+    <xsl:template name="rdfae:make-definition-span">
         <xsl:param name="property" as="xs:string"/>
         <xsl:param name="resource" as="xs:string?" select="()"/>
         <xsl:param name="text" as="xs:string?" select="()"/>
-        <xsl:variable name="span" as="element()" select="local:element('span')"/>
+        <xsl:variable name="span" as="element()" select="rdfae:element('span')"/>
         <ixsl:set-attribute name="property" select="$property" object="$span"/>
         <xsl:for-each select="$resource[. ne '']">
             <ixsl:set-attribute name="resource" select="." object="$span"/>
@@ -429,22 +429,22 @@ version="3.0">
     <xsl:template match="button[contains-token(@class, 'ldh-block-save')]" mode="ixsl:onclick">
         <xsl:variable name="dialog" as="element()" select="ancestor::div[@id = 'ldh-block-dialog']"/>
         <xsl:variable name="type" as="xs:string" select="string(ixsl:get(($dialog//select[@name = 'block-type-iri'])[1], 'value'))"/>
-        <xsl:variable name="about" as="xs:string" select="normalize-space(local:input-value($dialog, 'about'))"/>
-        <xsl:variable name="reference-uri" as="xs:string" select="normalize-space(local:input-value($dialog, 'reference-uri'))"/>
-        <xsl:variable name="view-query" as="xs:string" select="normalize-space(local:input-value($dialog, 'view-query'))"/>
-        <xsl:variable name="view-mode" as="xs:string" select="normalize-space(local:input-value($dialog, 'view-mode'))"/>
-        <xsl:variable name="chart-query" as="xs:string" select="normalize-space(local:input-value($dialog, 'chart-query'))"/>
+        <xsl:variable name="about" as="xs:string" select="normalize-space(rdfae:input-value($dialog, 'about'))"/>
+        <xsl:variable name="reference-uri" as="xs:string" select="normalize-space(rdfae:input-value($dialog, 'reference-uri'))"/>
+        <xsl:variable name="view-query" as="xs:string" select="normalize-space(rdfae:input-value($dialog, 'view-query'))"/>
+        <xsl:variable name="view-mode" as="xs:string" select="normalize-space(rdfae:input-value($dialog, 'view-mode'))"/>
+        <xsl:variable name="chart-query" as="xs:string" select="normalize-space(rdfae:input-value($dialog, 'chart-query'))"/>
         <xsl:variable name="chart-type" as="xs:string" select="string(ixsl:get(($dialog//select[@name = 'chart-type'])[1], 'value'))"/>
-        <xsl:variable name="chart-category" as="xs:string" select="normalize-space(local:input-value($dialog, 'chart-category'))"/>
-        <xsl:variable name="chart-series" as="xs:string" select="normalize-space(local:input-value($dialog, 'chart-series'))"/>
-        <xsl:variable name="reference" as="xs:boolean" select="$type = 'urn:rdfa-editor:reference'"/>
+        <xsl:variable name="chart-category" as="xs:string" select="normalize-space(rdfae:input-value($dialog, 'chart-category'))"/>
+        <xsl:variable name="chart-series" as="xs:string" select="normalize-space(rdfae:input-value($dialog, 'chart-series'))"/>
+        <xsl:variable name="reference" as="xs:boolean" select="$type = 'https://w3id.org/atomgraph/rdfa-editor#reference'"/>
         <xsl:variable name="valid" as="xs:boolean" select="
-            if ($reference) then local:is-absolute-iri($reference-uri)
+            if ($reference) then rdfae:is-absolute-iri($reference-uri)
             else $about ne '' and (
                 if ($type = '&ldh;View') then $view-query ne ''
                 else $chart-query ne '')"/>
         <xsl:if test="$valid">
-            <xsl:call-template name="local:push-undo"/>
+            <xsl:call-template name="rdfae:push-undo"/>
             <!-- the v6 block idiom: @about + @typeof directly on the element,
                  definition triples as property spans, fragment @about (the block
                  is a document part); NO containment edge - the document owns its
@@ -453,7 +453,7 @@ version="3.0">
                  the fragment rule: its @about is the referenced resource's own
                  absolute URI and it stays empty - naming the resource IS the
                  reference, no ldh:Object wrapper, no rdf:value span -->
-            <xsl:variable name="island" as="element()" select="local:element('div')"/>
+            <xsl:variable name="island" as="element()" select="rdfae:element('div')"/>
             <ixsl:set-attribute name="about" select="if ($reference) then $reference-uri else $about" object="$island"/>
             <xsl:if test="not($reference)">
                 <ixsl:set-attribute name="typeof" select="$type" object="$island"/>
@@ -462,29 +462,29 @@ version="3.0">
                 <xsl:choose>
                     <xsl:when test="$reference"/>
                     <xsl:when test="$type = '&ldh;View'">
-                        <xsl:call-template name="local:make-definition-span">
+                        <xsl:call-template name="rdfae:make-definition-span">
                             <xsl:with-param name="property" select="'&spin;query'"/>
                             <xsl:with-param name="resource" select="$view-query"/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:make-definition-span">
+                        <xsl:call-template name="rdfae:make-definition-span">
                             <xsl:with-param name="property" select="'&ac;mode'"/>
                             <xsl:with-param name="resource" select="$view-mode[. ne '']"/>
                         </xsl:call-template>
                     </xsl:when>
                     <xsl:otherwise>
-                        <xsl:call-template name="local:make-definition-span">
+                        <xsl:call-template name="rdfae:make-definition-span">
                             <xsl:with-param name="property" select="'&spin;query'"/>
                             <xsl:with-param name="resource" select="$chart-query"/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:make-definition-span">
+                        <xsl:call-template name="rdfae:make-definition-span">
                             <xsl:with-param name="property" select="'&ldh;chartType'"/>
                             <xsl:with-param name="resource" select="$chart-type"/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:make-definition-span">
+                        <xsl:call-template name="rdfae:make-definition-span">
                             <xsl:with-param name="property" select="'&ldh;categoryVarName'"/>
                             <xsl:with-param name="text" select="$chart-category[. ne '']"/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:make-definition-span">
+                        <xsl:call-template name="rdfae:make-definition-span">
                             <xsl:with-param name="property" select="'&ldh;seriesVarName'"/>
                             <xsl:with-param name="text" select="$chart-series[. ne '']"/>
                         </xsl:call-template>
@@ -498,23 +498,23 @@ version="3.0">
             <!-- placed per the content model relative to the host the dialog was
                  opened from (same path as figures/tables); init locks it, sets
                  tabindex and fires the renderer -->
-            <xsl:call-template name="local:insert-block-at-caret">
+            <xsl:call-template name="rdfae:insert-block-at-caret">
                 <xsl:with-param name="node" select="$island"/>
-                <xsl:with-param name="host" select="ixsl:get(local:editor-state(), 'insertHost')[exists(local:block-of(.))]"/>
+                <xsl:with-param name="host" select="ixsl:get(rdfae:editor-state(), 'insertHost')[exists(rdfae:block-of(.))]"/>
             </xsl:call-template>
-            <xsl:call-template name="local:init-block">
+            <xsl:call-template name="rdfae:init-block">
                 <xsl:with-param name="block" select="$island"/>
             </xsl:call-template>
-            <xsl:call-template name="local:select-island">
+            <xsl:call-template name="rdfae:select-island">
                 <xsl:with-param name="element" select="$island"/>
             </xsl:call-template>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:if>
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
     </xsl:template>
 
     <xsl:template match="button[contains-token(@class, 'ldh-block-cancel')]" mode="ixsl:onclick">
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
     </xsl:template>
 
 </xsl:stylesheet>
diff --git a/src/ldh-editor.xsl b/src/ldh-editor.xsl
index 9f87fbe..15b212a 100644
--- a/src/ldh-editor.xsl
+++ b/src/ldh-editor.xsl
@@ -7,7 +7,7 @@ version="3.0">
     The demo/dist entry: the core editor layered with the LinkedDataHub blocks
     extension. xsl:import puts the core at LOWER import precedence, so the
     included extension's declarations override it - $object-block-types, the
-    per-type mode="local:render-island" templates and the local:render-extra-*
+    per-type mode="rdfae:render-island" templates and the rdfae:render-extra-*
     hook stubs. This is exactly the shape LinkedDataHub's client.xsl uses to
     integrate the editor (docs/ldh/MIGRATION.md par. 10/12): in production,
     client.xsl plays the ldh-blocks.xsl role with its real ldh:RenderRow
diff --git a/src/lint-rdfa.xsl b/src/lint-rdfa.xsl
index 741f372..546031e 100644
--- a/src/lint-rdfa.xsl
+++ b/src/lint-rdfa.xsl
@@ -3,17 +3,17 @@
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
     xmlns:xs="http://www.w3.org/2001/XMLSchema"
     xmlns:map="http://www.w3.org/2005/xpath-functions/map"
-    xmlns:rdfa="urn:rdfa:functions"
-    xmlns:lint="urn:rdfa-editor:lint"
+    xmlns:rdfax="https://w3id.org/atomgraph/rdfa-editor/rdfa#"
+    xmlns:lint="https://w3id.org/atomgraph/rdfa-editor/lint#"
     xpath-default-namespace="http://www.w3.org/1999/xhtml"
-    exclude-result-prefixes="xs map rdfa"
+    exclude-result-prefixes="xs map rdfax"
     version="3.0">
 
 <!--
     RDFa lint: flags markup that extracts to something almost certainly unintended.
     Pure XSLT 3.0 - no ixsl: - tested headless via tests/lint-driver.xsl. Reuses the
-    extractor's resolution functions (rdfa:resolve-term-or-curie, rdfa:literal-value,
-    rdfa:bnode-label, $rdfa:default-prefixes), so lint verdicts and extraction
+    extractor's resolution functions (rdfax:resolve-term-or-curie, rdfax:literal-value,
+    rdfax:bnode-label, $rdfax:default-prefixes), so lint verdicts and extraction
     semantics cannot drift apart. Not standalone-compilable: include/import it
     alongside RDFa2RDFXML-v3.xsl.
 
@@ -38,8 +38,8 @@
     <!-- nearest-wins prefix map, mirroring the extractor's top-down merge -->
     <xsl:function name="lint:in-scope-prefixes" as="map(xs:string, xs:string)">
         <xsl:param name="element" as="element()"/>
-        <xsl:sequence select="map:merge(($rdfa:default-prefixes,
-            $element/ancestor-or-self::* ! (rdfa:in-scope-namespaces(.), rdfa:parse-prefix-attr(@prefix))),
+        <xsl:sequence select="map:merge(($rdfax:default-prefixes,
+            $element/ancestor-or-self::* ! (rdfax:in-scope-namespaces(.), rdfax:parse-prefix-attr(@prefix))),
             map{ 'duplicates': 'use-last' })"/>
     </xsl:function>
 
@@ -52,7 +52,7 @@
     <!-- deterministic element path, shared with the extractor's bnode labelling -->
     <xsl:function name="lint:path" as="xs:string">
         <xsl:param name="element" as="element()"/>
-        <xsl:sequence select="rdfa:bnode-label($element)"/>
+        <xsl:sequence select="rdfax:bnode-label($element)"/>
     </xsl:function>
 
     <xsl:function name="lint:element-issues" as="element(lint:issue)*">
@@ -64,7 +64,7 @@
         <!-- term-unresolvable -->
         <xsl:for-each select="$element/(@property, @typeof, @datatype)">
             <xsl:variable name="attribute" as="xs:string" select="name(.)"/>
-            <xsl:for-each select="tokenize(.)[empty(rdfa:resolve-term-or-curie(., $prefixes, $vocab))]">
+            <xsl:for-each select="tokenize(.)[empty(rdfax:resolve-term-or-curie(., $prefixes, $vocab))]">
                 <lint:issue code="term-unresolvable" path="{lint:path($element)}">@<xsl:value-of
                     select="$attribute"/> term '<xsl:value-of select="."/>' resolves to no IRI (no in-scope vocab or prefix)</lint:issue>
             </xsl:for-each>
@@ -84,11 +84,11 @@
         <!-- empty-literal: the extractor's statement branches, restricted to literal outcomes -->
         <xsl:for-each select="$element[@property][
                 (: literal via @content/@datatype (rule 5.2 branch) :)
-                ((@content or @datatype) and string((@content, rdfa:literal-value($element))[1]) = '')
+                ((@content or @datatype) and string((@content, rdfax:literal-value($element))[1]) = '')
                 or
                 (: plain text literal branch: no IRI object, no typeof chaining :)
                 (not(@content) and not(@datatype) and not(@resource) and not(@href) and not(@src)
-                    and not(@typeof and not(@about)) and rdfa:literal-value($element) = '')]">
+                    and not(@typeof and not(@about)) and rdfax:literal-value($element) = '')]">
             <lint:issue code="empty-literal" path="{lint:path($element)}">@property '<xsl:value-of
                 select="@property"/>' extracts an empty literal</lint:issue>
         </xsl:for-each>
diff --git a/src/lint-xhtml.xsl b/src/lint-xhtml.xsl
index d80c3af..b453764 100644
--- a/src/lint-xhtml.xsl
+++ b/src/lint-xhtml.xsl
@@ -2,8 +2,8 @@
 <xsl:stylesheet
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
     xmlns:xs="http://www.w3.org/2001/XMLSchema"
-    xmlns:cm="urn:rdfa-editor:content-model"
-    xmlns:lint="urn:rdfa-editor:lint"
+    xmlns:cm="https://w3id.org/atomgraph/rdfa-editor/content-model#"
+    xmlns:lint="https://w3id.org/atomgraph/rdfa-editor/lint#"
     xpath-default-namespace="http://www.w3.org/1999/xhtml"
     exclude-result-prefixes="xs cm"
     version="3.0">
diff --git a/src/navigate.xsl b/src/navigate.xsl
index a655c8b..d2de4d2 100644
--- a/src/navigate.xsl
+++ b/src/navigate.xsl
@@ -4,9 +4,9 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
-xmlns:rdfa="urn:rdfa:functions"
-xmlns:lint="urn:rdfa-editor:lint"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
+xmlns:rdfax="https://w3id.org/atomgraph/rdfa-editor/rdfa#"
+xmlns:lint="https://w3id.org/atomgraph/rdfa-editor/lint#"
 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
@@ -21,7 +21,7 @@ version="3.0">
     stripped, extractor-invisible; @title is forbidden - it would serialize).
 -->
 
-    <xsl:template name="local:init-navigate">
+    <xsl:template name="rdfae:init-navigate">
         <xsl:for-each select="ixsl:page()//body">
             <xsl:result-document href="?." method="ixsl:append-content">
                 <aside id="toc-drawer" class="rdfa-editor-ui" role="navigation" aria-label="Table of contents" style="display: none;">
@@ -43,31 +43,31 @@ version="3.0">
                             aria-label="RDFa validation issues" style="display: none;"/>
                     </div>
                 </footer>
-                <xsl:call-template name="local:render-find-dialog"/>
+                <xsl:call-template name="rdfae:render-find-dialog"/>
             </xsl:result-document>
         </xsl:for-each>
-        <xsl:call-template name="local:run-lint"/>
-        <xsl:call-template name="local:update-breadcrumb"/>
+        <xsl:call-template name="rdfae:run-lint"/>
+        <xsl:call-template name="rdfae:update-breadcrumb"/>
     </xsl:template>
 
     <!-- ................................ ToC drawer ................................ -->
 
-    <xsl:function name="local:rank" as="xs:integer">
+    <xsl:function name="rdfae:rank" as="xs:integer">
         <xsl:param name="heading" as="element()"/>
         <xsl:sequence select="xs:integer(substring(local-name($heading), 2))"/>
     </xsl:function>
 
-    <xsl:template name="local:render-toc">
-        <xsl:variable name="root" as="element()?" select="local:active-root()"/>
+    <xsl:template name="rdfae:render-toc">
+        <xsl:variable name="root" as="element()?" select="rdfae:active-root()"/>
         <xsl:variable name="headings" as="element()*" select="$root/(h1 | h2 | h3)"/>
         <!-- remembered for item click/drag resolution (roots are never replaced, only
              their children, so the reference stays valid across undo restores) -->
-        <ixsl:set-property name="tocRoot" select="$root" object="local:editor-state()"/>
+        <ixsl:set-property name="tocRoot" select="$root" object="rdfae:editor-state()"/>
         <xsl:for-each select="id('toc-list', ixsl:page())">
             <xsl:result-document href="?." method="ixsl:replace-content">
                 <xsl:choose>
                     <xsl:when test="exists($headings)">
-                        <xsl:call-template name="local:toc-level">
+                        <xsl:call-template name="rdfae:toc-level">
                             <xsl:with-param name="headings" select="$headings"/>
                             <xsl:with-param name="root" select="$root"/>
                             <xsl:with-param name="rank" select="1"/>
@@ -82,20 +82,20 @@ version="3.0">
     </xsl:template>
 
     <!-- hierarchical outline by heading rank; handles skipped ranks naturally -->
-    <xsl:template name="local:toc-level">
+    <xsl:template name="rdfae:toc-level">
         <xsl:param name="headings" as="element()*"/>
         <xsl:param name="root" as="element()"/>
         <xsl:param name="rank" as="xs:integer"/>
 
         <ul>
-            <xsl:for-each-group select="$headings" group-starting-with="*[local:rank(.) le $rank]">
+            <xsl:for-each-group select="$headings" group-starting-with="*[rdfae:rank(.) le $rank]">
                 <li class="toc-item toc-{local-name(current-group()[1])}" draggable="true"
                     data-index="{count($root/(h1 | h2 | h3)[. &lt;&lt; current-group()[1]]) + 1}">
                     <span class="toc-label">
-                        <xsl:value-of select="local:block-text(current-group()[1])"/>
+                        <xsl:value-of select="rdfae:block-text(current-group()[1])"/>
                     </span>
                     <xsl:if test="exists(current-group()[position() gt 1])">
-                        <xsl:call-template name="local:toc-level">
+                        <xsl:call-template name="rdfae:toc-level">
                             <xsl:with-param name="headings" select="current-group()[position() gt 1]"/>
                             <xsl:with-param name="root" select="$root"/>
                             <xsl:with-param name="rank" select="$rank + 1"/>
@@ -110,7 +110,7 @@ version="3.0">
         <xsl:for-each select="id('toc-drawer', ixsl:page())">
             <xsl:choose>
                 <xsl:when test="ixsl:get(., 'style.display') = 'none'">
-                    <xsl:call-template name="local:render-toc"/>
+                    <xsl:call-template name="rdfae:render-toc"/>
                     <ixsl:set-style name="display" select="'block'"/>
                 </xsl:when>
                 <xsl:otherwise>
@@ -133,7 +133,7 @@ version="3.0">
             <xsl:choose>
                 <xsl:when test="ixsl:get(., 'style.display') = 'none'">
                     <ixsl:set-style name="display" select="'block'"/>
-                    <xsl:call-template name="local:sync-inspector"/>
+                    <xsl:call-template name="rdfae:sync-inspector"/>
                 </xsl:when>
                 <xsl:otherwise>
                     <ixsl:set-style name="display" select="'none'"/>
@@ -150,24 +150,24 @@ version="3.0">
 
     <xsl:template match="span[contains-token(@class, 'toc-label')]" mode="ixsl:onclick">
         <xsl:variable name="index" as="xs:integer" select="xs:integer(../@data-index)"/>
-        <xsl:for-each select="(ixsl:get(local:editor-state(), 'tocRoot')/(h1 | h2 | h3))[$index]">
+        <xsl:for-each select="(ixsl:get(rdfae:editor-state(), 'tocRoot')/(h1 | h2 | h3))[$index]">
             <xsl:sequence select="ixsl:call(., 'scrollIntoView', [ map{ 'block': 'start' } ])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:call-template name="local:focus-caret">
+            <xsl:call-template name="rdfae:focus-caret">
     <xsl:with-param name="node" select="."/>
-    <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+    <xsl:with-param name="offset" select="rdfae:chrome-count(.)"/>
 </xsl:call-template>
-            <xsl:call-template name="local:update-breadcrumb"/>
+            <xsl:call-template name="rdfae:update-breadcrumb"/>
         </xsl:for-each>
     </xsl:template>
 
     <!-- ................................ ToC section drag ................................ -->
 
     <!-- a section = the heading plus everything up to the next same-or-higher heading -->
-    <xsl:function name="local:section-of" as="element()+">
+    <xsl:function name="rdfae:section-of" as="element()+">
         <xsl:param name="heading" as="element()"/>
         <xsl:variable name="stop" as="element()?"
             select="$heading/following-sibling::*[self::h1 or self::h2 or self::h3]
-                [local:rank(.) le local:rank($heading)][1]"/>
+                [rdfae:rank(.) le rdfae:rank($heading)][1]"/>
         <xsl:sequence select="$heading | $heading/following-sibling::*[empty($stop) or . &lt;&lt; $stop]"/>
     </xsl:function>
 
@@ -175,7 +175,7 @@ version="3.0">
         <xsl:variable name="transfer" select="ixsl:get(ixsl:event(), 'dataTransfer')"/>
         <xsl:variable name="index" as="xs:integer" select="xs:integer(@data-index)"/>
         <ixsl:set-property name="draggedSectionHeading"
-            select="(ixsl:get(local:editor-state(), 'tocRoot')/(h1 | h2 | h3))[$index]" object="local:editor-state()"/>
+            select="(ixsl:get(rdfae:editor-state(), 'tocRoot')/(h1 | h2 | h3))[$index]" object="rdfae:editor-state()"/>
         <ixsl:set-property name="effectAllowed" select="'move'" object="$transfer"/>
         <xsl:sequence select="ixsl:call($transfer, 'setData', [ 'application/x-rdfa-editor-section', '' ])[current-date() lt xs:date('2000-01-01')]"/>
         <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'add', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
@@ -183,38 +183,38 @@ version="3.0">
 
     <xsl:template match="li[contains-token(@class, 'toc-item')]" mode="ixsl:ondragover">
         <xsl:variable name="event" select="ixsl:event()"/>
-        <xsl:if test="exists(ixsl:get(local:editor-state(), 'draggedSectionHeading'))
-                and local:has-transfer-type($event, 'application/x-rdfa-editor-section')">
+        <xsl:if test="exists(ixsl:get(rdfae:editor-state(), 'draggedSectionHeading'))
+                and rdfae:has-transfer-type($event, 'application/x-rdfa-editor-section')">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
             <ixsl:set-property name="dropEffect" select="'move'" object="ixsl:get($event, 'dataTransfer')"/>
-            <xsl:call-template name="local:clear-drop-marks">
+            <xsl:call-template name="rdfae:clear-drop-marks">
             <xsl:with-param name="scope" select="id('toc-list', ixsl:page())//li"/>
         </xsl:call-template>
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'add',
-                [ if (local:drop-before($event, .)) then 'drop-before' else 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
+                [ if (rdfae:drop-before($event, .)) then 'drop-before' else 'drop-after' ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
     </xsl:template>
 
     <xsl:template match="li[contains-token(@class, 'toc-item')]" mode="ixsl:ondrop">
         <xsl:variable name="event" select="ixsl:event()"/>
         <xsl:variable name="item" as="element()" select="."/>
-        <xsl:variable name="source" select="ixsl:get(local:editor-state(), 'draggedSectionHeading')"/>
-        <xsl:variable name="before" as="xs:boolean" select="local:drop-before($event, $item)"/>
-        <xsl:call-template name="local:clear-drop-marks">
+        <xsl:variable name="source" select="ixsl:get(rdfae:editor-state(), 'draggedSectionHeading')"/>
+        <xsl:variable name="before" as="xs:boolean" select="rdfae:drop-before($event, $item)"/>
+        <xsl:call-template name="rdfae:clear-drop-marks">
             <xsl:with-param name="scope" select="id('toc-list', ixsl:page())//li"/>
         </xsl:call-template>
-        <xsl:if test="exists($source) and local:has-transfer-type($event, 'application/x-rdfa-editor-section')">
+        <xsl:if test="exists($source) and rdfae:has-transfer-type($event, 'application/x-rdfa-editor-section')">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
             <!-- bare-variable positional predicate: SaxonJS evaluates computed numeric
                  predicates as booleans in this context -->
             <xsl:variable name="index" as="xs:integer" select="xs:integer($item/@data-index)"/>
             <xsl:variable name="target" as="element()?"
-                select="(ixsl:get(local:editor-state(), 'tocRoot')/(h1 | h2 | h3))[$index]"/>
+                select="(ixsl:get(rdfae:editor-state(), 'tocRoot')/(h1 | h2 | h3))[$index]"/>
             <!-- no-op: dropping onto itself or into its own section (incl. subsections) -->
             <xsl:if test="exists($target) and not($target is $source)
-                    and empty($target intersect local:section-of($source))">
-                <xsl:call-template name="local:push-undo"/>
-                <xsl:variable name="section" as="element()+" select="local:section-of($source)"/>
+                    and empty($target intersect rdfae:section-of($source))">
+                <xsl:call-template name="rdfae:push-undo"/>
+                <xsl:variable name="section" as="element()+" select="rdfae:section-of($source)"/>
                 <xsl:choose>
                     <xsl:when test="$before">
                         <xsl:for-each select="$section">
@@ -223,7 +223,7 @@ version="3.0">
                     </xsl:when>
                     <xsl:otherwise>
                         <xsl:iterate select="$section">
-                            <xsl:param name="anchor" as="element()" select="local:section-of($target)[last()]"/>
+                            <xsl:param name="anchor" as="element()" select="rdfae:section-of($target)[last()]"/>
                             <xsl:sequence select="ixsl:call($anchor, 'after', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
                             <xsl:next-iteration>
                                 <xsl:with-param name="anchor" select="."/>
@@ -232,49 +232,49 @@ version="3.0">
                     </xsl:otherwise>
                 </xsl:choose>
                 <!-- after-mutation re-renders the (open) ToC -->
-                <xsl:call-template name="local:after-mutation"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
             </xsl:if>
         </xsl:if>
     </xsl:template>
 
     <xsl:template match="li[contains-token(@class, 'toc-item')]" mode="ixsl:ondragend">
         <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:clear-drop-marks">
+        <xsl:call-template name="rdfae:clear-drop-marks">
             <xsl:with-param name="scope" select="id('toc-list', ixsl:page())//li"/>
         </xsl:call-template>
-        <ixsl:set-property name="draggedSectionHeading" select="()" object="local:editor-state()"/>
+        <ixsl:set-property name="draggedSectionHeading" select="()" object="rdfae:editor-state()"/>
     </xsl:template>
 
     <!-- ................................ breadcrumb ................................ -->
 
-    <xsl:function name="local:compact-term" as="xs:string">
+    <xsl:function name="rdfae:compact-term" as="xs:string">
         <xsl:param name="term" as="xs:string"/>
         <xsl:sequence select="if (matches($term, '^[a-zA-Z][a-zA-Z0-9+.-]*:'))
-            then rdfa:prefixed-name(rdfa:split-uri($term), $rdfa:default-prefixes)
+            then rdfax:prefixed-name(rdfax:split-uri($term), $rdfax:default-prefixes)
             else $term"/>
     </xsl:function>
 
-    <xsl:function name="local:crumb-label" as="xs:string">
+    <xsl:function name="rdfae:crumb-label" as="xs:string">
         <xsl:param name="element" as="element()"/>
         <xsl:choose>
             <xsl:when test="contains-token($element/@class, 'rdfa-editor-content')">content</xsl:when>
             <xsl:otherwise>
                 <xsl:variable name="term" as="xs:string?"
                     select="($element/@property, $element/@typeof)[1] ! tokenize(.)[1]"/>
-                <xsl:sequence select="local-name($element) || ($term ! ('[' || local:compact-term(.) || ']'), '')[1]"/>
+                <xsl:sequence select="local-name($element) || ($term ! ('[' || rdfae:compact-term(.) || ']'), '')[1]"/>
             </xsl:otherwise>
         </xsl:choose>
     </xsl:function>
 
-    <xsl:template name="local:update-breadcrumb">
-        <xsl:variable name="node" select="(local:anchor-node(),
-            ixsl:get(local:editor-state(), 'activeBlock'))[1]"/>
+    <xsl:template name="rdfae:update-breadcrumb">
+        <xsl:variable name="node" select="(rdfae:anchor-node(),
+            ixsl:get(rdfae:editor-state(), 'activeBlock'))[1]"/>
         <xsl:variable name="leaf" as="element()?" select="$node/ancestor-or-self::*[1]"/>
         <xsl:choose>
-            <xsl:when test="exists($leaf) and exists(local:block-of($leaf))">
-                <ixsl:set-property name="breadcrumbLeaf" select="$leaf" object="local:editor-state()"/>
+            <xsl:when test="exists($leaf) and exists(rdfae:block-of($leaf))">
+                <ixsl:set-property name="breadcrumbLeaf" select="$leaf" object="rdfae:editor-state()"/>
                 <xsl:variable name="ancestors" as="element()*"
-                    select="$leaf/ancestor-or-self::* intersect local:root-of($leaf)/descendant-or-self::*"/>
+                    select="$leaf/ancestor-or-self::* intersect rdfae:root-of($leaf)/descendant-or-self::*"/>
                 <xsl:for-each select="id('rdfa-editor-breadcrumb-path', ixsl:page())">
                     <xsl:result-document href="?." method="ixsl:replace-content">
                         <xsl:for-each select="$ancestors">
@@ -282,42 +282,42 @@ version="3.0">
                                 <span class="crumb-sep">&#x203A;</span>
                             </xsl:if>
                             <span class="crumb" data-index="{position()}">
-                                <xsl:value-of select="local:crumb-label(.)"/>
+                                <xsl:value-of select="rdfae:crumb-label(.)"/>
                             </span>
                         </xsl:for-each>
                     </xsl:result-document>
                 </xsl:for-each>
                 <xsl:for-each select="id('rdfa-editor-breadcrumb-subject', ixsl:page())">
                     <ixsl:set-property name="textContent"
-                        select="rdfa:in-scope-subject($leaf, local:document-uri())" object="."/>
+                        select="rdfax:in-scope-subject($leaf, rdfae:document-uri())" object="."/>
                 </xsl:for-each>
             </xsl:when>
             <xsl:otherwise>
-                <ixsl:set-property name="breadcrumbLeaf" select="()" object="local:editor-state()"/>
+                <ixsl:set-property name="breadcrumbLeaf" select="()" object="rdfae:editor-state()"/>
                 <xsl:for-each select="id('rdfa-editor-breadcrumb-path', ixsl:page())">
                     <ixsl:set-property name="textContent" select="''" object="."/>
                 </xsl:for-each>
                 <xsl:for-each select="id('rdfa-editor-breadcrumb-subject', ixsl:page())">
-                    <ixsl:set-property name="textContent" select="local:document-uri()" object="."/>
+                    <ixsl:set-property name="textContent" select="rdfae:document-uri()" object="."/>
                 </xsl:for-each>
             </xsl:otherwise>
         </xsl:choose>
-        <xsl:call-template name="local:sync-table-toolbar"/>
-        <xsl:call-template name="local:sync-format-toolbar"/>
-        <xsl:call-template name="local:sync-inspector"/>
+        <xsl:call-template name="rdfae:sync-table-toolbar"/>
+        <xsl:call-template name="rdfae:sync-format-toolbar"/>
+        <xsl:call-template name="rdfae:sync-inspector"/>
     </xsl:template>
 
     <!-- the property sheet for the subject in scope at the caret. Read-only: it
          re-presents the extractor's own output (grouped per subject) so its verdicts
          can never drift from "Extract RDF"/lint. Only does work while the drawer is
-         open; rides local:update-breadcrumb, so it tracks the caret and refreshes
-         after every mutation (annotate/undo route through local:after-mutation). -->
-    <xsl:template name="local:sync-inspector">
+         open; rides rdfae:update-breadcrumb, so it tracks the caret and refreshes
+         after every mutation (annotate/undo route through rdfae:after-mutation). -->
+    <xsl:template name="rdfae:sync-inspector">
         <xsl:for-each select="id('inspector-drawer', ixsl:page())[ixsl:get(., 'style.display') ne 'none']">
-            <xsl:variable name="base" as="xs:string" select="local:document-uri()"/>
-            <xsl:variable name="leaf" select="ixsl:get(local:editor-state(), 'breadcrumbLeaf')"/>
+            <xsl:variable name="base" as="xs:string" select="rdfae:document-uri()"/>
+            <xsl:variable name="leaf" select="ixsl:get(rdfae:editor-state(), 'breadcrumbLeaf')"/>
             <xsl:variable name="subject" as="xs:string"
-                select="((if (exists($leaf)) then rdfa:in-scope-subject($leaf, $base) else ())[. ne ''], $base)[1]"/>
+                select="((if (exists($leaf)) then rdfax:in-scope-subject($leaf, $base) else ())[. ne ''], $base)[1]"/>
             <xsl:variable name="rdf" as="element(rdf:RDF)">
                 <xsl:call-template name="extract-rdfa">
                     <xsl:with-param name="doc" select="ixsl:page()"/>
@@ -325,7 +325,7 @@ version="3.0">
                 </xsl:call-template>
             </xsl:variable>
             <xsl:variable name="desc" as="element(rdf:Description)?" select="
-                local:group-triples($rdf)/rdf:Description[
+                rdfae:group-triples($rdf)/rdf:Description[
                     (@rdf:about = $subject)
                     or (starts-with($subject, '_:') and @rdf:nodeID = substring-after($subject, '_:'))
                 ]"/>
@@ -333,11 +333,11 @@ version="3.0">
             <xsl:for-each select="id('inspector-subject', ixsl:page())">
                 <xsl:result-document href="?." method="ixsl:replace-content">
                     <span class="inspector-subject-iri">
-                        <xsl:value-of select="local:short-iri($subject, $base)"/>
+                        <xsl:value-of select="rdfae:short-iri($subject, $base)"/>
                     </span>
                     <xsl:for-each select="$desc/rdf:type/@rdf:resource">
                         <span class="inspector-type">
-                            <xsl:value-of select="local:compact-term(.)"/>
+                            <xsl:value-of select="rdfae:compact-term(.)"/>
                         </span>
                     </xsl:for-each>
                 </xsl:result-document>
@@ -351,13 +351,13 @@ version="3.0">
                             <xsl:for-each select="$props">
                                 <div class="inspector-row">
                                     <span class="inspector-pred">
-                                        <xsl:value-of select="local:compact-term(namespace-uri() || local-name())"/>
+                                        <xsl:value-of select="rdfae:compact-term(namespace-uri() || local-name())"/>
                                     </span>
                                     <span class="inspector-obj">
                                         <xsl:choose>
                                             <xsl:when test="@rdf:resource">
                                                 <span class="inspector-obj-iri">
-                                                    <xsl:value-of select="local:short-iri(@rdf:resource, $base)"/>
+                                                    <xsl:value-of select="rdfae:short-iri(@rdf:resource, $base)"/>
                                                 </span>
                                             </xsl:when>
                                             <xsl:when test="@rdf:nodeID">
@@ -366,7 +366,7 @@ version="3.0">
                                             <xsl:otherwise>
                                                 <span class="inspector-obj-lit"><xsl:value-of select="."/></span>
                                                 <xsl:if test="@rdf:datatype">
-                                                    <span class="inspector-obj-dt"><xsl:value-of select="local:compact-term(@rdf:datatype)"/></span>
+                                                    <span class="inspector-obj-dt"><xsl:value-of select="rdfae:compact-term(@rdf:datatype)"/></span>
                                                 </xsl:if>
                                                 <xsl:if test="@xml:lang">
                                                     <span class="inspector-obj-lang">@<xsl:value-of select="@xml:lang"/></span>
@@ -387,14 +387,14 @@ version="3.0">
     </xsl:template>
 
     <!-- readable object/subject: the document itself, a same-document fragment, or a CURIE -->
-    <xsl:function name="local:short-iri" as="xs:string">
+    <xsl:function name="rdfae:short-iri" as="xs:string">
         <xsl:param name="iri" as="xs:string"/>
         <xsl:param name="base" as="xs:string"/>
         <xsl:sequence select="
             if ($iri eq $base) then 'this document'
             else if (starts-with($iri, '_:')) then $iri
             else if (starts-with($iri, $base)) then substring-after($iri, $base)
-            else local:compact-term($iri)"/>
+            else rdfae:compact-term($iri)"/>
     </xsl:function>
 
     <xsl:template match="span[contains-token(@class, 'crumb')]" mode="ixsl:onmousedown">
@@ -403,25 +403,25 @@ version="3.0">
 
     <xsl:template match="span[contains-token(@class, 'crumb')]" mode="ixsl:onclick">
         <xsl:variable name="index" as="xs:integer" select="xs:integer(@data-index)"/>
-        <xsl:for-each select="ixsl:get(local:editor-state(), 'breadcrumbLeaf')[exists(local:block-of(.))]">
+        <xsl:for-each select="ixsl:get(rdfae:editor-state(), 'breadcrumbLeaf')[exists(rdfae:block-of(.))]">
             <xsl:variable name="target" as="element()?"
-                select="(ancestor-or-self::* intersect local:root-of(.)/descendant-or-self::*)[$index]"/>
+                select="(ancestor-or-self::* intersect rdfae:root-of(.)/descendant-or-self::*)[$index]"/>
             <xsl:for-each select="$target">
-                <xsl:sequence select="ixsl:call(local:selection(),
+                <xsl:sequence select="ixsl:call(rdfae:selection(),
                     'selectAllChildren', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:for-each>
         </xsl:for-each>
-        <xsl:call-template name="local:update-breadcrumb"/>
+        <xsl:call-template name="rdfae:update-breadcrumb"/>
     </xsl:template>
 
     <!-- caret movement awareness: keyup and mouseup on hosts (no document-level
          selectionchange - unproven in SaxonJS); focusin is handled in edit.xsl -->
     <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onkeyup">
-        <xsl:if test="exists(local:block-of(.))">
-            <xsl:call-template name="local:update-breadcrumb"/>
+        <xsl:if test="exists(rdfae:block-of(.))">
+            <xsl:call-template name="rdfae:update-breadcrumb"/>
             <xsl:if test="(self::h1 or self::h2 or self::h3)
                     and id('toc-drawer', ixsl:page()) ! (ixsl:get(., 'style.display') ne 'none')">
-                <xsl:call-template name="local:render-toc"/>
+                <xsl:call-template name="rdfae:render-toc"/>
             </xsl:if>
         </xsl:if>
     </xsl:template>
@@ -429,21 +429,21 @@ version="3.0">
     <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onmouseup">
         <!-- innermost-match dispatch: a sweep ending over a host lands here, not
              on the body/html disarm template (select.xsl) -->
-        <xsl:call-template name="local:disarm-sweep"/>
-        <xsl:if test="exists(local:block-of(.))">
-            <xsl:call-template name="local:update-breadcrumb"/>
+        <xsl:call-template name="rdfae:disarm-sweep"/>
+        <xsl:if test="exists(rdfae:block-of(.))">
+            <xsl:call-template name="rdfae:update-breadcrumb"/>
         </xsl:if>
     </xsl:template>
 
     <!-- ................................ lint surfacing ................................ -->
 
-    <xsl:template name="local:run-lint">
-        <xsl:for-each select="local:roots()//*[contains-token(@class, 'rdfa-invalid')]">
+    <xsl:template name="rdfae:run-lint">
+        <xsl:for-each select="rdfae:roots()//*[contains-token(@class, 'rdfa-invalid')]">
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'rdfa-invalid' ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
         <!-- the issue functions run once per element: markers and the badge count
              both derive from the same evaluation (this fires on every mutation) -->
-        <xsl:variable name="linted" as="map(*)*" select="local:roots() ! lint:lintable(.) ! map{
+        <xsl:variable name="linted" as="map(*)*" select="rdfae:roots() ! lint:lintable(.) ! map{
             'element': .,
             'issues': count((lint:element-issues(.), lint:nesting-issues(.))) }"/>
         <xsl:for-each select="$linted[?issues gt 0]?element">
@@ -466,9 +466,9 @@ version="3.0">
 
     <xsl:template match="button[@id = 'lint-badge']" mode="ixsl:onclick">
         <xsl:variable name="lines" as="xs:string*"
-            select="local:roots() ! lint:lintable(.) ! (lint:element-issues(.), lint:nesting-issues(.))
+            select="rdfae:roots() ! lint:lintable(.) ! (lint:element-issues(.), lint:nesting-issues(.))
                 ! (string(@code) || ' &#x2014; ' || normalize-space(string(.)))"/>
-        <xsl:call-template name="local:show-output">
+        <xsl:call-template name="rdfae:show-output">
             <xsl:with-param name="title" select="'Validation issues'"/>
             <xsl:with-param name="text" select="string-join($lines, '&#10;')"/>
         </xsl:call-template>
@@ -476,37 +476,37 @@ version="3.0">
 
     <!-- ................................ find &amp; replace ................................ -->
 
-    <xsl:function name="local:norm" as="xs:string">
+    <xsl:function name="rdfae:norm" as="xs:string">
         <xsl:param name="s" as="xs:string"/>
         <xsl:param name="ci" as="xs:boolean"/>
         <xsl:sequence select="if ($ci) then lower-case($s) else $s"/>
     </xsl:function>
 
     <!-- 1-based position of the next occurrence at or after $from, or empty -->
-    <xsl:function name="local:find-in" as="xs:integer?">
+    <xsl:function name="rdfae:find-in" as="xs:integer?">
         <xsl:param name="hay" as="xs:string"/>
         <xsl:param name="from" as="xs:integer"/>
         <xsl:param name="query" as="xs:string"/>
         <xsl:param name="ci" as="xs:boolean"/>
-        <xsl:variable name="tail" as="xs:string" select="local:norm(substring($hay, $from), $ci)"/>
-        <xsl:variable name="q" as="xs:string" select="local:norm($query, $ci)"/>
+        <xsl:variable name="tail" as="xs:string" select="rdfae:norm(substring($hay, $from), $ci)"/>
+        <xsl:variable name="q" as="xs:string" select="rdfae:norm($query, $ci)"/>
         <xsl:sequence select="if (contains($tail, $q))
             then $from + string-length(substring-before($tail, $q)) else ()"/>
     </xsl:function>
 
     <!-- all occurrences replaced within one string; returns map{'value','count'} -->
-    <xsl:function name="local:replace-in-string" as="map(*)">
+    <xsl:function name="rdfae:replace-in-string" as="map(*)">
         <xsl:param name="hay" as="xs:string"/>
         <xsl:param name="query" as="xs:string"/>
         <xsl:param name="replacement" as="xs:string"/>
         <xsl:param name="ci" as="xs:boolean"/>
-        <xsl:variable name="p" as="xs:integer?" select="local:find-in($hay, 1, $query, $ci)"/>
+        <xsl:variable name="p" as="xs:integer?" select="rdfae:find-in($hay, 1, $query, $ci)"/>
         <xsl:choose>
             <xsl:when test="empty($p)">
                 <xsl:sequence select="map{ 'value': $hay, 'count': 0 }"/>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:variable name="rest" as="map(*)" select="local:replace-in-string(
+                <xsl:variable name="rest" as="map(*)" select="rdfae:replace-in-string(
                     substring($hay, $p + string-length($query)), $query, $replacement, $ci)"/>
                 <xsl:sequence select="map{
                     'value': substring($hay, 1, $p - 1) || $replacement || $rest?value,
@@ -515,7 +515,7 @@ version="3.0">
         </xsl:choose>
     </xsl:function>
 
-    <xsl:template name="local:render-find-dialog">
+    <xsl:template name="rdfae:render-find-dialog">
         <div id="find-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
                 aria-label="Find and replace" style="display: none;">
             <label>Find</label>
@@ -537,7 +537,7 @@ version="3.0">
 
     <xsl:template match="button[@id = 'find-open']" mode="ixsl:onclick">
         <xsl:variable name="dialog" as="element()" select="id('find-dialog', ixsl:page())"/>
-        <xsl:call-template name="local:show-at">
+        <xsl:call-template name="rdfae:show-at">
             <xsl:with-param name="element" select="$dialog"/>
             <xsl:with-param name="event" select="ixsl:event()"/>
         </xsl:call-template>
@@ -552,10 +552,10 @@ version="3.0">
     </xsl:template>
 
     <xsl:template match="button[contains-token(@class, 'find-close')]" mode="ixsl:onclick">
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
     </xsl:template>
 
-    <xsl:template name="local:find-status">
+    <xsl:template name="rdfae:find-status">
         <xsl:param name="message" as="xs:string"/>
         <xsl:for-each select="id('find-status', ixsl:page())">
             <ixsl:set-property name="textContent" select="$message" object="."/>
@@ -563,10 +563,10 @@ version="3.0">
     </xsl:template>
 
     <xsl:template match="button[contains-token(@class, 'find-next')]" mode="ixsl:onclick">
-        <xsl:call-template name="local:find-next"/>
+        <xsl:call-template name="rdfae:find-next"/>
     </xsl:template>
 
-    <xsl:template name="local:find-next">
+    <xsl:template name="rdfae:find-next">
         <xsl:variable name="dialog" as="element()" select="id('find-dialog', ixsl:page())"/>
         <xsl:variable name="query" as="xs:string"
             select="string(ixsl:get(($dialog//input[@name = 'find'])[1], 'value'))"/>
@@ -574,15 +574,15 @@ version="3.0">
             select="not(ixsl:get(($dialog//input[@name = 'match-case'])[1], 'checked'))"/>
         <xsl:choose>
             <xsl:when test="$query = ''">
-                <xsl:call-template name="local:find-status">
+                <xsl:call-template name="rdfae:find-status">
                     <xsl:with-param name="message" select="'Enter a search term.'"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:variable name="texts" select="local:roots()//text()[not(ancestor::*[@data-role])]"/>
-                <xsl:variable name="current" select="ixsl:get(local:editor-state(), 'findNode')[exists(local:block-of(.))]"/>
+                <xsl:variable name="texts" select="rdfae:roots()//text()[not(ancestor::*[@data-role])]"/>
+                <xsl:variable name="current" select="ixsl:get(rdfae:editor-state(), 'findNode')[exists(rdfae:block-of(.))]"/>
                 <xsl:variable name="offset" as="xs:integer"
-                    select="(ixsl:get(local:editor-state(), 'findOffset') ! xs:integer(.), 1)[1]"/>
+                    select="(ixsl:get(rdfae:editor-state(), 'findOffset') ! xs:integer(.), 1)[1]"/>
                 <!-- wrap-around scan plan: current node from the last match onward,
                      following nodes, preceding nodes, current node from the top -->
                 <xsl:variable name="plan" as="map(*)*" select="
@@ -594,34 +594,34 @@ version="3.0">
                     else for $t in $texts return map{ 'n': $t, 'from': 1 }"/>
                 <xsl:iterate select="$plan">
                     <xsl:on-completion>
-                        <xsl:call-template name="local:find-status">
+                        <xsl:call-template name="rdfae:find-status">
                             <xsl:with-param name="message" select="'No matches.'"/>
                         </xsl:call-template>
-                        <ixsl:set-property name="findNode" select="()" object="local:editor-state()"/>
-                        <ixsl:set-property name="findOffset" select="1" object="local:editor-state()"/>
+                        <ixsl:set-property name="findNode" select="()" object="rdfae:editor-state()"/>
+                        <ixsl:set-property name="findOffset" select="1" object="rdfae:editor-state()"/>
                     </xsl:on-completion>
                     <xsl:variable name="node" select="?n"/>
                     <xsl:variable name="position" as="xs:integer?"
-                        select="local:find-in(string($node), ?from, $query, $ci)"/>
+                        select="rdfae:find-in(string($node), ?from, $query, $ci)"/>
                     <xsl:choose>
                         <xsl:when test="exists($position)">
-                            <xsl:for-each select="local:host-of($node)">
-                                <xsl:call-template name="local:focus">
+                            <xsl:for-each select="rdfae:host-of($node)">
+                                <xsl:call-template name="rdfae:focus">
                                     <xsl:with-param name="element" select="."/>
                                 </xsl:call-template>
                             </xsl:for-each>
-                            <xsl:sequence select="ixsl:call(local:selection(),
+                            <xsl:sequence select="ixsl:call(rdfae:selection(),
                                 'setBaseAndExtent', [ $node, $position - 1, $node,
                                     $position - 1 + string-length($query) ])[current-date() lt xs:date('2000-01-01')]"/>
                             <xsl:sequence select="ixsl:call(ixsl:get($node, 'parentElement'), 'scrollIntoView',
                                 [ map{ 'block': 'center' } ])[current-date() lt xs:date('2000-01-01')]"/>
-                            <ixsl:set-property name="findNode" select="$node" object="local:editor-state()"/>
+                            <ixsl:set-property name="findNode" select="$node" object="rdfae:editor-state()"/>
                             <ixsl:set-property name="findOffset"
-                                select="$position + string-length($query)" object="local:editor-state()"/>
-                            <xsl:call-template name="local:find-status">
+                                select="$position + string-length($query)" object="rdfae:editor-state()"/>
+                            <xsl:call-template name="rdfae:find-status">
                                 <xsl:with-param name="message" select="''"/>
                             </xsl:call-template>
-                            <xsl:call-template name="local:update-breadcrumb"/>
+                            <xsl:call-template name="rdfae:update-breadcrumb"/>
                             <xsl:break/>
                         </xsl:when>
                         <xsl:otherwise>
@@ -641,27 +641,27 @@ version="3.0">
             select="string(ixsl:get(($dialog//input[@name = 'replace'])[1], 'value'))"/>
         <xsl:variable name="ci" as="xs:boolean"
             select="not(ixsl:get(($dialog//input[@name = 'match-case'])[1], 'checked'))"/>
-        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:choose>
             <!-- the current selection is the match found by find-next -->
             <xsl:when test="$query ne '' and ixsl:get($selection, 'rangeCount') ge 1
                     and not(ixsl:get($selection, 'isCollapsed'))
-                    and (ixsl:get($selection, 'anchorNode') ! exists(local:block-of(.)))
-                    and local:norm(string(ixsl:call($selection, 'toString', [])), $ci) eq local:norm($query, $ci)">
-                <xsl:variable name="range" select="local:caret-range()"/>
-                <xsl:call-template name="local:push-undo"/>
+                    and (ixsl:get($selection, 'anchorNode') ! exists(rdfae:block-of(.)))
+                    and rdfae:norm(string(ixsl:call($selection, 'toString', [])), $ci) eq rdfae:norm($query, $ci)">
+                <xsl:variable name="range" select="rdfae:caret-range()"/>
+                <xsl:call-template name="rdfae:push-undo"/>
                 <xsl:sequence select="ixsl:call($range, 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:if test="$replacement ne ''">
                     <xsl:variable name="node" select="ixsl:call(ixsl:page(), 'createTextNode', [ $replacement ])"/>
                     <xsl:sequence select="ixsl:call($range, 'insertNode', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
-                    <ixsl:set-property name="findNode" select="$node" object="local:editor-state()"/>
-                    <ixsl:set-property name="findOffset" select="string-length($replacement) + 1" object="local:editor-state()"/>
+                    <ixsl:set-property name="findNode" select="$node" object="rdfae:editor-state()"/>
+                    <ixsl:set-property name="findOffset" select="string-length($replacement) + 1" object="rdfae:editor-state()"/>
                 </xsl:if>
-                <xsl:call-template name="local:after-mutation"/>
-                <xsl:call-template name="local:find-next"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
+                <xsl:call-template name="rdfae:find-next"/>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:find-next"/>
+                <xsl:call-template name="rdfae:find-next"/>
             </xsl:otherwise>
         </xsl:choose>
     </xsl:template>
@@ -675,35 +675,35 @@ version="3.0">
             select="string(ixsl:get(($dialog//input[@name = 'replace'])[1], 'value'))"/>
         <xsl:variable name="ci" as="xs:boolean"
             select="not(ixsl:get(($dialog//input[@name = 'match-case'])[1], 'checked'))"/>
-        <xsl:variable name="matched" select="local:roots()//text()[not(ancestor::*[@data-role])]
-            [$query ne ''][contains(local:norm(string(.), $ci), local:norm($query, $ci))]"/>
+        <xsl:variable name="matched" select="rdfae:roots()//text()[not(ancestor::*[@data-role])]
+            [$query ne ''][contains(rdfae:norm(string(.), $ci), rdfae:norm($query, $ci))]"/>
         <xsl:choose>
             <xsl:when test="empty($matched)">
-                <xsl:call-template name="local:find-status">
+                <xsl:call-template name="rdfae:find-status">
                     <xsl:with-param name="message"
                         select="if ($query = '') then 'Enter a search term.' else 'No matches.'"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:push-undo"/>
+                <xsl:call-template name="rdfae:push-undo"/>
                 <xsl:iterate select="$matched">
                     <xsl:param name="total" as="xs:integer" select="0"/>
                     <xsl:on-completion>
-                        <xsl:call-template name="local:find-status">
+                        <xsl:call-template name="rdfae:find-status">
                             <xsl:with-param name="message" select="$total || ' occurrence'
                                 || (if ($total ne 1) then 's' else '') || ' replaced.'"/>
                         </xsl:call-template>
                     </xsl:on-completion>
                     <xsl:variable name="result" as="map(*)"
-                        select="local:replace-in-string(string(.), $query, $replacement, $ci)"/>
+                        select="rdfae:replace-in-string(string(.), $query, $replacement, $ci)"/>
                     <ixsl:set-property name="nodeValue" select="$result?value" object="."/>
                     <xsl:next-iteration>
                         <xsl:with-param name="total" select="$total + xs:integer($result?count)"/>
                     </xsl:next-iteration>
                 </xsl:iterate>
-                <ixsl:set-property name="findNode" select="()" object="local:editor-state()"/>
-                <ixsl:set-property name="findOffset" select="1" object="local:editor-state()"/>
-                <xsl:call-template name="local:after-mutation"/>
+                <ixsl:set-property name="findNode" select="()" object="rdfae:editor-state()"/>
+                <ixsl:set-property name="findOffset" select="1" object="rdfae:editor-state()"/>
+                <xsl:call-template name="rdfae:after-mutation"/>
             </xsl:otherwise>
         </xsl:choose>
     </xsl:template>
diff --git a/src/overlay.xsl b/src/overlay.xsl
index ec4226c..534b80f 100644
--- a/src/overlay.xsl
+++ b/src/overlay.xsl
@@ -4,13 +4,15 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 version="3.0">
 
     <!-- select value marking the free-text custom-IRI state ('' means none/unset) -->
-    <xsl:variable name="local:custom" as="xs:string" select="'urn:rdfa-editor:custom'"/>
+    <xsl:variable name="rdfae:custom" as="xs:string" select="'https://w3id.org/atomgraph/rdfa-editor#custom'"/>
+    <!-- id of the annotation overlay element; host UIs may shadow this variable -->
+    <xsl:variable name="rdfae:overlay-id" as="xs:string" select="'rdfa-editor-overlay'"/>
 
 <!--
     The annotation overlay: rendered once at startup (hidden), then only populated,
@@ -21,16 +23,16 @@ version="3.0">
     (checked/value/disabled/open) - attributes never reflect user input.
 -->
 
-    <xsl:template name="local:init-overlay">
+    <xsl:template name="rdfae:init-overlay">
         <xsl:for-each select="ixsl:page()//body">
             <xsl:result-document href="?." method="ixsl:append-content">
-                <xsl:call-template name="local:render-overlay"/>
+                <xsl:call-template name="rdfae:render-overlay"/>
             </xsl:result-document>
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template name="local:render-overlay">
-        <div id="overlay" class="rdfa-editor-ui" role="dialog" aria-modal="true" aria-label="RDFa annotation" style="display: none;">
+    <xsl:template name="rdfae:render-overlay">
+        <div id="{$rdfae:overlay-id}" class="rdfa-editor-ui" role="dialog" aria-modal="true" aria-label="RDFa annotation" style="display: none;">
             <div class="overlay-header">
                 <h3>RDFa Annotation</h3>
             </div>
@@ -40,7 +42,7 @@ version="3.0">
                     <div id="stmt-subject" class="stmt-value"/>
                     <span class="stmt-role" title="Predicate">P</span>
                     <div class="stmt-control">
-                        <xsl:sequence select="local:typeahead-field('property')"/>
+                        <xsl:sequence select="rdfae:typeahead-field('property')"/>
                     </div>
                     <span class="stmt-role" title="Object">O</span>
                     <div class="stmt-control">
@@ -53,7 +55,7 @@ version="3.0">
                     <summary>Type, subject &amp; object</summary>
                     <fieldset>
                         <label>Entity type (typeof)</label>
-                        <xsl:sequence select="local:typeahead-field('typeof')"/>
+                        <xsl:sequence select="rdfae:typeahead-field('typeof')"/>
                         <span class="helper-text">Types the annotated resource; without a subject the typed
                             resource becomes the object of the property (chaining)</span>
                     </fieldset>
@@ -76,7 +78,7 @@ version="3.0">
                                     'decimal', 'double', 'float', 'boolean', 'anyURI'">
                                 <option value="{$xsd || .}">xsd:<xsl:value-of select="."/></option>
                             </xsl:for-each>
-                            <option value="{$local:custom}">-- Custom datatype --</option>
+                            <option value="{$rdfae:custom}">-- Custom datatype --</option>
                         </select>
                         <input type="text" name="custom-datatype" placeholder="Datatype IRI" style="display: none;"/>
                         <span class="helper-text">Types the literal (e.g. xsd:date, xsd:integer);
@@ -99,36 +101,36 @@ version="3.0">
     </xsl:template>
 
     <!-- all form reads via live properties: the checked/value attributes never change on user input -->
-    <xsl:function name="local:form-values" as="map(xs:string, xs:string?)">
+    <xsl:function name="rdfae:form-values" as="map(xs:string, xs:string?)">
         <xsl:param name="form" as="element()"/>
 
         <xsl:map>
-            <xsl:map-entry key="'property'" select="local:typeahead-value($form, 'property')"/>
-            <xsl:map-entry key="'typeof'" select="local:typeahead-value($form, 'typeof')"/>
-            <xsl:map-entry key="'subject'" select="local:input-value($form, 'subject')[. ne '']"/>
-            <xsl:map-entry key="'object'" select="local:input-value($form, 'object')[. ne '']"/>
-            <xsl:map-entry key="'value'" select="local:input-value($form, 'value')[. ne '']"/>
-            <xsl:map-entry key="'datatype'" select="local:select-or-custom($form, 'datatype', 'custom-datatype')"/>
-            <xsl:map-entry key="'lang'" select="local:input-value($form, 'lang')[. ne '']"/>
+            <xsl:map-entry key="'property'" select="rdfae:typeahead-value($form, 'property')"/>
+            <xsl:map-entry key="'typeof'" select="rdfae:typeahead-value($form, 'typeof')"/>
+            <xsl:map-entry key="'subject'" select="rdfae:input-value($form, 'subject')[. ne '']"/>
+            <xsl:map-entry key="'object'" select="rdfae:input-value($form, 'object')[. ne '']"/>
+            <xsl:map-entry key="'value'" select="rdfae:input-value($form, 'value')[. ne '']"/>
+            <xsl:map-entry key="'datatype'" select="rdfae:select-or-custom($form, 'datatype', 'custom-datatype')"/>
+            <xsl:map-entry key="'lang'" select="rdfae:input-value($form, 'lang')[. ne '']"/>
         </xsl:map>
     </xsl:function>
 
     <!-- a select whose empty value defers to its free-text custom input -->
-    <xsl:function name="local:select-or-custom" as="xs:string?">
+    <xsl:function name="rdfae:select-or-custom" as="xs:string?">
         <xsl:param name="form" as="element()"/>
         <xsl:param name="select-name" as="xs:string"/>
         <xsl:param name="custom-name" as="xs:string"/>
 
         <xsl:variable name="value" as="xs:string"
             select="string(ixsl:get(($form//select[@name = $select-name])[1], 'value'))"/>
-        <xsl:sequence select="if ($value eq $local:custom)
-            then local:input-value($form, $custom-name)[. ne '']
+        <xsl:sequence select="if ($value eq $rdfae:custom)
+            then rdfae:input-value($form, $custom-name)[. ne '']
             else $value[. ne '']"/>
     </xsl:function>
 
     <!-- reset the form; when editing, pre-fill it from the annotated element.
          $value prefills the object row: the selected text, or @content/text when editing -->
-    <xsl:template name="local:populate-form">
+    <xsl:template name="rdfae:populate-form">
         <xsl:param name="span" as="element()?" select="()"/>
         <xsl:param name="value" as="xs:string?" select="()"/>
 
@@ -141,12 +143,12 @@ version="3.0">
             <!-- the typeahead widgets are not native controls, so form.reset() leaves
                  them as they were: reset both explicitly (empty in create mode, the
                  committed button in edit mode) -->
-            <xsl:call-template name="local:typeahead-set-value">
+            <xsl:call-template name="rdfae:typeahead-set-value">
                 <xsl:with-param name="form" select="$form"/>
                 <xsl:with-param name="field" select="'property'"/>
                 <xsl:with-param name="iri" select="string($span/@property)"/>
             </xsl:call-template>
-            <xsl:call-template name="local:typeahead-set-value">
+            <xsl:call-template name="rdfae:typeahead-set-value">
                 <xsl:with-param name="form" select="$form"/>
                 <xsl:with-param name="field" select="'typeof'"/>
                 <xsl:with-param name="iri" select="string($span/@typeof)"/>
@@ -176,7 +178,7 @@ version="3.0">
                     <ixsl:set-property name="value" select="string($span/@resource)" object="."/>
                 </xsl:for-each>
                 <xsl:for-each select="@datatype">
-                    <xsl:call-template name="local:set-select-or-custom">
+                    <xsl:call-template name="rdfae:set-select-or-custom">
                         <xsl:with-param name="form" select="$form"/>
                         <xsl:with-param name="select-name" select="'datatype'"/>
                         <xsl:with-param name="custom-name" select="'custom-datatype'"/>
@@ -192,7 +194,7 @@ version="3.0">
 
     <!-- set a select's value via the live property; an IRI absent from the options
          leaves the select empty, so route it to the custom input instead -->
-    <xsl:template name="local:set-select-or-custom">
+    <xsl:template name="rdfae:set-select-or-custom">
         <xsl:param name="form" as="element()"/>
         <xsl:param name="select-name" as="xs:string"/>
         <xsl:param name="custom-name" as="xs:string"/>
@@ -201,7 +203,7 @@ version="3.0">
         <xsl:for-each select="($form//select[@name = $select-name])[1]">
             <ixsl:set-property name="value" select="$value" object="."/>
             <xsl:if test="string(ixsl:get(., 'value')) ne $value">
-                <ixsl:set-property name="value" select="$local:custom" object="."/>
+                <ixsl:set-property name="value" select="$rdfae:custom" object="."/>
                 <xsl:for-each select="($form//input[@name = $custom-name])[1]">
                     <ixsl:set-property name="value" select="$value" object="."/>
                     <ixsl:set-style name="display" select="'block'"/>
@@ -213,20 +215,20 @@ version="3.0">
     <!-- show an element at the event position, clamped to the viewport with 10px
          padding. Positioned absolutely in page coordinates (client + scroll offset)
          so it scrolls with the content -->
-    <xsl:template name="local:show-at">
+    <xsl:template name="rdfae:show-at">
         <xsl:param name="element" as="element()"/>
         <xsl:param name="event"/>
 
-        <xsl:call-template name="local:show-at-point">
+        <xsl:call-template name="rdfae:show-at-point">
             <xsl:with-param name="element" select="$element"/>
             <xsl:with-param name="x" select="ixsl:get($event, 'clientX')"/>
             <xsl:with-param name="y" select="ixsl:get($event, 'clientY')"/>
         </xsl:call-template>
     </xsl:template>
 
-    <!-- the positioning core: shared by mouse-driven dialogs (local:show-at) and the
+    <!-- the positioning core: shared by mouse-driven dialogs (rdfae:show-at) and the
          caret-anchored popups (slash menu) which have no mouse event -->
-    <xsl:template name="local:show-at-point">
+    <xsl:template name="rdfae:show-at-point">
         <xsl:param name="element" as="element()"/>
         <xsl:param name="x" as="xs:double"/>
         <xsl:param name="y" as="xs:double"/>
@@ -251,12 +253,12 @@ version="3.0">
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template name="local:show-overlay">
+    <xsl:template name="rdfae:show-overlay">
         <xsl:param name="event"/>
         <xsl:param name="in-scope-subject" as="xs:string?" select="()"/>
 
-        <xsl:call-template name="local:show-at">
-            <xsl:with-param name="element" select="id('overlay', ixsl:page())"/>
+        <xsl:call-template name="rdfae:show-at">
+            <xsl:with-param name="element" select="id($rdfae:overlay-id, ixsl:page())"/>
             <xsl:with-param name="event" select="$event"/>
         </xsl:call-template>
 
@@ -269,7 +271,7 @@ version="3.0">
     <!-- the browser drops the visible selection once focus moves into the overlay
          form: paint the stored range's client rects as pointer-transparent hint
          boxes (no content mutation), cleared on hide -->
-    <xsl:template name="local:show-selection-hint">
+    <xsl:template name="rdfae:show-selection-hint">
         <xsl:param name="range"/>
 
         <xsl:variable name="scroll-x" as="xs:double" select="ixsl:get(ixsl:window(), 'scrollX')"/>
@@ -288,32 +290,32 @@ version="3.0">
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template name="local:hide-selection-hint">
+    <xsl:template name="rdfae:hide-selection-hint">
         <xsl:for-each select="ixsl:page()//body/div[contains-token(@class, 'rdfa-editor-selection-hint')]">
             <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
     </xsl:template>
 
     <!-- single teardown point: hiding the overlay always clears the interaction state -->
-    <xsl:template name="local:hide-overlay">
-        <xsl:call-template name="local:hide-selection-hint"/>
-        <xsl:for-each select="id('overlay', ixsl:page())">
+    <xsl:template name="rdfae:hide-overlay">
+        <xsl:call-template name="rdfae:hide-selection-hint"/>
+        <xsl:for-each select="id($rdfae:overlay-id, ixsl:page())">
             <ixsl:set-style name="display" select="'none'"/>
         </xsl:for-each>
-        <ixsl:set-property name="editingSpan" select="()" object="local:editor-state()"/>
-        <ixsl:set-property name="range" select="()" object="local:editor-state()"/>
+        <ixsl:set-property name="editingSpan" select="()" object="rdfae:editor-state()"/>
+        <ixsl:set-property name="range" select="()" object="rdfae:editor-state()"/>
         <!-- return focus to the content -->
-        <xsl:for-each select="ixsl:get(local:editor-state(), 'activeBlock')[exists(local:block-of(.))]">
-            <xsl:call-template name="local:focus">
+        <xsl:for-each select="ixsl:get(rdfae:editor-state(), 'activeBlock')[exists(rdfae:block-of(.))]">
+            <xsl:call-template name="rdfae:focus">
                 <xsl:with-param name="element" select="."/>
             </xsl:call-template>
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template match="div[@id = 'overlay']" mode="ixsl:onkeydown">
+    <xsl:template match="div[@id = $rdfae:overlay-id]" mode="ixsl:onkeydown">
         <xsl:if test="string(ixsl:get(ixsl:event(), 'key')) = 'Escape'">
             <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:call-template name="local:hide-overlay"/>
+            <xsl:call-template name="rdfae:hide-overlay"/>
         </xsl:if>
     </xsl:template>
 
@@ -330,7 +332,7 @@ version="3.0">
          a chosen datatype wins over language, disabling the language input -->
     <xsl:template match="select[@name = 'datatype']" mode="ixsl:onchange">
         <xsl:variable name="value" as="xs:string" select="string(ixsl:get(., 'value'))"/>
-        <xsl:variable name="custom" as="xs:boolean" select="$value eq $local:custom"/>
+        <xsl:variable name="custom" as="xs:boolean" select="$value eq $rdfae:custom"/>
         <xsl:for-each select="ancestor::form//input[@name = 'custom-datatype']">
             <ixsl:set-style name="display" select="if ($custom) then 'block' else 'none'"/>
             <xsl:if test="$custom">
diff --git a/src/select.xsl b/src/select.xsl
index 688c63e..291f79f 100644
--- a/src/select.xsl
+++ b/src/select.xsl
@@ -4,8 +4,8 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
-xmlns:cm="urn:rdfa-editor:content-model"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
+xmlns:cm="https://w3id.org/atomgraph/rdfa-editor/content-model#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 version="3.0">
@@ -45,35 +45,35 @@ version="3.0">
     <!-- ................................ predicates ................................ -->
 
     <!-- the host's content is entirely inside the selection (chrome- and
-         placeholder-insensitive via the local:at-* probes); an empty host counts
+         placeholder-insensitive via the rdfae:at-* probes); an empty host counts
          as fully selected, so Ctrl+A escalates immediately where stage 1 would
          have nothing to select -->
-    <xsl:function name="local:host-fully-selected" as="xs:boolean">
+    <xsl:function name="rdfae:host-fully-selected" as="xs:boolean">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="range"/>
-        <xsl:sequence select="local:block-text($host) = ''
+        <xsl:sequence select="rdfae:block-text($host) = ''
             or (not(ixsl:get($range, 'collapsed'))
-                and local:at-start($host, $range) and local:at-end($host, $range))"/>
+                and rdfae:at-start($host, $range) and rdfae:at-end($host, $range))"/>
     </xsl:function>
 
     <!-- true for a non-collapsed selection that engages an editable region but is
          not confined to a single host: the boundary hosts differ, or a boundary
          sits outside any host (region level, page background). Host-page
-         contenteditables don't count (the local:block-of clamp), and selections
+         contenteditables don't count (the rdfae:block-of clamp), and selections
          that never touch a region stay native -->
-    <xsl:function name="local:selection-crosses-hosts" as="xs:boolean">
-        <xsl:variable name="range" select="local:caret-range()"/>
+    <xsl:function name="rdfae:selection-crosses-hosts" as="xs:boolean">
+        <xsl:variable name="range" select="rdfae:caret-range()"/>
         <xsl:choose>
             <xsl:when test="empty($range) or ixsl:get($range, 'collapsed')">
                 <xsl:sequence select="false()"/>
             </xsl:when>
             <xsl:otherwise>
                 <xsl:variable name="start-host" as="element()?"
-                    select="local:host-of(ixsl:get($range, 'startContainer'))[exists(local:block-of(.))]"/>
+                    select="rdfae:host-of(ixsl:get($range, 'startContainer'))[exists(rdfae:block-of(.))]"/>
                 <xsl:variable name="end-host" as="element()?"
-                    select="local:host-of(ixsl:get($range, 'endContainer'))[exists(local:block-of(.))]"/>
+                    select="rdfae:host-of(ixsl:get($range, 'endContainer'))[exists(rdfae:block-of(.))]"/>
                 <xsl:sequence select="(empty($start-host) or empty($end-host) or not($start-host is $end-host))
-                    and (some $root in local:roots() satisfies ixsl:call($range, 'intersectsNode', [ $root ]))"/>
+                    and (some $root in rdfae:roots() satisfies ixsl:call($range, 'intersectsNode', [ $root ]))"/>
             </xsl:otherwise>
         </xsl:choose>
     </xsl:function>
@@ -82,7 +82,7 @@ version="3.0">
          range boundary sits at or below the node (an offset in a parent points
          between children, so a boundary inside the node means its container is
          in the node's subtree - pure XDM containment, no compareBoundaryPoints) -->
-    <xsl:function name="local:covered-by" as="xs:boolean">
+    <xsl:function name="rdfae:covered-by" as="xs:boolean">
         <xsl:param name="node" as="node()"/>
         <xsl:param name="range"/>
         <xsl:sequence select="ixsl:call($range, 'intersectsNode', [ $node ])
@@ -97,14 +97,14 @@ version="3.0">
     <!-- a document-level range over all of the region's blocks: it paints across
          host boundaries and never extends beyond the region. Focus stays where it
          was, so the same keydown template keeps firing -->
-    <xsl:template name="local:select-region">
+    <xsl:template name="rdfae:select-region">
         <xsl:param name="region" as="element()"/>
         <xsl:variable name="blocks" as="element()*" select="$region/*[not(@data-role)]"/>
         <xsl:if test="exists($blocks)">
             <xsl:variable name="range" select="ixsl:call(ixsl:page(), 'createRange', [])"/>
             <xsl:sequence select="ixsl:call($range, 'setStartBefore', [ $blocks[1] ])[current-date() lt xs:date('2000-01-01')],
                 ixsl:call($range, 'setEndAfter', [ $blocks[last()] ])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:variable name="selection" select="local:selection()"/>
+            <xsl:variable name="selection" select="rdfae:selection()"/>
             <xsl:sequence select="ixsl:call($selection, 'removeAllRanges', [])[current-date() lt xs:date('2000-01-01')],
                 ixsl:call($selection, 'addRange', [ $range ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
@@ -114,15 +114,15 @@ version="3.0">
          content, another region) move to the region's extremes, and a boundary
          inside chrome moves out of the ephemeral subtree (the handle is not
          content). Shared by the delete machine and canonical copy -->
-    <xsl:function name="local:clamped-range" as="item()">
+    <xsl:function name="rdfae:clamped-range" as="item()">
         <xsl:param name="range"/>
         <xsl:param name="region" as="element()"/>
         <xsl:variable name="all" as="element()*" select="$region/*[not(@data-role)]"/>
         <xsl:variable name="work" select="ixsl:call($range, 'cloneRange', [])"/>
-        <xsl:if test="not(local:root-of(ixsl:get($work, 'startContainer')) is $region)">
+        <xsl:if test="not(rdfae:root-of(ixsl:get($work, 'startContainer')) is $region)">
             <xsl:sequence select="ixsl:call($work, 'setStartBefore', [ $all[1] ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
-        <xsl:if test="not(local:root-of(ixsl:get($work, 'endContainer')) is $region)">
+        <xsl:if test="not(rdfae:root-of(ixsl:get($work, 'endContainer')) is $region)">
             <xsl:sequence select="ixsl:call($work, 'setEndAfter', [ $all[last()] ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:if>
         <xsl:for-each select="(ixsl:get($work, 'startContainer')/ancestor-or-self::*[@data-role])[1]">
@@ -135,10 +135,10 @@ version="3.0">
              chrome escape - the rendering div is chrome inside the island):
              islands join a selection whole, so the delete machine and canonical
              copy never see a boundary inside one -->
-        <xsl:for-each select="(ixsl:get($work, 'startContainer')/ancestor-or-self::*[local:island(.)])[1]">
+        <xsl:for-each select="(ixsl:get($work, 'startContainer')/ancestor-or-self::*[rdfae:island(.)])[1]">
             <xsl:sequence select="ixsl:call($work, 'setStartBefore', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
-        <xsl:for-each select="(ixsl:get($work, 'endContainer')/ancestor-or-self::*[local:island(.)])[1]">
+        <xsl:for-each select="(ixsl:get($work, 'endContainer')/ancestor-or-self::*[rdfae:island(.)])[1]">
             <xsl:sequence select="ixsl:call($work, 'setEndAfter', [ . ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
         <xsl:sequence select="$work"/>
@@ -149,9 +149,9 @@ version="3.0">
     <!-- the document position under a viewport point, as map{'node','offset'}:
          caretRangeFromPoint (Chromium, Safari) or caretPositionFromPoint
          (Firefox). A position inside chrome moves out of the ephemeral subtree
-         to just after it (mirroring local:clamped-range); empty when the point
+         to just after it (mirroring rdfae:clamped-range); empty when the point
          resolves to nothing -->
-    <xsl:function name="local:caret-at-point" as="map(*)?">
+    <xsl:function name="rdfae:caret-at-point" as="map(*)?">
         <xsl:param name="x" as="xs:double"/>
         <xsl:param name="y" as="xs:double"/>
         <xsl:variable name="raw" as="map(*)?">
@@ -174,7 +174,7 @@ version="3.0">
         </xsl:variable>
         <!-- one ancestor walk serves both probes: this runs per mousemove during a sweep -->
         <xsl:variable name="ancestors" as="element()*" select="$raw?node/ancestor-or-self::*"/>
-        <xsl:variable name="island" as="element()?" select="($ancestors[local:island(.)])[1]"/>
+        <xsl:variable name="island" as="element()?" select="($ancestors[rdfae:island(.)])[1]"/>
         <xsl:variable name="chrome" as="element()?" select="($ancestors[@data-role])[1]"/>
         <xsl:choose>
             <!-- a point inside an object-block island (its rendering or its RDFa
@@ -200,12 +200,12 @@ version="3.0">
     <!-- a selection focus clamped into $region: a position outside it (page
          content, another region) becomes the region extreme on that side -
          one gesture, one region -->
-    <xsl:function name="local:clamp-focus-to-region" as="map(*)">
+    <xsl:function name="rdfae:clamp-focus-to-region" as="map(*)">
         <xsl:param name="node"/>
         <xsl:param name="offset" as="xs:integer"/>
         <xsl:param name="region" as="element()"/>
         <xsl:choose>
-            <xsl:when test="local:root-of($node) is $region">
+            <xsl:when test="rdfae:root-of($node) is $region">
                 <xsl:sequence select="map{ 'node': $node, 'offset': $offset }"/>
             </xsl:when>
             <xsl:otherwise>
@@ -231,17 +231,17 @@ version="3.0">
     <!-- move the selection focus, anchor fixed: setBaseAndExtent is the only
          Selection API that can express a backward selection (focus before
          anchor), which an upward drag or Shift+Click produces -->
-    <xsl:template name="local:extend-selection-to">
+    <xsl:template name="rdfae:extend-selection-to">
         <xsl:param name="anchor-node"/>
         <xsl:param name="anchor-offset" as="xs:integer"/>
         <xsl:param name="focus" as="map(*)"/>
-        <xsl:sequence select="ixsl:call(local:selection(), 'setBaseAndExtent',
+        <xsl:sequence select="ixsl:call(rdfae:selection(), 'setBaseAndExtent',
             [ $anchor-node, $anchor-offset, $focus?node, $focus?offset ])[current-date() lt xs:date('2000-01-01')]"/>
     </xsl:template>
 
-    <xsl:template name="local:disarm-sweep">
+    <xsl:template name="rdfae:disarm-sweep">
         <xsl:for-each select="('sweepAnchorNode', 'sweepAnchorHost', 'sweepRegion')">
-            <ixsl:set-property name="{.}" select="()" object="local:editor-state()"/>
+            <ixsl:set-property name="{.}" select="()" object="rdfae:editor-state()"/>
         </xsl:for-each>
     </xsl:template>
 
@@ -259,36 +259,36 @@ version="3.0">
         <xsl:variable name="target" as="node()?" select="ixsl:get($event, 'target')"/>
         <xsl:variable name="button" as="xs:double" select="number(ixsl:get($event, 'button'))"/>
         <xsl:if test="$button = 0 and empty($target/ancestor-or-self::*[@data-role])">
-            <xsl:variable name="anchor-node" as="node()?" select="local:anchor-node()"/>
-            <xsl:variable name="point" as="map(*)?" select="local:caret-at-point(
+            <xsl:variable name="anchor-node" as="node()?" select="rdfae:anchor-node()"/>
+            <xsl:variable name="point" as="map(*)?" select="rdfae:caret-at-point(
                 xs:double(ixsl:get($event, 'clientX')), xs:double(ixsl:get($event, 'clientY')))"/>
             <xsl:choose>
                 <!-- an anchor outside any region is the host page's - never hijacked -->
                 <xsl:when test="ixsl:get($event, 'shiftKey') = true()
-                        and exists(local:root-of($anchor-node)) and exists($point)">
+                        and exists(rdfae:root-of($anchor-node)) and exists($point)">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-                    <xsl:variable name="anchor-offset" as="xs:integer" select="local:anchor-offset()"/>
-                    <xsl:call-template name="local:extend-selection-to">
+                    <xsl:variable name="anchor-offset" as="xs:integer" select="rdfae:anchor-offset()"/>
+                    <xsl:call-template name="rdfae:extend-selection-to">
                         <xsl:with-param name="anchor-node" select="$anchor-node"/>
                         <xsl:with-param name="anchor-offset" select="$anchor-offset"/>
-                        <xsl:with-param name="focus" select="local:clamp-focus-to-region(
-                            $point?node, $point?offset, local:root-of($anchor-node))"/>
+                        <xsl:with-param name="focus" select="rdfae:clamp-focus-to-region(
+                            $point?node, $point?offset, rdfae:root-of($anchor-node))"/>
                     </xsl:call-template>
                     <!-- re-arm from the same anchor so Shift+drag keeps extending; the
                          preventDefault killed the native drag session, so every move
                          must be synthetic (no anchor host) -->
-                    <ixsl:set-property name="sweepAnchorNode" select="$anchor-node" object="local:editor-state()"/>
-                    <ixsl:set-property name="sweepAnchorOffset" select="$anchor-offset" object="local:editor-state()"/>
-                    <ixsl:set-property name="sweepAnchorHost" select="()" object="local:editor-state()"/>
-                    <ixsl:set-property name="sweepRegion" select="local:root-of($anchor-node)" object="local:editor-state()"/>
+                    <ixsl:set-property name="sweepAnchorNode" select="$anchor-node" object="rdfae:editor-state()"/>
+                    <ixsl:set-property name="sweepAnchorOffset" select="$anchor-offset" object="rdfae:editor-state()"/>
+                    <ixsl:set-property name="sweepAnchorHost" select="()" object="rdfae:editor-state()"/>
+                    <ixsl:set-property name="sweepRegion" select="rdfae:root-of($anchor-node)" object="rdfae:editor-state()"/>
                 </xsl:when>
                 <xsl:otherwise>
                     <xsl:for-each select="$point">
-                        <ixsl:set-property name="sweepAnchorNode" select="?node" object="local:editor-state()"/>
-                        <ixsl:set-property name="sweepAnchorOffset" select="?offset" object="local:editor-state()"/>
+                        <ixsl:set-property name="sweepAnchorNode" select="?node" object="rdfae:editor-state()"/>
+                        <ixsl:set-property name="sweepAnchorOffset" select="?offset" object="rdfae:editor-state()"/>
                         <ixsl:set-property name="sweepAnchorHost"
-                            select="local:host-of(?node)[exists(local:block-of(.))]" object="local:editor-state()"/>
-                        <ixsl:set-property name="sweepRegion" select="$region" object="local:editor-state()"/>
+                            select="rdfae:host-of(?node)[exists(rdfae:block-of(.))]" object="rdfae:editor-state()"/>
+                        <ixsl:set-property name="sweepRegion" select="$region" object="rdfae:editor-state()"/>
                     </xsl:for-each>
                 </xsl:otherwise>
             </xsl:choose>
@@ -304,30 +304,30 @@ version="3.0">
          check comes first, one property read on the idle path. html catches
          moves over the body's margins -->
     <xsl:template match="body | html" mode="ixsl:onmousemove">
-        <xsl:variable name="anchor-node" select="ixsl:get(local:editor-state(), 'sweepAnchorNode')"/>
+        <xsl:variable name="anchor-node" select="ixsl:get(rdfae:editor-state(), 'sweepAnchorNode')"/>
         <xsl:if test="exists($anchor-node)">
             <xsl:variable name="event" select="ixsl:event()"/>
             <xsl:choose>
                 <!-- button released outside the window: the mouseup never fired -->
                 <xsl:when test="number(ixsl:get($event, 'buttons')) ne 1">
-                    <xsl:call-template name="local:disarm-sweep"/>
+                    <xsl:call-template name="rdfae:disarm-sweep"/>
                 </xsl:when>
                 <xsl:otherwise>
-                    <xsl:variable name="anchor-host" as="element()?" select="ixsl:get(local:editor-state(), 'sweepAnchorHost')"/>
+                    <xsl:variable name="anchor-host" as="element()?" select="ixsl:get(rdfae:editor-state(), 'sweepAnchorHost')"/>
                     <xsl:variable name="target" as="node()?" select="ixsl:get($event, 'target')"/>
                     <xsl:if test="empty($anchor-host) or empty($target/ancestor-or-self::* intersect $anchor-host)">
                         <xsl:variable name="y" as="xs:double" select="xs:double(ixsl:get($event, 'clientY'))"/>
-                        <xsl:variable name="point" as="map(*)?" select="local:caret-at-point(
+                        <xsl:variable name="point" as="map(*)?" select="rdfae:caret-at-point(
                             xs:double(ixsl:get($event, 'clientX')), $y)"/>
                         <!-- a point over floating editor UI does not move the focus -->
                         <xsl:if test="exists($point) and empty($point?node/ancestor-or-self::*[contains-token(@class, 'rdfa-editor-ui')])">
-                            <xsl:for-each select="ixsl:get(local:editor-state(), 'sweepRegion')">
-                                <xsl:call-template name="local:extend-selection-to">
+                            <xsl:for-each select="ixsl:get(rdfae:editor-state(), 'sweepRegion')">
+                                <xsl:call-template name="rdfae:extend-selection-to">
                                     <xsl:with-param name="anchor-node" select="$anchor-node"/>
                                     <xsl:with-param name="anchor-offset"
-                                        select="xs:integer(ixsl:get(local:editor-state(), 'sweepAnchorOffset'))"/>
+                                        select="xs:integer(ixsl:get(rdfae:editor-state(), 'sweepAnchorOffset'))"/>
                                     <xsl:with-param name="focus"
-                                        select="local:clamp-focus-to-region($point?node, $point?offset, .)"/>
+                                        select="rdfae:clamp-focus-to-region($point?node, $point?offset, .)"/>
                                 </xsl:call-template>
                             </xsl:for-each>
                         </xsl:if>
@@ -349,11 +349,11 @@ version="3.0">
          mouseup templates disarm on their own paths - innermost-match
          dispatch means only one of them sees the event) -->
     <xsl:template match="body | html" mode="ixsl:onmouseup">
-        <xsl:if test="exists(ixsl:get(local:editor-state(), 'sweepAnchorNode'))">
-            <xsl:call-template name="local:disarm-sweep"/>
+        <xsl:if test="exists(ixsl:get(rdfae:editor-state(), 'sweepAnchorNode'))">
+            <xsl:call-template name="rdfae:disarm-sweep"/>
             <!-- no host mouseup fires out here: sync the breadcrumb ourselves -->
-            <xsl:if test="local:selection-crosses-hosts()">
-                <xsl:call-template name="local:update-breadcrumb"/>
+            <xsl:if test="rdfae:selection-crosses-hosts()">
+                <xsl:call-template name="rdfae:update-breadcrumb"/>
             </xsl:if>
         </xsl:if>
     </xsl:template>
@@ -363,12 +363,12 @@ version="3.0">
          arrow is where native extension clamps - both are ours; anywhere else
          native line-wise extension is right. Probes run from the FOCUS: the
          range end is not the focus in a backward selection -->
-    <xsl:function name="local:shift-arrow-extends" as="xs:boolean">
+    <xsl:function name="rdfae:shift-arrow-extends" as="xs:boolean">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="direction" as="xs:string"/>
-        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:choose>
-            <xsl:when test="local:selection-crosses-hosts()">
+            <xsl:when test="rdfae:selection-crosses-hosts()">
                 <xsl:sequence select="true()"/>
             </xsl:when>
             <xsl:when test="ixsl:get($selection, 'rangeCount') lt 1">
@@ -389,7 +389,7 @@ version="3.0">
                                     ixsl:call($probe, 'setEnd', [ $host, xs:integer(ixsl:get($host, 'childNodes.length')) ])[current-date() lt xs:date('2000-01-01')]"/>
                             </xsl:when>
                             <xsl:otherwise>
-                                <xsl:sequence select="ixsl:call($probe, 'setStart', [ $host, local:chrome-count($host) ])[current-date() lt xs:date('2000-01-01')],
+                                <xsl:sequence select="ixsl:call($probe, 'setStart', [ $host, rdfae:chrome-count($host) ])[current-date() lt xs:date('2000-01-01')],
                                     ixsl:call($probe, 'setEnd', [ $focus-node, $focus-offset ])[current-date() lt xs:date('2000-01-01')]"/>
                             </xsl:otherwise>
                         </xsl:choose>
@@ -406,16 +406,16 @@ version="3.0">
          inside a block the first step lands just past (before) it; stepping
          across the anchor flips the selection direction; the extremes are
          no-ops -->
-    <xsl:template name="local:extend-selection-block-wise">
+    <xsl:template name="rdfae:extend-selection-block-wise">
         <xsl:param name="direction" as="xs:string"/>
-        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
             <xsl:variable name="focus-node" select="ixsl:get($selection, 'focusNode')"/>
             <xsl:variable name="focus-offset" as="xs:integer" select="xs:integer(ixsl:get($selection, 'focusOffset'))"/>
-            <xsl:for-each select="local:root-of($focus-node)">
+            <xsl:for-each select="rdfae:root-of($focus-node)">
                 <xsl:variable name="region" as="element()" select="."/>
                 <xsl:variable name="blocks" as="element()*" select="*[not(@data-role)]"/>
-                <xsl:variable name="focus-block" as="element()?" select="local:block-of($focus-node)"/>
+                <xsl:variable name="focus-block" as="element()?" select="rdfae:block-of($focus-node)"/>
                 <!-- the focus as a region-level coordinate: inside a block it
                      counts as just inside the edge facing the step -->
                 <xsl:variable name="current" as="xs:integer" select="
@@ -427,7 +427,7 @@ version="3.0">
                     then $blocks[count(preceding-sibling::node()) + 1 gt $current][1]
                     else $blocks[count(preceding-sibling::node()) lt $current][last()]"/>
                 <xsl:for-each select="$target-block">
-                    <xsl:call-template name="local:extend-selection-to">
+                    <xsl:call-template name="rdfae:extend-selection-to">
                         <xsl:with-param name="anchor-node" select="ixsl:get($selection, 'anchorNode')"/>
                         <xsl:with-param name="anchor-offset" select="xs:integer(ixsl:get($selection, 'anchorOffset'))"/>
                         <xsl:with-param name="focus" select="map{ 'node': $region,
@@ -451,9 +451,9 @@ version="3.0">
          or body after a background-origin sweep -->
     <xsl:template match="*[@contenteditable = 'true'] | body" mode="ixsl:oncopy">
         <xsl:variable name="event" select="ixsl:event()"/>
-        <xsl:if test="local:selection-crosses-hosts()">
+        <xsl:if test="rdfae:selection-crosses-hosts()">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:call-template name="local:copy-selection">
+            <xsl:call-template name="rdfae:copy-selection">
                 <xsl:with-param name="event" select="$event"/>
             </xsl:call-template>
         </xsl:if>
@@ -462,26 +462,26 @@ version="3.0">
     <!-- cut = canonical copy + the delete machine (one region-keyed undo entry) -->
     <xsl:template match="*[@contenteditable = 'true'] | body" mode="ixsl:oncut">
         <xsl:variable name="event" select="ixsl:event()"/>
-        <xsl:if test="local:selection-crosses-hosts()">
+        <xsl:if test="rdfae:selection-crosses-hosts()">
             <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:call-template name="local:copy-selection">
+            <xsl:call-template name="rdfae:copy-selection">
                 <xsl:with-param name="event" select="$event"/>
             </xsl:call-template>
-            <xsl:call-template name="local:delete-cross-host-selection"/>
+            <xsl:call-template name="rdfae:delete-cross-host-selection"/>
         </xsl:if>
     </xsl:template>
 
-    <xsl:template name="local:copy-selection">
+    <xsl:template name="rdfae:copy-selection">
         <xsl:param name="event"/>
-        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:variable name="range" select="rdfae:caret-range()"/>
         <xsl:variable name="region" as="element()?"
-            select="(local:root-of(ixsl:get($range, 'startContainer')),
-                local:roots()[ixsl:call($range, 'intersectsNode', [ . ])])[1]"/>
+            select="(rdfae:root-of(ixsl:get($range, 'startContainer')),
+                rdfae:roots()[ixsl:call($range, 'intersectsNode', [ . ])])[1]"/>
         <xsl:for-each select="$region[exists(*[not(@data-role)])]">
-            <xsl:variable name="work" select="local:clamped-range($range, .)"/>
+            <xsl:variable name="work" select="rdfae:clamped-range($range, .)"/>
             <!-- cloneContents keeps partially-selected ancestors as shells, so the
                  fragment stays block-shaped; the carrier div mirrors paste-html -->
-            <xsl:variable name="carrier" as="element()" select="local:element('div')"/>
+            <xsl:variable name="carrier" as="element()" select="rdfae:element('div')"/>
             <xsl:sequence select="ixsl:call($carrier, 'appendChild',
                 [ ixsl:call($work, 'cloneContents', []) ])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:variable name="pass1">
@@ -503,60 +503,60 @@ version="3.0">
     <!-- delete a cross-host selection: reads and classification first, one undo
          push, then the mutations in fixed order. Reached from the host and body
          keydown dispatchers (edit.xsl) -->
-    <xsl:template name="local:delete-cross-host-selection">
-        <xsl:variable name="range" select="local:caret-range()"/>
+    <xsl:template name="rdfae:delete-cross-host-selection">
+        <xsl:variable name="range" select="rdfae:caret-range()"/>
         <xsl:if test="exists($range) and not(ixsl:get($range, 'collapsed'))">
             <!-- the single region this gesture acts on: the start's region, else
                  the first region the sweep reaches (one gesture = one region-keyed
                  history entry; blocks never leave their region) -->
             <xsl:variable name="region" as="element()?"
-                select="(local:root-of(ixsl:get($range, 'startContainer')),
-                    local:roots()[ixsl:call($range, 'intersectsNode', [ . ])])[1]"/>
+                select="(rdfae:root-of(ixsl:get($range, 'startContainer')),
+                    rdfae:roots()[ixsl:call($range, 'intersectsNode', [ . ])])[1]"/>
             <xsl:variable name="all" as="element()*" select="$region/*[not(@data-role)]"/>
             <xsl:if test="exists($all)">
-                <xsl:variable name="work" select="local:clamped-range($range, $region)"/>
+                <xsl:variable name="work" select="rdfae:clamped-range($range, $region)"/>
                 <xsl:variable name="blocks" as="element()*" select="$all[ixsl:call($work, 'intersectsNode', [ . ])]"/>
                 <xsl:if test="exists($blocks) and not(ixsl:get($work, 'collapsed'))">
                     <!-- boundary hosts (a partial edge is an edge with a boundary
                          host); clamped boundaries sit at region level - no host -->
                     <xsl:variable name="start-host" as="element()?"
-                        select="local:host-of(ixsl:get($work, 'startContainer'))[local:root-of(.) is $region]"/>
+                        select="rdfae:host-of(ixsl:get($work, 'startContainer'))[rdfae:root-of(.) is $region]"/>
                     <xsl:variable name="end-host" as="element()?"
-                        select="local:host-of(ixsl:get($work, 'endContainer'))[local:root-of(.) is $region]"/>
+                        select="rdfae:host-of(ixsl:get($work, 'endContainer'))[rdfae:root-of(.) is $region]"/>
                     <!-- only the two edge blocks can be partially covered -->
-                    <xsl:variable name="head-block" as="element()?" select="$blocks[1][not(local:covered-by(., $work))]"/>
-                    <xsl:variable name="tail-block" as="element()?" select="$blocks[last()][not(local:covered-by(., $work))]"/>
+                    <xsl:variable name="head-block" as="element()?" select="$blocks[1][not(rdfae:covered-by(., $work))]"/>
+                    <xsl:variable name="tail-block" as="element()?" select="$blocks[last()][not(rdfae:covered-by(., $work))]"/>
                     <xsl:variable name="partial-blocks" as="element()*" select="$head-block | $tail-block"/>
                     <!-- composites holding a range boundary: their structure is
                          never ripped (composites are hard boundaries - B3/B4) -->
                     <xsl:variable name="partial-composites" as="element()*"
                         select="$partial-blocks/descendant-or-self::*[self::table or self::figure]
-                            [ixsl:call($work, 'intersectsNode', [ . ])][not(local:covered-by(., $work))]"/>
+                            [ixsl:call($work, 'intersectsNode', [ . ])][not(rdfae:covered-by(., $work))]"/>
                     <!-- removals: covered blocks whole, plus the maximal covered
                          fragments of the edge blocks - except grid parts of a
                          boundary-holding composite (rows, cells, captions, the
                          figure image), which survive with their content cleared -->
                     <xsl:variable name="removals" as="element()*" select="
-                        $blocks[local:covered-by(., $work)]
+                        $blocks[rdfae:covered-by(., $work)]
                         | $partial-blocks/descendant::*
                             [not(ancestor-or-self::*[@data-role])]
                             [not((self::tbody or self::thead or self::tfoot or self::tr
                                 or self::td or self::th or self::caption or self::figcaption or self::img)
                                 and exists(ancestor::*[self::table or self::figure]))]
-                            [local:covered-by(., $work)]
-                            [not(local:covered-by(.., $work))]"/>
+                            [rdfae:covered-by(., $work)]
+                            [not(rdfae:covered-by(.., $work))]"/>
                     <!-- covered cells of a boundary-holding composite: cleared, kept -->
                     <xsl:variable name="clears" as="element()*" select="
                         $partial-blocks/descendant::*[self::td or self::th or self::caption or self::figcaption]
                             [exists(ancestor::*[self::table or self::figure])]
-                            [local:covered-by(., $work)]
-                            [not(local:covered-by((ancestor::*[self::table or self::figure])[last()], $work))]"/>
+                            [rdfae:covered-by(., $work)]
+                            [not(rdfae:covered-by((ancestor::*[self::table or self::figure])[last()], $work))]"/>
                     <!-- flow containers of the edge blocks touched by the range:
                          after the removals they may have lost their last block
                          (never an island - a div island must not become a text host) -->
                     <xsl:variable name="collapse-candidates" as="element()*" select="
                         $partial-blocks/descendant::*[cm:flow(local-name(.))][not(self::figure)]
-                            [not(local:island(.))]
+                            [not(rdfae:island(.))]
                             [not(@contenteditable = 'true')]
                             [ixsl:call($work, 'intersectsNode', [ . ])]"/>
                     <!-- caret fallbacks for a fully-covered sweep: the untouched
@@ -582,14 +582,14 @@ version="3.0">
                     </xsl:for-each>
 
                     <!-- mutate: one region-keyed history entry, snapshot first -->
-                    <xsl:call-template name="local:push-undo">
+                    <xsl:call-template name="rdfae:push-undo">
                         <xsl:with-param name="root" select="$region"/>
                     </xsl:call-template>
                     <xsl:for-each select="$head-sub, $tail-sub">
                         <xsl:sequence select="ixsl:call(., 'deleteContents', [])[current-date() lt xs:date('2000-01-01')]"/>
                     </xsl:for-each>
                     <xsl:for-each select="$clears">
-                        <xsl:call-template name="local:clear-host">
+                        <xsl:call-template name="rdfae:clear-host">
                             <xsl:with-param name="host" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
@@ -602,88 +602,88 @@ version="3.0">
                     <xsl:variable name="seam-text" as="text()?"
                         select="($end-host//text()[not(ancestor::*[@data-role])])[1]"/>
                     <xsl:if test="$merge">
-                        <xsl:call-template name="local:merge-into-previous">
+                        <xsl:call-template name="rdfae:merge-into-previous">
                             <xsl:with-param name="host" select="$end-host"/>
                             <xsl:with-param name="prev" select="$start-host"/>
                         </xsl:call-template>
                     </xsl:if>
                     <!-- structural containers emptied by the deletion or the merge -->
-                    <xsl:for-each select="($head-block, $tail-block)[exists(local:root-of(.))]">
-                        <xsl:call-template name="local:prune-husks">
+                    <xsl:for-each select="($head-block, $tail-block)[exists(rdfae:root-of(.))]">
+                        <xsl:call-template name="rdfae:prune-husks">
                             <xsl:with-param name="scope" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
                     <!-- flow containers that lost their last block revert to text hosts -->
-                    <xsl:for-each select="$collapse-candidates[exists(local:root-of(.))]">
-                        <xsl:call-template name="local:collapse-container">
+                    <xsl:for-each select="$collapse-candidates[exists(rdfae:root-of(.))]">
+                        <xsl:call-template name="rdfae:collapse-container">
                             <xsl:with-param name="container" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
-                    <xsl:for-each select="($start-host, $end-host)[exists(local:root-of(.))][@contenteditable = 'true']">
-                        <xsl:call-template name="local:ensure-placeholder">
+                    <xsl:for-each select="($start-host, $end-host)[exists(rdfae:root-of(.))][@contenteditable = 'true']">
+                        <xsl:call-template name="rdfae:ensure-placeholder">
                             <xsl:with-param name="host" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
                     <!-- a boundary at a block's very edge can sweep the handle away:
                          re-inject (idempotent, top-level only) -->
                     <xsl:for-each select="$region/*[not(@data-role)]">
-                        <xsl:call-template name="local:inject-chrome">
+                        <xsl:call-template name="rdfae:inject-chrome">
                             <xsl:with-param name="block" select="."/>
                         </xsl:call-template>
                     </xsl:for-each>
-                    <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
+                    <ixsl:set-property name="activeBlock" select="()" object="rdfae:editor-state()"/>
                     <xsl:choose>
                         <!-- everything went: reseed so the region can hold a caret -->
                         <xsl:when test="empty($region/*[not(@data-role)])">
-                            <xsl:call-template name="local:seed-region">
+                            <xsl:call-template name="rdfae:seed-region">
                                 <xsl:with-param name="region" select="$region"/>
                             </xsl:call-template>
                         </xsl:when>
-                        <xsl:when test="$merge and exists($seam-text) and exists(local:host-of($seam-text))">
-                            <xsl:call-template name="local:focus-caret">
+                        <xsl:when test="$merge and exists($seam-text) and exists(rdfae:host-of($seam-text))">
+                            <xsl:call-template name="rdfae:focus-caret">
                                 <xsl:with-param name="node" select="$seam-text"/>
                                 <xsl:with-param name="offset" select="0"/>
                             </xsl:call-template>
                         </xsl:when>
-                        <xsl:when test="exists(local:last-host-in($head-block[exists(local:root-of(.))]))">
-                            <xsl:for-each select="local:last-host-in($head-block)">
-                                <xsl:call-template name="local:focus-caret">
+                        <xsl:when test="exists(rdfae:last-host-in($head-block[exists(rdfae:root-of(.))]))">
+                            <xsl:for-each select="rdfae:last-host-in($head-block)">
+                                <xsl:call-template name="rdfae:focus-caret">
                                     <xsl:with-param name="node" select="."/>
                                     <xsl:with-param name="offset"
                                         select="count(node()) - count(node()[last()][self::br])"/>
                                 </xsl:call-template>
                             </xsl:for-each>
                         </xsl:when>
-                        <xsl:when test="exists(local:first-host-in($tail-block[exists(local:root-of(.))]))">
-                            <xsl:for-each select="local:first-host-in($tail-block)">
-                                <xsl:call-template name="local:focus-caret">
+                        <xsl:when test="exists(rdfae:first-host-in($tail-block[exists(rdfae:root-of(.))]))">
+                            <xsl:for-each select="rdfae:first-host-in($tail-block)">
+                                <xsl:call-template name="rdfae:focus-caret">
                                     <xsl:with-param name="node" select="."/>
-                                    <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+                                    <xsl:with-param name="offset" select="rdfae:chrome-count(.)"/>
                                 </xsl:call-template>
                             </xsl:for-each>
                         </xsl:when>
-                        <xsl:when test="exists(local:first-host-in($next-block))">
-                            <xsl:for-each select="local:first-host-in($next-block)">
-                                <xsl:call-template name="local:focus-caret">
+                        <xsl:when test="exists(rdfae:first-host-in($next-block))">
+                            <xsl:for-each select="rdfae:first-host-in($next-block)">
+                                <xsl:call-template name="rdfae:focus-caret">
                                     <xsl:with-param name="node" select="."/>
-                                    <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+                                    <xsl:with-param name="offset" select="rdfae:chrome-count(.)"/>
                                 </xsl:call-template>
                             </xsl:for-each>
                         </xsl:when>
                         <!-- a neighboring island has no host to land in: select it -->
-                        <xsl:when test="local:island($next-block)">
-                            <xsl:call-template name="local:select-island">
+                        <xsl:when test="rdfae:island($next-block)">
+                            <xsl:call-template name="rdfae:select-island">
                                 <xsl:with-param name="element" select="$next-block"/>
                             </xsl:call-template>
                         </xsl:when>
-                        <xsl:when test="local:island($prev-block)">
-                            <xsl:call-template name="local:select-island">
+                        <xsl:when test="rdfae:island($prev-block)">
+                            <xsl:call-template name="rdfae:select-island">
                                 <xsl:with-param name="element" select="$prev-block"/>
                             </xsl:call-template>
                         </xsl:when>
                         <xsl:otherwise>
-                            <xsl:for-each select="local:last-host-in($prev-block)">
-                                <xsl:call-template name="local:focus-caret">
+                            <xsl:for-each select="rdfae:last-host-in($prev-block)">
+                                <xsl:call-template name="rdfae:focus-caret">
                                     <xsl:with-param name="node" select="."/>
                                     <xsl:with-param name="offset"
                                         select="count(node()) - count(node()[last()][self::br])"/>
@@ -691,7 +691,7 @@ version="3.0">
                             </xsl:for-each>
                         </xsl:otherwise>
                     </xsl:choose>
-                    <xsl:call-template name="local:after-mutation"/>
+                    <xsl:call-template name="rdfae:after-mutation"/>
                 </xsl:if>
             </xsl:if>
         </xsl:if>
@@ -700,14 +700,14 @@ version="3.0">
     <!-- type-to-replace: after the delete machine has collapsed the caret into a
          host, the typed character lands there - one gesture, one undo entry (the
          machine's push; the insert rides the same snapshot) -->
-    <xsl:template name="local:insert-text-at-caret">
+    <xsl:template name="rdfae:insert-text-at-caret">
         <xsl:param name="text" as="xs:string"/>
-        <xsl:variable name="range" select="local:caret-range()"/>
+        <xsl:variable name="range" select="rdfae:caret-range()"/>
         <xsl:for-each select="$range[ixsl:get(., 'collapsed')]">
-            <xsl:for-each select="local:host-of(ixsl:get(., 'startContainer'))[exists(local:block-of(.))]">
+            <xsl:for-each select="rdfae:host-of(ixsl:get(., 'startContainer'))[exists(rdfae:block-of(.))]">
                 <xsl:variable name="node" select="ixsl:call(ixsl:page(), 'createTextNode', [ $text ])"/>
                 <xsl:sequence select="ixsl:call($range, 'insertNode', [ $node ])[current-date() lt xs:date('2000-01-01')]"/>
-                <xsl:call-template name="local:place-caret">
+                <xsl:call-template name="rdfae:place-caret">
                     <xsl:with-param name="node" select="$node"/>
                     <xsl:with-param name="offset" select="string-length($text)"/>
                 </xsl:call-template>
@@ -720,19 +720,19 @@ version="3.0">
     <!-- empty a covered cell keeping the grid: content out, then a flow cell
          reverts to a text host (collapse handles editability and placeholder),
          an inline-only host (caption) just gets its placeholder back -->
-    <xsl:template name="local:clear-host">
+    <xsl:template name="rdfae:clear-host">
         <xsl:param name="host" as="element()"/>
         <xsl:for-each select="1 to xs:integer(ixsl:get($host, 'childNodes.length'))">
             <xsl:sequence select="ixsl:call($host, 'removeChild', [ ixsl:get($host, 'firstChild') ])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
         <xsl:choose>
             <xsl:when test="cm:flow(local-name($host))">
-                <xsl:call-template name="local:collapse-container">
+                <xsl:call-template name="rdfae:collapse-container">
                     <xsl:with-param name="container" select="$host"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
-                <xsl:call-template name="local:ensure-placeholder">
+                <xsl:call-template name="rdfae:ensure-placeholder">
                     <xsl:with-param name="host" select="$host"/>
                 </xsl:call-template>
             </xsl:otherwise>
@@ -742,7 +742,7 @@ version="3.0">
     <!-- remove structural containers emptied by a deletion (a list whose items
          all went, a quote whose blocks all went), innermost first, re-probing
          after each removal so emptiness cascades upward -->
-    <xsl:template name="local:prune-husks">
+    <xsl:template name="rdfae:prune-husks">
         <xsl:param name="scope" as="element()"/>
         <xsl:variable name="husk" as="element()?" select="($scope/descendant-or-self::*
             [self::ul or self::ol or self::dl or self::blockquote]
@@ -750,7 +750,7 @@ version="3.0">
         <xsl:for-each select="$husk">
             <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
             <xsl:if test="not(. is $scope)">
-                <xsl:call-template name="local:prune-husks">
+                <xsl:call-template name="rdfae:prune-husks">
                     <xsl:with-param name="scope" select="$scope"/>
                 </xsl:call-template>
             </xsl:if>
@@ -759,18 +759,18 @@ version="3.0">
 
     <!-- an emptied region cannot hold a caret: seed a fresh paragraph host (the
          empty-blockquote idiom with the region as explicit parent) -->
-    <xsl:template name="local:seed-region">
+    <xsl:template name="rdfae:seed-region">
         <xsl:param name="region" as="element()"/>
-        <xsl:variable name="p" as="element()" select="local:element('p')"/>
-        <xsl:sequence select="ixsl:call($p, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:variable name="p" as="element()" select="rdfae:element('p')"/>
+        <xsl:sequence select="ixsl:call($p, 'appendChild', [ rdfae:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
         <ixsl:set-attribute name="contenteditable" select="'true'" object="$p"/>
         <xsl:sequence select="ixsl:call($region, 'appendChild', [ $p ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:inject-chrome">
+        <xsl:call-template name="rdfae:inject-chrome">
             <xsl:with-param name="block" select="$p"/>
         </xsl:call-template>
-        <xsl:call-template name="local:focus-caret">
+        <xsl:call-template name="rdfae:focus-caret">
             <xsl:with-param name="node" select="$p"/>
-            <xsl:with-param name="offset" select="local:chrome-count($p)"/>
+            <xsl:with-param name="offset" select="rdfae:chrome-count($p)"/>
         </xsl:call-template>
     </xsl:template>
 
diff --git a/src/tables.xsl b/src/tables.xsl
index 0d1063c..e6e5936 100644
--- a/src/tables.xsl
+++ b/src/tables.xsl
@@ -4,7 +4,7 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 version="3.0">
@@ -24,63 +24,63 @@ version="3.0">
 
     <!-- ................................ helpers ................................ -->
 
-    <xsl:function name="local:cell-of" as="element()?">
+    <xsl:function name="rdfae:cell-of" as="element()?">
         <xsl:param name="node"/>
         <xsl:sequence select="$node/ancestor-or-self::*[self::td or self::th][1]"/>
     </xsl:function>
 
     <!-- the cell the caret is in: selection first, then the last focused host -->
-    <xsl:function name="local:current-cell" as="element()?">
-        <xsl:sequence select="(local:anchor-node() ! local:cell-of(.),
-            ixsl:get(local:editor-state(), 'activeBlock') ! local:cell-of(.))[1][exists(local:block-of(.))]"/>
+    <xsl:function name="rdfae:current-cell" as="element()?">
+        <xsl:sequence select="(rdfae:anchor-node() ! rdfae:cell-of(.),
+            ixsl:get(rdfae:editor-state(), 'activeBlock') ! rdfae:cell-of(.))[1][exists(rdfae:block-of(.))]"/>
     </xsl:function>
 
-    <xsl:function name="local:table-of" as="element()?">
+    <xsl:function name="rdfae:table-of" as="element()?">
         <xsl:param name="node"/>
         <xsl:sequence select="$node/ancestor-or-self::table[1]"/>
     </xsl:function>
 
     <!-- rows in visual order; tolerates bare table > tr (XHTML-parsed host pages) -->
-    <xsl:function name="local:table-rows" as="element()*">
+    <xsl:function name="rdfae:table-rows" as="element()*">
         <xsl:param name="table" as="element()?"/>
         <xsl:sequence select="$table/(thead | tbody | tfoot)/tr | $table/tr"/>
     </xsl:function>
 
-    <xsl:function name="local:table-cells" as="element()*">
+    <xsl:function name="rdfae:table-cells" as="element()*">
         <xsl:param name="table" as="element()?"/>
-        <xsl:sequence select="local:table-rows($table)/(td | th)"/>
+        <xsl:sequence select="rdfae:table-rows($table)/(td | th)"/>
     </xsl:function>
 
-    <xsl:function name="local:column-index" as="xs:integer">
+    <xsl:function name="rdfae:column-index" as="xs:integer">
         <xsl:param name="cell" as="element()"/>
         <xsl:sequence select="count($cell/preceding-sibling::*[self::td or self::th]) + 1"/>
     </xsl:function>
 
-    <xsl:function name="local:has-spans" as="xs:boolean">
+    <xsl:function name="rdfae:has-spans" as="xs:boolean">
         <xsl:param name="table" as="element()?"/>
-        <xsl:sequence select="exists(local:table-cells($table)[@colspan or @rowspan])"/>
+        <xsl:sequence select="exists(rdfae:table-cells($table)[@colspan or @rowspan])"/>
     </xsl:function>
 
     <!-- ................................ construction ................................ -->
 
     <!-- a fresh editable cell with the <br> caret placeholder (dropped again by
          canonical-xhtml.xsl); returned for the caller to place -->
-    <xsl:template name="local:make-cell">
+    <xsl:template name="rdfae:make-cell">
         <xsl:param name="name" as="xs:string"/>
 
-        <xsl:variable name="cell" as="element()" select="local:element($name)"/>
+        <xsl:variable name="cell" as="element()" select="rdfae:element($name)"/>
         <ixsl:set-attribute name="contenteditable" select="'true'" object="$cell"/>
-        <xsl:sequence select="ixsl:call($cell, 'appendChild', [ local:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
+        <xsl:sequence select="ixsl:call($cell, 'appendChild', [ rdfae:element('br') ])[current-date() lt xs:date('2000-01-01')]"/>
         <xsl:sequence select="$cell"/>
     </xsl:template>
 
-    <xsl:template name="local:make-row">
+    <xsl:template name="rdfae:make-row">
         <xsl:param name="cols" as="xs:integer"/>
 
-        <xsl:variable name="row" as="element()" select="local:element('tr')"/>
+        <xsl:variable name="row" as="element()" select="rdfae:element('tr')"/>
         <xsl:for-each select="1 to $cols">
             <xsl:variable name="cell" as="element()">
-                <xsl:call-template name="local:make-cell">
+                <xsl:call-template name="rdfae:make-cell">
                     <xsl:with-param name="name" select="'td'"/>
                 </xsl:call-template>
             </xsl:variable>
@@ -92,7 +92,7 @@ version="3.0">
     <!-- a fresh all-td row next to $row, returned for caret placement; () on a
          no-op. The header row is pinned first: "before" it does nothing,
          "after" it lands at the top of the body -->
-    <xsl:template name="local:insert-row">
+    <xsl:template name="rdfae:insert-row">
         <xsl:param name="row" as="element()"/>
         <xsl:param name="before" as="xs:boolean"/>
 
@@ -102,7 +102,7 @@ version="3.0">
             else $row"/>
         <xsl:for-each select="$anchor">
             <xsl:variable name="new" as="element()">
-                <xsl:call-template name="local:make-row">
+                <xsl:call-template name="rdfae:make-row">
                     <xsl:with-param name="cols" select="count($row/(td | th))"/>
                 </xsl:call-template>
             </xsl:variable>
@@ -114,7 +114,7 @@ version="3.0">
 
     <!-- ................................ insert dialog ................................ -->
 
-    <xsl:template name="local:render-table-dialog">
+    <xsl:template name="rdfae:render-table-dialog">
         <div id="table-dialog" class="rdfa-editor-ui edit-dialog" role="dialog" aria-modal="true"
                 aria-label="Insert table" style="display: none;">
             <label>Body rows</label>
@@ -133,7 +133,7 @@ version="3.0">
 
     <xsl:template match="button[contains-token(@class, 'insert-table')]" mode="ixsl:onclick">
         <ixsl:set-property name="insertHost"
-            select="local:current-host()[exists(local:block-of(.))]" object="local:editor-state()"/>
+            select="rdfae:current-host()[exists(rdfae:block-of(.))]" object="rdfae:editor-state()"/>
         <xsl:variable name="dialog" as="element()" select="id('table-dialog', ixsl:page())"/>
         <xsl:for-each select="($dialog//input[@name = 'rows'])[1], ($dialog//input[@name = 'cols'])[1]">
             <ixsl:set-property name="value" select="'3'" object="."/>
@@ -144,7 +144,7 @@ version="3.0">
         <xsl:for-each select="($dialog//input[@name = 'header-row'])[1]">
             <ixsl:set-property name="checked" select="true()" object="."/>
         </xsl:for-each>
-        <xsl:call-template name="local:show-at">
+        <xsl:call-template name="rdfae:show-at">
             <xsl:with-param name="element" select="$dialog"/>
             <xsl:with-param name="event" select="ixsl:event()"/>
         </xsl:call-template>
@@ -155,27 +155,27 @@ version="3.0">
 
     <xsl:template match="button[contains-token(@class, 'table-save')]" mode="ixsl:onclick">
         <xsl:variable name="dialog" as="element()" select="ancestor::div[@id = 'table-dialog']"/>
-        <xsl:variable name="rows-raw" as="xs:string" select="local:input-value($dialog, 'rows')"/>
-        <xsl:variable name="cols-raw" as="xs:string" select="local:input-value($dialog, 'cols')"/>
+        <xsl:variable name="rows-raw" as="xs:string" select="rdfae:input-value($dialog, 'rows')"/>
+        <xsl:variable name="cols-raw" as="xs:string" select="rdfae:input-value($dialog, 'cols')"/>
         <xsl:if test="$rows-raw castable as xs:integer and $cols-raw castable as xs:integer">
             <xsl:variable name="rows" as="xs:integer" select="min((max((xs:integer($rows-raw), 1)), 50))"/>
             <xsl:variable name="cols" as="xs:integer" select="min((max((xs:integer($cols-raw), 1)), 20))"/>
             <xsl:variable name="header" as="xs:boolean" select="boolean(ixsl:get(($dialog//input[@name = 'header-row'])[1], 'checked'))"/>
-            <xsl:variable name="caption-text" as="xs:string" select="local:input-value($dialog, 'caption')"/>
-            <xsl:call-template name="local:push-undo"/>
-            <xsl:variable name="table" as="element()" select="local:element('table')"/>
+            <xsl:variable name="caption-text" as="xs:string" select="rdfae:input-value($dialog, 'caption')"/>
+            <xsl:call-template name="rdfae:push-undo"/>
+            <xsl:variable name="table" as="element()" select="rdfae:element('table')"/>
             <xsl:if test="$caption-text ne ''">
-                <xsl:variable name="caption" as="element()" select="local:element('caption')"/>
+                <xsl:variable name="caption" as="element()" select="rdfae:element('caption')"/>
                 <ixsl:set-attribute name="contenteditable" select="'true'" object="$caption"/>
                 <ixsl:set-property name="textContent" select="$caption-text" object="$caption"/>
                 <xsl:sequence select="ixsl:call($table, 'appendChild', [ $caption ])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:if>
             <xsl:if test="$header">
-                <xsl:variable name="thead" as="element()" select="local:element('thead')"/>
-                <xsl:variable name="tr" as="element()" select="local:element('tr')"/>
+                <xsl:variable name="thead" as="element()" select="rdfae:element('thead')"/>
+                <xsl:variable name="tr" as="element()" select="rdfae:element('tr')"/>
                 <xsl:for-each select="1 to $cols">
                     <xsl:variable name="th" as="element()">
-                        <xsl:call-template name="local:make-cell">
+                        <xsl:call-template name="rdfae:make-cell">
                             <xsl:with-param name="name" select="'th'"/>
                         </xsl:call-template>
                     </xsl:variable>
@@ -184,10 +184,10 @@ version="3.0">
                 <xsl:sequence select="ixsl:call($thead, 'appendChild', [ $tr ])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:sequence select="ixsl:call($table, 'appendChild', [ $thead ])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:if>
-            <xsl:variable name="tbody" as="element()" select="local:element('tbody')"/>
+            <xsl:variable name="tbody" as="element()" select="rdfae:element('tbody')"/>
             <xsl:for-each select="1 to $rows">
                 <xsl:variable name="tr" as="element()">
-                    <xsl:call-template name="local:make-row">
+                    <xsl:call-template name="rdfae:make-row">
                         <xsl:with-param name="cols" select="$cols"/>
                     </xsl:call-template>
                 </xsl:variable>
@@ -198,46 +198,46 @@ version="3.0">
                  opened from: an empty list item or cell grows the table INSIDE
                  itself, a sibling where the parent admits it (chrome only when it
                  lands top-level - the helper guards it) -->
-            <xsl:call-template name="local:insert-block-at-caret">
+            <xsl:call-template name="rdfae:insert-block-at-caret">
                 <xsl:with-param name="node" select="$table"/>
-                <xsl:with-param name="host" select="ixsl:get(local:editor-state(), 'insertHost')[exists(local:block-of(.))]"/>
+                <xsl:with-param name="host" select="ixsl:get(rdfae:editor-state(), 'insertHost')[exists(rdfae:block-of(.))]"/>
             </xsl:call-template>
-            <xsl:for-each select="(local:table-cells($table))[1]">
-                <xsl:call-template name="local:focus-caret">
+            <xsl:for-each select="(rdfae:table-cells($table))[1]">
+                <xsl:call-template name="rdfae:focus-caret">
                     <xsl:with-param name="node" select="."/>
                     <xsl:with-param name="offset" select="0"/>
                 </xsl:call-template>
             </xsl:for-each>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:if>
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
     </xsl:template>
 
     <!-- ................................ row/column operations ................................ -->
 
     <xsl:template match="button[contains-token(@class, 'table-op')]" mode="ixsl:onclick">
         <xsl:variable name="op" as="xs:string" select="string(@data-op)"/>
-        <xsl:for-each select="local:current-cell()[not(local:has-spans(local:table-of(.)))]">
+        <xsl:for-each select="rdfae:current-cell()[not(rdfae:has-spans(rdfae:table-of(.)))]">
             <xsl:choose>
                 <xsl:when test="$op = ('row-above', 'row-below')">
-                    <xsl:call-template name="local:op-insert-row">
+                    <xsl:call-template name="rdfae:op-insert-row">
                         <xsl:with-param name="cell" select="."/>
                         <xsl:with-param name="before" select="$op = 'row-above'"/>
                     </xsl:call-template>
                 </xsl:when>
                 <xsl:when test="$op = ('col-left', 'col-right')">
-                    <xsl:call-template name="local:op-insert-column">
+                    <xsl:call-template name="rdfae:op-insert-column">
                         <xsl:with-param name="cell" select="."/>
                         <xsl:with-param name="before" select="$op = 'col-left'"/>
                     </xsl:call-template>
                 </xsl:when>
                 <xsl:when test="$op = 'del-row'">
-                    <xsl:call-template name="local:op-delete-row">
+                    <xsl:call-template name="rdfae:op-delete-row">
                         <xsl:with-param name="cell" select="."/>
                     </xsl:call-template>
                 </xsl:when>
                 <xsl:when test="$op = 'del-col'">
-                    <xsl:call-template name="local:op-delete-column">
+                    <xsl:call-template name="rdfae:op-delete-column">
                         <xsl:with-param name="cell" select="."/>
                     </xsl:call-template>
                 </xsl:when>
@@ -248,46 +248,46 @@ version="3.0">
 
     <!-- capture pre-insert state; push only when the insert happened (insert-row
          no-ops above the header row and after a headerless table's thead) -->
-    <xsl:template name="local:op-insert-row">
+    <xsl:template name="rdfae:op-insert-row">
         <xsl:param name="cell" as="element()"/>
         <xsl:param name="before" as="xs:boolean"/>
 
-        <xsl:variable name="i" as="xs:integer" select="local:column-index($cell)"/>
-        <xsl:variable name="snapshot-root" as="element()?" select="local:root-of($cell)"/>
+        <xsl:variable name="i" as="xs:integer" select="rdfae:column-index($cell)"/>
+        <xsl:variable name="snapshot-root" as="element()?" select="rdfae:root-of($cell)"/>
         <xsl:variable name="snapshot" as="xs:string?" select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
         <xsl:variable name="new" as="element()?">
-            <xsl:call-template name="local:insert-row">
+            <xsl:call-template name="rdfae:insert-row">
                 <xsl:with-param name="row" select="$cell/parent::tr"/>
                 <xsl:with-param name="before" select="$before"/>
             </xsl:call-template>
         </xsl:variable>
         <xsl:for-each select="$new">
-            <xsl:call-template name="local:push-undo">
+            <xsl:call-template name="rdfae:push-undo">
                 <xsl:with-param name="root" select="$snapshot-root"/>
                 <xsl:with-param name="snapshot" select="$snapshot"/>
             </xsl:call-template>
             <xsl:for-each select="((td | th)[$i], (td | th)[last()])[1]">
-                <xsl:call-template name="local:focus-caret">
+                <xsl:call-template name="rdfae:focus-caret">
                     <xsl:with-param name="node" select="."/>
                     <xsl:with-param name="offset" select="0"/>
                 </xsl:call-template>
             </xsl:for-each>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template name="local:op-insert-column">
+    <xsl:template name="rdfae:op-insert-column">
         <xsl:param name="cell" as="element()"/>
         <xsl:param name="before" as="xs:boolean"/>
 
-        <xsl:variable name="i" as="xs:integer" select="local:column-index($cell)"/>
-        <xsl:call-template name="local:push-undo">
+        <xsl:variable name="i" as="xs:integer" select="rdfae:column-index($cell)"/>
+        <xsl:call-template name="rdfae:push-undo">
             <xsl:with-param name="host" select="$cell"/>
         </xsl:call-template>
-        <xsl:for-each select="local:table-rows(local:table-of($cell))">
+        <xsl:for-each select="rdfae:table-rows(rdfae:table-of($cell))">
             <xsl:variable name="row" as="element()" select="."/>
             <xsl:variable name="new" as="element()">
-                <xsl:call-template name="local:make-cell">
+                <xsl:call-template name="rdfae:make-cell">
                     <xsl:with-param name="name" select="if ($row/parent::thead) then 'th' else 'td'"/>
                 </xsl:call-template>
             </xsl:variable>
@@ -303,29 +303,29 @@ version="3.0">
             </xsl:choose>
         </xsl:for-each>
         <xsl:variable name="j" as="xs:integer" select="$i + (if ($before) then 0 else 1)"/>
-        <xsl:for-each select="local:first-host-in(($cell/parent::tr/(td | th))[$j])">
-            <xsl:call-template name="local:focus-caret">
+        <xsl:for-each select="rdfae:first-host-in(($cell/parent::tr/(td | th))[$j])">
+            <xsl:call-template name="rdfae:focus-caret">
                 <xsl:with-param name="node" select="."/>
                 <xsl:with-param name="offset" select="0"/>
             </xsl:call-template>
         </xsl:for-each>
-        <xsl:call-template name="local:after-mutation"/>
+        <xsl:call-template name="rdfae:after-mutation"/>
     </xsl:template>
 
     <!-- the last body row stays (delete-block removes the whole table); a header
          row goes only while body rows remain to hold the caret -->
-    <xsl:template name="local:op-delete-row">
+    <xsl:template name="rdfae:op-delete-row">
         <xsl:param name="cell" as="element()"/>
 
         <xsl:variable name="row" as="element()" select="$cell/parent::tr"/>
-        <xsl:variable name="table" as="element()?" select="local:table-of($cell)"/>
-        <xsl:variable name="body-rows" as="element()*" select="local:table-rows($table)[not(parent::thead)]"/>
+        <xsl:variable name="table" as="element()?" select="rdfae:table-of($cell)"/>
+        <xsl:variable name="body-rows" as="element()*" select="rdfae:table-rows($table)[not(parent::thead)]"/>
         <xsl:if test="if ($row/parent::thead) then exists($body-rows) else count($body-rows) gt 1">
-            <xsl:variable name="i" as="xs:integer" select="local:column-index($cell)"/>
-            <xsl:variable name="rows" as="element()*" select="local:table-rows($table)"/>
+            <xsl:variable name="i" as="xs:integer" select="rdfae:column-index($cell)"/>
+            <xsl:variable name="rows" as="element()*" select="rdfae:table-rows($table)"/>
             <xsl:variable name="target" as="element()?"
                 select="(($rows[. &gt;&gt; $row])[1], ($rows[. &lt;&lt; $row])[last()])[1]"/>
-            <xsl:call-template name="local:push-undo">
+            <xsl:call-template name="rdfae:push-undo">
                 <xsl:with-param name="host" select="$cell"/>
             </xsl:call-template>
             <xsl:variable name="section" as="element()" select="$row/parent::*"/>
@@ -333,43 +333,43 @@ version="3.0">
             <xsl:if test="$section[self::thead or self::tbody or self::tfoot] and empty($section/tr)">
                 <xsl:sequence select="ixsl:call($section, 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:if>
-            <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
-            <xsl:for-each select="local:first-host-in(
+            <ixsl:set-property name="activeBlock" select="()" object="rdfae:editor-state()"/>
+            <xsl:for-each select="rdfae:first-host-in(
                     (($target/(td | th))[$i], ($target/(td | th))[last()])[1])">
-                <xsl:call-template name="local:focus-caret">
+                <xsl:call-template name="rdfae:focus-caret">
                     <xsl:with-param name="node" select="."/>
                     <xsl:with-param name="offset" select="0"/>
                 </xsl:call-template>
             </xsl:for-each>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:if>
     </xsl:template>
 
     <!-- the last column stays; victims are materialized before the first removal
          because the positional index shifts as cells go -->
-    <xsl:template name="local:op-delete-column">
+    <xsl:template name="rdfae:op-delete-column">
         <xsl:param name="cell" as="element()"/>
 
         <xsl:variable name="row" as="element()" select="$cell/parent::tr"/>
         <xsl:if test="count($row/(td | th)) gt 1">
-            <xsl:variable name="i" as="xs:integer" select="local:column-index($cell)"/>
+            <xsl:variable name="i" as="xs:integer" select="rdfae:column-index($cell)"/>
             <xsl:variable name="victims" as="element()*"
-                select="local:table-rows(local:table-of($cell)) ! (./(td | th))[$i]"/>
-            <xsl:call-template name="local:push-undo">
+                select="rdfae:table-rows(rdfae:table-of($cell)) ! (./(td | th))[$i]"/>
+            <xsl:call-template name="rdfae:push-undo">
                 <xsl:with-param name="host" select="$cell"/>
             </xsl:call-template>
             <xsl:for-each select="$victims">
                 <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:for-each>
-            <ixsl:set-property name="activeBlock" select="()" object="local:editor-state()"/>
-            <xsl:for-each select="local:first-host-in(
+            <ixsl:set-property name="activeBlock" select="()" object="rdfae:editor-state()"/>
+            <xsl:for-each select="rdfae:first-host-in(
                     (($row/(td | th))[$i], ($row/(td | th))[last()])[1])">
-                <xsl:call-template name="local:focus-caret">
+                <xsl:call-template name="rdfae:focus-caret">
                     <xsl:with-param name="node" select="."/>
                     <xsl:with-param name="offset" select="0"/>
                 </xsl:call-template>
             </xsl:for-each>
-            <xsl:call-template name="local:after-mutation"/>
+            <xsl:call-template name="rdfae:after-mutation"/>
         </xsl:if>
     </xsl:template>
 
@@ -378,27 +378,27 @@ version="3.0">
     <!-- Tab walks the cells in visual order and grows the table by a body row at
          the very last cell; the caption Tabs into the first cell. Focus never
          Tabs out of the grid into the toolbar -->
-    <xsl:template name="local:table-tab">
+    <xsl:template name="rdfae:table-tab">
         <xsl:param name="host" as="element()"/>
         <xsl:param name="event"/>
         <xsl:param name="shift" as="xs:boolean"/>
 
         <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:variable name="table" as="element()?" select="local:table-of($host)"/>
-        <xsl:variable name="cells" as="element()*" select="local:table-cells($table)"/>
+        <xsl:variable name="table" as="element()?" select="rdfae:table-of($host)"/>
+        <xsl:variable name="cells" as="element()*" select="rdfae:table-cells($table)"/>
         <xsl:choose>
             <xsl:when test="$shift">
-                <xsl:for-each select="local:last-host-in(($cells[. &lt;&lt; $host])[last()])">
+                <xsl:for-each select="rdfae:last-host-in(($cells[. &lt;&lt; $host])[last()])">
                     <!-- caret at the end, but before a trailing placeholder <br> -->
-                    <xsl:call-template name="local:focus-caret">
+                    <xsl:call-template name="rdfae:focus-caret">
                         <xsl:with-param name="node" select="."/>
                         <xsl:with-param name="offset" select="count(node()) - count(node()[last()][self::br])"/>
                     </xsl:call-template>
                 </xsl:for-each>
             </xsl:when>
             <xsl:when test="exists(($cells[. &gt;&gt; $host])[1])">
-                <xsl:for-each select="local:first-host-in(($cells[. &gt;&gt; $host])[1])">
-                    <xsl:call-template name="local:focus-caret">
+                <xsl:for-each select="rdfae:first-host-in(($cells[. &gt;&gt; $host])[1])">
+                    <xsl:call-template name="rdfae:focus-caret">
                         <xsl:with-param name="node" select="."/>
                         <xsl:with-param name="offset" select="0"/>
                     </xsl:call-template>
@@ -406,47 +406,47 @@ version="3.0">
             </xsl:when>
             <xsl:otherwise>
                 <!-- capture pre-insert state; push only when the row appeared -->
-                <xsl:variable name="snapshot-root" as="element()?" select="local:root-of($host)"/>
+                <xsl:variable name="snapshot-root" as="element()?" select="rdfae:root-of($host)"/>
                 <xsl:variable name="snapshot" as="xs:string?" select="$snapshot-root ! string(ixsl:get(., 'innerHTML'))"/>
                 <xsl:variable name="new" as="element()?">
-                    <xsl:for-each select="(local:table-rows($table))[last()]">
-                        <xsl:call-template name="local:insert-row">
+                    <xsl:for-each select="(rdfae:table-rows($table))[last()]">
+                        <xsl:call-template name="rdfae:insert-row">
                             <xsl:with-param name="row" select="."/>
                             <xsl:with-param name="before" select="false()"/>
                         </xsl:call-template>
                     </xsl:for-each>
                 </xsl:variable>
                 <xsl:for-each select="$new">
-                    <xsl:call-template name="local:push-undo">
+                    <xsl:call-template name="rdfae:push-undo">
                         <xsl:with-param name="root" select="$snapshot-root"/>
                         <xsl:with-param name="snapshot" select="$snapshot"/>
                     </xsl:call-template>
                     <xsl:for-each select="(td | th)[1]">
-                        <xsl:call-template name="local:focus-caret">
+                        <xsl:call-template name="rdfae:focus-caret">
                             <xsl:with-param name="node" select="."/>
                             <xsl:with-param name="offset" select="0"/>
                         </xsl:call-template>
                     </xsl:for-each>
-                    <xsl:call-template name="local:after-mutation"/>
+                    <xsl:call-template name="rdfae:after-mutation"/>
                 </xsl:for-each>
             </xsl:otherwise>
         </xsl:choose>
     </xsl:template>
 
     <!-- Enter steps down the column, growing the table below the last row; the
-         caller (local:handle-enter) has already pushed undo and cut a selection -->
-    <xsl:template name="local:table-enter">
+         caller (rdfae:handle-enter) has already pushed undo and cut a selection -->
+    <xsl:template name="rdfae:table-enter">
         <xsl:param name="host" as="element()"/>
 
-        <xsl:variable name="table" as="element()?" select="local:table-of($host)"/>
+        <xsl:variable name="table" as="element()?" select="rdfae:table-of($host)"/>
         <xsl:variable name="row" as="element()" select="$host/parent::tr"/>
-        <xsl:variable name="i" as="xs:integer" select="local:column-index($host)"/>
-        <xsl:variable name="next" as="element()?" select="(local:table-rows($table)[. &gt;&gt; $row])[1]"/>
+        <xsl:variable name="i" as="xs:integer" select="rdfae:column-index($host)"/>
+        <xsl:variable name="next" as="element()?" select="(rdfae:table-rows($table)[. &gt;&gt; $row])[1]"/>
         <xsl:choose>
             <xsl:when test="exists($next)">
-                <xsl:for-each select="local:first-host-in(
+                <xsl:for-each select="rdfae:first-host-in(
                         (($next/(td | th))[$i], ($next/(td | th))[last()])[1])">
-                    <xsl:call-template name="local:focus-caret">
+                    <xsl:call-template name="rdfae:focus-caret">
                         <xsl:with-param name="node" select="."/>
                         <xsl:with-param name="offset" select="0"/>
                     </xsl:call-template>
@@ -454,13 +454,13 @@ version="3.0">
             </xsl:when>
             <xsl:otherwise>
                 <xsl:variable name="new" as="element()?">
-                    <xsl:call-template name="local:insert-row">
+                    <xsl:call-template name="rdfae:insert-row">
                         <xsl:with-param name="row" select="$row"/>
                         <xsl:with-param name="before" select="false()"/>
                     </xsl:call-template>
                 </xsl:variable>
                 <xsl:for-each select="(($new/(td | th))[$i], ($new/(td | th))[last()])[1]">
-                    <xsl:call-template name="local:focus-caret">
+                    <xsl:call-template name="rdfae:focus-caret">
                         <xsl:with-param name="node" select="."/>
                         <xsl:with-param name="offset" select="0"/>
                     </xsl:call-template>
@@ -471,10 +471,10 @@ version="3.0">
 
     <!-- ................................ toolbar state ................................ -->
 
-    <!-- riding local:update-breadcrumb, the single caret-awareness choke point -->
-    <xsl:template name="local:sync-table-toolbar">
+    <!-- riding rdfae:update-breadcrumb, the single caret-awareness choke point -->
+    <xsl:template name="rdfae:sync-table-toolbar">
         <xsl:variable name="enabled" as="xs:boolean"
-            select="exists(local:current-cell()[not(local:has-spans(local:table-of(.)))])"/>
+            select="exists(rdfae:current-cell()[not(rdfae:has-spans(rdfae:table-of(.)))])"/>
         <xsl:for-each select="id('edit-toolbar', ixsl:page())//button[contains-token(@class, 'table-op')]">
             <ixsl:set-property name="disabled" select="not($enabled)" object="."/>
         </xsl:for-each>
diff --git a/src/typeahead.xsl b/src/typeahead.xsl
index d2b8f8f..a94ff5d 100644
--- a/src/typeahead.xsl
+++ b/src/typeahead.xsl
@@ -4,7 +4,7 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 exclude-result-prefixes="xs"
@@ -14,7 +14,7 @@ version="3.0">
     Typeahead lookups for the annotation form's property and type fields (replacing
     long <select> dropdowns). LinkedDataHub's typeahead fires debounced SPARQL; here
     the vocabularies are already in the SaxonJS document pool, so filtering is a
-    synchronous per-keystroke pass over local:vocab-terms - no async, no debounce.
+    synchronous per-keystroke pass over rdfae:vocab-terms - no async, no debounce.
 
     A field is a stable wrapper span[@data-field] holding one of two states, swapped
     via result-document (literal result elements, the IXSL-idiomatic DOM build):
@@ -26,59 +26,59 @@ version="3.0">
 -->
 
     <!-- an absolute IRI has a scheme; free text lacking one is not a usable value -->
-    <xsl:function name="local:is-absolute-iri" as="xs:boolean">
+    <xsl:function name="rdfae:is-absolute-iri" as="xs:boolean">
         <xsl:param name="s" as="xs:string"/>
         <xsl:sequence select="matches($s, '^[A-Za-z][A-Za-z0-9+.\-]*:')"/>
     </xsl:function>
 
-    <xsl:function name="local:typeahead-placeholder" as="xs:string">
+    <xsl:function name="rdfae:typeahead-placeholder" as="xs:string">
         <xsl:param name="field" as="xs:string"/>
         <xsl:sequence select="if ($field = 'typeof')
             then 'Type or paste a class IRI…' else 'Type or paste a property IRI…'"/>
     </xsl:function>
 
-    <xsl:function name="local:typeahead-kind" as="xs:string">
+    <xsl:function name="rdfae:typeahead-kind" as="xs:string">
         <xsl:param name="field" as="xs:string"/>
         <xsl:sequence select="if ($field = 'typeof') then 'class' else 'property'"/>
     </xsl:function>
 
     <!-- all terms of the field's kind across every vocabulary, resolved the same way
-         local:render-overlay does so doc() hits the preloaded pool -->
-    <xsl:function name="local:typeahead-terms" as="map(xs:string, xs:string)*">
+         rdfae:render-overlay does so doc() hits the preloaded pool -->
+    <xsl:function name="rdfae:typeahead-terms" as="map(xs:string, xs:string)*">
         <xsl:param name="field" as="xs:string"/>
 
-        <xsl:variable name="kind" as="xs:string" select="local:typeahead-kind($field)"/>
+        <xsl:variable name="kind" as="xs:string" select="rdfae:typeahead-kind($field)"/>
         <xsl:variable name="vocab-uris" as="xs:string*"
             select="$vocab-hrefs ! string(resolve-uri(., ixsl:location()))"/>
         <xsl:for-each select="$vocab-uris">
-            <xsl:sequence select="local:vocab-terms(doc(.), $kind)"/>
+            <xsl:sequence select="rdfae:vocab-terms(doc(.), $kind)"/>
         </xsl:for-each>
     </xsl:function>
 
     <!-- the human label for a committed IRI: the vocabulary term's label, else the IRI -->
-    <xsl:function name="local:typeahead-label-for" as="xs:string">
+    <xsl:function name="rdfae:typeahead-label-for" as="xs:string">
         <xsl:param name="field" as="xs:string"/>
         <xsl:param name="iri" as="xs:string"/>
 
         <xsl:variable name="match" as="map(xs:string, xs:string)?"
-            select="(local:typeahead-terms($field)[?uri = $iri])[1]"/>
+            select="(rdfae:typeahead-terms($field)[?uri = $iri])[1]"/>
         <xsl:sequence select="(if (exists($match)) then $match?label else (), $iri)[1]"/>
     </xsl:function>
 
-    <!-- the empty typing-state field, placed by local:render-overlay -->
-    <xsl:function name="local:typeahead-field" as="element()">
+    <!-- the empty typing-state field, placed by rdfae:render-overlay -->
+    <xsl:function name="rdfae:typeahead-field" as="element()">
         <xsl:param name="field" as="xs:string"/>
 
         <span class="typeahead-field rdfa-editor-ui" data-field="{$field}">
             <input type="text" class="typeahead-input" autocomplete="off"
-                placeholder="{local:typeahead-placeholder($field)}"/>
+                placeholder="{rdfae:typeahead-placeholder($field)}"/>
             <ul class="typeahead-menu" role="listbox" style="display: none;"/>
         </span>
     </xsl:function>
 
     <!-- the committed IRI, else a free-typed absolute IRI, else the untouched
          button->edit value, else nothing -->
-    <xsl:function name="local:typeahead-value" as="xs:string?">
+    <xsl:function name="rdfae:typeahead-value" as="xs:string?">
         <xsl:param name="form" as="element()"/>
         <xsl:param name="field" as="xs:string"/>
 
@@ -96,7 +96,7 @@ version="3.0">
                 <xsl:variable name="editing" as="xs:string" select="string($wrapper/@data-editing-iri)"/>
                 <xsl:sequence select="
                     if ($text eq '') then ()
-                    else if (local:is-absolute-iri($text)) then $text
+                    else if (rdfae:is-absolute-iri($text)) then $text
                     else if ($editing ne '') then $editing
                     else ()"/>
             </xsl:otherwise>
@@ -106,7 +106,7 @@ version="3.0">
     <!-- reset a field to reflect an IRI (empty -> empty input, non-empty -> button);
          drives form open and edit pre-fill, fully controlling the state (form.reset()
          leaves these custom widgets untouched) -->
-    <xsl:template name="local:typeahead-set-value">
+    <xsl:template name="rdfae:typeahead-set-value">
         <xsl:param name="form" as="element()"/>
         <xsl:param name="field" as="xs:string"/>
         <xsl:param name="iri" as="xs:string"/>
@@ -115,14 +115,14 @@ version="3.0">
             <ixsl:remove-attribute name="data-editing-iri"/>
             <xsl:choose>
                 <xsl:when test="$iri ne ''">
-                    <xsl:call-template name="local:typeahead-commit">
+                    <xsl:call-template name="rdfae:typeahead-commit">
                         <xsl:with-param name="wrapper" select="."/>
                         <xsl:with-param name="iri" select="$iri"/>
-                        <xsl:with-param name="label" select="local:typeahead-label-for($field, $iri)"/>
+                        <xsl:with-param name="label" select="rdfae:typeahead-label-for($field, $iri)"/>
                     </xsl:call-template>
                 </xsl:when>
                 <xsl:otherwise>
-                    <xsl:call-template name="local:typeahead-to-input">
+                    <xsl:call-template name="rdfae:typeahead-to-input">
                         <xsl:with-param name="wrapper" select="."/>
                     </xsl:call-template>
                 </xsl:otherwise>
@@ -131,7 +131,7 @@ version="3.0">
     </xsl:template>
 
     <!-- swap the wrapper to the committed button carrying the IRI -->
-    <xsl:template name="local:typeahead-commit">
+    <xsl:template name="rdfae:typeahead-commit">
         <xsl:param name="wrapper" as="element()"/>
         <xsl:param name="iri" as="xs:string"/>
         <xsl:param name="label" as="xs:string"/>
@@ -151,7 +151,7 @@ version="3.0">
 
     <!-- swap the wrapper to the typing state; optionally seed the text, focus the
          input and open the menu (button->edit) -->
-    <xsl:template name="local:typeahead-to-input">
+    <xsl:template name="rdfae:typeahead-to-input">
         <xsl:param name="wrapper" as="element()"/>
         <xsl:param name="text" as="xs:string" select="''"/>
         <xsl:param name="focus" as="xs:boolean" select="false()"/>
@@ -161,10 +161,10 @@ version="3.0">
         <xsl:for-each select="$wrapper">
             <xsl:result-document href="?." method="ixsl:replace-content">
                 <input type="text" class="typeahead-input" autocomplete="off"
-                    placeholder="{local:typeahead-placeholder($field)}" value="{$text}"/>
+                    placeholder="{rdfae:typeahead-placeholder($field)}" value="{$text}"/>
                 <ul class="typeahead-menu" role="listbox" style="display: {if ($open) then 'block' else 'none'};">
                     <xsl:if test="$open">
-                        <xsl:call-template name="local:typeahead-options">
+                        <xsl:call-template name="rdfae:typeahead-options">
                             <xsl:with-param name="field" select="$field"/>
                             <xsl:with-param name="query" select="$text"/>
                         </xsl:call-template>
@@ -182,12 +182,12 @@ version="3.0">
     <!-- render the option <li> list for a query (no result-document of its own: the
          caller places it inside one). Prefix matches rank first, then by label;
          capped so a large vocabulary stays snappy; the first option is pre-selected -->
-    <xsl:template name="local:typeahead-options">
+    <xsl:template name="rdfae:typeahead-options">
         <xsl:param name="field" as="xs:string"/>
         <xsl:param name="query" as="xs:string"/>
 
         <xsl:variable name="q" as="xs:string" select="lower-case(normalize-space($query))"/>
-        <xsl:variable name="matches" as="map(xs:string, xs:string)*" select="local:typeahead-terms($field)
+        <xsl:variable name="matches" as="map(xs:string, xs:string)*" select="rdfae:typeahead-terms($field)
             [$q = '' or contains(lower-case(?label), $q) or contains(lower-case(?uri), $q)]"/>
         <xsl:variable name="ranked" as="map(xs:string, xs:string)*">
             <xsl:perform-sort select="$matches">
@@ -202,7 +202,7 @@ version="3.0">
                     <xsl:attribute name="aria-selected" select="'true'"/>
                 </xsl:if>
                 <span class="typeahead-option-label">
-                    <xsl:call-template name="local:typeahead-highlight">
+                    <xsl:call-template name="rdfae:typeahead-highlight">
                         <xsl:with-param name="text" select="?label"/>
                         <xsl:with-param name="q" select="$q"/>
                     </xsl:call-template>
@@ -213,14 +213,14 @@ version="3.0">
     </xsl:template>
 
     <!-- re-render the menu for the current query and show/hide it -->
-    <xsl:template name="local:typeahead-refresh">
+    <xsl:template name="rdfae:typeahead-refresh">
         <xsl:param name="wrapper" as="element()"/>
         <xsl:param name="query" as="xs:string"/>
 
         <xsl:variable name="field" as="xs:string" select="string($wrapper/@data-field)"/>
         <xsl:for-each select="$wrapper//ul[contains-token(@class, 'typeahead-menu')]">
             <xsl:result-document href="?." method="ixsl:replace-content">
-                <xsl:call-template name="local:typeahead-options">
+                <xsl:call-template name="rdfae:typeahead-options">
                     <xsl:with-param name="field" select="$field"/>
                     <xsl:with-param name="query" select="$query"/>
                 </xsl:call-template>
@@ -231,7 +231,7 @@ version="3.0">
     </xsl:template>
 
     <!-- the matched substring in bold (first occurrence, case-insensitive) -->
-    <xsl:template name="local:typeahead-highlight">
+    <xsl:template name="rdfae:typeahead-highlight">
         <xsl:param name="text" as="xs:string"/>
         <xsl:param name="q" as="xs:string"/>
 
@@ -256,7 +256,7 @@ version="3.0">
         <xsl:variable name="wrapper" as="element()"
             select="ancestor::span[contains-token(@class, 'typeahead-field')][1]"/>
         <ixsl:remove-attribute name="data-editing-iri" object="$wrapper"/>
-        <xsl:call-template name="local:typeahead-refresh">
+        <xsl:call-template name="rdfae:typeahead-refresh">
             <xsl:with-param name="wrapper" select="$wrapper"/>
             <xsl:with-param name="query" select="string(ixsl:get(., 'value'))"/>
         </xsl:call-template>
@@ -284,22 +284,22 @@ version="3.0">
                         <ixsl:set-style name="display" select="'none'" object="$menu"/>
                     </xsl:when>
                     <xsl:otherwise>
-                        <xsl:call-template name="local:hide-overlay"/>
+                        <xsl:call-template name="rdfae:hide-overlay"/>
                     </xsl:otherwise>
                 </xsl:choose>
             </xsl:when>
             <xsl:when test="$key = 'Enter'">
                 <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
                 <xsl:choose>
-                    <xsl:when test="local:is-absolute-iri($text)">
-                        <xsl:call-template name="local:typeahead-commit">
+                    <xsl:when test="rdfae:is-absolute-iri($text)">
+                        <xsl:call-template name="rdfae:typeahead-commit">
                             <xsl:with-param name="wrapper" select="$wrapper"/>
                             <xsl:with-param name="iri" select="$text"/>
-                            <xsl:with-param name="label" select="local:typeahead-label-for($field, $text)"/>
+                            <xsl:with-param name="label" select="rdfae:typeahead-label-for($field, $text)"/>
                         </xsl:call-template>
                     </xsl:when>
                     <xsl:when test="$open and exists($current)">
-                        <xsl:call-template name="local:typeahead-commit">
+                        <xsl:call-template name="rdfae:typeahead-commit">
                             <xsl:with-param name="wrapper" select="$wrapper"/>
                             <xsl:with-param name="iri" select="string($current/@data-uri)"/>
                             <xsl:with-param name="label" select="string($current/@data-label)"/>
@@ -343,7 +343,7 @@ version="3.0">
          still there to read. preventDefault keeps the caret/focus -->
     <xsl:template match="li[contains-token(@class, 'typeahead-option')]" mode="ixsl:onmousedown">
         <xsl:sequence select="ixsl:call(ixsl:event(), 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:call-template name="local:typeahead-commit">
+        <xsl:call-template name="rdfae:typeahead-commit">
             <xsl:with-param name="wrapper" select="ancestor::span[contains-token(@class, 'typeahead-field')][1]"/>
             <xsl:with-param name="iri" select="string(@data-uri)"/>
             <xsl:with-param name="label" select="string(@data-label)"/>
@@ -362,14 +362,14 @@ version="3.0">
             select="string(.//span[contains-token(@class, 'typeahead-label')])"/>
         <xsl:choose>
             <xsl:when test="exists($target/ancestor-or-self::*[contains-token(@class, 'typeahead-clear')])">
-                <xsl:call-template name="local:typeahead-to-input">
+                <xsl:call-template name="rdfae:typeahead-to-input">
                     <xsl:with-param name="wrapper" select="$wrapper"/>
                     <xsl:with-param name="focus" select="true()"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
                 <ixsl:set-attribute name="data-editing-iri" select="$iri" object="$wrapper"/>
-                <xsl:call-template name="local:typeahead-to-input">
+                <xsl:call-template name="rdfae:typeahead-to-input">
                     <xsl:with-param name="wrapper" select="$wrapper"/>
                     <xsl:with-param name="text" select="$label"/>
                     <xsl:with-param name="focus" select="true()"/>
diff --git a/src/undo.xsl b/src/undo.xsl
index 3a21939..fdf200f 100644
--- a/src/undo.xsl
+++ b/src/undo.xsl
@@ -4,14 +4,14 @@ xmlns="http://www.w3.org/1999/xhtml"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ixsl="http://saxonica.com/ns/interactiveXSLT"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
-xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
 extension-element-prefixes="ixsl"
 xpath-default-namespace="http://www.w3.org/1999/xhtml"
 version="3.0">
 
 <!--
     Unified snapshot undo/redo: one whole-document history over #content innerHTML.
-    Every mutating handler pushes a snapshot first and calls local:after-mutation last;
+    Every mutating handler pushes a snapshot first and calls rdfae:after-mutation last;
     plain typing is
     coalesced into ~1s bursts via ixsl:onbeforeinput. Ctrl/Cmd+Z and Shift+Z / Ctrl+Y
     are intercepted in the keydown dispatcher (edit.xsl) - native undo is replaced.
@@ -28,9 +28,9 @@ version="3.0">
     markers, which the canonicalization contract forbids.
 -->
 
-    <xsl:variable name="local:max-undo" as="xs:integer" select="100"/>
+    <xsl:variable name="rdfae:max-undo" as="xs:integer" select="100"/>
 
-    <xsl:template name="local:init-undo">
+    <xsl:template name="rdfae:init-undo">
         <xsl:for-each select="ixsl:page()//body">
             <xsl:result-document href="?." method="ixsl:append-content">
                 <div id="rdfa-editor-undo-storage" data-role="storage" style="display: none;">
@@ -44,37 +44,37 @@ version="3.0">
     <!-- append a snapshot entry, enforcing the depth cap. The caret position of the
          state being snapshotted rides along as data attributes (the stash lives
          outside #content, so data attributes are fine here) -->
-    <xsl:template name="local:stash-push">
+    <xsl:template name="rdfae:stash-push">
         <xsl:param name="stack" as="element()"/>
         <xsl:param name="snapshot" as="xs:string"/>
         <xsl:param name="root" as="element()"/>
 
-        <xsl:variable name="entry" as="element()" select="local:element('div')"/>
+        <xsl:variable name="entry" as="element()" select="rdfae:element('div')"/>
         <ixsl:set-property name="textContent" select="$snapshot" object="$entry"/>
         <!-- histories are keyed by editable region -->
         <ixsl:set-attribute name="data-root"
-            select="string(count(local:roots()[. &lt;&lt; $root]) + 1)" object="$entry"/>
-        <xsl:call-template name="local:capture-caret">
+            select="string(count(rdfae:roots()[. &lt;&lt; $root]) + 1)" object="$entry"/>
+        <xsl:call-template name="rdfae:capture-caret">
             <xsl:with-param name="entry" select="$entry"/>
             <xsl:with-param name="root" select="$root"/>
         </xsl:call-template>
         <xsl:sequence select="ixsl:call($stack, 'appendChild', [ $entry ])[current-date() lt xs:date('2000-01-01')]"/>
-        <xsl:for-each select="($stack/div)[position() le count($stack/div) - $local:max-undo]">
+        <xsl:for-each select="($stack/div)[position() le count($stack/div) - $rdfae:max-undo]">
             <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
         </xsl:for-each>
     </xsl:template>
 
     <!-- caret as (block index, chrome-free text-node index, character offset);
          captured only when the selection anchors a text node inside content -->
-    <xsl:template name="local:capture-caret">
+    <xsl:template name="rdfae:capture-caret">
         <xsl:param name="entry" as="element()"/>
         <xsl:param name="root" as="element()"/>
 
-        <xsl:variable name="selection" select="local:selection()"/>
+        <xsl:variable name="selection" select="rdfae:selection()"/>
         <xsl:if test="ixsl:get($selection, 'rangeCount') ge 1">
             <xsl:variable name="anchor" select="ixsl:get($selection, 'anchorNode')"/>
-            <xsl:if test="ixsl:get($anchor, 'nodeType') = 3 and (local:root-of($anchor) ! (. is $root))">
-                <xsl:for-each select="local:block-of($anchor)">
+            <xsl:if test="ixsl:get($anchor, 'nodeType') = 3 and (rdfae:root-of($anchor) ! (. is $root))">
+                <xsl:for-each select="rdfae:block-of($anchor)">
                     <xsl:variable name="texts" select=".//text()[not(ancestor::*[@data-role])]"/>
                     <xsl:if test="exists($texts[. is $anchor])">
                         <ixsl:set-attribute name="data-block"
@@ -92,18 +92,18 @@ version="3.0">
     <!-- record the pre-mutation state; call FIRST in every mutating handler.
          $snapshot allows capturing before an operation that may fail (wrap-range)
          and pushing only on success -->
-    <xsl:template name="local:push-undo">
+    <xsl:template name="rdfae:push-undo">
         <xsl:param name="host" as="element()?" select="()"/>
-        <xsl:param name="root" as="element()?" select="($host ! local:root-of(.), local:active-root())[1]"/>
+        <xsl:param name="root" as="element()?" select="($host ! rdfae:root-of(.), rdfae:active-root())[1]"/>
         <xsl:param name="snapshot" as="xs:string?" select="$root ! string(ixsl:get(., 'innerHTML'))"/>
 
         <xsl:for-each select="$root[exists($snapshot)]">
             <xsl:variable name="stack" as="element()" select="id('rdfa-editor-undo-stack', ixsl:page())"/>
-            <xsl:variable name="root-index" as="xs:integer" select="count(local:roots()[. &lt;&lt; current()]) + 1"/>
+            <xsl:variable name="root-index" as="xs:integer" select="count(rdfae:roots()[. &lt;&lt; current()]) + 1"/>
             <xsl:variable name="top" as="element()?" select="($stack/div)[last()]"/>
             <!-- dedup guard: the same region's unchanged snapshot is a no-op -->
             <xsl:if test="not(string($top) eq $snapshot and xs:integer($top/@data-root) eq $root-index)">
-                <xsl:call-template name="local:stash-push">
+                <xsl:call-template name="rdfae:stash-push">
                     <xsl:with-param name="stack" select="$stack"/>
                     <xsl:with-param name="snapshot" select="$snapshot"/>
                     <xsl:with-param name="root" select="."/>
@@ -112,21 +112,21 @@ version="3.0">
             </xsl:if>
         </xsl:for-each>
         <ixsl:set-property name="lastUndoTime"
-            select="ixsl:call(ixsl:get(ixsl:window(), 'Date'), 'now', [])" object="local:editor-state()"/>
-        <ixsl:set-property name="lastUndoHost" select="$host" object="local:editor-state()"/>
+            select="ixsl:call(ixsl:get(ixsl:window(), 'Date'), 'now', [])" object="rdfae:editor-state()"/>
+        <ixsl:set-property name="lastUndoHost" select="$host" object="rdfae:editor-state()"/>
     </xsl:template>
 
     <!-- undo and redo are the same move with the stacks swapped: pop $from,
          push the popped entry's region's current state raw onto $to (raw: never
-         clears the redo stack - only local:push-undo does), restore -->
-    <xsl:template name="local:shift-history">
+         clears the redo stack - only rdfae:push-undo does), restore -->
+    <xsl:template name="rdfae:shift-history">
         <xsl:param name="from" as="xs:string"/>
         <xsl:param name="to" as="xs:string"/>
 
         <xsl:for-each select="(id($from, ixsl:page())/div)[last()]">
             <xsl:variable name="root-index" as="xs:integer" select="xs:integer(@data-root)"/>
-            <xsl:variable name="root" as="element()?" select="local:roots()[$root-index]"/>
-            <xsl:call-template name="local:stash-push">
+            <xsl:variable name="root" as="element()?" select="rdfae:roots()[$root-index]"/>
+            <xsl:call-template name="rdfae:stash-push">
                 <xsl:with-param name="stack" select="id($to, ixsl:page())"/>
                 <xsl:with-param name="snapshot" select="$root ! string(ixsl:get(., 'innerHTML'))"/>
                 <xsl:with-param name="root" select="$root"/>
@@ -134,7 +134,7 @@ version="3.0">
             <xsl:variable name="snapshot" as="xs:string" select="string(.)"/>
             <xsl:variable name="caret" as="xs:integer*" select="(@data-block, @data-node, @data-offset) ! xs:integer(.)"/>
             <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:call-template name="local:restore-snapshot">
+            <xsl:call-template name="rdfae:restore-snapshot">
                 <xsl:with-param name="snapshot" select="$snapshot"/>
                 <xsl:with-param name="caret" select="$caret"/>
                 <xsl:with-param name="root" select="$root"/>
@@ -142,21 +142,21 @@ version="3.0">
         </xsl:for-each>
     </xsl:template>
 
-    <xsl:template name="local:apply-undo">
-        <xsl:call-template name="local:shift-history">
+    <xsl:template name="rdfae:apply-undo">
+        <xsl:call-template name="rdfae:shift-history">
             <xsl:with-param name="from" select="'rdfa-editor-undo-stack'"/>
             <xsl:with-param name="to" select="'rdfa-editor-redo-stack'"/>
         </xsl:call-template>
     </xsl:template>
 
-    <xsl:template name="local:apply-redo">
-        <xsl:call-template name="local:shift-history">
+    <xsl:template name="rdfae:apply-redo">
+        <xsl:call-template name="rdfae:shift-history">
             <xsl:with-param name="from" select="'rdfa-editor-redo-stack'"/>
             <xsl:with-param name="to" select="'rdfa-editor-undo-stack'"/>
         </xsl:call-template>
     </xsl:template>
 
-    <xsl:template name="local:restore-snapshot">
+    <xsl:template name="rdfae:restore-snapshot">
         <xsl:param name="snapshot" as="xs:string"/>
         <xsl:param name="caret" as="xs:integer*" select="()"/>
         <xsl:param name="root" as="element()?"/>
@@ -171,31 +171,31 @@ version="3.0">
             <xsl:for-each select="descendant::*[@data-role = 'chrome']">
                 <xsl:sequence select="ixsl:call(., 'remove', [])[current-date() lt xs:date('2000-01-01')]"/>
             </xsl:for-each>
-            <xsl:call-template name="local:ensure-chrome">
+            <xsl:call-template name="rdfae:ensure-chrome">
                 <xsl:with-param name="scope" select="."/>
             </xsl:call-template>
             <!-- snapshots carry island rendering markup, so restores are normally
                  render-stable; only islands captured mid-render (no rendering div -
                  async renderers inject it in the completion callback only) re-fire -->
-            <xsl:for-each select="descendant-or-self::*[local:island(.)][empty(*[@data-role = 'rendering'])]">
-                <xsl:apply-templates select="." mode="local:render-island"/>
+            <xsl:for-each select="descendant-or-self::*[rdfae:island(.)][empty(*[@data-role = 'rendering'])]">
+                <xsl:apply-templates select="." mode="rdfae:render-island"/>
             </xsl:for-each>
         </xsl:for-each>
         <!-- every stored node reference is stale now -->
-        <xsl:call-template name="local:hide-overlay"/>
-        <xsl:call-template name="local:hide-dialogs"/>
+        <xsl:call-template name="rdfae:hide-overlay"/>
+        <xsl:call-template name="rdfae:hide-dialogs"/>
         <xsl:for-each select="('activeBlock', 'editingSpan', 'draggedBlock', 'editRange', 'editingLink',
                 'insertHost', 'range', 'breadcrumbLeaf', 'findNode', 'lastUndoHost',
                 'draggedSectionHeading', 'slashHost', 'sweepAnchorNode', 'sweepAnchorHost', 'sweepRegion')">
-            <ixsl:set-property name="{.}" select="()" object="local:editor-state()"/>
+            <ixsl:set-property name="{.}" select="()" object="rdfae:editor-state()"/>
         </xsl:for-each>
-        <ixsl:set-property name="lastUndoTime" select="0" object="local:editor-state()"/>
+        <ixsl:set-property name="lastUndoTime" select="0" object="rdfae:editor-state()"/>
         <!-- snapshots taken mid-drag may carry transient drag state -->
-        <xsl:call-template name="local:clear-drop-marks"/>
+        <xsl:call-template name="rdfae:clear-drop-marks"/>
         <xsl:for-each select="$root/descendant::*[@draggable]">
             <ixsl:remove-attribute name="draggable"/>
             <xsl:sequence select="ixsl:call(ixsl:get(., 'classList'), 'remove', [ 'dragging' ])[current-date() lt xs:date('2000-01-01')]"/>
-            <xsl:call-template name="local:tidy-class">
+            <xsl:call-template name="rdfae:tidy-class">
                 <xsl:with-param name="element" select="."/>
             </xsl:call-template>
         </xsl:for-each>
@@ -206,33 +206,33 @@ version="3.0">
             select="(($root/*)[$block-index]//text()[not(ancestor::*[@data-role])])[$node-index]"/>
         <xsl:choose>
             <xsl:when test="exists($target)">
-                <xsl:for-each select="local:host-of($target)">
-                    <xsl:call-template name="local:focus">
+                <xsl:for-each select="rdfae:host-of($target)">
+                    <xsl:call-template name="rdfae:focus">
                         <xsl:with-param name="element" select="."/>
                     </xsl:call-template>
                 </xsl:for-each>
-                <xsl:call-template name="local:place-caret">
+                <xsl:call-template name="rdfae:place-caret">
                     <xsl:with-param name="node" select="$target"/>
                     <xsl:with-param name="offset" select="min(($caret[3], string-length($target)))"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise>
                 <xsl:for-each select="($root/descendant-or-self::*[@contenteditable = 'true'])[1]">
-                    <xsl:call-template name="local:focus-caret">
+                    <xsl:call-template name="rdfae:focus-caret">
     <xsl:with-param name="node" select="."/>
-    <xsl:with-param name="offset" select="local:chrome-count(.)"/>
+    <xsl:with-param name="offset" select="rdfae:chrome-count(.)"/>
 </xsl:call-template>
                 </xsl:for-each>
             </xsl:otherwise>
         </xsl:choose>
-        <xsl:call-template name="local:after-mutation"/>
+        <xsl:call-template name="rdfae:after-mutation"/>
     </xsl:template>
 
     <!-- coalesced typing history: beforeinput fires pre-mutation for typing, native
          deletes and cut, so a burst boundary snapshot captures the state before it -->
     <xsl:template match="*[@contenteditable = 'true']" mode="ixsl:onbeforeinput">
         <xsl:variable name="event" select="ixsl:event()"/>
-        <xsl:if test="exists(local:block-of(.))">
+        <xsl:if test="exists(rdfae:block-of(.))">
             <xsl:variable name="type" as="xs:string" select="string(ixsl:get($event, 'inputType'))"/>
             <xsl:choose>
                 <!-- menu-driven Edit > Undo/Redo bypasses keydown -->
@@ -240,10 +240,10 @@ version="3.0">
                     <xsl:sequence select="ixsl:call($event, 'preventDefault', [])[current-date() lt xs:date('2000-01-01')]"/>
                     <xsl:choose>
                         <xsl:when test="$type = 'historyUndo'">
-                            <xsl:call-template name="local:apply-undo"/>
+                            <xsl:call-template name="rdfae:apply-undo"/>
                         </xsl:when>
                         <xsl:otherwise>
-                            <xsl:call-template name="local:apply-redo"/>
+                            <xsl:call-template name="rdfae:apply-redo"/>
                         </xsl:otherwise>
                     </xsl:choose>
                 </xsl:when>
@@ -252,12 +252,12 @@ version="3.0">
                          is stable across event invocations in SaxonJS (probed), so it cannot
                          detect burst boundaries -->
                     <xsl:variable name="now" as="xs:double" select="ixsl:call(ixsl:get(ixsl:window(), 'Date'), 'now', [])"/>
-                    <xsl:if test="$now - xs:double((ixsl:get(local:editor-state(), 'lastUndoTime'), 0)[1]) gt 1000
-                            or not(ixsl:get(local:editor-state(), 'lastUndoHost') ! (. is current()))">
-                        <xsl:call-template name="local:push-undo">
+                    <xsl:if test="$now - xs:double((ixsl:get(rdfae:editor-state(), 'lastUndoTime'), 0)[1]) gt 1000
+                            or not(ixsl:get(rdfae:editor-state(), 'lastUndoHost') ! (. is current()))">
+                        <xsl:call-template name="rdfae:push-undo">
                             <xsl:with-param name="host" select="."/>
                         </xsl:call-template>
-                        <xsl:call-template name="local:after-mutation"/>
+                        <xsl:call-template name="rdfae:after-mutation"/>
                     </xsl:if>
                 </xsl:otherwise>
             </xsl:choose>
@@ -266,13 +266,13 @@ version="3.0">
 
     <!-- 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:template name="rdfae:after-mutation">
+        <xsl:call-template name="rdfae:ensure-chrome"/>
+        <xsl:call-template name="rdfae:run-lint"/>
         <xsl:if test="id('toc-drawer', ixsl:page()) ! (ixsl:get(., 'style.display') ne 'none')">
-            <xsl:call-template name="local:render-toc"/>
+            <xsl:call-template name="rdfae:render-toc"/>
         </xsl:if>
-        <xsl:call-template name="local:update-breadcrumb"/>
+        <xsl:call-template name="rdfae:update-breadcrumb"/>
     </xsl:template>
 
 </xsl:stylesheet>
diff --git a/src/vocab.xsl b/src/vocab.xsl
index 662e664..fea07a8 100644
--- a/src/vocab.xsl
+++ b/src/vocab.xsl
@@ -8,7 +8,7 @@ xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
 xmlns:owl="http://www.w3.org/2002/07/owl#"
 xmlns:dc11="http://purl.org/dc/elements/1.1/"
 xmlns:dct="http://purl.org/dc/terms/"
-xmlns:local="urn:rdfa-editor:functions"
+xmlns:rdfae="https://w3id.org/atomgraph/rdfa-editor#"
 exclude-result-prefixes="#all"
 version="3.0">
 
@@ -26,12 +26,12 @@ version="3.0">
          into the SaxonJS document pool (must match its list) -->
     <xsl:param name="vocab-hrefs" as="xs:string*" select="('vocabs/foaf.rdf', 'vocabs/dcterms.rdf')"/>
 
-    <xsl:variable name="local:class-types" as="xs:string*" select="(
+    <xsl:variable name="rdfae:class-types" as="xs:string*" select="(
         'http://www.w3.org/2000/01/rdf-schema#Class',
         'http://www.w3.org/2002/07/owl#Class'
     )"/>
 
-    <xsl:variable name="local:property-types" as="xs:string*" select="(
+    <xsl:variable name="rdfae:property-types" as="xs:string*" select="(
         'http://www.w3.org/1999/02/22-rdf-syntax-ns#Property',
         'http://www.w3.org/2002/07/owl#ObjectProperty',
         'http://www.w3.org/2002/07/owl#DatatypeProperty',
@@ -39,7 +39,7 @@ version="3.0">
     )"/>
 
     <!-- the ontology's own URI: owl:Ontology description, else the first rdfs:isDefinedBy target -->
-    <xsl:function name="local:ontology-uri" as="xs:string?">
+    <xsl:function name="rdfae:ontology-uri" as="xs:string?">
         <xsl:param name="vocab" as="document-node()"/>
 
         <xsl:sequence select="(
@@ -54,13 +54,13 @@ version="3.0">
         Descriptions are grouped by @rdf:about so striped vocabularies work; terms outside
         the ontology namespace (e.g. FOAF's OWL-interop declarations) are dropped.
     -->
-    <xsl:function name="local:vocab-terms" as="map(xs:string, xs:string)*">
+    <xsl:function name="rdfae:vocab-terms" as="map(xs:string, xs:string)*">
         <xsl:param name="vocab" as="document-node()"/>
         <xsl:param name="kind" as="xs:string"/>
 
         <xsl:variable name="type-uris" as="xs:string*"
-            select="if ($kind = 'class') then $local:class-types else $local:property-types"/>
-        <xsl:variable name="ontology-uri" as="xs:string?" select="local:ontology-uri($vocab)"/>
+            select="if ($kind = 'class') then $rdfae:class-types else $rdfae:property-types"/>
+        <xsl:variable name="ontology-uri" as="xs:string?" select="rdfae:ontology-uri($vocab)"/>
         <xsl:for-each-group select="$vocab/rdf:RDF/*[@rdf:about]" group-by="@rdf:about">
             <xsl:if test="(current-group()/rdf:type/@rdf:resource, current-group() ! (namespace-uri() || local-name())) = $type-uris
                     and (empty($ontology-uri) or starts-with(current-grouping-key(), $ontology-uri))">
@@ -73,6 +73,6 @@ version="3.0">
         </xsl:for-each-group>
     </xsl:function>
 
-    <!-- local:vocab-terms feeds the property and type typeaheads (typeahead.xsl) -->
+    <!-- rdfae:vocab-terms feeds the property and type typeaheads (typeahead.xsl) -->
 
 </xsl:stylesheet>
diff --git a/tests/browser/datatype.mjs b/tests/browser/datatype.mjs
index e94df3b..76d181d 100644
--- a/tests/browser/datatype.mjs
+++ b/tests/browser/datatype.mjs
@@ -16,7 +16,7 @@ page.on('dialog', d => d.accept());
 const assert = (name, cond) => { results[name] = cond; if (!cond) errors.push('ASSERT FAILED: ' + name); };
 
 await page.goto(BASE + '/tests/fixture.html');
-await page.waitForSelector('#overlay', { state: 'attached', timeout: 15000 })
+await page.waitForSelector('#rdfa-editor-overlay', { state: 'attached', timeout: 15000 })
     .catch(() => errors.push('overlay never rendered'));
 await page.waitForSelector('#content > * > [data-role=chrome]', { state: 'attached', timeout: 5000 })
     .catch(() => errors.push('chrome never injected'));
@@ -65,9 +65,9 @@ const spanAttrs = (property) => page.evaluate(p => {
 await selectText('Q4 2024');
 await rightClickSelection();
 await typeIri(page, 'property', 'http://purl.org/dc/terms/date');
-await page.selectOption('#overlay select[name=datatype]', XSD + 'date');
-await page.fill('#overlay input[name=value]', '2024-10-01');
-await page.click('#overlay button.spo-action');
+await page.selectOption('#rdfa-editor-overlay select[name=datatype]', XSD + 'date');
+await page.fill('#rdfa-editor-overlay input[name=value]', '2024-10-01');
+await page.click('#rdfa-editor-overlay button.spo-action');
 await page.waitForTimeout(150);
 
 const dateSpan = await spanAttrs('http://purl.org/dc/terms/date');
@@ -87,8 +87,8 @@ await page.click('#output-modal .modal-close');
 await selectText('information');
 await rightClickSelection();
 await pickTerm(page, 'property', 'http://purl.org/dc/terms/description', 'description');
-await page.fill('#overlay input[name=lang]', 'fr');
-await page.click('#overlay button.spo-action');
+await page.fill('#rdfa-editor-overlay input[name=lang]', 'fr');
+await page.click('#rdfa-editor-overlay button.spo-action');
 await page.waitForTimeout(150);
 
 const langSpan = await spanAttrs('http://purl.org/dc/terms/description');
@@ -105,13 +105,13 @@ await page.click('#output-modal .modal-close');
 // ---- 3. mutual exclusion: a chosen datatype disables the language input --------
 await selectText('graduated');
 await rightClickSelection();
-await page.selectOption('#overlay select[name=datatype]', XSD + 'integer');
+await page.selectOption('#rdfa-editor-overlay select[name=datatype]', XSD + 'integer');
 assert('mutex.langDisabledWithDatatype',
-    await page.evaluate(() => document.querySelector('#overlay input[name=lang]').disabled === true));
-await page.selectOption('#overlay select[name=datatype]', '');
+    await page.evaluate(() => document.querySelector('#rdfa-editor-overlay input[name=lang]').disabled === true));
+await page.selectOption('#rdfa-editor-overlay select[name=datatype]', '');
 assert('mutex.langEnabledWithoutDatatype',
-    await page.evaluate(() => document.querySelector('#overlay input[name=lang]').disabled === false));
-await page.click('#overlay button.cancel-action');
+    await page.evaluate(() => document.querySelector('#rdfa-editor-overlay input[name=lang]').disabled === false));
+await page.click('#rdfa-editor-overlay button.cancel-action');
 await page.waitForTimeout(100);
 
 // ---- 4. edit round-trip: prefill, then clear the datatype ----------------------
@@ -125,10 +125,10 @@ await rightClickSelection();
 assert('edit.detailsAutoOpened',
     await page.evaluate(() => document.getElementById('advanced-fields').open === true));
 assert('edit.datatypePrefilled',
-    await page.evaluate(dt => document.querySelector('#overlay select[name=datatype]').value === dt, XSD + 'date'));
+    await page.evaluate(dt => document.querySelector('#rdfa-editor-overlay select[name=datatype]').value === dt, XSD + 'date'));
 // clear the datatype -> plain literal, keeping @content
-await page.selectOption('#overlay select[name=datatype]', '');
-await page.click('#overlay button.spo-action');
+await page.selectOption('#rdfa-editor-overlay select[name=datatype]', '');
+await page.click('#rdfa-editor-overlay button.spo-action');
 await page.waitForTimeout(150);
 const cleared = await spanAttrs('http://purl.org/dc/terms/date');
 assert('edit.datatypeClearedOnRemove', cleared !== null && cleared.datatype === null);
diff --git a/tests/browser/editor.mjs b/tests/browser/editor.mjs
index b657c2f..9a0ee2c 100644
--- a/tests/browser/editor.mjs
+++ b/tests/browser/editor.mjs
@@ -315,7 +315,7 @@ await page.evaluate(() => {
 await page.locator('#content > p', { hasText: 'official website' }).click({ button: 'right', position: { x: 25, y: 8 } });
 await page.waitForTimeout(300);
 await pickTerm(page, 'property', 'http://purl.org/dc/terms/description', 'description');
-await page.click('#overlay button.spo-action');
+await page.click('#rdfa-editor-overlay button.spo-action');
 await page.click('#parse-rdf');
 await page.waitForTimeout(300);
 const rdf = await page.evaluate(() => document.getElementById('output-content').textContent);
@@ -337,19 +337,19 @@ await page.locator('#content > h1').click({ button: 'right', position: { x: 60,
 await page.waitForTimeout(300);
 results.blockAnnotation = {
     editorOpened: await page.evaluate(() =>
-        getComputedStyle(document.getElementById('overlay')).display !== 'none'),
+        getComputedStyle(document.getElementById('rdfa-editor-overlay')).display !== 'none'),
     // edit pre-fill renders the committed typeahead button carrying the IRI
     propertyPrefilled: await page.evaluate(() =>
-        document.querySelector('#overlay .typeahead-field[data-field=property] input[type=hidden]')?.value
+        document.querySelector('#rdfa-editor-overlay .typeahead-field[data-field=property] input[type=hidden]')?.value
             === 'http://purl.org/dc/terms/title'),
     // the value field must not leak the block's chrome (⠿) glyph
     valueClean: await page.evaluate(() =>
-        document.querySelector('#overlay input[name=value]').value === 'Demo document'),
+        document.querySelector('#rdfa-editor-overlay input[name=value]').value === 'Demo document'),
     removeShown: await page.evaluate(() =>
-        getComputedStyle(document.querySelector('#overlay button.remove-action')).display !== 'none'),
+        getComputedStyle(document.querySelector('#rdfa-editor-overlay button.remove-action')).display !== 'none'),
 };
 // Remove strips the RDFa attributes but keeps the heading (does not unwrap it)
-await page.click('#overlay button.remove-action');
+await page.click('#rdfa-editor-overlay button.remove-action');
 await page.waitForTimeout(200);
 results.blockAnnotation.headingKept = await page.evaluate(() =>
     !!document.querySelector('#content > h1') &&
diff --git a/tests/browser/features.mjs b/tests/browser/features.mjs
index fe177db..8837943 100644
--- a/tests/browser/features.mjs
+++ b/tests/browser/features.mjs
@@ -114,7 +114,7 @@ await page.evaluate(() => {
 await page.locator('#content > p', { hasText: 'official website' }).click({ button: 'right', position: { x: 25, y: 8 } });
 await page.waitForTimeout(300);
 await pickTerm(page, 'property', 'http://purl.org/dc/terms/description', 'description');
-await page.click('#overlay button.spo-action');
+await page.click('#rdfa-editor-overlay button.spo-action');
 const spanCount = await page.evaluate(() => document.querySelectorAll('#content span[property="http://purl.org/dc/terms/description"]').length);
 await caretInText('#content > p:first-of-type');
 await page.keyboard.press(undoKey);
@@ -254,9 +254,9 @@ await page.waitForTimeout(300);
 // its input is unchanged. This exercises the same surfacing pipeline (badge/squiggle/
 // modal/canonical/undo). Open the advanced disclosure to reach the datatype control.
 await page.evaluate(() => { document.getElementById('advanced-fields').open = true; });
-await page.selectOption('#overlay select[name=datatype]', 'urn:rdfa-editor:custom');
-await page.fill('#overlay input[name=custom-datatype]', 'nmae');
-await page.click('#overlay button.spo-action');
+await page.selectOption('#rdfa-editor-overlay select[name=datatype]', 'https://w3id.org/atomgraph/rdfa-editor#custom');
+await page.fill('#rdfa-editor-overlay input[name=custom-datatype]', 'nmae');
+await page.click('#rdfa-editor-overlay button.spo-action');
 await page.waitForTimeout(200);
 results.lint.badgeShown = await page.evaluate(() =>
     getComputedStyle(document.getElementById('lint-badge')).display !== 'none'
diff --git a/tests/browser/hardening.mjs b/tests/browser/hardening.mjs
index 6ed14ba..53d77f1 100644
--- a/tests/browser/hardening.mjs
+++ b/tests/browser/hardening.mjs
@@ -114,7 +114,7 @@ await page.locator('#content > p', { hasText: 'official website' }).click({ butt
 await page.waitForTimeout(200);
 await page.keyboard.press('Escape');
 results.escape.overlayClosed = await page.evaluate(() =>
-    getComputedStyle(document.getElementById('overlay')).display === 'none');
+    getComputedStyle(document.getElementById('rdfa-editor-overlay')).display === 'none');
 
 // Alt+ArrowDown moves the block; undo restores
 const orderBefore = await page.evaluate(() => [...document.getElementById('content').children].map(e => e.tagName).join(','));
@@ -131,7 +131,7 @@ results.altMove = {
 results.aria = await page.evaluate(() => ({
     toolbar: document.getElementById('edit-toolbar').getAttribute('role') === 'toolbar',
     buttonsLabelled: [...document.querySelectorAll('#edit-toolbar button')].every(b => b.getAttribute('aria-label')),
-    overlayDialog: document.getElementById('overlay').getAttribute('role') === 'dialog',
+    overlayDialog: document.getElementById('rdfa-editor-overlay').getAttribute('role') === 'dialog',
     dialogsModal: ['link-dialog', 'figure-dialog', 'find-dialog'].every(id =>
         document.getElementById(id).getAttribute('aria-modal') === 'true'),
     tocNav: document.getElementById('toc-drawer').getAttribute('role') === 'navigation',
diff --git a/tests/browser/inspector.mjs b/tests/browser/inspector.mjs
index 6dd7ea2..26eba4d 100644
--- a/tests/browser/inspector.mjs
+++ b/tests/browser/inspector.mjs
@@ -13,7 +13,7 @@ page.on('dialog', d => d.accept());
 const assert = (name, cond) => { results[name] = cond; if (!cond) errors.push('ASSERT FAILED: ' + name); };
 
 await page.goto(BASE + '/tests/fixture.html');
-await page.waitForSelector('#overlay', { state: 'attached', timeout: 15000 })
+await page.waitForSelector('#rdfa-editor-overlay', { state: 'attached', timeout: 15000 })
     .catch(() => errors.push('overlay never rendered'));
 await page.waitForSelector('#content > * > [data-role=chrome]', { state: 'attached', timeout: 5000 })
     .catch(() => errors.push('chrome never injected'));
diff --git a/tests/browser/multiinstance.mjs b/tests/browser/multiinstance.mjs
index 6700666..a494d1b 100644
--- a/tests/browser/multiinstance.mjs
+++ b/tests/browser/multiinstance.mjs
@@ -123,7 +123,7 @@ await page.locator('#content > p', { hasText: 'official website' }).first()
     .click({ button: 'right', position: { x: 30, y: 8 } });
 await page.waitForTimeout(200);
 results.selectionHint = await page.evaluate(() => ({
-    overlayShown: getComputedStyle(document.getElementById('overlay')).display !== 'none',
+    overlayShown: getComputedStyle(document.getElementById('rdfa-editor-overlay')).display !== 'none',
     hintBoxes: document.querySelectorAll('.rdfa-editor-selection-hint').length > 0,
 }));
 await page.keyboard.press('Escape');
diff --git a/tests/browser/select.mjs b/tests/browser/select.mjs
index ee8bd47..805351b 100644
--- a/tests/browser/select.mjs
+++ b/tests/browser/select.mjs
@@ -427,7 +427,7 @@ results.bodyCtrlA = await page.evaluate(() => {
     };
 });
 
-// the last engaged region wins (local:active-root activeBlock precedence)
+// the last engaged region wins (rdfae:active-root activeBlock precedence)
 await load();
 await page.evaluate(() => {
     const host = [...document.querySelectorAll('#embedded [contenteditable=true]')]
diff --git a/tests/browser/tables.mjs b/tests/browser/tables.mjs
index 824df35..ea0bce2 100644
--- a/tests/browser/tables.mjs
+++ b/tests/browser/tables.mjs
@@ -286,7 +286,7 @@ await page.locator('#content table > tbody > tr:first-child > td').first()
     .click({ button: 'right', position: { x: 8, y: 8 } });
 await page.waitForTimeout(300);
 await pickTerm(page, 'property', 'http://purl.org/dc/terms/description', 'description');
-await page.click('#overlay button.spo-action');
+await page.click('#rdfa-editor-overlay button.spo-action');
 await page.waitForTimeout(120);
 assert('cellAnnotation', await page.evaluate(() =>
     !!document.querySelector('#content table td span[property="http://purl.org/dc/terms/description"]')));
diff --git a/tests/browser/typeahead-helper.mjs b/tests/browser/typeahead-helper.mjs
index b2a6be0..6124988 100644
--- a/tests/browser/typeahead-helper.mjs
+++ b/tests/browser/typeahead-helper.mjs
@@ -1,10 +1,10 @@
 // Shared drivers for the property/type typeahead fields in the annotation overlay.
-// A field is #overlay .typeahead-field[data-field=property|typeof]; it is either in
+// A field is #rdfa-editor-overlay .typeahead-field[data-field=property|typeof]; it is either in
 // the typing state (input.typeahead-input + ul.typeahead-menu) or committed
 // (button.typeahead-value). These helpers normalise to the typing state first.
 
 export async function openTypeahead(page, field) {
-    const wrap = `#overlay .typeahead-field[data-field=${field}]`;
+    const wrap = `#rdfa-editor-overlay .typeahead-field[data-field=${field}]`;
     if (await page.locator(`${wrap} .typeahead-value`).count())
         await page.click(`${wrap} .typeahead-value`);          // committed -> re-open for editing
     return wrap;
@@ -33,5 +33,5 @@ export async function typeIri(page, field, iri) {
 // the committed IRI a field currently holds (hidden input inside the button), or ''
 export async function committedIri(page, field) {
     return page.evaluate(f => document.querySelector(
-        `#overlay .typeahead-field[data-field=${f}] input[type=hidden]`)?.value ?? '', field);
+        `#rdfa-editor-overlay .typeahead-field[data-field=${f}] input[type=hidden]`)?.value ?? '', field);
 }
diff --git a/tests/browser/typeahead.mjs b/tests/browser/typeahead.mjs
index 2609cd7..833aab5 100644
--- a/tests/browser/typeahead.mjs
+++ b/tests/browser/typeahead.mjs
@@ -14,15 +14,15 @@ page.on('dialog', d => d.accept());
 const assert = (name, cond) => { results[name] = cond; if (!cond) errors.push('ASSERT FAILED: ' + name); };
 
 await page.goto(BASE + '/tests/fixture.html');
-await page.waitForSelector('#overlay', { state: 'attached', timeout: 15000 })
+await page.waitForSelector('#rdfa-editor-overlay', { state: 'attached', timeout: 15000 })
     .catch(() => errors.push('overlay never rendered'));
 await page.waitForSelector('#content > * > [data-role=chrome]', { state: 'attached', timeout: 5000 })
     .catch(() => errors.push('chrome never injected'));
 
 const FOAF = 'http://xmlns.com/foaf/0.1/';
 const TITLE = 'http://purl.org/dc/terms/title';
-const pWrap = '#overlay .typeahead-field[data-field=property]';
-const tWrap = '#overlay .typeahead-field[data-field=typeof]';
+const pWrap = '#rdfa-editor-overlay .typeahead-field[data-field=property]';
+const tWrap = '#rdfa-editor-overlay .typeahead-field[data-field=typeof]';
 const pIn = `${pWrap} input.typeahead-input`;
 const menuOpen = (w) => page.evaluate(s =>
     getComputedStyle(document.querySelector(s + ' .typeahead-menu')).display !== 'none', w);
@@ -61,7 +61,7 @@ const rightClickSelection = async () => {
 };
 
 const annotate = async (substr) => { await selectText(substr); await rightClickSelection(); };
-const cancel = async () => { await page.click('#overlay button.cancel-action'); await page.waitForTimeout(80); };
+const cancel = async () => { await page.click('#rdfa-editor-overlay button.cancel-action'); await page.waitForTimeout(80); };
 
 // select an existing annotation (the h1 that carries @property=dct:title) and open it
 const openTitleEdit = async () => {
@@ -111,7 +111,7 @@ await cancel();
 // ---- 4. a full IRI typed directly is accepted as a free entry -------------------
 await annotate('company');
 await typeIri(page, 'property', 'https://schema.org/birthDate');
-await page.click('#overlay button.spo-action');
+await page.click('#rdfa-editor-overlay button.spo-action');
 await page.waitForTimeout(120);
 assert('freeIri.written', await page.evaluate(() =>
     !!document.querySelector('#content span[property="https://schema.org/birthDate"]')));
@@ -121,7 +121,7 @@ await annotate('graduated');
 await page.fill(pIn, 'notaterm');
 await page.waitForTimeout(80);
 assert('nonIri.notCommitted', await committedIri(page, 'property') === '');
-await page.click('#overlay button.spo-action');
+await page.click('#rdfa-editor-overlay button.spo-action');
 await page.waitForTimeout(120);
 assert('nonIri.noProperty', await page.evaluate(() =>
     !document.querySelector('#content [property="notaterm"]')));
@@ -149,7 +149,7 @@ await cancel();
 await openTitleEdit();
 await page.click(`${pWrap} .typeahead-value`);
 await page.waitForTimeout(80);
-await page.click('#overlay button.spo-action');
+await page.click('#rdfa-editor-overlay button.spo-action');
 await page.waitForTimeout(120);
 assert('stale.untouchedPreserves', await page.evaluate(t =>
     document.querySelector('#content > h1')?.getAttribute('property') === t, TITLE));
diff --git a/tests/fixture-blocks.html b/tests/fixture-blocks.html
index 56ba2cb..99f9d49 100644
--- a/tests/fixture-blocks.html
+++ b/tests/fixture-blocks.html
@@ -31,6 +31,9 @@
             }
         </script>
         <link rel="stylesheet" href="../rdfa-editor.css" type="text/css"/>
+        <link rel="stylesheet" href="../overlay.css" type="text/css"/>
+        <link rel="stylesheet" href="../toolbar.css" type="text/css"/>
+        <link rel="stylesheet" href="../dialogs.css" type="text/css"/>
         <style type="text/css">
             body { padding-top: 70px; padding-bottom: 56px; }
             .rdfa-editor-content { padding-left: 2.5em; }
diff --git a/tests/fixture-dragnest.html b/tests/fixture-dragnest.html
index 54bc0fe..47fe5f7 100644
--- a/tests/fixture-dragnest.html
+++ b/tests/fixture-dragnest.html
@@ -26,6 +26,9 @@
             }
         </script>
         <link rel="stylesheet" href="../rdfa-editor.css" type="text/css"/>
+        <link rel="stylesheet" href="../overlay.css" type="text/css"/>
+        <link rel="stylesheet" href="../toolbar.css" type="text/css"/>
+        <link rel="stylesheet" href="../dialogs.css" type="text/css"/>
         <style type="text/css">
             body { padding-top: 70px; padding-bottom: 56px; }
             .rdfa-editor-content { padding-left: 2.5em; }
diff --git a/tests/fixture-nesting.html b/tests/fixture-nesting.html
index 65f93da..08e6de3 100644
--- a/tests/fixture-nesting.html
+++ b/tests/fixture-nesting.html
@@ -26,6 +26,9 @@
             }
         </script>
         <link rel="stylesheet" href="../rdfa-editor.css" type="text/css"/>
+        <link rel="stylesheet" href="../overlay.css" type="text/css"/>
+        <link rel="stylesheet" href="../toolbar.css" type="text/css"/>
+        <link rel="stylesheet" href="../dialogs.css" type="text/css"/>
         <style type="text/css">
             body { padding-top: 70px; padding-bottom: 56px; }
             .rdfa-editor-content { padding-left: 2.5em; }
diff --git a/tests/fixture.html b/tests/fixture.html
index af3bb62..1fcf2d4 100644
--- a/tests/fixture.html
+++ b/tests/fixture.html
@@ -32,6 +32,9 @@
 				}
 		 </script>
         <link rel="stylesheet" href="../rdfa-editor.css" type="text/css"/>
+        <link rel="stylesheet" href="../overlay.css" type="text/css"/>
+        <link rel="stylesheet" href="../toolbar.css" type="text/css"/>
+        <link rel="stylesheet" href="../dialogs.css" type="text/css"/>
         <style type="text/css">
 			body {
                 font-family: "Roboto", sans-serif;
diff --git a/tests/lint-driver.xsl b/tests/lint-driver.xsl
index 97d42c0..bda4255 100644
--- a/tests/lint-driver.xsl
+++ b/tests/lint-driver.xsl
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <xsl:stylesheet
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-    xmlns:lint="urn:rdfa-editor:lint"
+    xmlns:lint="https://w3id.org/atomgraph/rdfa-editor/lint#"
     version="3.0">
 
 <!--
diff --git a/toolbar.css b/toolbar.css
new file mode 100644
index 0000000..6ce5805
--- /dev/null
+++ b/toolbar.css
@@ -0,0 +1,57 @@
+/* RDFa Editor toolbar styles (injected into the host navbar).
+   Host UIs that provide their own button styling (e.g. Bootstrap)
+   should omit this file and style #edit-toolbar themselves. */
+
+#edit-toolbar button:disabled {
+                opacity: 0.4;
+                cursor: default;
+            }
+
+/* Editor toolbar (injected into the navbar) */
+            #edit-toolbar {
+                order: -1;
+                margin-right: auto;
+                display: flex;
+                gap: 6px;
+                align-items: center;
+            }
+
+#edit-toolbar select,
+            #edit-toolbar button {
+                padding: 6px 10px;
+                border: 1px solid #e0e0e0;
+                border-radius: 4px;
+                background: white;
+                font-size: 13px;
+                font-family: "Roboto", sans-serif;
+                cursor: pointer;
+            }
+
+#edit-toolbar button:hover {
+                background: #f5f5f5;
+            }
+
+/* Caret-contextual toggle state (aria-pressed toggle buttons) */
+            #edit-toolbar button[aria-pressed="true"] {
+                background: #e3f0ff;
+                border-color: #6aa3e0;
+                color: #1a5fb4;
+            }
+
+/* Functional groups: thin dividers between clusters, no labels */
+            #edit-toolbar .tb-group {
+                display: flex;
+                gap: 6px;
+                align-items: center;
+            }
+
+#edit-toolbar .tb-group + .tb-group {
+                border-left: 1px solid #e0e0e0;
+                padding-left: 6px;
+            }
+
+/* Table-ops cluster switches on when the caret is in a table */
+            #edit-toolbar .tb-group.table-ops.active {
+                background: #e3f0ff;
+                border-radius: 4px;
+            }