diff --git a/.sampo/changesets/cunning-thunderbearer-vipunen.md b/.sampo/changesets/cunning-thunderbearer-vipunen.md
new file mode 100644
index 00000000..e0bab576
--- /dev/null
+++ b/.sampo/changesets/cunning-thunderbearer-vipunen.md
@@ -0,0 +1,7 @@
+---
+cargo/satteri-ast: patch
+cargo/satteri-napi: patch
+npm/satteri: patch
+---
+
+Fixed `rawHtml: true` losing code-fence `data.lang` and `data.meta` in `markdownToHast` and MDX compilation, so HAST plugins can read fence options.
diff --git a/.sampo/changesets/raw-html-mdx-component-overrides.md b/.sampo/changesets/raw-html-mdx-component-overrides.md
new file mode 100644
index 00000000..3ee877dc
--- /dev/null
+++ b/.sampo/changesets/raw-html-mdx-component-overrides.md
@@ -0,0 +1,6 @@
+---
+cargo/satteri-ast: patch
+npm/satteri: patch
+---
+
+Fixed `export const components` being ignored in MDX when `rawHtml` and `optimizeStatic` are both enabled.
diff --git a/.sampo/changesets/raw-html-positions.md b/.sampo/changesets/raw-html-positions.md
new file mode 100644
index 00000000..1b13308b
--- /dev/null
+++ b/.sampo/changesets/raw-html-positions.md
@@ -0,0 +1,6 @@
+---
+cargo/satteri-ast: patch
+npm/satteri: patch
+---
+
+Fixed `rawHtml` dropping the original source and root span. Markdown-derived nodes and self-contained raw blocks now retain their positions when their source association is unambiguous.
diff --git a/crates/satteri-ast/src/convert.rs b/crates/satteri-ast/src/convert.rs
index 7ca6c949..e9e0c69f 100644
--- a/crates/satteri-ast/src/convert.rs
+++ b/crates/satteri-ast/src/convert.rs
@@ -397,7 +397,7 @@ pub struct ConvertOptions {
     /// Reparse raw HTML embedded in the converted tree into real HAST nodes
     /// (see [`raw_to_hast_arena`](crate::hast::from_html::raw_to_hast_arena)).
     /// Applied as the final conversion step so every pipeline that converts
-    /// MDAST to HAST gets it. Positions are not preserved through the reparse.
+    /// MDAST to HAST gets it. Unambiguously associated nodes retain their positions.
     /// Default: `false`.
     #[cfg(feature = "from-html")]
     pub raw_html: bool,
diff --git a/crates/satteri-ast/src/hast/from_html.rs b/crates/satteri-ast/src/hast/from_html.rs
index 4d5bd9fc..d36fe6fa 100644
--- a/crates/satteri-ast/src/hast/from_html.rs
+++ b/crates/satteri-ast/src/hast/from_html.rs
@@ -6,14 +6,19 @@
 //! that is then emitted into the builder in document order.
 
 use std::cell::{Cell, Ref, RefCell};
+use std::collections::{HashMap, HashSet};
+use std::ops::Range;
 
+use html5ever::buffer_queue::BufferQueue;
 use html5ever::interface::{ElementFlags, NodeOrText, QuirksMode, TreeSink};
 use html5ever::tendril::{StrTendril, TendrilSink};
+use html5ever::tokenizer::{TagKind, Token, TokenSink, TokenSinkResult, Tokenizer};
+use html5ever::tree_builder::TreeBuilder;
 use html5ever::{
     Attribute, LocalName, Namespace, ParseOpts, QualName, parse_document, parse_fragment,
     tree_builder::TreeBuilderOpts,
 };
-use satteri_arena::{Arena, ArenaBuilder, Hast, StringRef};
+use satteri_arena::{Arena, ArenaBuilder, Hast, NodePosition, StringRef};
 use satteri_property_info::{PropKind, find_property};
 
 use crate::hast::codec::{
@@ -103,6 +108,11 @@ struct Node {
     parent: Option<usize>,
     children: Vec<usize>,
     data: NodeData,
+    /// Original opening token that created this handle, retained through parser moves.
+    origin: Option<u32>,
+    position_origin: Option<u32>,
+    /// Serialized bytes that produced this node, including any coalesced text.
+    span: Option<Range<usize>>,
 }
 
 enum NodeData {
@@ -130,6 +140,7 @@ struct HtmlSink {
     nodes: RefCell<Vec<Node>>,
     quirks_mode: Cell<QuirksMode>,
     stitch: Option<StitchRecognizer>,
+    token_span: Cell<Option<(usize, usize)>>,
 }
 
 impl HtmlSink {
@@ -139,9 +150,13 @@ impl HtmlSink {
                 parent: None,
                 children: Vec::new(),
                 data: NodeData::Document,
+                origin: None,
+                position_origin: None,
+                span: None,
             }]),
             quirks_mode: Cell::new(QuirksMode::NoQuirks),
             stitch,
+            token_span: Cell::new(None),
         }
     }
 }
@@ -205,6 +220,9 @@ fn new_node(nodes: &mut Vec<Node>, data: NodeData) -> usize {
         parent: None,
         children: Vec::new(),
         data,
+        origin: None,
+        position_origin: None,
+        span: None,
     });
     id
 }
@@ -236,9 +254,13 @@ fn append_node(nodes: &mut [Node], parent: usize, child: usize) {
 }
 
 /// The tree builder expects adjacent text to coalesce into a single node.
-fn push_text(nodes: &mut [Node], target: usize, text: &str) -> bool {
+fn push_text(nodes: &mut [Node], target: usize, text: &str, span: Option<(usize, usize)>) -> bool {
     if let NodeData::Text { contents } = &mut nodes[target].data {
         contents.push_slice(text);
+        if let (Some(existing), Some((start, end))) = (&mut nodes[target].span, span) {
+            existing.start = existing.start.min(start);
+            existing.end = existing.end.max(end);
+        }
         true
     } else {
         false
@@ -304,7 +326,7 @@ impl TreeSink for HtmlSink {
         let parent = *parent;
         if let NodeOrText::AppendText(text) = &child
             && let Some(&last) = nodes[parent].children.last()
-            && push_text(&mut nodes, last, text)
+            && push_text(&mut nodes, last, text, self.token_span.get())
         {
             return;
         }
@@ -327,7 +349,7 @@ impl TreeSink for HtmlSink {
             }
             (NodeOrText::AppendText(text), index) => {
                 let prev = nodes[parent].children[index - 1];
-                if push_text(&mut nodes, prev, &text) {
+                if push_text(&mut nodes, prev, &text, self.token_span.get()) {
                     return;
                 }
                 new_node(&mut nodes, NodeData::Text { contents: text })
@@ -483,7 +505,12 @@ fn emit(
                 }
             }
             NodeData::Doctype => {
-                builder.add_leaf(HastNodeType::Doctype as u8);
+                let leaf = builder.add_leaf(HastNodeType::Doctype as u8);
+                copy_position(
+                    builder,
+                    leaf,
+                    nodes[id].position_origin.zip(stitching.map(|s| s.src)),
+                );
             }
             NodeData::Text { contents } => {
                 let text = scrub_markers(contents, leaked);
@@ -492,6 +519,11 @@ fn emit(
                 builder
                     .arena_mut()
                     .set_type_data(leaf, &text_ref.as_bytes());
+                copy_position(
+                    builder,
+                    leaf,
+                    nodes[id].position_origin.zip(stitching.map(|s| s.src)),
+                );
             }
             NodeData::Comment { contents } => {
                 let text = scrub_markers(contents, leaked);
@@ -500,6 +532,11 @@ fn emit(
                 builder
                     .arena_mut()
                     .set_type_data(leaf, &text_ref.as_bytes());
+                copy_position(
+                    builder,
+                    leaf,
+                    nodes[id].position_origin.zip(stitching.map(|s| s.src)),
+                );
             }
             NodeData::Stitch(index) => {
                 let stitches = stitching.expect("Stitch node without stitching").stitches;
@@ -526,6 +563,17 @@ fn emit(
                 let element = builder.open_node(HastNodeType::Element as u8);
                 let data = encode_element_data(tag_ref, &props);
                 builder.arena_mut().set_type_data(element, &data);
+                copy_position(
+                    builder,
+                    element,
+                    nodes[id].position_origin.zip(stitching.map(|s| s.src)),
+                );
+                if &*name.local == "code"
+                    && let Some(origin) = nodes[id].origin
+                    && let Some(data) = stitching.and_then(|s| s.src.get_node_data(origin))
+                {
+                    builder.arena_mut().set_node_data(element, data.to_vec());
+                }
 
                 stack.push(EmitTask::Close);
                 // `<template>` content lives in a detached document, not the
@@ -544,6 +592,18 @@ fn emit(
     }
 }
 
+/// Source offsets remain relative to the original document, not the serialized HTML.
+fn copy_position(
+    builder: &mut ArenaBuilder<Hast>,
+    node_id: u32,
+    origin: Option<(u32, &Arena<Hast>)>,
+) {
+    let Some((aid, src)) = origin else { return };
+    builder
+        .arena_mut()
+        .set_position(node_id, NodePosition::from_node(src.get_node(aid)));
+}
+
 /// Convert a parsed element's attributes into hast props under the schema of
 /// `space`: SVG keeps attribute casing (`viewBox`), HTML normalises it. An
 /// attribute whose name contains a leaked marker is junk the tokenizer minted
@@ -617,7 +677,8 @@ fn emit_arena_node(
             }
         }
         Some(HastNodeType::Doctype) => {
-            builder.add_leaf(HastNodeType::Doctype as u8);
+            let leaf = builder.add_leaf(HastNodeType::Doctype as u8);
+            copy_position(builder, leaf, Some((aid, src)));
         }
         Some(HastNodeType::Text | HastNodeType::Comment | HastNodeType::Raw) if data.len() >= 8 => {
             let value_ref = builder.alloc_string(src.get_str(decode_text_data(data)));
@@ -625,6 +686,7 @@ fn emit_arena_node(
             builder
                 .arena_mut()
                 .set_type_data(leaf, &value_ref.as_bytes());
+            copy_position(builder, leaf, Some((aid, src)));
         }
         Some(HastNodeType::Element) if data.len() >= 16 => {
             let tag = src.get_str(decode_element_tag(data));
@@ -643,6 +705,10 @@ fn emit_arena_node(
             let element = builder.open_node(HastNodeType::Element as u8);
             let encoded = encode_element_data(tag_ref, &props);
             builder.arena_mut().set_type_data(element, &encoded);
+            copy_position(builder, element, Some((aid, src)));
+            if let Some(data) = src.get_node_data(aid) {
+                builder.arena_mut().set_node_data(element, data.to_vec());
+            }
             stack.push(EmitTask::Close);
             for &child in src.get_children(aid).iter().rev() {
                 stack.push(EmitTask::EmitArena(child, child_space));
@@ -667,6 +733,7 @@ fn emit_arena_node(
             let element = builder.open_node(node_type);
             let encoded = encode_mdx_jsx_element_data(name_ref, &attrs, explicit);
             builder.arena_mut().set_type_data(element, &encoded);
+            copy_position(builder, element, Some((aid, src)));
             // Reparse rather than copy, so raw HTML nested inside the MDX
             // element is resolved too.
             reparse_children_into(src, aid, builder, child_space);
@@ -683,6 +750,7 @@ fn emit_arena_node(
             builder
                 .arena_mut()
                 .set_type_data(leaf, &value_ref.as_bytes());
+            copy_position(builder, leaf, Some((aid, src)));
         }
         // Unknown or malformed node: emit its children so a bad wrapper never
         // silently swallows a whole subtree.
@@ -712,6 +780,7 @@ fn reparse_children_into(
     let prefix = stitch_prefix();
     let mut html = String::new();
     let mut stitches: Vec<u32> = Vec::new();
+    let mut origins = Vec::new();
     let context = RenderOptions::new(false, space.is_svg());
     {
         let mut on_mdx = |out: &mut String, node_id: u32| {
@@ -721,12 +790,32 @@ fn reparse_children_into(
             out.push_str("-->");
             stitches.push(node_id);
         };
+        let mut on_node = |id, opening: Range<usize>, whole| {
+            if !opening.is_empty() {
+                origins.push(SerializedNode {
+                    opening,
+                    whole,
+                    id,
+                    node_type: src.get_node(id).node_type,
+                });
+            }
+        };
         for &child in src.get_children(parent) {
-            render_node_inner(child, src, &mut html, context, Some(&mut on_mdx), 0);
+            render_node_inner(
+                child,
+                src,
+                &mut html,
+                context,
+                Some(&mut on_mdx),
+                Some(&mut on_node),
+                0,
+            );
         }
     }
     let recognizer = StitchRecognizer::new(prefix, stitches.len());
-    let (nodes, roots, leaked) = parse_fragment_nodes(&html, Some(recognizer), space);
+    origins.sort_unstable_by_key(|origin| origin.opening.end);
+    let (mut nodes, roots, leaked) = parse_fragment_nodes(&html, Some(recognizer), space, &origins);
+    retain_positions(&mut nodes, &origins, src);
     let stitching = Stitching {
         src,
         stitches: &stitches,
@@ -869,7 +958,7 @@ pub fn html_to_hast_arena(html: &str) -> Arena<Hast> {
 /// fragment's own top-level nodes, with no synthesised `<html>`/`<head>`/
 /// `<body>` wrapper. `space` picks the namespace that content parses in.
 pub fn html_fragment_to_hast_arena(html: &str, space: HtmlSpace) -> Arena<Hast> {
-    let (nodes, roots, _) = parse_fragment_nodes(html, None, space);
+    let (nodes, roots, _) = parse_fragment_nodes(html, None, space, &[]);
 
     let mut builder = ArenaBuilder::<Hast>::new(String::new());
     builder.open_node(HastNodeType::Root as u8);
@@ -883,7 +972,7 @@ pub fn html_fragment_to_hast_arena(html: &str, space: HtmlSpace) -> Arena<Hast>
 /// around it is ignored; anything else (no element, extra top-level nodes, a
 /// void element) errors with the reason.
 pub fn html_fragment_to_wrap_arena(html: &str) -> Result<Arena<Hast>, String> {
-    let (nodes, roots, _) = parse_fragment_nodes(html, None, HtmlSpace::Html);
+    let (nodes, roots, _) = parse_fragment_nodes(html, None, HtmlSpace::Html, &[]);
     let mut wrapper: Option<usize> = None;
     for &r in &roots {
         match &nodes[r].data {
@@ -916,16 +1005,283 @@ pub fn html_fragment_to_wrap_arena(html: &str) -> Result<Arena<Hast>, String> {
 /// no synthesised `<html>`/`<head>`/`<body>` wrapper.
 ///
 /// MDX nodes have no HTML form; they are carried through as placeholder
-/// comments and spliced back afterwards. Positions are not preserved: the
-/// tree is rebuilt from serialised HTML.
+/// comments and spliced back afterwards. Original code elements retain their
+/// node data when their opening tags survive tokenization. Unambiguously
+/// associated nodes retain their positions; arena ids are rebuilt.
 pub fn raw_to_hast_arena(arena: &Arena<Hast>) -> Arena<Hast> {
-    let mut builder = ArenaBuilder::<Hast>::new(String::new());
-    builder.open_node(HastNodeType::Root as u8);
+    let mut builder = ArenaBuilder::<Hast>::new(arena.source().to_string());
+    let root = builder.open_node(HastNodeType::Root as u8);
+    copy_position(&mut builder, root, Some((0, arena)));
     reparse_children_into(arena, 0, &mut builder, HtmlSpace::Html);
     builder.close_node();
     builder.finish()
 }
 
+struct SerializedNode {
+    opening: Range<usize>,
+    whole: Range<usize>,
+    id: u32,
+    node_type: u8,
+}
+
+/// Keep a position only when all products of a serialized node remained in its
+/// parsed subtree and nothing from outside joined it. This rejects split nodes,
+/// swallowed tags, and formatting clones without confusing relocated elements.
+fn retain_positions(nodes: &mut [Node], origins: &[SerializedNode], src: &Arena<Hast>) {
+    #[derive(Clone, Copy)]
+    struct Products {
+        start: usize,
+        end: usize,
+        count: usize,
+    }
+    let mut products: Vec<Products> = nodes
+        .iter()
+        .map(|node| match &node.span {
+            Some(span) => Products {
+                start: span.start,
+                end: span.end,
+                count: 1,
+            },
+            None => Products {
+                start: usize::MAX,
+                end: 0,
+                count: 0,
+            },
+        })
+        .collect();
+    let mut order = Vec::with_capacity(nodes.len());
+    let mut stack = vec![0];
+    while let Some(id) = stack.pop() {
+        order.push(id);
+        stack.extend_from_slice(&nodes[id].children);
+        if let NodeData::Element {
+            template_contents: Some(contents),
+            ..
+        } = nodes[id].data
+        {
+            stack.push(contents);
+        }
+    }
+    for &id in order.iter().rev() {
+        let template = match nodes[id].data {
+            NodeData::Element {
+                template_contents, ..
+            } => template_contents,
+            _ => None,
+        };
+        for child in nodes[id].children.iter().copied().chain(template) {
+            products[id].start = products[id].start.min(products[child].start);
+            products[id].end = products[id].end.max(products[child].end);
+            products[id].count += products[child].count;
+        }
+    }
+    let mut starts: Vec<usize> = nodes
+        .iter()
+        .filter_map(|node| node.span.as_ref().map(|span| span.start))
+        .collect();
+    starts.sort_unstable();
+    let by_id: HashMap<u32, &SerializedNode> =
+        origins.iter().map(|origin| (origin.id, origin)).collect();
+    let mut leaves: Vec<&SerializedNode> = origins
+        .iter()
+        .filter(|origin| origin.node_type != HastNodeType::Element as u8)
+        .collect();
+    leaves.sort_unstable_by_key(|origin| origin.whole.start);
+    for &id in &order {
+        let node = &nodes[id];
+        let origin = node
+            .origin
+            .and_then(|aid| by_id.get(&aid).copied())
+            .or_else(|| {
+                let span = node.span.as_ref()?;
+                let index = leaves
+                    .partition_point(|origin| origin.whole.start <= span.start)
+                    .checked_sub(1)?;
+                let origin = leaves[index];
+                if origin.node_type == HastNodeType::Raw as u8 {
+                    let NodeData::Element { name, .. } = &node.data else {
+                        return None;
+                    };
+                    let raw = src.get_type_data(origin.id);
+                    (raw.len() >= 8
+                        && span.start == origin.whole.start
+                        && (!is_void_element(&name.local) || span.end == origin.whole.end)
+                        && is_lone_element_source(src.get_str(decode_text_data(raw)), &name.local))
+                    .then_some(origin)
+                } else {
+                    let node_type = match node.data {
+                        NodeData::Text { .. } => HastNodeType::Text,
+                        NodeData::Comment { .. } => HastNodeType::Comment,
+                        NodeData::Doctype => HastNodeType::Doctype,
+                        _ => return None,
+                    };
+                    (origin.node_type == node_type as u8 && *span == origin.whole).then_some(origin)
+                }
+            });
+        let Some(origin) = origin else { continue };
+        let all_products = starts.partition_point(|&start| start < origin.whole.end)
+            - starts.partition_point(|&start| start < origin.whole.start);
+        let product = products[id];
+        if product.start >= origin.whole.start
+            && product.end <= origin.whole.end
+            && product.count == all_products
+        {
+            nodes[id].position_origin = Some(origin.id);
+        }
+    }
+    // Swallowed or ignored markup creates no products. This can come from raw
+    // nodes or from text in a raw-text context; subtree counts alone cannot
+    // prove that an original wrapper survived it. Decline ancestor positions
+    // unless every serialized leaf inside it has a reliable source association.
+    let positioned: HashSet<u32> = nodes
+        .iter()
+        .filter_map(|node| node.position_origin)
+        .collect();
+    let mut uncertain_leaves: Vec<usize> = origins
+        .iter()
+        .filter(|origin| {
+            origin.node_type != HastNodeType::Element as u8 && !positioned.contains(&origin.id)
+        })
+        .map(|origin| origin.whole.start)
+        .collect();
+    uncertain_leaves.sort_unstable();
+    for node in nodes {
+        let Some(origin) = node.position_origin.and_then(|id| by_id.get(&id)) else {
+            continue;
+        };
+        if origin.node_type == HastNodeType::Element as u8
+            && uncertain_leaves.partition_point(|&start| start < origin.whole.end)
+                > uncertain_leaves.partition_point(|&start| start < origin.whole.start)
+        {
+            node.position_origin = None;
+        }
+    }
+}
+
+/// Raw-block spans describe a whole element only in unambiguous, self-contained
+/// cases. Literal lookalikes in comments or attributes can only force a decline.
+fn is_lone_element_source(html: &str, tag: &str) -> bool {
+    let body = html.trim();
+    if body
+        .strip_prefix('<')
+        .and_then(|rest| rest.strip_prefix(tag))
+        .is_none_or(|rest| rest.starts_with(|c: char| c.is_ascii_alphanumeric() || c == '-'))
+    {
+        return false;
+    }
+    let count = |closing| {
+        let needle = format!("<{}{tag}", if closing { "/" } else { "" });
+        html.match_indices(&needle)
+            .filter(|(at, _)| {
+                !html[at + needle.len()..]
+                    .starts_with(|c: char| c.is_ascii_alphanumeric() || c == '-')
+            })
+            .count()
+    };
+    if is_void_element(tag) {
+        count(false) == 1 && count(true) == 0 && body.ends_with('>')
+    } else {
+        count(false) == 1 && count(true) == 1 && body.ends_with(&format!("</{tag}>"))
+    }
+}
+
+/// Associate serialized opening tokens with the handles they actually create,
+/// never with output order, content, or attributes. Parser-created clones have
+/// no origin, whereas foster parenting preserves the original handle.
+struct OriginTokenSink<'a> {
+    tree: TreeBuilder<usize, HtmlSink>,
+    input: &'a BufferQueue,
+    input_len: usize,
+    origins: &'a [SerializedNode],
+    previous_end: Cell<usize>,
+}
+
+impl TokenSink for OriginTokenSink<'_> {
+    type Handle = usize;
+
+    fn process_token(&self, token: Token, line: u64) -> TokenSinkResult<usize> {
+        // Parse errors do not delimit source tokens. Counting one as a boundary
+        // could claim a tag that began in malformed user-supplied raw HTML.
+        if matches!(token, Token::ParseError(_)) {
+            return self.tree.process_token(token, line);
+        }
+        let remaining = self.input.clone();
+        let mut remaining_len = 0;
+        while let Some(buffer) = remaining.pop_front() {
+            remaining_len += buffer.len();
+        }
+        let end = self.input_len - remaining_len;
+        // Both boundaries must match: a tag partly consumed into user-supplied
+        // raw HTML is not the original opening token.
+        let start = self.previous_end.replace(end);
+        let tag_name = match &token {
+            Token::TagToken(tag) if tag.kind == TagKind::StartTag => Some(tag.name.clone()),
+            _ => None,
+        };
+        let origin = tag_name.as_ref().and_then(|_| {
+            self.origins
+                .binary_search_by_key(&end, |origin| origin.opening.end)
+                .ok()
+                .map(|index| &self.origins[index])
+                .filter(|origin| {
+                    origin.opening.start == start && origin.node_type == HastNodeType::Element as u8
+                })
+        });
+        let first_new = self.tree.sink.nodes.borrow().len();
+        self.tree.sink.token_span.set(Some((start, end)));
+        let result = self.tree.process_token(token, line);
+        let mut nodes = self.tree.sink.nodes.borrow_mut();
+        for node in &mut nodes[first_new..] {
+            if !matches!(node.data, NodeData::Document) {
+                node.span = Some(start..end);
+            }
+        }
+        if let (Some(origin), Some(tag)) = (origin, tag_name)
+            && let Some(node) = nodes[first_new..].iter_mut().rev().find(
+                |node| matches!(&node.data, NodeData::Element { name, .. } if name.local.eq_ignore_ascii_case(&tag)),
+            )
+        {
+            node.origin = Some(origin.id);
+        }
+        result
+    }
+
+    fn end(&self) {
+        self.tree.end();
+    }
+
+    fn adjusted_current_node_present_but_not_in_html_namespace(&self) -> bool {
+        self.tree
+            .adjusted_current_node_present_but_not_in_html_namespace()
+    }
+}
+
+fn parse_with_origins(
+    tree: TreeBuilder<usize, HtmlSink>,
+    html: &str,
+    origins: &[SerializedNode],
+) -> HtmlSink {
+    let opts = html5ever::tokenizer::TokenizerOpts {
+        initial_state: Some(tree.tokenizer_state_for_context_elem(false)),
+        ..parse_opts().tokenizer
+    };
+    let input = BufferQueue::default();
+    input.push_back(StrTendril::from(html));
+    let tokenizer = Tokenizer::new(
+        OriginTokenSink {
+            tree,
+            input: &input,
+            input_len: html.len(),
+            origins,
+            previous_end: Cell::new(0),
+        },
+        opts,
+    );
+    while !matches!(tokenizer.feed(&input), html5ever::TokenizerResult::Done) {}
+    tokenizer.end();
+    tokenizer.sink.tree.sink.finish()
+}
+
 /// Parse an HTML fragment in `space`'s context element, the insertion mode the
 /// fragment's top-level content is read in. Returns the node list, the
 /// top-level node indices, and the markers of any swallowed stitches. The
@@ -935,15 +1291,20 @@ fn parse_fragment_nodes(
     html: &str,
     stitch: Option<StitchRecognizer>,
     space: HtmlSpace,
+    origins: &[SerializedNode],
 ) -> (Vec<Node>, Vec<usize>, Vec<String>) {
-    let sink = parse_fragment(
+    let parser = parse_fragment(
         HtmlSink::new(stitch),
         parse_opts(),
         space.context_element(),
         Vec::new(),
         false,
-    )
-    .one(html);
+    );
+    let sink = if origins.is_empty() {
+        parser.one(html)
+    } else {
+        parse_with_origins(parser.tokenizer.sink, html, origins)
+    };
     let leaked = sink
         .stitch
         .map(StitchRecognizer::leaked_markers)
@@ -1504,7 +1865,7 @@ mod tests {
     }
 
     /// Open a hast element with `(name, kind, value)` props; the caller closes it.
-    fn open_element(b: &mut ArenaBuilder<Hast>, tag: &str, props: &[(&str, u8, &str)]) {
+    fn open_element(b: &mut ArenaBuilder<Hast>, tag: &str, props: &[(&str, u8, &str)]) -> u32 {
         let tag = b.alloc_string(tag);
         let props: Vec<(StringRef, u8, StringRef)> = props
             .iter()
@@ -1513,6 +1874,345 @@ mod tests {
         let el = b.open_node(HastNodeType::Element as u8);
         let data = encode_element_data(tag, &props);
         b.arena_mut().set_type_data(el, &data);
+        el
+    }
+
+    fn add_code_with_data(b: &mut ArenaBuilder<Hast>, meta: &str) {
+        let code = open_element(b, "code", &[("className", PROP_SPACE_SEP, "language-js")]);
+        let data = format!(r#"{{"lang":"js","meta":"{meta}"}}"#);
+        b.arena_mut().set_node_data(code, data.into_bytes());
+        let value = b.alloc_string("x\n");
+        let text = b.add_leaf(HastNodeType::Text as u8);
+        b.arena_mut().set_type_data(text, &value.as_bytes());
+        b.close_node();
+    }
+
+    fn add_fence(b: &mut ArenaBuilder<Hast>, meta: &str) {
+        open_element(b, "pre", &[]);
+        add_code_with_data(b, meta);
+        b.close_node();
+    }
+
+    fn code_metadata(arena: &Arena<Hast>) -> Vec<Option<serde_json::Value>> {
+        (0..arena.len() as u32)
+            .filter(|&id| {
+                arena.get_node(id).node_type == HastNodeType::Element as u8
+                    && arena.get_str(decode_element_tag(arena.get_type_data(id))) == "code"
+            })
+            .map(|id| {
+                arena
+                    .get_node_data(id)
+                    .map(|data| serde_json::from_slice(data).unwrap())
+            })
+            .collect()
+    }
+
+    fn fence_data(meta: &str) -> Option<serde_json::Value> {
+        Some(serde_json::json!({ "lang": "js", "meta": meta }))
+    }
+
+    #[test]
+    fn raw_reparse_keeps_metadata_on_relocated_and_repeated_fences_only() {
+        let mut b = ArenaBuilder::<Hast>::new("x".repeat(200));
+        b.open_node(HastNodeType::Root as u8);
+        add_raw_node(&mut b, "<table>");
+        add_fence(&mut b, "first");
+        add_raw_node(&mut b, "<tr><td>");
+        add_fence(&mut b, "second");
+        add_raw_node(
+            &mut b,
+            "</td></tr></table><pre><code class=language-js>x\n</code></pre>",
+        );
+        add_fence(&mut b, "third");
+        b.close_node();
+        let mut source = b.finish();
+        let source_codes: Vec<u32> = (0..source.len() as u32)
+            .filter(|&id| source.get_node_data(id).is_some())
+            .collect();
+        for (index, &id) in source_codes.iter().enumerate() {
+            source.set_position(
+                id,
+                NodePosition {
+                    start_offset: index as u32 * 10,
+                    end_offset: index as u32 * 10 + 5,
+                    start_line: 1,
+                    start_column: index as u32 * 10 + 1,
+                    end_line: 1,
+                    end_column: index as u32 * 10 + 6,
+                },
+            );
+        }
+        let reparsed = raw_to_hast_arena(&source);
+        assert_eq!(reparsed.source(), source.source());
+        let reparsed_codes: Vec<u32> = (0..reparsed.len() as u32)
+            .filter(|&id| reparsed.get_node_data(id).is_some())
+            .collect();
+        assert_ne!(
+            source_codes[0], reparsed_codes[0],
+            "reparsing rebuilds arena ids"
+        );
+        for (&original, &parsed) in source_codes.iter().zip(&reparsed_codes) {
+            assert_eq!(
+                NodePosition::from_node(source.get_node(original)),
+                NodePosition::from_node(reparsed.get_node(parsed))
+            );
+        }
+        assert_eq!(
+            code_metadata(&reparsed),
+            [
+                fence_data("first"),
+                fence_data("second"),
+                None,
+                fence_data("third")
+            ]
+        );
+        assert!(
+            hast_arena_to_html(&reparsed)
+                .starts_with("<pre><code class=\"language-js\">x\n</code></pre><table>")
+        );
+        assert_eq!(
+            code_metadata(&source),
+            [
+                fence_data("first"),
+                fence_data("second"),
+                fence_data("third")
+            ]
+        );
+    }
+
+    #[test]
+    fn raw_reparse_declines_positions_for_ambiguous_raw_children() {
+        for raw in ["</span>", "<!--", "<script>", "<em>x</em>"] {
+            let mut b = ArenaBuilder::<Hast>::new("source".to_string());
+            b.open_node(HastNodeType::Root as u8);
+            let span = open_element(&mut b, "span", &[]);
+            let position = NodePosition {
+                start_offset: 0,
+                end_offset: 6,
+                start_line: 1,
+                start_column: 1,
+                end_line: 1,
+                end_column: 7,
+            };
+            b.arena_mut().set_position(span, position);
+            add_raw_node(&mut b, raw);
+            b.close_node();
+            b.close_node();
+            let reparsed = raw_to_hast_arena(&b.finish());
+            let span = reparsed.get_children(0)[0];
+            assert_eq!(
+                NodePosition::from_node(reparsed.get_node(span)),
+                if raw == "<em>x</em>" {
+                    position
+                } else {
+                    NodePosition::default()
+                },
+                "{raw}"
+            );
+        }
+    }
+
+    #[test]
+    fn raw_reparse_declines_raw_text_positions_when_text_becomes_markup() {
+        for text in ["</script>", "a<b"] {
+            let mut b = ArenaBuilder::<Hast>::new(text.to_string());
+            b.open_node(HastNodeType::Root as u8);
+            let script = open_element(&mut b, "script", &[]);
+            let position = NodePosition {
+                start_offset: 0,
+                end_offset: text.len() as u32,
+                start_line: 1,
+                start_column: 1,
+                end_line: 1,
+                end_column: text.len() as u32 + 1,
+            };
+            b.arena_mut().set_position(script, position);
+            let value = b.alloc_string(text);
+            b.add_leaf_with_position(HastNodeType::Text as u8, position, &value.as_bytes());
+            b.close_node();
+            b.close_node();
+            let reparsed = raw_to_hast_arena(&b.finish());
+            let script = reparsed.get_children(0)[0];
+            assert_eq!(
+                NodePosition::from_node(reparsed.get_node(script)),
+                if text == "a<b" {
+                    position
+                } else {
+                    NodePosition::default()
+                },
+                "{text}"
+            );
+        }
+    }
+
+    #[test]
+    fn raw_reparse_does_not_overstate_raw_void_element_positions() {
+        for raw in ["<input checked>", "<input checked></div>"] {
+            let mut b = ArenaBuilder::<Hast>::new(raw.to_string());
+            b.open_node(HastNodeType::Root as u8);
+            let value = b.alloc_string(raw);
+            let position = NodePosition {
+                start_offset: 0,
+                end_offset: raw.len() as u32,
+                start_line: 1,
+                start_column: 1,
+                end_line: 1,
+                end_column: raw.len() as u32 + 1,
+            };
+            b.add_leaf_with_position(HastNodeType::Raw as u8, position, &value.as_bytes());
+            b.close_node();
+            let reparsed = raw_to_hast_arena(&b.finish());
+            let input = reparsed.get_children(0)[0];
+            assert_eq!(
+                NodePosition::from_node(reparsed.get_node(input)),
+                if raw == "<input checked>" {
+                    position
+                } else {
+                    NodePosition::default()
+                },
+                "{raw}"
+            );
+        }
+    }
+
+    #[test]
+    fn raw_reparse_does_not_give_coalesced_text_a_partial_position() {
+        let mut b = ArenaBuilder::<Hast>::new("before".to_string());
+        b.open_node(HastNodeType::Root as u8);
+        let value = b.alloc_string("before");
+        let text = b.add_leaf_with_position(
+            HastNodeType::Text as u8,
+            NodePosition {
+                start_offset: 0,
+                end_offset: 6,
+                start_line: 1,
+                start_column: 1,
+                end_line: 1,
+                end_column: 7,
+            },
+            &value.as_bytes(),
+        );
+        add_raw_node(&mut b, "after");
+        b.close_node();
+        let source = b.finish();
+        let reparsed = raw_to_hast_arena(&source);
+        let merged = reparsed.get_children(0)[0];
+        assert_eq!(crate::hast::text_content(&reparsed, merged), "beforeafter");
+        assert_eq!(
+            NodePosition::from_node(reparsed.get_node(merged)),
+            NodePosition::default()
+        );
+        assert_ne!(
+            NodePosition::from_node(source.get_node(text)),
+            NodePosition::default()
+        );
+    }
+
+    #[test]
+    fn raw_reparse_does_not_reassign_metadata_from_swallowed_fences() {
+        for (open, close) in [
+            ("<script>", "</script>"),
+            ("<!--", "-->"),
+            ("<textarea>", "</textarea>"),
+        ] {
+            let mut b = ArenaBuilder::<Hast>::new(String::new());
+            b.open_node(HastNodeType::Root as u8);
+            add_raw_node(&mut b, open);
+            add_fence(&mut b, "swallowed");
+            add_raw_node(&mut b, close);
+            add_raw_node(&mut b, "<pre><code class=language-js>x\n</code></pre>");
+            add_fence(&mut b, "survivor");
+            b.close_node();
+            let reparsed = raw_to_hast_arena(&b.finish());
+            assert_eq!(
+                code_metadata(&reparsed),
+                [None, fence_data("survivor")],
+                "{open}"
+            );
+        }
+    }
+
+    #[test]
+    fn raw_reparse_does_not_claim_tags_begun_in_raw_html() {
+        for prefix in [
+            "<code ",
+            "<code class=language-js ",
+            "<code title=\"",
+            "<code title=",
+            "<code /",
+            "<!--",
+            "<script>",
+        ] {
+            let mut b = ArenaBuilder::<Hast>::new(String::new());
+            b.open_node(HastNodeType::Root as u8);
+            add_raw_node(&mut b, prefix);
+            add_code_with_data(&mut b, "not-an-original-token");
+            b.close_node();
+            let reparsed = raw_to_hast_arena(&b.finish());
+            assert!(
+                code_metadata(&reparsed).iter().all(Option::is_none),
+                "{prefix}"
+            );
+        }
+    }
+
+    #[test]
+    fn raw_reparse_does_not_give_metadata_to_formatting_clones() {
+        let mut b = ArenaBuilder::<Hast>::new(String::new());
+        b.open_node(HastNodeType::Root as u8);
+        open_element(&mut b, "pre", &[]);
+        let code = open_element(&mut b, "code", &[]);
+        b.arena_mut()
+            .set_node_data(code, br#"{"lang":"js","meta":"original"}"#.to_vec());
+        b.arena_mut().set_position(
+            code,
+            NodePosition {
+                start_offset: 10,
+                end_offset: 20,
+                start_line: 1,
+                start_column: 11,
+                end_line: 1,
+                end_column: 21,
+            },
+        );
+        add_raw_node(&mut b, "a<p>b");
+        b.close_node();
+        b.close_node();
+        add_raw_node(&mut b, "</p><code><p>raw");
+        add_fence(&mut b, "next");
+        b.close_node();
+        let reparsed = raw_to_hast_arena(&b.finish());
+        let metadata = code_metadata(&reparsed);
+        assert!(metadata.len() > 3, "formatting reconstruction must occur");
+        assert_eq!(metadata[0], fence_data("original"));
+        assert_eq!(metadata.last(), Some(&fence_data("next")));
+        assert!(metadata[1..metadata.len() - 1].iter().all(Option::is_none));
+        for id in 0..reparsed.len() as u32 {
+            if reparsed.get_node(id).node_type == HastNodeType::Element as u8
+                && reparsed.get_str(decode_element_tag(reparsed.get_type_data(id))) == "code"
+            {
+                assert_eq!(
+                    NodePosition::from_node(reparsed.get_node(id)),
+                    NodePosition::default(),
+                    "split originals and parser clones have no reliable full-source span"
+                );
+            }
+        }
+    }
+
+    #[cfg(feature = "mdx")]
+    #[test]
+    fn raw_reparse_keeps_fence_data_inside_nested_mdx_elements() {
+        let mut b = ArenaBuilder::<Hast>::new(String::new());
+        b.open_node(HastNodeType::Root as u8);
+        open_mdx_element(&mut b, "Outer");
+        open_mdx_element(&mut b, "Inner");
+        add_fence(&mut b, "nested");
+        b.close_node();
+        b.close_node();
+        b.close_node();
+        let reparsed = raw_to_hast_arena(&b.finish());
+        assert_eq!(code_metadata(&reparsed), [fence_data("nested")]);
     }
 
     #[cfg(feature = "mdx")]
diff --git a/crates/satteri-ast/src/hast/render.rs b/crates/satteri-ast/src/hast/render.rs
index 91b45ae6..96a1e681 100644
--- a/crates/satteri-ast/src/hast/render.rs
+++ b/crates/satteri-ast/src/hast/render.rs
@@ -1,6 +1,7 @@
 //! Render a HAST arena to an HTML string.
 
 use std::borrow::Cow;
+use std::ops::Range;
 
 use satteri_arena::{Document, Hast};
 use satteri_property_info::{PropKind, find_property};
@@ -85,12 +86,15 @@ pub fn render_node_with_options(
     out: &mut String,
     options: RenderOptions,
 ) {
-    render_node_inner(node_id, view, out, options, None, 0);
+    render_node_inner(node_id, view, out, options, None, None, 0);
 }
 
 /// Raw-HTML reparse hook: receives the output buffer and the MDX node's id.
 pub(crate) type OnMdx<'a> = dyn FnMut(&mut String, u32) + 'a;
 
+/// Records each serialized node's opening token and whole byte ranges without changing HTML.
+pub(crate) type OnNode<'a> = dyn FnMut(u32, Range<usize>, Range<usize>) + 'a;
+
 /// MDX nodes have no HTML representation: `on_mdx` decides what to emit for
 /// them; `None` skips them.
 pub(crate) fn render_node_inner<'cb>(
@@ -99,10 +103,11 @@ pub(crate) fn render_node_inner<'cb>(
     out: &mut String,
     context: RenderOptions,
     on_mdx: Option<&mut OnMdx<'cb>>,
+    on_node: Option<&mut OnNode<'cb>>,
     depth: u32,
 ) {
     with_headroom(depth, || {
-        render_node_at(node_id, view, out, context, on_mdx, depth);
+        render_node_at(node_id, view, out, context, on_mdx, on_node, depth);
     });
 }
 
@@ -112,6 +117,7 @@ fn render_node_at<'cb>(
     out: &mut String,
     context: RenderOptions,
     mut on_mdx: Option<&mut OnMdx<'cb>>,
+    mut on_node: Option<&mut OnNode<'cb>>,
     depth: u32,
 ) {
     let node = view.get_node(node_id);
@@ -124,12 +130,14 @@ fn render_node_at<'cb>(
                 out,
                 context,
                 on_mdx.as_deref_mut(),
+                on_node.as_deref_mut(),
                 depth + 1,
             );
         }
         return;
     };
 
+    let start = out.len();
     match node_type {
         HastNodeType::Root => {
             for &child_id in view.get_children(node_id) {
@@ -139,6 +147,7 @@ fn render_node_at<'cb>(
                     out,
                     context,
                     on_mdx.as_deref_mut(),
+                    on_node.as_deref_mut(),
                     depth + 1,
                 );
             }
@@ -157,6 +166,7 @@ fn render_node_at<'cb>(
             let svg_schema = context.svg_schema || tag == "svg";
             let element_in_svg = context.svg_content || tag == "svg";
 
+            let start = out.len();
             out.push('<');
             out.push_str(tag);
 
@@ -183,10 +193,9 @@ fn render_node_at<'cb>(
                 }
             }
 
-            if !element_in_svg && is_void_element(tag) {
-                out.push('>');
-            } else {
-                out.push('>');
+            out.push('>');
+            let opening_end = out.len();
+            if element_in_svg || !is_void_element(tag) {
                 let child_context = context.for_children(tag);
                 for &child_id in view.get_children(node_id) {
                     render_node_inner(
@@ -195,6 +204,7 @@ fn render_node_at<'cb>(
                         out,
                         child_context,
                         on_mdx.as_deref_mut(),
+                        on_node.as_deref_mut(),
                         depth + 1,
                     );
                 }
@@ -202,6 +212,9 @@ fn render_node_at<'cb>(
                 out.push_str(tag);
                 out.push('>');
             }
+            if let Some(cb) = on_node.as_mut() {
+                cb(node_id, start..opening_end, start..out.len());
+            }
         }
 
         HastNodeType::Text => {
@@ -251,6 +264,13 @@ fn render_node_at<'cb>(
             }
         }
     }
+    if matches!(
+        node_type,
+        HastNodeType::Text | HastNodeType::Comment | HastNodeType::Doctype | HastNodeType::Raw
+    ) && let Some(cb) = on_node.as_mut()
+    {
+        cb(node_id, start..out.len(), start..out.len());
+    }
 }
 
 fn render_attribute(out: &mut String, name: &str, value: &str) {
diff --git a/packages/satteri/src/compile-types.ts b/packages/satteri/src/compile-types.ts
index 2b5ca745..d6f359d5 100644
--- a/packages/satteri/src/compile-types.ts
+++ b/packages/satteri/src/compile-types.ts
@@ -138,7 +138,11 @@ export interface Features {
    * (re-emitted verbatim on stringify). With `rawHtml: true`, the tree is
    * reparsed so raw HTML becomes structured `element`/`text`/`comment` nodes
    * with normalized properties, including tags that open in one raw block
-   * and close in another. Positions are not preserved through the reparse.
+   * and close in another. Markdown-derived positions are retained when the
+   * source association is unambiguous, as are spans of self-contained raw
+   * blocks containing exactly one element. Nodes parsed within a raw block
+   * have no positions. Original code-fence elements
+   * retain their `data.lang` and `data.meta`.
    */
   rawHtml?: boolean;
 }
diff --git a/packages/satteri/test/raw-html-code-data.test.ts b/packages/satteri/test/raw-html-code-data.test.ts
new file mode 100644
index 00000000..25e8bd03
--- /dev/null
+++ b/packages/satteri/test/raw-html-code-data.test.ts
@@ -0,0 +1,192 @@
+import { expect, test } from "vitest";
+import type { Element, Nodes } from "hast";
+import {
+  defineHastPlugin,
+  defineMdastPlugin,
+  markdownToHast,
+  markdownToHtml,
+  markdownToJs,
+  mdxToJs,
+  type CompileOptions,
+} from "../src/index.js";
+
+const source = '```js title="a.js"\nx\n```\n';
+const fenceData = { lang: "js", meta: 'title="a.js"' };
+
+test.each([false, true])("markdownToHast keeps fence data with rawHtml=%s", async (rawHtml) => {
+  const tree = await markdownToHast(source, { features: { rawHtml } });
+  if (tree.type !== "root") throw new Error("expected root");
+  const pre = tree.children[0];
+  expect(pre?.type).toBe("element");
+  if (pre?.type !== "element") throw new Error("expected pre");
+  const code = pre.children[0];
+  if (!code) throw new Error("expected code");
+  expect(code.data).toEqual(fenceData);
+  expect(code.position).toEqual(pre.position);
+  expect(code.position).toBeDefined();
+});
+
+test.each([false, true])("mdxToJs HAST plugins observe fence data with rawHtml=%s", (rawHtml) => {
+  const seen: unknown[] = [];
+  const observer = defineHastPlugin({
+    name: "observe-fences",
+    element: {
+      filter: ["code"],
+      visit(node) {
+        seen.push(node.data);
+      },
+    },
+  });
+  const { code } = mdxToJs(source, { features: { rawHtml }, hastPlugins: [observer] });
+  expect(code).toContain("language-js");
+  expect(seen).toEqual([fenceData]);
+});
+
+function codeElements(node: Nodes): Element[] {
+  return [
+    ...(node.type === "element" && node.tagName === "code" ? [node] : []),
+    ...("children" in node ? node.children.flatMap(codeElements) : []),
+  ];
+}
+
+const noopMdast = defineMdastPlugin({ name: "noop-mdast", code() {} });
+
+test.each([false, true])(
+  "raw HTML lookalikes never acquire fence data (mdast plugin=%s)",
+  async (withMdast) => {
+    const raw = '<pre><code class="language-js" data-lang="fake">x\n</code></pre>\n\n';
+    const repeated =
+      "# 👋 café\n\n" + raw + source + "\n" + raw + source.replace("a.js", "b.js") + "\n" + raw;
+    const seen: unknown[] = [];
+    const observer = defineHastPlugin({
+      name: "observe-originals",
+      element: {
+        filter: ["code"],
+        visit(node) {
+          seen.push(node.data);
+        },
+      },
+    });
+    const tree = await markdownToHast(repeated, {
+      features: { rawHtml: true },
+      mdastPlugins: withMdast ? [noopMdast] : [],
+      hastPlugins: [observer],
+    });
+    const expected = [
+      undefined,
+      fenceData,
+      undefined,
+      { lang: "js", meta: 'title="b.js"' },
+      undefined,
+    ];
+    const codes = codeElements(tree);
+    expect(codes.map((node) => node.data)).toEqual(expected);
+    expect(codes.filter((node) => node.data).map((node) => node.position)).toEqual(
+      codeElements(await markdownToHast(repeated)).map((node) => node.position),
+    );
+    expect(codes.filter((node) => !node.data).every((node) => node.position === undefined)).toBe(
+      true,
+    );
+    expect(seen).toEqual(expected);
+  },
+);
+
+test("foster parenting relocates fences without swapping identical code blocks' data", async () => {
+  const input =
+    "<table>\n\n" +
+    source +
+    "\n<tr><td>\n\n" +
+    source.replace("a.js", "b.js") +
+    "\n</td></tr></table>\n";
+  const tree = await markdownToHast(input, { features: { rawHtml: true } });
+  if (tree.type !== "root") throw new Error("expected root");
+  expect(tree.children[0]).toMatchObject({ type: "element", tagName: "pre" });
+  const codes = codeElements(tree);
+  expect(codes.map((node) => node.data)).toEqual([fenceData, { lang: "js", meta: 'title="b.js"' }]);
+  expect(codes.map((node) => node.position)).toEqual(
+    codeElements(await markdownToHast(input)).map((node) => node.position),
+  );
+  const table = tree.children.find((node) => node.type === "element" && node.tagName === "table");
+  expect(table && codeElements(table).map((node) => node.data)).toEqual([
+    { lang: "js", meta: 'title="b.js"' },
+  ]);
+});
+
+test.each([
+  "```\nx\n```\n",
+  "    x\n",
+  '```café title="été & <x>"\n<a>&b\n```\n',
+  '```js title="a.js"\r\nx\r\n```\r\n',
+])("rawHtml preserves code data and content for %j", async (input) => {
+  const before = codeElements(await markdownToHast(input));
+  const after = codeElements(await markdownToHast(input, { features: { rawHtml: true } }));
+  expect(after.map(({ data, properties, children }) => ({ data, properties, children }))).toEqual(
+    before.map(({ data, properties, children }) => ({ data, properties, children })),
+  );
+});
+
+test.each([
+  { name: "markdownToHtml", compile: (options: CompileOptions) => markdownToHtml(source, options) },
+  { name: "markdownToJs", compile: (options: CompileOptions) => markdownToJs(source, options) },
+  { name: "mdxToJs", compile: (options: CompileOptions) => mdxToJs(source, options) },
+])("HAST plugins can render fence metadata through $name", async ({ compile }) => {
+  const renderer = defineHastPlugin({
+    name: "render-fence-meta",
+    element: {
+      filter: ["code"],
+      visit(node) {
+        const meta = node.data?.meta;
+        if (typeof meta !== "string") return;
+        return { ...node, properties: { ...node.properties, title: meta } };
+      },
+    },
+  });
+  for (const withMdast of [false, true]) {
+    const result = await compile({
+      features: { rawHtml: true },
+      mdastPlugins: withMdast ? [noopMdast] : [],
+      hastPlugins: [renderer],
+    });
+    const output = "html" in result ? result.html : result.code;
+    expect(output).toContain("a.js");
+    expect(output).toContain("title");
+  }
+});
+
+test("MDX compilation preserves metadata and positions in nested JSX children", () => {
+  const input = "<Outer>\n\n<Inner>\n\n" + source + "\n</Inner>\n\n</Outer>\n";
+  const seen: unknown[] = [];
+  const positions: unknown[] = [];
+  const observer = defineHastPlugin({
+    name: "observe-nested-fences",
+    element: {
+      filter: ["code"],
+      visit(node) {
+        seen.push(node.data);
+        positions.push(node.position);
+      },
+    },
+  });
+  const baselinePositions: unknown[] = [];
+  const baselineObserver = defineHastPlugin({
+    name: "observe-baseline-positions",
+    element: {
+      filter: ["code"],
+      visit(node) {
+        baselinePositions.push(node.position);
+      },
+    },
+  });
+  mdxToJs(input, { hastPlugins: [baselineObserver] });
+  const { code } = mdxToJs(input, {
+    features: { rawHtml: true },
+    hastPlugins: [observer],
+  });
+  expect(seen).toEqual([fenceData]);
+  expect(positions).toEqual(baselinePositions);
+  // MDX currently omits these nested fence positions even without reparsing;
+  // preserving provenance must not invent a span that the source arena lacks.
+  expect(code).toContain("Outer");
+  expect(code).toContain("Inner");
+  expect(code).toContain("language-js");
+});
diff --git a/packages/satteri/test/raw-html-conformance.test.ts b/packages/satteri/test/raw-html-conformance.test.ts
index 2be8c80e..3b528723 100644
--- a/packages/satteri/test/raw-html-conformance.test.ts
+++ b/packages/satteri/test/raw-html-conformance.test.ts
@@ -7,14 +7,14 @@ import rehypeStringify from "rehype-stringify";
 import { markdownToHast } from "../src/index.js";
 import type { HastNode } from "../src/hast/hast-materializer.js";
 
-const reference = unified()
+const referenceProcessor = unified()
   .use(remarkParse)
   .use(remarkRehype, { allowDangerousHtml: true })
   .use(rehypeRaw)
   .use(rehypeStringify);
 
 const referenceTree = (md: string): HastNode =>
-  reference.runSync(reference.parse(md)) as unknown as HastNode;
+  referenceProcessor.runSync(referenceProcessor.parse(md)) as unknown as HastNode;
 
 const stringify = (tree: HastNode): string =>
   unified()
@@ -123,6 +123,18 @@ const cases: Array<{ name: string; md: string }> = [
   { name: "nested forms", md: `<form><form><input></form></form>` },
   { name: "inline svg in paragraph", md: `<p><svg><circle r="1"/></svg>after</p>` },
   { name: "mathml", md: `<math><mi>x</mi></math>` },
+  { name: "raw block interrupts paragraph", md: `before <div>inside</div> after` },
+  { name: "formatting crosses paragraphs", md: `before <b>bold\n\nnext</b>` },
+  { name: "coalesced raw and Markdown text", md: `before <span>raw &amp; text</span> after` },
+  { name: "Unicode surrounding raw HTML", md: `# 👋 héllo\n\n<div>raw</div>\n\nA [café](x) here.` },
+  { name: "escaped Markdown text", md: `# a & b < c\n\n<div>raw</div>\n\nx & y` },
+  { name: "multiple raw elements", md: `<div>a</div><div>b</div>` },
+  { name: "ignored suffix after void raw element", md: `<input checked></div>` },
+  { name: "ignored raw wrapper", md: `<body><div>a</div></body>` },
+  {
+    name: "raw element swallowing Markdown",
+    md: `<script>\n\n# swallowed\n\n</script>\n\n# survivor`,
+  },
 ];
 
 describe("rawHtml conformance vs rehype-raw", () => {
@@ -138,3 +150,54 @@ describe("rawHtml conformance vs rehype-raw", () => {
     });
   }
 });
+
+/** Flatten to `path → span`, so two trees compare node position by node position. */
+function spans(node: HastNode, path = "", out: Array<[string, string | null]> = []) {
+  const p = node.position;
+  out.push([path, p ? `${p.start.offset}..${p.end ? p.end.offset : "?"}` : null]);
+  if ("children" in node && node.children) {
+    (node.children as HastNode[]).forEach((child, i) => spans(child, `${path}/${i}`, out));
+  }
+  return out;
+}
+
+// The root is excluded: rehype-raw collapses it to a zero-width span at 1:1.
+describe("rawHtml position conformance vs rehype-raw", () => {
+  for (const { name, md } of cases) {
+    test(`every position kept matches the reference: ${name}`, () => {
+      const reference = new Map(spans(referenceTree(md)));
+      for (const [path, span] of spans(markdownToHast(md, { features: { rawHtml: true } }))) {
+        if (path === "" || span === null) continue;
+        expect([path, span]).toEqual([path, reference.get(path)]);
+      }
+    });
+  }
+
+  test("nodes that came from Markdown keep their positions", () => {
+    const md = "# Hi\n\n<div>raw</div>\n\nA [link](x) here.\n";
+    const reference = new Map(spans(referenceTree(md)));
+    const kept = spans(markdownToHast(md, { features: { rawHtml: true } })).filter(
+      ([path, span]) => path !== "" && span !== null,
+    );
+    expect(kept.length).toBeGreaterThan(4);
+    for (const [path, span] of kept) expect([path, span]).toEqual([path, reference.get(path)]);
+  });
+
+  test("a raw block that is one element gets that element's span", () => {
+    const md = "text\n\n<div><em>x</em></div>\n";
+    const reference = new Map(spans(referenceTree(md)));
+    const ours = new Map(spans(markdownToHast(md, { features: { rawHtml: true } })));
+    expect(ours.get("/2")).toBe(reference.get("/2"));
+    expect(ours.get("/2")).toBe("6..27");
+  });
+
+  // Spans within a raw block need per-token offsets, which html5ever does not expose.
+  test("nodes nested inside raw HTML carry no position", () => {
+    const tree = markdownToHast("text\n\n<div><em>x</em></div>\n", {
+      features: { rawHtml: true },
+    });
+    const inner = spans(tree).filter(([path]) => path.startsWith("/2/"));
+    expect(inner.length).toBeGreaterThan(0);
+    for (const [, span] of inner) expect(span).toBeNull();
+  });
+});
diff --git a/packages/satteri/test/raw-html-pipelines.test.ts b/packages/satteri/test/raw-html-pipelines.test.ts
index 15d95c75..4ef44d13 100644
--- a/packages/satteri/test/raw-html-pipelines.test.ts
+++ b/packages/satteri/test/raw-html-pipelines.test.ts
@@ -1,5 +1,12 @@
 import { test, expect } from "vitest";
-import { markdownToHtml, markdownToJs, defineMdastPlugin, defineHastPlugin } from "../src/index.js";
+import {
+  markdownToHtml,
+  markdownToHast,
+  markdownToJs,
+  mdxToJs,
+  defineMdastPlugin,
+  defineHastPlugin,
+} from "../src/index.js";
 
 // Class whitespace and implied tbody distinguish reparsed HTML from verbatim output.
 const src = '<div class="a  b">\n\n**hi**\n\n</div>\n\n<table><tr><td>x</td></tr></table>\n';
@@ -123,6 +130,27 @@ test("plugin-spliced raw HTML is reparsed too", () => {
   expect(html).toContain('<aside class="n m">hi</aside>');
 });
 
+test("rawHtml keeps the document span on the root", () => {
+  const md = "# Hi\n\n<div>hello</div>\n\nBye\n";
+  expect(markdownToHast(md, { features: { rawHtml: true } }).position).toEqual(
+    markdownToHast(md).position,
+  );
+});
+
+// Offsets are UTF-16 code units, so only a multibyte document exposes a lost source.
+test("rawHtml root offsets stay in UTF-16 code units", () => {
+  const md = "# 👋 héllo\n\n<div>x</div>\n\nBye\n";
+  expect(markdownToHast(md, { features: { rawHtml: true } }).position?.end.offset).toBe(md.length);
+});
+
+test("rawHtml keeps component overrides visible to optimizeStatic", () => {
+  const mdx = 'export const components = { h1: "h2" };\n\n# Hello\n\nSome text.\n';
+  const optimizeStatic = { component: "Fragment", prop: "set:html" };
+  expect(mdxToJs(mdx, { optimizeStatic, features: { rawHtml: true } }).code).toBe(
+    mdxToJs(mdx, { optimizeStatic }).code,
+  );
+});
+
 test("rawHtml keeps namespaced SVG attributes through the round trip", () => {
   const sprite =
     '<svg xmlns:xlink="http://www.w3.org/1999/xlink"><use xlink:href="#icon"/></svg>\n';
diff --git a/website/content/docs/entry-points.md b/website/content/docs/entry-points.md
index 977164c6..a239f243 100644
--- a/website/content/docs/entry-points.md
+++ b/website/content/docs/entry-points.md
@@ -163,4 +163,4 @@ const tree = markdownToHast(`<div class="note">\n\n**hi**\n\n</div>`, {
 // <div> is now a real element wrapping the parsed <p><strong>hi</strong></p>
 ```
 
-The whole tree is reparsed through the HTML parser, so a tag opened in one raw block and closed in another is resolved against the surrounding Markdown. Positions are not preserved through the reparse.
+The whole tree is reparsed through the HTML parser, so a tag opened in one raw block and closed in another is resolved against the surrounding Markdown. Markdown-derived positions are retained when the source association is unambiguous, as are spans of self-contained raw blocks containing exactly one element. Split or coalesced nodes, parser-created clones, and nodes parsed within a raw block have no positions. Original code-fence elements retain their `data.lang` and `data.meta`.
diff --git a/website/content/docs/features.md b/website/content/docs/features.md
index e9a738be..b0490f7c 100644
--- a/website/content/docs/features.md
+++ b/website/content/docs/features.md
@@ -200,7 +200,7 @@ MDX treats `{...}` as a JavaScript expression, which normally collides with the
 # Welcome {name}
 ```
 
-A `{...}` that *is* valid JavaScript stays an expression even when it looks like attributes: `{hidden}`, `{level=2}` and `{title="Home"}` evaluate rather than apply — silently, and unlike in plain Markdown. Add a `#`/`.` shorthand to force attributes; `{#id hidden}` applies both.
+A `{...}` that _is_ valid JavaScript stays an expression even when it looks like attributes: `{hidden}`, `{level=2}` and `{title="Home"}` evaluate rather than apply — silently, and unlike in plain Markdown. Add a `#`/`.` shorthand to force attributes; `{#id hidden}` applies both.
 
 ## Directives
 
@@ -286,7 +286,7 @@ rawHtml?: boolean
 
 By default, raw HTML embedded in Markdown is kept as opaque `raw` nodes and re-emitted verbatim. `rawHtml: true` reparses it into real HAST element, text, and comment nodes. The reparse runs during the mdast→hast conversion, so `markdownToHast`, `markdownToHtml`, and the plugin pipelines all reparse identically, and HAST plugins always see the reparsed elements.
 
-The whole tree goes through the HTML parser, so a tag opened in one raw block and closed in another is resolved against the surrounding Markdown. Attributes are normalised into typed hast properties (`class` → `className: ["…"]`, `disabled` → `true`, `tabindex` → a number, `data-foo-bar` → `dataFooBar`). In MDX, JSX elements and expressions are preserved in place while the raw HTML around them is still resolved. Positions are not preserved through the reparse.
+The whole tree goes through the HTML parser, so a tag opened in one raw block and closed in another is resolved against the surrounding Markdown. Attributes are normalised into typed hast properties (`class` → `className: ["…"]`, `disabled` → `true`, `tabindex` → a number, `data-foo-bar` → `dataFooBar`). In MDX, JSX elements and expressions are preserved in place while the raw HTML around them is still resolved. Markdown-derived positions are retained when the source association is unambiguous, as are spans of self-contained raw blocks containing exactly one element. Split or coalesced nodes, parser-created clones, and nodes parsed within a raw block have no positions. Original code-fence elements retain their `data.lang` and `data.meta`; user-supplied raw HTML and parser-created clones do not acquire fence metadata.
 
 ```js
 import { markdownToHast } from "satteri";